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

Java，PHP RSA加密解密，分段加解密及RSA签名_rsa2048签名长度

作者：小蓝xlanll | 2024-03-25 08:23:25

赞

踩

rsa2048签名长度
  1. 对接第三方支付系统接口，为这通信的安全性，通常有MD5签名，RSA签名为主，今天主要讲解RSA加解密及签名。
  2. RSA密钥长度有1024和2048位的，由于RSA加密的特殊性，文本内容过长不进行分段加密的话会出来加密失败
  3. 1024加密长度为：117，解密长度为：128; 2048加密长度为：245，解密长度为：256，这个地方特别需要注意，根据密钥长度修改不同的参数值
  4. 本地生成密钥对工具地址：本地生成RSA密钥对工具包，RSA加密解密-Java文档类资源-CSDN下载

JAVA RSA加解密工具类源码：

  1. package com.pay.utils;
  2.  
  3. import java.io.ByteArrayOutputStream;
  4. import java.security.Key;
  5. import java.security.KeyFactory;
  6. import java.security.KeyPair;
  7. import java.security.KeyPairGenerator;
  8. import java.security.NoSuchAlgorithmException;
  9. import java.security.interfaces.RSAPrivateKey;
  10. import java.security.interfaces.RSAPublicKey;
  11. import java.security.spec.InvalidKeySpecException;
  12. import java.security.spec.PKCS8EncodedKeySpec;
  13. import java.security.spec.X509EncodedKeySpec;
  14. import java.util.HashMap;
  15. import java.util.Map;
  16.  
  17. import javax.crypto.Cipher;
  18.  
  19. public class RSAEncrypt {
  20.     /**
  21.      * 字节数据转字符串专用集合
  22.      */
  23.     private static final char[] HEX_CHAR = { '0', '1', '2', '3', '4', '5', '6',
  24.             '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
  25.  
  26.     /**
  27. 	 * 加密算法RSA
  28. 	 */
  29. 	public static final String KEY_ALGORITHM = "RSA";
  30. 	
  31. 	/**
  32. 	 * 公钥
  33. 	 */
  34. 	public static final String PUBLIC_KEY = "publicKey";
  35. 	
  36. 	/**
  37. 	 * 私钥
  38. 	 */
  39. 	public static final String PRIVATE_KEY = "privateKey";
  40. 	
  41. 	/**
  42. 	 * RSA最大加密明文大小
  43. 	 */
  44. 	private static final int MAX_ENCRYPT_BLOCK = 245;
  45.  
  46. 	/**
  47. 	 * RSA最大解密密文大小
  48. 	 */
  49. 	private static final int MAX_DECRYPT_BLOCK = 256;
  50. 	
  51.     public static Map<String, String> generatorRSAKey(){
  52.         //获得对象 KeyPairGenerator 参数 RSA 2048个字节
  53.         KeyPairGenerator keyPairGen = null;
  54. 		try {
  55. 			keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
  56. 		} catch (NoSuchAlgorithmException e) {
  57. 			e.printStackTrace();
  58. 		}
  59.         keyPairGen.initialize(2048);
  60.         //通过对象 KeyPairGenerator 获取对象KeyPair
  61.         KeyPair keyPair = keyPairGen.generateKeyPair();
  62.         byte[] publicBytes = keyPair.getPublic().getEncoded();
  63.         byte[] privateBytes = keyPair.getPrivate().getEncoded();
  64.         //公私钥对象存入map中
  65.         Map<String, String> keyMap = new HashMap<String, String>();
  66.         keyMap.put(PUBLIC_KEY, Base64.encode(publicBytes));
  67.         keyMap.put(PRIVATE_KEY, Base64.encode(privateBytes));
  68.         return keyMap;
  69.     }
  70.     
  71.     /**
  72.      * 从字符串中加载公钥
  73.      *
  74.      * @param publicKeyStr
  75.      *            公钥数据字符串
  76.      * @throws Exception
  77.      *             加载公钥时产生的异常
  78.      */
  79.     public static RSAPublicKey getPublicKey(String publicKeyStr)
  80.             throws Exception {
  81.         try {
  82.             byte[] buffer = Base64.decode(publicKeyStr);
  83.             KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  84.             X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);
  85.             return (RSAPublicKey) keyFactory.generatePublic(keySpec);
  86.         } catch (NoSuchAlgorithmException e) {
  87.             throw new Exception("无此算法");
  88.         } catch (InvalidKeySpecException e) {
  89.             throw new Exception("公钥非法");
  90.         } catch (NullPointerException e) {
  91.             throw new Exception("公钥数据为空");
  92.         }
  93.     }
  94.  
  95.     public static RSAPrivateKey getPrivateKey(String privateKeyStr)
  96.             throws Exception {
  97.         try {
  98.             byte[] buffer = Base64.decode(privateKeyStr);
  99.             PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer);
  100.             KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  101.             return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
  102.         } catch (NoSuchAlgorithmException e) {
  103.             throw new Exception("无此算法");
  104.         } catch (InvalidKeySpecException e) {
  105.             throw new Exception("私钥非法");
  106.         } catch (NullPointerException e) {
  107.             throw new Exception("私钥数据为空");
  108.         }
  109.     }
  110.  
  111.     /**
  112. 	 * <P>
  113. 	 * 私钥解密
  114. 	 * </p>
  115. 	 * 
  116. 	 * @param encryptedData
  117. 	 *            已加密数据
  118. 	 * @param privateKey
  119. 	 *            私钥(BASE64编码)
  120. 	 * @return
  121. 	 * @throws Exception
  122. 	 */
  123. 	public static String decryptByPrivateKey(byte[] encryptedData, String privateKey) throws Exception {
  124. 		byte[] keyBytes = Base64.decode(privateKey);
  125. 		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
  126. 		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  127. 		Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
  128. 		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
  129. 		cipher.init(Cipher.DECRYPT_MODE, privateK);
  130. 		int inputLen = encryptedData.length;
  131. 		ByteArrayOutputStream out = new ByteArrayOutputStream();
  132. 		int offSet = 0;
  133. 		byte[] cache;
  134. 		int i = 0;
  135. 		// 对数据分段解密
  136. 		while (inputLen - offSet > 0) {
  137. 			if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
  138. 				cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
  139. 			} else {
  140. 				cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
  141. 			}
  142. 			out.write(cache, 0, cache.length);
  143. 			i++;
  144. 			offSet = i * MAX_DECRYPT_BLOCK;
  145. 		}
  146. 		byte[] decryptedData = out.toByteArray();
  147. 		out.close();
  148. 		return new String(decryptedData, "UTF-8");
  149. 	}
  150.  
  151. 	/**
  152. 	 * <p>
  153. 	 * 公钥解密
  154. 	 * </p>
  155. 	 * 
  156. 	 * @param encryptedData
  157. 	 *            已加密数据
  158. 	 * @param publicKey
  159. 	 *            公钥(BASE64编码)
  160. 	 * @return
  161. 	 * @throws Exception
  162. 	 */
  163. 	public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey) throws Exception {
  164. 		byte[] keyBytes = Base64.decode(publicKey);
  165. 		X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
  166. 		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  167. 		Key publicK = keyFactory.generatePublic(x509KeySpec);
  168. 		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
  169. 		cipher.init(Cipher.DECRYPT_MODE, publicK);
  170. 		int inputLen = encryptedData.length;
  171. 		ByteArrayOutputStream out = new ByteArrayOutputStream();
  172. 		int offSet = 0;
  173. 		byte[] cache;
  174. 		int i = 0;
  175. 		// 对数据分段解密
  176. 		while (inputLen - offSet > 0) {
  177. 			if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
  178. 				cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
  179. 			} else {
  180. 				cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
  181. 			}
  182. 			out.write(cache, 0, cache.length);
  183. 			i++;
  184. 			offSet = i * MAX_DECRYPT_BLOCK;
  185. 		}
  186. 		byte[] decryptedData = out.toByteArray();
  187. 		out.close();
  188. 		return decryptedData;
  189. 	}
  190.  
  191. 	/**
  192. 	 * <p>
  193. 	 * 公钥加密
  194. 	 * </p>
  195. 	 * 
  196. 	 * @param data
  197. 	 *            源数据
  198. 	 * @param publicKey
  199. 	 *            公钥(BASE64编码)
  200. 	 * @return
  201. 	 * @throws Exception
  202. 	 */
  203. 	public static String encryptByPublicKey(byte[] data, String publicKey) throws Exception {
  204. 		byte[] keyBytes = Base64.decode(publicKey);
  205. 		X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
  206. 		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  207. 		Key publicK = keyFactory.generatePublic(x509KeySpec);
  208. 		// 对数据加密
  209. 		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
  210. 		cipher.init(Cipher.ENCRYPT_MODE, publicK);
  211. 		int inputLen = data.length;
  212. 		ByteArrayOutputStream out = new ByteArrayOutputStream();
  213. 		int offSet = 0;
  214. 		byte[] cache;
  215. 		int i = 0;
  216. 		// 对数据分段加密
  217. 		while (inputLen - offSet > 0) {
  218. 			if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
  219. 				cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
  220. 			} else {
  221. 				cache = cipher.doFinal(data, offSet, inputLen - offSet);
  222. 			}
  223. 			out.write(cache, 0, cache.length);
  224. 			i++;
  225. 			offSet = i * MAX_ENCRYPT_BLOCK;
  226. 		}
  227. 		byte[] encryptedData = out.toByteArray();
  228. 		out.close();
  229. 		return Base64.encode(encryptedData);
  230. 	}
  231.  
  232. 	/**
  233. 	 * <p>
  234. 	 * 私钥加密
  235. 	 * </p>
  236. 	 * 
  237. 	 * @param data
  238. 	 *            源数�?
  239. 	 * @param privateKey
  240. 	 *            私钥(BASE64编码)
  241. 	 * @return
  242. 	 * @throws Exception
  243. 	 */
  244. 	public static byte[] encryptByPrivateKey(byte[] data, String privateKey) throws Exception {
  245. 		byte[] keyBytes = Base64.decode(privateKey);
  246. 		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
  247. 		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  248. 		Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
  249. 		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
  250. 		cipher.init(Cipher.ENCRYPT_MODE, privateK);
  251. 		int inputLen = data.length;
  252. 		ByteArrayOutputStream out = new ByteArrayOutputStream();
  253. 		int offSet = 0;
  254. 		byte[] cache;
  255. 		int i = 0;
  256. 		// 对数据分段加密
  257. 		while (inputLen - offSet > 0) {
  258. 			if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
  259. 				cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
  260. 			} else {
  261. 				cache = cipher.doFinal(data, offSet, inputLen - offSet);
  262. 			}
  263. 			out.write(cache, 0, cache.length);
  264. 			i++;
  265. 			offSet = i * MAX_ENCRYPT_BLOCK;
  266. 		}
  267. 		byte[] encryptedData = out.toByteArray();
  268. 		out.close();
  269. 		return encryptedData;
  270. 	}
  271.  
  272.     /**
  273.    	 * 公钥加密 
  274.    	 * @param publicKeyStr
  275.    	 * @param data 加密字符串
  276.    	 * @return String 密文数据
  277.    	 * @throws Exception
  278.    	 */
  279.    	public static String encryptForPublicKey(String data, String publicKeyStr) throws Exception{
  280.    		 return encryptByPublicKey(data.getBytes(), publicKeyStr);
  281.    	}
  282.    	
  283.    	/**
  284.    	 * 私钥加密
  285.    	 * @param privateKeyStr 私钥
  286.    	 * @param data 加密字符串
  287.    	 * @return String 密文数据
  288.    	 * @throws Exception
  289.    	 */
  290.    	public static String encryptForPrivateKey(String data, String privateKeyStr) throws Exception{
  291.    		byte[] decryptedData = encryptByPrivateKey(data.getBytes(), privateKeyStr);
  292.    		return Base64.encode(decryptedData);
  293.    	}
  294.    	
  295.    	/**
  296.    	 * 私钥解密方法
  297.    	 * @param privateKey 私钥
  298.    	 * @param plainTextData 密文
  299.    	 * @return String 明文
  300.    	 * @throws Exception
  301.    	 */
  302.    	public static String decryptForPrivateKey(String plainTextData, String privateKey) throws Exception{
  303.    		return decryptByPrivateKey(plainTextData.getBytes(), privateKey);
  304.    	}
  305.    	
  306.    	/**
  307.    	 * 公钥解密方法
  308.    	 * @param publicKey
  309.    	 * @param plainTextData 密文
  310.    	 * @return 明文
  311.    	 * @throws Exception
  312.    	 */
  313.    	public static String decryptForPublicKey(String plainTextData, String publicKey) throws Exception{
  314.    		byte[] decryptedData = decryptByPublicKey(Base64.decode(plainTextData), publicKey);
  315.    		return new String(decryptedData);
  316.    	}
  317.    	
  318.     /**
  319.      * 字节数据转十六进制字符串
  320.      *
  321.      * @param data
  322.      *            输入数据
  323.      * @return 十六进制内容
  324.      */
  325.     public static String byteArrayToString(byte[] data) {
  326.         StringBuilder stringBuilder = new StringBuilder();
  327.         for (int i = 0; i < data.length; i++) {
  328.             // 取出字节的高四位 作为索引得到相应的十六进制标识符 注意无符号右移
  329.             stringBuilder.append(HEX_CHAR[(data[i] & 0xf0) >>> 4]);
  330.             // 取出字节的低四位 作为索引得到相应的十六进制标识符
  331.             stringBuilder.append(HEX_CHAR[(data[i] & 0x0f)]);
  332.             if (i < data.length - 1) {
  333.                 stringBuilder.append(' ');
  334.             }
  335.         }
  336.         return stringBuilder.toString();
  337.     }
  338.     
  339.     static String bytesToString(byte[] encrytpByte) {
  340.         String result = "";
  341.         for (Byte bytes : encrytpByte) {
  342.             result += bytes.toString() + " ";
  343.         }
  344.         return result;
  345.     }
  346. }

