对称非对称算法混合加密实战（DES和AES混合加密）

•      最近需要用加密算法，开始研究加密算法，果然大学落下的需要全都补回来。泪奔啊！
•      网上找各种资料，看别人的原理解释看了了很多，使用非对称算法和对称算法混合加密在实际项目中是经常用的，但原理听的差不多，没有具体混合加密的可以参考的代码，索性翻出以前写的使用套接字创建服务端和客户端的例子写了个小程序，用来完整的模拟整个过程。
•     大致思路是A生成一对公私钥，将公钥发送给B，B接收到后用这个公钥加密对称算法的密钥，然后发送给A，A接收到后利用私钥解密得到对称算法的密钥，俗称会话密钥，再将自己要发送的消息用会话密钥加密，发送给B，B接收到后利用自己知道的会话密钥解密，得到密文，这就是一个完整的过程。具体细节我不做赘述了，不专业，我也讲不透。下面直接贴代码。

•      用Java实现的RSA算法和DES算法也是从网上搜刮来的，现在都忘了原帖在哪，感谢各位前辈。

•      整个过程全都是原生JDK的东西实现的，只用到了Apache的一个Base64编码工具，其实那个东西JDK也有自带的，在java.xml.DataConventer这个包下面。不想下载Apache那个的，可以用这个代替。

RSA算法（非对称算法）的实现：

package socket;

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

import javax.crypto.Cipher;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;


/**
 * 非对称加密算法RSA算法组件
 * 非对称算法一般是用来传送对称加密算法的密钥来使用的，相对于DH算法，RSA算法只需要一方构造密钥，不需要
 * 大费周章的构造各自本地的密钥对了。DH算法只能算法非对称算法的底层实现。而RSA算法算法实现起来较为简单
 *
 * @author kongqz
 */
public class RSACoder {
    //非对称密钥算法
    public static final String KEY_ALGORITHM = "RSA";


    /**
     * 密钥长度，DH算法的默认密钥长度是1024
     * 密钥长度必须是64的倍数，在512到65536位之间
     */
    private static final int KEY_SIZE = 512;
    //公钥
    public static final String PUBLIC_KEY = "RSAPublicKey";

    //私钥
    public static final String PRIVATE_KEY = "RSAPrivateKey";

