基础文档

import javax.crypto.Mac;

import javax.crypto.spec.SecretKeySpec;

import java.io.UnsupportedEncodingException;

import java.security.InvalidKeyException;

import java.security.NoSuchAlgorithmException;

import java.text.DateFormat;

import java.text.SimpleDateFormat;

import java.util.*;

/**

* 获取参数签名

* @author 壹证通

*/

public class  GetSignature {

  /**密钥*/

  private static String secretKey = "XXX";

  private static String charset = "UTF-8";

  private static final String TIMESTAMP_FORMAT = "yyyy-MM-dd HH:mm:ss";

  private static final String ALGORITHM = "HmacSHA256";

  private static final Object LOCK = new Object();

  private static Mac macInstance;

  public static void main(String[] args) {

    Map<String, String> paramMap = new HashMap<String, String>(10);

    //公共参数

    paramMap.put("appKey", "XXX");

    paramMap.put("signMethod", "HMAC-SHA256");

    paramMap.put("signVersion", "1");

    paramMap.put("method", "XXX");

    paramMap.put("format", "JSON");

    paramMap.put("timestamp", getTime());

    paramMap.put("version", "1");

    paramMap.put("nonce", getNonce());

    //具体接口参数,如姓名实名认证

    paramMap.put("realname", "XXX");

    paramMap.put("idcard", "XXX");

    //获取待签名内容,排序

    String signContent = getSignatureContent(paramMap);

    System.out.println("待签名内容：" + signContent);

    //计算签名

    String sign = computeSignature(secretKey, signContent, charset);

    System.out.println("签名后：" + sign);

  }

  /**

  * 格式化时间

  */

  private static String getTime() {

    TimeZone tz = TimeZone.getTimeZone("UTC");

    DateFormat df = new SimpleDateFormat(TIMESTAMP_FORMAT);

    df.setTimeZone(tz);

    return df.format(new Date());

  }

  /**

  * 生成随机数

  */

  private static String getNonce(){

    Random random = new Random();

    return String.valueOf(random.nextInt(1000000000));

  }

  /**

  * 将参数按key值排序

  */

  public static String getSignatureContent(Map<String, String> paramMap) {

    Collection<String> keySet = paramMap.keySet();

    //签名内容

    StringBuilder content = new StringBuilder();

    //所有的键值

    List<String> keys = new ArrayList<String>(keySet);

    //排序

    Collections.sort(keys);

    //循环赋值

    for (String key : keys) {

      String value = paramMap.get(key);

      if (isNotEmpty(key) && isNotEmpty(value)) {

        content.append(key).append(value);

      }

    }

    return content.toString();

  }

  /**

  *字符串非空校验

  */

  private static boolean isNotEmpty(String str) {

    return str != null && str.length() != 0;

  }

  /**

  * 计算签名值

  */

  private static String computeSignature(String key, String data, String charset) {

    try {

      byte[] signData = sign(key.getBytes(charset), data.getBytes(charset));

      return byte2hex(signData);

    } catch (UnsupportedEncodingException ex) {

      throw new RuntimeException("不支持的算法: " + charset, ex);

    }

  }

  /**

  * 把字节流转换为十六进制表示方式。

  */

  private static String byte2hex(byte[] bytes) {

    StringBuilder sign = new StringBuilder();

    for (int i = 0; i < bytes.length; i++) {

      String hex = Integer.toHexString(bytes[i] & 0xFF);

      if (hex.length() == 1) {

        sign.append("0");

      }

      sign.append(hex.toUpperCase());

    }

    return sign.toString();

  }

  /**

  * 使用HMAC加密

  */

  private static byte[] sign(byte[] key, byte[] data) {

    try {

    //因为Mac类的getInstance()方法的调用时一个同步方法，可能被阻塞，所以使用原型模式来提高可靠性

      if (macInstance == null) {

       synchronized (LOCK) {

        if (macInstance == null) {

          macInstance = Mac.getInstance(ALGORITHM);

        }

      }

    }

    Mac mac;

    try {

      mac = (Mac) macInstance.clone();

    } catch (CloneNotSupportedException e) {

    //如果不可复制，创建一个新的Mac对象

      mac = Mac.getInstance(ALGORITHM);

    }

    mac.init(new SecretKeySpec(key, ALGORITHM));

    return mac.doFinal(data);

    } catch (NoSuchAlgorithmException ex) {

      throw new RuntimeException("不支持的算法: " + ALGORITHM, ex);

    } catch (InvalidKeyException ex) {

      throw new RuntimeException("非法key: " + key, ex);

    }

  }

}

