PKI - 非对称加密算法

最新推荐文章于 2023-08-24 00:21:04 发布
最新推荐文章于 2023-08-24 00:21:04 发布
阅读量1.7k 收藏 1
点赞数
分类专栏： PKI 文章标签： 非对称加密算法 DH ECDH RSA ElGamal
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ttyy1112/article/details/108731584
版权

非对称加密算法

密钥管理是对称加密算法系统不容忽视的问题，它成为安全系统中最为薄弱的环节。为了弥补这一弱势，非对称加密算法应运而生。

非对称加密算法源于DH算法（Diffie-Hellman，密钥交换算法），由W.Diffie和M.Hellman共同提出。该算法为非对称加密算法奠定了基础，堪称非对称加密算法之鼻祖。

DH算法提出后，国际上相继出现了各种实用性更强的非对称加密算法，其构成主要是基于数学问题的求解，主要分为两类：

  • 基于因子分解难题。RSA算法是最为典型的非对称加密算法，该算法由美国麻省理工学院（MIT）的Ron Rivest、Adi Shamir和Leonard Adleman三位学者提出，并以这三位学者的姓氏开头字母命名，称为RSA算法。RSA算法是当今应用范围最为广泛的非对称加密算法，也是第一个既能用于数据加密也能用于数字签名的算法。

  • 基于离散对数难题。ElGamal算法由TaherElGamal提出，以自己的名字命名。该算法既可用于加密/解密，也可用于数字签名，并为数字签名算法形成标准提供参考。美国的DSS（Digital Signature Standard，数据签名标准）的DSA（Digital Signature Algorithm，数字签名算法）经ElGamal算法演变而来。

ECC（Elliptical Curve Cryptography，椭圆曲线加密）算法以椭圆曲线理论为基础，在创建密钥时可做到更快、更小，并且更有效。ECC算法通过椭圆曲线方程式的性质产生密钥，而不是采用传统的方法利用大质数的积来产生。

1. 密钥交换算法（DH&ECDH)

1.1 DH

对称加密算法提高数据安全性的同时带来了密钥管理的复杂性。消息收发双方若想发送加密消息，必须事先约定好加密算法并发放密钥。而如何安全的传递密钥，成为对称加密算法的一个棘手问题。密钥交换算法（Diffie-Hellman算法，简称DH算法）成为解决这一问题的金钥匙！

（甲方）发送方 （乙方）接收方 1. 构建甲方密钥 2. 公布甲方公钥 3. 利用甲方公钥构建乙方密钥 4. 公布乙方公钥 5. 使用甲方私钥、乙方公钥构建本地密钥 6. 使用乙方私钥、甲方公钥构建本地密钥 7. 使用本地密钥对消息加密 8. 发送加密消息 9. 使用本地密钥对消息解密 （甲方）发送方 （乙方）接收方

代码实现

public static final String KEY_ALGORITHM = "DH";
public static final String SECRET_ALGORITHM = "AES";
public static final int KEY_SIZE = 512;
public static final String PUBLIC_KEY = "DHPublicKey";
public static final String PRIVATE_KEY = "DHPrivateKey";

/**
 * 生成甲方密钥对（含公钥、私钥）
 *
 * @return map
 * @throws Exception 异常
 */
public Map<String, Object> initKey() throws Exception {
    // 初始化密钥对生成器
    final KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM);
    keyPairGenerator.initialize(KEY_SIZE);

    // 生成密钥对
    final KeyPair keyPair = keyPairGenerator.generateKeyPair();
    // 获取公钥
    final PublicKey publicKey = keyPair.getPublic();
    // 获取私钥
    final PrivateKey privateKey = keyPair.getPrivate();

    // 构造返回map
    Map<String, Object> keyMap = new HashMap<>();
    keyMap.put(PUBLIC_KEY, publicKey);
    keyMap.put(PRIVATE_KEY, privateKey);

    return keyMap;
}

/**
 * 根据甲方公钥生成乙方密钥对（含公钥、私钥）
 *
 * @param key 甲方公钥
 * @return map
 * @throws Exception 异常
 */
