JAVA加密解密

文章16 |   阅读 8315 |   点赞0

来源：https://blog.csdn.net/jianggujin/category_9265275.html

JAVA加密解密之DH（Diffie-Hellman）算法

转x33g5p2x  于2021-12-25 转载在 其他  
字(10.6k)|赞(0)|评价(0)|浏览(530)

DH算法简介

Diffie-Hellman算法(D-H算法)，密钥一致协议。是由公开密钥密码体制的奠基人Diffie和Hellman所提出的一种思想。简单的说就是允许两名用户在公开媒体上交换信息以生成”一致”的、可以共享的密钥。换句话说，就是由甲方产出一对密钥（公钥、私钥），乙方依照甲方公钥产生乙方密钥对（公钥、私钥）。以此为基线，作为数据传输保密基础，同时双方使用同一种对称加密算法构建本地密钥（SecretKey）对数据加密。这样，在互通了本地密钥（SecretKey）算法后，甲乙双方公开自己的公钥，使用对方的公钥和刚才产生的私钥加密数据，同时可以使用对方的公钥和自己的私钥对数据解密。不单单是甲乙双方两方，可以扩展为多方共享数据通讯，这样就完成了网络交互数据的安全通讯！该算法源于中国的同余定理——中国馀数定理。

  1. 甲方构建密钥对儿，将公钥公布给乙方，将私钥保留；双方约定数据加密算法；乙方通过甲方公钥构建密钥对儿，将公钥公布给甲方，将私钥保留。
  2. 甲方使用私钥、乙方公钥、约定数据加密算法构建本地密钥，然后通过本地密钥加密数据，发送给乙方加密后的数据；乙方使用私钥、甲方公钥、约定数据加密算法构建本地密钥，然后通过本地密钥对数据解密。
  3. 乙方使用私钥、甲方公钥、约定数据加密算法构建本地密钥，然后通过本地密钥加密数据，发送给甲方加密后的数据；甲方使用私钥、乙方公钥、约定数据加密算法构建本地密钥，然后通过本地密钥对数据解密。

