当前位置导航:炫浪网>>网络学院>>编程开发>>JAVA教程>>Java进阶

谈谈Java加密技术(五)

    接下来我们分析DH加密算法,一种适基于密钥一致协议的加密算法。

    DH

    Diffie-Hellman算法(D-H算法),密钥一致协议。是由公开密钥密码体制的奠基人Diffie和Hellman所提出的一种思想。简单的说就是允许两名用户在公开媒体上交换信息以生成"一致"的、可以共享的密钥。换句话说,就是由甲方产出一对密钥(公钥、私钥),乙方依照甲方公钥产生乙方密钥对(公钥、私钥)。以此为基线,作为数据传输保密基础,同时双方使用同一种对称加密算法构建本地密钥(SecretKey)对数据加密。这样,在互通了本地密钥(SecretKey)算法后,甲乙双方公开自己的公钥,使用对方的公钥和刚才产生的私钥加密数据,同时可以使用对方的公钥和自己的私钥对数据解密。不单单是甲乙双方两方,可以扩展为多方共享数据通讯,这样就完成了网络交互数据的安全通讯!该算法源于中国的同余定理——中国馀数定理。

    流程分析:

    1.甲方构建密钥对儿,将公钥公布给乙方,将私钥保留;双方约定数据加密算法;乙方通过甲方公钥构建密钥对儿,将公钥公布给甲方,将私钥保留。

    2.甲方使用私钥、乙方公钥、约定数据加密算法构建本地密钥,然后通过本地密钥加密数据,发送给乙方加密后的数据;乙方使用私钥、甲方公钥、约定数据加密算法构建本地密钥,然后通过本地密钥对数据解密。

    3.乙方使用私钥、甲方公钥、约定数据加密算法构建本地密钥,然后通过本地密钥加密数据,发送给甲方加密后的数据;甲方使用私钥、乙方公钥、约定数据加密算法构建本地密钥,然后通过本地密钥对数据解密。

    通过java代码实现如下:

import  java.security.Key;   
import  java.security.KeyFactory;   
import  java.security.KeyPair;   
import  java.security.KeyPairGenerator;   
import  java.security.PublicKey;   
import  java.security.spec.PKCS8EncodedKeySpec;   
import  java.security.spec.X509EncodedKeySpec;   
import  java.util.HashMap;   
import  java.util.Map;   
  
import  javax.crypto.Cipher;   
import  javax.crypto.KeyAgreement;   
import  javax.crypto.SecretKey;   
import  javax.crypto.interfaces.DHPrivateKey;   
import  javax.crypto.interfaces.DHPublicKey;   
import  javax.crypto.spec.DHParameterSpec;   
  
/**   
 * DH安全编码组件  
 *   
 * 
@author  梁栋   http://www.bt285.cn   http://www.5a520.cn
 * 
@version  1.0  
 * 
@since  1.0  
 
*/
  
