JAVA 上加密算法的實現用例
MD5/SHA1，DSA，DESede/DES，Diffie-Hellman 的使用
第 1 章基礎知識
1.1. 單鑰密碼體制
單鑰密碼體制是一種傳統的加密算法，是指信息的發送方和接收方共同使用同一把密鑰進行加解密。
通常 , 使用的加密算法比較簡便高效 , 密鑰簡短，加解密速度快，破譯極其困難。但是加密的安全性依靠密鑰保管的安全性 , 在公開的計算機網絡上安全地傳送和保管密鑰是一個嚴峻的問題，並且如果在多用戶的情況下密鑰的保管安全性也是一個問題。
單鑰密碼體制的代表是美國的 DES
1.2. 消息摘要
一個消息摘要就是一個數據塊的數字指紋。即對一個任意長度的一個數據塊進行計算，產生一個唯一指印（對於 SHA1 是產生一個 20 字節的二進制數組）。
消息摘要有兩個基本屬性：
- 兩個不同的報文難以生成相同的摘要
- 難以對指定的摘要生成一個報文，而由該報文反推算出該指定的摘要
代表：美國國家標準技術研究所的 SHA1 和麻省理工學院 Ronald Rivest 提出的 MD5
1.3. Diffie-Hellman 密鑰一致協議
密鑰一致協議是由公開密鑰密碼體制的奠基人 Diffie 和 Hellman 所提出的一種思想。
先決條件 , 允許兩名用戶在公開媒體上交換信息以生成"一致"的 , 可以共享的密鑰
代表：指數密鑰一致協議 (Exponential Key Agreement Protocol)
1.4. 非對稱算法與公鑰體系
1976 年，Dittie 和 Hellman 爲解決密鑰管理問題，在他們的奠基性的工作"密碼學的新方向"一文中，提出一種密鑰交換協議，允許在不安全的媒體上通過通訊雙方交換信息，安全地傳送祕密密鑰。在此新思想的基礎上，很快出現了非對稱密鑰密碼體制，即公鑰密碼體制。在公鑰體制中，加密密鑰不同於解密密鑰，加密密鑰公之於衆，誰都可以使用；解密密鑰只有解密人自己知道。它們分別稱爲公開密鑰（Public key）和祕密密鑰（Private key）。
迄今爲止的所有公鑰密碼體系中，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.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)
比效兩個摘要是否相同
代碼：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
|
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();
}
} |
2.3. 數字簽名 DSA
- 對於一個用戶來講首先要生成他的密鑰對 , 並且分別保存
生成一個 KeyPairGenerator 實例
123456789101112131415161718192021222324java.security.KeyPairGenerator keygen=java.security.KeyPairGenerator.getInstance("DSA");//如果設定隨機產生器就用如相代碼初始化SecureRandom secrand=new SecureRandom();secrand.setSeed("tttt".getBytes()); // 初始化隨機產生器keygen.initialize(512,secrand); // 初始化密鑰生成器//否則keygen.initialize(512);//生成密鑰公鑰 pubkey 和私鑰 prikeyKeyPair 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(); - 用他私人密鑰 (prikey) 對他所確認的信息 (info) 進行數字簽名產生一個簽名數組
從文件中讀入私人密鑰 (prikey)
1234567891011121314151617java.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();把他的公鑰的信息及簽名發給其它用戶 - 其他用戶用他的公共密鑰 (pubkey) 和簽名 (signed) 和信息 (info) 進行驗證是否由他簽名的信息
讀入公鑰
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();初始一個 Signature 對象 , 並用公鑰和簽名進行驗證
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.*具休說明如下
- public key 是用 X.509 編碼的 , 例碼如下 :
123456
byte[] bobEncodedPubKey=mypublic.getEncoded(); // 生成編碼// 傳送二進制編碼// 以下代碼轉換編碼爲相應 key 對象X509EncodedKeySpec bobPubKeySpec = new X509EncodedKeySpec(bobEncodedPubKey);KeyFactory keyFactory = KeyFactory.getInstance("DSA");PublicKey bobPubKey = keyFactory.generatePublic(bobPubKeySpec); - 對於 Private key 是用 PKCS#8 編碼 , 例碼如下 :
123456
byte[] bPKCS=myprikey.getEncoded();// 傳送二進制編碼// 以下代碼轉換編碼爲相應 key 對象PKCS8EncodedKeySpec priPKCS8=new PKCS8EncodedKeySpec(bPKCS);KeyFactory keyf=KeyFactory.getInstance("DSA");PrivateKey otherprikey=keyf.generatePrivate(priPKCS8);
- public key 是用 X.509 編碼的 , 例碼如下 :
- 常用 API
java.security.KeyPairGenerator 密鑰生成器類
public static KeyPairGenerator getInstance(String algorithm) throws NoSuchAlgorithmException
以指定的算法返回一個 KeyPairGenerator 對象
參數 : algorithm 算法名 . 如 :"DSA","RSA"public void initialize(int keysize)
以指定的長度初始化 KeyPairGenerator 對象 , 如果沒有初始化系統以 1024 長度默認設置
參數 :keysize 算法位長 . 其範圍必須在 512 到 1024 之間，且必須爲 64 的倍數
public void initialize(int keysize, SecureRandom random)
以指定的長度初始化和隨機發生器初始化 KeyPairGenerator 對象
參數 :keysize 算法位長 . 其範圍必須在 512 到 1024 之間，且必須爲 64 的倍數
random 一個隨機位的來源 ( 對於 initialize(int keysize) 使用了默認隨機器public abstract KeyPair generateKeyPair()
產生新密鑰對java.security.KeyPair 密鑰對類
public PrivateKey getPrivate()
返回私鑰public PublicKey getPublic()
返回公鑰java.security.Signature 簽名類
public static Signature getInstance(String algorithm) throws NoSuchAlgorithmException
返回一個指定算法的 Signature 對象
參數 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 和 updatepublic final void initVerify(PublicKey publicKey)
throws InvalidKeyException
用指定的公鑰初始化
參數 :publicKey 驗證時用的公鑰public final boolean verify(byte[] signature)
throws SignatureException
驗證簽名是否有效 , 前提是已經 initVerify 初始化
參數 : signature 簽名數組123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126import 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.X509EncodedKeySpecString 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();}}
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 三種加密術
對於密鑰的保存各傳送可使用對象流或者用二進制編碼 , 相關參考代碼如下
|
1
2
3
4
5
|
SecretKey deskey = keygen.generateKey();
byte[] desEncode=deskey.getEncoded();
javax.crypto.spec.SecretKeySpec destmp = new javax.crypto.spec.SecretKeySpec(desEncode,Algorithm);SecretKey mydeskey=destmp; |
相關 API
KeyGenerator 在 DSA 中已經說明 , 在添加 JCE 後在 instance 進可以如下參數
DES,DESede,Blowfish,HmacMD5,HmacSHA1
javax.crypto.Cipher 加 / 解密器
|
1
2
3
|
public static final Cipher getInstance(java.lang.String transformation)
throws java.security.NoSuchAlgorithmException,
NoSuchPaddingException |
返回一個指定方法的 Cipher 對象
參數 :transformation 方法名 ( 可用 DES,DESede,Blowfish)
public final void init(int opmode, java.security.Key key)
throws java.security.InvalidKeyException
用指定的密鑰和模式初始化 Cipher 對象
參數 :opmode 方式 (ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE,UNWRAP_MODE)
key 密鑰
|
1
2
3
4
|
public final byte[] doFinal(byte[] input)
throws java.lang.IllegalStateException,
IllegalBlockSizeException,
BadPaddingException |
對 input 內的串 , 進行編碼處理 , 返回處理後二進制串 , 是返回解密文還是加解文由 init 時的 opmode 決定
注意 : 本方法的執行前如果有 update, 是對 updat 和本次 input 全部處理 , 否則是本 inout 的內容
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
|
/* 安全程序 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();
}
} |
2.5. Diffie-Hellman 密鑰一致協議
公開密鑰密碼體制的奠基人 Diffie 和 Hellman 所提出的"指數密鑰一致協議"(Exponential Key Agreement Protocol), 該協議不要求別的安全性先決條件 , 允許兩名用戶在公開媒體上交換信息以生成"一致"的 , 可以共享的密鑰。在 JCE 的中實現用戶 alice 生成 DH 類型的密鑰對 , 如果長度用 1024 生成的時間請 , 推薦第一次生成後保存 DHParameterSpec, 以便下次使用直接初始化 . 使其速度加快
|
1
2
3
4
|
System.out.println("ALICE: 產生 DH 對 ...");
KeyPairGenerator aliceKpairGen = KeyPairGenerator.getInstance("DH");
aliceKpairGen.initialize(512);
KeyPair aliceKpair = aliceKpairGen.generateKeyPair(); |
alice 生成公鑰發送組 bob
|
1
|
byte[] alicePubKeyEnc = aliceKpair.getPublic().getEncoded(); |
bob 從 alice 發送來的公鑰中讀出 DH 密鑰對的初始參數生成 bob 的 DH 密鑰對
注意這一步一定要做 , 要保證每個用戶用相同的初始參數生成的
|
1
2
3
4
|
DHParameterSpec dhParamSpec = ((DHPublicKey)alicePubKey).getParams();
KeyPairGenerator bobKpairGen = KeyPairGenerator.getInstance("DH");
bobKpairGen.initialize(dhParamSpec);
KeyPair bobKpair = bobKpairGen.generateKeyPair(); |
bob 根據 alice 的公鑰生成本地的 DES 密鑰
|
1
2
3
4
|
KeyAgreement bobKeyAgree = KeyAgreement.getInstance("DH");
bobKeyAgree.init(bobKpair.getPrivate());
bobKeyAgree.doPhase(alicePubKey, true);
SecretKey bobDesKey = bobKeyAgree.generateSecret("DES"); |
bob 已經生成了他的 DES 密鑰 , 他現把他的公鑰發給 alice,
|
1
|
byte[] bobPubKeyEnc = bobKpair.getPublic().getEncoded(); |
alice 根據 bob 的公鑰生成本地的 DES 密鑰
|
1
2
3
4
5
|
,,,,,, 解碼KeyAgreement aliceKeyAgree = KeyAgreement.getInstance("DH");
aliceKeyAgree.init(aliceKpair.getPrivate());
aliceKeyAgree.doPhase(bobPubKey, true);
SecretKey aliceDesKey = aliceKeyAgree.generateSecret("DES"); |
bob 和 alice 能過這個過程就生成了相同的 DES 密鑰 , 在這種基礎就可進行安全能信
常用 API
java.security.KeyPairGenerator 密鑰生成器類
public static KeyPairGenerator getInstance(String algorithm)
throws NoSuchAlgorithmException
以指定的算法返回一個 KeyPairGenerator 對象
參數 : algorithm 算法名 . 如 : 原來是 DSA, 現在添加了 DiffieHellman(DH)
public void initialize(int keysize)
以指定的長度初始化 KeyPairGenerator 對象 , 如果沒有初始化系統以 1024 長度默認設置
參數 :keysize 算法位長 . 其範圍必須在 512 到 1024 之間，且必須爲 64 的倍數
注意 : 如果用 1024 生長的時間很長 , 最好生成一次後就保存 , 下次就不用生成了
public void initialize(AlgorithmParameterSpec params)
throws InvalidAlgorithmParameterException
以指定參數初始化
javax.crypto.interfaces.DHPublicKey
public DHParameterSpec getParams()
返回
java.security.KeyFactory
public static KeyFactory getInstance(String algorithm)
throws NoSuchAlgorithmException
以指定的算法返回一個 KeyFactory
參數 : algorithm 算法名 :DSH,DH
public final PublicKey generatePublic(KeySpec keySpec)
throws InvalidKeySpecException
根據指定的 key 說明 , 返回一個 PublicKey 對象
java.security.spec.X509EncodedKeySpec
public X509EncodedKeySpec(byte[] encodedKey)
根據指定的二進制編碼的字串生成一個 key 的說明
參數 :encodedKey 二進制編碼的字串 ( 一般能過 PublicKey.getEncoded() 生成 )
javax.crypto.KeyAgreement 密碼一至類
public static final KeyAgreement getInstance(java.lang.String algorithm)
throws java.security.NoSuchAlgorithmException
返回一個指定算法的 KeyAgreement 對象
參數 :algorithm 算法名 , 現在只能是 DiffieHellman(DH)
public final void init(java.security.Key key)
throws java.security.InvalidKeyException
用指定的私鑰初始化
參數 :key 一個私鑰
public final java.security.Key doPhase(java.security.Key key,
boolean lastPhase)
throws java.security.InvalidKeyException,
java.lang.IllegalStateException
用指定的公鑰進行定位 ,lastPhase 確定這是否是最後一個公鑰 , 對於兩個用戶的
情況下就可以多次定次 , 最後確定
參數 :key 公鑰
lastPhase 是否最後公鑰
public final SecretKey generateSecret(java.lang.String algorithm)
throws java.lang.IllegalStateException,
java.security.NoSuchAlgorithmException,
java.security.InvalidKeyException
根據指定的算法生成密鑰
參數 :algorithm 加密算法 ( 可用 DES,DESede,Blowfish)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
|
*/ 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("解密後相同");
}
} |
第 3 章小結
在加密術中生成密鑰對時，密鑰對的當然是越長越好，但費時也越多，請從中從實際出發選取合適的長度，大部分例碼中的密鑰是每次運行就從新生成，在實際的情況中是生成後在一段時間保存在文件中，再次運行直接從文件中讀入，從而加快速度。當然定時更新和加強密鑰保管的安全性也是必須的。
轉載自：https://www.ibm.com/developerworks/cn/java/l-security/
