使用C语言openssl库实现 RSA加密 和 消息验证

Q:什么是RSA?

A:RSA(Rivest-Shamir-Adleman)是一种非对称加密算法,是最早的一种用于公开密钥加密和数字签名的算法。它使用一对公钥(public key)和私钥(private key)。公钥用于加密,私钥用于解密。由于使用不同的密钥进行加密和解密,因此被称为非对称加密算法。RSA算法的安全性基于大数因子分解的难度,即大整数分解问题。目前尚未找到一种高效算法可以在合理时间内解决大整数的分解问题,这使得RSA在当前计算机性能下是安全的。


Q:什么是RSA消息验证?

A:RSA消息验证指的是使用RSA算法对消息进行签名和验证,以确保消息的完整性和真实性。


RSA密钥对生成

  • 选择两个大素数 p 和 q
  • 计算 𝑛=𝑝×𝑞,这是模数
  • 计算 𝜙(𝑛)=(𝑝−1)×(𝑞−1)
  • 选择一个整数 𝑒作为公用指数,使 1<𝑒<𝜙(𝑛)并且 𝑒 与 𝜙(𝑛)互质
  • 计算私钥指数 𝑑,使得 𝑑×𝑒≡1 (mod 𝜙(𝑛))

公钥是 (𝑒,𝑛),私钥是 (𝑑,𝑛)

RSA加密/解密步骤

加密

  • 将明文 𝑀 转换为整数 𝑚,其中 0≤𝑚<𝑛
  • 使用公钥 (𝑒,𝑛)进行加密,得到密文 𝑐=m^{e} (mod 𝑛)

解密

  • 使用私钥 (𝑑,𝑛) 进行解密,恢复明文 𝑚=c^{d}(mod 𝑛)

RSA消息验证步骤

签名

  • 发送方使用其私钥对消息进行签名。具体做法是对消息进行哈希处理,得到一个消息摘要,然后使用私钥对这个摘要进行加密,生成签名
  • 签名与原始消息一起发送给接收方

验证

  • 接收方使用发送方的公钥对签名进行验证。具体做法是对收到的签名使用公钥解密,得到解密后的摘要
  • 接收方同时对收到的原始消息进行哈希处理,得到本地计算的消息摘要
  • 比较解密后的摘要和本地计算的摘要,如果两者相同,则验证成功,消息没有被篡改且确实来自发送方

举个例子:

假设Alice要给Bob发送一条消息,并且需要确保Bob知道这条消息确实来自Alice且没有被篡改,Alice和Bob可以使用RSA进行消息签名和验证。

  1. Alice生成密钥对

    • 公钥:(𝑒,𝑛)
    • 私钥:(𝑑,𝑛)
  2. Alice签名消息

    • 对消息进行哈希处理,得到消息摘要 𝐻(𝑀)
    • 使用私钥对消息摘要进行加密,生成签名 𝑆=𝐻(𝑀)𝑑 (mod 𝑛)
    • 将消息 𝑀 和签名 𝑆 发送给Bob。
  3. Bob验证签名

    • 使用公钥对签名进行解密,得到解密后的摘要 𝐻 ′(𝑀)=𝑆𝑒 (mod 𝑛)
    • 对收到的消息 𝑀 进行哈希处理,得到本地计算的消息摘要 𝐻(𝑀)
    • 比较解密后的摘要 𝐻 ′(𝑀)和本地计算的摘要 𝐻(𝑀),如果两者相同,则验证成功。

通过上述过程,Bob可以确认消息确实来自Alice且未被篡改。

RSA加密/解密 & RSA消息验证

在刚刚的消息验证 例子中,公钥用于解密,而私钥用于加密,这似乎违背了在开头所说的“公钥加密,私钥解密”,其实并没有,这是因为RSA加/解密 和 RSA消息验证是两个不同的概念

他们可以各自单独使用,也可以结合使用,以下是三个不同的场景帮助理解:


1. 单独使用RSA加密

场景1:确保消息的机密性

步骤

  1. 密钥生成接收方生成一对RSA密钥对(公钥和私钥)。
  2. 公钥分发:接收方将公钥分发给发送方。
  3. 消息加密
    • 发送方使用接收方的公钥对消息进行加密。
    • 发送方将加密后的消息发送给接收方。
  4. 消息解密
    • 接收方使用自己的私钥对加密的消息进行解密,恢复原始消息


