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

openssl

传输层安全性/安全套接层及其加密库

项目地址：https://gitcode.com/gh_mirrors/ope/openssl

免费下载资源

mjmmm

2289人浏览 · 2024-05-29 18:46:00

mjmmm · 2024-05-29 18:46:00 发布

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;
}

编译和运行

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

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

场景3运行结果：

GitHub 加速计划 / ope / openssl

25.12 K

9.99 K

下载

传输层安全性/安全套接层及其加密库

最近提交(Master分支：1 个月前 )

fd39d1c8 Reviewed-by: Tomas Mraz <tomas@openssl.org> Reviewed-by: Shane Lontis <shane.lontis@oracle.com> (Merged from https://github.com/openssl/openssl/pull/25095) 2 个月前

ae87c488 Reviewed-by: Tomas Mraz <tomas@openssl.org> Reviewed-by: Shane Lontis <shane.lontis@oracle.com> (Merged from https://github.com/openssl/openssl/pull/25095) 2 个月前

GitCode 开源社区

旨在为数千万中国开发者提供一个无缝且高效的云端环境，以支持学习、使用和贡献开源项目。

更多推荐

[转载]在Windows环境下安装GNU Radio

转自：在Windows环境下安装GNURadio_恐弱智_新浪博客GNU Radio是用Python开发的，大部分开源的工程能够在Linux环境下运行良好，而Windows下却运行的很勉强，而且安装配置都很复杂。GNU Radio算是个例外了，不光提供了Windows的二进制安装，还有比较详细的说明。我是Python小白，所以折腾了好久才弄好，特意记录下来，免得以后再装还折腾。GNU Radio的

GitCode 开源社区

centOS 8 使用dnf安装Docker

DNF是什么？CentOS 8使用YUM软件包管理器版本v4.0.4。现在，该版本使用DNF(已删除YUM)。DNF是软件包管理器。它会在Linux发行版上安装，执行更新并删除软件包。使用DNF安装Docker跳过具有损坏依赖性的程序包一个有效的解决方案是使您的CentOS 8系统使用以下--nobest命令安装最符合条件的版本：sudo dnf install docker...

GitCode 开源社区

定时同步数据库表(mysql+linux+crontab)

sync.sh里面的参数需要改变，ip/username/password/database/tablesync.sh#!/bin/sh# Please change the IP and password of the data source db.# Then change the table name.filename=/home/nington/db/$(date +%Y-%m

GitCode 开源社区

所有评论(0)

查看更多评论

mjmmm

@mjmmm

已为社区贡献2条内容

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

mjmmm

RSA密钥对生成

RSA加密/解密步骤

加密

解密

RSA消息验证步骤

签名

验证

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

1. 单独使用RSA加密

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

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

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

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

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

相关函数认识

密钥对生成相关API

加密/解密API

签名/认证API

BIO的概念和相关API

创建和释放 BIO 结构

读写操作

公钥/私钥的读取/写入（打印）

实践仿真

场景1实现

场景2实现

场景3实现

编译和运行

场景3运行结果：

所有评论(0)

mjmmm

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

mjmmm

RSA密钥对生成

RSA加密/解密步骤

加密

解密

RSA消息验证步骤

签名

验证

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

1. 单独使用RSA加密

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

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

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

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

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

相关函数认识

密钥对生成相关API

加密/解密API

签名/认证API

BIO的概念和相关API

创建和释放 BIO 结构

读写操作

公钥/私钥的读取/写入（打印）

实践仿真

场景1实现

场景2实现

场景3实现

编译和运行

场景3运行结果：

所有评论(0)

mjmmm

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