RSA签名工具类源码：

  1. package com.pay.utils;
  2. import java.lang.reflect.Field;
  3. import java.security.KeyFactory;
  4. import java.security.PrivateKey;
  5. import java.security.PublicKey;
  6. import java.security.spec.PKCS8EncodedKeySpec;
  7. import java.security.spec.X509EncodedKeySpec;
  8. import java.util.Comparator;
  9. import java.util.HashMap;
  10. import java.util.Map;
  11.  
  12. public class RSASignature{
  13.  
  14.     /**
  15.      * 签名算法
  16.      */
  17.     public static final String SIGN_ALGORITHMS = "SHA256WithRSA";
  18.  
  19.     /**
  20. 	 * 加密算法RSA
  21. 	 */
  22. 	public static final String KEY_ALGORITHM = "RSA";
  23. 	
  24.     /**
  25.      * RSA签名
  26.      * @param content 待签名数据
  27.      * @param privateKey 商户私钥
  28.      * @param encode 字符集编码
  29.      * @return 签名值
  30.      */
  31.     public static String sign(String content, String privateKey, String encode)
  32.     {
  33.         try
  34.         {
  35.             PKCS8EncodedKeySpec priPKCS8    = new PKCS8EncodedKeySpec(Base64.decode(privateKey));
  36.             KeyFactory keyf                 = KeyFactory.getInstance(KEY_ALGORITHM);
  37.             PrivateKey priKey               = keyf.generatePrivate(priPKCS8);
  38.             java.security.Signature signature = java.security.Signature.getInstance(SIGN_ALGORITHMS);
  39.             signature.initSign(priKey);
  40.             signature.update(content.getBytes(encode));
  41.             byte[] signed = signature.sign();
  42.             return Base64.encode(signed);
  43.         }
  44.         catch (Exception e)
  45.         {
  46.             e.printStackTrace();
  47.         }
  48.  
  49.         return null;
  50.     }
  51.  
  52.     /**
  53.      * 根据 content 和 私钥  生成签名
  54.      * @param content  按字典顺序排序的内容
  55.      * @param privateKey  ftp上保存的私钥
  56.      * @return
  57.      */
  58.     public static String sign(String content, String privateKey)
  59.     {
  60.         try
  61.         {
  62.             PKCS8EncodedKeySpec priPKCS8 = new PKCS8EncodedKeySpec( Base64.decode(privateKey) );
  63.             KeyFactory keyf = KeyFactory.getInstance(KEY_ALGORITHM);
  64.             PrivateKey priKey = keyf.generatePrivate(priPKCS8);
  65.             java.security.Signature signature = java.security.Signature.getInstance(SIGN_ALGORITHMS);
  66.             signature.initSign(priKey);
  67.             signature.update(content.getBytes());
  68.             byte[] signed = signature.sign();
  69.             return Base64.encode(signed);
  70.         }
  71.         catch (Exception e)
  72.         {
  73.             e.printStackTrace();
  74.         }
  75.         return null;
  76.     }
  77.  
  78.     /**
  79.      * RSA验签名检查
  80.      * @param content 待签名数据
  81.      * @param sign 签名值
  82.      * @param publicKey 分配给开发商公钥
  83.      * @param encode 字符集编码
  84.      * @return 布尔值
  85.      */
  86.     public static boolean doCheck(String content, String sign, String publicKey,String encode)
  87.     {
  88.         try
  89.         {
  90.             KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  91.             byte[] encodedKey = Base64.decode(publicKey);
  92.             PublicKey pubKey = keyFactory.generatePublic(new X509EncodedKeySpec(encodedKey));
  93.             java.security.Signature signature = java.security.Signature
  94.                     .getInstance(SIGN_ALGORITHMS);
  95.             signature.initVerify(pubKey);
  96.             signature.update( content.getBytes(encode) );
  97.  
  98.             boolean bverify = signature.verify( Base64.decode(sign) );
  99.             return bverify;
  100.  
  101.         }
  102.         catch (Exception e)
  103.         {
  104.             e.printStackTrace();
  105.         }
  106.  
  107.         return false;
  108.     }
  109.  
  110.     /**
  111.      * RSA验签名检查
  112.      * @param content 待签名数据
  113.      * @param sign 签名值
  114.      * @param publicKey 分配给开发商公钥
  115.      * @return 布尔值
  116.      */
  117.     public static boolean doCheck(String content, String sign, String publicKey)
  118.     {
  119.         try
  120.         {
  121.             KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  122.             byte[] encodedKey = Base64.decode(publicKey);
  123.             if (encodedKey==null){
  124.                 return false;
  125.             }
  126.             PublicKey pubKey = keyFactory.generatePublic(new X509EncodedKeySpec(encodedKey));
  127.  
  128.             // 用私钥对信息生成数字签名
  129.             java.security.Signature signature = java.security.Signature
  130.                     .getInstance(SIGN_ALGORITHMS);
  131.  
  132.             signature.initVerify(pubKey);
  133.             signature.update( content.getBytes() );
  134.             // 验证方法  返回true则为比对成功
  135.             boolean bverify = signature.verify( Base64.decode(sign) );
  136.             return bverify;
  137.  
  138.         }
  139.         catch (Exception e)
  140.         {
  141.             e.printStackTrace();
  142.         }
  143.  
  144.         return false;
  145.     }
  146.  
  147.  
  148.     /**
  149.      * 对象转HashMap
  150.      * @param obj
  151.      * @return
  152.      */
  153.     public static Map<String, Object> objectToMap(Object obj) {
  154.         if (obj == null) {
  155.             return null;
  156.         }
  157.  
  158.         Map<String, Object> map = new HashMap<String, Object>();
  159.         try {
  160.             Field[] declaredFields = obj.getClass().getDeclaredFields();
  161.             for (Field field : declaredFields) {
  162.                 field.setAccessible(true);
  163.                 map.put(field.getName(), field.get(obj));
  164.             }
  165.         } catch (Exception e) {
  166.  
  167.         }
  168.  
  169.         return map;
  170.     }
  171.  
  172.     /**
  173.      *  @Description: 将签名的参数内容按参数名的字典顺序进行排序，并拼接为字符串
  174.      */
  175.     public static String getContent(Map<String,Object> map){
  176.         //得到第三方签名 第三方会把sign也放在json里，故转map的时候需要把sign删除
  177.         map.remove("shoppingAddrsInfo");
  178.         map.entrySet().removeIf(entry -> entry.getValue() == null);
  179.         // 将签名的参数内容按参数名的字典顺序进行排序，并拼接为字符串
  180.         StringBuilder sb = new StringBuilder();
  181.         map.entrySet().stream().sorted(Comparator.comparing(Map.Entry::getKey)).forEach(entry ->
  182.                 sb.append(entry.getKey()).append("=").append(entry.getValue()).append("&")
  183.         );
  184.         return sb.toString().substring(0, sb.length() - 1);
  185.     }
  186.  
  187.     /**
  188.      * 签名方法
  189.      * 因为很多处都需要用，特地封装一下，方便调用
  190.      * @param paramStr   按字典顺序拼接过的字符串
  191.      * @param publicKey  从数据库查询出来的第三方公钥
  192.      * @param sign  第三方签名
  193.      * @return
  194.      */
  195.     public static boolean signVerify(String paramStr,String publicKey,String sign){
  196.         try {
  197.             // 使用公钥进行验签
  198.             boolean result = RSASignature.doCheck(paramStr, sign, publicKey);
  199.             if (result){
  200.                 return true;
  201.             }
  202.         } catch (Exception e) {
  203.             e.printStackTrace();
  204.         }
  205.         return false;
  206.     }
  207.  
  208.  
  209. }

