/*
 * 密钥交换算法，即非对称加密算法
 * */
public 
class 
DHCoder {
        
//非对称加密算法
        
public 
static 
final 
String 
KEY_ALGORITHM
= 
“DH”
;
        
//本地密钥算法，即对称加密算法
        
public 
static 
final 
String 
SECRET_ALGORITHM
= 
“AES”
;
        
private
  
static 
final 
int 
KEY_SIZE
=512;
        
//公钥
        
private 
static 
final 
String 
PUBLIC_KEY
= 
“DHPublicKey”
;
        
//私钥
        
private 
static 
final 
String 
PRIVATE_KEY
= 
“DHPrivateKey”
;
       
        
//初始化甲方密钥
        
public 
static 
Map<String,Object> initKey() 
throws 
Exception{
               
//密钥对生成器
              KeyPairGenerator keyPairGenerator=KeyPairGenerator.getInstance( 
KEY_ALGORITHM
);
              keyPairGenerator.initialize( 
KEY_SIZE
);
              KeyPair keyPair=keyPairGenerator.generateKeyPair();
              
               
//甲方公钥
              DHPublicKey publicKey=(DHPublicKey)keyPair.getPublic();
               
//甲方私钥
              DHPrivateKey privateKey=(DHPrivateKey)keyPair.getPrivate();
              
               
//将密钥对存储在Map中
              Map<String,Object> keyMap= 
new 
HashMap<String,Object>(2);
              keyMap.put( 
PUBLIC_KEY
,publicKey);
              keyMap.put( 
PRIVATE_KEY
,privateKey);
               
return 
keyMap;
       }
       
       
        
//乙方密钥
        
public 
static 
Map<String,Object> initKey(
byte
[] key) 
throws 
Exception{
               
//解析甲方公钥，转换公钥规范
              X509EncodedKeySpec x509KeySpec= 
new 
X509EncodedKeySpec(key);
              KeyFactory keyFactory=KeyFactory. getInstance(
KEY_ALGORITHM
);
               
//产生甲方公钥
              PublicKey publicKey=keyFactory.generatePublic(x509KeySpec);
              
               
//由甲方公钥构建乙方密钥对
              DHParameterSpec dhParamSpec=((DHPublicKey)publicKey).getParams();
              KeyPairGenerator keyPairGenerator=KeyPairGenerator.getInstance(keyFactory.getAlgorithm());
              keyPairGenerator.initialize(dhParamSpec);
              
               
//产生密钥对
              KeyPair keyPair=keyPairGenerator.generateKeyPair();
               
//乙方公钥
              DHPublicKey publicKey1=(DHPublicKey)keyPair.getPublic();
               
//乙方私钥
              DHPrivateKey privateKey1=(DHPrivateKey)keyPair.getPrivate();
              
               
//将密钥存储在Map中
              Map<String,Object> keyMap= 
new 
HashMap<String,Object>(2);
              keyMap.put( 
PRIVATE_KEY
, privateKey1);
              keyMap.put( 
PUBLIC_KEY
, publicKey1);
               
return 
keyMap;
       }
       
       
        
//加密
        
public 
static 
byte
[] encrypt(
byte
[] data, 
byte
[] key) 
throws 
Exception, GeneralSecurityException{
               
//生成本地密钥
              SecretKey secretKey= 
new 
SecretKeySpec(key, 
SECRET_ALGORITHM
);
               
//加密数据
              Cipher cipher=Cipher. getInstance(secretKey.getAlgorithm());
              cipher.init(Cipher. 
ENCRYPT_MODE
, secretKey);
               
return 
cipher.doFinal(data);
       }
       
        
//解密
        
public 
static 
byte
[] decrypt(
byte
[] data, 
byte
[] key) 
throws 
Exception, NoSuchPaddingException{
               
//生成本地密钥
              SecretKey secretKey= 
new 
SecretKeySpec(key, 
SECRET_ALGORITHM
);
              Cipher cipher=Cipher. getInstance(secretKey.getAlgorithm());
              cipher.init(Cipher. 
DECRYPT_MODE
, secretKey);
               
return 
cipher.doFinal(data);
       }
       
        
//由公钥，私钥，构建本地密钥
        
public 
static 
byte
[] getSecretKey(
byte
[] publicKey, 
byte
[] privateKey) 
throws 
Exception{
              KeyFactory keyFactory=KeyFactory. getInstance(
KEY_ALGORITHM
);
               
//初始化公钥
              X509EncodedKeySpec x509EncodedKeySpec= 
new 
X509EncodedKeySpec(publicKey);
               
//产生公钥
              PublicKey pubKey=keyFactory.generatePublic(x509EncodedKeySpec);
              
               
//初始化私钥，密钥规范转换
              PKCS8EncodedKeySpec pkcs8KeySpec= 
new 
PKCS8EncodedKeySpec(privateKey);
               
//产生私钥
              PrivateKey priKey=keyFactory.generatePrivate(pkcs8KeySpec);
              
               
//实例化
              KeyAgreement keyAgree=KeyAgreement.getInstance(keyFactory.getAlgorithm());
              keyAgree.init(priKey);
              keyAgree.doPhase(pubKey, 
true
);
              
               
//生成本地密钥
              SecretKey secretKey=keyAgree.generateSecret( 
SECRET_ALGORITHM
);
               
return 
secretKey.getEncoded();
       }
       
        
//取得私钥
        
public 
static 
byte
[] getPrivateKey(Map<String,Object> keyMap){
              Key key=(Key)keyMap.get( 
PRIVATE_KEY
);
               
return 
key.getEncoded();
       }
        
//取得公钥
        
public 
static 
byte
[] getPublicKey(Map<String,Object> keyMap){
              Key key=(Key)keyMap.get( 
PUBLIC_KEY
);
               
return 
key.getEncoded();
       }
}


