当柳上原的风吹向天际的时候...

真正的快乐来源于创造

  BlogJava :: 首页 :: 联系 :: 聚合  :: 管理
  368 Posts :: 1 Stories :: 201 Comments :: 0 Trackbacks
按:下面的文字涉及早已在工程中广泛采用的混合加密方式,对此熟知者就不用往下看了,以免浪费时间。

我们知道,现代加密方式有两大类:一类是对称加密方式,其优点是加密速度快,缺点是密钥不便于传递,其中典型代表是AES;一类是非对称加密方式,优点是交换钥匙方便,缺点是加密时间长,代表是RSA。在实际应用,我们可以取其所长,弃其所短,这就是混合加密方式,有的场合也成为Hybrid方式。

具体来说混合加密方式的工作过程大体是这样:首先,客户端将明文用本地的AES钥匙加密,然后从服务器端得到服务器端的RSA公钥,用它来对本地的AES钥匙加密,然后把两端密文拼合在一起送给服务器端;服务器端得到密文后,将其拆分成密钥文和密文两段,然后,用本地的RSA私钥对密钥文进行解密,得到加密密文的AES钥匙,然后用AES钥匙对密文解密,得到明文。在此过程中,对明文加密和对密文解密都采用了对称加密解密方式,速度快,且都在服务器客户机的一侧进行,没有通过网络传输,安全性高;而网络传输的是服务器的RSA公钥和经其加密的AES钥匙,即使被截获也没有什么好担心的。如果要双向传递则把这个过程反过来就可以了。

以上过程的示意UML SEQUENCE图如下:



下面用代码来辅助说明一下。

客户端进行加密并传输密文到服务器端的代码,其中,服务器端的RSA公钥已经用别的方法得到了,下面serverPublicKey变量就存储了它:
        Socket s=new Socket("127.0.0.1",8888);
        
        InputStream  inStram
=s.getInputStream();
        OutputStream outStream
=s.getOutputStream();
        
        
// 输出
        PrintWriter out=new PrintWriter(outStream,true);
        
        
// 待加密的明文
        StringBuilder sb1=new StringBuilder();
        sb1.append(
"<request>");
        sb1.append(
"<command>register</command>");
        sb1.append(
"<username>何杨</username>");
        sb1.append(
"<password>123456</password>");
        sb1.append(
"</request>");
        String plainText
=sb1.toString();
        
        
// 对明文进行AES加密
        byte[] aesArr=aesCoder.getEncryptByteArray(plainText); // 对明文进行AES加密
        String cipherText=Base64.encodeBase64String(aesArr);// 得到AES加密后的密文
        
        
// 使用RSA对AES密钥进行加密
        String key=aesCoder.getAesKey();// 取得AES的密钥
        byte[] rsaArr=rsaCoder.getEncryptArray(key, serverPublicKey);
        String encryptedKey
=Base64.encodeBase64String(rsaArr);
        
        
// 在发出的密文前附带经服务器RSA公钥加密的AES密钥
        String request="<key>"+encryptedKey+"</key>"+cipherText;
        
        out.print(request);
        out.flush();
        s.shutdownOutput();
// 输出结束

从上面这段代码可以看出,想发送到服务器端的明文是:
<request><command>register</command><username>何杨</username><password>123456</password></request>

通过这段代码的处理后,最终发送到服务器端的密文是,
<key>1B2FM07HS4iB+vjeehb/RqHTnEXAr1cj/CR6z+SDPI58ZG5TK54iEoi8cvdIL0oj60X7axrAL3YO
b6PMzQxKHzipSYw3ishH/3KxoYF8bkQGn2PkMNsn+xL1Gz6XgJcQ+B700hYvVT2FFPfelVz3VNlB
KhwVIE6h8LyD4w/SxhE=
</key>J4TsMoB3l8Cy91a9v6O0TADXZvKEkDPZ3E5noeu2dImfdsM55urhEY7lFAAsXm0AB4/jUL1h1lNP
cafz9srORh7h8NCb4760XnrBA5Q2JQrqwr1TGsB3oGq2Ha+FOLoFcI2Ab/wjEiAhe/kB6ZTgTA==
其中key节点的内容是加密的AES密钥,后面是AES加密后的密文。如果这段文字在网络上被截获,截获者可能会猜测出key节点是密钥,后半段是密文,但密钥部分是被服务器的公钥进行RSA加密的,只有用服务器的私钥来解密;而密钥文解不出来的话,截获者对后端密文也是无能为力。这就可以让人放心了,如果服务器端没有潜伏一个余则成和截获者里应外合的话。这里还可以把整段文字用Base64加密一下,到服务器再解密。

