class OpenSSL::PKey::DSA

DSA, der Digital Signature Algorithm, ist in NISTs FIPS 186-3 spezifiziert. Es ist ein asymmetrischer Public-Key-Algorithmus, der ähnlich wie z. B. RSA verwendet werden kann.

Öffentliche Klassenmethoden

generate(size) → dsa

Source

# File ext/openssl/lib/openssl/pkey.rb, line 199
def generate(size, &blk)
  # FIPS 186-4 specifies four (L,N) pairs: (1024,160), (2048,224),
  # (2048,256), and (3072,256).
  #
  # q size is derived here with compatibility with
  # DSA_generator_parameters_ex() which previous versions of ruby/openssl
  # used to call.
  qsize = size >= 2048 ? 256 : 160
  dsaparams = OpenSSL::PKey.generate_parameters("DSA", {
    "dsa_paramgen_bits" => size,
    "dsa_paramgen_q_bits" => qsize,
  }, &blk)
  OpenSSL::PKey.generate_key(dsaparams)
end

Erstellt eine neue DSA-Instanz durch Generierung eines privaten/öffentlichen Schlüsselpaars von Grund auf.

Siehe auch OpenSSL::PKey.generate_parameters und OpenSSL::PKey.generate_key.

size: Die gewünschte Schlüsselgröße in Bits.

new → dsa

new(string [, pass]) → dsa

new(size) → dsa

Source

static VALUE
ossl_dsa_initialize(int argc, VALUE *argv, VALUE self)
{
    EVP_PKEY *pkey;
    DSA *dsa;
    BIO *in = NULL;
    VALUE arg, pass;
    int type;

    TypedData_Get_Struct(self, EVP_PKEY, &ossl_evp_pkey_type, pkey);
    if (pkey)
        rb_raise(rb_eTypeError, "pkey already initialized");

    /* The DSA.new(size, generator) form is handled by lib/openssl/pkey.rb */
    rb_scan_args(argc, argv, "02", &arg, &pass);
    if (argc == 0) {
#ifdef OSSL_HAVE_IMMUTABLE_PKEY
        rb_raise(rb_eArgError, "OpenSSL::PKey::DSA.new cannot be called " \
                 "without arguments; pkeys are immutable with OpenSSL 3.0");
#else
        dsa = DSA_new();
        if (!dsa)
            ossl_raise(ePKeyError, "DSA_new");
        goto legacy;
#endif
    }

    pass = ossl_pem_passwd_value(pass);
    arg = ossl_to_der_if_possible(arg);
    in = ossl_obj2bio(&arg);

    /* DER-encoded DSAPublicKey format isn't supported by the generic routine */
    dsa = (DSA *)PEM_ASN1_read_bio((d2i_of_void *)d2i_DSAPublicKey,
                                   PEM_STRING_DSA_PUBLIC,
                                   in, NULL, NULL, NULL);
    if (dsa)
        goto legacy;
    OSSL_BIO_reset(in);

    pkey = ossl_pkey_read_generic(in, pass);
    BIO_free(in);
    if (!pkey)
        ossl_raise(ePKeyError, "Neither PUB key nor PRIV key");

    type = EVP_PKEY_base_id(pkey);
    if (type != EVP_PKEY_DSA) {
        EVP_PKEY_free(pkey);
        rb_raise(ePKeyError, "incorrect pkey type: %s", OBJ_nid2sn(type));
    }
    RTYPEDDATA_DATA(self) = pkey;
    return self;

  legacy:
    BIO_free(in);
    pkey = EVP_PKEY_new();
    if (!pkey || EVP_PKEY_assign_DSA(pkey, dsa) != 1) {
        EVP_PKEY_free(pkey);
        DSA_free(dsa);
        ossl_raise(ePKeyError, "EVP_PKEY_assign_DSA");
    }
    RTYPEDDATA_DATA(self) = pkey;
    return self;
}

Erstellt eine neue DSA-Instanz durch Lesen eines vorhandenen Schlüssels aus string.

Wenn ohne Argumente aufgerufen, wird eine neue Instanz ohne gesetzte Schlüsselkomponenten erstellt. Diese können einzeln mit set_pqg und set_key gesetzt werden. Diese Form ist nicht kompatibel mit OpenSSL 3.0 oder neuer.

