Java使用RSA加密解密签名及校验

于 2024-08-26 23:31:19 发布
阅读量730 收藏 12
点赞数 19
文章标签： java python 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_85957993/article/details/141576053
版权

import java.security.InvalidKeyException;

import java.security.KeyFactory;

import java.security.KeyPair;

import java.security.KeyPairGenerator;

import java.security.NoSuchAlgorithmException;

import java.security.SecureRandom;

import java.security.interfaces.RSAPrivateKey;

import java.security.interfaces.RSAPublicKey;

import java.security.spec.InvalidKeySpecException;

import java.security.spec.PKCS8EncodedKeySpec;

import java.security.spec.X509EncodedKeySpec;

import javax.crypto.BadPaddingException;

import javax.crypto.Cipher;

import javax.crypto.IllegalBlockSizeException;

import javax.crypto.NoSuchPaddingException;

import com.fcplay.Base64;

public class RSAEncrypt {

/**

  • 字节数据转字符串专用集合

*/

private static final char[] HEX_CHAR = { ‘0’, ‘1’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’,

‘7’, ‘8’, ‘9’, ‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’ };

/**

  • 随机生成密钥对

*/

public static void genKeyPair(String filePath) {

// KeyPairGenerator类用于生成公钥和私钥对，基于RSA算法生成对象

KeyPairGenerator keyPairGen = null;

try {

keyPairGen = KeyPairGenerator.getInstance(“RSA”);

} catch (NoSuchAlgorithmException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

// 初始化密钥对生成器，密钥大小为96-1024位

keyPairGen.initialize(1024,new SecureRandom());

// 生成一个密钥对，保存在keyPair中

KeyPair keyPair = keyPairGen.generateKeyPair();

// 得到私钥

RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();

// 得到公钥

RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();

try {

// 得到公钥字符串

String publicKeyString = Base64.encode(publicKey.getEncoded());

// 得到私钥字符串

String privateKeyString = Base64.encode(privateKey.getEncoded());

// 将密钥对写入到文件

FileWriter pubfw = new FileWriter(filePath + “/publicKey.keystore”);

FileWriter prifw = new FileWriter(filePath + “/privateKey.keystore”);

BufferedWriter pubbw = new BufferedWriter(pubfw);

BufferedWriter pribw = new BufferedWriter(prifw);

pubbw.write(publicKeyString);

pribw.write(privateKeyString);

pubbw.flush();

pubbw.close();

pubfw.close();

pribw.flush();

pribw.close();

prifw.close();

} catch (Exception e) {

e.printStackTrace();

}

}

/**

  • 从文件中输入流中加载公钥

  • @param in

  •        公钥输入流

  • @throws Exception

  •         加载公钥时产生的异常

*/

public static String loadPublicKeyByFile(String path) throws Exception {

try {

BufferedReader br = new BufferedReader(new FileReader(path

  • “/publicKey.keystore”));

String readLine = null;

StringBuilder sb = new StringBuilder();

while ((readLine = br.readLine()) != null) {

sb.append(readLine);

}

br.close();

return sb.toString();

} catch (IOException e) {

throw new Exception(“公钥数据流读取错误”);

} catch (NullPointerException e) {

throw new Exception(“公钥输入流为空”);

}

}

/**

  • 从字符串中加载公钥

  • @param publicKeyStr

  •        公钥数据字符串

  • @throws Exception

  •         加载公钥时产生的异常

*/

public static RSAPublicKey loadPublicKeyByStr(String publicKeyStr)

throws Exception {

try {

byte[] buffer = Base64.decode(publicKeyStr);

KeyFactory keyFactory = KeyFactory.getInstance(“RSA”);

X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);

return (RSAPublicKey) keyFactory.generatePublic(keySpec);

} catch (NoSuchAlgorithmException e) {

throw new Exception(“无此算法”);

} catch (InvalidKeySpecException e) {

throw new Exception(“公钥非法”);

} catch (NullPointerException e) {

throw new Exception(“公钥数据为空”);

}

}

/**

  • 从文件中加载私钥

  • @param keyFileName

  •        私钥文件名

  • @return 是否成功

  • @throws Exception

*/

public static String loadPrivateKeyByFile(String path) throws Exception {

try {

BufferedReader br = new BufferedReader(new FileReader(path

  • “/privateKey.keystore”));

String readLine = null;

StringBuilder sb = new StringBuilder();

while ((readLine = br.readLine()) != null) {

sb.append(readLine);

}

br.close();

return sb.toString();

} catch (IOException e) {

throw new Exception(“私钥数据读取错误”);

} catch (NullPointerException e) {

throw new Exception(“私钥输入流为空”);

}

}

public static RSAPrivateKey loadPrivateKeyByStr(String privateKeyStr)

throws Exception {

try {

byte[] buffer = Base64.decode(privateKeyStr);

PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer);

KeyFactory keyFactory = KeyFactory.getInstance(“RSA”);

return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);

} catch (NoSuchAlgorithmException e) {

throw new Exception(“无此算法”);

} catch (InvalidKeySpecException e) {

throw new Exception(“私钥非法”);

} catch (NullPointerException e) {

throw new Exception(“私钥数据为空”);

}

}

