Java RSA 加密 解密 签名 验签

最新推荐文章于 2023-10-13 16:48:53 发布
最新推荐文章于 2023-10-13 16:48:53 发布
阅读量585 收藏 4
点赞数
分类专栏： Java 文章标签： java 加密 解密 签名 验签
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iteye_9461/article/details/82644738
版权
本文详细介绍了非对称加密的基本概念及其应用场景，并重点解析了RSA加密算法的工作原理及其实现过程。通过示例代码展示了如何生成RSA密钥对、进行数据加密解密以及数字签名验证。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

[b]1. 加密的作用[/b]

1）明文变密文（你不知道密钥是很难解密的）；
2）数据的一致性（hash值一样）；
3）数据的可信任性（验签）。

[b]2. 两种不同的加密与解密[/b]

[b]1）对称加密[/b]：加密与解密使用相同的密钥，处理速度快；
[b]2）非对称加密[/b]：加密与解密使用不同的密钥（生对生成），处理速度不及对称加密。

[b]3.在非对称加密中，究竟是公钥加密还是私钥加密的问题[/b]

[b]1）如果只是用加密的用途[/b]
公钥加密，私钥解密（私钥只有一个，公钥大家都知道）。
[b]2）如果用验签[/b]
私钥加密，公钥解密（解密的来源是私钥，其它的来源是不可信任的）。

下面是两个工具类。 

import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.Signature;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.crypto.Cipher;

public class RSAHelper {
	public static final String KEY_ALGORITHM = "RSA";
	private static final int KEY_LENGTH = 1024;
	public static final String PUBLIC_KEY = "PublicKey";
	public static final String PRIVATE_KEY = "PrivateKey";
	private static final int MAX_ENCRYPT_BLOCK = 117;
	private static final int MAX_DECRYPT_BLOCK = 128;
	private static final String SIGNATURE_ALGORITHM = "MD5withRSA";

	public RSAHelper() {
	}

	public static void generateKeyPair(Map<String, Object> keyMap) {
		boolean result = false;

		KeyPairGenerator keyPairGenerator = null;
		try {
			keyPairGenerator = KeyPairGenerator.getInstance("RSA");
			result = true;
		} catch (NoSuchAlgorithmException ex) {
			Logger.getLogger(RSAHelper.class.getName()).log(Level.SEVERE, null,
					ex);
		}

		if (result) {
			SecureRandom secureRandom = new SecureRandom();

			String currentDateTime = new SimpleDateFormat("yyyyMMddHHmmssSSS")
					.format(new Date());
			secureRandom.setSeed(currentDateTime.getBytes());

			keyPairGenerator.initialize(1024, secureRandom);

			KeyPair keyPair = keyPairGenerator.genKeyPair();

			PublicKey publicKey = keyPair.getPublic();
			PrivateKey privateKey = keyPair.getPrivate();

			keyMap.put("PublicKey", publicKey.getEncoded());
			keyMap.put("PrivateKey", privateKey.getEncoded());
		}
	}

	public static void saveKeyPair(Map<String, Object> keyPair,
			String publicKeyFileName, String privateKeyFileName) {
		try {
			FileOutputStream fileOutputStream = new FileOutputStream(
					publicKeyFileName);
			byte[] publicKey = (byte[]) keyPair.get("PublicKey");
			fileOutputStream.write(publicKey);
			fileOutputStream.close();
		} catch (FileNotFoundException ex) {
			Logger.getLogger(RSAHelper.class.getName()).log(Level.SEVERE, null,
					ex);
		} catch (IOException ex) {
			Logger.getLogger(RSAHelper.class.getName()).log(Level.SEVERE, null,
					ex);
		}

		try {
			FileOutputStream fileOutputStream = new FileOutputStream(
					privateKeyFileName);
			byte[] privateKey = (byte[]) keyPair.get("PrivateKey");
			fileOutputStream.write(privateKey);
			fileOutputStream.close();
		} catch (FileNotFoundException ex) {
			Logger.getLogger(RSAHelper.class.getName()).log(Level.SEVERE, null,
					ex);
		} catch (IOException ex) {
			Logger.getLogger(RSAHelper.class.getName()).log(Level.SEVERE, null,
					ex);
		}
	}

	public static byte[] getKey(String keyFileName) {
		byte[] keyBytes = null;
		try {
			File file = new File(keyFileName);
			FileInputStream fileInputStream = new FileInputStream(file);
			DataInputStream dataInputStream = new DataInputStream(
					fileInputStream);

			keyBytes = new byte[(int) file.length()];

			dataInputStream.readFully(keyBytes);

			dataInputStream.close();
			fileInputStream.close();
		} catch (FileNotFoundException ex) {
			Logger.getLogger(RSAHelper.class.getName()).log(Level.SEVERE, null,
					ex);
		} catch (IOException ex) {
			Logger.getLogger(RSAHelper.class.getName()).log(Level.SEVERE, null,
					ex);
		}

		return keyBytes;
	}