DH算法实现

  1. package com.jianggujin.codec;
  3. import java.io.InputStream;
  4. import java.io.OutputStream;
  5. import java.security.Key;
  6. import java.security.KeyFactory;
  7. import java.security.KeyPair;
  8. import java.security.KeyPairGenerator;
  9. import java.security.NoSuchAlgorithmException;
  10. import java.security.PublicKey;
  11. import java.security.spec.PKCS8EncodedKeySpec;
  12. import java.security.spec.X509EncodedKeySpec;
  14. import javax.crypto.Cipher;
  15. import javax.crypto.KeyAgreement;
  16. import javax.crypto.SecretKey;
  17. import javax.crypto.interfaces.DHPublicKey;
  18. import javax.crypto.spec.DHParameterSpec;
  20. import com.jianggujin.codec.util.JCipherInputStream;
  21. import com.jianggujin.codec.util.JCipherOutputStream;
  22. import com.jianggujin.codec.util.JCodecException;
  24. /** * Diffie-Hellman算法(D-H算法)，密钥一致协议。是由公开密钥密码体制的奠基人Diffie和Hellman所提出的一种思想。 * 简单的说就是允许两名用户在公开媒体上交换信息以生成"一致"的、可以共享的密钥。换句话说，就是由甲方产出一对密钥（公钥、私钥）， * 乙方依照甲方公钥产生乙方密钥对（公钥、私钥）。以此为基线，作为数据传输保密基础，同时双方使用同一种对称加密算法构建本地密钥（SecretKey）对数据加密 * 。这样，在互通了本地密钥（SecretKey）算法后，甲乙双方公开自己的公钥，使用对方的公钥和刚才产生的私钥加密数据， * 同时可以使用对方的公钥和自己的私钥对数据解密。不单单是甲乙双方两方，可以扩展为多方共享数据通讯，这样就完成了网络交互数据的安全通讯！ * 该算法源于中国的同余定理——中国馀数定理 * <ol> * <li>甲方构建密钥对儿，将公钥公布给乙方，将私钥保留；双方约定数据加密算法；乙方通过甲方公钥构建密钥对儿，将公钥公布给甲方，将私钥保留。</li> * <li>甲方使用私钥、乙方公钥、约定数据加密算法构建本地密钥，然后通过本地密钥加密数据，发送给乙方加密后的数据；乙方使用私钥、甲方公钥、 * 约定数据加密算法构建本地密钥，然后通过本地密钥对数据解密。</li> * <li>乙方使用私钥、甲方公钥、约定数据加密算法构建本地密钥，然后通过本地密钥加密数据，发送给甲方加密后的数据；甲方使用私钥、乙方公钥、 * 约定数据加密算法构建本地密钥，然后通过本地密钥对数据解密。</li> * </ol> * * @author jianggujin * */
  25. public class JDH {
  27.    private final static String ALGORITHM = "DH";
  29.    /** * 对称算法 * * @author jianggujin * */
  30.    public static enum JDHSymmetricalAlgorithm {
  31.       DES, DESede;
  32.       public String getName() {
  33.          return this.name();
  34.       }
  35.    }
  37.    /** * 初始化甲方密钥 * * @return */
  38.    public static KeyPair initPartyAKey() {
  39.       return initPartyAKey(1024);
  40.    }
  42.    /** * 初始化甲方密钥 * * @param keySize * @return */
  43.    public static KeyPair initPartyAKey(int keySize) {
  44.       try {
  45.          KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(ALGORITHM);
  46.          keyPairGen.initialize(keySize);
  47.          return keyPairGen.generateKeyPair();
  48.       } catch (NoSuchAlgorithmException e) {
  49.          throw new JCodecException(e);
  50.       }
  51.    }
  53.    /** * 初始化乙方密钥 * * @param partyAPublicKey * 甲方公钥 * @return */
  54.    public static KeyPair initPartyBKey(byte[] partyAPublicKey) {
  55.       try {
  56.          X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(partyAPublicKey);
  57.          KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
  58.          PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);
  60.          // 由甲方公钥构建乙方密钥
  61.          DHParameterSpec dhParamSpec = ((DHPublicKey) pubKey).getParams();
  63.          KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(keyFactory.getAlgorithm());
  64.          keyPairGenerator.initialize(dhParamSpec);
  66.          return keyPairGenerator.generateKeyPair();
  67.       } catch (Exception e) {
  68.          throw new JCodecException(e);
  69.       }
  70.    }
  72.    /** * 加密 * * @param data * 加密数据 * @param privateKey * 己方私钥 * @param publicKey * 对方公钥 * @param algorithm * 对称算法 * @return */
  73.    public static byte[] encrypt(byte[] data, byte[] privateKey, byte[] publicKey, String algorithm) {
  74.       // 数据加密
  75.       Cipher cipher = getEncryptCipher(privateKey, publicKey, algorithm);
  77.       try {
  78.          return cipher.doFinal(data);
  79.       } catch (Exception e) {
  80.          throw new JCodecException(e);
  81.       }
  82.    }
  84.    /** * 包裹输出流，包裹后的输出流为加密输出流 * * @param out * @param privateKey * @param publicKey * @param algorithm * @return */
  85.    public static OutputStream wrap(OutputStream out, byte[] privateKey, byte[] publicKey, String algorithm) {
  86.       // 数据加密
  87.       Cipher cipher = getEncryptCipher(privateKey, publicKey, algorithm);
  89.       return new JCipherOutputStream(cipher, out);
  90.    }
  92.    /** * 获得加密模式的{@link Cipher} * * @param privateKey * @param publicKey * @param algorithm * @return */
  93.    public static Cipher getEncryptCipher(byte[] privateKey, byte[] publicKey, String algorithm) {
  94.       return getCipher(privateKey, publicKey, algorithm, Cipher.ENCRYPT_MODE);
  95.    }
  97.    /** * 解密 * * @param data * 解密数据 * @param privateKey * 己方私钥 * @param publicKey * 对方公钥 * @param algorithm * 对称算法 * @return */
  98.    public static byte[] decrypt(byte[] data, byte[] privateKey, byte[] publicKey, String algorithm) {
  99.       // 数据解密
  100.       Cipher cipher = getDecryptCipher(privateKey, publicKey, algorithm);
  101.       try {
  102.          return cipher.doFinal(data);
  103.       } catch (Exception e) {
  104.          throw new JCodecException(e);
  105.       }
  106.    }
  108.    /** * 包裹输入流，原输入流为加密数据输入流 * * @param in * @param privateKey * @param publicKey * @param algorithm * @return */
  109.    public static InputStream wrap(InputStream in, byte[] privateKey, byte[] publicKey, String algorithm) {
  110.       // 数据解密
  111.       Cipher cipher = getDecryptCipher(privateKey, publicKey, algorithm);
  112.       return new JCipherInputStream(cipher, in);
  113.    }
  115.    /** * 获得解密模式的{@link Cipher} * * @param privateKey * @param publicKey * @param algorithm * @return */
  116.    public static Cipher getDecryptCipher(byte[] privateKey, byte[] publicKey, String algorithm) {
  117.       return getCipher(privateKey, publicKey, algorithm, Cipher.DECRYPT_MODE);
  118.    }
  120.    private static Cipher getCipher(byte[] privateKey, byte[] publicKey, String algorithm, int opmode) {
  121.       // 生成本地密钥
  122.       SecretKey secretKey = getSecretKey(privateKey, publicKey, algorithm);
  124.       try {
  125.          // 数据加密
  126.          Cipher cipher = Cipher.getInstance(secretKey.getAlgorithm());
  127.          cipher.init(opmode, secretKey);
  128.          return cipher;
  129.       } catch (Exception e) {
  130.          throw new JCodecException(e);
  131.       }
  132.    }
  134.    /** * 获得密钥 * * @param privateKey * 己方私钥 * @param publicKey * 对方公钥 * @param algorithm * 对称算法 * @return */
  135.    private static SecretKey getSecretKey(byte[] privateKey, byte[] publicKey, String algorithm) {
  136.       try {
  137.          KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
  138.          X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(publicKey);
  139.          PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);
  141.          PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(privateKey);
  142.          Key priKey = keyFactory.generatePrivate(pkcs8KeySpec);
  144.          KeyAgreement keyAgree = KeyAgreement.getInstance(keyFactory.getAlgorithm());
  145.          keyAgree.init(priKey);
  146.          keyAgree.doPhase(pubKey, true);
  148.          // 生成本地密钥
  149.          return keyAgree.generateSecret(algorithm);
  150.       } catch (Exception e) {
  151.          throw new JCodecException(e);
  152.       }
  153.    }
  154. }

