`

一个完整的混合加密方式在Socket客户机服务器通信应用中的例子

    博客分类：
  • java
应用服务器Socket正则表达式SecurityGmail 
阅读更多

按：前面(http://www.blogjava.net/heyang/archive/2010/12/25/341518.html)已经提到过混合加密方式，今天这里再来赘述一下完成的代码和流程，熟悉者就不用往下看了。

整个流程的UML Sequence图（Amaterus UML用得还不熟练请见谅，会意就好）


下面是以上八个步骤中使用到的代码和信息。

步骤一：
取得服务器端RSA公钥的Socket通信代码：

    public static byte[] getPublicKey() throws Exception{
        Socket s=new Socket("127.0.0.1",8888);
        
        InputStream  inStram=s.getInputStream();
        OutputStream outStream=s.getOutputStream();
        
        // 输出
        PrintWriter out=new PrintWriter(outStream,true);
        
        out.print("getPublicKey");
        out.flush();

        s.shutdownOutput();// 输出结束
        
        // 输入
        Scanner in=new Scanner(inStram);
        StringBuilder sb=new StringBuilder();
        while(in.hasNextLine()){
            String line=in.nextLine();
            sb.append(line);
        }
        String response=sb.toString();
        
        byte[] arr=Base64.decodeBase64(response);
        
        s.close();
        return arr;
    }

步骤二：
客户端加密过程代码：
        // 待加密的明文
        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);

步骤三：
将密文，AES密钥，本地RSA公钥送到服务器端的代码(粗体部分)：
        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密钥
        StringBuilder sb3=new StringBuilder();
        sb3.append("<aeskey>"+encryptedKey+"</aeskey>");
        sb3.append("<rsakey>"+rsaCoder.getPublicKeyString()+"</rsakey>");
        sb3.append("<text>"+cipherText+"</text>");
        
        // 请求送出前用Base64加密
        String request=Base64SecurityUtil.getEncryptString(sb3.toString());
      
        out.print(request);
       out.flush();
       s.shutdownOutput();// 输出结束

步骤四：
服务器端解密过程代码（变量request中就是客户端送来的请求文）：
       // 得到请求后先用Base64解密
        request=Base64SecurityUtil.getDecryptString(request);
        
        // 用正则表达式得到密钥文，客户端的RSA公钥和密文
        String regex="<(\\w+)>((.|\\s)+)</\\1>";

        Pattern pattern=Pattern.compile(regex);
        Matcher matcher=pattern.matcher(request);
            
        String cipheredAesKey="";// 经服务器RSA公钥加密的客户端AES钥匙密文
        String clientRsaKey="";// 客户端的RSA公钥
        String cipherText="";// 经客户端AES加密的密文
        
        Map<String,String> map=new HashMap<String,String>();
        while(matcher.find()){
            map.put(matcher.group(1), matcher.group(2));
        }
        
        if(map.size()==3){
            cipheredAesKey=map.get("aeskey");
            clientRsaKey=map.get("rsakey");
            cipherText=map.get("text");
        }
        else{
            return "无法用正则表达式解析服务器端请求";
        }

        // 得到经过服务器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);

步骤五：
这里的主要操作是根据看用户名是否在用户列表中存在，是则创建用户，否则告知名称重复。这段代码很简单常见，故省略之。

步骤六：
服务器端加密过程代码：
        // 对明文进行AES加密
        byte[] aesArr=model.getAesCoder().getEncryptByteArray(retval); // 对明文进行AES加密
        String cipherRetval=Base64.encodeBase64String(aesArr);// 得到AES加密后的密文
        
        // 使用RSA对AES密钥进行加密
        String key=model.getAesCoder().getAesKey();// 取得AES的密钥
        String aesKey="";
        try{
            byte[] clientRsaKeyArr=null;
            clientRsaKeyArr=Base64.decodeBase64(clientRsaKey);
            byte[] rsaArr=model.getRsaCoder().getEncryptArray(key, clientRsaKeyArr);
            aesKey=Base64.encodeBase64String(rsaArr);
        }
        catch(Exception ex){
            ex.printStackTrace();
        }
        
        // 在发出的密文前附带经服务器RSA公钥加密的AES密钥
        StringBuilder sb3=new StringBuilder();
        sb3.append("<aeskey>"+aesKey+"</aeskey>");
        sb3.append(cipherRetval);

步骤七：
将响应发还给客户端的代码（粗体部分）：
            InputStream  inStram=incoming.getInputStream();
            OutputStream outStream=incoming.getOutputStream();
            
            Scanner in=new Scanner(inStram);
            PrintWriter out=new PrintWriter(outStream,true);
            
            // 得到客户端的请求
            StringBuilder sb=new StringBuilder();
            while(in.hasNextLine()){
                String line=in.nextLine();
                sb.append(line);
            }
            
            
            String request=sb.toString();
            String response="";
            if("getPublicKey".equals(request)){
                // 求服务器公钥
                response=model.getPublicKey();
            }
            else{
                response=getResponse(request);
            }
            
            // 向客户端送出反馈
            out.print(response);
            out.flush();
            out.close();

步骤八：
客户端解密服务器端响应的过程：
        String cipheredAesKey="";// 经服务器RSA公钥加密的客户端AES钥匙密文
        String cipheredResponse="";// 经客户端AES加密的密文
        
        // 用正则表达式得到密钥文，客户端的RSA公钥和密文
        String regex="<aeskey>(.+)</aeskey>(.+)";
        Pattern pattern=Pattern.compile(regex);
        Matcher matcher=pattern.matcher(response);
            
        while(matcher.find()){
            cipheredAesKey=matcher.group(1);
            cipheredResponse=matcher.group(2);
            break;
        }
        
        // 得到经过服务器RSA私钥解密后的AES密钥
        String plainAesKey="";
        try {
            byte[] cipheredAesKeyArr=Base64.decodeBase64(cipheredAesKey);
            plainAesKey=rsaCoder.getDecryptString(cipheredAesKeyArr);
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        // 使用AES密钥解密出明文
        byte[] cipheredResponseArr=Base64.decodeBase64(cipheredResponse);
        String plainResponse=aesCoder.getDecryptString(cipheredResponseArr, plainAesKey);
        System.out.println(plainResponse);

好了，整个过程的代码都贴出来了，感谢您花费宝贵时间看到这里。另外三个加密解密类的代码如下：
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);
    }
}

Base64SecurityUtil类：
package com.heyang.common.code;

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


/**
 * 常规Base64加密解密实用工具类
 * 说明：
 * 作者：何杨(heyang78@gmail.com)
 * 创建时间：2010-11-29 上午07:52:01
 * 修改时间：2010-11-29 上午07:52:01
 */
public class Base64SecurityUtil{
    /**
     * 得到Base64加密后的字符串
     * 
     * 说明：
     * @param originalString
     * @return
     * 创建时间：2010-11-29 上午07:53:30
     */
    public static String getEncryptString(String originalString){
        byte[] arr = Base64.encodeBase64(originalString.getBytes(), true);
        return new String(arr);
    }
    
    /**
     * 得到Base64解密后的字符串
     * 
     * 说明：
     * @param encryptString
     * @return
     * 创建时间：2010-11-29 上午07:56:02
     */
    public static String getDecryptString(String encryptString){
        byte[] arr = Base64.decodeBase64(encryptString.getBytes());
        return new String(arr);
    }
    
    /**
     * 测试
     * 
     * 说明：
     * @param args
     * 创建时间：2010-11-29 上午07:56:39
     */
    public static void main(String[] args){
        String str="Hello world!你好，世界。";
        
        String str1=Base64SecurityUtil.getEncryptString(str);
        System.out.println("经Base64加密后的密文为"+str1);
        
        String str2=Base64SecurityUtil.getDecryptString(str1);
        System.out.println("经Base64解密后的原文为"+str2);
        
    }
}

 

http://www.blogjava.net/heyang/archive/2010/12/26/341556.html

分享到：
| 在网络通讯中采用混合方式对信息进行加密
评论
1 楼 ly8666 2012-06-11  
十分感谢。。谢谢
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    C# AES加密Socket通信

    在IT行业中，网络通信是软件开发中的重要组成部分，特别是在分布式系统和互联网应用中。C#是一种广泛用于构建桌面和Web应用程序的.NET编程语言，它提供了强大的网络通信支持。本篇文章将详细探讨C#中如何使用AES加密...

    Socket通信Des加密笔记

    在实际应用中，结合Socket和DES加密，可以构建安全的客户端-服务器通信，尤其在Android和Java跨平台交互时，这种组合非常常见。在使用时，注意处理网络异常、管理连接和密钥安全，以确保通信的稳定性和数据的安全性...

    java socket使用加密协议传输对象

    在Java中，SSLSocket是Socket的一个子类，专门用于支持SSL/TLS加密的网络通信。下面，我们将详细介绍如何在Java Socket中使用SSLSocket来传输加密的对象： 1. **创建SSLSocket实例** 首先，我们需要使用`...

    juyuwang.rar_MFC socket 加密_加密客户_服务器 加密_聊天 加密 c_聊天加密

    在IT领域，尤其是在网络通信和安全方面，"juyuwang.rar_MFC socket 加密_加密客户_服务器 加密_聊天 加密 c_聊天加密"这个主题涉及到的是使用MFC（Microsoft Foundation Classes）库和Socket编程来实现一个局域网内...

    Socket加密通信 socket communication development

    Socket加密通信是网络编程中的一个重要话题，特别是在当前网络安全日益重要的背景下。Socket是互联网协议栈中的一种基础通信机制，它允许应用程序通过网络进行双向通信。在本文中，我们将深入探讨Socket通信的发展，...

    客户机和服务器连接

    本文将详细解析标题“客户机和服务器连接”中的关键知识点，并结合标签"java"来探讨Java语言在实现客户端-服务器通信中的应用。 首先，客户机和服务器的连接通常涉及到TCP/IP协议，这是一种面向连接的、可靠的传输...

    C# Socket Udp 通信服务器端(控制台应用程序)

    本资源"**C# Socket Udp 通信服务器端(控制台应用程序)**"提供了C#语言实现的UDP通信服务器端代码，它是一个基于控制台的应用程序，特别适用于学习和开发UDP相关项目。本地端口设置为10000，意味着服务器将在该端口...

    C# SOCKET加密文件消息传输通信

    在IT行业中，网络通信是至关重要的一个领域，而C#作为一种强大的编程语言，常常被用于构建网络应用。本文将深入探讨“C# SOCKET加密文件消息传输通信”这一主题，包括其核心概念、实现方法以及相关技术。 首先，...

    Windows mobile 5.0的经典客户机、服务器Socket通信实例

    - Socket是网络通信中的一个端点，它代表了应用程序到网络协议栈的接口，允许应用层与传输层进行交互。 - 在Windows Mobile 5.0中，我们可以使用Winsock（Windows Sockets）API来实现Socket通信。 2. **TCP/IP...

    安卓socket通信客户端与服务器端

    - **安全性**：在实际应用中，应考虑使用SSL/TLS来加密Socket通信，防止数据在传输过程中被窃取或篡改。 - **性能优化**：通过合理设置缓冲区大小、使用NIO（非阻塞I/O）和线程池等技术，可以提高Socket通信的效率...

    iphone Socket通信例子

    6. **安全考虑**：在实际应用中，为了保护用户隐私和数据安全，可能需要使用SSL/TLS协议加密Socket通信。这可以通过CocoaAsyncSocket的SSL功能实现，或者在创建CFStream时配置SSL上下文。 7. **网络状态检测**：在...

    C# RSA分段加密SOCKET通信

    在我们的例子中，服务器会生成一个公钥和私钥对，然后将公钥发送给客户端。客户端使用这个公钥对要发送的数据进行加密，再通过`SOCKET`发送给服务器。服务器接收到加密数据后，使用其私钥进行解密。 但是，`RSA`...

    一个简单的SOCKET通讯程序

    在C/S模式下，服务器端创建一个Socket监听特定的IP地址和端口号，等待客户端连接；客户端则通过Socket向服务器发起连接请求，一旦连接建立，双方就可以通过Socket交换数据。 在C语言中实现Socket编程，通常需要以下...

    Java socket编程实现两台主机间的通信

    1. 打开一个 Socket 连接：在客户端，使用 Socket 类来建立连接，并指定主机名和端口号。在服务器端，使用 ServerSocket 类来监听客户端的连接。 2. 创建一个数据输入流：在客户端，使用 BufferedReader 类来读取...

    android 安卓手机与电脑socket通信

    在Android平台上，实现安卓手机与电脑之间的通信是一个常见的需求，特别是在进行远程控制、数据传输或者游戏同步等场景。本教程将深入探讨如何使用Socket通信来连接安卓设备与个人计算机。Socket，也被称作套接字，...

    Android Socket编程实例（与PC通信，不同手机中间通信）

    在提供的"Android Socket demo"压缩包中，可能包含了一个简单的Android Socket通信示例项目，包括客户端和服务器端的代码实现，你可以通过学习和运行这个示例来加深对Android Socket编程的理解。记得在实际部署时，...

    Android应用与framework的socket通信实例

    在Android系统中，Socket通信是一种常见的网络编程方式，它允许应用程序通过网络与其他设备或服务进行数据交换。在Android应用与框架之间使用Socket通信时，通常涉及到Android应用层、框架层以及可能的原生（Native...

    socket封装库，有服务器和客户端

    在本项目中，"TCPNetKit"是一个已经封装好的Socket库，包含了服务器端和客户端的功能，允许两者之间进行消息交互。以下是对这个库的一些详细说明和相关知识点： 1. **Socket基本概念**：Socket是操作系统提供的一种...

    GPRS转Socket通信服务器

    本篇文章将深入探讨GPRS转Socket通信服务器的工作原理、优化策略以及其在实际应用中的关键知识点。 首先，理解GPRS通信的基本概念至关重要。GPRS利用分组交换技术，使得移动设备可以在不中断连接的情况下发送和接收...

    Java基于socket的进程间通信 聊天小程序

    Java基于Socket的进程间通信（IPC）是一种网络编程技术，常用于实现客户端和服务器之间的通信。...通过对这些代码的学习和分析，你可以更深入地理解Java中的Socket通信以及如何构建一个简单的聊天应用。

Magicbox
Global site tag (gtag.js) - Google Analytics