    /**
     * 初始化密钥对
     *
     * @return Map 甲方密钥的Map
     */
    public static Map<String, Object> initKey() throws Exception {
        //实例化密钥生成器
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        //初始化密钥生成器
        keyPairGenerator.initialize(KEY_SIZE);
        //生成密钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        //甲方公钥
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        //甲方私钥
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        //将密钥存储在map中
        Map<String, Object> keyMap = new HashMap<String, Object>();
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);
        return keyMap;

    }


    /**
     * 私钥加密
     *
     * @param data 待加密数据
     * @param key       密钥
     * @return byte[] 加密数据
     */
    public static byte[] encryptByPrivateKey(byte[] data, byte[] key) throws Exception {

        //取得私钥
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        //生成私钥
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
        //数据加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, privateKey);
        return cipher.doFinal(data);
    }

    /**
     * 公钥加密
     *
     * @param data 待加密数据
     * @param key       密钥
     * @return byte[] 加密数据
     */
    public static byte[] encryptByPublicKey(byte[] data, byte[] key) throws Exception {

        //实例化密钥工厂
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        //初始化公钥
        //密钥材料转换
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
        //产生公钥
        PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);

        //数据加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, pubKey);
        return cipher.doFinal(data);
    }

    /**
     * 私钥解密
     *
     * @param data 待解密数据
     * @param key  密钥
     * @return byte[] 解密数据
     */
    public static byte[] decryptByPrivateKey(byte[] data, byte[] key) throws Exception {
        //取得私钥
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        //生成私钥
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
        //数据解密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        return cipher.doFinal(data);
    }

    /**
     * 公钥解密
     *
     * @param data 待解密数据
     * @param key  密钥
     * @return byte[] 解密数据
     */
    public static byte[] decryptByPublicKey(byte[] data, byte[] key) throws Exception {

        //实例化密钥工厂
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        //初始化公钥
        //密钥材料转换
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
        //产生公钥
        PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);
        //数据解密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, pubKey);
        return cipher.doFinal(data);
    }

    /**
     * 取得私钥
     *
     * @param keyMap 密钥map
     * @return byte[] 私钥
     */
    public static byte[] getPrivateKey(Map<String, Object> keyMap) {
        Key key = (Key) keyMap.get(PRIVATE_KEY);
        return key.getEncoded();
    }

    /**
     * 取得公钥
     *
     * @param keyMap 密钥map
     * @return byte[] 公钥
     */
    public static byte[] getPublicKey(Map<String, Object> keyMap) throws Exception {
        Key key = (Key) keyMap.get(PUBLIC_KEY);
        return key.getEncoded();
    }

    /**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        //初始化密钥
        //生成密钥对
        Map<String, Object> keyMap = RSACoder.initKey();
        //公钥
        byte[] publicKey = RSACoder.getPublicKey(keyMap);

        //私钥
        byte[] privateKey = RSACoder.getPrivateKey(keyMap);
        System.out.println("公钥：/n" + Base64.encodeBase64String(publicKey));
        System.out.println("私钥：/n" + Base64.encodeBase64String(privateKey));

        System.out.println("================密钥对构造完毕,甲方将公钥公布给乙方，开始进行加密数据的传输=============");
        String str = "RSA密码交换算法";
        System.out.println("/n===========甲方向乙方发送加密数据==============");
        System.out.println("原文:" + str);
        //甲方进行数据的加密
        byte[] code1 = RSACoder.encryptByPrivateKey(str.getBytes(), privateKey);
        System.out.println("加密后的数据：" + Base64.encodeBase64String(code1));
        System.out.println("===========乙方使用甲方提供的公钥对数据进行解密==============");
        //乙方进行数据的解密
        byte[] decode1 = RSACoder.decryptByPublicKey(code1, publicKey);
        System.out.println("乙方解密后的数据：" + new String(decode1) + "/n/n");

        System.out.println("===========反向进行操作，乙方向甲方发送数据==============/n/n");

        str = "乙方向甲方发送数据RSA算法";

        System.out.println("原文:" + str);

        //乙方使用公钥对数据进行加密
        byte[] code2 = RSACoder.encryptByPublicKey(str.getBytes(), publicKey);
        System.out.println("===========乙方使用公钥对数据进行加密==============");
        System.out.println("加密后的数据：" + Base64.encodeBase64String(code2));

        System.out.println("=============乙方将数据传送给甲方======================");
        System.out.println("===========甲方使用私钥对数据进行解密==============");

        //甲方使用私钥对数据进行解密
        byte[] decode2 = RSACoder.decryptByPrivateKey(code2, privateKey);

        System.out.println("甲方解密后的数据：" + new String(decode2));
    }
}

DES算法（对称算法）的实现：

package socket;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;

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

public class DES{
    public byte[] bytes;
    
    //生成一个DES密钥
    public static String getKey(){
        try {
            KeyGenerator keyGenerator = KeyGenerator.getInstance("DES");
            keyGenerator.init(56);
            // 生成一个Key
            SecretKey generateKey = keyGenerator.generateKey();
            // 转变为字节数组
            byte[] encoded = generateKey.getEncoded();
            // 生成密钥字符串
            String encodeHexString = Hex.encodeHexString(encoded);
            return encodeHexString;
        } catch (Exception e) {
            e.printStackTrace();
            return "密钥生成错误.";
        }   
    }
    
    //加密
    public static String encryptor(String str,String Key){
        String s=null;
        try {
            DESKeySpec desKey = new DESKeySpec(Key.getBytes());
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
            SecretKey securekey = keyFactory.generateSecret(desKey);
            Cipher cipher = Cipher.getInstance("DES");
            cipher.init(Cipher.ENCRYPT_MODE,securekey);    //初始化密码器，用密钥 secretKey 进入加密模式
            byte[] bytes=cipher.doFinal(str.getBytes());   //加密
            s= Base64.encodeBase64String(bytes);
        } catch (Exception e) {
            e.printStackTrace();
            return "加密错误.";
        }
        return s;
    }   

    //解密
    public static String decryptor(String buff,String Key){
        String s=null;
        try {
            DESKeySpec desKey = new DESKeySpec(Key.getBytes());
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
            SecretKey securekey = keyFactory.generateSecret(desKey);
            Cipher cipher = Cipher.getInstance("DES");
            cipher.init(Cipher.DECRYPT_MODE,securekey);
            byte[] responseByte=cipher.doFinal(Base64.decodeBase64(buff));
            s=new String(responseByte);
            return s;
        } catch (Exception e) {
            e.printStackTrace();
            return "解密错误.";
        }
    }
}

一个消息辅助类：

package socket;

public class MessageType {
    public static final int PUBLIC_KEY_MESSAGE = 1;
    public static final int SESSION_KEY_MESSAGE = 2;
    public static final int CRYPTO_MESSAGE = 3;
    public static final int RESULT_MESAAGE = 4;
}

服务端：

package socket;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

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

public class Server {
    static ServerSocket serverSocket;

    public static void main(String[] args) {
        try {
            int i = 1;
            serverSocket = new ServerSocket(8001);
            System.out.println("服务器启动，等待连接...");
            while (true) {
                // 等待客户端通过端口8001请求的连接
                Socket socket = serverSocket.accept();
                System.out.println(socket.getInetAddress().getHostAddress() + "上线，当前第" + i + "个");
                Runnable runnable = new ThreadEchoHandler(socket);
                Thread thread = new Thread(runnable);
                thread.start();
                i++;
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                serverSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

class ThreadEchoHandler implements Runnable {
    private Socket incomingSocket;
    private Scanner scanner;
    private PrintWriter writer;
    private String key;

    public ThreadEchoHandler(Socket in) {
        incomingSocket = in;
        System.out.println("正在生成DES的密钥...");
        key = DES.getKey();
        System.out.println("生成DES密钥为："+key);
    }

    public void run() {
        try {
            // 建立套接字的输入输出流
            InputStream inputStream = incomingSocket.getInputStream();
            OutputStream outputStream = incomingSocket.getOutputStream();
            // 将输入流转化为扫描器，输出流转化为写入器
            scanner = new Scanner(inputStream);
            writer = new PrintWriter(outputStream, true);

            while(scanner.hasNext()) {
                String backString = scanner.next();
                String[] split = backString.split(":");
                if(split.length>1) {
                    int flag = Integer.parseInt(split[0]);
                    switch(flag) {
                    case MessageType.PUBLIC_KEY_MESSAGE:
                        System.out.println("接收到客户端的RSA的公钥:"+split[1]);
                        System.out.println("=========用RSA公钥加密DES会话密钥=============");
                        byte[] decryptDesKey = RSACoder.encryptByPublicKey(key.getBytes(),Base64.decodeBase64(split[1]));
                        String decryptDesKeyString = Base64.encodeBase64String(decryptDesKey);
                        System.out.println("加密后的DES密钥：" + decryptDesKeyString);
                        System.out.println("=========密钥加密成功=============");
                        System.out.println("发送加密后的DES密钥");
                        writer.println(MessageType.SESSION_KEY_MESSAGE+":"+decryptDesKeyString);
                        break;
                    case MessageType.CRYPTO_MESSAGE:
                        System.out.println("接收到密文为"+split[1]);
                        System.out.println("用DES会话密钥解密密文...");
                        String message = DES.decryptor(split[1], key);
                        System.out.println("解密客户端发过来的消息为："+message);
                        String result = DES.encryptor("准奏！", key);
                        writer.println(MessageType.RESULT_MESAAGE+":"+result);
                        System.out.println("已处理相关请求，并回馈给客户端！");
                        break;
                    }
                }
            }
            System.out.println("客户端已断开连接，会话结束！");
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 关闭套接字（很重要，防止造成资源浪费）
            try {
                scanner.close();
                incomingSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

客户端：

package socket;                                                                                                                                                                                                                 

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Map;
import java.util.Scanner;

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

public class Client {
public static void main(String[] args) throws Exception {
    Socket socket=null;
    InputStream inputStream=null;
    OutputStream outputStream=null;
    Scanner scanner=null;
    PrintWriter writer=null;
    String sessionKey=null;
    
    
    try {
        socket = new Socket("localhost",8001);
        inputStream = socket.getInputStream();
        outputStream = socket.getOutputStream();
        scanner=new Scanner(inputStream);
        writer= new PrintWriter(outputStream, true);
        
        Map<String, Object> initKey = null;
        try {
            initKey = RSACoder.initKey();
            System.out.println("一对公私钥生成成功，分别为：");
            System.out.println("公钥为：" + initKey.get(RSACoder.PUBLIC_KEY));
            System.out.println("私钥为：" + initKey.get(RSACoder.PRIVATE_KEY));
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("正在发送RSA的公钥给服务端...");
        writer.println(MessageType.PUBLIC_KEY_MESSAGE+":"+Base64.encodeBase64String(RSACoder.getPublicKey(initKey)));
        writer.flush();
        
        //* 开始接受服务端发送的消息
        boolean notExit =true;
        while(notExit&&scanner.hasNext()) {
            String backString = scanner.next();
            System.out.println(backString);
            String[] split = backString.split(":");
            if(split.length>1) {
                int flag = Integer.parseInt(split[0]);
                switch(flag) {
                case MessageType.SESSION_KEY_MESSAGE:
                    System.out.println("接收到服务端发送的会话密钥:"+split[1]);
                    System.out.println("=========用RSA私钥解密DES会话密钥=============");
                    byte[] sessionKey_byte = RSACoder.decryptByPrivateKey(Base64.decodeBase64(split[1]), RSACoder.getPrivateKey(initKey));
                    sessionKey = new String(sessionKey_byte);
                    System.out.println("DES会话密钥解密完成："+sessionKey);
                    
                    System.out.println("用DES密钥将明文“能否午时三刻行刑？”加密...");
                    String cipherText = DES.encryptor("能否午时三刻行刑？", sessionKey);
                    System.out.println("加密过的明文为"+cipherText);
                    System.out.println("======================");
                    System.out.println("==========发送加密后的消息给服务器============");
                    writer.println(MessageType.CRYPTO_MESSAGE+":"+cipherText);
                    writer.flush();
                    break;
                case MessageType.RESULT_MESAAGE:
                    System.out.println("接收到服务端发送的处理结果密文:"+split[1]);
                    System.out.println("=========用DES会话密钥解密=============");
                    String result = DES.decryptor(split[1], sessionKey);
                    System.out.println("解密的明文为："+result);
                    System.out.println("==========所有流程结束============");
                    notExit=false;
                    break;
                }
            }
        }
    } catch (UnknownHostException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        scanner.close();
        inputStream.close();
        outputStream.close();
        socket.close();
    }
}
}