Base64类源码：

  1. package com.pay.utils;
  2.  
  3. public final class Base64
  4. {
  5.  
  6.     static private final int     BASELENGTH           = 128;
  7.     static private final int     LOOKUPLENGTH         = 64;
  8.     static private final int     TWENTYFOURBITGROUP   = 24;
  9.     static private final int     EIGHTBIT             = 8;
  10.     static private final int     SIXTEENBIT           = 16;
  11.     static private final int     FOURBYTE             = 4;
  12.     static private final int     SIGN                 = -128;
  13.     static private final char    PAD                  = '=';
  14.     static private final boolean fDebug               = false;
  15.     static final private byte[]  base64Alphabet       = new byte[BASELENGTH];
  16.     static final private char[]  lookUpBase64Alphabet = new char[LOOKUPLENGTH];
  17.  
  18.     static
  19.     {
  20.         for (int i = 0; i < BASELENGTH; ++i)
  21.         {
  22.             base64Alphabet[i] = -1;
  23.         }
  24.         for (int i = 'Z'; i >= 'A'; i--)
  25.         {
  26.             base64Alphabet[i] = (byte) (i - 'A');
  27.         }
  28.         for (int i = 'z'; i >= 'a'; i--)
  29.         {
  30.             base64Alphabet[i] = (byte) (i - 'a' + 26);
  31.         }
  32.  
  33.         for (int i = '9'; i >= '0'; i--)
  34.         {
  35.             base64Alphabet[i] = (byte) (i - '0' + 52);
  36.         }
  37.  
  38.         base64Alphabet['+'] = 62;
  39.         base64Alphabet['/'] = 63;
  40.  
  41.         for (int i = 0; i <= 25; i++)
  42.         {
  43.             lookUpBase64Alphabet[i] = (char) ('A' + i);
  44.         }
  45.  
  46.         for (int i = 26, j = 0; i <= 51; i++, j++)
  47.         {
  48.             lookUpBase64Alphabet[i] = (char) ('a' + j);
  49.         }
  50.  
  51.         for (int i = 52, j = 0; i <= 61; i++, j++)
  52.         {
  53.             lookUpBase64Alphabet[i] = (char) ('0' + j);
  54.         }
  55.         lookUpBase64Alphabet[62] = (char) '+';
  56.         lookUpBase64Alphabet[63] = (char) '/';
  57.  
  58.     }
  59.  
  60.     private static boolean isWhiteSpace(char octect)
  61.     {
  62.         return (octect == 0x20 || octect == 0xd || octect == 0xa || octect == 0x9);
  63.     }
  64.  
  65.     private static boolean isPad(char octect)
  66.     {
  67.         return (octect == PAD);
  68.     }
  69.  
  70.     private static boolean isData(char octect)
  71.     {
  72.         return (octect < BASELENGTH && base64Alphabet[octect] != -1);
  73.     }
  74.  
  75.     /**
  76.      * Encodes hex octects into Base64
  77.      * 
  78.      * @param binaryData
  79.      *            Array containing binaryData
  80.      * @return Encoded Base64 array
  81.      */
  82.     public static String encode(byte[] binaryData)
  83.     {
  84.  
  85.         if (binaryData == null)
  86.         {
  87.             return null;
  88.         }
  89.  
  90.         int lengthDataBits = binaryData.length * EIGHTBIT;
  91.         if (lengthDataBits == 0)
  92.         {
  93.             return "";
  94.         }
  95.  
  96.         int fewerThan24bits = lengthDataBits % TWENTYFOURBITGROUP;
  97.         int numberTriplets = lengthDataBits / TWENTYFOURBITGROUP;
  98.         int numberQuartet = fewerThan24bits != 0 ? numberTriplets + 1
  99.                 : numberTriplets;
  100.         char encodedData[] = null;
  101.  
  102.         encodedData = new char[numberQuartet * 4];
  103.  
  104.         byte k = 0, l = 0, b1 = 0, b2 = 0, b3 = 0;
  105.  
  106.         int encodedIndex = 0;
  107.         int dataIndex = 0;
  108.         if (fDebug)
  109.         {
  110.             System.out.println("number of triplets = " + numberTriplets);
  111.         }
  112.  
  113.         for (int i = 0; i < numberTriplets; i++)
  114.         {
  115.             b1 = binaryData[dataIndex++];
  116.             b2 = binaryData[dataIndex++];
  117.             b3 = binaryData[dataIndex++];
  118.  
  119.             if (fDebug)
  120.             {
  121.                 System.out.println("b1= " + b1 + ", b2= " + b2 + ", b3= " + b3);
  122.             }
  123.  
  124.             l = (byte) (b2 & 0x0f);
  125.             k = (byte) (b1 & 0x03);
  126.  
  127.             byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2)
  128.                     : (byte) ((b1) >> 2 ^ 0xc0);
  129.             byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4)
  130.                     : (byte) ((b2) >> 4 ^ 0xf0);
  131.             byte val3 = ((b3 & SIGN) == 0) ? (byte) (b3 >> 6)
  132.                     : (byte) ((b3) >> 6 ^ 0xfc);
  134.             if (fDebug)
  135.             {
  136.                 System.out.println("val2 = " + val2);
  137.                 System.out.println("k4   = " + (k << 4));
  138.                 System.out.println("vak  = " + (val2 | (k << 4)));
  139.             }
  140.  
  141.             encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];
  142.             encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)];
  143.             encodedData[encodedIndex++] = lookUpBase64Alphabet[(l << 2) | val3];
  144.             encodedData[encodedIndex++] = lookUpBase64Alphabet[b3 & 0x3f];
  145.         }
  146.  
  147.         // form integral number of 6-bit groups
  148.         if (fewerThan24bits == EIGHTBIT)
  149.         {
  150.             b1 = binaryData[dataIndex];
  151.             k = (byte) (b1 & 0x03);
  152.             if (fDebug)
  153.             {
  154.                 System.out.println("b1=" + b1);
  155.                 System.out.println("b1<<2 = " + (b1 >> 2));
  156.             }
  157.             byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2)
  158.                     : (byte) ((b1) >> 2 ^ 0xc0);
  159.             encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];
  160.             encodedData[encodedIndex++] = lookUpBase64Alphabet[k << 4];
  161.             encodedData[encodedIndex++] = PAD;
  162.             encodedData[encodedIndex++] = PAD;
  163.         }
  164.         else if (fewerThan24bits == SIXTEENBIT)
  165.         {
  166.             b1 = binaryData[dataIndex];
  167.             b2 = binaryData[dataIndex + 1];
  168.             l = (byte) (b2 & 0x0f);
  169.             k = (byte) (b1 & 0x03);
  170.  
  171.             byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2)
  172.                     : (byte) ((b1) >> 2 ^ 0xc0);
  173.             byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4)
  174.                     : (byte) ((b2) >> 4 ^ 0xf0);
  176.             encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];
  177.             encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)];
  178.             encodedData[encodedIndex++] = lookUpBase64Alphabet[l << 2];
  179.             encodedData[encodedIndex++] = PAD;
  180.         }
  181.  
  182.         return new String(encodedData);
  183.     }
  184.  
  185.     /**
  186.      * Decodes Base64 data into octects
  187.      * 
  188.      * @param encoded
  189.      *            string containing Base64 data
  190.      * @return Array containind decoded data.
  191.      */
  192.     public static byte[] decode(String encoded)
  193.     {
  194.  
  195.         if (encoded == null)
  196.         {
  197.             return null;
  198.         }
  199.  
  200.         char[] base64Data = encoded.toCharArray();
  201.         // remove white spaces
  202.         int len = removeWhiteSpace(base64Data);
  203.  
  204.         if (len % FOURBYTE != 0)
  205.         {
  206.             return null;// should be divisible by four
  207.         }
  208.  
  209.         int numberQuadruple = (len / FOURBYTE);
  210.  
  211.         if (numberQuadruple == 0)
  212.         {
  213.             return new byte[0];
  214.         }
  215.  
  216.         byte decodedData[] = null;
  217.         byte b1 = 0, b2 = 0, b3 = 0, b4 = 0;
  218.         char d1 = 0, d2 = 0, d3 = 0, d4 = 0;
  219.  
  220.         int i = 0;
  221.         int encodedIndex = 0;
  222.         int dataIndex = 0;
  223.         decodedData = new byte[(numberQuadruple) * 3];
  224.  
  225.         for (; i < numberQuadruple - 1; i++)
  226.         {
  227.  
  228.             if (!isData((d1 = base64Data[dataIndex++]))
  229.                     || !isData((d2 = base64Data[dataIndex++]))
  230.                     || !isData((d3 = base64Data[dataIndex++]))
  231.                     || !isData((d4 = base64Data[dataIndex++])))
  232.             {
  233.                 return null;
  234.             }// if found "no data" just return null
  235.  
  236.             b1 = base64Alphabet[d1];
  237.             b2 = base64Alphabet[d2];
  238.             b3 = base64Alphabet[d3];
  239.             b4 = base64Alphabet[d4];
  240.  
  241.             decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
  242.             decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
  243.             decodedData[encodedIndex++] = (byte) (b3 << 6 | b4);
  244.         }
  245.  
  246.         if (!isData((d1 = base64Data[dataIndex++]))
  247.                 || !isData((d2 = base64Data[dataIndex++])))
  248.         {
  249.             return null;// if found "no data" just return null
  250.         }
  251.  
  252.         b1 = base64Alphabet[d1];
  253.         b2 = base64Alphabet[d2];
  254.  
  255.         d3 = base64Data[dataIndex++];
  256.         d4 = base64Data[dataIndex++];
  257.         if (!isData((d3)) || !isData((d4)))
  258.         {// Check if they are PAD characters
  259.             if (isPad(d3) && isPad(d4))
  260.             {
  261.                 if ((b2 & 0xf) != 0)// last 4 bits should be zero
  262.                 {
  263.                     return null;
  264.                 }
  265.                 byte[] tmp = new byte[i * 3 + 1];
  266.                 System.arraycopy(decodedData, 0, tmp, 0, i * 3);
  267.                 tmp[encodedIndex] = (byte) (b1 << 2 | b2 >> 4);
  268.                 return tmp;
  269.             }
  270.             else if (!isPad(d3) && isPad(d4))
  271.             {
  272.                 b3 = base64Alphabet[d3];
  273.                 if ((b3 & 0x3) != 0)// last 2 bits should be zero
  274.                 {
  275.                     return null;
  276.                 }
  277.                 byte[] tmp = new byte[i * 3 + 2];
  278.                 System.arraycopy(decodedData, 0, tmp, 0, i * 3);
  279.                 tmp[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
  280.                 tmp[encodedIndex] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
  281.                 return tmp;
  282.             }
  283.             else
  284.             {
  285.                 return null;
  286.             }
  287.         }
  288.         else
  289.         { // No PAD e.g 3cQl
  290.             b3 = base64Alphabet[d3];
  291.             b4 = base64Alphabet[d4];
  292.             decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
  293.             decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
  294.             decodedData[encodedIndex++] = (byte) (b3 << 6 | b4);
  295.  
  296.         }
  297.  
  298.         return decodedData;
  299.     }
  300.  
  301.     /**
  302.      * remove WhiteSpace from MIME containing encoded Base64 data.
  303.      * 
  304.      * @param data
  305.      *            the byte array of base64 data (with WS)
  306.      * @return the new length
  307.      */
  308.     private static int removeWhiteSpace(char[] data)
  309.     {
  310.         if (data == null)
  311.         {
  312.             return 0;
  313.         }
  314.  
  315.         // count characters that's not whitespace
  316.         int newSize = 0;
  317.         int len = data.length;
  318.         for (int i = 0; i < len; i++)
  319.         {
  320.             if (!isWhiteSpace(data[i]))
  321.             {
  322.                 data[newSize++] = data[i];
  323.             }
  324.         }
  325.         return newSize;
  326.     }
  327. }

