对称加密算法

        对称加密算法就是传统的用一个密码进行加密和解密。举个例子：我们常见的对压缩包就可以进行对称加密算法。

        在软件开发的过程中，常见的对称加密算法有：

算法

密钥长度

工作模式

填充模式

DES

56/64

ECB/CBC/PCBC/CTR/...

NoPadding/PKCS5Padding...

AES

128/192/256

ECB/CBC/PCBC/CTR/...

NoPadding/PKCS5Padding/pkcs7Padding...

IDEA

128

ECB

PKCS5Padding/pkcs7Padding...

        而密钥的长度直接决定了加密强度。DES由于密钥长度过短，可以在短时间内被暴力破解，所以现在已经不再安全了。

AES加密算法

        AES是目前使用最为广泛的算法。比较常见的工作模式位ECB和CBC。

ECB模式

       大致思路：我们首先分别创建了加密和解密对应的方法。在进行加密和解密时，我们可以直接调用方法即可。

        在加密算法中，我们首先根据算法名称/工作模式/填充模式就获取Cipher对象。

        其次根据算法名称初始化一个SecretKey实例，并且密钥必须是指定长度。

        然后使用SecretKey初始化Cipher实例，设置加密或者解密。(加密和解密都有特定对应的代码，切记不能搞混，否则系统就会抛出异常。)

        最后传入我们需要加密或者解密的内容，得到相应的输出。

ECB模式只需要一个固定长度的密钥，固定的明文就会生成一个固定的密文，这种一对一的加密方式会导致安全性的降低。

import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.Base64;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

// AES对称加密
// ECB工作模式
public class Main02 {
	public static void main(String[] args) throws Exception {
		// 原文
		String message = "Hello, world!";
		System.out.println("Message：" + message);
		
		// 128位密钥 = 16 bytes Key：
		byte[] key = "1234567890abcdef".getBytes();
		
		// 加密：
		byte[] data = message.getBytes();
		byte[] encrypted = encrypt(key, data); // 加密结果
		System.out.println("Encrypt(加密)：" + Base64.getEncoder().encodeToString(encrypted)); // 进行编码显示
		
		// 解密：
		byte[] decrypted = decrypt(key, encrypted);
		System.out.println("Decrypt(解密)：" + new String(decrypted));
	}
	
	// 加密：
	public static byte[] encrypt(byte[] key, byte[] input) throws Exception {
		// 创建密码对象，需要传入算法/工作模式/填充模式
		Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
		
		// 根据key的字节内容，"恢复"密钥对象
		SecretKey keySpec = new SecretKeySpec(key, "AES");
		
		// 初始化密钥(字节)：设置加密模式ENCRYPT_MODE
		cipher.init(Cipher.ENCRYPT_MODE, keySpec);
		
		// 根据原始内容(字节),进行加密
		return cipher.doFinal(input);
	}
	
	// 解密：
	public static byte[] decrypt(byte[] key, byte[] input) throws Exception {
		// 创建密码对象，需要传入算法/工作模式/填充模式
		Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
		
		// 根据key的字节内容，"恢复"密钥对象
		SecretKey keySpec = new SecretKeySpec(key, "AES");
		
		// 初始化密钥(字节)：设置加密模式DECRYPT_MODE
		cipher.init(Cipher.DECRYPT_MODE, keySpec);
		
		// 根据原始内容(字节),进行加密
		return cipher.doFinal(input);
	}
}

CBC模式

        CBC模式相对于ECB模式而言，CBC模式需要生成一个随机数作为IV参数，这样对于同样一份明文，每次生成的密文都不相同，这样就可以提高其安全性。而这16字节的IV随机参数，必须由SecureRandom生成。

import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Arrays;
import java.util.Base64;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;

// AES对称加密
// CBC工作模式
public class Main03 {
	public static void main(String[] args) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException {
		// 原文：
		String message = "Hello, world!";
		System.out.println("Message(原始信息)：" + message);
		
		// 256位密钥 = 32 bytes Key：
		byte[] key = "1234567890abcdef1234567890abcdef".getBytes();
		
		// 加密：
		byte[] data = message.getBytes();
		byte[] encrypted = encrypt(key, data);
		System.out.println("Encryted(加密内容)：" + Base64.getEncoder().encodeToString(encrypted));
		
		// 解密：
		byte[] decrypted = decrypt(key, encrypted);
		System.out.println("Decrypted(解密内容)：" + new String(decrypted));
	}
	