2. 单独使用RSA消息验证(数字签名)

场景2:确保消息的完整性和真实性

步骤

  1. 密钥生成发送方生成一对RSA密钥对(公钥和私钥)。
  2. 公钥分发:发送方将公钥分发给接收方。
  3. 消息签名
    • 发送方对消息进行哈希处理,生成消息摘要。
    • 发送方使用自己的私钥对消息摘要进行加密,生成签名。
    • 发送方将原始消息和签名一起发送给接收方。
  4. 签名验证
    • 接收方使用发送方的公钥对签名进行解密,得到解密后的消息摘要。
    • 接收方对收到的原始消息进行哈希处理,生成本地计算的消息摘要。
    • 接收方比较解密后的消息摘要和本地计算的消息摘要,如果两者相同,则验证成功。


3. 结合使用RSA加密和消息验证

场景3:确保消息的机密性、完整性和真实性

步骤

  1. 密钥生成
    • 发送方和接收方各自生成一对RSA密钥对(各自的公钥和私钥)。
  2. 公钥分发
    • 发送方和接收方互相交换公钥。
  3. 消息签名和加密
    • 发送方对消息进行哈希处理,生成消息摘要。
    • 发送方使用自己的私钥对消息摘要进行加密,生成签名。
    • 发送方将签名附加到原始消息上。 
    • 发送方使用接收方的公钥对包含签名的消息进行加密。
    • 发送方将加密后的消息发送给接收方。
  4. 消息解密和验证
    • 接收方使用自己的私钥对加密的消息进行解密,得到原始消息和签名。
    • 接收方使用发送方的公钥对签名进行解密,得到解密后的消息摘要。
    • 接收方对收到的原始消息进行哈希处理,生成本地计算的消息摘要。
    • 接收方比较解密后的消息摘要和本地计算的消息摘要,如果两者相同,则验证成功。

相关函数认识

密钥对生成相关API

  • OpenSSL_add_all_algorithms(void):用于注册所有可用的加密算法、摘要算法和公钥算法。这个函数通常在程序初始化时调用,以确保在后续的加密操作中可以使用所有 OpenSSL 提供的算法
  • RSA_new(void):创建一个新的 RSA 结构,该结构用于存储 RSA 密钥对。RSA 结构包含了生成和使用 RSA 密钥对所需的信息

返回值

  • 成功时返回一个指向新分配的 RSA 结构的指针
  • 失败时返回 NULL
  • RSA_free(RSA *rsa): 用于释放 RSA 结构体占用的内存的函数。它用于清理和释放与 RSA 结构相关的所有资源,防止内存泄漏。 

参数

  • RSA *rsa:指向要释放的RSA结构体的指针
  • BN_new(void):创建一个新的 BIGNUM 结构,该结构用于存储任意大小的整数。BIGNUM 是 OpenSSL 中表示大整数的基本数据类型,用于各种密码学计算

返回值

  • 成功时返回一个指向新分配的 BIGNUM 结构的指针
  • 失败时返回 NULL
  • BN_set_word(BIGNUM *a,unsigned long w) : 用于将一个无符号长整数 (unsigned long) 设置为 BIGNUM 结构的值。这个函数在初始化 BIGNUM 结构时特别有用,例如设置 RSA 公钥的指数

参数

  • BIGNUM *a:指向 BIGNUM 结构的指针
  • unsigned long w:要设置的无符号长整数值

返回值

  • 成功时返回 1
  • 失败时返回 0
  •  BN_free(BIGNUM *a) : 函数用于释放由 BN_new() 分配的 BIGNUM 结构。BIGNUM 是 OpenSSL 中用于表示大整数的结构,当它们不再需要时,需要调用 BN_free() 来释放分配的内存,以避免内存泄漏

参数

  • BIGNUM *a:指向 BIGNUM 结构的指针,需要被释放的 BIGNUM 结构
  •  RSA_generate_key_ex(RSA *rsa,int bits,BIGNUM *e,BN_GENCB *cb): 函数是 OpenSSL 库中用于生成 RSA 密钥对的函数

