|
|
@@ -0,0 +1,443 @@
|
|
|
+package com.ym.mec.thirdparty.lingxinpay;
|
|
|
+
|
|
|
+import org.apache.commons.codec.binary.Base64;
|
|
|
+import org.slf4j.Logger;
|
|
|
+import org.slf4j.LoggerFactory;
|
|
|
+
|
|
|
+import javax.crypto.Cipher;
|
|
|
+import java.io.ByteArrayOutputStream;
|
|
|
+import java.io.UnsupportedEncodingException;
|
|
|
+import java.security.*;
|
|
|
+import java.security.interfaces.RSAPrivateKey;
|
|
|
+import java.security.interfaces.RSAPublicKey;
|
|
|
+import java.security.spec.PKCS8EncodedKeySpec;
|
|
|
+import java.security.spec.X509EncodedKeySpec;
|
|
|
+import java.util.HashMap;
|
|
|
+import java.util.Map;
|
|
|
+
|
|
|
+/**
|
|
|
+ *
|
|
|
+ * <p>
|
|
|
+ * RSA签名,加解密处理核心文件，注意：密钥长度1024
|
|
|
+ * </p>
|
|
|
+ *
|
|
|
+ * @author leelun
|
|
|
+ * @version $Id: RSA.java, v 0.1 2013-11-15 下午2:33:53 lilun Exp $
|
|
|
+ */
|
|
|
+public class RSA {
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 签名算法
|
|
|
+ */
|
|
|
+ public static final String SIGNATURE_ALGORITHM = "SHA1withRSA";
|
|
|
+ /**
|
|
|
+ * 加密算法RSA
|
|
|
+ */
|
|
|
+ public static final String KEY_ALGORITHM = "RSA";
|
|
|
+ /**
|
|
|
+ * RSA最大加密明文大小
|
|
|
+ */
|
|
|
+ private static final int MAX_ENCRYPT_BLOCK = 117;
|
|
|
+
|
|
|
+ /**
|
|
|
+ * RSA最大解密密文大小
|
|
|
+ */
|
|
|
+ private static final int MAX_DECRYPT_BLOCK = 128;
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 获取公钥的key
|
|
|
+ */
|
|
|
+ public static final String PUBLIC_KEY = "RSAPublicKey";
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 获取私钥的key
|
|
|
+ */
|
|
|
+ public static final String PRIVATE_KEY = "RSAPrivateKey";
|
|
|
+
|
|
|
+ private static Logger logger = LoggerFactory.getLogger(RSA.class);
|
|
|
+
|
|
|
+ /**
|
|
|
+ * <p>
|
|
|
+ * 生成密钥对(公钥和私钥)
|
|
|
+ * </p>
|
|
|
+ *
|
|
|
+ * @return
|
|
|
+ * @throws Exception
|
|
|
+ */
|
|
|
+ public static Map<String, Object> genKeyPair() throws Exception {
|
|
|
+ KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
|
|
|
+ keyPairGen.initialize(1024);
|
|
|
+ KeyPair keyPair = keyPairGen.generateKeyPair();
|
|
|
+ RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
|
|
|
+ RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
|
|
|
+ Map<String, Object> keyMap = new HashMap<String, Object>(2);
|
|
|
+ keyMap.put(PUBLIC_KEY, publicKey);
|
|
|
+ keyMap.put(PRIVATE_KEY, privateKey);
|
|
|
+ return keyMap;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 签名字符串
|
|
|
+ *
|
|
|
+ * @param text
|
|
|
+ * 需要签名的字符串
|
|
|
+ * @param privateKey
|
|
|
+ * 私钥(BASE64编码)
|
|
|
+ *
|
|
|
+ * @param input_charset
|
|
|
+ * 编码格式
|
|
|
+ * @return 签名结果(BASE64编码)
|
|
|
+ */
|
|
|
+ public static String sign(String text, String privateKey, String charset) throws Exception {
|
|
|
+
|
|
|
+ byte[] keyBytes = Base64.decodeBase64(privateKey);
|
|
|
+ PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
|
|
|
+ KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
|
|
|
+ PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
|
|
|
+ Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
|
|
|
+ signature.initSign(privateK);
|
|
|
+ signature.update(getContentBytes(text, charset));
|
|
|
+ byte[] result = signature.sign();
|
|
|
+ return Base64.encodeBase64String(result);
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 签名字符串
|
|
|
+ *
|
|
|
+ * @param text
|
|
|
+ * 需要签名的字符串
|
|
|
+ * @param sign
|
|
|
+ * 客户签名结果
|
|
|
+ * @param publicKey
|
|
|
+ * 公钥(BASE64编码)
|
|
|
+ * @param input_charset
|
|
|
+ * 编码格式
|
|
|
+ * @return 验签结果
|
|
|
+ */
|
|
|
+ public static boolean verify(String text, String sign, String publicKey, String charset) throws Exception {
|
|
|
+ byte[] keyBytes = Base64.decodeBase64(publicKey);
|
|
|
+ X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
|
|
|
+ KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
|
|
|
+ PublicKey publicK = keyFactory.generatePublic(keySpec);
|
|
|
+
|
|
|
+ Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
|
|
|
+ signature.initVerify(publicK);
|
|
|
+ signature.update(getContentBytes(text, charset));
|
|
|
+ return signature.verify(Base64.decodeBase64(sign));
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * <P>
|
|
|
+ * 私钥解密
|
|
|
+ * </p>
|
|
|
+ *
|
|
|
+ * @param encryptedData
|
|
|
+ * 已加密数据
|
|
|
+ * @param privateKey
|
|
|
+ * 私钥(BASE64编码)
|
|
|
+ * @return
|
|
|
+ * @throws Exception
|
|
|
+ */
|
|
|
+ public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey) throws Exception {
|
|
|
+ byte[] keyBytes = Base64.decodeBase64(privateKey);
|
|
|
+ PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
|
|
|
+ KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
|
|
|
+ Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
|
|
|
+ Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
|
|
|
+ cipher.init(Cipher.DECRYPT_MODE, privateK);
|
|
|
+ int inputLen = encryptedData.length;
|
|
|
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
|
|
|
+ int offSet = 0;
|
|
|
+ byte[] cache;
|
|
|
+ int i = 0;
|
|
|
+ // 对数据分段解密
|
|
|
+ while (inputLen - offSet > 0) {
|
|
|
+ if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
|
|
|
+ cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
|
|
|
+ } else {
|
|
|
+ cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
|
|
|
+ }
|
|
|
+ out.write(cache, 0, cache.length);
|
|
|
+ i++;
|
|
|
+ offSet = i * MAX_DECRYPT_BLOCK;
|
|
|
+ }
|
|
|
+ byte[] decryptedData = out.toByteArray();
|
|
|
+ out.close();
|
|
|
+ return decryptedData;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * <p>
|
|
|
+ * 公钥解密
|
|
|
+ * </p>
|
|
|
+ *
|
|
|
+ * @param encryptedData
|
|
|
+ * 已加密数据
|
|
|
+ * @param publicKey
|
|
|
+ * 公钥(BASE64编码)
|
|
|
+ * @return
|
|
|
+ * @throws Exception
|
|
|
+ */
|
|
|
+ public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey) throws Exception {
|
|
|
+ byte[] keyBytes = Base64.decodeBase64(publicKey);
|
|
|
+ X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
|
|
|
+ KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
|
|
|
+ Key publicK = keyFactory.generatePublic(x509KeySpec);
|
|
|
+ Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
|
|
|
+ cipher.init(Cipher.DECRYPT_MODE, publicK);
|
|
|
+ int inputLen = encryptedData.length;
|
|
|
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
|
|
|
+ int offSet = 0;
|
|
|
+ byte[] cache;
|
|
|
+ int i = 0;
|
|
|
+ // 对数据分段解密
|
|
|
+ while (inputLen - offSet > 0) {
|
|
|
+ if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
|
|
|
+ cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
|
|
|
+ } else {
|
|
|
+ cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
|
|
|
+ }
|
|
|
+ out.write(cache, 0, cache.length);
|
|
|
+ i++;
|
|
|
+ offSet = i * MAX_DECRYPT_BLOCK;
|
|
|
+ }
|
|
|
+ byte[] decryptedData = out.toByteArray();
|
|
|
+ out.close();
|
|
|
+ return decryptedData;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * <p>
|
|
|
+ * 公钥加密
|
|
|
+ * </p>
|
|
|
+ *
|
|
|
+ * @param data
|
|
|
+ * 源数据
|
|
|
+ * @param publicKey
|
|
|
+ * 公钥(BASE64编码)
|
|
|
+ * @return
|
|
|
+ * @throws Exception
|
|
|
+ */
|
|
|
+ public static byte[] encryptByPublicKey(byte[] data, String publicKey) throws Exception {
|
|
|
+ byte[] keyBytes = Base64.decodeBase64(publicKey);
|
|
|
+ X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
|
|
|
+ KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
|
|
|
+ Key publicK = keyFactory.generatePublic(x509KeySpec);
|
|
|
+ // 对数据加密
|
|
|
+ Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
|
|
|
+ cipher.init(Cipher.ENCRYPT_MODE, publicK);
|
|
|
+ int inputLen = data.length;
|
|
|
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
|
|
|
+ int offSet = 0;
|
|
|
+ byte[] cache;
|
|
|
+ int i = 0;
|
|
|
+ // 对数据分段加密
|
|
|
+ while (inputLen - offSet > 0) {
|
|
|
+ if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
|
|
|
+ cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
|
|
|
+ } else {
|
|
|
+ cache = cipher.doFinal(data, offSet, inputLen - offSet);
|
|
|
+ }
|
|
|
+ out.write(cache, 0, cache.length);
|
|
|
+ i++;
|
|
|
+ offSet = i * MAX_ENCRYPT_BLOCK;
|
|
|
+ }
|
|
|
+ byte[] encryptedData = out.toByteArray();
|
|
|
+ out.close();
|
|
|
+ return encryptedData;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * <p>
|
|
|
+ * 私钥加密
|
|
|
+ * </p>
|
|
|
+ *
|
|
|
+ * @param data
|
|
|
+ * 源数据
|
|
|
+ * @param privateKey
|
|
|
+ * 私钥(BASE64编码)
|
|
|
+ * @return
|
|
|
+ * @throws Exception
|
|
|
+ */
|
|
|
+ public static byte[] encryptByPrivateKey(byte[] data, String privateKey) throws Exception {
|
|
|
+ byte[] keyBytes = Base64.decodeBase64(privateKey);
|
|
|
+ PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
|
|
|
+ KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
|
|
|
+ Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
|
|
|
+ Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
|
|
|
+ cipher.init(Cipher.ENCRYPT_MODE, privateK);
|
|
|
+ int inputLen = data.length;
|
|
|
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
|
|
|
+ int offSet = 0;
|
|
|
+ byte[] cache;
|
|
|
+ int i = 0;
|
|
|
+ // 对数据分段加密
|
|
|
+ while (inputLen - offSet > 0) {
|
|
|
+ if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
|
|
|
+ cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
|
|
|
+ } else {
|
|
|
+ cache = cipher.doFinal(data, offSet, inputLen - offSet);
|
|
|
+ }
|
|
|
+ out.write(cache, 0, cache.length);
|
|
|
+ i++;
|
|
|
+ offSet = i * MAX_ENCRYPT_BLOCK;
|
|
|
+ }
|
|
|
+ byte[] encryptedData = out.toByteArray();
|
|
|
+ out.close();
|
|
|
+ return encryptedData;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @param content
|
|
|
+ * @param charset
|
|
|
+ * @return
|
|
|
+ * @throws SignatureException
|
|
|
+ * @throws UnsupportedEncodingException
|
|
|
+ */
|
|
|
+ private static byte[] getContentBytes(String content, String charset) {
|
|
|
+ if (charset == null || "".equals(charset)) {
|
|
|
+ return content.getBytes();
|
|
|
+ }
|
|
|
+ try {
|
|
|
+ return content.getBytes(charset);
|
|
|
+ } catch (UnsupportedEncodingException e) {
|
|
|
+ throw new RuntimeException("签名过程中出现错误,指定的编码集不对,您目前指定的编码集是:" + charset);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * <p>
|
|
|
+ * 获取私钥
|
|
|
+ * </p>
|
|
|
+ *
|
|
|
+ * @param keyMap
|
|
|
+ * 密钥对
|
|
|
+ * @return
|
|
|
+ * @throws Exception
|
|
|
+ */
|
|
|
+ public static String getPrivateKey(Map<String, Object> keyMap) throws Exception {
|
|
|
+ Key key = (Key) keyMap.get(PRIVATE_KEY);
|
|
|
+ return Base64.encodeBase64String(key.getEncoded());
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * <p>
|
|
|
+ * 获取公钥
|
|
|
+ * </p>
|
|
|
+ *
|
|
|
+ * @param keyMap
|
|
|
+ * 密钥对
|
|
|
+ * @return
|
|
|
+ * @throws Exception
|
|
|
+ */
|
|
|
+ public static String getPublicKey(Map<String, Object> keyMap) throws Exception {
|
|
|
+ Key key = (Key) keyMap.get(PUBLIC_KEY);
|
|
|
+ return Base64.encodeBase64String(key.getEncoded());
|
|
|
+ }
|
|
|
+
|
|
|
+ public static void main(String[] args) throws Exception {
|
|
|
+ Map<String, Object> stringObjectMap = genKeyPair();
|
|
|
+ String publicKey = getPublicKey(stringObjectMap);
|
|
|
+ String privateKey = getPrivateKey(stringObjectMap);
|
|
|
+
|
|
|
+ System.out.println(publicKey);
|
|
|
+ System.out.println(privateKey);
|
|
|
+ // String jiami =
|
|
|
+ String jiami = "{'cardAttribute':'1','cardType':'DC','certificateNo':'340323199401163311','charset':'UTF-8','md5Key':'819ee10adc87e33486c8df1aa299c0b6','mobile':'18621542144','name':'崔','notifyUrl':'test','outMemberNo':'1136225387043356673','outerOrderNo':'111111','payAccount':'12345678','payType':'1','predictAmount':10,'projectName':'测试','salaryType':'1','service':'1dada','signType':'RSA','version':'1.0'}";
|
|
|
+ //String jiami = "{'cardAttribute':'1'}";
|
|
|
+
|
|
|
+ /*
|
|
|
+ * byte[] bytes1 = encryptByPublicKey(jiami.getBytes(), publicKey); String bytes
|
|
|
+ * = RSAUtils.decryptByPrivateKey(bytes1, privateKey);
|
|
|
+ * System.out.println(bytes);
|
|
|
+ */
|
|
|
+
|
|
|
+ /*
|
|
|
+ * byte[] encryptPub = encryptByPublicKey(jiami.getBytes(), publicKey); byte[]
|
|
|
+ * decryptPri =
|
|
|
+ * decryptByPrivateKey(Base64.decodeBase64(Base64.encodeBase64(encryptPub)),
|
|
|
+ * privateKey); System.out.println(decryptPri);
|
|
|
+ */
|
|
|
+ /*String encryptPub = encryptPub(jiami, publicKey);
|
|
|
+ String decryptPri = decryptPri(encryptPub, privateKey);
|
|
|
+*/
|
|
|
+ String encryptPub = encryptPub(jiami, publicKey);
|
|
|
+ String decryptPri = decryptPri(encryptPub, privateKey);
|
|
|
+ System.out.println(decryptPri);
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ public static String encryptPub(String str, String publicKey) throws Exception {
|
|
|
+ // base64编码的公钥
|
|
|
+ byte[] decoded = Base64.decodeBase64(publicKey);
|
|
|
+ RSAPublicKey pubKey = (RSAPublicKey) KeyFactory.getInstance("RSA")
|
|
|
+ .generatePublic(new X509EncodedKeySpec(decoded));
|
|
|
+ // RSA加密
|
|
|
+ Cipher cipher = Cipher.getInstance("RSA");
|
|
|
+ cipher.init(Cipher.ENCRYPT_MODE, pubKey);
|
|
|
+ int inputLen = str.getBytes("utf-8").length;
|
|
|
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
|
|
|
+ int offSet = 0;
|
|
|
+ byte[] cache;
|
|
|
+ int i = 0;
|
|
|
+ // 对数据分段加密
|
|
|
+ while (inputLen - offSet > 0) {
|
|
|
+ if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
|
|
|
+ cache = cipher.doFinal(str.getBytes("UTF-8"), offSet, MAX_ENCRYPT_BLOCK);
|
|
|
+ } else {
|
|
|
+ cache = cipher.doFinal(str.getBytes("UTF-8"), offSet, inputLen - offSet);
|
|
|
+ }
|
|
|
+ out.write(cache, 0, cache.length);
|
|
|
+ i++;
|
|
|
+ offSet = i * MAX_ENCRYPT_BLOCK;
|
|
|
+ }
|
|
|
+ byte[] encryptedData = out.toByteArray();
|
|
|
+ out.close();
|
|
|
+ // String outStr =
|
|
|
+ // Base64.encodeBase64String(cipher.doFinal(str.getBytes("UTF-8")));
|
|
|
+ String outStr = Base64.encodeBase64String(encryptedData);
|
|
|
+ return outStr;
|
|
|
+ }
|
|
|
+
|
|
|
+ public static String decryptPri(String str, String privateKey) throws Exception {
|
|
|
+ // 64位解码加密后的字符串
|
|
|
+ byte[] inputByte = Base64.decodeBase64(str.getBytes("UTF-8"));
|
|
|
+ // base64编码的私钥
|
|
|
+ byte[] decoded = Base64.decodeBase64(privateKey);
|
|
|
+ RSAPrivateKey priKey = (RSAPrivateKey) KeyFactory.getInstance("RSA")
|
|
|
+ .generatePrivate(new PKCS8EncodedKeySpec(decoded));
|
|
|
+ // RSA解密
|
|
|
+ Cipher cipher = Cipher.getInstance("RSA");
|
|
|
+ cipher.init(Cipher.DECRYPT_MODE, priKey);
|
|
|
+
|
|
|
+ int inputLen = inputByte.length;
|
|
|
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
|
|
|
+ int offSet = 0;
|
|
|
+ byte[] cache;
|
|
|
+ int i = 0;
|
|
|
+ // 对数据分段解密
|
|
|
+ while (inputLen - offSet > 0) {
|
|
|
+ if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
|
|
|
+ cache = cipher.doFinal(inputByte, offSet, MAX_DECRYPT_BLOCK);
|
|
|
+ } else {
|
|
|
+ cache = cipher.doFinal(inputByte, offSet, inputLen - offSet);
|
|
|
+ }
|
|
|
+ out.write(cache, 0, cache.length);
|
|
|
+ i++;
|
|
|
+ offSet = i * MAX_DECRYPT_BLOCK;
|
|
|
+ }
|
|
|
+ byte[] decryptedData = out.toByteArray();
|
|
|
+ out.close();
|
|
|
+ // String outStr = new String(cipher.doFinal(inputByte));
|
|
|
+ String outStr = new String(decryptedData);
|
|
|
+ return outStr;
|
|
|
+ }
|
|
|
+
|
|
|
+}
|
zouxuan