Wenn mit einem String aufgerufen, wird versucht, als DER- oder PEM-Kodierung eines DSA-Schlüssels zu parsen. Siehe auch OpenSSL::PKey.read, das Schlüssel jeder Art parsen kann.

Wenn mit einer Zahl aufgerufen, werden zufällige Parameter und ein Schlüsselpaar generiert. Diese Form funktioniert als Alias für DSA.generate.

Zeichenkette: Ein String, der einen DER- oder PEM-kodierten Schlüssel enthält.
pass: Ein String, der ein optionales Passwort enthält.
size: Siehe DSA.generate.

Beispiele

p OpenSSL::PKey::DSA.new(1024)
#=> #<OpenSSL::PKey::DSA:0x000055a8d6025bf0 oid=DSA>

p OpenSSL::PKey::DSA.new(File.read('dsa.pem'))
#=> #<OpenSSL::PKey::DSA:0x000055555d6b8110 oid=DSA>

p OpenSSL::PKey::DSA.new(File.read('dsa.pem'), 'mypassword')
#=> #<OpenSSL::PKey::DSA:0x0000556f973c40b8 oid=DSA>

Öffentliche Instanzmethoden

export([cipher, password]) → aString

Source

static VALUE
ossl_dsa_export(int argc, VALUE *argv, VALUE self)
{
    OSSL_3_const DSA *dsa;

    GetDSA(self, dsa);
    if (DSA_HAS_PRIVATE(dsa))
        return ossl_pkey_export_traditional(argc, argv, self, 0);
    else
        return ossl_pkey_export_spki(self, 0);
}

Serialisiert einen privaten oder öffentlichen Schlüssel in PEM-Kodierung.

Wenn der Schlüssel nur öffentliche Komponenten enthält

Serialisiert ihn in eine X.509 SubjectPublicKeyInfo. Die Parameter cipher und password werden ignoriert.

Ein PEM-kodierter Schlüssel sieht so aus:

-----BEGIN PUBLIC KEY-----
[...]
-----END PUBLIC KEY-----

Erwägen Sie stattdessen die Verwendung von public_to_pem. Dies serialisiert den Schlüssel in eine X.509 SubjectPublicKeyInfo, unabhängig davon, ob es sich um einen öffentlichen oder privaten Schlüssel handelt.

Wenn der Schlüssel private Komponenten enthält und keine Parameter angegeben sind

Serialisiert ihn in einen traditionellen OpenSSL DSAPrivateKey.

Ein PEM-kodierter Schlüssel sieht so aus:

-----BEGIN DSA PRIVATE KEY-----
[...]
-----END DSA PRIVATE KEY-----

Wenn der Schlüssel private Komponenten enthält und cipher und password angegeben sind

Serialisiert ihn in einen traditionellen OpenSSL DSAPrivateKey und verschlüsselt ihn im traditionellen PEM-Verschlüsselungsformat von OpenSSL. cipher muss ein von OpenSSL::Cipher.new verstandener Cipher-Name oder eine Instanz von OpenSSL::Cipher sein.

Ein verschlüsselter PEM-kodierter Schlüssel sieht so aus:

-----BEGIN DSA PRIVATE KEY-----
Proc-Type: 4,ENCRYPTED
DEK-Info: AES-128-CBC,733F5302505B34701FC41F5C0746E4C0

[...]
-----END DSA PRIVATE KEY-----

Beachten Sie, dass dieses Format MD5 zur Ableitung des Verschlüsselungsschlüssels verwendet und daher auf FIPS-konformen Systemen nicht verfügbar ist.

Diese Methode wird aus Kompatibilitätsgründen beibehalten. Sie sollte nur verwendet werden, wenn das traditionelle, nicht standardmäßige OpenSSL-Format erforderlich ist.

