常用的几种非对称加密算法

矫情吗；* 2023-06-10 08:26 263阅读 0赞

### 文章目录 ###

*   *  \`1、RSA(算法的名字以发明者的名字命名：Ron Rivest, AdiShamir 和Leonard Adleman)\`
     *  \`2、DSA 签名\`

相对对称加密而言，无需拥有同一组密钥，非对称加密是一种“信息公开的密钥交换协议”。非对称加密需要公开密钥和私有密钥两组密钥，公开密钥和私有密钥是配对起来的，也就是说使用公开密钥进行数据加密，只有对应的私有密钥才能解密。这两个密钥是数学相关，用某用户密钥加密后的密文，只能使用该用户的加密密钥才能解密。如果知道了其中一个，并不能计算出另外一个。因此如果公开了一对密钥中的一个，并不会危害到另外一个密钥性质。这里把公开的密钥为公钥，不公开的密钥为私钥。算法代表：RSA，DSA。

RSA 能同时用于加密和数字签名，而DSA只能用于签名，本文重点讲解RSA。

## `1、RSA(算法的名字以发明者的名字命名：Ron Rivest, AdiShamir 和Leonard Adleman)` ##

这种算法1978年就出现了，它是第一个既能用于数据加密也能用于数字签名的算法。它易于理解和操作，也很流行。算法的名字以发明者的名字命名：Ron Rivest, AdiShamir 和Leonard Adleman。

这种加密算法的特点主要是密钥的变化，上文我们看到DES只有一个密钥。相当于只有一把钥匙，如果这把钥匙丢了，数据也就不安全了。RSA同时有两把钥匙，公钥与私钥。同时支持数字签名。数字签名的意义在于，对传输过来的数据进行校验。确保数据在传输工程中不被修改。

**RSA 加密工具类：**

package com.blog.www.util.coder.asymmetrical;
 
 import com.blog.www.util.coder.base.BaseCoderUtils;
 import lombok.extern.slf4j.Slf4j;
 
 import javax.crypto.BadPaddingException;
 import javax.crypto.Cipher;
 import javax.crypto.IllegalBlockSizeException;
 import javax.crypto.NoSuchPaddingException;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.UnsupportedEncodingException;
 import java.nio.charset.StandardCharsets;
 import java.security.*;
 import java.security.cert.CertificateException;
 import java.security.interfaces.RSAPrivateKey;
 import java.security.interfaces.RSAPublicKey;
 import java.security.spec.InvalidKeySpecException;
 import java.security.spec.PKCS8EncodedKeySpec;
 import java.security.spec.X509EncodedKeySpec;
 
 /** * RSA非对称加密解密工具类 * * * 这种算法1978年就出现了，它是第一个既能用于数据加密也能用于数字签名的算法。它易于理解和操作，也很流行。 算法的名字以发明者的名字命名：Ron * Rivest, AdiShamir 和Leonard Adleman。 这种加密算法的特点主要是密钥的变化，RSA同时有两把钥匙，公钥与私钥。 * 同时支持数字签名。数字签名的意义在于，对传输过来的数据进行校验。确保数据在传输工程中不被修改。 * * 参考： * * <ul> * <li><a href='https://www.iteye.com/blog/snowolf-381767'>Java加密技术（四）——非对称加密算法RSA</a></li> * <li><a href='https://my.oschina.net/jiangli0502/blog/171263'>RSA加密解密及数字签名Java实现</a></li> * </ul> * * <a href="https://github.com/wwwtyro/cryptico">前端demo<a> * */
 @Slf4j
 public class RSACoder { 
 
 	/** * 填充方式。这里有【RSA/ECB/PKCS1Padding】填充（默认）和【RSA/ECB/NoPadding】填充两种可选。 * * 注意：使用填充时，公钥每次加密的字符串都会不一样，这样更安全；不使用则每次都一样。因为java默认是填充的，而安卓默认不填充， * 所以安卓默认加密的密文，java默认不能解密！！必须手动指定他们用一致的填充方式，才能正确加密解密。 */
 	private static final String CIPHER_MODE = "RSA/ECB/PKCS1Padding";
 
 	/** * 算法类型 */
 	private static final String ALGORITHM = "RSA";
 
 	/** * RSA密钥长度必须是64的倍数，在512~65536之间。默认是1024 */
 	private static final int KEY_SIZE = 1024;
 
 	/** * 由公钥字节数组用Base64编码成的字符串，方便传播、储存 */
 	private static final String PUB_KEY_BASE64 = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCxKRX+P64kA0qrd3JYYZIZ5jam63DsAlx5PKlfC0hOAhJ3wfD2Bjl3CHKNMtEKwcnZlunvikOt7/7uKdVdxDYzwpU2ivwNXDA5kMPsx8prjwS7FsdCMWnOTGWBTCYeReFHWVmSj4KxYaOO7csPWBR0AhQX9qiPSWDEKcnH5YNiiQIDAQAB";
 
 	/** * 由私钥字节数组用Base64编码成的字符串，方便传播、储存 */
 	private static final String PRI_KEY_BASE64 = "MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBALEpFf4/riQDSqt3clhhkhnmNqbrcOwCXHk8qV8LSE4CEnfB8PYGOXcIco0y0QrBydmW6e+KQ63v/u4p1V3ENjPClTaK/A1cMDmQw+zHymuPBLsWx0Ixac5MZYFMJh5F4UdZWZKPgrFho47tyw9YFHQCFBf2qI9JYMQpycflg2KJAgMBAAECgYBltrwc1HzrykQFvDeXTLWwTv+TyFt19UkYhl6L5hNmTkRCI8RvzFUT5XK3ZLSmY2q7lazMTerbo44POU96XVvsV+ltmUW4ohh1cf+q7ICz73r+OEaFdxa+wHFthXvMuKpFbDiH89HfAmGGUVezf7dByClyVxn3yuKlb42ZC6AdsQJBAOyA+mBot7a98txTrMl4jRD1MI9t0dWHA51JzJ2vLBX4IlEr944Qhb6N0lNtYChEkEOCrTlLIDxWUtQhZbTP6R0CQQC/w8PcHulcbCY1JhBTefyzA4jmm9LZ0c+byqCSEiffE6/neTMLOxUpt9zDvtdWw7UvMZWgQ4a8QGZrlCw3Lw9dAkEAg9cqvE/kChU9q6FhszZmvUtR9MLttLD9TNN1I3ohg2W+C64M5L9FL4Lz+toAPrJqEZhpZIUCxWAB8ItlnTRB6QJBAKUMwsv3kxUoRG5kV5LxoK0XMsKBhaZSrmTBrxhqJgUbtb/+Eg/th1aD2LBl1oPoKE75V3Y8CICI0V5whunsSEUCQE1ZvMp5a0yblGENWU5F+kWT3aBCkmMN8Zqp2+R5p8kQ7Chxv7llCZ405YXnTdEQyLp+q6OW+eu0TdIQ3qHkA4c=";
 
 	/** * 公钥对象 */
 	static PublicKey PUB_KEY;
 
 	/** * 私钥对象 */
 	static PrivateKey PRI_KEY;
 
 	// 初始化
 	// ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓
 	// 静态代码块，初始化密钥对象，供后面使用
 	static { 
 		try { 
 			PUB_KEY = restorePubKey();
 			PRI_KEY = restorePriKey();
 		} catch (NoSuchAlgorithmException | InvalidKeySpecException e) { 
 			log.error("初始化出错", e);
 		}
 	}
 
 	/** * 从 .p12 文件中读取私钥。 * * 创建人： leigq * 创建时间： 2017年10月28日 下午4:21:56 * * @param pfxKeyFileName .p12文件路径 * @param aliasName 私钥别名 * @param pfxPassword 私钥密码 * @return 私钥对象 */
 	public static PrivateKey readP12Key(String pfxKeyFileName, String aliasName, String pfxPassword)
 			throws KeyStoreException, NoSuchAlgorithmException, CertificateException, IOException, UnrecoverableKeyException { 
 		InputStream fis = new FileInputStream(pfxKeyFileName);
 		KeyStore keyStore = KeyStore.getInstance("PKCS12");
 		keyStore.load(fis, pfxPassword.toCharArray());
 		return (PrivateKey) keyStore.getKey(aliasName, pfxPassword.toCharArray());
 	}
 
 	// 加密、解密
 	// ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓
 
 	/** * 通用加密操作 * * 创建人：leigq * 创建时间：2018年8月18日 下午5:37:32 * * 修改人： * 修改时间： * 修改备注： * * * @param key 公钥或密钥对象 * @param data 明文字符串 * @return 密文字节数组用Base64算法编码成的字符串，方便传输、储存 */
 	public static String encrypt(Key key, String data)
 			throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException,
 			BadPaddingException { 
 		Cipher cipher = Cipher.getInstance(CIPHER_MODE);
 		cipher.init(Cipher.ENCRYPT_MODE, key);
 		byte[] bytes = cipher.doFinal(data.getBytes(StandardCharsets.UTF_8));
 		return BaseCoderUtils.encryptBase64(bytes);
 	}
 
 	/** * 通用解密操作 * * 创建人：leigq * 创建时间：2018年8月18日 下午5:43:34 * * 修改人： * 修改时间： * 修改备注： * * * @param key 公钥或密钥对象 * @param data 密文字符串（由密文字节数组用Base64算法编码成的字符串） * @return 明文字符串 */
 	public static String decrypt(Key key, String data)
 			throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, UnsupportedEncodingException,
 			IllegalBlockSizeException, BadPaddingException { 
 		Cipher cipher = Cipher.getInstance(CIPHER_MODE);
 		cipher.init(Cipher.DECRYPT_MODE, key);
 		byte[] bytes = cipher.doFinal(BaseCoderUtils.decryptBase64(data));
 		return new String(bytes, StandardCharsets.UTF_8);
 	}
 
 	/** * 用公钥加密 * * 创建人： leigq * 创建时间： 2017年10月24日 下午2:00:49 * * @param decoded 明文字符串 * @return 密文字节数组用Base64算法编码成的字符串，方便传输、储存 */
 	public static String encryptByPubKey(String decoded)
 			throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException,
 			IllegalBlockSizeException, BadPaddingException { 
 		return encrypt(PUB_KEY, decoded);
 	}
 
 	/** * 用私钥解密 * * 创建人： leigq * 创建时间： 2017年10月24日 下午1:57:42 * * @param encoded 密文字符串（由密文字节数组用Base64算法编码成的字符串） * @return 明文字符串 */
 	public static String decryptByPriKey(String encoded) throws NoSuchPaddingException, BadPaddingException,
 			NoSuchAlgorithmException, IllegalBlockSizeException, UnsupportedEncodingException, InvalidKeyException { 
 		return decrypt(PRI_KEY, encoded);
 	}
 
 	/** * 用私钥加密 * * 创建人：leigq * 创建时间：2018年8月18日 下午5:37:32 * * 修改人： * 修改时间： * 修改备注： * * * @param decoded 明文字符串 * @return 密文字节数组用Base64算法编码成的字符串，方便传输、储存 */
 	public static String encryptByPriKey(String decoded)
 			throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException,
 			BadPaddingException { 
 		return encrypt(PRI_KEY, decoded);
 	}
 
 	/** * 用公钥解密 * * 创建人：leigq * 创建时间：2018年8月18日 下午5:43:34 * * 修改人： * 修改时间： * 修改备注： * * * @param encoded 密文字符串（由密文字节数组用Base64算法编码成的字符串） * @return 明文字符串 */
 	public static String decryptByPubKey(String encoded)
 			throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, UnsupportedEncodingException,
 			IllegalBlockSizeException, BadPaddingException { 
 		return decrypt(PUB_KEY, encoded);
 	}
 
 
 	/** * 还原公钥，X509EncodedKeySpec 用于构建公钥的规范 * * 创建人：leigq * 创建时间：2018年8月18日 下午5:16:50 * * 修改人： * 修改时间： * 修改备注： * * * @return 公钥对象 */
 	private static PublicKey restorePubKey()
 			throws NoSuchAlgorithmException, InvalidKeySpecException { 
 		X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(BaseCoderUtils.decryptBase64(RSACoder.PUB_KEY_BASE64));
 		KeyFactory factory = KeyFactory.getInstance(ALGORITHM);
 		return factory.generatePublic(x509EncodedKeySpec);
 	}
 
 	/** * 还原私钥，PKCS8EncodedKeySpec 用于构建私钥的规范 * * 创建人：leigq * 创建时间：2018年8月18日 下午5:19:09 * * 修改人： * 修改时间： * 修改备注： * * * @return 私钥对象 */
 	private static PrivateKey restorePriKey()
 			throws NoSuchAlgorithmException, InvalidKeySpecException { 
 		PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(BaseCoderUtils.decryptBase64(RSACoder.PRI_KEY_BASE64));
 		KeyFactory factory = KeyFactory.getInstance(ALGORITHM);
 		return factory.generatePrivate(pkcs8EncodedKeySpec);
 	}
 
 
 	// 更换密钥对
 	// ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓
 
 	/** * 生成密钥对。注意这里是生成密钥对KeyPair，再由密钥对获取公私钥 * * 创建人：leigq * 创建时间：2018年8月18日 下午7:35:21 * * 修改人： * 修改时间： * 修改备注： * */
 	public static void generateKeyPair() { 
 		try { 
 			KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(ALGORITHM);
 			keyPairGenerator.initialize(KEY_SIZE);
 			KeyPair keyPair = keyPairGenerator.generateKeyPair();
 
 			/* 公钥、私钥用 encryptBase64 还是 encryptBase64Sun 加密都可以，后者的 Base64 是多行的，比较适合保存到文件的方式储存 */
 			RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
 			log.info("新公钥：{}", BaseCoderUtils.encryptBase64(publicKey.getEncoded()));
 
 			RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
 			log.info("新私钥：{}", BaseCoderUtils.encryptBase64(privateKey.getEncoded()));
 
 		} catch (NoSuchAlgorithmException e) { 
 			log.error("生成密钥对异常：", e);
 		}
 	}
 }

**测试加密：**

/** * RSA 测试 */
    @Slf4j
    class RSATest { 
    	public static void main(String[] args) throws IllegalBlockSizeException, NoSuchPaddingException, BadPaddingException,
    			NoSuchAlgorithmException, InvalidKeyException, UnsupportedEncodingException { 
    		// 生成密钥对。注意这里是生成密钥对KeyPair，再由密钥对获取公私钥
    		RSACoder.generateKeyPair();
    
    		log.warn("公钥加密 >> 私钥解密");
    
    		String originalStr = "helloWorld";
    		log.warn("原文：{}", originalStr);
    
    		/* 公钥加密 >> 私钥解密 */
    		// 公钥加密
    		String encryptByPubKey = RSACoder.encryptByPubKey(originalStr);
    		log.warn("公钥加密后：" + encryptByPubKey);
    
    		// 私钥解密
    		String decryptByPriKey = RSACoder.decryptByPriKey(encryptByPubKey);
    		log.warn("私钥解密后：" + decryptByPriKey);
    
    
    		/* 私钥加密 >> 公钥解密 */
    		// 私钥加密
    		String encryptByPriKey = RSACoder.encryptByPriKey(originalStr);
    		log.warn("私钥加密后：" + encryptByPriKey);
    
    		// 公钥解密
    		String decryptByPubKey = RSACoder.decryptByPubKey(encryptByPriKey);
    		log.warn("公钥解密后：" + decryptByPubKey);
    	}
    }

RSA加密、解密测试结果：

![20191026171006.png][]

**RSA 签名工具类：**

package com.blog.www.util.coder.asymmetrical;
 
 import com.blog.www.util.coder.base.BaseCoderUtils;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.codec.DecoderException;
 import org.apache.commons.codec.binary.Hex;
 
 import java.nio.charset.StandardCharsets;
 import java.security.InvalidKeyException;
 import java.security.NoSuchAlgorithmException;
 import java.security.Signature;
 import java.security.SignatureException;
 
 /** * RSA签名验签类 */
 @Slf4j
 public class RSASignature extends RSACoder { 
 
 	/** * 用哪个算法来签名 */
 	private static final String SIGNATURE_ALGORITHM = "SHA1WithRSA";
 
 
 	/* ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ 生成签名 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ */
 
 	/** * 用私钥生成 Base64数字签名 * * * @param encoded 加密字符串 * @return 签名，已用Base64编码 */
 	public static String signToBase64(String encoded) throws NoSuchAlgorithmException, InvalidKeyException, SignatureException { 
 		Signature sign = getSign(encoded.getBytes(StandardCharsets.UTF_8));
 		return BaseCoderUtils.encryptBase64(sign.sign());
 	}
 
 	/** * 用私钥生成16进制数字签名 * * * @param encoded 加密字符串 * @return 签名，已用转16进制字符串 */
 	public static String signToHex(String encoded) throws NoSuchAlgorithmException, InvalidKeyException, SignatureException { 
 		Signature sign = getSign(encoded.getBytes(StandardCharsets.UTF_8));
 		return Hex.encodeHexString(sign.sign());
 	}
 	/* ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ 生成签名 ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ */
 
 
 
 	/* ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ 验证签名 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ */
 
 	/** * 用公钥校验 Base64数字签名 * * * @param encoded 加密数据 * @param signed 签名，已用Base64编码 * @return 校验成功返回true 失败返回false */
 	public static boolean verifyFromBase64(String encoded, String signed) throws NoSuchAlgorithmException, InvalidKeyException, SignatureException { 
 		Signature verify = getVerify(encoded.getBytes(StandardCharsets.UTF_8));
 		return verify.verify(BaseCoderUtils.decryptBase64(signed));
 	}
 
 	/** * 用公钥校验 16进制数字签名 * * * @param data 加密数据 * @param signed 签名，是由字节数组转换成的16进制字符串 */
 	public static boolean verifyFromHex(String data, String signed) throws NoSuchAlgorithmException, InvalidKeyException, SignatureException, DecoderException { 
 		Signature verify = getVerify(data.getBytes(StandardCharsets.UTF_8));
 		return verify.verify(Hex.decodeHex(signed));
 	}
 	/* ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ 验证签名 ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ */
 
 
 	/** * 用私钥生成数字签名对象 * * * @param encoded 加密字符串转换的字节数组 * @return Signature，方便进一步转换为其他数据 */
 	private static Signature getSign(byte[] encoded) throws NoSuchAlgorithmException, InvalidKeyException, SignatureException { 
 		Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
 		signature.initSign(PRI_KEY);
 		signature.update(encoded);
 		return signature;
 	}
 
 
 	/** * 用公钥生成校验数字签名对象 * * * @param data 加密字符串转换的字节数组 * @return */
 	private static Signature getVerify(byte[] data) throws NoSuchAlgorithmException, InvalidKeyException, SignatureException { 
 		Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
 		signature.initVerify(PUB_KEY);
 		signature.update(data);
 		return signature;
 	}
 }

**测试签名：**

/** * RSA 签名测试 */
    @Slf4j
    class RSASignTest { 
    	public static void main(String[] args) throws NoSuchAlgorithmException,
    			InvalidKeyException, SignatureException, DecoderException { 
    		// 上面公钥加密产生的密文
    		String ciphertext = "S1E4OieVAlGyrOB7CzKugseg/R9TGSdDhRSna64tTpxJubpndp2AwCrJ3myIoWEqXNBPKlPVo21vd+KQgzhQcX5WxoNXD5sLarmbZ5eFsBNQOuTzwIhSql+zaUKV6qq+RTSYNR4c/fqllh5Mviq73dB42bWbUY7nHlim+jGojPY=";
    
    		log.warn("私钥签名——公钥验证签名");
    
    		// 产生签名 16 进制签名
    		String signToBase64 = RSASignature.signToBase64(ciphertext);
    		log.warn("签名：[{}]", signToBase64);
    
    		// 验证签名
    		boolean verifyFromBase64 = RSASignature.verifyFromBase64(ciphertext, signToBase64);
    		log.warn("验证签名：[{}]", verifyFromBase64);
    
    
    		// 产生签名 16 进制签名
    		String signToHex = RSASignature.signToHex(ciphertext);
    		log.warn("签名：[{}]", signToHex);
    
    		// 验证签名
    		boolean verifyFromHex = RSASignature.verifyFromHex(ciphertext, signToHex);
    		log.warn("验证签名：[{}]", verifyFromHex);
    	}
    }

**测试结果：**

![20191026171039.png][]

## `2、DSA 签名` ##

DSA-Digital Signature Algorithm 是Schnorr和ElGamal签名算法的变种，被美国NIST作为DSS(DigitalSignature Standard)。简单的说，这是一种更高级的验证方式，用作数字签名。不单单只有公钥、私钥，还有数字签名。私钥加密生成数字签名，公钥验证数据及签名。如果数据和签名不匹配则认为验证失败！数字签名的作用就是校验数据在传输过程中不被修改。数字签名，是单向加密的升级

具体使用看：https://blog.csdn.net/jianggujin/article/details/53440060

[20191026171006.png]: /images/20230531/ab142be022c642268bc1eb2946ec7087.png
[20191026171039.png]: /images/20230531/f512e047ed994c42933167a84ee18b5b.png