/**

  • 公钥加密过程

  • @param publicKey

  •        公钥

  • @param plainTextData

  •        明文数据

  • @return

  • @throws Exception

  •         加密过程中的异常信息

*/

public static byte[] encrypt(RSAPublicKey publicKey, byte[] plainTextData)

throws Exception {

if (publicKey == null) {

throw new Exception(“加密公钥为空, 请设置”);

}

Cipher cipher = null;

try {

// 使用默认RSA

cipher = Cipher.getInstance(“RSA”);

// cipher= Cipher.getInstance(“RSA”, new BouncyCastleProvider());

cipher.init(Cipher.ENCRYPT_MODE, publicKey);

byte[] output = cipher.doFinal(plainTextData);

return output;

} catch (NoSuchAlgorithmException e) {

throw new Exception(“无此加密算法”);

} catch (NoSuchPaddingException e) {

e.printStackTrace();

return null;

} catch (InvalidKeyException e) {

throw new Exception(“加密公钥非法,请检查”);

} catch (IllegalBlockSizeException e) {

throw new Exception(“明文长度非法”);

} catch (BadPaddingException e) {

throw new Exception(“明文数据已损坏”);

}

}

/**

  • 私钥加密过程

  • @param privateKey

  •        私钥

  • @param plainTextData

  •        明文数据

  • @return

  • @throws Exception

  •         加密过程中的异常信息

*/

public static byte[] encrypt(RSAPrivateKey privateKey, byte[] plainTextData)

throws Exception {

if (privateKey == null) {

throw new Exception(“加密私钥为空, 请设置”);

}

Cipher cipher = null;

try {

// 使用默认RSA

cipher = Cipher.getInstance(“RSA”);

cipher.init(Cipher.ENCRYPT_MODE, privateKey);

byte[] output = cipher.doFinal(plainTextData);

return output;

} catch (NoSuchAlgorithmException e) {

throw new Exception(“无此加密算法”);

} catch (NoSuchPaddingException e) {

e.printStackTrace();

return null;

} catch (InvalidKeyException e) {

throw new Exception(“加密私钥非法,请检查”);

} catch (IllegalBlockSizeException e) {

throw new Exception(“明文长度非法”);

} catch (BadPaddingException e) {

throw new Exception(“明文数据已损坏”);

}

}

/**

  • 私钥解密过程

  • @param privateKey

  •        私钥

  • @param cipherData

  •        密文数据

  • @return 明文

  • @throws Exception

  •         解密过程中的异常信息

*/

public static byte[] decrypt(RSAPrivateKey privateKey, byte[] cipherData)

throws Exception {

if (privateKey == null) {

throw new Exception(“解密私钥为空, 请设置”);

}

Cipher cipher = null;

try {

// 使用默认RSA

cipher = Cipher.getInstance(“RSA”);

// cipher= Cipher.getInstance(“RSA”, new BouncyCastleProvider());

cipher.init(Cipher.DECRYPT_MODE, privateKey);

byte[] output = cipher.doFinal(cipherData);

return output;

} catch (NoSuchAlgorithmException e) {

throw new Exception(“无此解密算法”);

} catch (NoSuchPaddingException e) {

e.printStackTrace();

return null;

} catch (InvalidKeyException e) {

throw new Exception(“解密私钥非法,请检查”);

} catch (IllegalBlockSizeException e) {

throw new Exception(“密文长度非法”);

} catch (BadPaddingException e) {

throw new Exception(“密文数据已损坏”);

}

}