测试代码：

  1. package com.jianggujin.codec.test;
  3. import java.io.File;
  4. import java.io.FileInputStream;
  5. import java.io.FileOutputStream;
  6. import java.io.InputStream;
  7. import java.io.OutputStream;
  8. import java.security.KeyPair;
  10. import org.junit.Test;
  12. import com.jianggujin.codec.JBase64;
  13. import com.jianggujin.codec.JBase64.JEncoder;
  14. import com.jianggujin.codec.JDH;
  15. import com.jianggujin.codec.JDH.JDHSymmetricalAlgorithm;
  17. public class DHTest {
  18.    String str = "jianggujin";
  19.    File file = new File(getClass().getSimpleName() + ".dat");
  21.    @Test
  22.    public void test() throws Exception {
  23.       System.out.println("原串：" + str);
  24.       JEncoder encoder = JBase64.getEncoder();
  25.       KeyPair keyPairA = JDH.initPartyAKey();
  26.       byte[] keyPairAPrivate = keyPairA.getPrivate().getEncoded();
  27.       byte[] keyPairAPublic = keyPairA.getPublic().getEncoded();
  28.       System.out.println("甲方私钥：" + encoder.encodeToString(keyPairAPrivate, "UTF-8"));
  29.       System.out.println("甲方公钥：" + encoder.encodeToString(keyPairAPublic, "UTF-8"));
  30.       KeyPair keyPairB = JDH.initPartyBKey(keyPairAPublic);
  31.       byte[] keyPairBPrivate = keyPairB.getPrivate().getEncoded();
  32.       byte[] keyPairBPublic = keyPairB.getPublic().getEncoded();
  33.       System.out.println("乙方私钥：" + encoder.encodeToString(keyPairBPrivate, "UTF-8"));
  34.       System.out.println("乙方公钥：" + encoder.encodeToString(keyPairBPublic, "UTF-8"));
  35.       for (JDHSymmetricalAlgorithm algorithm : JDHSymmetricalAlgorithm.values()) {
  36.          System.out.println("-----------------------------------------");
  37.          System.out.println("对称算法：" + algorithm.getName());
  38.          byte[] encrypt = JDH.encrypt(str.getBytes(), keyPairAPrivate, keyPairBPublic, algorithm.getName());
  39.          System.out.println("加密：" + encoder.encodeToString(encrypt, "UTF-8"));
  40.          System.out
  41.                .println("解密：" + new String(JDH.decrypt(encrypt, keyPairBPrivate, keyPairAPublic, algorithm.getName())));
  43.          System.out.print("输出流加密：" + file.getAbsolutePath());
  44.          OutputStream out = JDH.wrap(new FileOutputStream(file), keyPairAPrivate, keyPairBPublic, algorithm.getName());
  45.          out.write(str.getBytes());
  46.          out.flush();
  47.          out.close();
  48.          System.out.println();
  49.          System.out.print("输入流解密：");
  50.          InputStream in = JDH.wrap(new FileInputStream(file), keyPairBPrivate, keyPairAPublic, algorithm.getName());
  51.          byte[] buffer = new byte[1024];
  52.          int len = in.read(buffer);
  53.          System.out.println(new String(buffer, 0, len));
  54.       }
  55.    }
  56. }

