java实现dh算法代码 des算法java代码

简述DH算法

DH组的本质是使用非对称密钥来加密对称密钥。 DH算法过程： 1、相互产生密钥对 2、交换公钥 3、用对方的公钥和自己的私钥运行DH算法——得到另外一个密钥X

10余年的夏津网站建设经验，针对设计、前端、开发、售后、文案、推广等六对一服务，响应快，48小时及时工作处理。成都营销网站建设的优势是能够根据用户设备显示端的尺寸不同，自动调整夏津建站的显示方式，使网站能够适用不同显示终端，在浏览器中调整网站的宽度，无论在任何一种浏览器上浏览网站，都能展现优雅布局与设计，从而大程度地提升浏览体验。创新互联从事“夏津网站设计”,“夏津网站推广”以来，每个客户项目都认真落实执行。

验证DH密钥交换算法

我自己写了个DH秘钥的demo代码，以前加密用过AES的加密，全套代码写下来太费时间又没技术含量。

如果你需要AES的加密代码可以留个邮箱给我。

public class Test1 {

public static final int P=30;//公开的大家都知道的

public static final int G=9;//公开的大家都知道的

public static void main(String[] args) {

A x = new A();

int one = x.getV();

//分割 A 代表A这边的系统加密 one 代表是给别人的值

B y = new B();

int two = y.getV();

//B 代表另外一边加密 two 代表是给别人的值

System.out.println(x.getKey(two));

System.out.println(y.getKey(one));

}

class A{

private int a;//自己的私有密值,不会告诉任何人

public A() {

Random r = new Random(200);

a=r.nextInt();

}

public int getV(){

return (Test1.G^a)%Test1.P;

}

public int getKey(int v){

return (v^a)%Test1.P;

}

class B{

private int b;//自己的私有密值，不会告诉任何人

public B() {

Random r = new Random(200);

b=r.nextInt();

}

public int getV(){

return (Test1.G^b)%Test1.P;

}

public int getKey(int v){

return (v^b)%Test1.P;

}

简要介绍DH密钥交换算法

姓名：朱睿琦

学号：15180288015

参考：

【嵌牛导读】：随着互联网络的高速发展，计算机运算能力的提升，对信息的保密也有了更近一步的要求——不仅信息要保密，密钥也要保密。DH(Diffie-Hellman)算法就提供了使密钥安全通过不安全网络的方法。

【嵌牛鼻子】：DH算法，密钥，网络信息安全

【嵌牛提问】：DH算法是用来保护什么在网络中的通信安全？DH密钥交换的基本原理是什么？

【嵌牛正文】：(1)、算法描述

离散对数的概念：

原根：如果 a 是素数 p 的一个原根，那么数值：

a mod p ， a^ 2 mod p ，…， a^( p-1) mod p

是各不相同的整数，且以某种排列方式组成了从 1 到 p-1 的所有整数。

离散对数：如果对于一个整数 b 和素数 p 的一个原根 a ，可以找到一个唯一的指数 i ，使得：

b =（ a的i次方） mod p 其中 0 ≦ i ≦ p-1

那么指数 i 称为 b 的以 a 为基数的模p的离散对数。

Diffie-Hellman算法的有效性依赖于计算离散对数的难度，其含义是：当已知大素数 p 和它的一个原根 a 后，对给定的 b ，要计算 i ，被认为是很困难的，而给定 i 计算 b 却相对容易。

Diffie-Hellman算法：

假如用户A和用户B希望交换一个密钥。

取素数 p 和整数 a ， a 是 p 的一个原根，公开 a 和p。

A选择随机数XA p ，并计算YA= a^ XA mod p。

B选择随机数XB p ，并计算YB= a^ XB mod p。

每一方都将X保密而将Y公开让另一方得到。

A计算密钥的方式是：K=(YB) ^XA mod p

B计算密钥的方式是：K=(YA) ^XB mod p

证明：

(YB)^ XA mod p = ( a^ XB mod p )^ XA mod p

= ( a^ XB)^ XA mod p = ( a^ XA) ^XB mod p (-- 密钥即为 a^(XA*XB) mod p )

=( a^ XA mod p )^ XB mod p = (YA) ^XB mod p

由于XA和XB是保密的，而第三方只有 p 、 a 、YB、YA可以利用，只有通过取离散对数来确定密钥，但对于大的素数 p ，计算离散对数是十分困难的。

例子：

假如用户Alice和用户Bob希望交换一个密钥。

取一个素数 p =97和97的一个原根 a =5。

Alice和Bob分别选择秘密密钥XA=36和XB=58，并计算各自的公开密钥：

YA= a^ XA mod p =5^36 mod 97=50

YB= a^ XB mod p =5^58 mod 97=44

Alice和Bob交换了公开密钥之后，计算共享密钥如下：

Alice：K=(YB) ^XA mod p =44^36 mod 97=75

Bob：K=(YA) ^XB mod p =50^58 mod 97=75

(2)、安全性

当然，为了使这个例子变得安全，必须使用非常大的XA, XB 以及 p ，否则可以实验所有的可能取值。(总共有最多97个这样的值, 就算XA和XB很大也无济于事)。

如果 p 是一个至少 300 位的质数，并且XA和XB至少有100位长，那么即使使用全人类所有的计算资源和当今最好的算法也不可能从a, p 和a^(XA*XB) mod p 中计算出 XA*XB。

这个问题就是著名的离散对数问题。注意g则不需要很大, 并且在一般的实践中通常是2或者5。

在最初的描述中，迪菲－赫尔曼密钥交换本身并没有提供通讯双方的身份验证服务，因此它很容易受到中间人攻击。

一个中间人在信道的中央进行两次迪菲－赫尔曼密钥交换，一次和Alice另一次和Bob，就能够成功的向Alice假装自己是Bob，反之亦然。

而攻击者可以解密（读取和存储）任何一个人的信息并重新加密信息，然后传递给另一个人。因此通常都需要一个能够验证通讯双方身份的机制来防止这类攻击。

有很多种安全身份验证解决方案使用到了迪菲－赫尔曼密钥交换。例如当Alice和Bob共有一个公钥基础设施时，他们可以将他们的返回密钥进行签名。

java问题

-------------参考下------------------

JAVA加密算法的实现用例

对象

参数 algorithm 如:"DSA"

public final void initSign(PrivateKey privateKey)

throws InvalidKeyException

用指定的私钥初始化

参数:privateKey 所进行签名时用的私钥

public final void update(byte data)

throws SignatureException

public final void update(byte[] data)

throws SignatureException

public final void update(byte[] data, int off, int len)

throws SignatureException

添加要签名的信息

public final byte[] sign()

throws SignatureException

返回签名的数组,前提是initSign和update

public final void initVerify(PublicKey publicKey)

throws InvalidKeyException

用指定的公钥初始化

参数:publicKey 验证时用的公钥

public final boolean verify(byte[] signature)

throws SignatureException

验证签名是否有效,前提是已经initVerify初始化

参数: signature 签名数组

import java.security.*;

import java.security.spec.*;

public class testdsa {

public static void main(String[] args) throws java.security.NoSuchAlgorithmException,java.lang.Exception {

testdsa my=new testdsa();

my.run();

}

public void run()

{

//数字签名生成密钥

//第一步生成密钥对,如果已经生成过,本过程就可以跳过,对用户来讲myprikey.dat要保存在本地

//而mypubkey.dat给发布给其它用户

if ((new java.io.File("myprikey.dat")).exists()==false) {

if (generatekey()==false) {

System.out.println("生成密钥对败");

return;

};

}

//第二步,此用户

//从文件中读入私钥,对一个字符串进行签名后保存在一个文件(myinfo.dat)中

//并且再把myinfo.dat发送出去

//为了方便数字签名也放进了myifno.dat文件中,当然也可分别发送

try {

java.io.ObjectInputStream in=new java.io.ObjectInputStream(new java.io.FileInputStream("myprikey.dat"));

PrivateKey myprikey=(PrivateKey)in.readObject();

in.close();

// java.security.spec.X509EncodedKeySpec pubX509=new java.security.spec.X509EncodedKeySpec(bX509);

//java.security.spec.X509EncodedKeySpec pubkeyEncode=java.security.spec.X509EncodedKeySpec

String myinfo="这是我的信息"; //要签名的信息

//用私钥对信息生成数字签名

java.security.Signature signet=java.security.Signature.getInstance("DSA");

signet.initSign(myprikey);

signet.update(myinfo.getBytes());

byte[] signed=signet.sign(); //对信息的数字签名

System.out.println ("signed(签名内容)="+byte2hex(signed));

//把信息和数字签名保存在一个文件中

java.io.ObjectOutputStream out=new java.io.ObjectOutputStream(new java.io.FileOutputStream("myinfo.dat"));

out.writeObject(myinfo);

out.writeObject(signed);

out.close();

System.out.println("签名并生成文件成功");

}

catch (java.lang.Exception e) {

e.printStackTrace();

System.out.println("签名并生成文件失败");

};

//第三步

//其他人通过公共方式得到此户的公钥和文件

//其他人用此户的公钥,对文件进行检查,如果成功说明是此用户发布的信息.

try {

java.io.ObjectInputStream in=new java.io.ObjectInputStream(new java.io.FileInputStream("mypubkey.dat"));

PublicKey pubkey=(PublicKey)in.readObject();

in.close();

System.out.println(pubkey.getFormat());

in=new java.io.ObjectInputStream(new java.io.FileInputStream("myinfo.dat"));

String info=(String)in.readObject();

byte[] signed=(byte[])in.readObject();

in.close();

java.security.Signature signetcheck=java.security.Signature.getInstance("DSA");

signetcheck.initVerify(pubkey);

signetcheck.update (info.getBytes());

if (signetcheck.verify(signed)) {

System.out.println("info="+info);

System.out.println("签名正常");

}

else System.out.println("非签名正常");

}

catch ( java.lang.Exception e) {e.printStackTrace();};

}

//生成一对文件myprikey.dat和mypubkey.dat---私钥和公钥,

//公钥要用户发送(文件,网络等方法)给其它用户,私钥保存在本地

public boolean generatekey()

{

try {

java.security.KeyPairGenerator keygen=java.security.KeyPairGenerator.getInstance("DSA");

// SecureRandom secrand=new SecureRandom();

// secrand.setSeed("tttt".getBytes()); //初始化随机产生器

// keygen.initialize(576,secrand); //初始化密钥生成器

keygen.initialize(512);

KeyPair keys=keygen.genKeyPair();

// KeyPair keys=keygen.generateKeyPair(); //生成密钥组

PublicKey pubkey=keys.getPublic();

PrivateKey prikey=keys.getPrivate();

java.io.ObjectOutputStream out=new java.io.ObjectOutputStream(new java.io.FileOutputStream("myprikey.dat"));

out.writeObject(prikey);

out.close();

System.out.println("写入对象 prikeys ok");

out=new java.io.ObjectOutputStream (new java.io.FileOutputStream("mypubkey.dat"));

out.writeObject(pubkey);

out.close();

System.out.println("写入对象 pubkeys ok");

System.out.println("生成密钥对成功");

return true;

}

catch (java.lang.Exception e) {

e.printStackTrace();

System.out.println("生成密钥对失败");

return false;

};

}

public String byte2hex(byte[] b)

{

String hs="";

String stmp="";

for (int n=0;nb.length;n++)

{

stmp=(java.lang.Integer.toHexString(b[n] 0XFF));

if (stmp.length()==1) hs=hs+"0"+stmp;

else hs=hs+stmp;

if (nb.length-1) hs=hs+":";

}

return hs.toUpperCase();

}

2.4. DESede/DES对称算法

首先生成密钥,并保存(这里并没的保存的代码,可参考DSA中的方法)

KeyGenerator keygen = KeyGenerator.getInstance(Algorithm);

SecretKey deskey = keygen.generateKey();

用密钥加密明文(myinfo),生成密文(cipherByte)

Cipher c1 = Cipher.getInstance(Algorithm);

c1.init(Cipher.ENCRYPT_MODE,deskey);

byte[] cipherByte=c1.doFinal(myinfo.getBytes());

传送密文和密钥,本文没有相应代码可参考DSA

.............

用密钥解密密文

c1 = Cipher.getInstance(Algorithm);

c1.init(Cipher.DECRYPT_MODE,deskey);

byte[] clearByte= c1.doFinal(cipherByte);

相对来说对称密钥的使用是很简单的,对于JCE来讲支技DES,DESede,Blowfish三种加密术

对于密钥的保存各传送可使用对象流或者用二进制编码,相关参考代码如下

SecretKey deskey = keygen.generateKey();

byte[] desEncode=deskey.getEncoded();

javax.crypto.spec.SecretKeySpec destmp=new javax.crypto.spec.SecretKeySpec(desEncode,Algorithm);

SecretKey mydeskey=destmp;