/**

  • 公钥解密过程

  • @param publicKey

  •        公钥

  • @param cipherData

  •        密文数据

  • @return 明文

  • @throws Exception

  •         解密过程中的异常信息

*/

public static byte[] decrypt(RSAPublicKey publicKey, byte[] cipherData)

throws Exception {

if (publicKey == null) {

throw new Exception(“解密公钥为空, 请设置”);

}

Cipher cipher = null;

try {

// 使用默认RSA

cipher = Cipher.getInstance(“RSA”);

// cipher= Cipher.getInstance(“RSA”, new BouncyCastleProvider());

cipher.init(Cipher.DECRYPT_MODE, publicKey);

byte[] output = cipher.doFinal(cipherData);

return output;

} catch (NoSuchAlgorithmException e) {

throw new Exception(“无此解密算法”);

} catch (NoSuchPaddingException e) {

e.printStackTrace();

return null;

} catch (InvalidKeyException e) {

throw new Exception(“解密公钥非法,请检查”);

} catch (IllegalBlockSizeException e) {

throw new Exception(“密文长度非法”);

} catch (BadPaddingException e) {

throw new Exception(“密文数据已损坏”);

}

}

/**

  • 字节数据转十六进制字符串

  • @param data

  •        输入数据

  • @return 十六进制内容

*/

public static String byteArrayToString(byte[] data) {

StringBuilder stringBuilder = new StringBuilder();

for (int i = 0; i < data.length; i++) {

// 取出字节的高四位 作为索引得到相应的十六进制标识符 注意无符号右移

stringBuilder.append(HEX_CHAR[(data[i] & 0xf0) >>> 4]);

// 取出字节的低四位 作为索引得到相应的十六进制标识符

stringBuilder.append(HEX_CHAR[(data[i] & 0x0f)]);

if (i < data.length - 1) {

stringBuilder.append(’ ');

}

}

return stringBuilder.toString();

}

}

签名及校验类：

package com.ihep;

import java.security.KeyFactory;

import java.security.PrivateKey;

import java.security.PublicKey;

import java.security.spec.PKCS8EncodedKeySpec;

import java.security.spec.X509EncodedKeySpec;

/**

  • RSA签名验签类

*/

public class RSASignature{

/**

  • 签名算法

*/

public static final String SIGN_ALGORITHMS = “SHA1WithRSA”;

/**

  • RSA签名

  • @param content 待签名数据

  • @param privateKey 商户私钥

  • @param encode 字符集编码

  • @return 签名值

*/

public static String sign(String content, String privateKey, String encode)

{

try

{

PKCS8EncodedKeySpec priPKCS8 = new PKCS8EncodedKeySpec( Base64.decode(privateKey) );

KeyFactory keyf = KeyFactory.getInstance(“RSA”);

PrivateKey priKey = keyf.generatePrivate(priPKCS8);

java.security.Signature signature = java.security.Signature.getInstance(SIGN_ALGORITHMS);

signature.initSign(priKey);

signature.update( content.getBytes(encode));

byte[] signed = signature.sign();

return Base64.encode(signed);

}

catch (Exception e)

{

e.printStackTrace();

}

return null;

}

public static String sign(String content, String privateKey)

{

try

{

PKCS8EncodedKeySpec priPKCS8 = new PKCS8EncodedKeySpec( Base64.decode(privateKey) );

KeyFactory keyf = KeyFactory.getInstance(“RSA”);

PrivateKey priKey = keyf.generatePrivate(priPKCS8);

java.security.Signature signature = java.security.Signature.getInstance(SIGN_ALGORITHMS);

signature.initSign(priKey);

signature.update( content.getBytes());

byte[] signed = signature.sign();

return Base64.encode(signed);

}

catch (Exception e)

{

e.printStackTrace();

}

return null;

}

/**

  • RSA验签名检查

  • @param content 待签名数据

  • @param sign 签名值

  • @param publicKey 分配给开发商公钥

  • @param encode 字符集编码

  • @return 布尔值

*/

public static boolean doCheck(String content, String sign, String publicKey,String encode)

{

try

{

KeyFactory keyFactory = KeyFactory.getInstance(“RSA”);

byte[] encodedKey = Base64.decode(publicKey);

PublicKey pubKey = keyFactory.generatePublic(new X509EncodedKeySpec(encodedKey));

java.security.Signature signature = java.security.Signature

.getInstance(SIGN_ALGORITHMS);

signature.initVerify(pubKey);

signature.update( content.getBytes(encode) );

boolean bverify = signature.verify( Base64.decode(sign) );

return bverify;

}

catch (Exception e)

{

e.printStackTrace();

}

return false;

}

public static boolean doCheck(String content, String sign, String publicKey)

{

try

{

KeyFactory keyFactory = KeyFactory.getInstance(“RSA”);

byte[] encodedKey = Base64.decode(publicKey);

PublicKey pubKey = keyFactory.generatePublic(new X509EncodedKeySpec(encodedKey));

java.security.Signature signature = java.security.Signature

.getInstance(SIGN_ALGORITHMS);

signature.initVerify(pubKey);

signature.update( content.getBytes() );

boolean bverify = signature.verify( Base64.decode(sign) );

return bverify;

}

catch (Exception e)

{

e.printStackTrace();

}

return false;

}

}

