JAVA上加密算法的实现用例：MD5/SHA1，DSA，DESede/DES，Diffie-Hellman的使用

wangxiaohua

2010-09-21

关注关注

通常,使用的加密算法比较简便高效,密钥简短，加解密速度快，破译极其困难。本文介绍了MD5/SHA1，DSA，DESede/DES，Diffie-Hellman的使用。

第1章基础知识

1.1.单钥密码体制

单钥密码体制是一种传统的加密算法，是指信息的发送方和接收方共同使用同一把密钥进行加解密。

通常,使用的加密算法比较简便高效,密钥简短，加解密速度快，破译极其困难。但是加密的安全性依靠密钥保管的安全性,在公开的计算机网络上安全地传送和保管密钥是一个严峻的问题，并且如果在多用户的情况下密钥的保管安全性也是一个问题。

单钥密码体制的代表是美国的DES

1.2.消息摘要

一个消息摘要就是一个数据块的数字指纹。即对一个任意长度的一个数据块进行计算，产生一个唯一指印（对于SHA1是产生一个20字节的二进制数组）。

消息摘要有两个基本属性：

两个不同的报文难以生成相同的摘要

难以对指定的摘要生成一个报文，而由该报文反推算出该指定的摘要

代表：美国国家标准技术研究所的SHA1和麻省理工学院RonaldRivest提出的MD5

1.3.Diffie-Hellman密钥一致协议

密钥一致协议是由公开密钥密码体制的奠基人Diffie和Hellman所提出的一种思想。

先决条件,允许两名用户在公开媒体上交换信息以生成"一致"的,可以共享的密钥

代表：指数密钥一致协议(ExponentialKeyAgreementProtocol)

1.4.非对称算法与公钥体系

1976年，Dittie和Hellman为解决密钥管理问题，在他们的奠基性的工作"密码学的新方向"一文中，提出一种密钥交换协议，允许在不安全的媒体上通过通讯双方交换信息，安全地传送秘密密钥。在此新思想的基础上，很快出现了非对称密钥密码体制，即公钥密码体制。在公钥体制中，加密密钥不同于解密密钥，加密密钥公之于众，谁都可以使用；解密密钥只有解密人自己知道。它们分别称为公开密钥（Publickey）和秘密密钥（Privatekey）。

迄今为止的所有公钥密码体系中，RSA系统是最著名、最多使用的一种。RSA公开密钥密码系统是由R.Rivest、A.Shamir和L.Adleman俊教授于1977年提出的。RSA的取名就是来自于这三位发明者的姓的第一个字母

1.5.数字签名

所谓数字签名就是信息发送者用其私钥对从所传报文中提取出的特征数据（或称数字指纹）进行RSA算法操作，以保证发信人无法抵赖曾发过该信息（即不可抵赖性），同时也确保信息报文在经签名后末被篡改（即完整性）。当信息接收者收到报文后，就可以用发送者的公钥对数字签名进行验证。　

在数字签名中有重要作用的数字指纹是通过一类特殊的散列函数（HASH函数）生成的，对这些HASH函数的特殊要求是：

接受的输入报文数据没有长度限制；

对任何输入报文数据生成固定长度的摘要（数字指纹）输出

从报文能方便地算出摘要；

难以对指定的摘要生成一个报文，而由该报文反推算出该指定的摘要；

两个不同的报文难以生成相同的摘要

代表：DSA

回页首

第2章在JAVA中的实现

2.1.相关

Diffie-Hellman密钥一致协议和DES程序需要JCE工具库的支持,可以到http://java.sun.com/security/index.html下载JCE,并进行安装。简易安装把jce1.2.1\lib下的所有内容复制到%java_home%\lib\ext下,如果没有ext目录自行建立,再把jce1_2_1.jar和sunjce_provider.jar添加到CLASSPATH内,更详细说明请看相应用户手册

2.2.消息摘要MD5和SHA的使用

使用方法:

首先用生成一个MessageDigest类,确定计算方法

java.security.MessageDigestalga=java.security.MessageDigest.getInstance("SHA-1");

添加要进行计算摘要的信息

alga.update(myinfo.getBytes());

计算出摘要

byte[]digesta=alga.digest();

发送给其他人你的信息和摘要

其他人用相同的方法初始化,添加信息,最后进行比较摘要是否相同

algb.isEqual(digesta,algb.digest())

相关API

KeyGenerator在DSA中已经说明,在添加JCE后在instance进可以如下参数

DES,DESede,Blowfish,HmacMD5,HmacSHA1

javax.crypto.Cipher加/解密器