参数解释

  • RSA *rsa:一个指向 RSA 结构的指针,这个结构将保存生成的密钥对。你需要预先分配并初始化这个结构。
  • int bits:指定生成的 RSA 密钥的长度,以位为单位。常见的长度有 1024、2048、4096 等,长度越大,安全性越高,但生成和使用的时间也越长。
  • BIGNUM *e:指定公钥指数的 BIGNUM 结构。通常使用 65537 作为公钥指数,因为它是一个常用且有效率的选择。
  • BN_GENCB *cb:一个可选的回调函数,用于在密钥生成的过程中提供反馈。如果不需要反馈,可以传递 NULL。

返回值

  • 成功时返回 1,失败时返回 0。

加密/解密API 

RSA_public_encrypt RSA_private_decrypt 是 OpenSSL 中用于 RSA 加密和解密操作的函数。它们分别使用公钥进行加密和私钥进行解密:

  • RSA_public_encrypt(int flen,const unsigned char *from,unsigned char *to,RSA *rsa,int padding):
  • RSA_private_decrypt(int flen,const unsigned char *from,unsigned char *to,RSA *rsa,int padding):

参数解释

  • int flen:输入数据的长度
  • const unsigned char *from:指向输入数据的指针
  • unsigned char *to:指向输出数据的缓冲区的指针
  • RSA *rsa:指向 RSA 密钥的指针
  • int padding:填充方式。常见的填充方式有:
    • RSA_PKCS1_PADDING:PKCS #1 v1.5 填充
    • RSA_NO_PADDING:无填充
    • RSA_PKCS1_OAEP_PADDING:PKCS #1 OAEP 填充

返回值

  • 成功时,返回加密或解密的数据长度
  • 失败时,返回 -1

 

签名/认证API

  • SHA256(const unsigned char *d,size_t n,unsigned char *md): OpenSSL 库中用于计算消息的 SHA-256 哈希值的函数

参数说明

  • const unsigned char *d:指向要进行哈希运算的数据的指针
  • size_t n:数据的长度,以字节为单位
  • unsigned char *md:指向保存哈希值的输出缓冲区的指针。这个缓冲区需要有足够的空间来存储 SHA-256 哈希值(32 字节)

返回值

  • 返回指向哈希值的指针(通常与 md 相同),如果 md 为 NULL,则该函数会使用静态分配的内存并返回该内存的指针

 RSA_sign RSA_verify 是 OpenSSL 库中用于 RSA 签名和验证的函数:

  • RSA_sign(int type,const unsigned char *m,unsigned int m_len,unsigned char *sigret,unsigned int *siglen,RSA *rsa):
  • RSA_verify(int type,const unsigned char *m,unsigned int m_len,const unsigned char *sigbuf,unsigned int *siglen,RSA *rsa):

参数说明

  • int type:要使用的哈希类型的 NID。例如,NID_sha256 表示 SHA-256
  • const unsigned char *m:指向要签名/验证的消息的哈希值
  • unsigned int m_len:哈希值的长度,以字节为单位
  • unsigned char *sigret:指向存储生成的签名的缓冲区的指针
  • unsigned int *siglen:指向存储生成的签名长度的变量的指针
  • const unsigned char *sigbuf:指向存储签名的缓冲区的指针
  • unsigned int siglen:签名的长度,以字节为单位
  • RSA *rsa:指向 RSA 密钥的指针

返回值

  • 成功返回 1,失败返回 0

BIO的概念和相关API

BIO 结构是 OpenSSL 中的一个核心概念,它用于处理各种 I/O 操作。BIO 是 Basic Input/Output 的缩写,代表了一个抽象的 I/O 流。BIO 可以用于多种不同的 I/O 操作,包括文件 I/O、内存 I/O、网络 I/O 等。

在 OpenSSL 中,BIO 提供了一种统一的接口来处理这些不同类型的 I/O 操作,使得程序员可以更方便地进行加密和解密操作,而不需要关心底层的 I/O 细节。

创建和释放 BIO 结构
  • BIO_new_file(const char *filename, const char *mode): 创建一个文件 BIO,用于文件读写。

参数解释

  • const char *filename:要打开的文件的名称(文件路径)。
  • const char *mode:文件打开模式,与标准 C 库中的 fopen 函数的模式参数相同。例如:
    • "r":以只读模式打开文件。
    • "w":以写入模式打开文件(如果文件不存在则创建文件)。
    • "a":以追加模式打开文件(数据写入到文件末尾)。