public Map<String, Object> initKey(byte[] key) throws Exception {
    // 解析甲方公钥
    final X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(key);
    // 实例化密钥工厂
    final KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    // 产生甲方公钥
    final PublicKey aPublicKey = keyFactory.generatePublic(x509EncodedKeySpec);

    // 由甲方公钥构建乙方密钥
    final DHParameterSpec dhParameterSpec = ((DHPublicKey) aPublicKey).getParams();
    // 初始化密钥对生成器
    final KeyPairGenerator dh = KeyPairGenerator.getInstance(keyFactory.getAlgorithm());
    dh.initialize(dhParameterSpec);
    // 生成密钥对
    final KeyPair keyPair = dh.generateKeyPair();
    // 获取公钥
    final PublicKey publicKey = keyPair.getPublic();
    // 获取私钥
    final PrivateKey privateKey = keyPair.getPrivate();

    // 构造返回map
    Map<String, Object> keyMap = new HashMap<>();
    keyMap.put(PUBLIC_KEY, publicKey);
    keyMap.put(PRIVATE_KEY, privateKey);
    return keyMap;
}

/**
 * 生成密钥
 * @param publicKey 对方公钥
 * @param privateKey 自己私钥
 * @return 密钥
 * @throws Exception 异常
 */
public byte[] getSecretKey(byte[] publicKey, byte[] privateKey) throws Exception {
    // 初始化密钥工厂
    final KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);

    // 初始化公钥
    final X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(publicKey);
    final PublicKey pubKey = keyFactory.generatePublic(x509EncodedKeySpec);

    // 初始化私钥
    final PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(privateKey);
    final PrivateKey priKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);

    // 实例化
    final KeyAgreement keyAgreement = KeyAgreement.getInstance(keyFactory.getAlgorithm());
    keyAgreement.init(priKey);
    keyAgreement.doPhase(pubKey, true);

    // 生成本地密钥
    final SecretKey secretKey = keyAgreement.generateSecret(SECRET_ALGORITHM);
    return secretKey.getEncoded();
}

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

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

/**
 * 数据加密
 *
 * @param data 待加密数据
 * @param key  密钥
 * @return 加密后数据
 */
public byte[] encrypt(byte[] data, byte[] key) throws Exception {
    // 生成本地密钥
    final SecretKeySpec secretKeySpec = new SecretKeySpec(key, SECRET_ALGORITHM);
    // 数据加密
    final Cipher cipher = Cipher.getInstance(secretKeySpec.getAlgorithm());
    cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);
    return cipher.doFinal(data);
}

/**
 * 数据解密
 *
 * @param data 待解密数据
 * @param key  密钥
 * @return 解密后数据
 */
public byte[] decrypt(byte[] data, byte[] key) throws Exception {
    // 生成本地密钥
    final SecretKeySpec secretKeySpec = new SecretKeySpec(key, SECRET_ALGORITHM);
    // 数据加密
    final Cipher cipher = Cipher.getInstance(secretKeySpec.getAlgorithm());
    cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);
    return cipher.doFinal(data);
}

测试用例

@Test
public void testDH() throws Exception {
    final Map<String, Object> aKeyMap = initKey();
    final byte[] aPublicKey = getPublicKey(aKeyMap);
    final byte[] aPrivateKey = getPrivateKey(aKeyMap);
    System.out.println("甲方公钥：" + Base64.toBase64String(aPublicKey));
    System.out.println("甲方私钥：" + Base64.toBase64String(aPrivateKey));

    final Map<String, Object> bKeyMap = initKey(aPublicKey);
    final byte[] bPublicKey = getPublicKey(bKeyMap);
    final byte[] bPrivateKey = getPrivateKey(bKeyMap);
    System.out.println("乙方公钥：" + Base64.toBase64String(bPublicKey));
    System.out.println("乙方私钥：" + Base64.toBase64String(bPrivateKey));

    final byte[] aSecretKey = getSecretKey(bPublicKey, aPrivateKey);
    final byte[] bSecretKey = getSecretKey(aPublicKey, bPrivateKey);
    System.out.println("甲方密钥：" + Base64.toBase64String(aSecretKey));
    System.out.println("乙方密钥：" + Base64.toBase64String(bSecretKey));

    final byte[] aEncrypt = encrypt("我是阿汤哥".getBytes(), aSecretKey);
    final byte[] bDecrypt = decrypt(aEncrypt, bSecretKey);
    System.out.println("甲方加密消息：" + Base64.toBase64String(aEncrypt));
    System.out.println("乙方解密消息：" + Base64.toBase64String(bDecrypt));

    final byte[] bEncrypt = encrypt("Hello， 阿汤哥".getBytes(), bSecretKey);
    final byte[] aDecrypt = decrypt(bEncrypt, aSecretKey);
    System.out.println("乙方加密消息：" + Base64.toBase64String(bEncrypt));
    System.out.println("甲方解密消息：" + Base64.toBase64String(aDecrypt));
}

