module OpenSSL::PKey

Asymmetrische Public-Key-Algorithmen

Asymmetrische Public-Key-Algorithmen lösen das Problem der Einrichtung und des Austauschs von geheimen Schlüsseln zur Ver-/Entschlüsselung von Nachrichten. Der Schlüssel in einem solchen Algorithmus besteht aus zwei Teilen: einem Public Key, der an andere verteilt werden kann, und einem Private Key, der geheim bleiben muss.

Mit einem Public Key verschlüsselte Nachrichten können nur von Empfängern entschlüsselt werden, die im Besitz des zugehörigen Private Keys sind. Da asymmetrische Algorithmen erheblich langsamer als symmetrische Schlüsselalgorithmen sind (siehe OpenSSL::Cipher), werden sie oft verwendet, um einen symmetrischen Schlüssel zwischen zwei Parteien einzurichten, die im Besitz des Public Keys des jeweils anderen sind.

Asymmetrische Algorithmen bieten viele nützliche Funktionen, die in vielen verschiedenen Bereichen eingesetzt werden. Eine sehr häufige Anwendung ist die Erstellung und Validierung digitaler Signaturen. Zum Signieren eines Dokuments verwendet der Unterzeichner im Allgemeinen einen Message-Digest-Algorithmus (siehe OpenSSL::Digest), um eine Zusammenfassung des Dokuments zu berechnen, die dann mit dem Private Key verschlüsselt (d. h. signiert) wird. Jeder, der im Besitz des Public Keys ist, kann die Signatur dann verifizieren, indem er die Message-Digest-Zusammenfassung des Originaldokuments selbst berechnet, die Signatur mit dem Public Key des Unterzeichners entschlüsselt und das Ergebnis mit der zuvor berechneten Message-Digest-Zusammenfassung vergleicht. Die Signatur ist genau dann gültig, wenn die entschlüsselte Signatur mit dieser Message-Digest-Zusammenfassung übereinstimmt.

Das Modul PKey bietet Unterstützung für drei beliebte Public/Private-Key-Algorithmen

RSA (OpenSSL::PKey::RSA)
DSA (OpenSSL::PKey::DSA)
Elliptische Kurvenkryptographie (OpenSSL::PKey::EC)

Jede dieser Implementierungen ist tatsächlich eine Unterklasse der abstrakten Klasse PKey, die die Schnittstelle zur Unterstützung digitaler Signaturen in Form von PKey#sign und PKey#verify bietet.

Diffie-Hellman-Schlüsselaustausch

Schließlich bietet PKey auch OpenSSL::PKey::DH, eine Implementierung des Diffie-Hellman-Schlüsselaustauschprotokolls, das auf diskreten Logarithmen in endlichen Körpern basiert, derselben Grundlage, auf der DSA aufbaut. Das Diffie-Hellman-Protokoll kann verwendet werden, um (symmetrische) Schlüssel über unsichere Kanäle auszutauschen, ohne dass eine vorherige gemeinsame Kenntnis zwischen den teilnehmenden Parteien erforderlich ist. Da die Sicherheit von DH relativ lange „Public Keys“ (d. h. den Teil, der offen zwischen den Teilnehmern übertragen wird) erfordert, ist DH tendenziell ziemlich langsam. Wenn Sicherheit oder Geschwindigkeit Ihre Hauptanliegen sind, bietet OpenSSL::PKey::EC eine weitere Implementierung des Diffie-Hellman-Protokolls.

Constants

DHError: Alias für PKeyError. Vor Version 4.0.0 war dies eine Unterklasse von PKeyError.
DSAError: Alias für PKeyError. Vor Version 4.0.0 war dies eine Unterklasse von PKeyError.
ECError: Alias für PKeyError. Vor Version 4.0.0 war dies eine Unterklasse von PKeyError.
RSAError: Alias für PKeyError. Vor Version 4.0.0 war dies eine Unterklasse von PKeyError.

Öffentliche Klassenmethoden

OpenSSL::PKey.generate_key(algo_name [, options]) → pkey

OpenSSL::PKey.generate_key(pkey [, options]) → pkey

Source

static VALUE
ossl_pkey_s_generate_key(int argc, VALUE *argv, VALUE self)
{
    return pkey_generate(argc, argv, self, 0);
}

Erzeugt einen neuen Schlüssel (Paar).

Wenn ein String als erstes Argument übergeben wird, wird ein neuer zufälliger Schlüssel für den Algorithmus generiert, der durch den Namen angegeben wird, genau wie ::generate_parameters dies tut. Wenn stattdessen ein OpenSSL::PKey::PKey übergeben wird, wird ein neuer zufälliger Schlüssel für denselben Algorithmus wie der Schlüssel generiert, wobei die Parameter verwendet werden, die der Schlüssel enthält.

Siehe ::generate_parameters für Details zu options und dem übergebenen Block.

Beispiel