返回值

  • 成功时返回一个指向新 BIO 对象的指针。
  • 失败时返回 NULL。
  • BIO_new_mem_buf(const void *buf, int len): 创建一个内存 BIO,用于内存读写。
  • BIO_free_all(BIO *a): 释放一个 BIO 结构。
  • BIO_new_fp(FILE *stream,int close_flag):用于创建一个新的 BIO(Basic Input/Output)对象,并将其与一个文件指针关联起来的函数

参数解释

  • FILE *stream:一个标准 C 的文件指针,指向你希望 BIO 对象读取或写入的文件
  • int close_flag:一个标志,指定当 BIO 对象被释放时,是否关闭关联的文件。如果设置为 1,当 BIO 释放时文件也会被关闭;如果设置为 0,文件将保持打开状态

返回值

  • 成功时返回一个指向新 BIO 对象的指针,失败时返回 NULL
读写操作
  • BIO_read(BIO *b, void *buf, int len): 从 BIO 读取数据。
  • BIO_write(BIO *b, const void *buf, int len): 向 BIO 写入数据。

公钥/私钥的读取/写入(打印)

PEM_write_bio_RSAPublicKey PEM_write_bio_RSAPrivateKey 用于将 RSA 公钥和私钥以 PEM 格式写入 BIO 结构中。PEM(Privacy Enhanced Mail)格式是一种用于存储和传输加密密钥、证书和其他数据的标准格式,通常以 ASCII 编码表示。

  • PEM_write_bio_RSAPublicKey(Bio *bp, RSA *x)
  • PEM_write_bio_RSAPrivateKey(Bio *bp, RSA *x,const EVP_CIPHER *enc, unsigned char *kstr, int klen, pem_password_cb *cb, void *u)

参数说明

  • BIO *bp: 指向 BIO 结构的指针,用于指定输出位置,如文件或内存
  • RSA *x: 指向 RSA 结构的指针,包含要写入的公钥或私钥
  • const EVP_CIPHER *enc: 指向加密算法的指针,如果为 NULL,则不加密私钥
  • unsigned char *kstr: 密钥字符串,用于加密私钥
  • int klen: 密钥字符串的长度
  • pem_password_cb *cb: 回调函数,用于获取加密私钥所需的密码
  • void *u: 传递给回调函数的用户数据

返回值

  • 成功时返回 1,失败时返回 0

PEM_read_bio_RSAPrivateKeyPEM_read_bio_RSAPublicKey 用于从 BIO 对象中读取 PEM 格式的 RSA 私钥和公钥。这两个函数分别适用于私钥和公钥的读取操作,可以用来替代直接从文件读取密钥的方法。

  • PEM_read_bio_RSAPrivateKey(BIO *bio, RSA **x, pem_password_cb *cb, void *u)
  • PEM_read_bio_RSAPublicKey(BIO *bio, RSA **x, pem_password_cb *cb, void *u)

参数

  • bio:BIO 对象。
  • x:指向一个 RSA 结构的指针,通常传递 NULL,表示由函数内部创建新的 RSA 结构。
  • cb:用于提供私钥解密的回调函数,通常传递 NULL
  • u:用于私钥解密的用户数据,通常传递 NULL

返回值

  • 成功时返回指向 RSA 结构的指针,失败时返回 NULL

实践仿真

接下来就使用C语言的openssl库来分别实现刚刚所述的三个场景:

场景1实现

单独使用RSA加密/解密,确保消息的机密性

rsa_jiajiemi.c:

#include <openssl/rsa.h>
#include <openssl/pem.h>
#include <openssl/err.h>
#include <stdio.h>
#include <string.h>

// 定义密钥长度和公钥指数
#define KEY_LENGTH 2048
#define PUB_EXP 3

// 如果定义了 PRINT_KEYS 则打印密钥
#define PRINT_KEYS

// 如果定义了 WRITE_TO_FILE 则写密钥到文件
#define WRITE_TO_FILE

// 错误处理函数,打印错误信息并终止程序
void handle_errors() {
    ERR_print_errors_fp(stderr);
    abort();
}