	// 加密：
	public static byte[] encrypt(byte[] key, byte[] input) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException {
		// 设置算法/工作模式CBC/填充模式
		Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
		
		// 恢复密钥对象
		SecretKeySpec keySpec = new SecretKeySpec(key, "AES");
		
		// CBC模式需要一个16bytes的initialization vector:
		SecureRandom sr = SecureRandom.getInstanceStrong();
		byte[] iv = sr.generateSeed(16); // 生成16个字节的随机数
		System.out.println(Arrays.toString(iv));
		IvParameterSpec ivps = new IvParameterSpec(iv); // 随机数封装成IvParameterSpec
		
		// 初始化密钥：操作模式、密钥、IV参数
		cipher.init(Cipher.ENCRYPT_MODE, keySpec, ivps);
		
		// 加密
		byte[] data = cipher.doFinal(input);
		
		// IV不需要保密，把IV和密文一起返回
		return join(iv, data);
	}
	
	// 解密：
	public static byte[] decrypt(byte[] key, byte[] input) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException {
		// 把input分割成IV和密文
		byte[] iv = new byte[16];
		byte[] data = new byte[input.length - 16];
		
		System.arraycopy(input, 0, iv, 0, 16); // IV
		System.arraycopy(input, 16, data, 0, data.length); // 密文
		System.out.println(Arrays.toString(iv));
		
		// 解密：
		Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding"); // 密码对象
		SecretKeySpec keySpec = new SecretKeySpec(key, "AES"); // 恢复密钥
		IvParameterSpec ivps = new IvParameterSpec(iv); // 恢复IV
		
		// 初始化密钥：操作模式、密钥、IV参数
		cipher.init(Cipher.DECRYPT_MODE, keySpec, ivps);
		
		// 解密操作
		return cipher.doFinal(data);
	}
	
	// 合并数组
	public static byte[] join(byte[] bs1, byte[] bs2) {
		byte[] r = new byte[bs1.length + bs2.length];
		System.arraycopy(bs1, 0, r, 0, bs1.length);
		System.arraycopy(bs2, 0, r, bs1.length, bs2.length);
		return r;
	}
}

对于相同的明文，每次输出结果都不相同：

jiava中常用的对称加密算法 对称加密算法举例_System

 

jiava中常用的对称加密算法 对称加密算法举例_System_02

 密钥交换算法()

        这里我们引入一个问题：以AES加密为例，李雷要给韩梅梅发送一个加密文件，李雷先生成了一个AES密钥，通过对文件的加密之后，将加密文件发送给了韩梅梅，而韩梅梅想要对加密文件进行解密，就需要李雷的密钥。提问：如何将密钥发送给韩梅梅？

       要解决此问题，我们就要采用的是DH算法(Diffie-Hellman算法)。这个算法解决了双方在不发送密钥的前提下，实现类密钥交换。这个交换原理完全由数学原理支持。

具体实现如下：

import java.math.BigInteger;
import java.security.GeneralSecurityException;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.X509EncodedKeySpec;

import javax.crypto.KeyAgreement;

public class Main04 {
	public static void main(String[] args) {
        // Bob和Alice:
        Person bob = new Person("Bob");
        Person alice = new Person("Alice");
        
        // 各自生成KeyPair: 公钥+私钥
        bob.generateKeyPair();
        alice.generateKeyPair();

        // 双方交换各自的PublicKey(公钥):
        // Bob根据Alice的PublicKey生成自己的本地密钥(共享公钥):
        bob.generateSecretKey(alice.publicKey.getEncoded());
        
        // Alice根据Bob的PublicKey生成自己的本地密钥(共享公钥):
        alice.generateSecretKey(bob.publicKey.getEncoded());

        // 检查双方的本地密钥是否相同:
        bob.printKeys();
        alice.printKeys();
        
        // 双方的SecretKey相同，后续通信将使用SecretKey作为密钥进行AES加解密...
    }
}

// 用户类
class Person {
    public final String name; // 姓名
    
    // 密钥
    public PublicKey publicKey; // 公钥
    private PrivateKey privateKey; // 私钥
    private byte[] secretKey; // 本地秘钥(共享密钥)

    // 构造方法
    public Person(String name) {
        this.name = name;
    }

    // 生成本地KeyPair:(公钥+私钥)
    public void generateKeyPair() {
        try {
        	// 创建DH算法的“密钥对”生成器
            KeyPairGenerator kpGen = KeyPairGenerator.getInstance("DH");
            kpGen.initialize(512);
            
            // 生成一个"密钥对"
            KeyPair kp = kpGen.generateKeyPair();
            this.privateKey = kp.getPrivate(); // 私钥
            this.publicKey = kp.getPublic(); // 公钥
            
        } catch (GeneralSecurityException e) {
            throw new RuntimeException(e);
        }
    }
    