使用jdk8执行本用例时如果报错

java.security.NoSuchAlgorithmException: Unsupported secret key algorithm: AES

	at com.sun.crypto.provider.DHKeyAgreement.engineGenerateSecret(DHKeyAgreement.java:387)
	at javax.crypto.KeyAgreement.generateSecret(KeyAgreement.java:648)
	at com.jd.eps.eis.product.core.config.DHTest.getSecretKey(DHTest.java:110)
	at com.jd.eps.eis.product.core.config.DHTest.testDH(DHTest.java:183)

可以通过增加vm参数 -Djdk.crypto.KeyAgreement.legacyKDF=true 解决。

执行结果

甲方公钥：MIHgMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYXrgHzW5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpDTWSGkx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgANEAAJBAMCeFF4M4gFXNabyak7DplZnTVPJCNpw9eOao4BWNrdu8ptUiTg4kwmP8bxjot873vQ7QDg4cPyTFJGZ/c3HApE=
甲方私钥：MIHSAgEAMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYXrgHzW5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpDTWSGkx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgAQzAjEA1f2vYbDfzWpVlX8ib4ftWD5q24Mzh74C0L+ze8ienkfwv41dErOl0HqZOmmf18HN
乙方公钥：MIHgMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYXrgHzW5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpDTWSGkx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgANEAAJBAJ3BzkiX8n6RurBasjqLYwCbewwX0ZkWykCzyQj6y/4uBgNX0m+0bgPX1emxlFt/N3ueC8803OhNcprcHRxschY=
乙方私钥：MIHSAgEAMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYXrgHzW5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpDTWSGkx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgAQzAjEAqi55vmMEF5pfS4//fvfqELLlo817cCRlRMOZ+sQ9HLtroIJ16x7RWusDpK75dqxA
甲方密钥：sSVOKIBcVtQ5h806csVXzmkPZWUhC75Xp9glwAjFWhY=
乙方密钥：sSVOKIBcVtQ5h806csVXzmkPZWUhC75Xp9glwAjFWhY=
甲方加密消息：DPftIVbpAGj7dkF73QB4zw==
乙方解密消息：我是阿汤哥
乙方加密消息：FTZnyPN+ZAzdqU4vEKjkMCo6U0TLlKPDyL3zoBSGvvQ=
甲方解密消息：Hello， 阿汤哥

1.2 ECDH

JDK8没有ECDH的实现，需要添加Provider。

Security.addProvider(new BouncyCastleProvider());

根据甲方公钥生成乙方密钥对时需对ParameterSpec进行调整。

/**
 * 根据甲方公钥生成乙方密钥对（含公钥、私钥）
 *
 * @param key 甲方公钥
 * @return map
 * @throws Exception 异常
 */
