JAVA加密解密

文章16 |   阅读 8319 |   点赞0

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

JAVA加密解密之数字证书

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

系统之间在进行交互的时候，我们经常会用到数字证书，数字证书可以帮我们验证身份等，下面我们就来看一下在java中如何使用数字证书。
我们先使用keytool工具生成密钥库并导出公钥证书。
第一步：生成keyStroe文件
执行如下命令：
keytool -genkey -validity 36000 -alias www.jianggujin.com -keyalg RSA -keystore test.keystore

该命令相关参数如下：

输入完后，我们需要按照提示完成后续信息的输入，这里面我们使用的密码为：123456

第二步：导出公钥证书
生成完密钥库后，我们就可以导出公钥文件了，执行如下命令：
keytool -export -keystore test.keystore -alias www.jianggujin.com -file test.cer -rfc

该命令相关参数如下：

完整操作过程如下：

经过这两步后，我们就有了密钥库和证书文件，和之前的加密解密工具类一样，我们再来编写一个用于操作数字证书的工具类：

  1. package com.jianggujin.codec;
  3. import java.io.InputStream;
  4. import java.io.OutputStream;
  5. import java.security.Key;
  6. import java.security.KeyStore;
  7. import java.security.KeyStoreException;
  8. import java.security.NoSuchAlgorithmException;
  9. import java.security.PrivateKey;
  10. import java.security.PublicKey;
  11. import java.security.UnrecoverableKeyException;
  12. import java.security.cert.Certificate;
  13. import java.security.cert.CertificateExpiredException;
  14. import java.security.cert.CertificateFactory;
  15. import java.security.cert.CertificateNotYetValidException;
  16. import java.security.cert.X509Certificate;
  17. import java.util.ArrayList;
  18. import java.util.Date;
  19. import java.util.Enumeration;
  20. import java.util.List;
  22. import javax.crypto.Cipher;
  24. import com.jianggujin.codec.util.JCipherInputStream;
  25. import com.jianggujin.codec.util.JCipherOutputStream;
  26. import com.jianggujin.codec.util.JCodecException;
  27. import com.jianggujin.codec.util.JCodecUtils;
  29. /** * 数字证书 * * @author jianggujin * */
  30. public class JCertificate {
  31.    public final static String X509 = "X.509";
  33.    /** * 密钥库枚举 * * @author jianggujin * */
  34.    public static enum JKeyStore {
  36.       JCEKS, JKS, DKS, PKCS11, PKCS12;
  38.       public String getName() {
  39.          return this.name();
  40.       }
  41.    }
  43.    /** * 获得{@link KeyStore} * * @param in * @param password * @param keyStore * @return */
  44.    public static KeyStore getKeyStore(InputStream in, char[] password, JKeyStore keyStore) {
  45.       return getKeyStore(in, password, keyStore.getName());
  46.    }
  48.    /** * 获得{@link KeyStore} * * @param in * @param password * @param keyStore * @return * @throws Exception */
  49.    public static KeyStore getKeyStore(InputStream in, char[] password, String keyStore) {
  50.       try {
  51.          KeyStore ks = KeyStore.getInstance(keyStore);
  52.          ks.load(in, password);
  53.          return ks;
  54.       } catch (Exception e) {
  55.          throw new JCodecException(e);
  56.       }
  57.    }
  59.    /** * 列出别名 * * @param keyStore * @return */
  60.    public static List<String> listAlias(KeyStore keyStore) {
  61.       try {
  62.          Enumeration<String> aliasEnum = keyStore.aliases();
  63.          List<String> aliases = new ArrayList<String>();
  64.          while (aliasEnum.hasMoreElements()) {
  65.             aliases.add(aliasEnum.nextElement());
  66.          }
  67.          return aliases;
  68.       } catch (KeyStoreException e) {
  69.          throw new JCodecException(e);
  70.       }
  71.    }
  73.    /** * 获得私钥 * * @param keyStore * @param alias * @param password * @return */
  74.    public static PrivateKey getPrivateKey(KeyStore keyStore, String alias, char[] password) {
  75.       try {
  76.          PrivateKey key = (PrivateKey) keyStore.getKey(alias, password);
  77.          return key;
  78.       } catch (Exception e) {
  79.          throw new JCodecException(e);
  80.       }
  81.    }
  83.    /** * 获得私钥 * * @param in * @param alias * @param password * @param keyStore * @return */
  84.    public static PrivateKey getPrivateKey(InputStream in, String alias, char[] password, JKeyStore keyStore) {
  85.       return getPrivateKey(in, alias, password, keyStore.getName());
  86.    }
  88.    /** * 获得私钥 * * @param in * @param alias * @param password * @param keyStore * @return * @throws Exception */
  89.    public static PrivateKey getPrivateKey(InputStream in, String alias, char[] password, String keyStore) {
  90.       try {
  91.          KeyStore ks = getKeyStore(in, password, keyStore);
  92.          PrivateKey key = (PrivateKey) ks.getKey(alias, password);
  93.          return key;
  94.       } catch (Exception e) {
  95.          throw new JCodecException(e);
  96.       }
  97.    }
  99.    /** * 获得{@link Certificate} * * @param in * @return */
  100.    public static Certificate getCertificate(InputStream in) {
  101.       try {
  102.          CertificateFactory certificateFactory = CertificateFactory.getInstance(X509);
  103.          Certificate certificate = certificateFactory.generateCertificate(in);
  104.          return certificate;
  105.       } catch (Exception e) {
  106.          throw new JCodecException(e);
  107.       }
  108.    }
  110.    /** * 获得{@link Certificate} * * @param in * @param alias * @param password * @param keyStore * @return */
  111.    public static Certificate getCertificate(InputStream in, String alias, char[] password, JKeyStore keyStore) {
  112.       return getCertificate(in, alias, password, keyStore.getName());
  113.    }
  115.    /** * 获得{@link Certificate} * * @param in * @param alias * @param password * @param keyStore * @return */
  116.    public static Certificate getCertificate(InputStream in, String alias, char[] password, String keyStore) {
  117.       KeyStore ks = getKeyStore(in, password, keyStore);
  118.       return getCertificate(ks, alias);
  119.    }
  121.    /** * 获得{@link Certificate} * * @param keyStore * @param alias * @return */
  122.    public static Certificate getCertificate(KeyStore keyStore, String alias) {
  123.       try {
  124.          Certificate certificate = keyStore.getCertificate(alias);
  125.          return certificate;
  126.       } catch (Exception e) {
  127.          throw new JCodecException(e);
  128.       }
  129.    }
  131.    /** * 获得证书链 * * @param in * @param alias * @param password * @param keyStore * @return */
  132.    public static Certificate[] getCertificateChain(InputStream in, String alias, char[] password, JKeyStore keyStore) {
  133.       return getCertificateChain(in, alias, password, keyStore.getName());
  134.    }
  136.    /** * 获得证书链 * * @param in * @param alias * @param password * @param keyStore * @return */
  137.    public static Certificate[] getCertificateChain(InputStream in, String alias, char[] password, String keyStore) {
  138.       KeyStore ks = getKeyStore(in, password, keyStore);
  139.       return getCertificateChain(ks, alias);
  140.    }
  142.    /** * 获得证书链 * * @param keyStore * @param alias * @return */
  143.    public static Certificate[] getCertificateChain(KeyStore keyStore, String alias) {
  144.       try {
  145.          Certificate[] certificateChain = keyStore.getCertificateChain(alias);
  146.          return certificateChain;
  147.       } catch (Exception e) {
  148.          throw new JCodecException(e);
  149.       }
  150.    }
  152.    /** * 获得公钥 * * @param certificate * @return */
  153.    public static PublicKey getPublicKey(Certificate certificate) {
  154.       PublicKey key = certificate.getPublicKey();
  155.       return key;
  156.    }
  158.    /** * 获得公钥 * * @param in * @return */
  159.    public static PublicKey getPublicKey(InputStream in) {
  160.       Certificate certificate = getCertificate(in);
  161.       return getPublicKey(certificate);
  162.    }
  164.    /** * 获得公钥 * * @param in * @param alias * @param password * @param keyStore * @return */
  165.    public static PublicKey getPublicKey(InputStream in, String alias, char[] password, JKeyStore keyStore) {
  166.       return getPublicKey(in, alias, password, keyStore.getName());
  167.    }
  169.    /** * 获得公钥 * * @param in * @param alias * @param password * @param keyStore * @return */
  170.    public static PublicKey getPublicKey(InputStream in, String alias, char[] password, String keyStore) {
  171.       Certificate certificate = getCertificate(in, alias, password, keyStore);
  172.       return getPublicKey(certificate);
  173.    }
  175.    /** * 获得公钥 * * @param keyStore * @param alias * @return */
  176.    public static PublicKey getPublicKey(KeyStore keyStore, String alias) {
  177.       Certificate certificate = getCertificate(keyStore, alias);
  178.       return getPublicKey(certificate);
  179.    }
  181.    /** * 验证{@link Certificate}是否过期或无效 * * @param date * @param certificate * @return */
  182.    public static boolean verifyCertificate(Date date, Certificate certificate) {
  183.       X509Certificate x509Certificate = (X509Certificate) certificate;
  184.       try {
  185.          x509Certificate.checkValidity(date);
  186.          return true;
  187.       } catch (CertificateExpiredException e1) {
  188.          return false;
  189.       } catch (CertificateNotYetValidException e1) {
  190.          return false;
  191.       }
  192.    }
  194.    /** * 验证{@link Certificate}是否过期或无效 * * @param certificate * @return */
  195.    public static boolean verifyCertificate(Certificate certificate) {
  196.       return verifyCertificate(new Date(), certificate);
  197.    }
  199.    /** * 验证{@link Certificate}是否过期或无效 * * @param in * @return */
  200.    public static boolean verifyCertificate(InputStream in) {
  201.       Certificate certificate = getCertificate(in);
  202.       return verifyCertificate(certificate);
  203.    }
  205.    /** * 验证{@link Certificate}是否过期或无效 * * @param date * @param in * @return */
  206.    public static boolean verifyCertificate(Date date, InputStream in) {
  207.       Certificate certificate = getCertificate(in);
  208.       return verifyCertificate(date, certificate);
  209.    }
  211.    /** * 验证{@link Certificate}是否过期或无效 * * @param in * @param alias * @param password * @param keyStore * @return */
  212.    public static boolean verifyCertificate(InputStream in, String alias, char[] password, JKeyStore keyStore) {
  213.       return verifyCertificate(in, alias, password, keyStore.getName());
  214.    }
  216.    /** * 验证{@link Certificate}是否过期或无效 * * @param in * @param alias * @param password * @param keyStore * @return */
  217.    public static boolean verifyCertificate(InputStream in, String alias, char[] password, String keyStore) {
  218.       Certificate certificate = getCertificate(in, alias, password, keyStore);
  219.       return verifyCertificate(certificate);
  220.    }
  222.    /** * 验证{@link Certificate}是否过期或无效 * * @param date * @param in * @param alias * @param password * @param keyStore * @return */
  223.    public static boolean verifyCertificate(Date date, InputStream in, String alias, char[] password,
  224.          JKeyStore keyStore) {
  225.       return verifyCertificate(date, in, alias, password, keyStore.getName());
  226.    }
  228.    /** * 验证{@link Certificate}是否过期或无效 * * @param date * @param in * @param alias * @param password * @param keyStore * @return */
  229.    public static boolean verifyCertificate(Date date, InputStream in, String alias, char[] password, String keyStore) {
  230.       Certificate certificate = getCertificate(in, alias, password, keyStore);
  231.       return verifyCertificate(date, certificate);
  232.    }
  234.    /** * 验证{@link Certificate}是否过期或无效 * * @param keyStore * @param alias * @return */
  235.    public static boolean verifyCertificate(KeyStore keyStore, String alias) {
  236.       Certificate certificate = getCertificate(keyStore, alias);
  237.       return verifyCertificate(certificate);
  238.    }
  240.    /** * 验证{@link Certificate}是否过期或无效 * * @param date * @param keyStore * @param alias * @return */
  241.    public static boolean verifyCertificate(Date date, KeyStore keyStore, String alias) {
  242.       Certificate certificate = getCertificate(keyStore, alias);
  243.       return verifyCertificate(date, certificate);
  244.    }
  246.    /** * 签名 * * @param data * @param in * @param alias * @param password * @param keyStore * @return */
  247.    public static byte[] sign(byte[] data, InputStream in, String alias, char[] password, JKeyStore keyStore) {
  248.       return sign(data, in, alias, password, keyStore.getName());
  249.    }
  251.    /** * 签名 * * @param data * @param in * @param alias * @param password * @param keyStore * @return */
  252.    public static byte[] sign(byte[] data, InputStream in, String alias, char[] password, String keyStore) {
  253.       // 获得证书
  254.       Certificate certificate = getCertificate(in, alias, password, keyStore);
  255.       // 取得私钥
  256.       PrivateKey privateKey = getPrivateKey(in, alias, password, keyStore);
  257.       return sign(data, certificate, privateKey);
  258.    }
  260.    /** * 签名 * * @param data * @param keyStore * @param alias * @param password * @return */
  261.    public static byte[] sign(byte[] data, KeyStore keyStore, String alias, char[] password) {
  262.       // 获得证书
  263.       Certificate certificate = getCertificate(keyStore, alias);
  264.       // 取得私钥
  265.       PrivateKey privateKey = getPrivateKey(keyStore, alias, password);
  266.       return sign(data, certificate, privateKey);
  267.    }
  269.    /** * 签名 * * @param data * @param certificate * @param privateKey * @return */
  270.    public static byte[] sign(byte[] data, Certificate certificate, PrivateKey privateKey) {
  271.       // 获得证书
  272.       X509Certificate x509Certificate = (X509Certificate) certificate;
  273.       return sign(data, privateKey, x509Certificate.getSigAlgName());
  274.    }
  276.    /** * 签名 * * @param data * @param privateKey * @param signatureAlgorithm * @return */
  277.    public static byte[] sign(byte[] data, PrivateKey privateKey, String signatureAlgorithm) {
  278.       return JCodecUtils.sign(data, privateKey, signatureAlgorithm);
  279.    }
  281.    /** * 验签 * * @param data * @param sign * @param in * @return */
  282.    public static boolean verify(byte[] data, byte[] sign, InputStream in) {
  283.       // 获得证书
  284.       Certificate certificate = getCertificate(in);
  286.       return verify(data, sign, certificate);
  287.    }
  289.    /** * 验签 * * @param data * @param sign * @param certificate * @return */
  290.    public static boolean verify(byte[] data, byte[] sign, Certificate certificate) {
  291.       // 获得证书
  292.       X509Certificate x509Certificate = (X509Certificate) certificate;
  293.       // 获得公钥
  294.       PublicKey publicKey = x509Certificate.getPublicKey();
  295.       return verify(data, sign, publicKey, x509Certificate.getSigAlgName());
  296.    }
  298.    /** * 验签 * * @param data * @param sign * @param publicKey * @param signatureAlgorithm * @return */
  299.    public static boolean verify(byte[] data, byte[] sign, PublicKey publicKey, String signatureAlgorithm) {
  300.       return JCodecUtils.verify(data, sign, publicKey, signatureAlgorithm);
  301.    }
  303.    /** * 验签 * * @param data * @param sign * @param keyStore * @param alias * @return */
  304.    public static boolean verify(byte[] data, byte[] sign, KeyStore keyStore, String alias) {
  305.       Certificate certificate = getCertificate(keyStore, alias);
  306.       return verify(data, sign, certificate);
  307.    }
  309.    /** * 验签，遍历密钥库中的所有公钥 * * @param data * @param sign * @param keyStore * @return */
  310.    public static boolean verify(byte[] data, byte[] sign, KeyStore keyStore) {
  311.       try {
  312.          Enumeration<String> aliasEnum = keyStore.aliases();
  313.          while (aliasEnum.hasMoreElements()) {
  314.             if (verify(data, sign, keyStore.getCertificate(aliasEnum.nextElement())))
  315.                return true;
  316.          }
  317.       } catch (KeyStoreException e) {
  318.          throw new JCodecException(e);
  319.       }
  320.       return false;
  321.    }
  323.    /** * 私钥加密 * * @param data * @param in * @param alias * @param password * @param keyStore * @return */
  324.    public static byte[] encryptByPrivate(byte[] data, InputStream in, String alias, char[] password,
  325.          JKeyStore keyStore) {
  326.       return encryptByPrivate(data, in, alias, password, keyStore.getName());
  327.    }
  329.    /** * 私钥加密 * * @param data * @param in * @param alias * @param password * @param keyStore * @return */
  330.    public static byte[] encryptByPrivate(byte[] data, InputStream in, String alias, char[] password, String keyStore) {
  331.       PrivateKey privateKey = getPrivateKey(in, alias, password, keyStore);
  332.       return encrypt(data, privateKey);
  333.    }
  335.    /** * 私钥加密 * * @param data * @param keyStore * @param alias * @param password * @return */
  336.    public static byte[] encryptByPrivate(byte[] data, KeyStore keyStore, String alias, char[] password) {
  337.       PrivateKey privateKey = getPrivateKey(keyStore, alias, password);
  338.       return encrypt(data, privateKey);
  339.    }
  341.    /** * 私钥加密 * * @param data * @param privateKey * @return */
  342.    public static byte[] encrypt(byte[] data, PrivateKey privateKey) {
  343.       Cipher cipher = getCipher(privateKey, Cipher.ENCRYPT_MODE);
  344.       return JCodecUtils.doFinal(data, cipher);
  345.    }
  347.    public static OutputStream wrapByPrivate(OutputStream out, InputStream in, String alias, char[] password,
  348.          JKeyStore keyStore) {
  349.       return wrapByPrivate(out, in, alias, password, keyStore.getName());
  350.    }
  352.    public static OutputStream wrapByPrivate(OutputStream out, InputStream in, String alias, char[] password,
  353.          String keyStore) {
  354.       PrivateKey privateKey = getPrivateKey(in, alias, password, keyStore);
  355.       return wrap(out, privateKey);
  356.    }
  358.    public static OutputStream wrapByPrivate(OutputStream out, KeyStore keyStore, String alias, char[] password) {
  359.       PrivateKey privateKey = getPrivateKey(keyStore, alias, password);
  360.       return wrap(out, privateKey);
  361.    }
  363.    public static OutputStream wrap(OutputStream out, PrivateKey privateKey) {
  364.       Cipher cipher = getCipher(privateKey, Cipher.ENCRYPT_MODE);
  365.       return new JCipherOutputStream(cipher, out);
  366.    }
  368.    /** * 公钥加密 * * @param data * @param certificate * @return */
  369.    public static byte[] encrypt(byte[] data, Certificate certificate) {
  370.       PublicKey publicKey = certificate.getPublicKey();
  371.       return encrypt(data, publicKey);
  372.    }
  374.    /** * 公钥加密 * * @param data * @param in * @return */
  375.    public static byte[] encryptByPublic(byte[] data, InputStream in) {
  376.       PublicKey publicKey = getPublicKey(in);
  377.       return encrypt(data, publicKey);
  378.    }
  380.    /** * 公钥加密 * * @param data * @param in * @param alias * @param password * @param keyStore * @return */
  381.    public static byte[] encryptByPublic(byte[] data, InputStream in, String alias, char[] password,
  382.          JKeyStore keyStore) {
  383.       return encryptByPublic(data, in, alias, password, keyStore.getName());
  384.    }
  386.    /** * 公钥加密 * * @param data * @param in * @param alias * @param password * @param keyStore * @return */
  387.    public static byte[] encryptByPublic(byte[] data, InputStream in, String alias, char[] password, String keyStore) {
  388.       PublicKey publicKey = getPublicKey(in, alias, password, keyStore);
  389.       return encrypt(data, publicKey);
  390.    }
  392.    /** * 公钥加密 * * @param data * @param keyStore * @param alias * @return */
  393.    public static byte[] encryptByPublic(byte[] data, KeyStore keyStore, String alias) {
  394.       PublicKey publicKey = getPublicKey(keyStore, alias);
  395.       return encrypt(data, publicKey);
  396.    }
  398.    /** * 公钥加密 * * @param data * @param publicKey * @return */
  399.    public static byte[] encrypt(byte[] data, PublicKey publicKey) {
  400.       Cipher cipher = getCipher(publicKey, Cipher.ENCRYPT_MODE);
  401.       return JCodecUtils.doFinal(data, cipher);
  402.    }
  404.    public static OutputStream wrap(OutputStream out, Certificate certificate) {
  405.       PublicKey publicKey = certificate.getPublicKey();
  406.       return wrap(out, publicKey);
  407.    }
  409.    public static OutputStream wrapByPublic(OutputStream out, InputStream in) {
  410.       PublicKey publicKey = getPublicKey(in);
  411.       return wrap(out, publicKey);
  412.    }
  414.    public static OutputStream wrapByPublic(OutputStream out, InputStream in, String alias, char[] password,
  415.          JKeyStore keyStore) {
  416.       return wrapByPublic(out, in, alias, password, keyStore.getName());
  417.    }
  419.    public static OutputStream wrapByPublic(OutputStream out, InputStream in, String alias, char[] password,
  420.          String keyStore) {
  421.       PublicKey publicKey = getPublicKey(in, alias, password, keyStore);
  422.       return wrap(out, publicKey);
  423.    }
  425.    public static OutputStream wrapByPublic(OutputStream out, KeyStore keyStore, String alias) {
  426.       PublicKey publicKey = getPublicKey(keyStore, alias);
  427.       return wrap(out, publicKey);
  428.    }
  430.    public static OutputStream wrap(OutputStream out, PublicKey publicKey) {
  431.       Cipher cipher = getCipher(publicKey, Cipher.ENCRYPT_MODE);
  432.       return new JCipherOutputStream(cipher, out);
  433.    }
  435.    /** * 私钥解密 * * @param data * @param in * @param alias * @param password * @param keyStore * @return */
  436.    public static byte[] decryptByPrivate(byte[] data, InputStream in, String alias, char[] password,
  437.          JKeyStore keyStore) {
  438.       return decryptByPrivate(data, in, alias, password, keyStore.getName());
  439.    }
  441.    /** * 私钥解密 * * @param data * @param in * @param alias * @param password * @param keyStore * @return */
  442.    public static byte[] decryptByPrivate(byte[] data, InputStream in, String alias, char[] password, String keyStore) {
  443.       PrivateKey privateKey = getPrivateKey(in, alias, password, keyStore);
  444.       return decrypt(data, privateKey);
  445.    }
  447.    /** * 私钥解密 * * @param data * @param keyStore * @param alias * @param password * @return */
  448.    public static byte[] decryptByPrivate(byte[] data, KeyStore keyStore, String alias, char[] password) {
  449.       // 取得私钥
  450.       PrivateKey privateKey = getPrivateKey(keyStore, alias, password);
  451.       return decrypt(data, privateKey);
  452.    }
  454.    /** * 私钥解密 * * @param data * @param privateKey * @return */
  455.    public static byte[] decrypt(byte[] data, PrivateKey privateKey) {
  456.       Cipher cipher = getCipher(privateKey, Cipher.DECRYPT_MODE);
  457.       return JCodecUtils.doFinal(data, cipher);
  458.    }
  460.    public static InputStream wrapByPrivate(InputStream sIn, InputStream in, String alias, char[] password,
  461.          JKeyStore keyStore) {
  462.       return wrapByPrivate(sIn, in, alias, password, keyStore.getName());
  463.    }
  465.    public static InputStream wrapByPrivate(InputStream sIn, InputStream in, String alias, char[] password,
  466.          String keyStore) {
  467.       PrivateKey privateKey = getPrivateKey(in, alias, password, keyStore);
  468.       return wrap(sIn, privateKey);
  469.    }
  471.    public static InputStream wrapByPrivate(InputStream sIn, KeyStore keyStore, String alias, char[] password) {
  472.       PrivateKey privateKey = getPrivateKey(keyStore, alias, password);
  473.       return wrap(sIn, privateKey);
  474.    }
  476.    public static InputStream wrap(InputStream sIn, PrivateKey privateKey) {
  477.       Cipher cipher = getCipher(privateKey, Cipher.ENCRYPT_MODE);
  478.       return new JCipherInputStream(cipher, sIn);
  479.    }
  481.    /** * 公钥解密 * * @param data * @param certificate * @return */
  482.    public static byte[] decrypt(byte[] data, Certificate certificate) {
  483.       PublicKey publicKey = certificate.getPublicKey();
  484.       return decrypt(data, publicKey);
  485.    }
  487.    /** * 公钥解密 * * @param data * @param in * @return */
  488.    public static byte[] decryptByPublic(byte[] data, InputStream in) {
  489.       PublicKey publicKey = getPublicKey(in);
  490.       return decrypt(data, publicKey);
  491.    }
  493.    /** * 公钥解密 * * @param data * @param in * @param alias * @param password * @param keyStore * @return */
  494.    public static byte[] decryptByPublic(byte[] data, InputStream in, String alias, char[] password,
  495.          JKeyStore keyStore) {
  496.       return decryptByPublic(data, in, alias, password, keyStore.getName());
  497.    }
  499.    /** * 公钥解密 * * @param data * @param in * @param alias * @param password * @param keyStore * @return */
  500.    public static byte[] decryptByPublic(byte[] data, InputStream in, String alias, char[] password, String keyStore) {
  501.       PublicKey publicKey = getPublicKey(in, alias, password, keyStore);
  502.       return decrypt(data, publicKey);
  503.    }
  505.    /** * 公钥解密 * * @param data * @param keyStore * @param alias * @return */
  506.    public static byte[] decryptByPublic(byte[] data, KeyStore keyStore, String alias) {
  507.       PublicKey publicKey = getPublicKey(keyStore, alias);
  508.       return decrypt(data, publicKey);
  509.    }
  511.    /** * 公钥解密 * * @param data * @param publicKey * @return */
  512.    public static byte[] decrypt(byte[] data, PublicKey publicKey) {
  513.       Cipher cipher = getCipher(publicKey, Cipher.DECRYPT_MODE);
  514.       return JCodecUtils.doFinal(data, cipher);
  515.    }
  517.    public static InputStream wrap(InputStream sIn, Certificate certificate) {
  518.       PublicKey publicKey = certificate.getPublicKey();
  519.       return wrap(sIn, publicKey);
  520.    }
  522.    public static InputStream wrapByPublic(InputStream sIn, InputStream in) {
  523.       PublicKey publicKey = getPublicKey(in);
  524.       return wrap(sIn, publicKey);
  525.    }
  527.    public static InputStream wrapByPublic(InputStream sIn, InputStream in, String alias, char[] password,
  528.          JKeyStore keyStore) {
  529.       return wrapByPublic(sIn, in, alias, password, keyStore.getName());
  530.    }
  532.    public static InputStream wrapByPublic(InputStream sIn, InputStream in, String alias, char[] password,
  533.          String keyStore) {
  534.       PublicKey publicKey = getPublicKey(in, alias, password, keyStore);
  535.       return wrap(sIn, publicKey);
  536.    }
  538.    public static InputStream wrapByPublic(InputStream sIn, KeyStore keyStore, String alias) {
  539.       PublicKey publicKey = getPublicKey(keyStore, alias);
  540.       return wrap(sIn, publicKey);
  541.    }
  543.    public static InputStream wrap(InputStream sIn, PublicKey publicKey) {
  544.       Cipher cipher = getCipher(publicKey, Cipher.DECRYPT_MODE);
  545.       return new JCipherInputStream(cipher, sIn);
  546.    }
  548.    public static Cipher getCipher(Key key, int opmode) {
  549.       JCodecUtils.checkOpMode(opmode);
  550.       try {
  551.          Cipher cipher = Cipher.getInstance(key.getAlgorithm());
  552.          cipher.init(opmode, key);
  553.          return cipher;
  554.       } catch (Exception e) {
  555.          throw new JCodecException(e);
  556.       }
  557.    }
  559.    /** * 导出公钥证书 * * @param out * @param certificate * @param rfc */
  560.    public static void export(OutputStream out, Certificate certificate, boolean rfc) {
  561.       try {
  562.          byte[] encoded = certificate.getEncoded();
  563.          if (rfc) {
  564.             out.write("-----BEGIN CERTIFICATE-----\r\n".getBytes());
  565.             out.write(JBase64.getMimeEncoder().encode(encoded));
  566.             out.write("\r\n-----END CERTIFICATE-----\r\n".getBytes());
  567.          } else out.write(encoded);
  568.          out.flush();
  569.       } catch (Exception e) {
  570.          throw new JCodecException(e);
  571.       }
  572.    }
  574.    /** * 将密钥库转换为指定类型的密钥库 * * @param srcKeyStore * @param target * @param password * @param alias * 导出指定别名的证书 * @return */
  575.    public static KeyStore convert(KeyStore srcKeyStore, JKeyStore target, char[] password, String... alias) {
  576.       return convert(srcKeyStore, target.getName(), password, alias);
  577.    }
  579.    /** * 将密钥库转换为指定类型的密钥库 * * @param srcKeyStore * @param target * @param password * @param alias * 导出指定别名的证书 * @return */
  580.    public static KeyStore convert(KeyStore srcKeyStore, String target, char[] password, String... alias) {
  581.       try {
  582.          KeyStore outputKeyStore = KeyStore.getInstance(target);
  583.          outputKeyStore.load(null, password);
  584.          if (alias.length == 0) {
  585.             Enumeration<String> enums = srcKeyStore.aliases();
  586.             while (enums.hasMoreElements()) {
  587.                String keyAlias = enums.nextElement();
  588.                copyKeyEntry(srcKeyStore, outputKeyStore, keyAlias, password);
  589.             }
  590.          } else {
  591.             for (String keyAlias : alias) {
  592.                copyKeyEntry(srcKeyStore, outputKeyStore, keyAlias, password);
  593.             }
  594.          }
  595.          return outputKeyStore;
  596.       } catch (Exception e) {
  597.          throw new JCodecException(e);
  598.       }
  599.    }
  601.    /** * 复制 * * @param src * @param target * @param alias * @param password * @throws UnrecoverableKeyException * @throws KeyStoreException * @throws NoSuchAlgorithmException */
  602.    public static void copyKeyEntry(KeyStore src, KeyStore target, String alias, char[] password)
  603.          throws UnrecoverableKeyException, KeyStoreException, NoSuchAlgorithmException {
  604.       if (src.isKeyEntry(alias)) {
  605.          Key key = src.getKey(alias, password);
  606.          Certificate[] certChain = src.getCertificateChain(alias);
  607.          target.setKeyEntry(alias, key, password, certChain);
  608.       }
  609.    }
  610. }
  1. package com.jianggujin.codec.util;
  3. import java.security.KeyFactory;
  4. import java.security.KeyPair;
  5. import java.security.KeyPairGenerator;
  6. import java.security.PrivateKey;
  7. import java.security.PublicKey;
  8. import java.security.Signature;
  9. import java.security.spec.PKCS8EncodedKeySpec;
  10. import java.security.spec.X509EncodedKeySpec;
  12. import javax.crypto.Cipher;
  13. import javax.crypto.KeyGenerator;
  14. import javax.crypto.SecretKey;
  16. /** * 加解密工具 * * @author jianggujin * */
  17. public class JCodecUtils {
  18.    /** * 获得私钥 * * @param privateKey * @param algorithm * @return */
  19.    public static PrivateKey getPrivateKey(byte[] privateKey, String algorithm) {
  20.       try {
  21.          PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(privateKey);
  22.          KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
  23.          return keyFactory.generatePrivate(pkcs8KeySpec);
  24.       } catch (Exception e) {
  25.          throw new JCodecException(e);
  26.       }
  27.    }
  29.    /** * 获得公钥 * * @param publicKey * @param algorithm * @return */
  30.    public static PublicKey getPublicKey(byte[] publicKey, String algorithm) {
  31.       try {
  32.          X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKey);
  33.          KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
  34.          return keyFactory.generatePublic(keySpec);
  35.       } catch (Exception e) {
  36.          throw new JCodecException(e);
  37.       }
  38.    }
  40.    /** * 检查加解密操作模式 * * @param opmode */
  41.    public static void checkOpMode(int opmode) {
  42.       if (opmode != Cipher.ENCRYPT_MODE && opmode != Cipher.DECRYPT_MODE)
  43.          throw new IllegalArgumentException("opmode invalid");
  44.    }
  46.    /** * 签名 * * @param data * @param privateKey * @param signatureAlgorithm * @return */
  47.    public static byte[] sign(byte[] data, PrivateKey privateKey, String signatureAlgorithm) {
  48.       try {
  49.          Signature signature = Signature.getInstance(signatureAlgorithm);
  50.          signature.initSign(privateKey);
  51.          signature.update(data);
  52.          return signature.sign();
  53.       } catch (Exception e) {
  54.          throw new JCodecException(e);
  55.       }
  56.    }
  58.    /** * 验签 * * @param data * @param sign * @param publicKey * @param signatureAlgorithm * @return */
  59.    public static boolean verify(byte[] data, byte[] sign, PublicKey publicKey, String signatureAlgorithm) {
  60.       try {
  61.          Signature signature = Signature.getInstance(signatureAlgorithm);
  62.          signature.initVerify(publicKey);
  63.          signature.update(data);
  65.          return signature.verify(sign);
  66.       } catch (Exception e) {
  67.          throw new JCodecException(e);
  68.       }
  69.    }
  71.    /** * 按单部分操作加密或解密数据，或者结束一个多部分操作 * * @param data * @param cipher * @return */
  72.    public static byte[] doFinal(byte[] data, Cipher cipher) {
  73.       try {
  74.          return cipher.doFinal(data);
  75.       } catch (Exception e) {
  76.          throw new JCodecException(e);
  77.       }
  78.    }
  80.    /** * 初始化密钥 * * @param algorithm * @param keySize * @return */
  81.    public static KeyPair initKey(String algorithm, int keySize) {
  82.       try {
  83.          KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(algorithm);
  84.          keyPairGen.initialize(keySize);
  85.          return keyPairGen.generateKeyPair();
  86.       } catch (Exception e) {
  87.          throw new JCodecException(e);
  88.       }
  89.    }
  91.    /** * 初始化密钥 * * @param algorithm * @return */
  92.    public static SecretKey initKey(String algorithm) {
  93.       try {
  94.          KeyGenerator keyGenerator = KeyGenerator.getInstance(algorithm);
  95.          SecretKey secretKey = keyGenerator.generateKey();
  96.          return secretKey;
  97.       } catch (Exception e) {
  98.          throw new JCodecException(e);
  99.       }
  100.    }
  102. }