    // 按照 "对方的公钥" => 生成"共享密钥"
    public void generateSecretKey(byte[] receivedPubKeyBytes) {
        try {
            // 从byte[]恢复PublicKey:
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(receivedPubKeyBytes);
            
            // 根据DH算法获取KeyFactory
            KeyFactory kf = KeyFactory.getInstance("DH");
            
            // 通过KeyFactory创建公钥
            PublicKey receivedPublicKey = kf.generatePublic(keySpec);
            
            // 生成本地密钥(共享公钥)
            KeyAgreement keyAgreement = KeyAgreement.getInstance("DH");
            keyAgreement.init(this.privateKey); // 初始化"自己的PrivateKey"
            keyAgreement.doPhase(receivedPublicKey, true); // 根据"对方的PublicKey"
            
            // 生成SecretKey本地密钥(共享公钥)
            this.secretKey = keyAgreement.generateSecret();
            
        } catch (GeneralSecurityException e) {
            throw new RuntimeException(e);
        }
    }

    public void printKeys() {
        System.out.printf("Name: %s\n", this.name);
        System.out.printf("Private key: %x\n", new BigInteger(1, this.privateKey.getEncoded()));
        System.out.printf("Public key: %x\n", new BigInteger(1, this.publicKey.getEncoded()));
        System.out.printf("Secret key: %x\n", new BigInteger(1, this.secretKey));
    }
}

非对称加密算法

        非对称加密算法：加密和解密使用的是不同的密钥，只有同一个公钥-私钥对才能正常解密。

        非对称加密的典型算法就是RSA算法，它是由三个人一起发明的，所以就用他们三个人的姓氏首字母命名了这个算法。

        非对称式加密算法的优点:对称加密需要协商密钥，而非对称加密可以安全地公开各自的公钥，在N个人之间通信的时 候:使用非对称加密只需要N个密钥对，每个人只管理自己的密钥对。而使用对称加密需要则需要N(N-1)/2个密钥， 因此每个人需要管理N-1个密钥，密钥管理难度大，而且非常容易泄漏。

       非对称式加密算法的缺点:运算速度非常慢，比对称加密要慢很多。

具体实现如下：

package com.zwd.demo03;

import java.math.BigInteger;
import java.security.GeneralSecurityException;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;

import javax.crypto.Cipher;

// RSA
public class Main05 {
    public static void main(String[] args) throws Exception {
        // 明文:
        byte[] plain = "Hello, encrypt use RSA".getBytes("UTF-8");
        
        // 创建公钥／私钥对:
        Human alice = new Human("Alice");
        
        // 用Alice的公钥加密:
        // 获取Alice的公钥，并输出
        byte[] pk = alice.getPublicKey();
        System.out.println(String.format("public key(公钥)：%x", new BigInteger(1, pk)));
        
        // 使用公钥加密
        byte[] encrypted = alice.encrypt(plain);
        System.out.println(String.format("encrypted(加密)： %x", new BigInteger(1, encrypted)));
       
        // 用Alice的私钥解密:
        // 获取Alice的私钥，并输出
        byte[] sk = alice.getPrivateKey();
        System.out.println(String.format("private key(私钥)：%x", new BigInteger(1, sk)));
        
        // 使用私钥解密
        byte[] decrypted = alice.decrypt(encrypted);
        System.out.println("decrypted(解密)：" + new String(decrypted, "UTF-8"));
    }
}

// 用户类
class Human {
	// 姓名
    String name;
    
    // 私钥:
    PrivateKey sk;
    
    // 公钥:
    PublicKey pk;

    // 构造方法
    public Human(String name) throws GeneralSecurityException {
    	// 初始化姓名
        this.name = name;
        
        // 生成公钥／私钥对:
        KeyPairGenerator kpGen = KeyPairGenerator.getInstance("RSA");
        kpGen.initialize(1024);
        KeyPair kp = kpGen.generateKeyPair();
        
        this.sk = kp.getPrivate();
        this.pk = kp.getPublic();
    }

    // 把私钥导出为字节
    public byte[] getPrivateKey() {
        return this.sk.getEncoded();
    }

    // 把公钥导出为字节
    public byte[] getPublicKey() {
        return this.pk.getEncoded();
    }

    // 用公钥加密:
    public byte[] encrypt(byte[] message) throws GeneralSecurityException {
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, this.pk); // 使用公钥进行初始化
        return cipher.doFinal(message);
    }

    // 用私钥解密:
    public byte[] decrypt(byte[] input) throws GeneralSecurityException {
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, this.sk); // 使用私钥进行初始化
        return cipher.doFinal(input);
    }
}

        RSA的公钥和私钥都可以通过getEncoded()方法获得以byte[]表示的二进制数据，并根据需要保存到文件中。

对称式加密与非对称式加密的对比

        对称式加密算法使用的是同一个密钥进行加密和解密。

        对称式加密算法的密钥长度由算法设计决定。

        使用对称加密算法需要指定算法名称、工作模式和填充模式。

       非对称加密算法在加密和解密时使用的是不同的密钥，只有同一个公钥-私钥对才能进行加密和解密。