public Map<String, Object> initKey(byte[] key) throws Exception {
    // 解析甲方公钥
    final X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(key);
    // 实例化密钥工厂
    final KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    // 产生甲方公钥
    final PublicKey aPublicKey = keyFactory.generatePublic(x509EncodedKeySpec);

    // 由甲方公钥构建乙方密钥
    final ECParameterSpec ecParameterSpec = ((ECPublicKey) aPublicKey).getParams();
    // 初始化密钥对生成器
    final KeyPairGenerator dh = KeyPairGenerator.getInstance(keyFactory.getAlgorithm());
    dh.initialize(ecParameterSpec);
    // 生成密钥对
    final KeyPair keyPair = dh.generateKeyPair();
    // 获取公钥
    final PublicKey publicKey = keyPair.getPublic();
    // 获取私钥
    final PrivateKey privateKey = keyPair.getPrivate();

    // 构造返回map
    Map<String, Object> keyMap = new HashMap<>();
    keyMap.put(PUBLIC_KEY, publicKey);
    keyMap.put(PRIVATE_KEY, privateKey);
    return keyMap;
}

2. 典型非对称加密算法 - RSA

甲方（发送者） 乙方（接收者） 1. 构建密钥对 2. 发布公钥 3. 使用私钥加密数据 4. 发送加密数据 5. 使用甲方公钥解密数据 6. 使用甲方公钥加密数据 7. 发送加密数据 8. 使用私钥解密数据 甲方（发送者） 乙方（接收者）

代码实现

public static final String KEY_ALGORITHM = "RSA";
public static final int KEY_SIZE = 512;
public static final String PUBLIC_KEY = "DHPublicKey";
public static final String PRIVATE_KEY = "DHPrivateKey";

/**
 * 生成甲方密钥对（含公钥、私钥）
 *
 * @return map
 * @throws Exception 异常
 */
public Map<String, Object> initKey() throws Exception {
    // 初始化密钥对生成器
    final KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM);
    keyPairGenerator.initialize(KEY_SIZE);

    // 生成密钥对
    final KeyPair keyPair = keyPairGenerator.generateKeyPair();
    // 获取公钥
    final PublicKey publicKey = keyPair.getPublic();
    // 获取私钥
    final PrivateKey privateKey = keyPair.getPrivate();

    // 构造返回map
    Map<String, Object> keyMap = new HashMap<>();
    keyMap.put(PUBLIC_KEY, publicKey);
    keyMap.put(PRIVATE_KEY, privateKey);

    return keyMap;
}

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

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

/**
 * 使用私钥加密数据
 *
 * @param data       待加密数据
 * @param privateKey 私钥
 * @return 加密后数据
 */
public byte[] encryptByPrivateKey(byte[] data, byte[] privateKey) throws Exception {
    // 获取私钥
    final PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(privateKey);
    final KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    // 生成私钥
    final PrivateKey priKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
    // 数据加密
    final Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
    cipher.init(Cipher.ENCRYPT_MODE, priKey);
    return cipher.doFinal(data);
}

/**
 * 使用公钥解密数据
 *
 * @param data      待解密数据
 * @param publicKey 公钥
 * @return 解密后数据
 */
public byte[] decryptByPublicKey(byte[] data, byte[] publicKey) throws Exception {
    // 获取公钥
    final X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(publicKey);
    final KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    // 生成公钥
    final PublicKey pubKey = keyFactory.generatePublic(x509EncodedKeySpec);
    // 数据加密
    final Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
    cipher.init(Cipher.DECRYPT_MODE, pubKey);
    return cipher.doFinal(data);
}

/**
 * 使用公钥加密数据
 *
 * @param data      待解密数据
 * @param publicKey 公钥
 * @return 解密后数据
 */
public byte[] encryptByPublicKey(byte[] data, byte[] publicKey) throws Exception {
    // 获取公钥
    final X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(publicKey);
    final KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    // 生成公钥
    final PublicKey pubKey = keyFactory.generatePublic(x509EncodedKeySpec);
    // 数据加密
    final Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
    cipher.init(Cipher.ENCRYPT_MODE, pubKey);
    return cipher.doFinal(data);
}

/**
 * 使用私钥解密数据
 *
 * @param data       待加密数据
 * @param privateKey 私钥
 * @return 加密后数据
 */
public byte[] decryptByPrivateKey(byte[] data, byte[] privateKey) throws Exception {
    // 获取私钥
    final PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(privateKey);
    final KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    // 生成私钥
    final PrivateKey priKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
    // 数据加密
    final Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
    cipher.init(Cipher.DECRYPT_MODE, priKey);
    return cipher.doFinal(data);
}

