devbox
小丑西瓜9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

微信支付V3获取平台证书并解密平台证书详细流程_解密后得到的微信平台证书怎么使用

作者：小丑西瓜9 | 2024-05-20 18:48:24

赞

踩

解密后得到的微信平台证书怎么使用

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

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

     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.      * 从字符串中加载私钥<br>
  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<String> 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<String> 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<String, String> 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<String, String> 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<String, String> params, String connStr, boolean encode) {
  139.         return createLinkString(params, connStr, encode, false);
  140.     }
  141.  
  142.     public static String createLinkString(Map<String, String> params, String connStr, boolean encode, boolean quotes) {
  143.         List<String> 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<String> 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. 	 *      <code>sendPostRequest(String,String,boolean,String,String)</code>
  63. 	 *      的简化方法
  64. 	 * @see 该方法在对请求数据的编码和响应数据的解码时,所采用的字符集均为UTF-8
  65. 	 * @see 当<code>isEncoder=true</code>时,其会自动对<code>sendData</code>中的[中文][|][
  66. 	 *      ]等特殊字符进行<code>URLEncoder.encode(string,"UTF-8")</code>
  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 当<code>isEncoder=true</code>时,其会自动对<code>sendData</code>中的[中文][|][
  79. 	 *      ]等特殊字符进行<code>URLEncoder.encode(string,encodeCharset)</code>
  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错误 | 微信开放社区

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

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

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小丑西瓜9/article/detail/598849
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号