编写测试工具类，使用我们刚才生成的密钥库和证书文件进行测试：

  1. package com.jianggujin.codec.test;
  3. import java.io.FileOutputStream;
  4. import java.security.KeyStore;
  5. import java.security.PrivateKey;
  6. import java.security.PublicKey;
  7. import java.security.cert.X509Certificate;
  8. import java.text.SimpleDateFormat;
  10. import org.junit.Test;
  12. import com.jianggujin.codec.JBase64;
  13. import com.jianggujin.codec.JCertificate;
  14. import com.jianggujin.codec.JCertificate.JKeyStore;
  16. public class CertificateTest {
  17.    @Test
  18.    public void encode() throws Exception {
  19.       SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  20.       char[] password = "123456".toCharArray();
  21.       String alias = "www.jianggujin.com";
  22.       String certificatePath = "test.cer";
  23.       String keyStorePath = "test.pfx";
  24.       byte[] data = "jianggujin".getBytes();
  26.       KeyStore keyStore = JCertificate.getKeyStore(getClass().getResourceAsStream(keyStorePath), password,
  27.             JKeyStore.JKS);
  28.       X509Certificate certificate = (X509Certificate) JCertificate
  29.             .getCertificate(getClass().getResourceAsStream(certificatePath));
  30.       PrivateKey privateKey = JCertificate.getPrivateKey(keyStore, alias, password);
  31.       PublicKey publicKey = JCertificate.getPublicKey(certificate);
  33.       System.out.println("是否有效：" + JCertificate.verifyCertificate(certificate));
  34.       System.out.println("使用者：" + certificate.getSubjectDN().getName());
  35.       System.out.println("版本：" + certificate.getVersion());
  36.       System.out.println("序列号：" + certificate.getSerialNumber().toString(16));
  37.       System.out.println("签名算法：" + certificate.getSigAlgName());
  38.       System.out.println("证书类型：" + certificate.getType());
  39.       System.out.println("颁发者：" + certificate.getIssuerDN().getName());
  40.       System.out.println(
  41.             "有效期：" + format.format(certificate.getNotBefore()) + "到" + format.format(certificate.getNotAfter()));
  43.       byte[] signResult = JCertificate.sign(data, keyStore, alias, password);
  44.       System.out.println("签名：" + JBase64.getEncoder().encodeToString(signResult, "UTF-8"));
  45.       System.out.println("证书验签：" + JCertificate.verify(data, signResult, certificate));
  46.       System.out.println("密钥库验签：" + JCertificate.verify(data, signResult, keyStore));
  48.       byte[] result = JCertificate.encrypt(data, privateKey);
  49.       System.out.println("私钥加密：" + JBase64.getEncoder().encodeToString(result, "UTF-8"));
  50.       System.out.println("公钥解密：" + new String(JCertificate.decrypt(result, publicKey)));
  52.       result = JCertificate.encrypt(data, publicKey);
  53.       System.out.println("公钥加密：" + JBase64.getEncoder().encodeToString(result, "UTF-8"));
  54.       System.out.println("私钥解密：" + new String(JCertificate.decrypt(result, privateKey)));
  55.    }
  57.    public void convert() throws Exception {
  58.       char[] password = "123456".toCharArray();
  59.       String keyStorePath = "test.keystore";
  61.       KeyStore keyStore = JCertificate.getKeyStore(getClass().getResourceAsStream(keyStorePath), password,
  62.             JKeyStore.JKS);
  63.       KeyStore target = JCertificate.convert(keyStore, JKeyStore.PKCS12, password);
  64.       for (String alias : JCertificate.listAlias(target)) {
  65.          System.out.println(alias);
  66.       }
  67.       target.store(new FileOutputStream("test.pfx"), password);
  68.    }
  69. }

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

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

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

Javajava加密解密加密解密数字证书

相关文章

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