JAVA调用示例：

  1. public class Test {
  2. static String publicKey = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnPo+UWWzx0Ny83acrRJCZy8sE5sYkuwvNYMTMd9ZHZQb8QRdZq6Ib+04+FocSHPt6OoMD+QB6ekbPyKY9NUGdtDVJ6AySGYlYnMT963lthsJrcJIL+QFyAlN2+BSh40ReTPISc2RpC7ahScsRmoj+wQE+HUSXvt7rqAdQM/ijthudPOI+DfGCtZjX7oS5pN3U2Ih7Qsx/51NpGbYKxA7ve+KCYDfmGbWDtwAChAFQnVZDyNOuusjyXbmHu2q+ey5y7Ztn2MyIQ2d/Ki3wDqLvZORgPpm6xm73+qh1A/9sjbsSc0cxPju21wP2tSKzNdegj6soXYUsWkrUM7Bcoi91wIDAQAB";
  3.     static String privateKey = "MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQCQuWPZmqnRPKbxtLkowlF+foMHM0NPr5D2dqWLAwmarUgdUd1L10WLIaJOjL36S1VOF4woDc8sd26ntO2LfP+TpAAIXpmsWRq9C4fY7Z24mR2EAu6FlDlHXvteYKh6XUYw36xn9fg9yh7yKjC0M8F/LTsmY1fKc4k0w0ARrWdY3IqpbFv8E/7WkUp6oBaza5+GiQ614fvmxzIAJaXg6D6USvmbPLMgxYFePOXyxDnA3YmC4SC4Zru3V0QVHewmy+VOHc+L3MJcMPPzMifZ5R2tXUM0mQPb3k9GuDY2etCI00jwhaw1IGIdgGsv8yJcwX9IBZYTsPIX5FUh9eVWKE/LAgMBAAECggEAdwfjtf/dF/i4niez+nAIMu++uNdSz2Fo6y0ebr0q0wseOu8wAcamrg4VvmFHh2saWEZJwk/JS5tXaZwHnChM1JOYa0nTPstykHXBX4vfowpcGk2G/Fqy2Z6nRDJfn3TD3EK7PC4z5C4vUaGduTiwNvdupN4kQKDSApFsSp3CWHSY0rE+kgNXfBrY6u16xc0QNRzoj+8/R1mno8OZCUEnFocRV4975mtAVrt3xsA+ejQqjhJnxUAKXVDMmOaVTyHwQyRrRDk7UzCpYax5YgVUbquRweOJl/HK9+zZzNcAy1cQUMjrAr9gUwCXZaKkdL0fujXXxPmfDLZF+QzoZrKVQQKBgQDqbps2vX/EGii8HjOFf4uvhMbSct37kWOiJMGqLIinxvrlxeWWShXhNp5eUPHg9i0bEZYSTLxRd2qM3xFsE6Wy/Zt/1x+9M7EDYafvJsSVsvmcJFBlfG2/VBT56iT4xDgHJOoDa8OeYQMbkJIEE+Xl+dXmfcfnijZkL66/JSebewKBgQCeCfb5D1ehRvvRw9gh0vXI18J0lc6wUEFS6A5UV7P27jmh80HgRnYlLzWryIAXcqvGACir9V6ZHCWfdzuhxxFqjSBqZPTMfKFHCxOk2YvHcGRQwsSZMGBfRKjyETFGRkPBphnq0sE3zKIKafB7Z0swBlcKB0yneIAilwUAsT2D8QKBgBPJ2lg4jrxi6OVYN0khhwz9zDqfb5V4pExfhelzcOWYqj0TA1o4Trh//8Y+VuyCWzRZu603xP2rctcJTVMuJWKCfcnAwvEZl+uNJrvNLfLk9KT1e8PVSP5JfqvJ0+0bww73UrmPMyf/UF/XSDwH4fQTrraSD3m/9O9oBvwjisBZAoGAQ5GXGl1I5hdnSwQkwDFmDHzTEu2J9TAa/cthdQYaV5T65xcOL0lw8e0BUXTj7yKD9p/Sw9Kgo225WDiuMjjeZWP5XAPV9ifC/JDr0SuB679N5ImhbK2WRqUgZn6bRqR8C6tsoU2Cdszy6ujofJppNxs+03bTeza18hQHe4hL+MECgYB9fEHhluk+fuKDfxVNTd98PBjatv4ZhMD3j1d+u0PWGZ2ajOBZ7m0ewso2n5otaTP2pxclmOq1/NX2KXUS2XVgX/bVZy1iUOmT8lUX3CHLUugQqdcv2oBL9n8n3rFhebps98MmUtVhx7qORrNU0aG6RlvFn3QBmF6mHXOuZ1nq6w==";
  4.     public static void main(String[] args) throws Exception {
  5.         Map<String,Object> params = new HashMap<>();
  6.         params.put("merchantNo", merchantNo); // 商户号
  7. 		params.put("merchantOrderNo", merchantOrderNo); // 商户订单号
  8. 		params.put("currency", "CNY"); // 币种
  9. 		params.put("amount", "0.15");// 交易金额（单位：元）
  10.         //签名数据按ASCII字码从小到大排序，所有键值对以“&”字符连接起来
  11. 		String data = 
  12.         RSASignature.getContent(JSON.parseObject(JSON.toJSONString(params)));
  13. 		System.out.println(data);
  14.         // RSA签名
  15. 		String sign = RSASignature.sign(data, privateKey, "UTF-8");
  16.         System.out.println(sign);
  17.         String encryptData = RSAEncrypt.encryptForPrivateKey(str, privateKey);
  18.         System.out.println("加密后内容:" + encryptData);
  19.         //公钥解密
  20.         //RSA解密
  21. 		String decryptData = RSAEncrypt.decryptForPublicKey(encryptData, publicKey);
  22. 		System.out.println("解密后内容:" + decryptData);
  23.     }
  24. }