// 生成RSA密钥对的函数
RSA *generate_RSA_keypair() {
    RSA *rsa = RSA_new(); // 创建新的RSA对象
    BIGNUM *bn = BN_new(); // 创建新的大数对象

    // 设置公钥指数
    if (!BN_set_word(bn, PUB_EXP)) {
        handle_errors(); // 如果设置失败,则处理错误
    }

    // 生成密钥对
    if (!RSA_generate_key_ex(rsa, KEY_LENGTH, bn, NULL)) {
        handle_errors(); // 如果生成失败,则处理错误
    }

    BN_free(bn); // 释放大数对象
    return rsa; // 返回生成的RSA对象
}

// 将密钥写入文件的函数
void write_key_to_file(RSA *rsa) {
    // 写公钥到文件
    BIO *bp_public = BIO_new_file("public.pem", "w+");
    PEM_write_bio_RSAPublicKey(bp_public, rsa);
    BIO_free_all(bp_public);

    // 写私钥到文件
    BIO *bp_private = BIO_new_file("private.pem", "w+");
    PEM_write_bio_RSAPrivateKey(bp_private, rsa, NULL, NULL, 0, NULL, NULL);
    BIO_free_all(bp_private);
}

// 打印密钥的函数
void print_keys(RSA *rsa) {
    // 打印公钥到控制台
    BIO *bp_public = BIO_new_fp(stdout, BIO_NOCLOSE);
    PEM_write_bio_RSAPublicKey(bp_public, rsa);
    BIO_free_all(bp_public);

    // 打印私钥到控制台
    BIO *bp_private = BIO_new_fp(stdout, BIO_NOCLOSE);
    PEM_write_bio_RSAPrivateKey(bp_private, rsa, NULL, NULL, 0, NULL, NULL);
    BIO_free_all(bp_private);
}

// 执行加密和解密操作的函数
void rsa_encrypt_decrypt() {
    RSA *rsa = generate_RSA_keypair(); // 生成RSA密钥对

    #ifdef PRINT_KEYS
    print_keys(rsa); // 如果定义了 PRINT_KEYS,则打印密钥
    #endif

    #ifdef WRITE_TO_FILE
    write_key_to_file(rsa); // 如果定义了 WRITE_TO_FILE,则写密钥到文件
    #endif

    const char *message = "Hello, this is a test message."; // 要加密的消息
    unsigned char encrypted[KEY_LENGTH/8]; // 加密后的消息
    unsigned char decrypted[KEY_LENGTH/8]; // 解密后的消息
    
    // 使用公钥加密消息
    int encrypted_length = RSA_public_encrypt(strlen(message)+1, (unsigned char*)message, encrypted, rsa, RSA_PKCS1_OAEP_PADDING);
    if(encrypted_length == -1) {
        handle_errors(); // 如果加密失败,则处理错误
    }
    
    // 打印加密后的消息
    printf("Encrypted message: ");
    for(int i = 0; i < encrypted_length; i++) {
        printf("%02x", encrypted[i]);
    }
    printf("\n");

    // 使用私钥解密消息
    int decrypted_length = RSA_private_decrypt(encrypted_length, encrypted, decrypted, rsa, RSA_PKCS1_OAEP_PADDING);
    if(decrypted_length == -1) {
        handle_errors(); // 如果解密失败,则处理错误
    }

    // 打印解密后的消息
    printf("Decrypted message: %s\n", decrypted);

    RSA_free(rsa); // 释放RSA对象
}

int main() {
    // 初始化OpenSSL库
    OpenSSL_add_all_algorithms();
    ERR_load_BIO_strings();
    ERR_load_crypto_strings();

    // 执行加密和解密操作
    rsa_encrypt_decrypt();

    return 0;
}

场景2实现

单独使用RSA消息验证,确保消息的完整性和真实性

rsa_xxyz.c:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <openssl/rsa.h>
#include <openssl/pem.h>
#include <openssl/err.h>
#include <openssl/sha.h>

