技術文章 » 20.2 OpenSSL 非對稱RSA加解密演演算法

20.2 OpenSSL 非對稱RSA加解密演演算法

2023-10-29 12:00:31

RSA演演算法是一種非對稱加密演演算法，由三位數學家Rivest、Shamir和Adleman共同發明，以他們三人的名字首字母命名。RSA演演算法的安全性基於大數分解問題，即對於一個非常大的合數，將其分解為兩個質數的乘積是非常困難的。

RSA演演算法是一種常用的非對稱加密演演算法，與對稱加密演演算法不同，RSA演演算法使用一對非對稱金鑰，分別為公鑰和私鑰，公鑰和私鑰是成對生成的，公鑰可以公開，用於加密資料和驗證數位簽章，而私鑰必須保密，用於解密資料和生成數位簽章。因此，RSA演演算法的使用場景是公鑰加密、私鑰解密，或者私鑰加密、公鑰解密。

OpenSSL庫中提供了針對此類演演算法的支援，但在使用時讀者需要自行生成公鑰與私鑰檔案，在開發工具包內有一個openssl.exe程式，該程式則是用於生成金鑰對的工具，當我們需要使用非對稱加密演演算法時，則可以使用如下命令生成公鑰和私鑰。

  • 生成私鑰: openssl genrsa -out rsa_private_key.pem 1024
  • 生成公鑰: openssl rsa -in rsa_private_key.pem -pubout -out rsa_public_key.pem

讀者執行上述兩條命令後即可得到rsa_private_key.pem私鑰，以及rsa_public_key.pem公鑰，如下圖所示；

在使用非對稱加密時，讀者需要分別匯入所需要的標頭檔案，這其中就包括了rsa.h用於處理加密演演算法的庫，以及pem.h用於處理私鑰的庫，這兩個庫是使用RSA時必須要匯入的。

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

extern "C"
{
#include <openssl/applink.c>
}

#pragma comment(lib,"libssl.lib")
#pragma comment(lib,"libcrypto.lib")

20.2.1 公鑰加密私鑰解密

RSA公鑰用於加密資料和驗證數位簽章，私鑰用於解密資料和生成數位簽章，通常用於公鑰加密、私鑰解密的場景，具有較高的安全性，但加密和解密速度較慢，因此通常採用一種混合加密方式，即使用RSA演演算法加密對稱加密演演算法中的金鑰，再使用對稱加密演演算法加密資料，以保證資料的機密性和加密解密的效率。

首先我們來實現公鑰加密功能，如下Public_RsaEncrypt函數，該函數接受兩個引數，分別是需要加密的字串以及公鑰檔案，程式碼中首先通過fopen()開啟一個公鑰檔案，並通過PEM_read_RSA_PUBKEY函數讀入並初始化公鑰檔案，接著呼叫RSA_public_encrypt該函數主要用於實現公鑰加密，當加密成功後返回加密後的文字內容，型別是字串。

// 公鑰加密
std::string Public_RsaEncrypt(const std::string& str, const std::string& path)
{
    RSA* rsa = NULL;
    FILE* file = NULL;
    char* ciphertext = NULL;
    int len = 0;
    int ret = 0;

    file = fopen(path.c_str(), "r");
    if (file == NULL)
    {
        return std::string();
    }

    rsa = PEM_read_RSA_PUBKEY(file, NULL, NULL, NULL);
    if (rsa == NULL)
    {
        ERR_print_errors_fp(stdout);
        fclose(file);
        return std::string();
    }

    len = RSA_size(rsa);
    ciphertext = (char*)malloc(len + 1);
    if (ciphertext == NULL)
    {
        RSA_free(rsa);
        fclose(file);
        return std::string();
    }
    memset(ciphertext, 0, len + 1);

    ret = RSA_public_encrypt(str.length(), (unsigned char*)str.c_str(), (unsigned char*)ciphertext, rsa, RSA_PKCS1_PADDING);
    if (ret < 0)
    {
        ERR_print_errors_fp(stdout);
        free(ciphertext);
        RSA_free(rsa);
        fclose(file);
        return std::string();
    }

    std::string s(ciphertext, ret);
    free(ciphertext);
    RSA_free(rsa);
    fclose(file);
    return s;
}

與公鑰加密方法類似，Private_RsaDecrypt函數用於使用私鑰進行解密，該函數接受兩個引數，第一個引數是加密後的字串資料，第二個引數則是私鑰的具體路徑，函數中通過PEM_read_RSAPrivateKey實現對私鑰的初始化，並通過RSA_private_decrypt函數來實現對特定字串的解密操作。

// 私鑰解密
std::string Private_RsaDecrypt(const std::string& str, const std::string& path)
{
    RSA* rsa = NULL;
    FILE* file = NULL;
    char* plaintext = NULL;
    int len = 0;
    int ret = 0;

    file = fopen(path.c_str(), "r");
    if (file == NULL)
    {
        return std::string();
    }

    rsa = PEM_read_RSAPrivateKey(file, NULL, NULL, NULL);
    if (rsa == NULL)
    {
        ERR_print_errors_fp(stdout);
        fclose(file);
        return std::string();
    }

    len = RSA_size(rsa);
    plaintext = (char*)malloc(len + 1);
    if (plaintext == NULL)
    {
        RSA_free(rsa);
        fclose(file);
        return std::string();
    }
    memset(plaintext, 0, len + 1);

    ret = RSA_private_decrypt(str.length(), (unsigned char*)str.c_str(), (unsigned char*)plaintext, rsa, RSA_PKCS1_PADDING);
    if (ret < 0)
    {
        ERR_print_errors_fp(stdout);
        free(plaintext);
        RSA_free(rsa);
        fclose(file);
        return std::string();
    }
    std::string s(plaintext, ret);

    free(plaintext);
    RSA_free(rsa);
    fclose(file);
    return s;
}