Erwägen Sie stattdessen die Verwendung von public_to_pem (X.509 SubjectPublicKeyInfo) oder private_to_pem (PKCS #8 PrivateKeyInfo oder EncryptedPrivateKeyInfo).

Auch aliased als: to_pem, to_s

params → hash

Source

# File ext/openssl/lib/openssl/pkey.rb, line 181
def params
  %w{p q g pub_key priv_key}.map { |name|
    [name, send(name)]
  }.to_h
end

Speichert alle Parameter des Schlüssels in einem Hash.

Der Hash hat die Schlüssel ‘p’, ‘q’, ‘g’, ‘pub_key’ und ‘priv_key’.

private? → true | false

Source

static VALUE
ossl_dsa_is_private(VALUE self)
{
    OSSL_3_const DSA *dsa;

    GetDSA(self, dsa);

    return DSA_PRIVATE(self, dsa) ? Qtrue : Qfalse;
}

Zeigt an, ob diese DSA-Instanz über einen zugeordneten privaten Schlüssel verfügt oder nicht. Der private Schlüssel kann mit DSA#private_key abgerufen werden.

public? → true | false

Source

static VALUE
ossl_dsa_is_public(VALUE self)
{
    const DSA *dsa;
    const BIGNUM *bn;

    GetDSA(self, dsa);
    DSA_get0_key(dsa, &bn, NULL);

    return bn ? Qtrue : Qfalse;
}

Zeigt an, ob diese DSA-Instanz über einen zugeordneten öffentlichen Schlüssel verfügt oder nicht. Der öffentliche Schlüssel kann mit DSA#public_key abgerufen werden.

public_key → dsanew

Source

# File ext/openssl/lib/openssl/pkey.rb, line 171
def public_key
  OpenSSL::PKey.read(public_to_der)
end

Gibt eine neue DSA-Instanz zurück, die nur die DSA-Parameter und den öffentlichen Schlüssel enthält.

Diese Methode wird aus Gründen der Abwärtskompatibilität bereitgestellt. In den meisten Fällen ist es nicht erforderlich, diese Methode aufzurufen.

Für die Serialisierung des öffentlichen Schlüssels in PEM- oder DER-Kodierung im X.509 SubjectPublicKeyInfo-Format prüfen Sie PKey#public_to_pem und PKey#public_to_der.

set_key(pub_key, priv_key) → self

Setzt pub_key und priv_key für die DSA-Instanz. priv_key kann nil sein.

set_pqg(p, q, g) → self

Setzt p, q, g für die DSA-Instanz.

syssign(string) → string

Source

# File ext/openssl/lib/openssl/pkey.rb, line 250
def syssign(string)
  q or raise PKeyError, "incomplete DSA"
  private? or raise PKeyError, "Private DSA key needed!"
  sign_raw(nil, string)
end

Berechnet und gibt die DSA-Signatur von string zurück, wobei erwartet wird, dass string eine bereits berechnete Nachrichtenzusammenfassung der ursprünglichen Eingabedaten ist. Die Signatur wird mit dem privaten Schlüssel dieser DSA-Instanz ausgestellt.

Deprecated in version 3.0. Erwägen Sie stattdessen die Verwendung von PKey::PKey#sign_raw und PKey::PKey#verify_raw.

Zeichenkette: Eine Nachrichtenzusammenfassung der ursprünglichen zu signierenden Eingabedaten.

Beispiel

dsa = OpenSSL::PKey::DSA.new(2048)
doc = "Sign me"
digest = OpenSSL::Digest.digest('SHA1', doc)

# With legacy #syssign and #sysverify:
sig = dsa.syssign(digest)
p dsa.sysverify(digest, sig) #=> true

# With #sign_raw and #verify_raw:
sig = dsa.sign_raw(nil, digest)
p dsa.verify_raw(nil, sig, digest) #=> true

sysverify(digest, sig) → true | false

Source

# File ext/openssl/lib/openssl/pkey.rb, line 269
def sysverify(digest, sig)
  verify_raw(nil, sig, digest)
end

Überprüft, ob die Signatur angesichts der Nachrichtenzusammenfassung gültig ist. Dies geschieht durch Validierung von sig mit dem öffentlichen Schlüssel dieser DSA-Instanz.

Deprecated in version 3.0. Erwägen Sie stattdessen die Verwendung von PKey::PKey#sign_raw und PKey::PKey#verify_raw.

digest: Eine Nachrichtenzusammenfassung der ursprünglichen zu signierenden Eingabedaten.
sig: Ein DSA-Signaturwert.

to_der → aString

Source

static VALUE
ossl_dsa_to_der(VALUE self)
{
    OSSL_3_const DSA *dsa;

    GetDSA(self, dsa);
    if (DSA_HAS_PRIVATE(dsa))
        return ossl_pkey_export_traditional(0, NULL, self, 1);
    else
        return ossl_pkey_export_spki(self, 1);
}

Serialisiert einen privaten oder öffentlichen Schlüssel in DER-Kodierung.

Siehe to_pem für Details.

Diese Methode wird aus Kompatibilitätsgründen beibehalten. Sie sollte nur verwendet werden, wenn das traditionelle, nicht standardmäßige OpenSSL-Format erforderlich ist.

Erwägen Sie stattdessen die Verwendung von public_to_der oder private_to_der.

to_pem([cipher, password]) → aString

Serialisiert einen privaten oder öffentlichen Schlüssel in PEM-Kodierung.

Wenn der Schlüssel nur öffentliche Komponenten enthält

Serialisiert ihn in eine X.509 SubjectPublicKeyInfo. Die Parameter cipher und password werden ignoriert.

Ein PEM-kodierter Schlüssel sieht so aus:

-----BEGIN PUBLIC KEY-----
[...]
-----END PUBLIC KEY-----

Wenn der Schlüssel private Komponenten enthält und keine Parameter angegeben sind

Serialisiert ihn in einen traditionellen OpenSSL DSAPrivateKey.

Ein PEM-kodierter Schlüssel sieht so aus:

-----BEGIN DSA PRIVATE KEY-----
[...]
-----END DSA PRIVATE KEY-----

Wenn der Schlüssel private Komponenten enthält und cipher und password angegeben sind

Ein verschlüsselter PEM-kodierter Schlüssel sieht so aus:

-----BEGIN DSA PRIVATE KEY-----
Proc-Type: 4,ENCRYPTED
DEK-Info: AES-128-CBC,733F5302505B34701FC41F5C0746E4C0

[...]
-----END DSA PRIVATE KEY-----

Beachten Sie, dass dieses Format MD5 zur Ableitung des Verschlüsselungsschlüssels verwendet und daher auf FIPS-konformen Systemen nicht verfügbar ist.

Diese Methode wird aus Kompatibilitätsgründen beibehalten. Sie sollte nur verwendet werden, wenn das traditionelle, nicht standardmäßige OpenSSL-Format erforderlich ist.

Erwägen Sie stattdessen die Verwendung von public_to_pem (X.509 SubjectPublicKeyInfo) oder private_to_pem (PKCS #8 PrivateKeyInfo oder EncryptedPrivateKeyInfo).

Alias für: export

to_s([cipher, password]) → aString

Serialisiert einen privaten oder öffentlichen Schlüssel in PEM-Kodierung.

Wenn der Schlüssel nur öffentliche Komponenten enthält

Serialisiert ihn in eine X.509 SubjectPublicKeyInfo. Die Parameter cipher und password werden ignoriert.

Ein PEM-kodierter Schlüssel sieht so aus:

-----BEGIN PUBLIC KEY-----
[...]
-----END PUBLIC KEY-----

Wenn der Schlüssel private Komponenten enthält und keine Parameter angegeben sind

Serialisiert ihn in einen traditionellen OpenSSL DSAPrivateKey.

Ein PEM-kodierter Schlüssel sieht so aus:

-----BEGIN DSA PRIVATE KEY-----
[...]
-----END DSA PRIVATE KEY-----

Wenn der Schlüssel private Komponenten enthält und cipher und password angegeben sind

Ein verschlüsselter PEM-kodierter Schlüssel sieht so aus:

-----BEGIN DSA PRIVATE KEY-----
Proc-Type: 4,ENCRYPTED
DEK-Info: AES-128-CBC,733F5302505B34701FC41F5C0746E4C0

[...]
-----END DSA PRIVATE KEY-----

Beachten Sie, dass dieses Format MD5 zur Ableitung des Verschlüsselungsschlüssels verwendet und daher auf FIPS-konformen Systemen nicht verfügbar ist.

Diese Methode wird aus Kompatibilitätsgründen beibehalten. Sie sollte nur verwendet werden, wenn das traditionelle, nicht standardmäßige OpenSSL-Format erforderlich ist.

Erwägen Sie stattdessen die Verwendung von public_to_pem (X.509 SubjectPublicKeyInfo) oder private_to_pem (PKCS #8 PrivateKeyInfo oder EncryptedPrivateKeyInfo).

Alias für: export