import cn.unitid.ca.sdk.dto.cert.BaseCertificate;
import cn.unitid.ca.sdk.utils.P10Util;
import org.junit.Test;

/**
 * PkCS10生成测试
 */
public class PkCS10Test {

    /**
     * 根据主题项生成P10
     *
     * @throws Exception Exception
     */
    @Test
    public void testGenSM2PKCS10() throws Exception {
        P10Util.P10Info p10Info = P10Util.p10Structure("CN=诸葛亮,OU=蜀汉,O=刘备CA,ST=西蜀,L=成都,C=CN");

        System.out.println("P10 BASE64 字符串形式:" + p10Info.getP10());
        System.out.println("KCS#10 certification request 形式:" + p10Info.getPkCs10());
        System.out.println("公钥:" + p10Info.getSm2PublicKey());
        System.out.println("私钥:" + p10Info.getSm2PrivateKey());
    }

    /**
     * 根据证书生成P10
     *
     * @throws Exception Exception
     */
    @Test
    public void testGenSM2PKCS10ByCert() throws Exception {
        //构造一个证书对象
        BaseCertificate certificate = new BaseCertificate();
        //设置证书基本信息
        certificate.setCommonName("诸葛亮");
        certificate.setOrganization("刘备CA");
        certificate.setOrganizationUnit("蜀汉");
        certificate.setCountry("CN");
        certificate.setProvince("西蜀");
        certificate.setCity("成都");

        P10Util.P10Info p10Info = P10Util.p10Structure(certificate);

        System.out.println("P10 BASE64 字符串形式:" + p10Info.getP10());
        System.out.println("KCS#10 certification request 形式:" + p10Info.getPkCs10());
        System.out.println("公钥:" + p10Info.getSm2PublicKey());
        System.out.println("私钥:" + p10Info.getSm2PrivateKey());
    }

     /**
     * 根据主题项生成RSA P10
     *
     * @throws Exception Exception
     */
   @Test
    public void testRsaP10() throws Exception {
        String subject = "CN=诸葛亮,OU=蜀汉,O=刘备CA,ST=西蜀,L=成都,C=CN";
        String pkcs10 = P10UtilWithRSA.genP10(subject);
        System.out.println(pkcs10);
    }

}

import cn.unitid.ca.sdk.dto.cert.AdapteBaseCertificate;
import org.junit.Test;

import java.util.HashMap;

/**
 * @author YRJ
 * @date 2019/5/6
 */
public class CertReaderTest {

    @Test
    public void adaptCert_Test() throws Exception{
        String base64Cert = "MIICqzCCAlKgAwIBAgIIIBkFBgAAgJcwCgYIKoEcz1UBg3UwdjEcMBoGA1UEAwwTU21hcnRDQV9UZXN0X1NNMl9DQTEVMBMGA1UECwwMU21hcnRDQV9UZXN0MRAwDgYDVQQKDAdTbWFydENBMQ8wDQYDVQQHDAbljZfkuqwxDzANBgNVBAgMBuaxn+iLjzELMAkGA1UEBhMCQ04wHhcNMTkwNTA2MDY0NzEyWhcNMjAwNTA2MDY0NzE0WjCBwDFQME4GA1UELQxHYXBpX2NhX1RFU1RfVE9fUEhfUkFfMl9VU0wxM1NTMV9hcGlfY2FfYzVlMjcwYmI1OTMwNDg4MGJiZDM5NTRlOTNjN2JiNjIxCzAJBgNVBAYTAkNOMQ8wDQYDVQQIDAbmsZ/oi48xDzANBgNVBAcMBuWNl+S6rDEQMA4GA1UECgwHU21hcnRDQTESMBAGA1UECwwJ5aO56K+B6YCaMRcwFQYDVQQDDA7mtZnmsZ/opb/muZZAMTBZMBMGByqGSM49AgEGCCqBHM9VAYItA0IABIZVFqTa9ar4WScUO6D2Ww/qCwyglNGVi5wkh89DdQXvsY2RkHqlfdhg4NifbPMg9kP4LVst0HVUsHIzaHevwSijfzB9MAsGA1UdDwQEAwIGwDAMBgNVHRMEBTADAQH/MB0GA1UdDgQWBBQ6Lpzol3uyBwOEjSc2S6Td1HpdLjAfBgNVHSMEGDAWgBRc87oljMJlDOxn777djWunXq/jrDAgBggqgRzQFAQBAwQUExI2NjQ2NDg4NDk0MTM2NDY0NjcwCgYIKoEcz1UBg3UDRwAwRAIgW+cwWylLKsuAhqx3dNt/UHriw2oq/QspDIsW9v+qHb8CICyie8vv1ZdaY4OsjJdAhd1/fuNn/sT0RYUIz03psQ6q";
        AdapteBaseCertificate baseCertificate = new AdapteBaseCertificate();
        baseCertificate.convert(base64Cert);

        // 获取证书主题项集合
        HashMap<String, String> subjectExtensionMap = baseCertificate.getSubjectExtension(base64Cert);
        // 获取证书ID
        String certId = subjectExtensionMap.get("UniqueIdentifier");
        System.out.println(certId);
        // 获取证书算法
        System.out.println(baseCertificate.getAlgorithm());
    }
}

