Können Sie mir helfen, meinen Kopf um openssl public key-Verschlüsselung mit rsa.h in c++?

Sollten Sie tatsächlich mit dem höheren "Envelope Encryption" - Funktionen von openssl/evp.h eher als die low-level-RSA-Funktionen direkt. Diese machen den Großteil der Arbeit für Sie und meinen Sie nicht das Rad neu zu erfinden.

In diesem Fall, die Sie verwenden würden, die EVP_SealInit(), EVP_SealUpdate() und EVP_SealFinal() Funktionen. Die Entschlüsselung Funktionen sind EVP_OpenInit(), EVP_OpenUpdate() und EVP_OpenFinal(). Ich würde vorschlagen, mit EVP_aes_128_cbc() als der Wert der Ziffer-type-parameter.

Sobald der öffentliche Schlüssel geladen in ein RSA * Griff, Sie verwenden EVP_PKEY_assign_RSA() steckte es in eine EVP_PKEY * Griff für die GD-Funktionen.

Sobald Sie haben das vor sich geht, zu lösen die Authentifizierung problem, das ich bereits in meinem Kommentar, müssen Sie etabliert eine Vertrauenswürdige Autorität ("Trient"). Trents öffentlichen Schlüssel bekannt ist auf alle Nutzer verteilt, die mit der Anwendung oder ähnliches - nur laden Sie es aus einer PEM-Datei). Statt Austausch bare RSA-Parameter, die Alice und Bob austauschen x509-Zertifikate, die Ihre RSA-public-keys zusammen mit Ihrem Namen und signiert von Trent. Alice und Bob dann überprüfen Sie das Zertifikat Sie erhalten von den anderen (mit Trents öffentlichen Schlüssel, die Sie bereits kennen), einschließlich der Prüfung, dass die damit verbundenen Namen der richtige ist, bevor Sie fortfahren das Protokoll. OpenSSL beinhaltet Funktionen zum laden und überprüfen der Zertifikate in der x509.h header.

Hier ist ein Beispiel, wie EVP_Seal*() um eine Datei zu verschlüsseln gegeben, dem öffentlichen Schlüssel des Empfängers. Es nimmt die PEM RSA-Public-Key-Datei (ie erwirtschaftet openssl rsa -pubout) als Befehlszeile argument, liest die Quelldaten von stdin und schreibt die verschlüsselten Daten auf stdout. Zum entschlüsseln verwenden Sie EVP_Open*() statt, und PEM_read_RSAPrivateKey() zu Lesen, einen privaten Schlüssel und nicht als öffentlichen Schlüssel.

Es ist nicht wirklich schwer und sicherlich weniger fehleranfällig als Unordnung zu erzeugen Polsterung, IVs und so auf sich selbst (das Siegel-Funktion funktioniert sowohl für die RSA-und AES-Teile der deal). Trotzdem, der code:

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

Den code, den Sie gepostet haben zeigt schön, warum sollte man den höher-level-Funktionen - Sie verliebt habe in ein paar Fallstricke:

• rand() ist mit Nachdruck nicht einen kryptographisch starken Zufallszahlengenerator! Erstellung Ihrer symmetrischen Schlüssel mit rand() ist genug, um das ganze system völlig unsicher. (Die EVP_*() Funktionen erzeugen die erforderlichen Zufallszahlen selbst, mit einem kryptografisch starken RNG, ausgesät aus einer entsprechenden Entropie-Quelle).

• Werden Sie durch die IV für CFB-Modus auf einen festen Wert (null). Dies negiert jeden Vorteil bei der Verwendung von CFB-Modus in den ersten Platz (sodass Angreifer trivial durchzuführen, block-Ersatz-Angriffe und schlechter). (Die EVP_*() Funktionen erzeugen einen entsprechenden IV für Sie, wenn es nötig ist).

• RSA_PKCS1_OAEP_PADDING sollte verwendet werden, wenn Sie die Definition eines neuen Protokolls, sondern als Interaktion mit einem bestehenden Protokoll.

Den entsprechenden Entschlüsselungs-code für die Nachwelt:

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

InformationsquelleAutor

Schreibe ich zwei Beispiele um CAF-code. Sie sind stark modifiziert und verwendet OpenSSL ist BIO container für mehr Abstraktion.

Einem Beispiel verwendet eine Datei als Eingabe und das andere Beispiel verwendet einen string-Puffer. Es nutzt RSA und DES jedoch können Sie leicht ändern Sie es aus dem code. Kompilieren der Anweisungen im code. Ich brauchte ein Beispiel, ich hoffe, jemand findet das nützlich. Ich bemerkte auch den code. Sie können es von hier:

Nehmen Datei als input:
https://github.com/farslan/snippets/blob/master/hybrid_file.c

Nehmen string-Puffer als input:
https://github.com/farslan/snippets/blob/master/hybrid_data.c

InformationsquelleAutor