publicstaticfinalCiphergetInstance(java.lang.Stringtransformation)

throwsjava.security.NoSuchAlgorithmException,

NoSuchPaddingException

返回一个指定方法的Cipher对象

参数:transformation方法名(可用DES,DESede,Blowfish)

publicfinalvoidinit(intopmode,java.security.Keykey)

throwsjava.security.InvalidKeyException

用指定的密钥和模式初始化Cipher对象

参数:opmode方式(ENCRYPT_MODE,DECRYPT_MODE,WRAP_MODE,UNWRAP_MODE)

key密钥

publicfinalbyte[]doFinal(byte[]input)

throwsjava.lang.IllegalStateException,

IllegalBlockSizeException,

BadPaddingException

对input内的串,进行编码处理,返回处理后二进制串,是返回解密文还是加解文由init时的opmode决定

注意:本方法的执行前如果有update,是对updat和本次input全部处理,否则是本inout的内容

安全程序DESede/DES测试

importjava.security.*;

importjavax.crypto.*;

publicclasstestdes{

publicstaticvoidmain(String[]args){

testdesmy=newtestdes();

my.run();

}

publicvoidrun(){

//添加新安全算法,如果用JCE就要把它添加进去

Security.addProvider(newcom.sun.crypto.provider.SunJCE());

StringAlgorithm="DES";//定义加密算法,可用DES,DESede,Blowfish

Stringmyinfo="要加密的信息";

try{

//生成密钥

KeyGeneratorkeygen=KeyGenerator.getInstance(Algorithm);

SecretKeydeskey=keygen.generateKey();

//加密

System.out.println("加密前的二进串:"+byte2hex(myinfo.getBytes()));

System.out.println("加密前的信息:"+myinfo);

Cipherc1=Cipher.getInstance(Algorithm);

c1.init(Cipher.ENCRYPT_MODE,deskey);

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

System.out.println("加密后的二进串:"+byte2hex(cipherByte));

//解密

c1=Cipher.getInstance(Algorithm);

c1.init(Cipher.DECRYPT_MODE,deskey);

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

System.out.println("解密后的二进串:"+byte2hex(clearByte));

System.out.println("解密后的信息:"+(newString(clearByte)));

}

catch(java.security.NoSuchAlgorithmExceptione1){e1.printStackTrace();}

catch(javax.crypto.NoSuchPaddingExceptione2){e2.printStackTrace();}

catch(java.lang.Exceptione3){e3.printStackTrace();}

}

publicStringbyte2hex(byte[]b)//二行制转字符串

{

Stringhs="";

Stringstmp="";

for(intn=0;n<b.length;n++)

{

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

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

elsehs=hs+stmp;

if(n<b.length-1)hs=hs+":";

}

returnhs.toUpperCase();

}

2.5.Diffie-Hellman密钥一致协议

公开密钥密码体制的奠基人Diffie和Hellman所提出的"指数密钥一致协议"(ExponentialKeyAgreementProtocol),该协议不要求别的安全性先决条件,允许两名用户在公开媒体上交换信息以生成"一致"的,可以共享的密钥。在JCE的中实现用户alice生成DH类型的密钥对,如果长度用1024生成的时间请,推荐第一次生成后保存DHParameterSpec,以便下次使用直接初始化.使其速度加快

System.out.println("ALICE:产生DH对...");

KeyPairGeneratoraliceKpairGen=KeyPairGenerator.getInstance("DH");

aliceKpairGen.initialize(512);

KeyPairaliceKpair=aliceKpairGen.generateKeyPair();

alice生成公钥发送组bob

byte[]alicePubKeyEnc=aliceKpair.getPublic().getEncoded();

bob从alice发送来的公钥中读出DH密钥对的初始参数生成bob的DH密钥对

注意这一步一定要做,要保证每个用户用相同的初始参数生成的

DHParameterSpecdhParamSpec=((DHPublicKey)alicePubKey).getParams();

KeyPairGeneratorbobKpairGen=KeyPairGenerator.getInstance("DH");

bobKpairGen.initialize(dhParamSpec);

KeyPairbobKpair=bobKpairGen.generateKeyPair();

bob根据alice的公钥生成本地的DES密钥

KeyAgreementbobKeyAgree=KeyAgreement.getInstance("DH");

bobKeyAgree.init(bobKpair.getPrivate());

bobKeyAgree.doPhase(alicePubKey,true);

SecretKeybobDesKey=bobKeyAgree.generateSecret("DES");

bob已经生成了他的DES密钥,他现把他的公钥发给alice,

byte[]bobPubKeyEnc=bobKpair.getPublic().getEncoded();

alice根据bob的公钥生成本地的DES密钥

,,,,,,解码

KeyAgreementaliceKeyAgree=KeyAgreement.getInstance("DH");

aliceKeyAgree.init(aliceKpair.getPrivate());

aliceKeyAgree.doPhase(bobPubKey,true);

SecretKeyaliceDesKey=aliceKeyAgree.generateSecret("DES");

bob和alice能过这个过程就生成了相同的DES密钥,在这种基础就可进行安全能信

常用API

java.security.KeyPairGenerator密钥生成器类

publicstaticKeyPairGeneratorgetInstance(Stringalgorithm)

throwsNoSuchAlgorithmException

以指定的算法返回一个KeyPairGenerator对象

参数:algorithm算法名.如:原来是DSA,现在添加了DiffieHellman(DH)

publicvoidinitialize(intkeysize)

以指定的长度初始化KeyPairGenerator对象,如果没有初始化系统以1024长度默认设置

参数:keysize算法位长.其范围必须在512到1024之间，且必须为64的倍数

注意:如果用1024生长的时间很长,最好生成一次后就保存,下次就不用生成了

publicvoidinitialize(AlgorithmParameterSpecparams)

throwsInvalidAlgorithmParameterException

以指定参数初始化

javax.crypto.interfaces.DHPublicKey

publicDHParameterSpecgetParams()

java.security.KeyFactory

publicstaticKeyFactorygetInstance(Stringalgorithm)

throwsNoSuchAlgorithmException

以指定的算法返回一个KeyFactory

参数:algorithm算法名:DSH,DH

publicfinalPublicKeygeneratePublic(KeySpeckeySpec)

throwsInvalidKeySpecException

根据指定的key说明,返回一个PublicKey对象

java.security.spec.X509EncodedKeySpec

publicX509EncodedKeySpec(byte[]encodedKey)

根据指定的二进制编码的字串生成一个key的说明

参数:encodedKey二进制编码的字串(一般能过PublicKey.getEncoded()生成)

javax.crypto.KeyAgreement密码一至类

publicstaticfinalKeyAgreementgetInstance(java.lang.Stringalgorithm)

throwsjava.security.NoSuchAlgorithmException

返回一个指定算法的KeyAgreement对象

参数:algorithm算法名,现在只能是DiffieHellman(DH)

publicfinalvoidinit(java.security.Keykey)

throwsjava.security.InvalidKeyException

用指定的私钥初始化

参数:key一个私钥

publicfinaljava.security.KeydoPhase(java.security.Keykey,

booleanlastPhase)

throwsjava.security.InvalidKeyException,

java.lang.IllegalStateException

用指定的公钥进行定位,lastPhase确定这是否是最后一个公钥,对于两个用户的

情况下就可以多次定次,最后确定

参数:key公钥

lastPhase是否最后公钥

publicfinalSecretKeygenerateSecret(java.lang.Stringalgorithm)

throwsjava.lang.IllegalStateException,

java.security.NoSuchAlgorithmException,

java.security.InvalidKeyException

根据指定的算法生成密钥

参数:algorithm加密算法(可用DES,DESede,Blowfish)

importjava.io.*;

importjava.math.BigInteger;

importjava.security.*;

importjava.security.spec.*;

importjava.security.interfaces.*;

importjavax.crypto.*;

importjavax.crypto.spec.*;

importjavax.crypto.interfaces.*;

importcom.sun.crypto.provider.SunJCE;

publicclasstestDHKey{

publicstaticvoidmain(Stringargv[]){

try{

testDHKeymy=newtestDHKey();

my.run();

}catch(Exceptione){

System.err.println(e);

}

privatevoidrun()throwsException{

Security.addProvider(newcom.sun.crypto.provider.SunJCE());

System.out.println("ALICE:产生DH对...");

KeyPairGeneratoraliceKpairGen=KeyPairGenerator.getInstance("DH");

aliceKpairGen.initialize(512);

KeyPairaliceKpair=aliceKpairGen.generateKeyPair();//生成时间长

//张三(Alice)生成公共密钥alicePubKeyEnc并发送给李四(Bob),

//比如用文件方式,socket.....

byte[]alicePubKeyEnc=aliceKpair.getPublic().getEncoded();

//bob接收到alice的编码后的公钥,将其解码

KeyFactorybobKeyFac=KeyFactory.getInstance("DH");

X509EncodedKeySpecx509KeySpec=newX509EncodedKeySpec(alicePubKeyEnc);

PublicKeyalicePubKey=bobKeyFac.generatePublic(x509KeySpec);

System.out.println("alice公钥bob解码成功");

//bob必须用相同的参数初始化的他的DHKEY对,所以要从Alice发给他的公开密钥,

//中读出参数,再用这个参数初始化他的DHkey对

//从alicePubKye中取alice初始化时用的参数

DHParameterSpecdhParamSpec=((DHPublicKey)alicePubKey).getParams();

KeyPairGeneratorbobKpairGen=KeyPairGenerator.getInstance("DH");

bobKpairGen.initialize(dhParamSpec);

KeyPairbobKpair=bobKpairGen.generateKeyPair();

System.out.println("BOB:生成DHkey对成功");

KeyAgreementbobKeyAgree=KeyAgreement.getInstance("DH");

bobKeyAgree.init(bobKpair.getPrivate());

System.out.println("BOB:初始化本地key成功");

//李四(bob)生成本地的密钥bobDesKey

bobKeyAgree.doPhase(alicePubKey,true);

SecretKeybobDesKey=bobKeyAgree.generateSecret("DES");

System.out.println("BOB:用alice的公钥定位本地key,生成本地DES密钥成功");

//Bob生成公共密钥bobPubKeyEnc并发送给Alice,

//比如用文件方式,socket.....,使其生成本地密钥

byte[]bobPubKeyEnc=bobKpair.getPublic().getEncoded();

System.out.println("BOB向ALICE发送公钥");

//alice接收到bobPubKeyEnc后生成bobPubKey

//再进行定位,使aliceKeyAgree定位在bobPubKey

KeyFactoryaliceKeyFac=KeyFactory.getInstance("DH");

x509KeySpec=newX509EncodedKeySpec(bobPubKeyEnc);

PublicKeybobPubKey=aliceKeyFac.generatePublic(x509KeySpec);

System.out.println("ALICE接收BOB公钥并解码成功");

;

KeyAgreementaliceKeyAgree=KeyAgreement.getInstance("DH");

aliceKeyAgree.init(aliceKpair.getPrivate());

System.out.println("ALICE:初始化本地key成功");

aliceKeyAgree.doPhase(bobPubKey,true);

//张三(alice)生成本地的密钥aliceDesKey

SecretKeyaliceDesKey=aliceKeyAgree.generateSecret("DES");

System.out.println("ALICE:用bob的公钥定位本地key,并生成本地DES密钥");

if(aliceDesKey.equals(bobDesKey))System.out.println("张三和李四的密钥相同");

//现在张三和李四的本地的deskey是相同的所以,完全可以进行发送加密,接收后解密,达到

//安全通道的的目的

*bob用bobDesKey密钥加密信息

CipherbobCipher=Cipher.getInstance("DES");

bobCipher.init(Cipher.ENCRYPT_MODE,bobDesKey);

Stringbobinfo="这是李四的机密信息";

System.out.println("李四加密前原文:"+bobinfo);

byte[]cleartext=bobinfo.getBytes();

byte[]ciphertext=bobCipher.doFinal(cleartext);

*alice用aliceDesKey密钥解密

CipheraliceCipher=Cipher.getInstance("DES");

aliceCipher.init(Cipher.DECRYPT_MODE,aliceDesKey);

byte[]recovered=aliceCipher.doFinal(ciphertext);

System.out.println("alice解密bob的信息:"+(newString(recovered)));

if(!java.util.Arrays.equals(cleartext,recovered))

thrownewException("解密后与原文信息不同");

System.out.println("解密后相同");

}

回页首

第3章小结

在加密术中生成密钥对时，密钥对的当然是越长越好，但费时也越多，请从中从实际出发选取合适的长度，大部分例码中的密钥是每次运行就从新生成，在实际的情况中是生成后在一段时间保存在文件中，再次运行直接从文件中读入，从而加快速度。当然定时更新和加强密钥保管的安全性也是必须的。

关于作者

王辉，具有八年的编程及系统管理经验，所使用的语言为C和Java编程语言。目前在深圳一家公司做程序员，使用C和JAVA为DB2数据库编程.

diffie-hellman sha1 des 密钥管理 sha1加密摘要算法报文交换密码学数字签名 md5加密算法

安科网

JAVA上加密算法的实现用例：MD5/SHA1，DSA，DESede/DES，Diffie-Hellman的使用

wangxiaohua

wangxiaohua

相关推荐

PuTTY 错误：expected key exchange group packer from server

Diffie-Hellman秘钥交换算法

wangxiaohua