再来一个Base64的类，当然你也可以用commons-codec-1.9.jar

package com.ihep;

public final class Base64 {

static private final int BASELENGTH = 128;

static private final int LOOKUPLENGTH = 64;

static private final int TWENTYFOURBITGROUP = 24;

static private final int EIGHTBIT = 8;

static private final int SIXTEENBIT = 16;

static private final int FOURBYTE = 4;

static private final int SIGN = -128;

static private final char PAD = ‘=’;

static private final boolean fDebug = false;

static final private byte[] base64Alphabet = new byte[BASELENGTH];

static final private char[] lookUpBase64Alphabet = new char[LOOKUPLENGTH];

static {

for (int i = 0; i < BASELENGTH; ++i) {

base64Alphabet[i] = -1;

}

for (int i = ‘Z’; i >= ‘A’; i–) {

base64Alphabet[i] = (byte) (i - ‘A’);

}

for (int i = ‘z’; i >= ‘a’; i–) {

base64Alphabet[i] = (byte) (i - ‘a’ + 26);

}

for (int i = ‘9’; i >= ‘0’; i–) {

base64Alphabet[i] = (byte) (i - ‘0’ + 52);

}

base64Alphabet[‘+’] = 62;

base64Alphabet[‘/’] = 63;

for (int i = 0; i <= 25; i++) {

lookUpBase64Alphabet[i] = (char) (‘A’ + i);

}

for (int i = 26, j = 0; i <= 51; i++, j++) {

lookUpBase64Alphabet[i] = (char) (‘a’ + j);

}

for (int i = 52, j = 0; i <= 61; i++, j++) {

lookUpBase64Alphabet[i] = (char) (‘0’ + j);

}

lookUpBase64Alphabet[62] = (char) ‘+’;

lookUpBase64Alphabet[63] = (char) ‘/’;

}

private static boolean isWhiteSpace(char octect) {

return (octect == 0x20 || octect == 0xd || octect == 0xa || octect == 0x9);

}

private static boolean isPad(char octect) {

return (octect == PAD);

}

private static boolean isData(char octect) {

return (octect < BASELENGTH && base64Alphabet[octect] != -1);

}

/**

  • Encodes hex octects into Base64

  • @param binaryData Array containing binaryData

  • @return Encoded Base64 array

*/

public static String encode(byte[] binaryData) {

if (binaryData == null) {

return null;

}

int lengthDataBits = binaryData.length * EIGHTBIT;

if (lengthDataBits == 0) {

return “”;

}

int fewerThan24bits = lengthDataBits % TWENTYFOURBITGROUP;

int numberTriplets = lengthDataBits / TWENTYFOURBITGROUP;

int numberQuartet = fewerThan24bits != 0 ? numberTriplets + 1 : numberTriplets;

char encodedData[] = null;

encodedData = new char[numberQuartet * 4];

byte k = 0, l = 0, b1 = 0, b2 = 0, b3 = 0;

int encodedIndex = 0;

int dataIndex = 0;

if (fDebug) {

System.out.println("number of triplets = " + numberTriplets);

}

for (int i = 0; i < numberTriplets; i++) {

b1 = binaryData[dataIndex++];

b2 = binaryData[dataIndex++];

b3 = binaryData[dataIndex++];

更多：Java进阶核心知识集

包含：JVM，JAVA集合，网络，JAVA多线程并发，JAVA基础，Spring原理，微服务，Zookeeper，Kafka，RabbitMQ，Hbase，MongoDB，Cassandra，设计模式，负载均衡，数据库，一致性哈希，JAVA算法，数据结构，加密算法，分布式缓存等等

image

高效学习视频

相关阅读docs.qq.com/doc/DSmxTbFJ1cmN1R2dB
aining binaryData

  • @return Encoded Base64 array

*/

public static String encode(byte[] binaryData) {

if (binaryData == null) {

return null;

}

int lengthDataBits = binaryData.length * EIGHTBIT;

if (lengthDataBits == 0) {

return “”;

}

int fewerThan24bits = lengthDataBits % TWENTYFOURBITGROUP;

int numberTriplets = lengthDataBits / TWENTYFOURBITGROUP;

int numberQuartet = fewerThan24bits != 0 ? numberTriplets + 1 : numberTriplets;

char encodedData[] = null;

encodedData = new char[numberQuartet * 4];

byte k = 0, l = 0, b1 = 0, b2 = 0, b3 = 0;

int encodedIndex = 0;

int dataIndex = 0;

if (fDebug) {

System.out.println("number of triplets = " + numberTriplets);

}

for (int i = 0; i < numberTriplets; i++) {

b1 = binaryData[dataIndex++];

b2 = binaryData[dataIndex++];

b3 = binaryData[dataIndex++];

更多：Java进阶核心知识集

包含：JVM，JAVA集合，网络，JAVA多线程并发，JAVA基础，Spring原理，微服务，Zookeeper，Kafka，RabbitMQ，Hbase，MongoDB，Cassandra，设计模式，负载均衡，数据库，一致性哈希，JAVA算法，数据结构，加密算法，分布式缓存等等

[外链图片转存中…(img-ZAbJUUGU-1724686266263)]

高效学习视频

相关阅读docs.qq.com/doc/DSmxTbFJ1cmN1R2dB

2401_85957993
关注
  • 19
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
2024年Java最全Java使用RSA加密解密签名及校验(1)，java锁机制面试题
ghfgjfg679的博客
05-05 1049
在开头跟大家分享的时候我就说，面试我是没有做好准备的，全靠平时的积累，确实有点临时抱佛脚了，以至于我自己还是挺懊恼的。（准备好了或许可以拿个40k，没做准备只有30k+，你们懂那种感觉吗）程序员面试其实是对于技术的一次摸底考试，你的技术牛逼，那你就是大爷。大厂对于技术的要求主要体现在：基础，原理，深入研究源码，广度，实战五个方面，也只有将原理理论结合实战才能把技术点吃透。下面是我会看的一些资料笔记，希望能帮助大家由浅入深，由点到面的学习Java，应对大厂面试官的灵魂追问。
java rsa x509_Java使用RSA加密解密签名及校验
weixin_42184548的博客
02-16 812
由于项目要用到非对称加密解密签名校验什么的，于是参考《Java加密解密的艺术》写一个RSA进行加密解密签名及校验的Demo，代码很简单，特此分享！RSA加密解密类：packagecom.ihep;importjava.io.BufferedReader;importjava.io.BufferedWriter;importjava.io.FileReader;importjava.io.FileW...
Java OpenSSL生成的RSA公私钥进行数据加解密详细介绍
09-01
主要介绍了Java OpenSSL生成的RSA公私钥进行数据加解密详细介绍的相关资料,这里提供实例代码及说明具体如何实现，需要的朋友可以参考下
Java中使用OpenSSL生成的RSA公私钥进行数据加解密
weixin_34054866的博客
06-25 183
当前使用的是Linux系统，已经按装使用OpenSSL软件包， 一、使用OpenSSL来生成私钥和公钥 1、执行命令openssl version -a 验证机器上已经安装openssl  1 openssl version -a 运行结果： 2、生成私钥：这条命令让openssl随机生成了一份私钥，加密长度是1024位。加密长度是指理论上最大允许”被加密的信...
Java OpenSSL生成的RSA公私钥进行数据加解密 .
yangxn的专栏
07-24 3177
openssl req -x509 -out public_key.der -outform der -new -newkey rsa:1024 -keyout private_key.pem openssl rsa -in private_key.pem -pubout -out public_key.pem openssl pkcs8 -topk8 -inform PEM -in priv
java rsa签名验证失败_Java使用RSA加密解密及签名校验
weixin_31290291的博客
02-24 1301
packagecom.ljq.test;importjava.io.ByteArrayOutputStream;importjava.security.Key;importjava.security.KeyFactory;importjava.security.KeyPair;importjava.security.KeyPairGenerator;importjava.security.Priv...
Java实现RSA加密解密签名校验
02-14
Java实现RSA加密解密签名校验是信息安全领域中常见的任务，尤其在数据传输和网络通信中，RSA算法因其非对称性的特点，被广泛应用于数据的加密、解密以及数字签名。下面将详细介绍RSA算法的基本原理，以及如何使用...
JavaRSA生成公钥私钥加解密
03-10
用java代码生成公钥私钥密钥对，公钥加密私钥解密，私钥加密公钥解密。直接导入idea，可直接运行。小编正在看区块链的多重加密，看到这儿了就写了一个demo，用于理解加解密。
java 使用RSA生成公私钥对、加解密、及签名验签
03-19
一个简单的java使用RSA生成公私钥对 非对称加密解密 签名验签的过程，附带一个基本的加密工具类，有兴趣的朋友可以下载下来看看
java读取openssl生成的RSA密钥
weixin_34232617的博客
02-20 397
2019独角兽企业重金招聘Python工程师标准>>> ...
java rsa openssl_java读取openssl生成的RSA密钥
weixin_31785421的博客
02-12 497
在这里不贴代码，只为了说明遇到的问题，及怎么解决。问题：最近项目需要，要根据对方给定的rsa密钥来给程序通信身份认证。发现在正常编码过程中，无法解析rsa密钥文件。一番搜索，知道关键点：1.openssl生成的RSA密钥默认是PEM格式；2.java包默认只支持DER格式；那么PEM和DER是什么东东呢？这个要扯到ASN1了。哪这个又是啥？ASN1:Abstract Syntax Notation...
java中使用openssl生成的rsa公私钥进行数据加解密_使用openssl生成RSA公钥和私钥对...
weixin_39829497的博客
02-27 423
在ubuntu上要使用openssl的话需要先进行安装，命令如下：sudo apt-get install openssl安装完成就可以使用openssl了。首先需要进入openssl的交互界面，在命令行了输入openssl即可；1)生成RSA私钥：genrsa -out rsa_private_key.pem 1024该命令会生成1024位的私钥，生成成功的界面如下：此时我们就可以在当前路径下看...
spring security 安全策略加密解密处理过程
qq_17641373的专栏
03-04 3555
1.现在后台生成密钥对，把得到公钥的加密系数，加密指数，传个前台登录界面，进行加密 //rsa生成密钥对，和加密解密函数。 public class RSAUtil { private static String RSAKeyStore = "RSAKey.txt" public static KeyPair generateKeyPair() throws Exceptio
Java 中使用 OpenSSL 生成公钥私钥进行数据加解密
天行健，君子以自强不息；地势坤，君子以厚德载物。
08-21 2730
当前使用的是Linux系统，已经安装OpenSSL软件包。一、使用OpenSSL来生成私钥和公钥执行命令openssl version -a 验证机器上已经安装openssl$opensslversion-a生成私钥 这条命令让openssl随机生成一份私钥，加密长度是1024位。加密长度是指理论上最大允许”被加密的信息“长度的限制，也就是明文的长度限制。随着这个参数的增大（比方说2048）...
随机生成秘钥对
m0_37715184的博客
09-25 510
随机生成秘钥对 public static void genKeyPair() throws NoSuchAlgorithmException { // KeyPairGenerator类用于生成公钥和私钥对，基于RSA算法生成对象 KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA"); keyPairGen.initialize(1024, new SecureRandom()); KeyPair keyPair
Java加密解密方法详解与应用
在实际的Java加密解密过程中，常见的算法包括对称加密（如DES、AES）和非对称加密（如RSA），对称加密使用相同的密钥进行加密和解密，效率高但密钥管理复杂；非对称加密则使用一对公钥和私钥，公钥用于加密，私钥...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值