• 微信支付V3获取平台证书并解密平台证书详细流程

    公司要搞服务号商户卷功能，所以用到了创建商户号接口，有很多数据需要平台证书单独加密，并且图片上传接口返回数据也需要平台证书验签。

       就搞了一下,现在说一下具体细节：

         1：直接点进 敏感信息加密说明

     2 看到微信说加密需要 平台证书

     这里你要搞清楚：商户号证书  和  平台证书不是一个东西，

     商户号证书：是服务商下载的证书

    平台证书：微信支付证书

    3：现在就去下载微信平台证书，请求接口方式下载

     

     不废话了，直接上获取平台证书代码：

       

    1.  //获取 获取平台证书列表  测试成功
    2.    public static void main(String[] args) throws Exception {
    3.         //时间戳
    4.         long timestamp = System.currentTimeMillis() / 1000;
    5.         //随机字符串（用UUID去掉-就行）
    6.         String nonce = IdUtil.fastSimpleUUID().toUpperCase();
    7.         String body =  "";
    8.         //拼接要签名的字符串
    9.         PrivateKey privateKey = PayKit.getPrivateKey("这里填商户平台私钥证书");
    10.         //拼接要签名的字符串
    11.         String orgSignText = "GET\n"
    12.                 + "/v3/certificates\n"
    13.                 + timestamp + "\n"
    14.                 + nonce + "\n"
    15.                 + body + "\n";
    16.         // 生成签名
    17.         String sign = RsaKit.encryptByPrivateKey(orgSignText, privateKey);
    18.         //要放在HttpHeader中的auth信息
    19.         // 获取商户证书序列号  这里填写公钥路径 也就是apiclient_cert.pem这个文件的路径
    20.         //证书序列号
    21.         X509Certificate certificate = PayKit.getCertificate(FileUtil.getInputStream("填你的apiclient_cert.pem"));
    22.         String serialNo = certificate.getSerialNumber().toString(16).toUpperCase();
    23.         String auth = "WECHATPAY2-SHA256-RSA2048 "
    24.                 + "mchid=\"商户号\",nonce_str=\""
    25.                 + nonce + "\",timestamp=\"" + timestamp
    26.                 + "\",serial_no=\"" + serialNo + "\",signature=\"" + sign + "\"";
    27.         String url = "https://api.mch.weixin.qq.com/v3/certificates";
    28.  
    29.         HashMap<String, Object> tmap = new HashMap<String, Object>();
    30.         tmap.put("Authorization",auth);//tmap.put("token","tonken值");
    31.         tmap.put("Accept","application/json");
    32.         tmap.put("User-Agent","https://zh.wikipedia.org/wiki/User_agent");
    33.         String vmsg= httpGet(url,tmap);//获取请求的返回结果
    34.  
    35.         String rs = HttpClientUtil.sendGetRequest(url, null);
    36.         System.out.println("获取平台证书"+vmsg);
    37.     }

    下面是具体用到的工具类：

    1. public class RsaKit {
    2.  
    3.     /**
    4.      * 加密算法RSA
    5.      */
    6.     private static final String KEY_ALGORITHM = "RSA";
    7.  
    8.     /**
    9.      * 私钥签名
    10.      *
    11.      * @param data       需要加密的数据
    12.      * @param privateKey 私钥
    13.      * @return 加密后的数据
    14.      * @throws Exception 异常信息
    15.      */
    16.     public static String encryptByPrivateKey(String data, PrivateKey privateKey) throws Exception {
    17.         java.security.Signature signature = java.security.Signature.getInstance("SHA256WithRSA");
    18.         signature.initSign(privateKey);
    19.         signature.update(data.getBytes(StandardCharsets.UTF_8));
    20.         byte[] signed = signature.sign();
    21.         return StrUtil.str(Base64.encode(signed));
    22.     }
    23.  
    24.     /**
    25.      * 从字符串中加载私钥
    26.      * 加载时使用的是PKCS8EncodedKeySpec（PKCS#8编码的Key指令）。
    27.      *
    28.      * @param privateKeyStr 私钥
    29.      * @return {@link PrivateKey}
    30.      * @throws Exception 异常信息
    31.      */
    32.     public static PrivateKey loadPrivateKey(String privateKeyStr) throws Exception {
    33.         try {
    34.             byte[] buffer = Base64.decode(privateKeyStr);
    35.             PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer);
    36.             KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    37.             return keyFactory.generatePrivate(keySpec);
    38.         } catch (NoSuchAlgorithmException e) {
    39.             throw new Exception("无此算法");
    40.         } catch (InvalidKeySpecException e) {
    41.             throw new Exception("私钥非法");
    42.         } catch (NullPointerException e) {
    43.             throw new Exception("私钥数据为空");
    44.         }
    45.     }
    46.     /**
    47.      * 公钥验证签名
    48.      *
    49.      * @param data      需要加密的数据
    50.      * @param sign      签名
    51.      * @param publicKey 公钥
    52.      * @return 验证结果
    53.      * @throws Exception 异常信息
    54.      */
    55.     public static boolean checkByPublicKey(String data, String sign, PublicKey publicKey) throws Exception {
    56.         java.security.Signature signature = java.security.Signature.getInstance("SHA256WithRSA");
    57.         signature.initVerify(publicKey);
    58.         signature.update(data.getBytes(StandardCharsets.UTF_8));
    59.         return signature.verify(Base64.decode(sign.getBytes(StandardCharsets.UTF_8)));
    60.     }
    61. }
    1. public class PayKit {
    2.  
    3.     /**
    4.      * 获取证书
    5.      *
    6.      * @param inputStream 证书文件
    7.      * @return {@link X509Certificate} 获取证书
    8.      */
    9.     public static X509Certificate getCertificate(InputStream inputStream) {
    10.         try {
    11.             CertificateFactory cf = CertificateFactory.getInstance("X509");
    12.             X509Certificate cert = (X509Certificate) cf.generateCertificate(inputStream);
    13.             cert.checkValidity();
    14.             return cert;
    15.         } catch (CertificateExpiredException e) {
    16.             throw new RuntimeException("证书已过期", e);
    17.         } catch (CertificateNotYetValidException e) {
    18.             throw new RuntimeException("证书尚未生效", e);
    19.         } catch (CertificateException e) {
    20.             throw new RuntimeException("无效的证书", e);
    21.         }
    22.     }
    23.     /**
    24.      * 简化的UUID，去掉了横线，使用性能更好的 ThreadLocalRandom 生成UUID
    25.      *
    26.      * @return 简化的 UUID，去掉了横线
    27.      */
    28.     public static String generateStr() {
    29.         return IdUtil.fastSimpleUUID();
    30.     }
    31.  
    32.     /**
    33.      * 构造签名串
    34.      *
    35.      * @param method    {@link RequestMethod} GET,POST,PUT等
    36.      * @param url       请求接口 /v3/certificates
    37.      * @param timestamp 获取发起请求时的系统当前时间戳
    38.      * @param nonceStr  随机字符串
    39.      * @param body      请求报文主体
    40.      * @return 待签名字符串
    41.      */
    42.     public static String buildSignMessage(String method, String url, String timestamp, String nonceStr, String body) {
    43.         ArrayList arrayList = new ArrayList<>();
    44.         arrayList.add(method);
    45.         arrayList.add(url);
    46.         arrayList.add(String.valueOf(timestamp));
    47.         arrayList.add(nonceStr);
    48.         arrayList.add(body);
    49.         return buildSignMessage(arrayList);
    50.     }
    51.     /**
    52.      * 构造签名串
    53.      *
    54.      * @param signMessage 待签名的参数
    55.      * @return 构造后带待签名串
    56.      */
    57.     public static String buildSignMessage(ArrayList signMessage) {
    58.         if (signMessage == null || signMessage.size() <= 0) {
    59.             return null;
    60.         }
    61.         StringBuilder sbf = new StringBuilder();
    62.         for (String str : signMessage) {
    63.             sbf.append(str).append("\n");
    64.         }
    65.         System.out.println("待签名字符串内容：" + sbf.toString());
    66.         System.out.println("待签名字符串长度：" + sbf.toString().length());
    67.         return sbf.toString();
    68.     }
    69.     /**
    70.      * v3 接口创建签名
    71.      *
    72.      * @param signMessage 待签名的参数
    73.      * @param keyPath     key.pem 证书路径
    74.      * @return 生成 v3 签名
    75.      * @throws Exception 异常信息
    76.      */
    77.     public static String createSign(String signMessage, String keyPath) throws Exception {
    78.         if (StrUtil.isEmpty(signMessage)) {
    79.             return null;
    80.         }
    81.         // 获取商户私钥
    82.         PrivateKey privateKey = PayKit.getPrivateKey(keyPath);
    83.         // 生成签名
    84.         return RsaKit.encryptByPrivateKey(signMessage, privateKey);
    85.     }
    86.  
    87.     /**
    88.      * 获取商户私钥
    89.      *
    90.      * @param keyPath 商户私钥证书路径
    91.      * @return {@link PrivateKey} 商户私钥
    92.      * @throws Exception 异常信息
    93.      */
    94.     public static PrivateKey getPrivateKey(String keyPath) throws Exception {
    95.         String originalKey = FileUtil.readUtf8String(keyPath);
    96.         String privateKey = originalKey
    97.                 .replace("-----BEGIN PRIVATE KEY-----", "")
    98.                 .replace("-----END PRIVATE KEY-----", "")
    99.                 .replaceAll("\\s+", "");
    100.  
    101.         return RsaKit.loadPrivateKey(privateKey);
    102.     }
    103.  
    104.     /**
    105.      * 获取授权认证信息
    106.      *
    107.      * @param mchId     商户号
    108.      * @param serialNo  商户API证书序列号
    109.      * @param nonceStr  请求随机串
    110.      * @param timestamp 时间戳
    111.      * @param signature 签名值
    112.      * @param authType  认证类型，目前为WECHATPAY2-SHA256-RSA2048
    113.      * @return 请求头 Authorization
    114.      */
    115.     public static String getAuthorization(String mchId, String serialNo, String nonceStr, String timestamp, String signature, String authType) {
    116.         Map params = new HashMap<>(5);
    117.         params.put("mchid", mchId);
    118.         params.put("serial_no", serialNo);
    119.         params.put("nonce_str", nonceStr);
    120.         params.put("timestamp", timestamp);
    121.         params.put("signature", signature);
    122.         return authType.concat(" ").concat(createLinkString(params, ",", false, true));
    123.     }
    124.     /**
    125.      * @param params 需要排序并参与字符拼接的参数组
    126.      * @param encode 是否进行URLEncoder
    127.      * @return 拼接后字符串
    128.      */
    129.     public static String createLinkString(Map params, boolean encode) {
    130.         return createLinkString(params, "&", encode);
    131.     }
    132.     /**
    133.      * @param params  需要排序并参与字符拼接的参数组
    134.      * @param connStr 连接符号
    135.      * @param encode  是否进行URLEncoder
    136.      * @return 拼接后字符串
    137.      */
    138.     public static String createLinkString(Map params, String connStr, boolean encode) {
    139.         return createLinkString(params, connStr, encode, false);
    140.     }
    141.  
    142.     public static String createLinkString(Map params, String connStr, boolean encode, boolean quotes) {
    143.         List keys = new ArrayList<>(params.keySet());
    144.         Collections.sort(keys);
    145.         StringBuilder content = new StringBuilder();
    146.         for (int i = 0; i < keys.size(); i++) {
    147.             String key = keys.get(i);
    148.             String value = params.get(key);
    149.             // 拼接时，不包括最后一个&字符
    150.             if (i == keys.size() - 1) {
    151.                 if (quotes) {
    152.                     content.append(key).append("=").append('"').append(encode ? urlEncode(value) : value).append('"');
    153.                 } else {
    154.                     content.append(key).append("=").append(encode ? urlEncode(value) : value);
    155.                 }
    156.             } else {
    157.                 if (quotes) {
    158.                     content.append(key).append("=").append('"').append(encode ? urlEncode(value) : value).append('"').append(connStr);
    159.                 } else {
    160.                     content.append(key).append("=").append(encode ? urlEncode(value) : value).append(connStr);
    161.                 }
    162.             }
    163.         }
    164.         return content.toString();
    165.     }
    166.  
    167.     /**
    168.      * URL 编码
    169.      *
    170.      * @param src 需要编码的字符串
    171.      * @return 编码后的字符串
    172.      */
    173.     public static String urlEncode(String src) {
    174.         try {
    175.             return URLEncoder.encode(src, CharsetUtil.UTF_8).replace("+", "%20");
    176.         } catch (UnsupportedEncodingException e) {
    177.             e.printStackTrace();
    178.             return null;
    179.         }
    180.     }
    181.  
    182.     /**
    183.      * 构造签名串
    184.      *
    185.      * @param timestamp 应答时间戳
    186.      * @param nonceStr  应答随机串
    187.      * @param body      应答报文主体
    188.      * @return 应答待签名字符串
    189.      */
    190.     public static String buildSignMessage(String timestamp, String nonceStr, String body) {
    191.         ArrayList arrayList = new ArrayList<>();
    192.         arrayList.add(timestamp);
    193.         arrayList.add(nonceStr);
    194.         arrayList.add(body);
    195.         return buildSignMessage(arrayList);
    196.     }
    197.  
    198.     /**
    199.      * 公钥加密
    200.      *
    201.      * @param data        待加密数据
    202.      * @param certificate 平台公钥证书
    203.      * @return 加密后的数据
    204.      * @throws Exception 异常信息
    205.      */
    206.     public static String rsaEncryptOAEP(String data, X509Certificate certificate) throws Exception {
    207.         try {
    208.             Cipher cipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-1AndMGF1Padding");
    209.             cipher.init(Cipher.ENCRYPT_MODE, certificate.getPublicKey());
    210.  
    211.             byte[] dataByte = data.getBytes(StandardCharsets.UTF_8);
    212.             byte[] cipherData = cipher.doFinal(dataByte);
    213.             return Base64.encode(cipherData);
    214.         } catch (NoSuchAlgorithmException | NoSuchPaddingException e) {
    215.             throw new RuntimeException("当前Java环境不支持RSA v1.5/OAEP", e);
    216.         } catch (InvalidKeyException e) {
    217.             throw new IllegalArgumentException("无效的证书", e);
    218.         } catch (IllegalBlockSizeException | BadPaddingException e) {
    219.             throw new IllegalBlockSizeException("加密原串的长度不能超过214字节");
    220.         }
    221.     }
    222.  
    223.     /**
    224.      * 私钥解密
    225.      *
    226.      * @param cipherText 加密字符
    227.      * @param privateKey 私钥
    228.      * @return 解密后的数据
    229.      * @throws Exception 异常信息
    230.      */
    231.     public static String rsaDecryptOAEP(String cipherText, PrivateKey privateKey) throws Exception {
    232.         try {
    233.             Cipher cipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-1AndMGF1Padding");
    234.             cipher.init(Cipher.DECRYPT_MODE, privateKey);
    235.             byte[] data = Base64.decode(cipherText);
    236.             return new String(cipher.doFinal(data), StandardCharsets.UTF_8);
    237.         } catch (NoSuchPaddingException | NoSuchAlgorithmException e) {
    238.             throw new RuntimeException("当前Java环境不支持RSA v1.5/OAEP", e);
    239.         } catch (InvalidKeyException e) {
    240.             throw new IllegalArgumentException("无效的私钥", e);
    241.         } catch (BadPaddingException | IllegalBlockSizeException e) {
    242.             throw new BadPaddingException("解密失败");
    243.         }
    244.     }
    245. }
    1. public class HttpClientUtil
    2.  {
    3.    public static final String SunX509 = "SunX509";
    4.    public static final String JKS = "JKS";
    5.    public static final String PKCS12 = "PKCS12";
    6.    public static final String TLS = "TLS";
    7.    
    8.    public static HttpURLConnection getHttpURLConnection(String strUrl)
    9.      throws IOException
    10.    {
    11.      URL url = new URL(strUrl);
    12.      HttpURLConnection httpURLConnection = (HttpURLConnection)url
    13.        .openConnection();
    14.      return httpURLConnection;
    15.    }
    16.    
    17.  
    18.  
    19.    /**
    20. 	 * 发送HTTP_GET请求
    21. 	 * 
    22. 	 * @see 该方法会自动关闭连接,释放资源
    23. 	 * @param reqURL
    24. 	 *            请求地址(含参数)
    25. 	 * @param decodeCharset
    26. 	 *            解码字符集,解析响应数据时用之,其为null时默认采用UTF-8解码
    27. 	 * @return 远程主机响应正文
    28. 	 */
    29. 	public static String sendGetRequest(String reqURL, String decodeCharset) {
    30. 		long responseLength = 0; // 响应长度
    31. 		String responseContent = null; // 响应内容
    32. 		HttpClient httpClient = new DefaultHttpClient(); // 创建默认的httpClient实例
    33. 		HttpGet httpGet = new HttpGet(reqURL); // 创建org.apache.http.client.methods.HttpGet
    34. 		try {
    35. 			HttpResponse response = httpClient.execute(httpGet); // 执行GET请求
    36. 			HttpEntity entity = response.getEntity(); // 获取响应实体
    37. 			if (null != entity) {
    38. 				responseLength = entity.getContentLength();
    39. 				responseContent = EntityUtils.toString(entity, decodeCharset == null ? "UTF-8" : decodeCharset);
    40. 				EntityUtils.consume(entity); // Consume response content
    41. 			}
    42. 			System.out.println("请求地址: " + httpGet.getURI());
    43. 			System.out.println("响应状态: " + response.getStatusLine());
    44. 			System.out.println("响应长度: " + responseLength);
    45. 			System.out.println("响应内容: " + responseContent);
    46. 		} catch (ClientProtocolException e) {
    47. 			System.out.println("该异常通常是协议错误导致,比如构造HttpGet对象时传入的协议不对(将'http'写成'htp')或者服务器端返回的内容不符合HTTP协议要求等,堆栈信息如下");
    48. 		} catch (ParseException e) {
    49. 			System.out.println(e.getMessage());
    50. 		} catch (IOException e) {
    51. 			System.out.println("该异常通常是网络原因引起的,如HTTP服务器未启动等,堆栈信息如下");
    52. 		} finally {
    53. 			httpClient.getConnectionManager().shutdown(); // 关闭连接,释放资源
    54. 		}
    55. 		return responseContent;
    56. 	}
    57.  
    58. 	/**
    59. 	 * 发送HTTP_POST请求
    60. 	 * 
    61. 	 * @see 该方法为
    62. 	 *      sendPostRequest(String,String,boolean,String,String)
    63. 	 *      的简化方法
    64. 	 * @see 该方法在对请求数据的编码和响应数据的解码时,所采用的字符集均为UTF-8
    65. 	 * @see 当isEncoder=true时,其会自动对sendData中的[中文][|][
    66. 	 *      ]等特殊字符进行URLEncoder.encode(string,"UTF-8")
    67. 	 * @param isEncoder
    68. 	 *            用于指明请求数据是否需要UTF-8编码,true为需要
    69. 	 */
    70. 	public static String sendPostRequest(String reqURL, String sendData, boolean isEncoder) {
    71. 		return sendPostRequest(reqURL, sendData, isEncoder, null, null,"application/json");
    72. 	}
    73. 	
    74. 	/**
    75. 	 * 发送HTTP_POST请求
    76. 	 * 
    77. 	 * @see 该方法会自动关闭连接,释放资源
    78. 	 * @see 当isEncoder=true时,其会自动对sendData中的[中文][|][
    79. 	 *      ]等特殊字符进行URLEncoder.encode(string,encodeCharset)
    80. 	 * @param reqURL
    81. 	 *            请求地址
    82. 	 * @param sendData
    83. 	 *            请求参数,若有多个参数则应拼接成param11=value11¶m22=value22¶m33=value33的形式后,
    84. 	 *            传入该参数中
    85. 	 * @param isEncoder
    86. 	 *            请求数据是否需要encodeCharset编码,true为需要
    87. 	 * @param encodeCharset
    88. 	 *            编码字符集,编码请求数据时用之,其为null时默认采用UTF-8解码
    89. 	 * @param decodeCharset
    90. 	 *            解码字符集,解析响应数据时用之,其为null时默认采用UTF-8解码
    91. 	 * @return 远程主机响应正文
    92. 	 */
    93. 	public static String sendPostRequest(String reqURL, String sendData, boolean isEncoder, String encodeCharset,
    94. 			String decodeCharset,String contentType) {
    95. 		String responseContent = null;
    96. 		HttpClient httpClient = new DefaultHttpClient();
    97.  
    98. 		HttpPost httpPost = new HttpPost(reqURL);
    99. 		// httpPost.setHeader(HTTP.CONTENT_TYPE,
    100. 		// "application/x-www-form-urlencoded; charset=UTF-8");
    101. 		httpPost.setHeader(HTTP.CONTENT_TYPE, contentType);
    102. 		try {
    103. 			if (isEncoder) {
    104. 				httpPost.setEntity(new StringEntity(sendData, encodeCharset == null ? "UTF-8" : encodeCharset));
    105. 			} else {
    106. 				httpPost.setEntity(new StringEntity(sendData));
    107. 			}
    108. 			// 设置请求超时时间
    109. 			httpClient.getParams().setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, 5000);
    110. 			HttpResponse response = httpClient.execute(httpPost);
    111. 			HttpEntity entity = response.getEntity();
    112. 			if (null != entity) {
    113. 				responseContent = EntityUtils.toString(entity, decodeCharset == null ? "UTF-8" : decodeCharset);
    114. 				EntityUtils.consume(entity);
    115. 			}
    116. 		} catch (Exception e) {
    117. 			System.out.println("与[" + reqURL + "]通信过程中发生异常,堆栈信息如下");
    118. 			e.printStackTrace();
    119. 		} finally {
    120. 			httpClient.getConnectionManager().shutdown();
    121. 		}
    122. 		return responseContent;
    123. 	}
    124.  
    125.  
    126.    public static HttpsURLConnection getHttpsURLConnection(String strUrl)
    127.      throws IOException
    128.    {
    129.      URL url = new URL(strUrl);
    130.      HttpsURLConnection httpsURLConnection = (HttpsURLConnection)url
    131.        .openConnection();
    132.      return httpsURLConnection;
    133.    }
    134.    
    135.  
    136.  
    137.  
    138.    public static String getURL(String strUrl)
    139.    {
    140.      if (strUrl != null) {
    141.        int indexOf = strUrl.indexOf("?");
    142.        if (-1 != indexOf) {
    143.          return strUrl.substring(0, indexOf);
    144.        }
    145.        
    146.        return strUrl;
    147.      }
    148.      
    149.      return strUrl;
    150.    }
    151.  
    152.  
    153.  
    154.    public static String getQueryString(String strUrl)
    155.    {
    156.      if (strUrl != null) {
    157.        int indexOf = strUrl.indexOf("?");
    158.        if (-1 != indexOf) {
    159.          return strUrl.substring(indexOf + 1, strUrl.length());
    160.        }
    161.        
    162.        return "";
    163.      }
    164.      
    165.      return strUrl;
    166.    }
    167.    
    168.  
    169.  
    170.    public static Map queryString2Map(String queryString)
    171.    {
    172.      if ((queryString == null) || ("".equals(queryString))) {
    173.        return null;
    174.      }
    175.      
    176.      Map m = new HashMap();
    177.      String[] strArray = queryString.split("&");
    178.      for (int index = 0; index < strArray.length; index++) {
    179.        String pair = strArray[index];
    180.        putMapByPair(pair, m);
    181.      }
    182.      
    183.      return m;
    184.    }
    185.    
    186.  
    187.  
    188.    public static void putMapByPair(String pair, Map m)
    189.    {
    190.      if ((pair == null) || ("".equals(pair))) {
    191.        return;
    192.      }
    193.      
    194.      int indexOf = pair.indexOf("=");
    195.      if (-1 != indexOf) {
    196.        String k = pair.substring(0, indexOf);
    197.        String v = pair.substring(indexOf + 1, pair.length());
    198.        if ((k != null) && (!"".equals(k))) {
    199.          m.put(k, v);
    200.        }
    201.      } else {
    202.        m.put(pair, "");
    203.      }
    204.    }
    205.    
    206.  
    207.  
    208.  
    209.    public static String bufferedReader2String(BufferedReader reader)
    210.      throws IOException
    211.    {
    212.      StringBuffer buf = new StringBuffer();
    213.      String line = null;
    214.      while ((line = reader.readLine()) != null) {
    215.        buf.append(line);
    216.        buf.append("\r\n");
    217.      }
    218.      
    219.      return buf.toString();
    220.    }
    221.    
    222.  
    223.  
    224.  
    225.    public static void doOutput(OutputStream out, byte[] data, int len)
    226.      throws IOException
    227.    {
    228.      int dataLen = data.length;
    229.      int off = 0;
    230.      while (off < dataLen) {
    231.        if (len >= dataLen) {
    232.          out.write(data, off, dataLen);
    233.        } else {
    234.          out.write(data, off, len);
    235.        }
    236.        
    237.  
    238.        out.flush();
    239.        
    240.        off += len;
    241.        
    242.        dataLen -= len;
    243.      }
    244.    }
    245.    
    246.  
    247.  
    248.  
    249.    public static SSLContext getSSLContext(FileInputStream trustFileInputStream, String trustPasswd, FileInputStream keyFileInputStream, String keyPasswd)
    250.      throws NoSuchAlgorithmException, KeyStoreException, CertificateException, IOException, UnrecoverableKeyException, KeyManagementException
    251.    {
    252.      TrustManagerFactory tmf = 
    253.        TrustManagerFactory.getInstance("SunX509");
    254.      KeyStore trustKeyStore = KeyStore.getInstance("JKS");
    255.      trustKeyStore.load(trustFileInputStream, 
    256.        str2CharArray(trustPasswd));
    257.      tmf.init(trustKeyStore);
    258.      
    259.      char[] kp = str2CharArray(keyPasswd);
    260.      KeyManagerFactory kmf = 
    261.        KeyManagerFactory.getInstance("SunX509");
    262.      KeyStore ks = KeyStore.getInstance("PKCS12");
    263.      ks.load(keyFileInputStream, kp);
    264.      kmf.init(ks, kp);
    265.      
    266.      SecureRandom rand = new SecureRandom();
    267.      SSLContext ctx = SSLContext.getInstance("TLS");
    268.      ctx.init(kmf.getKeyManagers(), tmf.getTrustManagers(), rand);
    269.      
    270.      return ctx;
    271.    }
    272.    
    273.  
    274.  
    275.  
    276.  
    277.  
    278.    public static Certificate getCertificate(File cafile)
    279.      throws CertificateException, IOException
    280.    {
    281.      CertificateFactory cf = CertificateFactory.getInstance("X.509");
    282.      FileInputStream in = new FileInputStream(cafile);
    283.      Certificate cert = cf.generateCertificate(in);
    284.      in.close();
    285.      return cert;
    286.    }
    287.    
    288.  
    289.  
    290.  
    291.  
    292.  
    293.    public static char[] str2CharArray(String str)
    294.    {
    295.      if (str == null) {
    296.        return null;
    297.      }
    298.      return str.toCharArray();
    299.    }
    300.    
    301.  
    302.  
    303.  
    304.  
    305.  
    306.  
    307.    public static void storeCACert(Certificate cert, String alias, String password, OutputStream out)
    308.      throws KeyStoreException, NoSuchAlgorithmException, CertificateException, IOException
    309.    {
    310.      KeyStore ks = KeyStore.getInstance("JKS");
    311.      
    312.      ks.load(null, null);
    313.      
    314.      ks.setCertificateEntry(alias, cert);
    315.      
    316.  
    317.      ks.store(out, str2CharArray(password));
    318.    }
    319.    
    320.    public static InputStream String2Inputstream(String str)
    321.    {
    322.      return new ByteArrayInputStream(str.getBytes());
    323.    }
    324.  }

    返回结果：

    这就获取到了微信平台证书，但是要注意，这只是获取到了平台证书加密密文 还要进行解密，直接用微信支付文档里面的解密代码就可以。

     

    然后解析出真正的微信证书。

    注意这里解密有个问题：解密出现Illegal key size错误

       解决：微信支付V3支付通知JAVA解密出现Illegal key size错误 | 微信开放社区

    可以用微信证书去加/解密指定内容：

     好了，结束，希望对你有所帮助！

  • 相关阅读:
    去哪里找JAVA项目练手？
    Python QGIS 3自动化教程
    ZJUBCA研报分享 | 《BTC/USDT周内效应研究》
    GoogLeNet
    chrome安装vue devtools
    鸿鹄工程项目管理系统em Spring Cloud+Spring Boot+前后端分离构建工程项目管理系统
    二分查找（c语言）
    FasterViT：英伟达提出分层注意力，构造高吞吐CNN-ViT混合网络 | ICLR 2024
    深入解析JVM G1 垃圾回收器
    智慧工地管理云平台源码，Spring Cloud +Vue+UniApp
  • 原文地址：https://blog.csdn.net/qq_37272886/article/details/126068981