public   abstract   class  DHCoder  extends  Coder  {   
    
public   static   final  String ALGORITHM  =   " DH " ;   
  
    
/**   
     * 默认密钥字节数  
     *   
     * <pre>  
     * DH  
     * Default Keysize 1024    
     * Keysize must be a multiple of 64, ranging from 512 to 1024 (inclusive).  
     * </pre>  
     
*/
  
    
private   static   final   int  KEY_SIZE  =   1024 ;   
  
    
/**   
     * DH加密下需要一种对称加密算法对数据加密,这里我们使用DES,也可以使用其他对称加密算法。  
     
*/
  
    
public   static   final  String SECRET_ALGORITHM  =   " DES " ;   
    
private   static   final  String PUBLIC_KEY  =   " DHPublicKey " ;   
    
private   static   final  String PRIVATE_KEY  =   " DHPrivateKey " ;   
  
    
/**   
     * 初始化甲方密钥  
     *   
     * 
@return   
     * 
@throws  Exception  
     
*/
  
    
public   static  Map < String, Object >  initKey()  throws  Exception  {   
        KeyPairGenerator keyPairGenerator 
=  KeyPairGenerator   
                .getInstance(ALGORITHM);   
        keyPairGenerator.initialize(KEY_SIZE);   
  
        KeyPair keyPair 
=  keyPairGenerator.generateKeyPair();   
  
        
//  甲方公钥   
        DHPublicKey publicKey  =  (DHPublicKey) keyPair.getPublic();   
  
        
//  甲方私钥   
        DHPrivateKey privateKey  =  (DHPrivateKey) keyPair.getPrivate();   
  
        Map
< String, Object >  keyMap  =   new  HashMap < String, Object > ( 2 );   
  
        keyMap.put(PUBLIC_KEY, publicKey);   
        keyMap.put(PRIVATE_KEY, privateKey);   
        
return  keyMap;   
    }
   
  
    
/**   
     * 初始化乙方密钥  
     *   
     * 
@param  key  
     *            甲方公钥  
     * 
@return   
     * 
@throws  Exception  
     
*/
  
    
public   static  Map < String, Object >  initKey(String key)  throws  Exception  {   
        
//  解析甲方公钥   
         byte [] keyBytes  =  decryptBASE64(key);   
        X509EncodedKeySpec x509KeySpec 
=   new  X509EncodedKeySpec(keyBytes);   
        KeyFactory keyFactory 
=  KeyFactory.getInstance(ALGORITHM);   
        PublicKey pubKey 
=  keyFactory.generatePublic(x509KeySpec);   
  
        
//  由甲方公钥构建乙方密钥   
        DHParameterSpec dhParamSpec  =  ((DHPublicKey) pubKey).getParams();   
  
        KeyPairGenerator keyPairGenerator 
=  KeyPairGenerator   
                .getInstance(keyFactory.getAlgorithm());   
        keyPairGenerator.initialize(dhParamSpec);   
  
        KeyPair keyPair 
=  keyPairGenerator.generateKeyPair();   
  
        
//  乙方公钥   
        DHPublicKey publicKey  =  (DHPublicKey) keyPair.getPublic();   
  
        
//  乙方私钥   
        DHPrivateKey privateKey  =  (DHPrivateKey) keyPair.getPrivate();   
  
        Map
< String, Object >  keyMap  =   new  HashMap < String, Object > ( 2 );   
  
        keyMap.put(PUBLIC_KEY, publicKey);   
        keyMap.put(PRIVATE_KEY, privateKey);   
  
        
return  keyMap;   
    }
   
  
    
/**   
     * 加密<br>  
     *   
     * 
@param  data  
     *            待加密数据  
     * 
@param  publicKey  
     *            甲方公钥  
     * 
@param  privateKey  
     *            乙方私钥  
     * 
@return   
     * 
@throws  Exception  
     
*/
  
    
public   static   byte [] encrypt( byte [] data, String publicKey,   
            String privateKey) 
throws  Exception  {   
  
        
//  生成本地密钥   
        SecretKey secretKey  =  getSecretKey(publicKey, privateKey);   
  
        
//  数据加密   
        Cipher cipher  =  Cipher.getInstance(secretKey.getAlgorithm());   
        cipher.init(Cipher.ENCRYPT_MODE, secretKey);   
  
        
return  cipher.doFinal(data);   
    }
   
  
    
/**   
     * 解密<br>  
     *   
     * 
@param  data  
     *            待解密数据  
     * 
@param  publicKey  
     *            乙方公钥  
     * 
@param  privateKey  
     *            乙方私钥  
     * 
@return   
     * 
@throws  Exception  
     
*/
  
    
public   static   byte [] decrypt( byte [] data, String publicKey,   
            String privateKey) 
throws  Exception  {   
  
        
//  生成本地密钥   
        SecretKey secretKey  =  getSecretKey(publicKey, privateKey);   
        
//  数据解密   
        Cipher cipher  =  Cipher.getInstance(secretKey.getAlgorithm());   
        cipher.init(Cipher.DECRYPT_MODE, secretKey);   
  
        
return  cipher.doFinal(data);   
    }
   
  
    
/**   
     * 构建密钥  
     *   
     * 
@param  publicKey  
     *            公钥  
     * 
@param  privateKey  
     *            私钥  
     * 
@return   
     * 
@throws  Exception  
     
*/
  
    
private   static  SecretKey getSecretKey(String publicKey, String privateKey)   
            
throws  Exception  {   
        
//  初始化公钥   
         byte [] pubKeyBytes  =  decryptBASE64(publicKey);   
  
        KeyFactory keyFactory 
=  KeyFactory.getInstance(ALGORITHM);   
        X509EncodedKeySpec x509KeySpec 
=   new  X509EncodedKeySpec(pubKeyBytes);   
        PublicKey pubKey 
=  keyFactory.generatePublic(x509KeySpec);   
  
        
//  初始化私钥   
         byte [] priKeyBytes  =  decryptBASE64(privateKey);   
  
        PKCS8EncodedKeySpec pkcs8KeySpec 
=   new  PKCS8EncodedKeySpec(priKeyBytes);   
        Key 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;   
    }
   
  
    
/**   
     * 取得私钥  
     *   
     * 
@param  keyMap  
     * 
@return   
     * 
@throws  Exception  
     
*/
  
    
public   static  String getPrivateKey(Map < String, Object >  keyMap)   
            
throws  Exception  {   
        Key key 
=  (Key) keyMap.get(PRIVATE_KEY);   
  
        
return  encryptBASE64(key.getEncoded());   
    }
   
  
    
/**   
     * 取得公钥  
     *   
     * 
@param  keyMap  
     * 
@return   
     * 
@throws  Exception  
     
*/
  
    
public   static  String getPublicKey(Map < String, Object >  keyMap)   
            
throws  Exception  {   
        Key key 
=  (Key) keyMap.get(PUBLIC_KEY);   
  
        
return  encryptBASE64(key.getEncoded());   
    }
   
}

共2页 首页 上一页 1 2 下一页 尾页 跳转到
相关内容
赞助商链接