- 浏览: 538045 次
- 性别:
- 来自: 北京
-
文章分类
最新评论
-
landerson：
明显就有要求的嘛
ANDROID轻量级JSON序列化和反序列化［转］ -
jimode2013：
很不错，就是需要这个方法
多个UIViewController使用addSubView，第二个 UIViewController 不响应旋转[转] -
w11h22j33：
...
［转］NSMutableArray中的自动释放对象让我郁闷了一整天 -
w11h22j33：
UILabel* label = [[UILabel a ...
Iphone开发 -
w11h22j33：
http://mobile.51cto.com/iphone- ...
获得通讯录中联系人的所有属性［转］
单钥密码体制是一种传统的加密算法，是指信息的发送方和接收方共同使用同一把密钥进行加解密。 通常,使用的加密算法比较简便高效,密钥简短，加解密速度快，破译极其困难。但是加密的安全性依靠密钥保管的安全性,在公开的计算机网络上安全地传送和保管密钥是一个严峻的问题，并且如果在多用户的情况下密钥的保管安全性也是一个问题。 单钥密码体制的代表是美国的DES 一个消息摘要就是一个数据块的数字指纹。即对一个任意长度的一个数据块进行计算，产生一个唯一指印（对于SHA1是产生一个20字节的二进制数组）。 消息摘要有两个基本属性： 代表：美国国家标准技术研究所的SHA1和麻省理工学院Ronald Rivest提出的MD5 密钥一致协议是由公开密钥密码体制的奠基人Diffie和Hellman所提出的一种思想。 先决条件,允许两名用户在公开媒体上交换信息以生成"一致"的,可以共享的密钥 代表：指数密钥一致协议(Exponential Key Agreement Protocol) 1976年，Dittie和Hellman为解决密钥管理问题，在他们的奠基性的工作"密码学的新方向"一文中，提出一种密钥交换协议，允许在不安全的媒体上通过通讯双方交换信息，安全地传送秘密密钥。在此新思想的基础上，很快出现了非对称密钥密码体制，即公钥密码体制。在公钥体制中，加密密钥不同于解密密钥，加密密钥公之于众，谁都可以使用；解密密钥只有解密人自己知道。它们分别称为公开密钥（Public key）和秘密密钥（Private key）。 迄今为止的所有公钥密码体系中，RSA系统是最著名、最多使用的一种。RSA公开密钥密码系统是由R.Rivest、A.Shamir和L.Adleman俊教授于1977年提出的。RSA的取名就是来自于这三位发明者的姓的第一个字母 所谓数字签名就是信息发送者用其私钥对从所传报文中提取出的特征数据（或称数字指纹）进行RSA算法操作，以保证发信人无法抵赖曾发过该信息（即不可抵赖性），同时也确保信息报文在经签名后末被篡改（即完整性）。当信息接收者收到报文后，就可以用发送者的公钥对数字签名进行验证。 在数字签名中有重要作用的数字指纹是通过一类特殊的散列函数（HASH函数）生成的，对这些HASH函数的特殊要求是： 代表：DSA 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内,更详细说明请看相应用户手册 使用方法: 首先用生成一个MessageDigest类,确定计算方法 java.security.MessageDigest alga=java.security.MessageDigest.getInstance("SHA-1"); 添加要进行计算摘要的信息 alga.update(myinfo.getBytes()); 计算出摘要 byte[] digesta=alga.digest(); 发送给其他人你的信息和摘要 其他人用相同的方法初始化,添加信息,最后进行比较摘要是否相同 algb.isEqual(digesta,algb.digest()) 相关AIP java.security.MessageDigest 类 static getInstance(String algorithm) 返回一个MessageDigest对象,它实现指定的算法 参数:算法名,如 SHA-1 或MD5 void update (byte input) void update (byte[] input) void update(byte[] input, int offset, int len) 添加要进行计算摘要的信息 byte[] digest() 完成计算,返回计算得到的摘要(对于MD5是16位,SHA是20位) void reset() 复位 static boolean isEqual(byte[] digesta, byte[] digestb) 比效两个摘要是否相同 代码： 生成一个KeyPairGenerator实例 从文件中读入私人密钥(prikey) 读入公钥 读入签名和信息 初始一个Signature对象,并用公钥和签名进行验证 对于密钥的保存本文是用对象流的方式保存和传送的,也可可以用编码的方式保存.注意要 具休说明如下 java.security.KeyPairGenerator 密钥生成器类 public void initialize(int keysize) 以指定的长度初始化KeyPairGenerator对象,如果没有初始化系统以1024长度默认设置 参数:keysize 算法位长.其范围必须在 512 到 1024 之间，且必须为 64 的倍数 public void initialize(int keysize, SecureRandom random) public abstract KeyPair generateKeyPair() java.security.KeyPair 密钥对类 public PublicKey getPublic() java.security.Signature 签名类 public final void initSign(PrivateKey privateKey) public final void update(byte data) public final byte[] sign() public final void initVerify(PublicKey publicKey) public final boolean verify(byte[] signature) 首先生成密钥,并保存(这里并没的保存的代码,可参考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三种加密术 对于密钥的保存各传送可使用对象流或者用二进制编码,相关参考代码如下 相关API KeyGenerator 在DSA中已经说明,在添加JCE后在instance进可以如下参数 DES,DESede,Blowfish,HmacMD5,HmacSHA1 javax.crypto.Cipher 加/解密器 返回一个指定方法的Cipher对象 参数:transformation 方法名(可用 DES,DESede,Blowfish) public final void init(int opmode, java.security.Key key) 用指定的密钥和模式初始化Cipher对象 参数:opmode 方式(ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE,UNWRAP_MODE) key 密钥 对input内的串,进行编码处理,返回处理后二进制串,是返回解密文还是加解文由init时的opmode决定 注意:本方法的执行前如果有update,是对updat和本次input全部处理,否则是本inout的内容 公开密钥密码体制的奠基人Diffie和Hellman所提出的 "指数密钥一致协议"(Exponential Key Agreement Protocol),该协议不要求别的安全性先决条件,允许两名用户在公开媒体上交换信息以生成"一致"的,可以共享的密钥。在JCE的中实现用户alice生成DH类型的密钥对,如果长度用1024生成的时间请,推荐第一次生成后保存DHParameterSpec,以便下次使用直接初始化.使其速度加快 alice生成公钥发送组bob bob从alice发送来的公钥中读出DH密钥对的初始参数生成bob的DH密钥对 注意这一步一定要做,要保证每个用户用相同的初始参数生成的 bob根据alice的公钥生成本地的DES密钥 bob已经生成了他的DES密钥,他现把他的公钥发给alice, alice根据bob的公钥生成本地的DES密钥 bob和alice能过这个过程就生成了相同的DES密钥,在这种基础就可进行安全能信 常用API java.security.KeyPairGenerator 密钥生成器类 public void initialize(int keysize) public void initialize(AlgorithmParameterSpec params) javax.crypto.interfaces.DHPublicKey public static KeyFactory getInstance(String algorithm) public final PublicKey generatePublic(KeySpec keySpec) java.security.spec.X509EncodedKeySpec public static final KeyAgreement getInstance(java.lang.String algorithm) public final void init(java.security.Key key) public final java.security.Key doPhase(java.security.Key key, public final SecretKey generateSecret(java.lang.String algorithm) 通常,使用的加密算法 比较简便高效,密钥简短，加解密速度快，破译极其困难。本文介绍了 MD5/SHA1，DSA，DESede/DES，Diffie-Hellman的使用。
回页首
import java.security.*;
public class myDigest {
public static void main(String[] args) {
myDigest my=new myDigest();
my.testDigest();
}
public void testDigest()
{
try {
String myinfo="我的测试信息";
//java.security.MessageDigest alg=java.security.MessageDigest.getInstance("MD5");
java.security.MessageDigest alga=java.security.MessageDigest.getInstance("SHA-1");
alga.update(myinfo.getBytes());
byte[] digesta=alga.digest();
System.out.println("本信息摘要是:"+byte2hex(digesta));
//通过某中方式传给其他人你的信息(myinfo)和摘要(digesta) 对方可以判断是否更改或传输正常
java.security.MessageDigest algb=java.security.MessageDigest.getInstance("SHA-1");
algb.update(myinfo.getBytes());
if (algb.isEqual(digesta,algb.digest())) {
System.out.println("信息检查正常");
}
else
{
System.out.println("摘要不相同");
}
}
catch (java.security.NoSuchAlgorithmException ex) {
System.out.println("非法摘要算法");
}
}
public String byte2hex(byte[] b) //二行制转字符串
{
String hs="";
String stmp="";
for (int n=0;n<b.length;n++)
{
stmp=(java.lang.Integer.toHexString(b[n] & 0XFF));
if (stmp.length()==1) hs=hs+"0"+stmp;
else hs=hs+stmp;
if (n<b.length-1) hs=hs+":";
}
return hs.toUpperCase();
}
}
java.security.KeyPairGenerator keygen=java.security.KeyPairGenerator.getInstance("DSA");
如果设定随机产生器就用如相代码初始化
SecureRandom secrand=new SecureRandom();
secrand.setSeed("tttt".getBytes()); //初始化随机产生器
keygen.initialize(512,secrand); //初始化密钥生成器
否则
keygen.initialize(512);
生成密钥公钥pubkey和私钥prikey
KeyPair keys=keygen.generateKeyPair(); //生成密钥组
PublicKey pubkey=keys.getPublic();
PrivateKey prikey=keys.getPrivate();
分别保存在myprikey.dat和mypubkey.dat中,以便下次不在生成
(生成密钥对的时间比较长
java.io.ObjectOutputStream out=new java.io.ObjectOutputStream(new java.io.FileOutputStream("myprikey.dat"));
out.writeObject(prikey);
out.close();
out=new java.io.ObjectOutputStream(new java.io.FileOutputStream("mypubkey.dat"));
out.writeObject(pubkey);
out.close();
java.io.ObjectInputStream in=new java.io.ObjectInputStream(new java.io.FileInputStream("myprikey.dat"));
PrivateKey myprikey=(PrivateKey)in.readObject();
in.close();
初始一个Signature对象,并用私钥对信息签名
java.security.Signature signet=java.security.Signature.getInstance("DSA");
signet.initSign(myprikey);
signet.update(myinfo.getBytes());
byte[] signed=signet.sign();
把信息和签名保存在一个文件中(myinfo.dat)
java.io.ObjectOutputStream out=new java.io.ObjectOutputStream(new java.io.FileOutputStream("myinfo.dat"));
out.writeObject(myinfo);
out.writeObject(signed);
out.close();
把他的公钥的信息及签名发给其它用户
java.io.ObjectInputStream in=new java.io.ObjectInputStream(new java.io.FileInputStream("mypubkey.dat"));
PublicKey pubkey=(PublicKey)in.readObject();
in.close();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("签名正常");}import java.security.spec.*
import java.security.*
byte[] bobEncodedPubKey=mypublic.getEncoded(); //生成编码
//传送二进制编码
//以下代码转换编码为相应key对象
X509EncodedKeySpec bobPubKeySpec = new X509EncodedKeySpec(bobEncodedPubKey);
KeyFactory keyFactory = KeyFactory.getInstance("DSA");
PublicKey bobPubKey = keyFactory.generatePublic(bobPubKeySpec);
byte[] bPKCS=myprikey.getEncoded();
//传送二进制编码
//以下代码转换编码为相应key对象
PKCS8EncodedKeySpec priPKCS8=new PKCS8EncodedKeySpec(bPKCS);
KeyFactory keyf=KeyFactory.getInstance("DSA");
PrivateKey otherprikey=keyf.generatePrivate(priPKCS8);
public static KeyPairGenerator getInstance(String algorithm) throws NoSuchAlgorithmException
以指定的算法返回一个KeyPairGenerator 对象
参数: algorithm 算法名.如:"DSA","RSA"
以指定的长度初始化和随机发生器初始化KeyPairGenerator对象
参数:keysize 算法位长.其范围必须在 512 到 1024 之间，且必须为 64 的倍数
random 一个随机位的来源(对于initialize(int keysize)使用了默认随机器
产生新密钥对
public PrivateKey getPrivate()
返回私钥
返回公钥
public static Signature getInstance(String algorithm) throws NoSuchAlgorithmException
返回一个指定算法的Signature对象
参数 algorithm 如:"DSA"
throws InvalidKeyException
用指定的私钥初始化
参数:privateKey 所进行签名时用的私钥
throws SignatureException
public final void update(byte[] data)
throws SignatureException
public final void update(byte[] data, int off, int len)
throws SignatureException
添加要签名的信息
throws SignatureException
返回签名的数组,前提是initSign和update
throws InvalidKeyException
用指定的公钥初始化
参数:publicKey 验证时用的公钥
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;n<b.length;n++)
{
stmp=(java.lang.Integer.toHexString(b[n] & 0XFF));
if (stmp.length()==1) hs=hs+"0"+stmp;
else hs=hs+stmp;
if (n<b.length-1) hs=hs+":";
}
return hs.toUpperCase();
}
}
SecretKey deskey = keygen.generateKey();
byte[] desEncode=deskey.getEncoded();
javax.crypto.spec.SecretKeySpec destmp=new javax.crypto.spec.SecretKeySpec(desEncode,Algorithm);
SecretKey mydeskey=destmp;
public static final Cipher getInstance(java.lang.String transformation)
throws java.security.NoSuchAlgorithmException,
NoSuchPaddingException
throws java.security.InvalidKeyException
public final byte[] doFinal(byte[] input)
throws java.lang.IllegalStateException,
IllegalBlockSizeException,
BadPaddingException
/*
安全程序 DESede/DES测试
*/
import java.security.*;
import javax.crypto.*;
public class testdes {
public static void main(String[] args){
testdes my=new testdes();
my.run();
}
public void run() {
//添加新安全算法,如果用JCE就要把它添加进去
Security.addProvider(new com.sun.crypto.provider.SunJCE());
String Algorithm="DES"; //定义 加密算法,可用 DES,DESede,Blowfish
String myinfo="要加密的信息";
try {
//生成密钥
KeyGenerator keygen = KeyGenerator.getInstance(Algorithm);
SecretKey deskey = keygen.generateKey();
//加密
System.out.println("加密前的二进串:"+byte2hex(myinfo.getBytes()));
System.out.println("加密前的信息:"+myinfo);
Cipher c1 = 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("解密后的信息:"+(new String(clearByte)));
}
catch (java.security.NoSuchAlgorithmException e1) {e1.printStackTrace();}
catch (javax.crypto.NoSuchPaddingException e2) {e2.printStackTrace();}
catch (java.lang.Exception e3) {e3.printStackTrace();}
}
public String byte2hex(byte[] b) //二行制转字符串
{
String hs="";
String stmp="";
for (int n=0;n<b.length;n++)
{
stmp=(java.lang.Integer.toHexString(b[n] & 0XFF));
if (stmp.length()==1) hs=hs+"0"+stmp;
else hs=hs+stmp;
if (n<b.length-1) hs=hs+":";
}
return hs.toUpperCase();
}
}
System.out.println("ALICE: 产生 DH 对 ...");
KeyPairGenerator aliceKpairGen = KeyPairGenerator.getInstance("DH");
aliceKpairGen.initialize(512);
KeyPair aliceKpair = aliceKpairGen.generateKeyPair();
byte[] alicePubKeyEnc = aliceKpair.getPublic().getEncoded();
DHParameterSpec dhParamSpec = ((DHPublicKey)alicePubKey).getParams();
KeyPairGenerator bobKpairGen = KeyPairGenerator.getInstance("DH");
bobKpairGen.initialize(dhParamSpec);
KeyPair bobKpair = bobKpairGen.generateKeyPair();
KeyAgreement bobKeyAgree = KeyAgreement.getInstance("DH");
bobKeyAgree.init(bobKpair.getPrivate());
bobKeyAgree.doPhase(alicePubKey, true);
SecretKey bobDesKey = bobKeyAgree.generateSecret("DES");
byte[] bobPubKeyEnc = bobKpair.getPublic().getEncoded();
,,,,,,解码
KeyAgreement aliceKeyAgree = KeyAgreement.getInstance("DH");
aliceKeyAgree.init(aliceKpair.getPrivate());
aliceKeyAgree.doPhase(bobPubKey, true);
SecretKey aliceDesKey = aliceKeyAgree.generateSecret("DES");
public static KeyPairGenerator getInstance(String algorithm)
throws NoSuchAlgorithmException
以指定的算法返回一个KeyPairGenerator 对象
参数: algorithm 算法名.如:原来是DSA,现在添加了 DiffieHellman(DH)
以指定的长度初始化KeyPairGenerator对象,如果没有初始化系统以1024长度默认设置
参数:keysize 算法位长.其范围必须在 512 到 1024 之间，且必须为 64 的倍数
注意:如果用1024生长的时间很长,最好生成一次后就保存,下次就不用生成了
throws InvalidAlgorithmParameterException
以指定参数初始化
public DHParameterSpec getParams()
返回
java.security.KeyFactory
throws NoSuchAlgorithmException
以指定的算法返回一个KeyFactory
参数: algorithm 算法名:DSH,DH
throws InvalidKeySpecException
根据指定的key说明,返回一个PublicKey对象
public X509EncodedKeySpec(byte[] encodedKey)
根据指定的二进制编码的字串生成一个key的说明
参数:encodedKey 二进制编码的字串(一般能过PublicKey.getEncoded()生成)
javax.crypto.KeyAgreement 密码一至类
throws java.security.NoSuchAlgorithmException
返回一个指定算法的KeyAgreement对象
参数:algorithm 算法名,现在只能是DiffieHellman(DH)
throws java.security.InvalidKeyException
用指定的私钥初始化
参数:key 一个私钥
boolean lastPhase)
throws java.security.InvalidKeyException,
java.lang.IllegalStateException
用指定的公钥进行定位,lastPhase确定这是否是最后一个公钥,对于两个用户的
情况下就可以多次定次,最后确定
参数:key 公钥
lastPhase 是否最后公钥
throws java.lang.IllegalStateException,
java.security.NoSuchAlgorithmException,
java.security.InvalidKeyException
根据指定的算法生成密钥
参数:algorithm 加密算法(可用 DES,DESede,Blowfish)
*/
import java.io.*;
import java.math.BigInteger;
import java.security.*;
import java.security.spec.*;
import java.security.interfaces.*;
import javax.crypto.*;
import javax.crypto.spec.*;
import javax.crypto.interfaces.*;
import com.sun.crypto.provider.SunJCE;
public class testDHKey {
public static void main(String argv[]) {
try {
testDHKey my= new testDHKey();
my.run();
} catch (Exception e) {
System.err.println(e);
}
}
private void run() throws Exception {
Security.addProvider(new com.sun.crypto.provider.SunJCE());
System.out.println("ALICE: 产生 DH 对 ...");
KeyPairGenerator aliceKpairGen = KeyPairGenerator.getInstance("DH");
aliceKpairGen.initialize(512);
KeyPair aliceKpair = aliceKpairGen.generateKeyPair(); //生成时间长
// 张三(Alice)生成公共密钥 alicePubKeyEnc 并发送给李四(Bob) ,
//比如用文件方式,socket.....
byte[] alicePubKeyEnc = aliceKpair.getPublic().getEncoded();
//bob接收到alice的编码后的公钥,将其解码
KeyFactory bobKeyFac = KeyFactory.getInstance("DH");
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec (alicePubKeyEnc);
PublicKey alicePubKey = bobKeyFac.generatePublic(x509KeySpec);
System.out.println("alice公钥bob解码成功");
// bob必须用相同的参数初始化的他的DH KEY对,所以要从Alice发给他的公开密钥,
//中读出参数,再用这个参数初始化他的 DH key对
//从alicePubKye中取alice初始化时用的参数
DHParameterSpec dhParamSpec = ((DHPublicKey)alicePubKey).getParams();
KeyPairGenerator bobKpairGen = KeyPairGenerator.getInstance("DH");
bobKpairGen.initialize(dhParamSpec);
KeyPair bobKpair = bobKpairGen.generateKeyPair();
System.out.println("BOB: 生成 DH key 对成功");
KeyAgreement bobKeyAgree = KeyAgreement.getInstance("DH");
bobKeyAgree.init(bobKpair.getPrivate());
System.out.println("BOB: 初始化本地key成功");
//李四(bob) 生成本地的密钥 bobDesKey
bobKeyAgree.doPhase(alicePubKey, true);
SecretKey bobDesKey = 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
KeyFactory aliceKeyFac = KeyFactory.getInstance("DH");
x509KeySpec = new X509EncodedKeySpec(bobPubKeyEnc);
PublicKey bobPubKey = aliceKeyFac.generatePublic(x509KeySpec);
System.out.println("ALICE接收BOB公钥并解码成功");
;
KeyAgreement aliceKeyAgree = KeyAgreement.getInstance("DH");
aliceKeyAgree.init(aliceKpair.getPrivate());
System.out.println("ALICE: 初始化本地key成功");
aliceKeyAgree.doPhase(bobPubKey, true);
// 张三(alice) 生成本地的密钥 aliceDesKey
SecretKey aliceDesKey = aliceKeyAgree.generateSecret("DES");
System.out.println("ALICE: 用bob的公钥定位本地key,并生成本地DES密钥");
if (aliceDesKey.equals(bobDesKey)) System.out.println("张三和李四的密钥相同");
//现在张三和李四的本地的deskey是相同的所以,完全可以进行发送加密,接收后解密,达到
//安全通道的的目的
/*
* bob用bobDesKey密钥加密信息
*/
Cipher bobCipher = Cipher.getInstance("DES");
bobCipher.init(Cipher.ENCRYPT_MODE, bobDesKey);
String bobinfo= "这是李四的机密信息";
System.out.println("李四加密前原文:"+bobinfo);
byte[] cleartext =bobinfo.getBytes();
byte[] ciphertext = bobCipher.doFinal(cleartext);
/*
* alice用aliceDesKey密钥解密
*/
Cipher aliceCipher = Cipher.getInstance("DES");
aliceCipher.init(Cipher.DECRYPT_MODE, aliceDesKey);
byte[] recovered = aliceCipher.doFinal(ciphertext);
System.out.println("alice解密bob的信息:"+(new String(recovered)));
if (!java.util.Arrays.equals(cleartext, recovered))
throw new Exception("解密后与原文信息不同");
System.out.println("解密后相同");
}
}
发表评论
-
如何 永久ROOT 中兴V88【转】
2011-05-12 20:32 22981.安装附件中的软件VI ... -
使用android中的AIDL让Service与Activity通信[转]
2011-04-29 14:42 1414http://linconz.net/archives/2 ... -
Android调用内置的无线信息隐藏菜单[转]【待验证】
2011-04-05 22:59 1596最近自己在汉化分析Android只带的“设置”程序（即se ... -
android第三方应用apk安装和运行控制解决方案[转]
2011-01-26 00:03 3688需求: 要求让用户选择喜欢的第三方应用 下载 并通过自 ... -
知识点和代码积累[转]++
2011-01-22 14:05 12741.如何调用外部图片选择器，选择图片并返回结果 ... -
Android 中自定义属性(attr.xml,TypedArray)的使用
2011-01-20 22:44 1765在xml 文件里定义控件的属性，我们已经习惯了android: ... -
android 程序错误处理全局处理[转]
2011-01-08 23:39 2062原文 本文将分析在程 ... -
命令行执行Android【转载】
2010-12-22 23:20 1319原始出处 一直以来都是用adb install xxx.apk ... -
Android开发——android调试工具集【转】
2010-12-14 18:36 13201. 查看当前堆栈 1) 功能：在程序中加入代码，使可以在l ... -
Android平台中可以使用第三方外部JAR库文件【转】
2010-12-14 09:25 2669导入： 在Android平台中可以使用第三方外部JAR库文件 ... -
Android 应用程序快速启动的秘诀
2010-12-13 00:21 2127Android系统框架和上层应用是类java(不是正统的sun ... -
关于Android Logcat打印输出中文乱码问题的解决方法
2010-12-11 00:36 2308Android LOGCAT输出是UTF-8编码，要想正确显示 ...
相关推荐
在Java中实现加密算法涉及到多个重要的概念和技术，包括单钥密码体制、消息摘要、Diffie-Hellman密钥一致协议、非对称算法和公钥体系以及数字签名。下面将详细阐述这些知识点。 **1. 单钥密码体制** 单钥密码体制，...
Java提供了一个强大的加密框架——Java Cryptography Extension (JCE)，它包含了各种加密算法的实现，如AES、DES、RSA等。此外，Java Standard Edition (Java SE) 还内置了java.security包，包含加密相关的类和接口...
这个RAR压缩包文件“JAVA上加密算法的实现用例”包含了一个PDF文档，很可能是详细介绍了如何在Java环境中应用各种加密算法的实际案例。虽然没有具体的标签提供额外的信息，但我们可以基于通常的加密算法来探讨相关...
本案例主要探讨了IBM Java平台上如何实现加密算法，这对于开发人员来说是一个非常实用的技术点。 首先，我们要了解加密的基本概念。加密是将明文（可读数据）转化为密文（不可读数据）的过程，目的是保护信息不被...
中兴测试用例 中兴系统测试用例--JAVA
在这个压缩包中，包含的资源可以帮助我们理解并实现SHA1、SHA、MD5、AES加密与解密，以及BASE64编码和解码。下面我们将详细探讨这些加密算法和它们在Java中的实现。 1. **SHA（Secure Hash Algorithm）**: SHA是一...
本文将详细介绍C++中SHA1、MD5和Base64加解密算法的实现及其原理。这些技术广泛应用于密码存储、数据完整性验证以及网络传输中。 首先，SHA1（Secure Hash Algorithm 1）是一种哈希函数，它接受任意长度的数据输入...
8. **测试与验证**：设计测试用例，包括正常文件和故意构造的冲突数据，以检验你的程序是否正确实现了MD5和SHA-1算法。 这个实验旨在帮助你深入理解散列函数的工作原理，并实际操作这些算法，提升你的编程和信息...
“信息摘要算法示例”可能包含一些实际操作这些算法的代码示例或测试用例，可能是用不同的编程语言实现的，比如Python、Java或C++。这些示例可以用来理解如何计算文件或字符串的MD5、SHA-1或SHA-256哈希值，并对比...
Android手机测试用例-从事手机测试必备Android手机测试用例-从事手机测试必备Android手机测试用例-从事手机测试必备
【乐游无锡产品测试用例】是一份详细阐述了针对乐游无锡旅游产品系统的测试计划文档，涵盖了系统的核心功能测试，包括用户注册登录、产品筛选购买、验证信息处理、取卡验证以及数据查询导出等多个方面。以下是这些...
4. **使用小记功能需求**（普通用户需求用例描述-3/5/7）：用户可以快速记录想法或知识点，这要求有便捷的笔记创建、编辑和检索功能。同时，可能与同步和备份功能相关联，确保数据安全。 5. **浏览文档需求**（普通...