PHP加解密工具类源码：

  1. class RSA
  2. {
  3.     public $privateKey = './rsa_private_key.pem';           //私钥地址
  4.     public $publicKey = './rsa_public_key.pem';             //公钥地址
  5.  
  6.     public $pri_key = '';
  7.     public $pub_key = '';
  8.  
  9.     /**
  10.      * RSA constructor.
  11.      * @param null $publicKeyPath
  12.      * @param null $privateKeyPath
  13.      * @param null $publicKey
  14.      * @param null $privateKey
  15.      * @throws FileNotFoundException
  16.      */
  17.     public function __construct($publicKeyPath=null, $privateKeyPath=null, $publicKey=null, $privateKey=null) {
  18.  
  19.         if ($this->checkKeyFile($publicKeyPath)) {
  20.             $this->pub_key = openssl_pkey_get_public(file_get_contents($publicKeyPath));
  21.         }
  22.  
  23.         if ($this->checkKeyFile($privateKeyPath)) {
  24.             $this->pri_key = openssl_pkey_get_private(file_get_contents($privateKeyPath));
  25.         }
  26.  
  27.         if (!is_null($publicKey)) {
  28.             $this->pub_key = openssl_pkey_get_public($this->formatterPublicKey($publicKey));
  29.         }
  30.  
  31.         if (!is_null($privateKey)) {
  32.             $this->pri_key = openssl_pkey_get_private($this->formatterPrivateKey($privateKey));
  33.         }
  34.  
  35.     }
  36.  
  37.     /**
  38.      * 校验文件是否存在
  39.      * @param $keyPath string 文件路径
  40.      * @return bool
  41.      * @throws FileNotFoundException
  42.      */
  43.     public function checkKeyFile($keyPath)
  44.     {
  45.         if (!is_null($keyPath)) {
  46.             if(!file_exists($keyPath)) {
  47.                 throw new FileNotFoundException($keyPath);
  48.             }
  49.  
  50.             return true;
  51.         }
  52.  
  53.         return false;
  54.     }
  55.  
  56.     /**
  57.      * 格式化公钥
  58.      * @param $publicKey string 公钥
  59.      * @return string
  60.      */
  61.     public function formatterPublicKey($publicKey)
  62.     {
  63.         if (str_contains('-----BEGIN PUBLIC KEY-----', $publicKey)) return $publicKey;
  64.  
  65.         $str = chunk_split($publicKey, 64, PHP_EOL);//在每一个64字符后加一个\n
  66.         $publicKey = "-----BEGIN PUBLIC KEY-----".PHP_EOL.$str."-----END PUBLIC KEY-----";
  67.  
  68.         return $publicKey;
  69.     }
  70.  
  71.     /**
  72.      * 格式化私钥
  73.      * @param $privateKey string 公钥
  74.      * @return string
  75.      */
  76.     public function formatterPrivateKey($privateKey)
  77.     {
  78.         if (str_contains('-----BEGIN RSA PRIVATE KEY-----', $privateKey)) return $privateKey;
  79.  
  80.         $str = chunk_split($privateKey, 64, PHP_EOL);//在每一个64字符后加一个\n
  81.         $privateKey = "-----BEGIN RSA PRIVATE KEY-----".PHP_EOL.$str."-----END RSA PRIVATE KEY-----";
  82.  
  83.         return $privateKey;
  84.     }
  85.  
  86.     /**
  87.      *  私钥加密（分段加密）
  88.      *  emptyStr    需要加密字符串
  89.      */
  90.     public function encrypt($str) {
  91.         $crypted = array();
  92. //        $data = json_encode($str);
  93.         $data = $str;
  94.         $dataArray = str_split($data, 117);
  95.         foreach($dataArray as $subData){
  96.             $subCrypted = null;
  97.             openssl_private_encrypt($subData, $subCrypted, $this->pri_key);
  98.             $crypted[] = $subCrypted;
  99.         }
  100.         $crypted = implode('',$crypted);
  101.         return base64_encode($crypted);
  102.     }
  103.  
  104.     /**
  105.      *  公钥解密（分段解密）
  106.      *  @encrypstr  加密字符串
  107.      */
  108.     public function decrypt($encryptstr) {
  109.         // echo $encryptstr;exit;
  110.         $encryptstr = base64_decode($encryptstr);
  111.         $decrypted = array();
  112.         $dataArray = str_split($encryptstr, 128);
  113.  
  114.         foreach($dataArray as $subData){
  115.             $subDecrypted = null;
  116.             openssl_public_decrypt($subData, $subDecrypted, $this->pub_key);
  117.             $decrypted[] = $subDecrypted;
  118.         }
  119.         $decrypted = implode('',$decrypted);
  120.         // openssl_public_decrypt(base64_decode($encryptstr),$decryptstr,$this->pub_key);
  121.         return $decrypted;
  122.     }
  123.  
  124. }