	public static byte[] encryptWithPublicKey(byte[] data, int offSet,
			int length, byte[] keyBytes) throws Exception {
		X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance("RSA");
		Key publicK = keyFactory.generatePublic(x509KeySpec);

		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(1, publicK);
		ByteArrayOutputStream out = new ByteArrayOutputStream();

		int i = 0;

		while (length - offSet > 0) {
			byte[] cache;
			if (length - offSet > 117) {
				cache = cipher.doFinal(data, offSet, 117);
			} else {
				cache = cipher.doFinal(data, offSet, length - offSet);
			}
			out.write(cache, 0, cache.length);
			i++;
			offSet = i * 117;
		}
		byte[] encryptedData = out.toByteArray();
		out.close();
		return encryptedData;
	}

	public static byte[] encryptWithPrivateKey(byte[] data, int offSet,
			int length, byte[] keyBytes) throws Exception {
		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance("RSA");
		Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(1, privateK);
		ByteArrayOutputStream out = new ByteArrayOutputStream();

		int i = 0;

		while (length - offSet > 0) {
			byte[] cache;
			if (length - offSet > 117) {
				cache = cipher.doFinal(data, offSet, 117);
			} else {
				cache = cipher.doFinal(data, offSet, length - offSet);
			}
			out.write(cache, 0, cache.length);
			i++;
			offSet = i * 117;
		}
		byte[] encryptedData = out.toByteArray();
		out.close();
		return encryptedData;
	}

	public static byte[] decryptWithPublicKey(byte[] data, int offSet,
			int length, byte[] keyBytes) throws Exception {
		X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance("RSA");
		Key publicK = keyFactory.generatePublic(x509KeySpec);
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(2, publicK);
		ByteArrayOutputStream out = new ByteArrayOutputStream();

		int i = 0;

		while (length - offSet > 0) {
			byte[] cache;
			if (length - offSet > 128) {
				cache = cipher.doFinal(data, offSet, 128);
			} else {
				cache = cipher.doFinal(data, offSet, length - offSet);
			}
			out.write(cache, 0, cache.length);
			i++;
			offSet = i * 128;
		}
		byte[] decryptedData = out.toByteArray();
		out.close();
		return decryptedData;
	}

	public static byte[] decryptWithPrivateKey(byte[] data, int offSet,
			int length, byte[] keyBytes) throws Exception {
		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance("RSA");
		Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(2, privateK);
		ByteArrayOutputStream out = new ByteArrayOutputStream();

		int i = 0;

		while (length - offSet > 0) {
			byte[] cache;
			if (length - offSet > 128) {
				cache = cipher.doFinal(data, offSet, 128);
			} else {
				cache = cipher.doFinal(data, offSet, length - offSet);
			}
			out.write(cache, 0, cache.length);
			i++;
			offSet = i * 128;
		}
		byte[] decryptedData = out.toByteArray();
		out.close();
		return decryptedData;
	}

	public static byte[] sign(byte[] data, int offset, int length,
			byte[] privateKeyBytes) {
		byte[] signedData = null;
		try {
			PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(
					privateKeyBytes);

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

			PrivateKey privateKey = keyFactory
					.generatePrivate(pkcs8EncodedKeySpec);

			Signature signature = Signature.getInstance("MD5withRSA");

			signature.initSign(privateKey);

			signature.update(data, offset, length);

			signedData = signature.sign();
		} catch (Exception ex) {
			Logger.getLogger(RSAHelper.class.getName()).log(Level.SEVERE, null,
					ex);
		}

		return signedData;
	}

	public static boolean verify(byte[] data, int offset, int length,
			byte[] publicKeyBytes, byte[] dataSignature) {
		boolean result = false;
		try {
			X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(
					publicKeyBytes);

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

			PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);

			Signature signature = Signature.getInstance("MD5withRSA");

			signature.initVerify(publicKey);

			signature.update(data, offset, length);

			result = signature.verify(dataSignature);
		} catch (Exception ex) {
			Logger.getLogger(RSAHelper.class.getName()).log(Level.SEVERE, null,
					ex);
		}

		return result;
	}
}



import com.adph.jms.Base64Utils;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.io.FileUtils;
import org.apache.commons.lang.StringUtils;

