RSA 签名 / 验签工具

依赖 jar 包下载

zmxysdkjava20170605134301.jar
zmxysdkjava20170605134301source.jar

代码如下


   import com.antgroup.zmxy.openplatform.api.ZhimaApiException;
   import com.antgroup.zmxy.openplatform.api.internal.util.Base64Util;
   import com.antgroup.zmxy.openplatform.api.internal.util.CoderUtil;
   import com.antgroup.zmxy.openplatform.api.internal.util.EncryptionModeEnum;
   import com.antgroup.zmxy.openplatform.api.internal.util.SignTypeEnum;
   import com.antgroup.zmxy.openplatform.api.internal.util.json.ExceptionErrorListener;
   import com.antgroup.zmxy.openplatform.api.internal.util.json.JSONValidatingReader;
	import java.io.ByteArrayOutputStream;
	import java.security.Key;
	import java.security.KeyFactory;
	import java.security.PrivateKey;
	import java.security.PublicKey;
	import java.security.Signature;
	import java.security.spec.PKCS8EncodedKeySpec;
	import java.security.spec.RSAPrivateKeySpec;
	import java.security.spec.RSAPublicKeySpec;
	import java.security.spec.X509EncodedKeySpec;
	import java.util.Iterator;
	import java.util.Map;
	import javax.crypto.Cipher;

   import org.apache.log4j.Logger;

	public class PKRSACoderUtil extends CoderUtil{
    
  	protected static Logger log = Logger.getLogger(PKRSACoderUtil.class);
  
  	public static final String KEY_ALGORTHM = "RSA";
  	public static final String SPECIFIC_KEY_ALGORITHM = "RSA/ECB/PKCS1Padding";
  	public static final String SIGNATURE_ALGORITHM = "SHA256WITHRSA";
  	public static String encrypt(String paramsString, String charset, String publicKey)
    throws Exception
  	{
    	byte[] encryptedResult = encryptByPublicKey(paramsString.getBytes(charset), publicKey, null);
    	return Base64Util.byteArrayToBase64(encryptedResult);
  	}
 	public static String encrypt(String paramsString, String charset, String publicKey, EncryptionModeEnum encryptionType)
    throws Exception
  	{
    	byte[] encryptedResult = encryptByPublicKey(paramsString.getBytes(charset), publicKey, encryptionType);


    	return Base64Util.byteArrayToBase64(encryptedResult);
  	}


  	public static String sign(String data, String charset, String privateKey)
    throws Exception
  	{
    	byte[] dataInBytes = data.getBytes(charset);
   	 String signParams = sign(dataInBytes, privateKey);
   	 return signParams;
  	}



  	public static String sign(SignTypeEnum signType, String data, String charset, String privateKey)
    throws Exception
  	{
   	 byte[] dataInBytes = data.getBytes(charset);
   	 String signParams = sign(signType, dataInBytes, privateKey);
   	 return signParams;
  	}

  	public static String decrypt(String data, String key, String charset)
    throws Exception
  	{
    	byte[] byte64 = Base64Util.base64ToByteArray(data);
    	byte[] encryptedBytes = decryptByPrivateKey(byte64, key, null);
   	 return new String(encryptedBytes, charset);
  	}


 	 public static String decrypt(String data, String key, String charset, EncryptionModeEnum encryptionType)
    throws Exception
  	{
   	 byte[] byte64 = Base64Util.base64ToByteArray(data);
   	 byte[] encryptedBytes = decryptByPrivateKey(byte64, key, encryptionType);
   	 return new String(encryptedBytes, charset);
 	 }


 	 public static byte[] decryptByPrivateKey(byte[] data, String key, EncryptionModeEnum encryptionType)
    throws Exception
 	 {
   	 byte[] decryptedData = null;


    	byte[] keyBytes = decryptBASE64(key);

    	PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(keyBytes);
    	KeyFactory keyFactory = KeyFactory.getInstance("RSA");
    	Key privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);

   	 Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
    cipher.init(2, privateKey);

    	int maxDecryptBlockSize;
    	if (encryptionType != null)
     	 maxDecryptBlockSize = getMaxDecryptBlockSizeByEncryptionType(encryptionType);
    	else {
     	 maxDecryptBlockSize = getMaxDecryptBlockSize(keyFactory, privateKey);
    	}

    	ByteArrayOutputStream bout = new ByteArrayOutputStream();
   	 try {
    	  int dataLength = data.length;
    	  for (int i = 0; i < dataLength; i += maxDecryptBlockSize) {
       	 int decryptLength = (dataLength - i < maxDecryptBlockSize) ? dataLength - i : maxDecryptBlockSize;

       	 byte[] doFinal = cipher.doFinal(data, i, decryptLength);
        	bout.write(doFinal);
     	 }
     	 decryptedData = bout.toByteArray();
   	 } finally {
     	 if (bout != null) {
      	  bout.close();
     	 }
   	 }

    	return decryptedData;
  	}


  	public static byte[] encryptByPublicKey(byte[] data, String key, EncryptionModeEnum encryptionType)
    throws Exception
 	 {
    	byte[] encryptedData = null;


    	byte[] keyBytes = decryptBASE64(key);

    	X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(keyBytes);
    	KeyFactory keyFactory = KeyFactory.getInstance("RSA");
    	Key publicKey = keyFactory.generatePublic(x509EncodedKeySpec);


   	 Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
    	cipher.init(1, publicKey);

   	 int maxEncryptBlockSize;
    	if (encryptionType != null)
     	 maxEncryptBlockSize = getMaxEncryptBlockSizeByEncryptionType(encryptionType);
    	else {
     	 maxEncryptBlockSize = getMaxEncryptBlockSize(keyFactory, publicKey);
   	 }

    	ByteArrayOutputStream bout = new ByteArrayOutputStream();
    	try {
     	 int dataLength = data.length;
      	for (int i = 0; i < data.length; i += maxEncryptBlockSize) {
        	int encryptLength = (dataLength - i < maxEncryptBlockSize) ? dataLength - i : maxEncryptBlockSize;

        	byte[] doFinal = cipher.doFinal(data, i, encryptLength);
        	bout.write(doFinal);
     	 }
      	encryptedData = bout.toByteArray();
   	 } finally {
     	 if (bout != null) {
       	 bout.close();
      	}
   	 }
    	return encryptedData;
 	 }

  	public static String sign(byte[] data, String privateKey)
    throws Exception
 	 {
   	 return sign(SignTypeEnum.SHA1WITHRSA, data, privateKey);
 	 }


 	 public static String sign(SignTypeEnum signType, byte[] data, String privateKey)
    throws Exception
  	{
   	 byte[] keyBytes = decryptBASE64(privateKey);

    	PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(keyBytes);

    	KeyFactory keyFactory = KeyFactory.getInstance("RSA");

    	PrivateKey privateKey2 = keyFactory.generatePrivate(pkcs8EncodedKeySpec);


    	Signature signature = Signature.getInstance(signType.getDesc());
    	signature.initSign(privateKey2);
    	signature.update(data);

   	 return encryptBASE64(signature.sign());
 	 }


  public static boolean verify(byte[] data, String publicKey, String sign)
    throws Exception
  {
    return verify(SignTypeEnum.SHA1WITHRSA, data, publicKey, sign);
  }



  public static boolean verify(SignTypeEnum signType, byte[] data, String publicKey, String sign)
    throws Exception
  {
    byte[] keyBytes = decryptBASE64(publicKey);

    X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(keyBytes);

    KeyFactory keyFactory = KeyFactory.getInstance("RSA");

    PublicKey publicKey2 = keyFactory.generatePublic(x509EncodedKeySpec);

    Signature signature = Signature.getInstance(signType.getDesc());
    signature.initVerify(publicKey2);
    signature.update(data);
    return signature.verify(decryptBASE64(sign));
  }



  public static String decryptResponse(String fullResponse, String privateKey, String charset, EncryptionModeEnum encryptionType)
    throws Exception
  {
    String decryptedRsp = null;
    Map rootJson = parseResponseMap(fullResponse);
    for (Iterator it = rootJson.keySet().iterator(); it.hasNext(); ) {
      String key = (String)it.next();
      if (key.endsWith("_response")) {
        String value = (String)rootJson.get(key);
        decryptedRsp = value;
      }
    }

    if (((Boolean)rootJson.get("encrypted")).booleanValue()) {
      decryptedRsp = decrypt(decryptedRsp, privateKey, charset, encryptionType);
    }
    return decryptedRsp;
  }



  public static void verifySign(String fullResponse, String decryptedBizResponse, String publicKey, String charset)
    throws Exception
  {
    verifySign(SignTypeEnum.SHA1WITHRSA, fullResponse, decryptedBizResponse, publicKey, charset);
  }



  public static void verifySign(SignTypeEnum signType, String fullResponse, String decryptedBizResponse, String publicKey, String charset)
    throws Exception
  {
    Map rootJson = parseResponseMap(fullResponse);
    String sign = (String)rootJson.get("biz_response_sign");

    if ((sign != null) && (sign.length() > 0)) {
      boolean success = verify(signType, decryptedBizResponse.getBytes(charset), publicKey, sign);

      if (!(success))
        throw new ZhimaApiException("验签失败: " + sign.toString());
    }
  }

  public static Map parseResponseMap(String fullResponse)
    throws ZhimaApiException
  {
    JSONValidatingReader reader = new JSONValidatingReader(new ExceptionErrorListener());
    Object rootObj = reader.read(fullResponse);
    if (rootObj instanceof Map) {
      Map rootJson = (Map)rootObj;
      return rootJson;
    }

    throw new ZhimaApiException("返回结果格式有误:" + fullResponse);
  }








  private static int getMaxEncryptBlockSize(KeyFactory keyFactory, Key key)
    throws Exception
  {
    int maxLength = 117;
    try {
      RSAPublicKeySpec publicKeySpec = (RSAPublicKeySpec)keyFactory.getKeySpec(key, RSAPublicKeySpec.class);
      int keyLength = publicKeySpec.getModulus().bitLength();
      maxLength = keyLength / 8 - 11;
    }
    catch (Exception e) {
    }
    return maxLength;
  }






  private static int getMaxEncryptBlockSizeByEncryptionType(EncryptionModeEnum encryptionType)
  {
    if (encryptionType == EncryptionModeEnum.RSA1024)
      return 117;
    if (encryptionType == EncryptionModeEnum.RSA2048) {
      return 245;
    }

    return 117;
  }








  private static int getMaxDecryptBlockSize(KeyFactory keyFactory, Key key)
    throws Exception
  {
    int maxLength = 128;
    try {
      RSAPrivateKeySpec publicKeySpec = (RSAPrivateKeySpec)keyFactory.getKeySpec(key, RSAPrivateKeySpec.class);
      int keyLength = publicKeySpec.getModulus().bitLength();
      maxLength = keyLength / 8;
    }
    catch (Exception e) {
    }
    return maxLength;
  }






  private static int getMaxDecryptBlockSizeByEncryptionType(EncryptionModeEnum encryptionType)
  {
    if (encryptionType == EncryptionModeEnum.RSA1024)
      return 128;
    if (encryptionType == EncryptionModeEnum.RSA2048) {
      return 256;
    }

    return 128;
  }
}