@Test
public void testRSA() throws Exception {
    Security.addProvider(new BouncyCastleProvider());

    final Map<String, Object> aKeyMap = initKey();
    final byte[] aPublicKey = getPublicKey(aKeyMap);
    final byte[] aPrivateKey = getPrivateKey(aKeyMap);
    System.out.println("甲方公钥：" + Base64.toBase64String(aPublicKey));
    System.out.println("甲方私钥：" + Base64.toBase64String(aPrivateKey));


    final byte[] aEncrypt = encryptByPrivateKey("我是阿汤哥".getBytes(), aPrivateKey);
    final byte[] bDecrypt = decryptByPublicKey(aEncrypt, aPublicKey);
    System.out.println("甲方：使用甲方私钥加密消息：" + Base64.toBase64String(aEncrypt));
    System.out.println("乙方：使用甲方公钥解密消息：" + new String(bDecrypt));

    final byte[] bEncrypt = encryptByPublicKey("Hello， 阿汤哥".getBytes(), aPublicKey);
    final byte[] aDecrypt = decryptByPrivateKey(bEncrypt, aPrivateKey);
    System.out.println("乙方：使用甲方公钥加密消息：" + Base64.toBase64String(bEncrypt));
    System.out.println("甲方：使用甲方私钥解密消息：" + new String(aDecrypt));
}

执行结果

甲方公钥：MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAJ7vEoMQFnSZq8tIKydTxeZQZbg3EzZ+uoqMB6xYUz0bJKTLBE2VdT8SKmhCFjyBLzRla8bCl5EtLB/S3F/isD0CAwEAAQ==
甲方私钥：MIIBUwIBADANBgkqhkiG9w0BAQEFAASCAT0wggE5AgEAAkEAnu8SgxAWdJmry0grJ1PF5lBluDcTNn66iowHrFhTPRskpMsETZV1PxIqaEIWPIEvNGVrxsKXkS0sH9LcX+KwPQIDAQABAkAePbMyCP+c1BiiJ2s+omwHdMjGEoSvW9G2xwo2ut+rwo+UiKX/OXtjggNL32sOG/VBpmwQnCzhHXlM3Uf/AyLBAiEA0j02vlbqrkb4eLLTX/K1ZXk05xFMaxjCfqIdv9VwqykCIQDBhxD/jP48lN/I/cNQjg4710e46gL5U3TvDfmpXZYS9QIgYAHkRfebJAr03OmM7XwAql43cm3L3/xmlT2jKD9oPEECIBAgRh1VTVYU/bTM2Hqc67i2zqYs8cR+3M6StowTXU8FAiAp+LnIyULp1obJN9ZnLRv5RldROa9Evj94cfDq3gu+QQ==
甲方：使用甲方私钥加密消息：lK3A3bNyxV1xc34st8fOtIy5vyjTL1zm7wbU9v5mV21t0hxf1ZLTdvN5+vZPSylF3th0c0KqSdGNLpaazvEYSg==
乙方：使用甲方公钥解密消息：我是阿汤哥
乙方：使用甲方公钥加密消息：msiUhALltZYWQdpDWpp6X4wmDCR3ZVGw4d3AqYBnnwDloNDBivpBhT4LgWseX7x74GpgKFA1g/mpsKCIoXqOiw==
甲方：使用甲方私钥解密消息：Hello， 阿汤哥

3. 常用非对称加密算法 - ElGamal

甲方（发送者） 乙方（接收者） 1. 构建密钥对 2. 发布公钥 3. 使用乙方公钥加密数据 4. 发送加密数据 5. 使用私钥解密数据 甲方（发送者） 乙方（接收者）

代码实现

public static final String KEY_ALGORITHM = "ElGamal";
public static final int KEY_SIZE = 256;
public static final String PUBLIC_KEY = "ElGamalPublicKey";
public static final String PRIVATE_KEY = "ElGamalPrivateKey";

/**
 * 生成甲方密钥对（含公钥、私钥）
 *
 * @return map
 * @throws Exception 异常
 */