/**
 * @author jcq
 * @date 2021年06月07日 2:00 下午
 * @Description :获取随机数示例
 */
public class GetRandom {

  @Test
  public void getRandom() throws Exception {
    //返回结果
    String result = "";
    //请求url
    String url = "http://cip.api.ht.demo.smartcert.cn/rest/cip/random";
    //请求appKey
    String appKey = "w8MuGC9C";
    //签名算法
    String signMethod = "HMAC-SHA256";
    //签名算法版本
    String signVersion = "1.0";
    //服务方法接口名称
    String method = "random";
    //返回值类型
    String format = "json";
    //时间戳 日期格式按照 ISO8601 标准表示，并需要使用 UTC 时间。格式为 yyyy-MM-dd HH:mm:ss
    String timestamp = "1623035141160";
    //唯一随机数,同样的值，10 分钟内只能被使用一次
    String nonce = "ldqxNxOkVB";
    //API 版本号,目前版本是1
    String version = "1";
    //签名结果串,请参看 API 签名机制
    String sign = "F97BA592A3C3056EEB64346A09180D044E07CD0F55FAECF05DDEB043305FF20A";
    //请求的随机数长度
    String nLength = "5000";

    Map<String, String> params = new HashMap<String, String>();
    params.put("appKey", appKey);
    params.put("signMethod", signMethod);
    params.put("signVersion", signVersion);
    params.put("method", method);
    params.put("format", format);
    params.put("timestamp", timestamp);
    params.put("nonce", nonce);
    params.put("version", version);
    params.put("sign", sign);
    params.put("nLength", nLength);

    Map<String,String> headerMap = new HashMap<String, String>();
    //在请求头中增加x-request-id参数
    headerMap.put("x-request-id", RandomStringUtils.randomAlphanumeric(10));

    //发送http post请求，该方法返回的是String类型
    result = WebUtils.doPost(url, params, Constants.CHARSET_UTF8, 15000, 60000, headerMap, null);
    JSONObject jo = JSONObject.parseObject(result);
    String code = jo.getString("code");
    assert ("0".equals(code));
    JSONObject data = jo.getJSONObject("data");
    System.out.println("返回的随机数串："+data.get("dataHexStr"));
  }
}

import javax.crypto.*;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.Charset;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Base64;


public class AesUtils {

    private static final String KEY_ALGORITHM = "AES";
    static Charset charset = Charset.forName("UTF-8");
    private static final String SHA1PRNG ="SHA1PRNG";
    private static final String CIPHER_ALGORITHM = "AES/ECB/PKCS5Padding";

    /**
     * AES对称-加密操作
     *
     * @param secretKey 秘钥
     * @param data      需要进行加密的原文
     * @return 数据密文，加密后的数据，进行了Base64的编码
     * @throws Exception
     */
    public static String encrypt(String data, SecretKey secretKey) throws Exception {
        byte[] result = aes(data.getBytes(), Cipher.ENCRYPT_MODE, secretKey);
        return Base64.getEncoder().encodeToString(result);
    }