PHP RSA签名验签：

  1. /**
  2.  * 生成签名
  3.  * @param    string     $signString 待签名字符串
  4.  * @param    [type]     $priKey     私钥
  5.  * @return   string     base64结果值
  6.  */
  7. function getSign($signString,$priKey){
  8.     $privKeyId = openssl_pkey_get_private($priKey);
  9.     $signature = '';
  10.     openssl_sign($signString, $signature, $privKeyId);
  11.     openssl_free_key($privKeyId);
  12.     return base64_encode($signature);
  13. }
  14.  
  15. /**
  16.  * 校验签名
  17.  * @param    string     $pubKey 公钥
  18.  * @param    string     $sign   签名
  19.  * @param    string     $toSign 待签名字符串
  20.  * @param    string     $signature_alg 签名方式 比如 sha1WithRSAEncryption 或者sha512
  21.  * @return   bool
  22.  */
  23. function checkSign($pubKey,$sign,$toSign,$signature_alg=OPENSSL_ALGO_SHA1){
  24.     $publicKeyId = openssl_pkey_get_public($pubKey);
  25.     $result = openssl_verify($toSign, base64_decode($sign), $publicKeyId,$signature_alg);
  26.     openssl_free_key($publicKeyId);
  27.     return $result === 1 ? true : false;
  28. }

 PHP调用示例：

  1. $privateKey = 'MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBANSwa2pVnn4QbVxaNJg/1sudmGZL3eFOEOMk/ILagTnXNNtdV6pOslBOp5RBd93TdMZg/4KaAiluyOfg+WbExS7hg/cPXEiVfhF+4O+39uGmoYjlxAAs0dr+ZMAYjiZ+XKh8fuctD7mRYEkr7pBvqQbcRIDyJZpKIbyotcFudXVfAgMBAAECgYAJwJEcThK3Ww94pZY1yO+TZIWBY0coNoklsSN26If2W/zLdis33uXkMscSUDIr1K9NDVOJ7H/e4HqLz1AAO1ODLmFxflnyeEIKan6M/4NA8/7IF+Wu0FDQjNm2iKW68axKiW01j6yqq2JagG9kff5xbkzxriuWpmiDF0TWxzm6aQJBAPB2asI5dVr7bBC+sK7FjPQGNIu6X2NHeacHzUswSo7b4NgTucAkubjLTgpd3s8/FQoVBm4Ay7Juzc0DBjVUv2UCQQDibpd6lzY0E9cNGol83HDKJGUTmnpduE9PKYua019vx/tgoMOK4squqnV74IY7NkhP5V0djO0XYxD0EaFnmV9zAkAkp4hijuuqsMSqUMcR/R8dW4zK99/ufEi5A2Fx4qya1j2R8n/QIEkHOEZvIhwCr3T/knDmd8yVKHrKk3lwy7hZAkEAlB7SGpCGFaUQ3XKJk9NEOQd700oPV/V0dA1yVHKHEMFaMIiZweW/vmild8aVKHDG9vTMZ8NDaTQV6AMMeY+7/wJBANeLmqSHflwpMA9BdyTxmuRv8W2lLKsjGDBDnVaKf4hBltMll/e3/OPkg/BPew3lxrHkp3E1I6RyMTzmQxwXd78=';
  2.  
  3. $rsa = new RSA(null, null, null, $privateKey);
  4.  
  5. // 读取pem文件
  6. // $rsa = new RSA(null, public_path('rsa_private_key.pem'));
  7.  
  8. $string = '{"phone":"15256232333","name":"张三","inAcctNo":"8239472342342342","idNo":"342422165897654326","inAcctBankName":"平安银行"}';
  9.  
  10. $encryptstr = $rsa->encrypt($string);
  11.  
  12. echo $encryptstr;
  13.  
  14.  
  15. //获取签名
  16. $sign = getSign($signString,$priKey);
  17.  
  18. //验证签名
  19. $res = checkSign($pubKey,$sign,$signString);
  20. var_dump($res);//结果为 true

本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/小蓝xlanll/article/detail/308270
推荐阅读
相关标签

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

  

闽ICP备14008679号