验证===


public 
class 
DHCoderTest {


        
//初始化密钥
        
public 
final 
void 
initKey() 
throws 
Exception{


       }
       
        
public 
static 
void 
main(String[] args) 
throws 
Exception {
               
// 
TODO 
Auto-generated method stub
              
               
/*
               * 需要关注，甲乙双方本地密钥是否相同；一方加密，另一方是否可以解密
               */ 
    


               
//甲方公钥
               
byte
[] publicKey1;
               
//甲方私钥
               
byte
[] privateKey1;
               
//甲方本地密钥
               
byte
[] key1;
              
               
//乙方公钥
               
byte
[] publicKey2;
               
//一方私钥
               
byte
[] privateKey2;
               
//一方本地密钥
               
byte
[] key2;
              
               
//生成甲方密钥对
              Map<String,Object> keyMap1=DHCoder. initKey();
              privateKey1=DHCoder. getPrivateKey(keyMap1);
              publicKey1=DHCoder. getPublicKey(keyMap1);
              System. 
out
.println(
“甲方公钥：\n” 
+Base64.encodeBase64String (publicKey1));
              System. 
out
.println(
“甲方私钥：\n” 
+Base64.encodeBase64String (privateKey1));
              
               
//由甲方产生乙方密钥对
              Map<String,Object> keyMap2=DHCoder. initKey(publicKey1);
              publicKey2=DHCoder. getPublicKey(keyMap2);
              privateKey2=DHCoder. getPrivateKey(keyMap2);
              System. 
out
.println(
“乙方公钥：\n” 
+Base64.encodeBase64String (publicKey2));
              System. 
out
.println(
“乙方私钥：\n” 
+Base64.encodeBase64String (privateKey2));
              
               
//甲方私钥，乙方公钥，构造本地密钥
              key1=DHCoder. getSecretKey(publicKey2, privateKey1);
              System. 
out
.println(
“甲方本地密钥：\n” 
+Base64.encodeBase64String (key1));
              
               
//乙方私钥，甲方公钥，构造本地密钥
              key2=DHCoder. getSecretKey(publicKey1, privateKey2);
              System. 
out
.println(
“乙方本地密钥：\n” 
+Base64.encodeBase64String (key2));
              
               
//校验
               assertArrayEquals(key1,key2);
       }


}