使用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进行消息签名和验证。

Alice生成密钥对：

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

Alice签名消息：

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

Bob验证签名：

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

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

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

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

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

1. 单独使用RSA加密

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

步骤：

密钥生成：接收方生成一对RSA密钥对（公钥和私钥）。
公钥分发：接收方将公钥分发给发送方。
消息加密：
- 发送方使用接收方的公钥对消息进行加密。
- 发送方将加密后的消息发送给接收方。
消息解密：
- 接收方使用自己的私钥对加密的消息进行解密，恢复原始消息

2. 单独使用RSA消息验证（数字签名）

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

步骤：

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

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

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

步骤：

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

实践仿真

接下来就使用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;
}