pkey_params = OpenSSL::PKey.generate_parameters("DSA", "dsa_paramgen_bits" => 2048)
pkey_params.priv_key #=> nil
pkey = OpenSSL::PKey.generate_key(pkey_params)
pkey.priv_key #=> #<OpenSSL::BN 6277...

OpenSSL::PKey.generate_parameters(algo_name [, options]) → pkey

Source

static VALUE
ossl_pkey_s_generate_parameters(int argc, VALUE *argv, VALUE self)
{
    return pkey_generate(argc, argv, self, 1);
}

Erzeugt neue Parameter für den Algorithmus. algo_name ist ein String, der den Algorithmus darstellt. Das optionale Argument options ist ein Hash, der die spezifischen Optionen für den Algorithmus angibt. Die Reihenfolge der Optionen kann wichtig sein.

Optional kann ein Block übergeben werden. Die Bedeutung der an den Block übergebenen Argumente variiert je nach Implementierung des Algorithmus. Der Block kann einmal oder mehrmals aufgerufen werden oder gar nicht aufgerufen werden.

Für die unterstützten Optionen siehe die Dokumentation des Dienstprogramms ‘openssl genpkey’.

Beispiel

pkey = OpenSSL::PKey.generate_parameters("DSA", "dsa_paramgen_bits" => 2048)
p pkey.p.num_bits #=> 2048

OpenSSL::PKey.new_raw_private_key(algo, string) → PKey

Source

static VALUE
ossl_pkey_new_raw_private_key(VALUE self, VALUE type, VALUE key)
{
    EVP_PKEY *pkey;
    size_t keylen;

    StringValue(key);
    keylen = RSTRING_LEN(key);

#ifdef OSSL_USE_PROVIDER
    pkey = EVP_PKEY_new_raw_private_key_ex(NULL, StringValueCStr(type), NULL,
                                           (unsigned char *)RSTRING_PTR(key),
                                           keylen);
    if (!pkey)
        ossl_raise(ePKeyError, "EVP_PKEY_new_raw_private_key_ex");
#else
    int pkey_id = lookup_pkey_type(type);
    pkey = EVP_PKEY_new_raw_private_key(pkey_id, NULL, (unsigned char *)RSTRING_PTR(key), keylen);
    if (!pkey)
        ossl_raise(ePKeyError, "EVP_PKEY_new_raw_private_key");
#endif

    return ossl_pkey_wrap(pkey);
}

Siehe die Dokumentation von OpenSSL für EVP_PKEY_new_raw_private_key()

OpenSSL::PKey.new_raw_public_key(algo, string) → PKey

Source

static VALUE
ossl_pkey_new_raw_public_key(VALUE self, VALUE type, VALUE key)
{
    EVP_PKEY *pkey;
    size_t keylen;

    StringValue(key);
    keylen = RSTRING_LEN(key);

#ifdef OSSL_USE_PROVIDER
    pkey = EVP_PKEY_new_raw_public_key_ex(NULL, StringValueCStr(type), NULL,
                                          (unsigned char *)RSTRING_PTR(key),
                                          keylen);
    if (!pkey)
        ossl_raise(ePKeyError, "EVP_PKEY_new_raw_public_key_ex");
#else
    int pkey_id = lookup_pkey_type(type);
    pkey = EVP_PKEY_new_raw_public_key(pkey_id, NULL, (unsigned char *)RSTRING_PTR(key), keylen);
    if (!pkey)
        ossl_raise(ePKeyError, "EVP_PKEY_new_raw_public_key");
#endif

    return ossl_pkey_wrap(pkey);
}

Siehe die Dokumentation von OpenSSL für EVP_PKEY_new_raw_public_key()

OpenSSL::PKey.read(string [, pwd ]) → PKey

OpenSSL::PKey.read(io [, pwd ]) → PKey

Source

static VALUE
ossl_pkey_new_from_data(int argc, VALUE *argv, VALUE self)
{
    EVP_PKEY *pkey;
    BIO *bio;
    VALUE data, pass;

    rb_scan_args(argc, argv, "11", &data, &pass);
    bio = ossl_obj2bio(&data);
    pkey = ossl_pkey_read_generic(bio, ossl_pem_passwd_value(pass));
    BIO_free(bio);
    if (!pkey)
        ossl_raise(ePKeyError, "Could not parse PKey");
    return ossl_pkey_wrap(pkey);
}

Liest eine DER- oder PEM-kodierte Zeichenkette aus string oder io und gibt eine Instanz der entsprechenden PKey-Klasse zurück.

Parameter

string ist eine DER- oder PEM-kodierte Zeichenkette, die einen beliebigen privaten oder öffentlichen Schlüssel enthält.
io ist eine Instanz von IO, die einen DER- oder PEM-kodierten beliebigen privaten oder öffentlichen Schlüssel enthält.
pwd ist ein optionales Passwort für den Fall, dass string oder io eine verschlüsselte PEM-Ressource ist.