openssl+ RSA + linux 签名校验开发实例（C++）

一、RSA签名校验

RSA签名校验是一种用于验证数字签名的过程，它确保签名是由拥有相应私钥的合法实体创建的。以下是RSA签名校验的理论知识点：

1. RSA密钥对： RSA签名使用一对公钥和私钥。公钥用于验证签名，私钥用于创建签名。

2. 数字签名过程：

   • 消息哈希： 对要签名的消息进行哈希运算，通常使用SHA-256等哈希算法，以确保消息的唯一性和完整性。
   • 私钥签名： 使用私钥对消息的哈希值进行加密，形成数字签名。

3. 数字签名校验过程：

   • 消息哈希： 接收到签名后，对原始消息进行相同的哈希运算，得到消息的哈希值。
   • 公钥验证： 使用签名者的公钥对数字签名进行解密，得到解密后的哈希值。
   • 比较哈希值： 将解密后的哈希值与原始消息的哈希值进行比较。如果相同，则签名验证通过，否则失败。

4. RSA签名验证的数学基础：

   • RSA签名验证的关键是使用签名者的公钥进行解密。只有持有相应私钥的实体才能正确地对消息进行签名。
   • RSA的安全性基于大整数分解问题的难解性。在没有私钥的情况下，从签名中分解出原始哈希值的难度使得其他实体无法伪造合法的签名。

5. 填充方案： 在实际应用中，为增加安全性，通常使用填充方案对消息进行填充。常见的填充方案包括PKCS#1 v1.5和OAEP。

6. 常见错误：

   • 签名长度： 确保签名长度与RSA密钥长度相匹配。签名长度超过密钥长度时可能导致验证失败。
   • 密钥匹配： 使用正确的公钥进行验证，确保公钥和私钥匹配。

7. 安全性注意事项：

   • 使用足够长的RSA密钥长度，通常建议使用2048位或更长的密钥。
   • 定期更新密钥对，以防止安全性降低。

理解以上理论知识有助于正确实现和使用RSA签名，并在应用中确保数据的安全性和完整性。

二、RSA签名校验开发实例

下面是一个简单的示例，演示如何使用OpenSSL库在Linux环境下进行RSA签名和验证。在这个示例中，我们使用PEM格式的密钥对进行签名和验证。

#include 
#include 
#include 
#include 

// 用于读取PEM格式的私钥文件
RSA* readPrivateKey(const char* privateKeyFile) {
    FILE* file = fopen(privateKeyFile, "r");
    if (!file) {
        perror("Error opening private key file");
        return nullptr;
    }

    RSA* rsa = PEM_read_RSAPrivateKey(file, nullptr, nullptr, nullptr);
    fclose(file);

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

    return rsa;
}

// 对消息进行RSA签名
bool signMessage(const char* message, RSA* privateKey, unsigned char* signature, unsigned int* signatureLength) {
    EVP_PKEY* pkey = EVP_PKEY_new();
    EVP_PKEY_set1_RSA(pkey, privateKey);

    EVP_MD_CTX* ctx = EVP_MD_CTX_new();
    if (!ctx) {
        perror("Error creating context");
        EVP_PKEY_free(pkey);
        return false;
    }

    if (EVP_DigestSignInit(ctx, nullptr, EVP_sha256(), nullptr, pkey) != 1) {
        perror("Error initializing sign context");
        EVP_MD_CTX_free(ctx);
        EVP_PKEY_free(pkey);
        return false;
    }

    if (EVP_DigestSignUpdate(ctx, message, strlen(message)) != 1) {
        perror("Error updating sign context");
        EVP_MD_CTX_free(ctx);
        EVP_PKEY_free(pkey);
        return false;
    }

    if (EVP_DigestSignFinal(ctx, signature, signatureLength) != 1) {
        perror("Error finalizing sign context");
        EVP_MD_CTX_free(ctx);
        EVP_PKEY_free(pkey);
        return false;
    }

    EVP_MD_CTX_free(ctx);
    EVP_PKEY_free(pkey);

    return true;
}

// 验证RSA签名
bool verifySignature(const char* message, RSA* publicKey, const unsigned char* signature, unsigned int signatureLength) {
    EVP_PKEY* pkey = EVP_PKEY_new();
    EVP_PKEY_set1_RSA(pkey, publicKey);

    EVP_MD_CTX* ctx = EVP_MD_CTX_new();
    if (!ctx) {
        perror("Error creating context");
        EVP_PKEY_free(pkey);
        return false;
    }

    if (EVP_DigestVerifyInit(ctx, nullptr, EVP_sha256(), nullptr, pkey) != 1) {
        perror("Error initializing verify context");
        EVP_MD_CTX_free(ctx);
        EVP_PKEY_free(pkey);
        return false;
    }

    if (EVP_DigestVerifyUpdate(ctx, message, strlen(message)) != 1) {
        perror("Error updating verify context");
        EVP_MD_CTX_free(ctx);
        EVP_PKEY_free(pkey);
        return false;
    }

    int result = EVP_DigestVerifyFinal(ctx, signature, signatureLength);
    EVP_MD_CTX_free(ctx);
    EVP_PKEY_free(pkey);

    return (result == 1);
}

int main() {
    // 读取私钥
    const char* privateKeyFile = "private_key.pem";
    RSA* privateKey = readPrivateKey(privateKeyFile);
    if (!privateKey) {
        std::cerr << "Error loading private key" << std::endl;
        return 1;
    }

    // 待签名的消息
    const char* message = "Hello, RSA!";

    // 计算签名
    unsigned char signature[2048];  // 2048是RSA密钥长度
    unsigned int signatureLength;

    if (signMessage(message, privateKey, signature, &signatureLength)) {
        std::cout << "Signature created successfully" << std::endl;
    } else {
        std::cerr << "Error creating signature" << std::endl;
        RSA_free(privateKey);
        return 1;
    }

    // 读取公钥
    const char* publicKeyFile = "public_key.pem";
    RSA* publicKey = readPrivateKey(publicKeyFile);
    if (!publicKey) {
        std::cerr << "Error loading public key" << std::endl;
        RSA_free(privateKey);
        return 1;
    }

    // 验证签名
    if (verifySignature(message, publicKey, signature, signatureLength)) {
        std::cout << "Signature verified successfully" << std::endl;
    } else {
        std::cerr << "Error verifying signature" << std::endl;
    }

    // 释放资源
    RSA_free(privateKey);
    RSA_free(publicKey);

    return 0;
}

确保替换 private_key.pem 和 public_key.pem 为实际的私钥和公钥文件。这个示例中包含了签名和验证两个步骤。签名的结果可以被验证，以确保消息的完整性和真实性。