    public static String decryptByPassword(String keyStr, String data) throws Exception {
        // 转换密钥
        Key key = new SecretKeySpec(keyStr.getBytes(), KEY_ALGORITHM);
        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
        // 解密
        cipher.init(Cipher.DECRYPT_MODE, key);
        byte[] result = cipher.doFinal(Base64.getDecoder().decode(data));
        return new String(result);
    }
    /**
     * AES对称-解密操作
     *
     * @param secretKey 秘钥
     * @param data      需要解密的数据（数据必须是通过AES进行加密后，对加密数据Base64编码的数据）
     * @return 返回解密后的原文
     * @throws Exception
     */
    public static String decrypt(String data, SecretKey secretKey) throws Exception {
        byte[] result = aes(Base64.getDecoder().decode(data), Cipher.DECRYPT_MODE, secretKey);
        return new String(result, charset);
    }

    /**
     * 生成密钥
     *
     * @return
     * @throws NoSuchAlgorithmException
     */
    public static SecretKey generateKey(String password) throws NoSuchAlgorithmException {
        KeyGenerator secretGenerator = KeyGenerator.getInstance(KEY_ALGORITHM);
        SecureRandom secureRandom = SecureRandom.getInstance(SHA1PRNG);
        secureRandom.setSeed(password.getBytes());
        secretGenerator.init(128, secureRandom);
        SecretKey secretKey = secretGenerator.generateKey();
        return secretKey;
    }

    private static byte[] aes(byte[] contentArray, int mode, SecretKey secretKey) throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
        cipher.init(mode, secretKey);
        return cipher.doFinal(contentArray);
    }
}

import cn.unitid.easypki.crypto.CipherException;
import cn.unitid.easypki.crypto.SM4SymmetricCipher;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import java.nio.charset.Charset;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Base64;

/**
 * 描述: SM4加解密
 *
 * @author whx on 2022/10/08
 */
public class SM4Utils {

    private static final String KEY_ALGORITHM = "AES";
    public static final String ECB = "ECB";
    static Charset charset = Charset.forName("UTF-8");


    /**
     * SM4加密
     *
     * @param data 需要进行加密的原文
     * @param secretKey 密钥
     * @return 数据密文，加密后的数据，进行了Base64的编码
     * @throws NoSuchAlgorithmException
     * @throws InvalidKeyException
     * @throws CipherException
     */
    public static String encrypt(String data,SecretKey secretKey) throws NoSuchAlgorithmException, InvalidKeyException, CipherException{
        byte[] result = sm4(data.getBytes(), Cipher.ENCRYPT_MODE, secretKey);
        return Base64.getEncoder().encodeToString(result);
    }

    /**
     * SM4解密
     *
     * @param data 需要进行加密的原文
     * @param secretKey 密钥
     * @return 返回解密后的原文
     * @throws InvalidKeyException
     * @throws CipherException
     * @throws NoSuchAlgorithmException
     */
    public static String decrypt(String  data, SecretKey secretKey) throws InvalidKeyException, CipherException, NoSuchAlgorithmException {
        byte[] result = sm4(Base64.getDecoder().decode(data), Cipher.DECRYPT_MODE, secretKey);
        return new String(result, charset);
    }


        /**
         * 生成密钥
         *
         * @return
         * @throws NoSuchAlgorithmException
         */
    public static SecretKey generateKey(String password) throws NoSuchAlgorithmException {
        KeyGenerator secretGenerator = KeyGenerator.getInstance(KEY_ALGORITHM);
        secretGenerator.init(128, new SecureRandom(password.getBytes()));
        SecretKey secretKey = secretGenerator.generateKey();
        return secretKey;
    }

    private static byte[] sm4(byte[] contentArray, int mode, SecretKey secretKey) throws NoSuchAlgorithmException, InvalidKeyException, CipherException {
        SM4SymmetricCipher cipher = new SM4SymmetricCipher(ECB);
        cipher.init(mode, secretKey.getEncoded());
        cipher.update(contentArray);
        byte[] bytes = cipher.doFinal();
        return bytes;
    }
}