這兩段程式碼的呼叫也非常容易，如下程式碼片段則分別實現了對text字串的加密與解密功能，使用公鑰加密，使用私鑰解密。

int main(int argc, char* argv[])
{
  std::string text = "hello lyshark";

  // 公鑰加密
  std::string public_path = "d://rsa_public_key.pem";
  std::string encry = Public_RsaEncrypt(text, public_path);
  // std::cout << "加密後文字: " << encry << std::endl;

  // 私鑰解密
  std::string private_path = "d://rsa_private_key.pem";
  std::string decry = Private_RsaDecrypt(encry, private_path);
  std::cout << "解密後文字: " << decry << std::endl;

  system("pause");
  return 0;
}

這段程式碼輸出效果如下圖所示；

20.2.2 私鑰加密公鑰解密

在RSA演演算法中，私鑰加密公鑰解密並不是一種常見的使用方式，因為私鑰是用於簽名而不是加密的。通常的使用方式是，使用公鑰加密，私鑰解密，這樣可以保證資料的機密性，只有擁有私鑰的人才能解密資料，但在某些時候我們不得不將這個流程反過來，使用私鑰加密並使用公鑰解密。

私鑰加密的封裝程式碼如下所示，其中Private_RsaEncrypt用於實現私鑰加密，該函數同樣接受兩個引數，分別是待加密字串以及當前私鑰路徑，函數的核心部分是RSA_private_encrypt該函數可用於使用私鑰對資料進行加密。

// 私鑰加密
std::string Private_RsaEncrypt(const std::string& str, const std::string& path)
{
    RSA* rsa = NULL;
    FILE* file = NULL;
    char* ciphertext = NULL;
    int len = 0;
    int ret = 0;

    file = fopen(path.c_str(), "r");
    if (file == NULL)
    {
        return std::string();
    }
    rsa = PEM_read_RSAPrivateKey(file, NULL, NULL, NULL);

    if (rsa == NULL)
    {
        ERR_print_errors_fp(stdout);
        fclose(file);
        return std::string();
    }

    len = RSA_size(rsa);
    ciphertext = (char*)malloc(len + 1);
    if (ciphertext == NULL)
    {
        RSA_free(rsa);
        fclose(file);
        return std::string();
    }
    memset(ciphertext, 0, len + 1);

    ret = RSA_private_encrypt(str.length(), (unsigned char*)str.c_str(), (unsigned char*)ciphertext, rsa, RSA_PKCS1_PADDING);
    if (ret < 0)
    {
        ERR_print_errors_fp(stdout);
        free(ciphertext);
        RSA_free(rsa);
        fclose(file);
        return std::string();
    }

    std::string s(ciphertext, ret);
    free(ciphertext);
    RSA_free(rsa);
    fclose(file);
    return s;
}

公鑰解密的實現方法與加密完全一致，程式碼中Public_RsaDecrypt函數用於實現公鑰解密，其核心功能的實現依賴於RSA_public_decrypt這個關鍵函數。

// 公鑰解密
std::string Public_RsaDecrypt(const std::string& str, const std::string& path)
{
    RSA* rsa = NULL;
    FILE* file = NULL;
    char* plaintext = NULL;
    int len = 0;
    int ret = 0;

    file = fopen(path.c_str(), "r");
    if (file == NULL)
    {
        return std::string();
    }

    rsa = PEM_read_RSA_PUBKEY(file, NULL, NULL, NULL);
    if (rsa == NULL)
    {
        ERR_print_errors_fp(stdout);
        fclose(file);
        return std::string();
    }

    len = RSA_size(rsa);
    plaintext = (char*)malloc(len + 1);
    if (plaintext == NULL)
    {
        RSA_free(rsa);
        fclose(file);
        return std::string();
    }
    memset(plaintext, 0, len + 1);

    ret = RSA_public_decrypt(str.length(), (unsigned char*)str.c_str(), (unsigned char*)plaintext, rsa, RSA_PKCS1_PADDING);
    if (ret < 0)
    {
        ERR_print_errors_fp(stdout);
        free(plaintext);
        RSA_free(rsa);
        fclose(file);
        return std::string();
    }
    std::string s(plaintext, ret);

    free(plaintext);
    RSA_free(rsa);
    fclose(file);
    return s;
}

有了上述方法，那麼呼叫程式碼則變得很容易，如下所示，我們將text字串使用私鑰進行加密，並使用公鑰進行解密。

int main(int argc, char* argv[])
{
  std::string text = "hello lyshark";

  // 私鑰加密
  std::string private_path = "d://rsa_private_key.pem";
  std::string encry = Private_RsaEncrypt(text, private_path);
  // std::cout << "加密後文字: " << encry << std::endl;

  // 公鑰解密
  std::string public_path = "d://rsa_public_key.pem";
  std::string decry = Public_RsaDecrypt(encry, public_path);
  std::cout << "解密後文字:" << decry << std::endl;

  system("pause");
  return 0;
}

這段程式碼輸出效果如下圖所示；