验签代码


/**

 * 验证签名
 * @return
 * @throws Exception 
 */
public static boolean checksign(JSONObject jsonObject,String platpublickey) throws Exception{
	//获取签名
	String sign = jsonObject.getString("sign");
	//json对象转换成map
	Map<String,Object> bizParams = getTextParams(jsonObject);
	String content = unurlgetSignCheckContentV2(bizParams).trim().replace("\\/", "/");
	return PKRSACoderUtil.verify(SignTypeEnum.SHA256WITHRSA, content.getBytes(SysUtil.CHARSET),platpublickey, sign);
}

签名代码


/**
 * 生成签名
 * 
 * 
 * @return
 * 
 */
public static String producesignByJson(JSONObject jsonObject ,String zzrsprivatekey){
	String signstr="";
	try{
			String content = unurlgetSignCheckContentV2(getTextParams(jsonObject)).trim();
			signstr = PKRSACoderUtil.sign(SignTypeEnum.SHA256WITHRSA, content, SysUtil.CHARSET, zzrsprivatekey);
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (Exception e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	return signstr;
}

Java RSA 密钥对生成，加密与解密

[图片] RSA 密钥对最近做的项目有要求对传输的数据进行加密和解密，所以就用到了 RSA 非对称加密，所以在这里记录一下。首先介绍下什么是 RSA 加密算法吧(复制的) RSA 加密算法是一种非对称加密算法。在公开密钥加密和电子商业中 RSA 被广泛使用。RSA 是 1977 年由罗纳德·李维斯特（Ron Riv ..

密码：参考 TLS 握手协议实现移动支付密码的一次一密加解密方案

[图片] 本文阐述了一种参考 TLS 握手协议实现的移动端 APP 支付密码一次一密加解密方案。具体内容为五个部分组成，即 TLS 协议简单介绍及握手协议的流程说明，支付密码一次一密加解密流程说明，涉及的加密算法，实施过程，示例代码及测试结果等。什么 TLS 协议？ TLS 协议的主要目标是在两个通信应用程序之间提供 ..

JS 公钥可以解密私钥生成的串吗？

RT，服务端使用 RSA 算法通过私钥加密的数据，JS 可以使用公钥解密吗？这个库没有支持 JS 端公钥解密。[链接][链接] 这个库[链接][链接] 作者说的意思应该是可以实现，但是我没能理解。 @88250 @Vanessa ，麻烦 2 位和各位分享下有哪个库可以支持 JS 公钥解密的吗？或者第二库要怎么实现，一 ..

黎曼猜想 - 素数 -RSA- 非对称加密 -https- 通信安全 - 比特币 & 区块链 - 概率

#一句话总结：素数出现的频率与黎曼 ζ 函数紧密相关，随机选择一个自然数 x，那么 P(x)，即该数字为素数的概率约为 1/ln(x)，貌似对 RSA 非对称加密没有破坏性影响，要解密还是需要暴力破解黎曼猜想 https://zhuanlan.zhihu.com/p/25055731 https://zhuanla ..

RSA 算法原理

讲的最好的文章 RSA 算法原理 (http://)http://www.ruanyifeng.com/blog/2013/06/rsa_algorithm_part_one.html [链接] 简单来说 RSA 加密的前提是：大整数的因数分解，是一件非常困难的事情。目前，除了暴力破解，还没有发现别的有效方法。维基百 ..

RSA 加密与加签

rsa有两个非常重要的作用：加密和加签 1. 加密时用公钥加密，私钥解密。 2. 加签时用私钥加签，公钥验证签名。理解： 1. 私钥用来进行解密和签名，是给自己用的。 2. 公钥由本人公开，用于加密和验证签名，是给别人用的。 3. 当该用户发送文件时，用私钥签名，别人用他给的公钥验证签名，可以保证该信息是由他发送的。 ..

欢迎来到这里！

我们正在构建一个小众社区，大家在这里相互信任，以平等 • 自由 • 奔放的价值观进行分享交流。最终，希望大家能够找到与自己志同道合的伙伴，共同成长。

关于

RSA 签名 / 验签工具

相关帖子

Java RSA 密钥对生成，加密与解密

密码：参考 TLS 握手协议实现移动支付密码的一次一密加解密方案

JS 公钥可以解密私钥生成的串吗？

黎曼猜想 - 素数 -RSA- 非对称加密 -https- 通信安全 - 比特币 & 区块链 - 概率

科普黎曼猜想 - 素数 -RSA 非对称加密 -https- 安全通信 - 比特币 & 区块链的关系

RSA 算法原理

RSA 加密与加签

欢迎来到这里！

近期热议

推荐标签标签

最新标签

RSA 签名 / 验签工具

相关帖子

Java RSA 密钥对生成，加密与解密

密码：参考 TLS 握手协议实现移动支付密码的一次一密加解密方案

JS 公钥可以解密私钥生成的串吗？

黎曼猜想 - 素数 -RSA- 非对称加密 -https- 通信安全 - 比特币 & 区块链 - 概率

科普黎曼猜想 - 素数 -RSA 非对称加密 -https- 安全通信 - 比特币 & 区块链的关系

RSA 算法原理

RSA 加密与加签

欢迎来到这里！

近期热议

推荐标签 标签

最新标签

推荐标签标签