// 生成RSA密钥对并保存到文件
void generate_keys(const char *private_key_file, const char *public_key_file) {
    RSA *rsa = RSA_new();
    BIGNUM *bn = BN_new();
    BN_set_word(bn, RSA_F4); // 设置密钥的公用指数

    if (RSA_generate_key_ex(rsa, 2048, bn, NULL) != 1) {
        ERR_print_errors_fp(stderr);
        exit(EXIT_FAILURE);
    }

    // 写公钥到文件
    BIO *bp_public = BIO_new_file(public_key_file, "wb");
    PEM_write_bio_RSAPublicKey(bp_public, rsa);
    BIO_free_all(bp_public);

    // 写私钥到文件
    BIO *bp_private = BIO_new_file(private_key_file, "wb");
    PEM_write_bio_RSAPrivateKey(bp_private, rsa, NULL, NULL, 0, NULL, NULL);
    BIO_free_all(bp_private);

    RSA_free(rsa);
    BN_free(bn);
}

// 使用私钥对消息进行签名
unsigned char* sign_message(const char *private_key_file, const char *message, size_t *sig_len) {
    BIO *priv_bio = BIO_new_file(private_key_file, "rb"); //rb 具体代表“读取二进制”模式
    if (!priv_bio) {
        perror("无法打开私钥文件");
        exit(EXIT_FAILURE);
    }

    RSA *rsa = PEM_read_bio_RSAPrivateKey(priv_bio, NULL, NULL, NULL);
    BIO_free_all(priv_bio);

    if (!rsa) {
        ERR_print_errors_fp(stderr);
        exit(EXIT_FAILURE);
    }

    unsigned char hash[SHA256_DIGEST_LENGTH];
    SHA256((unsigned char*)message, strlen(message), hash); // 计算消息的SHA256哈希

    unsigned char *signature = (unsigned char*)malloc(RSA_size(rsa));
    if (RSA_sign(NID_sha256, hash, SHA256_DIGEST_LENGTH, signature, (unsigned int*)sig_len, rsa) != 1) {
        ERR_print_errors_fp(stderr);
        exit(EXIT_FAILURE);
    }

    RSA_free(rsa);
    return signature;
}

// 使用公钥验证签名
int verify_signature(const char *public_key_file, const char *message, unsigned char *signature, size_t sig_len) {
    BIO *pub_bio = BIO_new_file(public_key_file, "rb"); //rb 具体代表“读取二进制”模式
    if (!pub_bio) {
        perror("无法打开公钥文件");
        exit(EXIT_FAILURE);
    }

    RSA *rsa = PEM_read_bio_RSAPublicKey(pub_bio, NULL, NULL, NULL);
    BIO_free_all(pub_bio);

    if (!rsa) {
        ERR_print_errors_fp(stderr);
        exit(EXIT_FAILURE);
    }

    unsigned char hash[SHA256_DIGEST_LENGTH];
    SHA256((unsigned char*)message, strlen(message), hash); // 计算消息的SHA256哈希

    int result = RSA_verify(NID_sha256, hash, SHA256_DIGEST_LENGTH, signature, sig_len, rsa);
    RSA_free(rsa);
    return result;
}

int main() {
    const char *private_key_file = "private_key.pem";
    const char *public_key_file = "public_key.pem";
    const char *message = "这是一个用于签名和验证的消息";

    // 生成RSA密钥对
    generate_keys(private_key_file, public_key_file);

    // 签名消息
    size_t sig_len;
    unsigned char *signature = sign_message(private_key_file, message, &sig_len);

    // 验证签名
    int verified = verify_signature(public_key_file, message, signature, sig_len);
    if (verified) {
        printf("签名验证成功\n");
    } else {
        printf("签名验证失败\n");
    }

    free(signature);
    return 0;
}

场景3实现

结合使用RSA加密/解密 和 消息验证,确保消息的机密性、完整性和真实性

#include <openssl/rsa.h>
#include <openssl/pem.h>
#include <openssl/err.h>
#include <openssl/sha.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

// 定义密钥长度和公钥指数
#define KEY_LENGTH 2048
#define PUB_EXP 3

// 错误处理函数,打印错误信息并终止程序
void handle_errors() {
    ERR_print_errors_fp(stderr);
    abort();
}

// 生成RSA密钥对的函数
RSA *generate_RSA_keypair() {
    RSA *rsa = RSA_new();
    BIGNUM *bn = BN_new();

    if (!BN_set_word(bn, PUB_EXP)) {
        handle_errors();
    }

    if (!RSA_generate_key_ex(rsa, KEY_LENGTH, bn, NULL)) {
        handle_errors();
    }

    BN_free(bn);
    return rsa;
}