public class RSAKeyUtils {
	private static String RAS_PUBLICKEY_PATH = "D://security.key";
	private static String RSA_PRIVATEKEY_PATH= "D://security.crt";

	public RSAKeyUtils() {
	}

	protected static void init(String RAS_PUBLICKEY_PATH,
			String RSA_PRIVATEKEY_PATH) {
		try {
			FileUtils.forceMkdir(new File(new File(RAS_PUBLICKEY_PATH)
					.getParent()));
			Map<String, Object> keyPair = new HashMap();
			RSAHelper.generateKeyPair(keyPair);
			RSAHelper.saveKeyPair(keyPair, RAS_PUBLICKEY_PATH,
					RSA_PRIVATEKEY_PATH);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public static void setKeyPath(String keyPath) {
		RAS_PUBLICKEY_PATH = keyPath;
	}

	public static void setCrtPath(String crtPath) {
		RSA_PRIVATEKEY_PATH = crtPath;
	}

	public static String encByPublicKey(String data) {
		String dataBack = "";
		try {
			if (!StringUtils.isEmpty(data)) {
				byte[] Bytes = RSAHelper.encryptWithPublicKey(data.getBytes(),
						0, data.getBytes().length,
						RSAHelper.getKey(RAS_PUBLICKEY_PATH));
				dataBack = Base64Utils.encode(Bytes);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return dataBack;
	}

	public static String encByPrivateKey(String data) {
		String dataBack = "";
		try {
			if (!StringUtils.isEmpty(data)) {
				byte[] Bytes = RSAHelper.encryptWithPrivateKey(data.getBytes(),
						0, data.getBytes().length,
						RSAHelper.getKey(RSA_PRIVATEKEY_PATH));
				dataBack = Base64Utils.encode(Bytes);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return dataBack;
	}

	public static String decByPublicKey(String data) {
		String dataBack = "";
		try {
			if (!StringUtils.isEmpty(data)) {
				byte[] Bytes = RSAHelper.decryptWithPublicKey(
						Base64Utils.decode(data), 0,
						Base64Utils.decode(data).length,
						RSAHelper.getKey(RAS_PUBLICKEY_PATH));
				dataBack = new String(Bytes);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return dataBack;
	}

	public static String decByPrivateKey(String data) {
		String dataBack = "";
		try {
			if (!StringUtils.isEmpty(data)) {
				byte[] Bytes = RSAHelper.decryptWithPrivateKey(
						Base64Utils.decode(data), 0,
						Base64Utils.decode(data).length,
						RSAHelper.getKey(RSA_PRIVATEKEY_PATH));
				dataBack = new String(Bytes);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return dataBack;
	}

	public static String doSignPrivateKey(String data) {
		String dataBack = "";
		try {
			if (!StringUtils.isEmpty(data)) {
				byte[] Bytes = RSAHelper.sign(data.getBytes(), 0,
						data.getBytes().length,
						RSAHelper.getKey(RSA_PRIVATEKEY_PATH));
				dataBack = Base64Utils.encode(Bytes);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return dataBack;
	}

	public static boolean doVerifyPublicKey(String data, String sign) {
		Boolean returnFlag = Boolean.FALSE;
		if ((StringUtils.isEmpty(data)) || (StringUtils.isEmpty(sign))) {
			return Boolean.FALSE.booleanValue();
		}
		try {
			returnFlag = Boolean.valueOf(RSAHelper.verify(data.getBytes(), 0,
					data.getBytes().length,
					RSAHelper.getKey(RAS_PUBLICKEY_PATH),
					Base64Utils.decode(sign)));
		} catch (Exception e) {
			e.printStackTrace();
		}
		return returnFlag.booleanValue();
	}

//	public static void main(String[] args) {
//		init("D://security.key", "D://security.crt");
//	}
}


写一个例子测试下。[b]注意：先要运行上面main方法，使其生成security.key和security.crt。[/b] 


public class EncTest {
	public static void main(String[] args) throws Exception {
		String text = "Hello World";
		String enc = RSAKeyUtils.encByPublicKey(text);
		System.out.println("加密数据:" + enc);
		System.out.println("解密数据:" + RSAKeyUtils.decByPrivateKey(enc));
		String sign=RSAKeyUtils.doSignPrivateKey(text);
		System.out.println("签名:"+sign);
		System.out.println("验签结果:"+RSAKeyUtils.doVerifyPublicKey(text, sign));
	}
}
Java RSA 加解密及签名验证
guokm的博客
10-13 1906
RSA算法是目前非常常见的加密算法，他对应的加解密、签名验签的场景非常常见。因其特性对大字符串加解密效率较低，曾经想对较长字符串加解密，而因其解密过程为分段解密而捣鼓过；这里贴一下代码。
java RSA验签方法
java1703的博客
04-09 2481
package com.community.shop.util; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.security.*; import ja...
JAVA 使用RSA算法进行数字签名验证-附完整代码
qq_41831842的博客
08-21 6298
公司项目是有做资金管理相关的，涉及到充值，提现，转账等关键性的功能，需要保证数据传输的安全性，所以使用了较为简单的RSA进行生成秘钥且每个接口都需要做验签。RSA是一种非对称加密算法，它是由Rivest-Shamir-Adleman三位密码学家于1978年提出的。RSA算法的加密规则如下：钥匙生成：RSA算法使用两个密钥，一个是公钥（public key），用于加密数据，另一个是私钥（private key），用于解密数据。
【Java实现RSA的加密解密签名验签】
u013349377的博客
10-13 749
RSA（Rivest-Shamir-Adleman）是一种非对称加密算法，常用于加密和解密数据，数字签名和密钥交换。RSA算法的安全性基于两个关键的数学难题：大质数的素因子分解问题和指数对数问题。非对称加密： RSA是一种非对称加密算法，意味着它使用一对密钥，即公钥和私钥。公钥用于加密数据，私钥用于解密数据。这种非对称性使RSA非常适合数字通信的安全性，因为发送者只需知道接收者的公钥，而无需知道私钥。
C#与java平台RSA加密解密签名验签互通案例
04-23
本案例聚焦于"C#与Java平台RSA加密解密签名验签互通"的问题，这涉及到两个主要的技术点：RSA加密算法和跨平台兼容性。下面将详细阐述这两个知识点。 首先，RSA是一种非对称加密算法，由Ron Rivest、Adi Shamir和...
Android之RSA加密解密签名验签（亲测可用）
05-11
在Android开发中，数据安全是至关重要的，尤其是在...通过以上步骤，您可以在Android应用中实现RSA加密解密和签名验签功能，确保数据的安全传输和验证。记住，安全无小事，合理的加密策略是保障应用安全的重要一环。
C# 实现与JAVA互通 加签/验签，RSA加密/解密
05-07
* RSA加密解密：私钥解密，公钥加密。 * RSA数字签名-俗称加签验签：私钥加签，公钥验签。  * RSA加密解密：私钥解密，公钥加密。 * RSA数字签名-俗称加签验签：私钥加签，公钥验签。  * RSA加密解密：私钥...
RSA加密解密签名验签代码（sun、BC）
05-01
总的来说，该博客文章通过`RSAEncrypto.java`和`RSADecrypto.java`文件提供了使用Java进行RSA加密解密和签名验证的示例代码，涵盖了Sun JCE库和Bouncy Castle库的使用，这对于理解RSA加密机制和实践Java安全编程非常...
Java 实现RSA 签名/验签与加密解密
最新发布
01-02
6. 压缩包中的`signature`文件可能包含的是一个示例程序，演示了如何在Java中使用RSA进行签名、验签、加密和解密。这个程序可能会包括以下关键部分： - 导入必要的安全库 - 创建并初始化`KeyPairGenerator` - ...
RSA数字签名java实现
05-12
1、数字签名原理 用RSA算法做数字签名，总的来说，就是签名者用私钥参数d加密，也就是签名；验证者用签字者的公钥参数e解密来完成认证。 下面简要描述数字签名和认证的过程。 （1）、生成密钥 为用户随机生成一对密钥：公钥(e,n)和私钥(d,n). （2）、签名过程 a) 计算消息的散列值H(M). b) 用私钥(d,n)加密散列值：s=(H(M)) mod n，签名结果就是s. c) 发送消息和签名(M,s). （3）、认证过程 a) 取得发送方的公钥(e,n). b) 解密签名s:h=s mod n. c) 计算消息的散列值H(M). d) 比较，如果h=H(M),表示签名有效；否则，签名无效。 根据上面的过程，我们可以得到RSA数字签名的框图如图2-1： 图 2-1 RSA数字签名框图 2、 假设Alice想和Bob通信，以本地两个文件夹Alice和Bob模拟两个用户，实现消息M和签名的模拟分发 （1）、Alice通过RSA算法生成一对密钥：公钥(e,n)和私钥(d,n)，将公私钥分别存入pubKey.txt和priKey.txt中。 pubKey.txt中公钥如下： priKey.txt中私钥如下： （2）、将Alice中的pubKey.txt拷到Bob中，模拟公玥的分发。 （3）、将Alice中的消息info.txt做散列，将散列后的值存入hashInfo.txt中。 （4）、将Alice中的消息hashInfo.txt和签名sign.txt拷到Bob中，实现M密文状态下的签名与模拟分发、消息传递。 （5）Bob取得公钥pubKey.txt,用公钥解密签名，计算消息的散列值H(M).比较，如果h=H(M),表示签名有效；否则，签名无效。 后台运行结果如下：
java 使用RSA生成公私钥对、加解密、及签名验签
03-19
一个简单的java使用RSA生成公私钥对 非对称加密解密 签名验签的过程，附带一个基本的加密工具类，有兴趣的朋友可以下载下来看看
java RSA 加密签名工具包(开发)
09-22
java RSA加密工具包 相关说明：http://blog.csdn.net/joe_storm/article/details/11477297 工具包可以从某个路径下读取密钥并进行加密解密签名验签。密钥以UTF-8编码的字符串格式存储。密文经过sun 内部的Base64Encoder编码成为字符串后返回密文字符串。解密的时候先使用Base64Decoder先解码密文，然后再解密。 数字签名也是同样道理。 该工具在jre7以及以上的环境能够更好的运行。 使用范例： public class Demo { public static void main(String[] args) { String msg = "天气阴了,我犯困了"; RSAPrivateKey privateKey = RSAUtils.privateKey("F:\\RSAkeys\\pri"); RSAPublicKey publicKey = RSAUtils.publicKey("F:\\RSAkeys\\pub"); String signature = RSAUtils.signature(msg, privateKey); System.out.println("签名 = " + signature); String encript = RSAUtils.encript(publicKey, msg); System.out.println("密文 ： " + encript); if (RSAUtils.verify(msg, signature, publicKey)) { String decript = RSAUtils.decript(privateKey, encript); System.out.println("解密后的明文 ： " + decript); } } }
Java实现RSA加密解密签名校验
02-14
自己参考网上手写的代码，只能算是1.0版本吧，加密、解密、签名、校验都有，并附有部分备注。有的方法封装的不是特别好，等后几个版本再优化吧，这个版本比较适合刚刚接触，想自己实现的童鞋吧，一起学习。
java RSA 加签验签【转】
weixin_30577801的博客
04-20 1050
引用自:http://blog.csdn.net/wangqiuyun/article/details/42143957/ java RSA 加签验签 package com.testdemo.core.service.impl.alipay; import java.security.KeyFactory; import java.security.Private...
java基础-RSA签名验签
wwwzhouzy的专栏
08-13 4942
一、介绍 RSA加密是一种非对称加密。可以在不直接传递密钥的情况下，完成解密。这能够确保信息的安全性，避免了直接传递密钥所造成的被破解的风险。是由一对密钥来进行加解密的过程，分别称为公钥和私钥。两者之间有数学相关，该加密算法的原理就是对一极大整数做因数分解的困难性来保证安全性。通常个人保存私钥，公钥是公开的（可能同时多人持有）。 二、RSA加密、签名区别 　加密和签名都是为了安全性考虑，但略有不同。常有人问加密和签名是用私钥还是公钥？其实都是对加密和签名的作用有所混淆。简单的说，加密是为了防止信息被泄
java rsa 签名，验签
weixin_30530523的博客
03-30 118
package com.fabiao;import java.security.KeyFactory;import java.security.MessageDigest;import java.security.PrivateKey;import java.security.PublicKey;import java.security.spec.PKCS8EncodedKeySpec;impor...
java实现验签_Java 实现RSA签名验签
weixin_40003512的博客
03-08 588
1. 通过JDK提供的方法生成公私钥：import java.security.KeyPair;import java.security.KeyPairGenerator;KeyPairGenerator keyPair = KeyPairGenerator.getInstance("RSA");keyPair.initialize(len);KeyPair kp = keyPair.genera...
JAVA实现RSA签名、验签
Smilelfq的专栏
09-02 3482
生成签名的时候将需要传递的参数bean通过BaseHelper.sortParamAll(bean)转成K=V&K1=V1......的形式，然后调用Rsa.sign()方法即可生成签名。验签的时候获取到传递过来的参数json串（jsonParams），同样将业务参数通过BaseHelper.sortCheckParam(jsonParams)转成K=V&K1=V1......的形式（剔除sign参数），然后调用Rsa.doCheck()方法验证签名是否通过。2、使用私钥进行签名。3、使用公钥验证签名。
RSA加密解密签名验签代码实现及分析
RSA加密解密签名验签是信息安全领域的核心内容之一。RSA算法由Rivest、Shamir和Adleman三位科学家在1977年提出，是一种广泛使用的非对称加密算法。非对称加密算法相较于对称加密算法有其独特的优势，即使用一对密钥...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值