服务器端的处理代码:
        String cipheredAesKey="";// 经服务器RSA公钥加密的客户端AES钥匙密文
        String cipherText="";// 经客户端AES加密的密文
        
        
// 用正则表达式得到密钥文和密文
        String regex="<key>(.+)</key>(.+)";
        Pattern pattern
=Pattern.compile(regex);
        Matcher matcher
=pattern.matcher(request);
            
        
while(matcher.find()){
            cipheredAesKey
=matcher.group(1);
            cipherText
=matcher.group(2);
            
break;
        }

        
// 得到经过服务器RSA私钥解密后的AES密钥
        String plainAesKey="";
        
try {
            
byte[] cipheredAesKeyArr=Base64.decodeBase64(cipheredAesKey);
            plainAesKey
=model.getRsaCoder().getDecryptString(cipheredAesKeyArr);
        } 
catch (Exception e) {
            e.printStackTrace();
            
return null;
        }
        
        
// 使用AES密钥解密出明文
        byte[] cipherTextArr=Base64.decodeBase64(cipherText);
        String plainText
=model.getAesCoder().getDecryptString(cipherTextArr, plainAesKey);

这段代码的输入是:
<key>P9SQ2DtWqrdH3hJbQNWRb51OEs9c7KpsgjRg0yPT5LZJoqJBeYmq3r/1T050n136OelvTh+XtaZaXbCJAvfnF4fvtAKdXqPp+lzUNgPYk8R0OaVDUIi8pNi1rb/+GvtY2ZucFYL1BOwO8ARwvXf8f52Cl+Vdu5TdinXVjmwSPZY=</key>u0ube9sy7bsIy8aaUSJofoswY+R3WXD8yJbOzEZWiDniyXNNyrHNiygfRHj3TKwVQXRck/OVPXptMvUjCVqmg118TN0tc4sKoOKHaSmUtvGC2WW3K5anxlFzdUIZMIhvpDF1nWoaTXvEJ1nOuwhIig==
它和客户端传过来的内容是一样的。

而经过拆分和解密后,AES密钥是:
83aeacfa1b59eb2dc557a9f3d5df6af83ee9a1646652f1d2b55ea6ec76a95bde

用得到的AES密钥解密后,最终得到的明文部分是:
<request><command>register</command><username>何杨</username><password>123456</password></request>

