對稱非對稱算法混合加密實戰（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();
    }
}
}