public Map<String, Object> initKey() throws Exception {
    // 加入BouncyCastleProvider支持
    Security.addProvider(new BouncyCastleProvider());
    // 实例化算法参数生成器
    final AlgorithmParameterGenerator apg = AlgorithmParameterGenerator.getInstance(KEY_ALGORITHM);
    // 初始化算法生成器
    apg.init(KEY_SIZE);
    // 生成算法参数
    final AlgorithmParameters parameters = apg.generateParameters();
    // 构建参数材料
    final DHParameterSpec dhParameterSpec = parameters.getParameterSpec(DHParameterSpec.class);
    // 实例化密钥对生成器
    final KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM);
    keyPairGenerator.initialize(dhParameterSpec, new SecureRandom());

    // 生成密钥对
    final KeyPair keyPair = keyPairGenerator.generateKeyPair();
    // 获取公钥
    final PublicKey publicKey = keyPair.getPublic();
    // 获取私钥
    final PrivateKey privateKey = keyPair.getPrivate();

    // 构造返回map
    Map<String, Object> keyMap = new HashMap<>();
    keyMap.put(PUBLIC_KEY, publicKey);
    keyMap.put(PRIVATE_KEY, privateKey);

    return keyMap;
}

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

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

/**
 * 使用公钥加密数据
 *
 * @param data      待解密数据
 * @param publicKey 公钥
 * @return 解密后数据
 */
public byte[] encryptByPublicKey(byte[] data, byte[] publicKey) throws Exception {
    Security.addProvider(new BouncyCastleProvider());
    // 获取公钥
    final X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(publicKey);
    final KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    // 生成公钥
    final PublicKey pubKey = keyFactory.generatePublic(x509EncodedKeySpec);
    // 数据加密
    final Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
    cipher.init(Cipher.ENCRYPT_MODE, pubKey);
    return cipher.doFinal(data);
}

/**
 * 使用私钥解密数据
 *
 * @param data       待加密数据
 * @param privateKey 私钥
 * @return 加密后数据
 */
public byte[] decryptByPrivateKey(byte[] data, byte[] privateKey) throws Exception {
    Security.addProvider(new BouncyCastleProvider());
    // 获取私钥
    final PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(privateKey);
    final KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    // 生成私钥
    final PrivateKey priKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
    // 数据加密
    final Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
    cipher.init(Cipher.DECRYPT_MODE, priKey);
    return cipher.doFinal(data);
}

@Test
public void testRSA() throws Exception {
    Security.addProvider(new BouncyCastleProvider());

    final Map<String, Object> bKeyMap = initKey();
    final byte[] bPublicKey = getPublicKey(bKeyMap);
    final byte[] bPrivateKey = getPrivateKey(bKeyMap);
    System.out.println("乙方公钥：" + Base64.toBase64String(bPublicKey));
    System.out.println("乙方私钥：" + Base64.toBase64String(bPrivateKey));

    final byte[] aEncrypt = encryptByPublicKey("我是阿汤哥".getBytes(), bPublicKey);
    final byte[] bDecrypt = decryptByPrivateKey(aEncrypt, bPrivateKey);
    System.out.println("甲方：使用乙方公钥加密消息：" + Base64.toBase64String(aEncrypt));
    System.out.println("乙方：使用乙方私钥解密消息：" + new String(bDecrypt));
}

执行结果