// 将密钥写入文件的函数
void write_key_to_file(RSA *rsa) {
    BIO *bp_public = BIO_new_file("public.pem", "w+");
    PEM_write_bio_RSAPublicKey(bp_public, rsa);
    BIO_free_all(bp_public);

    BIO *bp_private = BIO_new_file("private.pem", "w+");
    PEM_write_bio_RSAPrivateKey(bp_private, rsa, NULL, NULL, 0, NULL, NULL);
    BIO_free_all(bp_private);
}

// 打印密钥的函数
void print_keys(RSA *rsa) {
    BIO *bp_public = BIO_new_fp(stdout, BIO_NOCLOSE);
    PEM_write_bio_RSAPublicKey(bp_public, rsa);
    BIO_free_all(bp_public);

    BIO *bp_private = BIO_new_fp(stdout, BIO_NOCLOSE);
    PEM_write_bio_RSAPrivateKey(bp_private, rsa, NULL, NULL, 0, NULL, NULL);
    BIO_free_all(bp_private);
}

// 使用私钥对消息进行签名
unsigned char* sign_message(RSA *rsa, const char *message, size_t *sig_len) {
    unsigned char hash[SHA256_DIGEST_LENGTH];
    SHA256((unsigned char*)message, strlen(message), hash);

    unsigned char *signature = (unsigned char*)malloc(RSA_size(rsa));
    if (RSA_sign(NID_sha256, hash, SHA256_DIGEST_LENGTH, signature, (unsigned int*)sig_len, rsa) != 1) {
        ERR_print_errors_fp(stderr);
        exit(EXIT_FAILURE);
    }

    return signature;
}

// 使用公钥验证签名
int verify_signature(RSA *rsa, const char *message, unsigned char *signature, size_t sig_len) {
    unsigned char hash[SHA256_DIGEST_LENGTH];
    SHA256((unsigned char*)message, strlen(message), hash);

    int result = RSA_verify(NID_sha256, hash, SHA256_DIGEST_LENGTH, signature, sig_len, rsa);
    return result;
}

// 执行加密、解密、签名和验证操作的函数
void rsa_operations() {
    RSA *rsa = generate_RSA_keypair();

    //print_keys(rsa);//打印密钥对的函数
    write_key_to_file(rsa);


    const char *message = "Hello, this is a test message.";

    //第一步,使用私钥对原始消息签名
    size_t sig_len;
    unsigned char *signature = sign_message(rsa, message, &sig_len);
    printf("消息签名成功!\n");

    //第二步,使用接收方的公钥对原始消息加密
    unsigned char encrypted[KEY_LENGTH/8];
    unsigned char decrypted[KEY_LENGTH/8];
    int encrypted_length = RSA_public_encrypt(strlen(message)+1, (unsigned char*)message, encrypted, rsa, RSA_PKCS1_OAEP_PADDING);
    if(encrypted_length == -1) {
        handle_errors();
    }

    printf("加密成功!加密后的信息: ");
    for(int i = 0; i < encrypted_length; i++) {
        printf("%02x", encrypted[i]);
    }
    printf("\n");


    //第三步,chengg接收方使用自己的私钥对密文进行解密,恢复出原始消息
    int decrypted_length = RSA_private_decrypt(encrypted_length, encrypted, decrypted, rsa, RSA_PKCS1_OAEP_PADDING);
    if(decrypted_length == -1) {
        handle_errors();
    }

    printf("解密成功!解密后的信息: %s\n", decrypted);

    //第四步,接收方使用发送方的公钥对解密后的消息进行签名验证,确认消息的完整性和真实性
    int verified = verify_signature(rsa, message, signature, sig_len);
    if (verified) {
        printf("签名认证成功\n");
    } else {
        printf("签名认证失败\n");
    }

    free(signature);
    RSA_free(rsa);
}

int main() {
    OpenSSL_add_all_algorithms();
    ERR_load_BIO_strings();
    ERR_load_crypto_strings();

    rsa_operations();

    return 0;
}

编译和运行

使用以下代码进行编译&运行:

gcc rsa_XXX.c -lssl -lcrypto
./a.out

 场景3运行结果:

  • 24
    点赞
  • 18
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值