RSA 数据加签验签 & 加密解密 - 附完整代码&注释

最新推荐文章于 2024-07-31 19:38:21 发布
最新推荐文章于 2024-07-31 19:38:21 发布
阅读量526 收藏 8
点赞数 10
分类专栏： 笔记 java 文章标签： 开发语言 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WIK_7264/article/details/137336352
版权

RSA 数据加签验签 && 加密解密

简介

  • RSA是一种非对称加密算法，它是由Rivest-Shamir-Adleman三位密码学家于1978年提出的。

  • RSA算法的加密规则如下：

    • 钥匙生成：RSA算法使用两个密钥，一个是公钥（public key），用于加密数据，另一个是私钥（private key），用于解密数据。首先，密钥生成者生成一对公钥和私钥，其中公钥可以公开给任何人使用，而私钥必须保密。

    • 加密过程：发送方使用接收方的公钥对数据进行加密。发送方将数据按照一定的规则进行转换，并使用公钥进行加密操作。加密后的数据将无法直接被解密，只能使用私钥才能将其解密。

    • 解密过程：接收方使用自己的私钥对加密后的数据进行解密。接收方使用私钥对加密后的数据进行解密操作，从而得到原始的明文数据。

  • 参考：JAVA 使用RSA算法进行数字签名验证

代码

  • 公钥私钥是唯一一对 可以使用公钥加密私钥解密也可以使用私钥加密公钥解密 看自己需求。
import org.apache.commons.codec.binary.Base64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.crypto.Cipher;
import java.nio.charset.StandardCharsets;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

/**
 * @Author: 小新
 * @Date: 2024/4/3 9:56
 *  RSA 数据加签验签 加密解密
 */
public class RSAUtil {
    private static final Logger logger = LoggerFactory.getLogger(RSAUtil.class);

    private String privateKey;
    private String publicKey;

    public static void main(String[] args) {
        Entity entity = new Entity();
        // 使用RSA算法生成 公钥与私钥, 生成的公私钥 是一一对应的。
        createRSAKey(entity);
        String body = "加签";
        // 将入参数据以及私钥进行数字加签
        String sign = sign(body, entity.getPrivateKey());
        // 根据入参数据以及公钥进行验证签名，若入参数据body被修改或者秘钥不正确都会导致验签失败；例如加签使用body，验签使用body2则导致验签失败
        boolean verifyFlag = verify(body,entity.getPublicKey(), sign);
        if (verifyFlag) {
            logger.info("验签成功");
        } else {
            logger.info("验签失败");
        }
    }

    /**
     * 生成对应的 与我通信的公钥和私钥
     * @return
     */
    public static void createRSAKey(Entity entity) {
        try {
            // 创建KeyPairGenerator 指定算法为RSA，用于生成对应的公钥和私钥
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
            // 指定字节长度
            keyPairGenerator.initialize(1024);
            // 秘钥生成器
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            // 公钥
            RSAPublicKey publicKey = (RSAPublicKey)keyPair.getPublic();
            // 进行Base64编码存入
            String clientPublicKey = Base64.encodeBase64String(publicKey.getEncoded());
            logger.info("生成的clientPublicKey是: {}", clientPublicKey);
            entity.setPublicKey(clientPublicKey);
            // 私钥
            RSAPrivateKey privateKey = (RSAPrivateKey)keyPair.getPrivate();
            // 进行Base64编码存入
            String clientPrivateKey = Base64.encodeBase64String(privateKey.getEncoded());
            logger.info("生成的clientPrivateKey是: {}", clientPrivateKey);
            entity.setPrivateKey(clientPrivateKey);
        } catch (Exception e) {
            logger.error("生成秘钥失败");
            e.printStackTrace();
        }
    }