乙方公钥：MHYwTwYGKw4HAgEBMEUCIQD3Tow0iMrSnqcab/qk3sixGNZsFqerw5TZS8AthdG9/wIgVwGItAIOERVrOUQuvYUf4iBgNedVcIVEMpmCAAF67GsDIwACICuSrF+jA6g2XGfFjtP8zmZWA0LstwQQgsMBB6AYuA1/
乙方私钥：MHgCAQAwTwYGKw4HAgEBMEUCIQD3Tow0iMrSnqcab/qk3sixGNZsFqerw5TZS8AthdG9/wIgVwGItAIOERVrOUQuvYUf4iBgNedVcIVEMpmCAAF67GsEIgIgS99qTF3QgAjIKNcpPaA5jnTSp6AUOqb1XhOGGtr75iw=
甲方：使用乙方公钥加密消息：3sdh+pOViDQWU8aDO/LC1SnK427qrFc8PHrMVyE+k7MbL7tQHbq+5I7MZ0vz7WAc6ysAvVZU9pg8YcQvoYWoEw==
乙方：使用乙方私钥解密消息：我是阿汤哥
阿湯哥
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
加密算法PKI
10-13
包括： 密码学基础 2PKI体系 3PKI应用 详细讲解了通讯双方掌握的秘钥 包括典型算法：DES,3DES,AES,IDEA
AES-CBC对称加密
04-10
AES-CBC（Advanced Encryption Standard - Cipher Block Chaining）是对称加密算法AES（高级加密标准）的一种工作模式。AES是国际标准化组织（ISO）和国际电工委员会（IEC）联合制定的，用于保护电子数据的强加密...
对称密码、非对称密码、散列算法与PKI
weixin_34111790的博客
02-02 864
对称密码、非对称密码、散列算法与PKI密码学要解决的问题：机密性、完整性、身份验证（抗抵赖性）：一、对称密码：对称密码技术：发件人和收件人使用其共同拥有的单个密钥 ,这种密钥既用于加密，也用于解密，叫做机密密钥(也称为对称密钥或会话密钥)。能够提供信息机密性（没有密钥信息不能被解密）、完整性（被改变的信息不能被解密）的服务。对称式密码学又称：单钥密码学、秘密密...
PKI 算法
xwhoyeah
07-03 413
数字签名：  MD5（Message Digest Algorithm 5）：是RSA数据安全公司开发的一种单向散列算法。  SHA（Secure Hash Algorithm）：可以对任意长度的数据运算生成一个160位的数值；  DSA（Digital Signature Algorithm）：数字签名算法，是一种标准的 DSS（数字签名标准）； 非对称加密：  R...
PKI体系及密码算法
lurenyi333的博客
06-02 2083
HTTPS 的诞生 可先参考网络协议、HTTPS协议等文章 明文传输 对称加密 “加密”和“解密”使用【相同的】密钥，如果密钥可以安全的传输，那么消息也应该可以安全的传输。 非对称加密 上述非对称加密与对称加密效果基本一样，如果公钥可以安全的传输，那么消息也应该可以安全的传输，接下来看看被劫持的情况。 窃听者可以伪造服务器的公钥与客户端通讯，客户端以为是跟服务器通讯，其实是与窃听者在通讯。 无论是对称加密还是非对称加密，都遗留了一个问题没有解决，那就是如何证明我们访问的网站就是我们
PKI - 对称加密算法
ttyy1112的专栏
09-22 1883
PKI - 对称加密算法数据加密标准(DES - Data Encryption Standard) 1977 DES 1998 AES 数据加密标准(DES - Data Encryption Standard)
Asymmetric-Key-Cryptosystem.rar_非对称加密
09-24
C++是一种强大的、面向对象的编程语言，适合实现复杂的算法和数据结构，如非对称加密所需的数学运算。 非对称加密的核心原理基于数学难题，如大整数因子分解（RSA）或离散对数问题（如Diffie-Hellman和ElGamal）。...
WJCipher:对称加密算法
06-15
在IT领域，对称加密算法是一种广泛应用于数据保护的核心技术，尤其在Objective-C编程中，开发者经常使用这种算法来确保信息安全。"WJCipher"很可能是一个Objective-C实现的对称加密库，它提供了多种对称加密算法的...
PKI-CA体系介绍.zip
01-19
公钥基础设施（PKI）是一种用于安全数据交换的技术系统，它基于非对称加密算法，确保了在网络通信中的数据完整性、保密性和身份认证。在PKI系统中，每个参与者都有一对密钥：公钥和私钥。公钥可以公开，用于加密数据...
加密技术和PKI系统
学习 - 总结 - 分享 - Francis
10-02 1760
对称加密 VS 非对称加密   对称加密技术： ● DES：数据加密标准算法（Data Encryption Standard），主要采用替换和移位的方法加密，用56位密钥对64位二进制数据块进行加密。 ● TDES : 在DES上采用三重DES，用两个密钥K1和K2，通过K1加密，K2解密，K1再加密实现。 ● RC-5：采用基本变换数据相依旋转（Data-Dependen
PKI和加密，散列算法
weixin_30345577的博客
09-30 339
Day 11-PKI和加密，散列算法 PKI（Public Key Infrastructure公钥基础设施） 1 PKI（Public Key Infrastructure公钥基础设施）回顾学习 - 签名等过程 1.1 基础说明： 1.1.1 PKI技术-CAs架构（Single-Root CA -简单/Hierarchical CAs-分层/Cross-Certifi...
PKI技术
qq_43910068的博客
03-03 1748
公钥基础设施 1.PKI概述 PKI（Public Key Infrastructure） 作用：通过加密技术和数字签名保证信息的安全 组成：公钥加密技术，数字证书、CA(电子认证服务机构)、RA 2、信息三要素 机密性 完整性 身份验证/操作的不可否认性 3.都有哪些IT领域用PKI 1.ssl 2.IPsecVPN 3.部分远程访问vpn 4.公钥加密技术 作用：实现对信息加密，数字签名的安全...
网安学习——PKI概述和加密算法
最新发布
xyx112的博客
08-24 312
PKI概述 名称：公钥基础设施（Public Key Infrastructure, PKI）是目前网络安全建设的基础与核心。 作用：通过加密技术和数字签名保证信息的安全。 组成：公钥加密技术、数字证书、CA(Certification Authority)认证机构、RA(Registration Authority)注册机构。 对称加密算法 对称加密算法，所谓对称就是加密和解密的密钥是一致的！ 对称密钥是由双方的对称加密算法协商生成的，不是人为配置的！ 对称算法的优点：加密速度快 对称算法的缺点：密
加密和 PKI 基础知识
蝈蝈俊.net
12-02 3300
Microsoft Windows 2000 Server白皮书 2000年7月5日发布 摘要 本白皮书介绍了加密和公钥基本结构（PKI）的概念和使用 Microsoft Windows 2000 Server 操作系统中的证书服务的基础知识。如果您还不熟悉加密和公钥技术，先阅读本白皮书将有助于理解 Windows 2000 Web 站点上有关这些主题的其它技术白皮书。 引言 Mi
PKI 基础知识
mystudyblog0507的专栏
03-27 8625
PKI 基础知识 (摘自Microsoft Windows 2000 Server白皮书,2000年7月5日发布) 摘要本白皮书介绍了加密和公钥基本结构(PKI)的概念和使用 Microsoft Windows 2000 Server 操作系统中的证书服务的基础知识。如果您还不熟悉加密和公钥技术，先阅读本白皮书将有助于理解 Windows 2000 Web 站...
计算机网络安全 之 信息加密与PKI
01-05 2061
计算机网络安全 之 信息加密与PKI 1，前言概述 信息加密技术是利用密码学的原理与方法对传输数据提供保护的手段，它以数学计算为基础，信息论和复杂性理论是其两个重要组成部分。 信息论主要包括香农关于保密系统的信息理论。 密码学复杂性理论主要讨论算法复杂性和问题复杂性两个方面。 密码技术主要由密码编码技术和密码分析技术组成。 密码编码技术主要解决产生安全有效的密码算法问题，实现对信息的加密或认证。 密码分析技术主要解决破译密码或伪造认证码问题，从而获取保密信息或进行破坏活动。 1，
PKI详解
热门推荐
appdeveloperxg的博客
02-03 1万+
PKI详解 一、什么是PKI？ 官方定义：PKI是Public Key Infrastructure的首字母缩写，翻译过来就是公钥基础设施；PKI是一种遵循标准的利用公钥加密技术为电子商务的开展提供一套安全基础平台的技术和规范。PKI技术是一种遵循既定标准的密钥管理平台，它的基础是加密技术，核心是证书服务，支持集中自动的密钥管理和密钥分配，能够为所有的网络应用提供加密和数字签名等密码服务及所需要的密钥和证书管理体系。 通俗理解：PKI就是利用公开密钥理论和技术建立提供安全服务的、具有通用性的基础设施.
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值