测试结果：
原串：jianggujin
甲方私钥：MIIBZwIBADCCARsGCSqGSIb3DQEDATCCAQwCgYEA/X9TgR11EilS30qcLuzk5/YRt1I870QAwx4/gLZRJmlFXUAiUftZPY1Y+r/F9bow9subVWzXgTuAHTRv8mZgt2uZUKWkn5/oBHsQIsJPu6nX/rfGG/g7V+fGqKYVDwT7g/bTxR7DAjVUE1oWkTL2dfOuK2HXKu/yIgMZndFIAccCgYEA9+GghdabPd7LvKtcNrhXuXmUr7v6OuqC+VdMCz0HgmdRWVeOutRZT+ZxBxCBgLRJFnEj6EwoFhO3zwkyjMim4TwWeotUfI0o4KOuHiuzpnWRbqN/C/ohNWLx+2J6ASQ7zKTxvqhRkImog9/hWuWfBpKLZl6Ae1UlZAFMO/7PSSoCAgIABEMCQQCKZ/IM4bTS0YkWGsMGFY6NAAICuvHpvhSBaPZ3Le4PS/owyrEnsiS3AXig5OYYko/fVvIBz1kOaKTl/0tsQLtt
甲方公钥：MIIBpzCCARsGCSqGSIb3DQEDATCCAQwCgYEA/X9TgR11EilS30qcLuzk5/YRt1I870QAwx4/gLZRJmlFXUAiUftZPY1Y+r/F9bow9subVWzXgTuAHTRv8mZgt2uZUKWkn5/oBHsQIsJPu6nX/rfGG/g7V+fGqKYVDwT7g/bTxR7DAjVUE1oWkTL2dfOuK2HXKu/yIgMZndFIAccCgYEA9+GghdabPd7LvKtcNrhXuXmUr7v6OuqC+VdMCz0HgmdRWVeOutRZT+ZxBxCBgLRJFnEj6EwoFhO3zwkyjMim4TwWeotUfI0o4KOuHiuzpnWRbqN/C/ohNWLx+2J6ASQ7zKTxvqhRkImog9/hWuWfBpKLZl6Ae1UlZAFMO/7PSSoCAgIAA4GFAAKBgQClQTWNc/3DBQQvs/KHwJ6CC9lYT2Cr2NdSHBUFiCuAUhQ7vpEgzL14IrhqJqixtMuOKOAOUOFBipavJTwhXNnviRNHQ0TJ1l+2ZNQaXHLQdpkBSl5E0fR7DRigbHUeNso52ZrNkDpyR0d7a6XQQRw9Ffig1ZujtO2+D7Ka2F8EJg==
乙方私钥：MIIBZwIBADCCARsGCSqGSIb3DQEDATCCAQwCgYEA/X9TgR11EilS30qcLuzk5/YRt1I870QAwx4/gLZRJmlFXUAiUftZPY1Y+r/F9bow9subVWzXgTuAHTRv8mZgt2uZUKWkn5/oBHsQIsJPu6nX/rfGG/g7V+fGqKYVDwT7g/bTxR7DAjVUE1oWkTL2dfOuK2HXKu/yIgMZndFIAccCgYEA9+GghdabPd7LvKtcNrhXuXmUr7v6OuqC+VdMCz0HgmdRWVeOutRZT+ZxBxCBgLRJFnEj6EwoFhO3zwkyjMim4TwWeotUfI0o4KOuHiuzpnWRbqN/C/ohNWLx+2J6ASQ7zKTxvqhRkImog9/hWuWfBpKLZl6Ae1UlZAFMO/7PSSoCAgIABEMCQQDfg2OOQ+Rz4eRaatC0AKhNtA5i7KIrss7uM7Vtv2ls7zRCKWwXP5nRdbZAlO96tS1vF9AIZsYI82e8fQSBVfbX
乙方公钥：MIIBpjCCARsGCSqGSIb3DQEDATCCAQwCgYEA/X9TgR11EilS30qcLuzk5/YRt1I870QAwx4/gLZRJmlFXUAiUftZPY1Y+r/F9bow9subVWzXgTuAHTRv8mZgt2uZUKWkn5/oBHsQIsJPu6nX/rfGG/g7V+fGqKYVDwT7g/bTxR7DAjVUE1oWkTL2dfOuK2HXKu/yIgMZndFIAccCgYEA9+GghdabPd7LvKtcNrhXuXmUr7v6OuqC+VdMCz0HgmdRWVeOutRZT+ZxBxCBgLRJFnEj6EwoFhO3zwkyjMim4TwWeotUfI0o4KOuHiuzpnWRbqN/C/ohNWLx+2J6ASQ7zKTxvqhRkImog9/hWuWfBpKLZl6Ae1UlZAFMO/7PSSoCAgIAA4GEAAKBgDtzbZB/0vIobewwv7mUGGS54TBuNGf6wl3lLsAfTKylvzD2//qPqTJVXBGy9ZInHMYOwLb5nn85l8oULoXsp0uwZe2cFpmgJfRFpRD2FH+ZahBbtb7zgdsB30t0y42Qed+bL/o8znzv5yE1E6/z2iQdKhCRc52254hWgUVDkrH5
—————————————–
对称算法：DES
加密：zBJhlhWDFme0qIlClaBUQw==
解密：jianggujin
输出流加密：F:\workspace\java\eclipse\JCodec\DHTest.dat
输入流解密：jianggujin
—————————————–
对称算法：DESede
加密：0TFsnTdcA3JuJH2ZYn1ZcQ==
解密：jianggujin
输出流加密：F:\workspace\java\eclipse\JCodec\DHTest.dat
输入流解密：jianggujin

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/jianggujin/article/details/50537103

内容来源于网络，如有侵权，请联系作者删除！

Javajava加密解密加密解密dh

相关文章

    查看更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com