到这里,密文的还原工作就完成了。如果服务器端要向客户端发回处理后的结果,把上述过程再做一遍就可以了,注意一点,客户端要把自己的RSA公钥发过来,也就是说传递的文本中还要增加一个节点,这样服务器端就有了客户端的RSA公钥对服务器端的AES钥匙进行加密。(完整混合加密客户机服务器通讯过程请参看:http://www.blogjava.net/heyang/archive/2010/12/26/341556.html

这种方式看似比纯RSA方式和AES方式都复杂了一点,但考虑到网络传输的安全性和速度,多写一些代码是完全值得的。

上文中用到的AESSecurityCoder类代码如下:
package com.heyang.common.code;

import java.security.Key;
import java.security.NoSuchAlgorithmException;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

import org.apache.commons.codec.binary.Hex;


/**
 * AES加密解密类
 * 说明:
 * 作者:何杨(heyang78@gmail.com)
 * 创建时间:2010-12-25 下午12:19:12
 * 修改时间:2010-12-25 下午12:19:12
 
*/
public class AESSecurityCoder{
    
// 加密方法
    private static final String Algorithm="AES";
    
    
// 进行加密解密的密钥
    private String aesKey="";
    
    
/**
     * 构造函数
     * 
@throws NoSuchAlgorithmException 
     
*/
    
public AESSecurityCoder() throws NoSuchAlgorithmException{
        KeyGenerator kg
=KeyGenerator.getInstance(Algorithm);
        kg.init(
256);
        SecretKey sk
=kg.generateKey();
        
byte[] arr=sk.getEncoded();
        
        aesKey
=new String(Hex.encodeHex(arr));
    }
    
    
/**
     * 取得解密后的字符串
     * 
     * 说明:
     * 
@param encryptArr
     * 
@return
     * 创建时间:2010-12-1 下午03:33:31
     
*/
    
public String getDecryptString(byte[] encryptArr){
        
try{
            Cipher cp
=Cipher.getInstance(Algorithm);
            cp.init(Cipher.DECRYPT_MODE, getKey());
            
byte[] arr=cp.doFinal(encryptArr);
            
            
return new String(arr);
        }
        
catch(Exception ex){
            System.out.println(
"无法进行解密,原因是"+ex.getMessage());
            
return null;
        }
    }
    
    
/**
     * 传入密钥,得到解密后的字符串
     * 
     * 说明:
     * 
@param encryptArr
     * 
@param aesKey
     * 
@return
     * 创建时间:2010-12-25 下午01:55:42
     
*/
    
public String getDecryptString(byte[] encryptArr,String aesKeyIn){
        
try{
            Cipher cp
=Cipher.getInstance(Algorithm);
            
            
byte[] arr1=Hex.decodeHex(aesKeyIn.toCharArray());
            cp.init(Cipher.DECRYPT_MODE, 
new SecretKeySpec(arr1,Algorithm));
            
byte[] arr=cp.doFinal(encryptArr);
            
            
return new String(arr);
        }
        
catch(Exception ex){
            System.out.println(
"无法进行解密,原因是"+ex.getMessage());
            
return null;
        }
    }
    
    
/**
     * 取得加密后的字节数组
     * 
     * 说明:
     * 
@param originalString
     * 
@return
     * 创建时间:2010-12-1 下午03:33:49
     
*/
    
public byte[] getEncryptByteArray(String originalString){
        
try{
            Cipher cp
=Cipher.getInstance(Algorithm);
            cp.init(Cipher.ENCRYPT_MODE, getKey());
            
return cp.doFinal(originalString.getBytes());
        }
        
catch(Exception ex){
            System.out.println(
"无法进行加密,原因是"+ex.getMessage());
            
return null;
        }
    }
    
    
/**
     * 取得密钥
     * 
     * 说明:
     * 
@return
     * 
@throws Exception
     * 创建时间:2010-12-1 下午03:33:17
     
*/
    
private Key getKey() throws Exception{
        
byte[] arr=Hex.decodeHex(aesKey.toCharArray());
        
        
return new SecretKeySpec(arr,Algorithm);
    }

    
/**
     * 取得AES加密钥匙
     * 
     * 说明:
     * 
@return
     * 创建时间:2010-12-25 下午12:27:16
     
*/
    
public String getAesKey() {
        
return aesKey;
    }
}

上文中用到的RSASecurityCoder类代码如下:
package com.heyang.common.code;

import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

import javax.crypto.Cipher;

import org.apache.commons.codec.binary.Base64;

/**
 * RSA加密解密类
 * 说明:
 * 作者:何杨(heyang78@gmail.com)
 * 创建时间:2010-12-1 下午06:14:38
 * 修改时间:2010-12-1 下午06:14:38
 
*/
public class RSASecurityCoder{
    
// 非对称加密密钥算法
    private static final String Algorithm="RSA";
    
    
// 密钥长度,用来初始化
    private static final int Key_Size=1024;
    
    
// 公钥
    private byte[] publicKey;
    
    
// 私钥
    private byte[] privateKey;
    
    
/**
     * 构造函数,在其中生成公钥和私钥
     * 
@throws Exception
     
*/
    
public RSASecurityCoder() throws Exception{
        
// 得到密钥对生成器
        KeyPairGenerator kpg=KeyPairGenerator.getInstance(Algorithm);
        kpg.initialize(Key_Size);
        
        
// 得到密钥对
        KeyPair kp=kpg.generateKeyPair();
        
        
// 得到公钥
        RSAPublicKey keyPublic=(RSAPublicKey)kp.getPublic();
        publicKey
=keyPublic.getEncoded();
        
        
// 得到私钥
        RSAPrivateKey keyPrivate=(RSAPrivateKey)kp.getPrivate();
        privateKey
=keyPrivate.getEncoded();
    }
    
    
/**
     * 用公钥对字符串进行加密
     * 
     * 说明:
     * 
@param originalString
     * 
@param publicKeyArray
     * 
@return
     * 
@throws Exception
     * 创建时间:2010-12-1 下午06:29:51
     
*/
    
public byte[] getEncryptArray(String originalString,byte[] publicKeyArray) throws Exception{
        
// 得到公钥
        X509EncodedKeySpec keySpec=new X509EncodedKeySpec(publicKeyArray);
        KeyFactory kf
=KeyFactory.getInstance(Algorithm);
        PublicKey keyPublic
=kf.generatePublic(keySpec);
        
        
// 加密数据
        Cipher cp=Cipher.getInstance(Algorithm);
        cp.init(Cipher.ENCRYPT_MODE, keyPublic);
        
return cp.doFinal(originalString.getBytes());
    }
    
    
    
/**
     * 使用私钥进行解密
     * 
     * 说明:
     * 
@param encryptedDataArray
     * 
@return
     * 
@throws Exception
     * 创建时间:2010-12-1 下午06:35:28
     
*/
    
public String getDecryptString(byte[] encryptedDataArray) throws Exception{
        
// 得到私钥
        PKCS8EncodedKeySpec keySpec=new PKCS8EncodedKeySpec(privateKey);
        KeyFactory kf
=KeyFactory.getInstance(Algorithm);
        PrivateKey keyPrivate
=kf.generatePrivate(keySpec);
        
        
// 解密数据
        Cipher cp=Cipher.getInstance(Algorithm);
        cp.init(Cipher.DECRYPT_MODE, keyPrivate);
        
byte[] arr=cp.doFinal(encryptedDataArray);
        
        
// 得到解密后的字符串
        return new String(arr);
    }

    
/**
     * 取得数组形式的公钥
     * 
     * 说明:
     * 
@return
     * 创建时间:2010-12-25 上午07:50:04
     
*/
    
public byte[] getPublicKey() {
        
return publicKey;
    }
    
    
/**
     * 取得字符串形式的公钥
     * 
     * 说明:
     * 
@return
     * 创建时间:2010-12-25 上午07:51:11
     
*/
    
public String getPublicKeyString() {
        
return  Base64.encodeBase64String(getPublicKey());
    }
    
    
public static void main(String[] arr) throws Exception{
        String str
="你好,世界! Hello,world!";
        System.out.println(
"准备用公钥加密的字符串为:"+str);
        
        
// 用公钥加密
        RSASecurityCoder rsaCoder=new RSASecurityCoder();
        
byte[] publicKey=rsaCoder.getPublicKey();        
        
byte[] encryptArray=rsaCoder.getEncryptArray(str, publicKey);
        
        System.out.print(
"用公钥加密后的结果为:");
        
for(byte b:encryptArray){
            System.out.print(b);
        }
        System.out.println();
        
        
// 用私钥解密
        String str1=rsaCoder.getDecryptString(encryptArray);
        System.out.println(
"用私钥解密后的字符串为:"+str1);
    }
}

好了,感谢您看到这里,希望它没有太多耽误您的宝贵时间。
posted on 2010-12-25 16:02 何杨 阅读(4051) 评论(6)  编辑  收藏

Feedback

# re: 在网络通讯中采用混合方式对信息进行加密 2010-12-25 21:20 Michaelsong
加密解密,大学专业是信息安全,要好好学学……  回复  更多评论
  

# re: 在网络通讯中采用混合方式对信息进行加密[未登录] 2012-06-11 00:29 Tim
对我有用。。十分感谢。谢谢  回复  更多评论
  

# re: 在网络通讯中采用混合方式对信息进行加密 2014-01-17 11:26 无敌3
请问楼主,服务器存储的公钥密钥对只有一个,还是根据客户端发来的随机数生成针对这个用户的公钥密钥对  回复  更多评论
  

# re: 在网络通讯中采用混合方式对信息进行加密 2014-11-29 20:59 Zagfai
还不是跟https一个原理  回复  更多评论
  

# re: 在网络通讯中采用混合方式对信息进行加密 2016-07-04 12:58 #123
还在 不
?
  回复  更多评论
  

# re: 在网络通讯中采用混合方式对信息进行加密 2016-07-04 12:59 #123
你给的那个程序 代码链接 打不开了
是不是 失效了 能不能再给个   回复  更多评论
  


只有注册用户登录后才能发表评论。


网站导航: