你能幫我用c ++中的rsa.h來解決openssl公鑰加密問題嗎？

Question

我試圖在C ++中使用rsa的openssl實現來解決公鑰加密問題。 你能幫我嗎？ 到目前為止，這些是我的想法（請在必要時更正）

1. Alice通過網絡連接到Bob
2. Alice和Bob希望進行安全通信
3. Alice生成公鑰/私鑰對，並將公鑰發送給Bob
4. Bob接收公鑰並使用公鑰加密隨機生成的對稱密碼密鑰（例如，河豚）並將結果發送給Alice
5. Alice用最初生成的私鑰解密密文，並獲得對稱的河豚鍵
6. Alice和Bob現在都具有對稱河豚鍵的知識，並且可以建立安全的通信渠道

現在，我已經查看了openssl / rsa.h rsa實現（因為我已經有了openssl / blowfish.h的實際經驗），我看到了這兩個函數：

int RSA_public_encrypt(int flen, unsigned char *from,
unsigned char *to, RSA *rsa, int padding);
int RSA_private_decrypt(int flen, unsigned char *from,
 unsigned char *to, RSA *rsa, int padding);

如果Alice要生成* rsa，那么它如何產生rsa密鑰對？ 是否有類似rsa_public和rsa_private的東西來自rsa？ * rsa是否包含公鑰和私鑰，上述功能會根據是否需要公鑰或私鑰來自動刪除必要的密鑰？ 應該生成兩個唯一的* rsa指針，實際上，我們有以下內容：

int RSA_public_encrypt(int flen, unsigned char *from,
unsigned char *to, RSA *rsa_public, int padding);
int RSA_private_decrypt(int flen, unsigned char *from,
 unsigned char *to, RSA *rsa_private, int padding);

其次，* rsa公鑰應該以什么格式發送給Bob？ 是否必須將其重新解釋為字符數組然后以標准方式發送？ 我聽說過證書 - 它們與它有什么關系嗎？

抱歉，所有的問題，祝福，本。

編輯：Coe我目前正在雇用：

/*
 *  theEncryptor.cpp
 *  
 *
 *  Created by ben on 14/01/2010.
 *  Copyright 2010 __MyCompanyName__. All rights reserved.
 *
 */

#include "theEncryptor.h"
#include <iostream>
#include <sys/socket.h>
#include <sstream>

theEncryptor::theEncryptor()
{

}

void
theEncryptor::blowfish(unsigned char *data, int data_len, unsigned char* key, int enc)
{

    //  hash the key first! 
    unsigned char obuf[20];
    bzero(obuf,20);
    SHA1((const unsigned char*)key, 64, obuf);

    BF_KEY bfkey;
    int keySize = 16;//strlen((char*)key);
    BF_set_key(&bfkey, keySize, obuf);

    unsigned char ivec[16];
    memset(ivec, 0, 16);

    unsigned char* out=(unsigned char*) malloc(data_len);
    bzero(out,data_len);
    int num = 0;
    BF_cfb64_encrypt(data, out, data_len, &bfkey, ivec, &num, enc);

    //for(int i = 0;i<data_len;i++)data[i]=out[i];

    memcpy(data, out, data_len);
    free(out);  

}

void
theEncryptor::generateRSAKeyPair(int bits)
{
    rsa = RSA_generate_key(bits, 65537, NULL, NULL);
}


int
theEncryptor::publicEncrypt(unsigned char* data, unsigned char* dataEncrypted,int dataLen)
{   
    return RSA_public_encrypt(dataLen, data, dataEncrypted, rsa, RSA_PKCS1_OAEP_PADDING);   
}

int
theEncryptor::privateDecrypt(unsigned char* dataEncrypted,
                             unsigned char* dataDecrypted)
{
    return RSA_private_decrypt(RSA_size(rsa), dataEncrypted, 
                                   dataDecrypted, rsa, RSA_PKCS1_OAEP_PADDING);
}

void 
theEncryptor::receivePublicKeyAndSetRSA(int sock, int bits)
{
    int max_hex_size = (bits / 4) + 1;
    char keybufA[max_hex_size];
    bzero(keybufA,max_hex_size);
    char keybufB[max_hex_size];
    bzero(keybufB,max_hex_size);
    int n = recv(sock,keybufA,max_hex_size,0); 
    n = send(sock,"OK",2,0);
    n = recv(sock,keybufB,max_hex_size,0); 
    n = send(sock,"OK",2,0); 
    rsa = RSA_new();
    BN_hex2bn(&rsa->n, keybufA);
    BN_hex2bn(&rsa->e, keybufB);
}

void 
theEncryptor::transmitPublicKey(int sock, int bits)
{
    const int max_hex_size = (bits / 4) + 1;
    long size = max_hex_size;
    char keyBufferA[size];
    char keyBufferB[size];
    bzero(keyBufferA,size);
    bzero(keyBufferB,size);
    sprintf(keyBufferA,"%s\r\n",BN_bn2hex(rsa->n));
    sprintf(keyBufferB,"%s\r\n",BN_bn2hex(rsa->e));
    int n = send(sock,keyBufferA,size,0);
    char recBuf[2];
    n = recv(sock,recBuf,2,0);
    n = send(sock,keyBufferB,size,0);
    n = recv(sock,recBuf,2,0);
}

void
theEncryptor::generateRandomBlowfishKey(unsigned char* key, int bytes)
{
            /*
    srand( (unsigned)time( NULL ) );
    std::ostringstream stm;
    for(int i = 0;i<bytes;i++){
        int randomValue = 65 + rand()% 26;
        stm << (char)((int)randomValue);
    }
    std::string str(stm.str());
    const char* strs = str.c_str();
    for(int i = 0;bytes;i++)key[i]=strs[i];
            */

    int n = RAND_bytes(key, bytes);

    if(n==0)std::cout<<"Warning key was generated with bad entropy. You should not consider communication to be secure"<<std::endl;

}

theEncryptor::~theEncryptor(){}

Answer 1

您實際上應該使用openssl/evp.h的更高級別的“Envelope Encryption”函數，而不是直接使用低級RSA函數。 這些為您完成大部分工作，並且意味着您不必重新發明輪子。

在這種情況下，您將使用EVP_SealInit() ， EVP_SealUpdate()和EVP_SealFinal()函數。 相應的解密函數是EVP_OpenInit() ， EVP_OpenUpdate()和EVP_OpenFinal() 。 我建議使用EVP_aes_128_cbc()作為密碼類型參數的值。

將公鑰加載到RSA *句柄后，可以使用EVP_PKEY_assign_RSA()將其放入EVP函數的EVP_PKEY *句柄中。

一旦你完成了這個，為了解決我在評論中提到的身份驗證問題，你需要建立一個可信任的權限（“Trent”）。 Trent的公鑰是所有用戶都知道的（與應用程序或類似的一起分發 - 只需從PEM文件加載它）。 Alice和Bob不再交換裸RSA參數，而是交換包含其RSA公鑰及其名稱的x509證書，並由Trent簽名。 然后，Alice和Bob各自驗證他們從另一方獲得的證書（使用Trent的公鑰，他們已經知道），包括在繼續協議之前檢查相關名稱是否正確。 OpenSSL包括用於加載和驗證x509.h標頭中的證書的x509.h 。

---

這是一個如何使用EVP_Seal*()加密給定收件人公鑰的文件的示例。 它將PEM RSA公鑰文件（即由openssl rsa -pubout生成）作為命令行參數，從stdin讀取源數據並將加密數據寫入stdout。 要解密，請改用EVP_Open*()和PEM_read_RSAPrivateKey()來讀取私鑰而不是公鑰。

它並不是那么難 - 當然也不會比自己生成填充，IV等等更容易出錯（Seal函數同時執行交易的RSA和AES部分）。 無論如何，代碼：

#include <stdio.h>
#include <stdlib.h>

#include <openssl/evp.h>
#include <openssl/pem.h>
#include <openssl/rsa.h>
#include <openssl/err.h>

#include <arpa/inet.h> /* For htonl() */

int do_evp_seal(FILE *rsa_pkey_file, FILE *in_file, FILE *out_file)
{
    int retval = 0;
    RSA *rsa_pkey = NULL;
    EVP_PKEY *pkey = EVP_PKEY_new();
    EVP_CIPHER_CTX ctx;
    unsigned char buffer[4096];
    unsigned char buffer_out[4096 + EVP_MAX_IV_LENGTH];
    size_t len;
    int len_out;
    unsigned char *ek;
    int eklen;
    uint32_t eklen_n;
    unsigned char iv[EVP_MAX_IV_LENGTH];

    if (!PEM_read_RSA_PUBKEY(rsa_pkey_file, &rsa_pkey, NULL, NULL))
    {
        fprintf(stderr, "Error loading RSA Public Key File.\n");
        ERR_print_errors_fp(stderr);
        retval = 2;
        goto out;
    }

    if (!EVP_PKEY_assign_RSA(pkey, rsa_pkey))
    {
        fprintf(stderr, "EVP_PKEY_assign_RSA: failed.\n");
        retval = 3;
        goto out;
    }

    EVP_CIPHER_CTX_init(&ctx);
    ek = malloc(EVP_PKEY_size(pkey));

    if (!EVP_SealInit(&ctx, EVP_aes_128_cbc(), &ek, &eklen, iv, &pkey, 1))
    {
        fprintf(stderr, "EVP_SealInit: failed.\n");
        retval = 3;
        goto out_free;
    }

    /* First we write out the encrypted key length, then the encrypted key,
     * then the iv (the IV length is fixed by the cipher we have chosen).
     */

    eklen_n = htonl(eklen);
    if (fwrite(&eklen_n, sizeof eklen_n, 1, out_file) != 1)
    {
        perror("output file");
        retval = 5;
        goto out_free;
    }
    if (fwrite(ek, eklen, 1, out_file) != 1)
    {
        perror("output file");
        retval = 5;
        goto out_free;
    }
    if (fwrite(iv, EVP_CIPHER_iv_length(EVP_aes_128_cbc()), 1, out_file) != 1)
    {
        perror("output file");
        retval = 5;
        goto out_free;
    }

    /* Now we process the input file and write the encrypted data to the
     * output file. */

    while ((len = fread(buffer, 1, sizeof buffer, in_file)) > 0)
    {
        if (!EVP_SealUpdate(&ctx, buffer_out, &len_out, buffer, len))
        {
            fprintf(stderr, "EVP_SealUpdate: failed.\n");
            retval = 3;
            goto out_free;
        }

        if (fwrite(buffer_out, len_out, 1, out_file) != 1)
        {
            perror("output file");
            retval = 5;
            goto out_free;
        }
    }

    if (ferror(in_file))
    {
        perror("input file");
        retval = 4;
        goto out_free;
    }

    if (!EVP_SealFinal(&ctx, buffer_out, &len_out))
    {
        fprintf(stderr, "EVP_SealFinal: failed.\n");
        retval = 3;
        goto out_free;
    }

    if (fwrite(buffer_out, len_out, 1, out_file) != 1)
    {
        perror("output file");
        retval = 5;
        goto out_free;
    }

    out_free:
    EVP_PKEY_free(pkey);
    free(ek);

    out:
    return retval;
}

int main(int argc, char *argv[])
{
    FILE *rsa_pkey_file;
    int rv;

    if (argc < 2)
    {
        fprintf(stderr, "Usage: %s <PEM RSA Public Key File>\n", argv[0]);
        exit(1);
    }

    rsa_pkey_file = fopen(argv[1], "rb");
    if (!rsa_pkey_file)
    {
        perror(argv[1]);
        fprintf(stderr, "Error loading PEM RSA Public Key File.\n");
        exit(2);
    }

    rv = do_evp_seal(rsa_pkey_file, stdin, stdout);

    fclose(rsa_pkey_file);
    return rv;
}

---

您發布的代碼很好地說明了為什么您應該使用更高級別的函數 - 您陷入了一些陷阱：

• rand()強調的不是加密強大的隨機數生成器！ 使用rand()生成對稱密鑰足以使整個系統完全不安全。 （ EVP_*()函數自身生成必要的隨機數，使用加密強RNG，從適當的熵源播種）。

• 您正在將CFB模式的IV設置為固定值（零）。 這首先否定了使用CFB模式的任何優勢（允許攻擊者輕易地執行塊替換攻擊，甚至更糟）。 （ EVP_*()函數在需要時為您生成適當的IV）。

• 如果您要定義新協議，而不是與現有協議進行互操作，則應使用RSA_PKCS1_OAEP_PADDING 。

---

相應的解密代碼，為子孫后代：

#include <stdio.h>
#include <stdlib.h>

#include <openssl/evp.h>
#include <openssl/pem.h>
#include <openssl/rsa.h>
#include <openssl/err.h>

#include <arpa/inet.h> /* For htonl() */

int do_evp_unseal(FILE *rsa_pkey_file, FILE *in_file, FILE *out_file)
{
    int retval = 0;
    RSA *rsa_pkey = NULL;
    EVP_PKEY *pkey = EVP_PKEY_new();
    EVP_CIPHER_CTX ctx;
    unsigned char buffer[4096];
    unsigned char buffer_out[4096 + EVP_MAX_IV_LENGTH];
    size_t len;
    int len_out;
    unsigned char *ek;
    unsigned int eklen;
    uint32_t eklen_n;
    unsigned char iv[EVP_MAX_IV_LENGTH];

    if (!PEM_read_RSAPrivateKey(rsa_pkey_file, &rsa_pkey, NULL, NULL))
    {
        fprintf(stderr, "Error loading RSA Private Key File.\n");
        ERR_print_errors_fp(stderr);
        retval = 2;
        goto out;
    }

    if (!EVP_PKEY_assign_RSA(pkey, rsa_pkey))
    {
        fprintf(stderr, "EVP_PKEY_assign_RSA: failed.\n");
        retval = 3;
        goto out;
    }

    EVP_CIPHER_CTX_init(&ctx);
    ek = malloc(EVP_PKEY_size(pkey));

    /* First need to fetch the encrypted key length, encrypted key and IV */

    if (fread(&eklen_n, sizeof eklen_n, 1, in_file) != 1)
    {
        perror("input file");
        retval = 4;
        goto out_free;
    }
    eklen = ntohl(eklen_n);
    if (eklen > EVP_PKEY_size(pkey))
    {
        fprintf(stderr, "Bad encrypted key length (%u > %d)\n", eklen,
            EVP_PKEY_size(pkey));
        retval = 4;
        goto out_free;
    }
    if (fread(ek, eklen, 1, in_file) != 1)
    {
        perror("input file");
        retval = 4;
        goto out_free;
    }
    if (fread(iv, EVP_CIPHER_iv_length(EVP_aes_128_cbc()), 1, in_file) != 1)
    {
        perror("input file");
        retval = 4;
        goto out_free;
    }

    if (!EVP_OpenInit(&ctx, EVP_aes_128_cbc(), ek, eklen, iv, pkey))
    {
        fprintf(stderr, "EVP_OpenInit: failed.\n");
        retval = 3;
        goto out_free;
    }

    while ((len = fread(buffer, 1, sizeof buffer, in_file)) > 0)
    {
        if (!EVP_OpenUpdate(&ctx, buffer_out, &len_out, buffer, len))
        {
            fprintf(stderr, "EVP_OpenUpdate: failed.\n");
            retval = 3;
            goto out_free;
        }

        if (fwrite(buffer_out, len_out, 1, out_file) != 1)
        {
            perror("output file");
            retval = 5;
            goto out_free;
        }
    }

    if (ferror(in_file))
    {
        perror("input file");
        retval = 4;
        goto out_free;
    }

    if (!EVP_OpenFinal(&ctx, buffer_out, &len_out))
    {
        fprintf(stderr, "EVP_OpenFinal: failed.\n");
        retval = 3;
        goto out_free;
    }

    if (fwrite(buffer_out, len_out, 1, out_file) != 1)
    {
        perror("output file");
        retval = 5;
        goto out_free;
    }

    out_free:
    EVP_PKEY_free(pkey);
    free(ek);

    out:
    return retval;
}

int main(int argc, char *argv[])
{
    FILE *rsa_pkey_file;
    int rv;

    if (argc < 2)
    {
        fprintf(stderr, "Usage: %s <PEM RSA Private Key File>\n", argv[0]);
        exit(1);
    }

    rsa_pkey_file = fopen(argv[1], "rb");
    if (!rsa_pkey_file)
    {
        perror(argv[1]);
        fprintf(stderr, "Error loading PEM RSA Private Key File.\n");
        exit(2);
    }

    rv = do_evp_unseal(rsa_pkey_file, stdin, stdout);

    fclose(rsa_pkey_file);
    return rv;
}

Answer 2

我圍繞CAF的代碼寫了兩個例子 。 它們經過了大量修改，並使用OpenSSL的BIO容器來實現更多抽象。

一個示例使用文件作為輸入，另一個示例使用字符串緩沖區。 它使用RSA和DES ，但您可以從代碼中輕松更改它。 編譯指令在代碼中。 我需要一個有效的例子，我希望有人覺得這很有用。 我還評論了代碼。 你可以從這里得到它：

將文件作為輸入： https ： //github.com/farslan/snippets/blob/master/hybrid_file.c

將字符串緩沖區作為輸入： https ： //github.com/farslan/snippets/blob/master/hybrid_data.c

Answer 3

謝謝@Caf。 你的帖子有幫助。 但是我得到了

程序'[7056] Encryption2.exe：Native'已退出，代碼為-1073741811（0xc000000d）

  PEM_read_RSA_PUBKEY(rsa_pkey_file, &rsa_pkey, NULL, NULL)

我換了

BIO *bio;
X509 *certificate;

bio = BIO_new(BIO_s_mem());
BIO_puts(bio, (const char*)data);
certificate = PEM_read_bio_X509(bio, NULL, NULL, NULL);
EVP_PKEY *pubkey = X509_get_pubkey (certificate);
rsa_pkey = EVP_PKEY_get1_RSA(pubkey);

數據具有僅具有公鑰的PEM文件。 我的挑戰是用C ++加密和用java解密。 我傳輸了大小為eklen的base64編碼ek（我沒有使用eklen_n）並使用RSA私鑰解密以獲取AES密鑰。 然后我使用此AES密鑰解密密碼文件。 它工作正常。

Answer 4

實際上，沒問題，我剛剛讀到，基本上，RSA對象是一個包含公共和私有字段的結構。 可以提取公共字段數據並僅將其發送給Bob。

即基本上，要從rsa中提取公共字段並將它們存儲在兩個不同的緩沖區（可以是char數組，然后可以發送給Bob）中，您可以：

sprintf(keyBufferA,"%s\r\n",BN_bn2hex(rsa->n));
sprintf(keyBufferB,"%s\r\n",BN_bn2hex(rsa->e));

然后Bob在接收端重建如下：

rsa = RSA_new();
BN_hex2bn(&rsa->n, keybufA);
BN_hex2bn(&rsa->e, keybufB);

然后Bob可以使用rsa *公開加密對稱密碼密鑰，然后可以將其發送給Alice。 然后Alice可以使用私鑰解密

本。