    /**
     * 利用私钥信息生成数字签名
     * @param data 入参数据body
     * @param privateKey 私钥
     * @return
     */
    public static String sign(String data, String privateKey) {
        try {
            // 入参数据body字节数组
            byte[] dataBytes = data.getBytes();
            // 获取私钥秘钥字节数组
            byte[] keyBytes = Base64.decodeBase64(privateKey);
            // 使用给定的编码密钥创建一个新的PKCS8EncodedKeySpec。
            // PKCS8EncodedKeySpec 是 PKCS#8标准作为密钥规范管理的编码格式
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
            // 实例化KeyFactory,指定为加密算法 为 RSA
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            // 获得PrivateKey对象
            PrivateKey privateKey1 = keyFactory.generatePrivate(keySpec);
            // 用私钥对信息生成数字签名，指定签名算法为 MD5withRSA
            Signature signature = Signature.getInstance("MD5withRSA");
            // 初始化签名
            signature.initSign(privateKey1);
            // 数据body带入
            signature.update(dataBytes);
            // 对签名进行Base64编码
            return Base64.encodeBase64String(signature.sign());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 利用公钥校验数字签名
     * @param data 入参数据body
     * @param publicKey 公钥
     * @param sign 签名
     * @return
     */
    public static boolean verify(String data, String publicKey, String sign) {
        try {
            // 入参数据body字节数组
            byte[] dataBytes = data.getBytes(StandardCharsets.UTF_8);
            // 获取公钥秘钥字节数组
            byte[] keyBytes = Base64.decodeBase64(publicKey);
            // 使用给定的编码密钥创建一个新的X509EncodedKeySpec
            // X509EncodedKeySpec是基于X.509证书提前的公钥，一种java秘钥规范
            X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(keyBytes);
            // 实例化KeyFactory,指定为加密算法 为 RSA
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            // 获取publicKey对象
            PublicKey publicKey1 = keyFactory.generatePublic(x509EncodedKeySpec);
            // 用私钥对信息生成数字签名，指定签名算法为 MD5withRSA
            Signature signature = Signature.getInstance("MD5withRSA");
            // 带入公钥进行验证
            signature.initVerify(publicKey1);
            // 数据body带入
            signature.update(dataBytes);
            // 验证签名
            return signature.verify(Base64.decodeBase64(sign));
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 使用公钥对明文进行加密
     *
     * @param plainText 明文字符串
     * @param publicKey 公钥字符串（Base64编码）
     * @return 加密后的数据（字节数组形式）
     * @throws Exception 加密过程中发生的异常
     */
    public static byte[] encryptWithPublicKey(String plainText, String publicKey) throws Exception {
        // 解码公钥字符串
        byte[] keyBytes = Base64.decodeBase64(publicKey);
        // 生成X509EncodedKeySpec
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        // 实例化KeyFactory并指定为RSA
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        // 生成PublicKey对象
        PublicKey rsaPublicKey = keyFactory.generatePublic(keySpec);
        // 实例化Cipher并指定为RSA/ECB/PKCS1Padding
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
        // 使用公钥初始化Cipher为加密模式
        cipher.init(Cipher.ENCRYPT_MODE, rsaPublicKey);
        // 执行加密操作
        return cipher.doFinal(plainText.getBytes(StandardCharsets.UTF_8));
    }

    /**
     * 使用私钥对密文进行解密
     *
     * @param encryptedData 加密后的数据（字节数组形式）
     * @param privateKey    私钥字符串（Base64编码）
     * @return 解密后的明文字符串
     * @throws Exception 解密过程中发生的异常
     */
    public static String decryptWithPrivateKey(byte[] encryptedData, String privateKey) throws Exception {
        // 解码私钥字符串
        byte[] keyBytes = Base64.decodeBase64(privateKey);
        // 生成PKCS8EncodedKeySpec
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
        // 实例化KeyFactory并指定为RSA
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        // 生成PrivateKey对象
        PrivateKey rsaPrivateKey = keyFactory.generatePrivate(keySpec);
        // 实例化Cipher并指定为RSA/ECB/PKCS1Padding
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
        // 使用私钥初始化Cipher为解密模式
        cipher.init(Cipher.DECRYPT_MODE, rsaPrivateKey);
        // 执行解密操作
        byte[] decryptedBytes = cipher.doFinal(encryptedData);
        // 将解密后的字节数组转换为字符串（使用UTF-8编码）
        return new String(decryptedBytes, StandardCharsets.UTF_8);
    }

    /**
     * 使用私钥对数据进行加密
     *
     * @param data 明文数据（字符串形式）
     * @param privateKey 私钥字符串（Base64编码）
     * @return 加密后的密文（字节数组）
     * @throws Exception 加密过程中发生的异常
     */
    public static byte[] encryptWithPrivateKey(String data, String privateKey) throws Exception {
        // 解码私钥字符串
        byte[] keyBytes = Base64.decodeBase64(privateKey);
        // 生成PKCS8EncodedKeySpec
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
        // 实例化KeyFactory并指定为RSA
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        // 生成PrivateKey对象
        PrivateKey rsaPrivateKey = keyFactory.generatePrivate(keySpec);
        // 实例化Cipher并指定为RSA/ECB/PKCS1Padding
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
        // 使用私钥初始化Cipher为加密模式
        cipher.init(Cipher.ENCRYPT_MODE, rsaPrivateKey);
        // 执行加密操作
        return cipher.doFinal(data.getBytes(StandardCharsets.UTF_8));
    }

    /**
     * 使用公钥对数据进行解密
     *
     * @param encryptedData 加密后的数据（字节数组形式）
     * @param publicKey 公钥字符串（Base64编码）
     * @return 解密后的明文数据（字符串）
     * @throws Exception 解密过程中发生的异常
     */
    public static String decryptWithPublicKey(byte[] encryptedData, String publicKey) throws Exception {
        // 解码公钥字符串
        byte[] keyBytes = Base64.decodeBase64(publicKey);
        // 生成X509EncodedKeySpec
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        // 实例化KeyFactory并指定为RSA
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        // 生成PublicKey对象
        PublicKey rsaPublicKey = keyFactory.generatePublic(keySpec);
        // 实例化Cipher并指定为RSA/ECB/PKCS1Padding
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
        // 使用公钥初始化Cipher为解密模式
        cipher.init(Cipher.DECRYPT_MODE, rsaPublicKey);
        // 执行解密操作
        byte[] decryptedBytes = cipher.doFinal(encryptedData);
        // 将解密后的字节数组转换为字符串（使用UTF-8编码）
        return new String(decryptedBytes, StandardCharsets.UTF_8);
    }
}
阿新-
关注
  • 10
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#纯源代码实现RSA加解密-没有注释
05-09
本文将深入探讨如何使用C#语言实现RSA加解密，并关注提供的源代码文件`RSA.cs`。 1. **RSA原理**： RSA算法的核心在于两个大素数的乘积，这两个素数是保密的，称为私钥。公钥是这两个素数的乘积和一个欧拉函数φ(n...
C#自定义RSA加密解密及RSA签名和验证类实例
01-01
这个C#类自定义RSA加密解密及RSA签名和验证，包含了RSA加密、解密及签名所需的相关函数，带有详细的注释说明。 using System; using System.Text; using System.Security.Cryptography; namespace DotNet.Utilities...
RSA加密解密签名加签验签RsaUtils工具类
gongjin28_csdn的博客
03-19 1449
RSA基于数学上的大整数因子分解难题，只要密钥足够大（通常建议至少2048位），在现有的计算机技术和算法条件下，破解RSA加密的数据所需的时间极其漫长，从而确保了高度的安全性。RSA算法基于大数因子分解难题，提供了公钥加密和私钥解密的能力。：除了加密外，RSA还可用于数字签名，通过私钥对数据进行签名，然后接收方可以用公钥验证签名的真实性，确保数据完整性并确认发送者的身份。：虽然实际运算复杂，但RSA算法本身是公开的，这增强了人们对算法安全性的信任，因为任何潜在的漏洞都可以经过全球专家的审查和改进。
Java最全RSA加密解密算法原理以及实现_rsa简介及源码实现，java算法基础面试题
ghfgjfg679的博客
05-10 1480
为了应付面试也刷了很多的面试题与资料，现在就分享给有需要的读者朋友，资料我只截取出来一部分哦φ(n)，k为任意整数，d便是e的模反元素。同时也可得到，e的模反元素d并不是唯一的。例如，e=3，φn11φ(n)=11，则d=4±\pm±k·11。至此，公钥，私钥便都已经得到。
在node环境实现RSA数据加密加签以及解密验签
qq_45676251的博客
10-23 2403
在node环境实现数据加密加签以及解密验签 最近上密码学的课要求代码实现RSA算法，语言任选，可以引用包，我使用的是js，下面是内容 首先我们得知道一个客户端与服务端之间数据传输加密的过程，大致如下： 1、A给B发送信息STR 2、A先用SHA256对信息STR计算，得到摘要Z 3、A用A的私钥对Z进行加密，得到签名S（只有发送者的私钥才能代表发送者，只能使用发送方的私钥加密才能达到不可抵赖性） 4、A用B的公钥对信息STR和签名S加密，得到传输数据M 传输M 1、B用B的私钥对M解密，得到信息STR和签名
Java实现RSA工具类（加密、解密、签名、验签）
热门推荐
嘉禾嘉宁papa
06-08 1万+
目录一、简介二、RSA2.1 算法原理2.2RSA与RSA2区别2.2 公钥加密、私钥解密2.3 私钥签名、公钥验签三、RsaUtil工具类四、实践结语 一、简介   RSA是1977年由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）一起提出的。RSA就是他们三人姓氏开头字母拼在一起组成的。   RSA公开密钥密码体制是一种使用不同的加密密钥与解密密钥，“由已知加密密钥推导出解密密钥在计算上是不可行的”密码体制。 二、RSA
【nodejs】使用node-rsa数字签名/隐私信息加密解密
皇夜_的博客
11-06 2230
nodejs-使用node-rsa数字签名/隐私信息加密解密 加密解密：公钥加密，私钥解密 1.sender生成密钥对：私钥A，公钥A，将公钥A给接收者receiver 2.receiver生成密钥对：私钥B，公钥B，将公钥B给sender 3.sender持有：私钥A，公钥B 4.receiver持有：私钥B，公钥A 5.发送过程：【私钥保留在自己手中，只有自己能够解密，保证了数据的安...
asp版 vbscript RSA公钥加密 / 私钥解密 / 私钥签名 / 公钥验签（支持中文）分段加密解密
xuemu2008的专栏
11-07 1920
最近有空在把自己的asp站点后端函数全部整理了下，在弄RSA的时候遇到了坑了，然后找到下面这位兄弟刚好发布的文章： https://blog.csdn.net/todaygods/article/details/109383438 用了他的demo在本机win7，IIS环境测试，一切正常，然后传到服务器windows server 2008 R2 IIS环境下测试，IIS站点的应用程序池用的默认.net 2.0的，上demo，直接提示mscorlib 错误，估计是没有调起.net的类，在服务器的安装程.
SpringBoot非对称加解密---RSA、通过注解自动化实现
barcke的博客
07-27 1187
rsa-body-spring-boot 使用方式 源码地址:https://github.com/Barcke/rsa-body-spring-boot/tree/master 导入对应的MAVEN包: <dependency> <groupId>com.barcke.y</groupId> <artifactId>rsa-body-spring-boot</artifactId> <version&g
RSA加密算法-前端(JS)加密,后端(JAVA)解密
qq_39027229的博客
12-14 5973
简述一下: RSA非对称加密算法, 简单理解就是: 准备两把钥匙-公钥, 私钥. 加密的时候使用公钥进行加密, 解密的时候使用私钥进行解密, 这两把钥匙是不同的. js里面包含了解密和加密方法, 我们需要做的就是使用方法的时候传递 钥匙和数据进去. RSA工具类里面也包含 解密js端传递来的密文方法, 以及在后台进行数据的加密解密方法. 直接开始: 1. 准备前端需要的js jque...
kotlin版本RSA非对称加密解密与分段加密解密
duner12138的博客
01-15 2160
基于kotlin语言的RSA非对称加密解密/RSA非对称分段加密解密 RSA非对称加密 RSA非对称加密的具体算法与来源我就不写了，感兴趣的可以自己找度娘或者维基百科 前面我的两篇文章讲了DES和AES对称加密，我们可以看出他们加密和解密时都使用的是同一个密钥，那么： 非对称加密就是加密和解密使用不同的密钥： 我们将它称为密钥对，密钥对包含公钥私钥两个，如果使用公钥加密则要使用私钥解密，反之使用私钥加密则要用公钥解密，我们将相对应的公钥私钥称为密钥对。 密钥对由系统生成 使用时两个组织或者个人通过交换公钥解
SpringBoot--RSA自动加密解密工具
ONROAD0612的博客
08-25 1万+
1 概述 在项目中，为了保证数据的安全，我们常常会对传递的数据进行加密。常用的加密算法包括对称加密（AES）和非对称加密（RSA），这里针对SpringBoot搭建的项目，博主根据SpringBoot自动配置的原理写了一个RSA自动加密工具，实现自动加密返回数据、解密传入数据并映射成json。 2 项目结构 上图的项目结构其实和SpringBoot--自动配置Demo实现的项目结构基本一...
RSA.rar_RSA加密文件_RSA加密明文_RSA加密解密和_rsa c_rsa文件加密
09-14
RSA算法是一种非对称加密...总的来说，这个压缩包提供了一套完整的RSA加密解密解决方案，涵盖了理论知识、C语言实现以及用户交互的界面设计。对于学习RSA算法和实践加密应用的开发者来说，这是一个非常有价值的资源。
基于C#的数据加密、解密示例
03-17
标签"C#源代码 加密解密"进一步确认了我们将关注的是使用C#编写的实际代码，特别是与加密和解密相关的部分。这意味着我们可以期待看到如何在C#代码中实现加密算法，以及如何使用这些算法来保护数据。 至于压缩包中...
加密解密演示资源，源代码，带有注释.rar
05-21
此资源“加密解密演示资源，源代码，带有注释.rar”提供了一个关于加密解密的实际操作示例，适用于学习和理解相关概念。以下是基于这个主题的详细知识点： 1. **加密**: 加密是将明文数据转化为无法被轻易理解的...
thinkPHP开发的彩漂网站源码，含pc端和手机端
jiyc2008的博客
07-30 1万+
thinkPHP开发的菜票网站源码，含pc端和手机端
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 584
1.导入hutool的maven依赖。2.复制一下代码执行。
社区养老服务小程序的设计
最新发布
Karen198的博客
07-31 493
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
使用c语言和OpenSSL编写RSA的加密解密算法并附上每行代码注释
06-07
好的，以下是使用C语言和OpenSSL编写RSA加密解密算法的代码及注释： ```c #include <stdio.h> #include <stdlib.h> #include <string.h> #include <openssl/bio.h> #include <openssl/evp.h> #include <openssl/rsa.h> #define KEY_LENGTH 2048 // RSA密钥长度 #define PUB_EXP 3 // RSA公钥指数 // RSA密钥对结构体 typedef struct _rsa_keys { RSA *public_key; RSA *private_key; } rsa_keys; // 生成RSA密钥对函数 int generate_rsa_keys(rsa_keys *keys) { int ret = 0; BIGNUM *bn = NULL; BIO *bio = NULL; // 生成RSA密钥对 keys->public_key = RSA_new(); keys->private_key = RSA_new(); bn = BN_new(); ret = BN_set_word(bn, PUB_EXP); ret = RSA_generate_key_ex(keys->public_key, KEY_LENGTH, bn, NULL); ret = RSA_generate_key_ex(keys->private_key, KEY_LENGTH, bn, NULL); // 清除内存 BN_free(bn); return ret; } // RSA加密函数 int rsa_encrypt(char *input, int input_len, char *output, rsa_keys *keys) { int ret = 0; BIO *bio = NULL; EVP_PKEY *pkey = NULL; EVP_PKEY_CTX *ctx = NULL; size_t output_len = 0; // 获取RSA公钥 pkey = EVP_PKEY_new(); ret = EVP_PKEY_set1_RSA(pkey, keys->public_key); // 创建RSA加密上下文 ctx = EVP_PKEY_CTX_new(pkey, NULL); // 初始化RSA加密上下文 ret = EVP_PKEY_encrypt_init(ctx); // 设置RSA加密填充模式 ret = EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PADDING); // 执行RSA加密 ret = EVP_PKEY_encrypt(ctx, NULL, &output_len, input, input_len); // 申请内存 output = (char*) malloc(output_len); // 执行RSA加密 ret = EVP_PKEY_encrypt(ctx, output, &output_len, input, input_len); // 清除内存 EVP_PKEY_CTX_free(ctx); EVP_PKEY_free(pkey); return ret; } // RSA解密函数 int rsa_decrypt(char *input, int input_len, char *output, rsa_keys *keys) { int ret = 0; BIO *bio = NULL; EVP_PKEY *pkey = NULL; EVP_PKEY_CTX *ctx = NULL; size_t output_len = 0; // 获取RSA私钥 pkey = EVP_PKEY_new(); ret = EVP_PKEY_set1_RSA(pkey, keys->private_key); // 创建RSA解密上下文 ctx = EVP_PKEY_CTX_new(pkey, NULL); // 初始化RSA解密上下文 ret = EVP_PKEY_decrypt_init(ctx); // 设置RSA解密填充模式 ret = EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PADDING); // 执行RSA解密 ret = EVP_PKEY_decrypt(ctx, NULL, &output_len, input, input_len); // 申请内存 output = (char*) malloc(output_len); // 执行RSA解密 ret = EVP_PKEY_decrypt(ctx, output, &output_len, input, input_len); // 清除内存 EVP_PKEY_CTX_free(ctx); EVP_PKEY_free(pkey); return ret; } int main() { rsa_keys keys; char *input = "Hello, RSA!"; char *encrypted = NULL; char *decrypted = NULL; int ret = 0; // 生成RSA密钥对 ret = generate_rsa_keys(&keys); // RSA加密 ret = rsa_encrypt(input, strlen(input), encrypted, &keys); // RSA解密 ret = rsa_decrypt(encrypted, strlen(encrypted), decrypted, &keys); // 输出结果 printf("Input: %s\n", input); printf("Encrypted: %s\n", encrypted); printf("Decrypted: %s\n", decrypted); // 清除内存 free(encrypted); free(decrypted); return 0; } ``` 注释已经标注在代码中，主要分为以下几个部分： - 生成RSA密钥对 - RSA加密 - RSA解密 代码中使用了OpenSSL库提供的RSA相关函数。首先使用`RSA_new()`函数创建RSA密钥对结构体，然后使用`RSA_generate_key_ex()`函数生成RSA密钥对。生成RSA密钥对后，使用`EVP_PKEY_set1_RSA()`函数获取RSA公钥或私钥，使用`EVP_PKEY_CTX_new()`函数创建RSA加密或解密上下文，使用`EVP_PKEY_encrypt()`或`EVP_PKEY_decrypt()`函数执行RSA加密或解密，最后使用`EVP_PKEY_CTX_free()`和`EVP_PKEY_free()`函数清除内存。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值