class OpenSSL::PKey::EC

OpenSSL::PKey::EC bietet Zugriff auf den Elliptic Curve Digital Signature Algorithm (ECDSA) und Elliptic Curve Diffie-Hellman (ECDH).

Schlüsselaustausch

ec1 = OpenSSL::PKey::EC.generate("prime256v1")
ec2 = OpenSSL::PKey::EC.generate("prime256v1")
# ec1 and ec2 have own private key respectively
shared_key1 = ec1.dh_compute_key(ec2.public_key)
shared_key2 = ec2.dh_compute_key(ec1.public_key)

p shared_key1 == shared_key2 #=> true

Öffentliche Klassenmethoden

builtin_curves → [[sn, comment], ...]

Source

static VALUE ossl_s_builtin_curves(VALUE self)
{
    EC_builtin_curve *curves = NULL;
    int n;
    int crv_len = rb_long2int(EC_get_builtin_curves(NULL, 0));
    VALUE ary, ret;

    curves = ALLOCA_N(EC_builtin_curve, crv_len);
    if (curves == NULL)
        return Qnil;
    if (!EC_get_builtin_curves(curves, crv_len))
        ossl_raise(rb_eRuntimeError, "EC_get_builtin_curves");

    ret = rb_ary_new2(crv_len);

    for (n = 0; n < crv_len; n++) {
        const char *sname = OBJ_nid2sn(curves[n].nid);
        const char *comment = curves[n].comment;

        ary = rb_ary_new2(2);
        rb_ary_push(ary, rb_str_new2(sname));
        rb_ary_push(ary, comment ? rb_str_new2(comment) : Qnil);
        rb_ary_push(ret, ary);
    }

    return ret;
}

Ermittelt eine Liste aller vordefinierten Kurven durch OpenSSL. Kurvennamen werden als sn zurückgegeben.

Siehe die OpenSSL-Dokumentation für EC_get_builtin_curves().

generate(ec_group) → ec

generate(string) → ec

Source

static VALUE
ossl_ec_key_s_generate(VALUE klass, VALUE arg)
{
    EVP_PKEY *pkey;
    EC_KEY *ec;
    VALUE obj;

    obj = rb_obj_alloc(klass);

    ec = ec_key_new_from_group(arg);
    pkey = EVP_PKEY_new();
    if (!pkey || EVP_PKEY_assign_EC_KEY(pkey, ec) != 1) {
        EVP_PKEY_free(pkey);
        EC_KEY_free(ec);
        ossl_raise(ePKeyError, "EVP_PKEY_assign_EC_KEY");
    }
    RTYPEDDATA_DATA(obj) = pkey;

    if (!EC_KEY_generate_key(ec))
        ossl_raise(ePKeyError, "EC_KEY_generate_key");

    return obj;
}

Erstellt eine neue EC-Instanz mit einem neuen zufälligen privaten und öffentlichen Schlüssel.

OpenSSL::PKey::EC.new

OpenSSL::PKey::EC.new(ec_key)

OpenSSL::PKey::EC.new(ec_group)

OpenSSL::PKey::EC.new("secp112r1")

OpenSSL::PKey::EC.new(pem_string [, pwd])

OpenSSL::PKey::EC.new(der_string)

Source

static VALUE ossl_ec_key_initialize(int argc, VALUE *argv, VALUE self)
{
    EVP_PKEY *pkey;
    EC_KEY *ec;
    BIO *in;
    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");

    rb_scan_args(argc, argv, "02", &arg, &pass);
    if (NIL_P(arg)) {
#ifdef OSSL_HAVE_IMMUTABLE_PKEY
        rb_raise(rb_eArgError, "OpenSSL::PKey::EC.new cannot be called " \
                 "without arguments; pkeys are immutable with OpenSSL 3.0");
#else
        if (!(ec = EC_KEY_new()))
            ossl_raise(ePKeyError, "EC_KEY_new");
        goto legacy;
#endif
    }
    else if (rb_obj_is_kind_of(arg, cEC_GROUP)) {
        ec = ec_key_new_from_group(arg);
        goto legacy;
    }

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

    pkey = ossl_pkey_read_generic(in, pass);
    BIO_free(in);
    if (!pkey) {
        ossl_clear_error();
        ec = ec_key_new_from_group(arg);
        goto legacy;
    }

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

  legacy:
    pkey = EVP_PKEY_new();
    if (!pkey || EVP_PKEY_assign_EC_KEY(pkey, ec) != 1) {
        EVP_PKEY_free(pkey);
        EC_KEY_free(ec);
        ossl_raise(ePKeyError, "EVP_PKEY_assign_EC_KEY");
    }
    RTYPEDDATA_DATA(self) = pkey;
    return self;
}

Erstellt ein neues EC-Objekt aus den angegebenen Argumenten.

Öffentliche Instanzmethoden

check_key → true

Source

static VALUE ossl_ec_key_check_key(VALUE self)
{
#ifdef HAVE_EVP_PKEY_CHECK
    EVP_PKEY *pkey;
    EVP_PKEY_CTX *pctx;
    const EC_KEY *ec;

    GetPKey(self, pkey);
    GetEC(self, ec);
    pctx = EVP_PKEY_CTX_new(pkey, /* engine */NULL);
    if (!pctx)
        ossl_raise(ePKeyError, "EVP_PKEY_CTX_new");

    if (EC_KEY_get0_private_key(ec) != NULL) {
        if (EVP_PKEY_check(pctx) != 1) {
            EVP_PKEY_CTX_free(pctx);
            ossl_raise(ePKeyError, "EVP_PKEY_check");
        }
    }
    else {
        if (EVP_PKEY_public_check(pctx) != 1) {
            EVP_PKEY_CTX_free(pctx);
            ossl_raise(ePKeyError, "EVP_PKEY_public_check");
        }
    }

    EVP_PKEY_CTX_free(pctx);
#else
    EC_KEY *ec;

    GetEC(self, ec);
    if (EC_KEY_check_key(ec) != 1)
        ossl_raise(ePKeyError, "EC_KEY_check_key");
#endif

    return Qtrue;
}

Löst eine Ausnahme aus, wenn der Schlüssel ungültig ist.

Siehe auch die Manpage EVP_PKEY_public_check(3).

dh_compute_key(pubkey) → string

Source

# File ext/openssl/lib/openssl/pkey.rb, line 307
def dh_compute_key(pubkey)
  obj = OpenSSL::ASN1.Sequence([
    OpenSSL::ASN1.Sequence([
      OpenSSL::ASN1.ObjectId("id-ecPublicKey"),
      group.to_der,
    ]),
    OpenSSL::ASN1.BitString(pubkey.to_octet_string(:uncompressed)),
  ])
  derive(OpenSSL::PKey.read(obj.to_der))
end

Leitet ein gemeinsames Geheimnis durch ECDH ab. pubkey muss eine Instanz von OpenSSL::PKey::EC::Point sein und derselben Gruppe angehören.

Diese Methode wird aus Kompatibilitätsgründen bereitgestellt und ruft intern derive auf.

dsa_sign_asn1(data) → String

Source

# File ext/openssl/lib/openssl/pkey.rb, line 286
def dsa_sign_asn1(data)
  sign_raw(nil, data)
end

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

dsa_verify_asn1(data, sig) → true | false

Source

# File ext/openssl/lib/openssl/pkey.rb, line 295
def dsa_verify_asn1(data, sig)
  verify_raw(nil, sig, data)
end

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

export([cipher, password]) → String

Source

static VALUE
ossl_ec_key_export(int argc, VALUE *argv, VALUE self)
{
    OSSL_3_const EC_KEY *ec;

    GetEC(self, ec);
    if (EC_KEY_get0_public_key(ec) == NULL)
        ossl_raise(ePKeyError, "can't export - no public key set");
    if (EC_KEY_get0_private_key(ec))
        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 unabhängig davon, ob es sich um einen öffentlichen oder privaten Schlüssel handelt, in ein X.509 SubjectPublicKeyInfo.

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

Serialisiert ihn in einen SEC 1/RFC 5915 ECPrivateKey.

Ein PEM-kodierter Schlüssel sieht so aus:

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

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

Serialisiert ihn in einen SEC 1/RFC 5915 ECPrivateKey und verschlüsselt ihn im traditionellen PEM-Verschlüsselungsformat von OpenSSL. cipher muss ein von OpenSSL::Cipher.new verstandener Chiffrename oder eine Instanz von OpenSSL::Cipher sein.

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

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

[...]
-----END EC 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 SEC 1/RFC 5915 ECPrivateKey-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 als to_pem alias.

generate_key

Alias für: generate_key!

generate_key! → self

Source

static VALUE ossl_ec_key_generate_key(VALUE self)
{
#ifdef OSSL_HAVE_IMMUTABLE_PKEY
    rb_raise(ePKeyError, "pkeys are immutable on OpenSSL 3.0");
#else
    EC_KEY *ec;

    GetEC(self, ec);
    if (EC_KEY_generate_key(ec) != 1)
        ossl_raise(ePKeyError, "EC_KEY_generate_key");

    return self;
#endif
}

Erzeugt einen neuen zufälligen privaten und öffentlichen Schlüssel.

Siehe auch die OpenSSL-Dokumentation für EC_KEY_generate_key()

Beispiel

ec = OpenSSL::PKey::EC.new("prime256v1")
p ec.private_key # => nil
ec.generate_key!
p ec.private_key # => #<OpenSSL::BN XXXXXX>

Auch als generate_key alias.

group → group

Source

static VALUE
ossl_ec_key_get_group(VALUE self)
{
    OSSL_3_const EC_KEY *ec;
    const EC_GROUP *group;

    GetEC(self, ec);
    group = EC_KEY_get0_group(ec);
    if (!group)
        return Qnil;

    return ec_group_new(group);
}

Gibt die EC::Group zurück, mit der der Schlüssel verknüpft ist. Änderungen an der zurückgegebenen Gruppe haben keine Auswirkungen auf den key.

group = group

Source

static VALUE
ossl_ec_key_set_group(VALUE self, VALUE group_v)
{
#ifdef OSSL_HAVE_IMMUTABLE_PKEY
    rb_raise(ePKeyError, "pkeys are immutable on OpenSSL 3.0");
#else
    EC_KEY *ec;
    EC_GROUP *group;

    GetEC(self, ec);
    GetECGroup(group_v, group);

    if (EC_KEY_set_group(ec, group) != 1)
        ossl_raise(ePKeyError, "EC_KEY_set_group");

    return group_v;
#endif
}

Legt die EC::Group für den Schlüssel fest. Die Gruppenstruktur wird intern kopiert, sodass Änderungen an group nach der Zuweisung an einen Schlüssel keine Auswirkungen auf den Schlüssel haben.

private? → true oder false

Source

static VALUE ossl_ec_key_is_private(VALUE self)
{
    OSSL_3_const EC_KEY *ec;

    GetEC(self, ec);

    return EC_KEY_get0_private_key(ec) ? Qtrue : Qfalse;
}

Gibt zurück, ob diese EC-Instanz einen privaten Schlüssel hat. Der private Schlüssel (BN) kann mit EC#private_key abgerufen werden.

Auch als private_key? alias.

private_key → OpenSSL::BN

Source

static VALUE ossl_ec_key_get_private_key(VALUE self)
{
    OSSL_3_const EC_KEY *ec;
    const BIGNUM *bn;

    GetEC(self, ec);
    if ((bn = EC_KEY_get0_private_key(ec)) == NULL)
        return Qnil;

    return ossl_bn_new(bn);
}

Siehe die OpenSSL-Dokumentation für EC_KEY_get0_private_key()

private_key = openssl_bn

Source

static VALUE ossl_ec_key_set_private_key(VALUE self, VALUE private_key)
{
#ifdef OSSL_HAVE_IMMUTABLE_PKEY
    rb_raise(ePKeyError, "pkeys are immutable on OpenSSL 3.0");
#else
    EC_KEY *ec;
    BIGNUM *bn = NULL;

    GetEC(self, ec);
    if (!NIL_P(private_key))
        bn = GetBNPtr(private_key);

    switch (EC_KEY_set_private_key(ec, bn)) {
      case 1:
        break;
      case 0:
        if (bn == NULL)
            break;
        /* fallthrough */
      default:
        ossl_raise(ePKeyError, "EC_KEY_set_private_key");
    }

    return private_key;
#endif
}

Siehe die OpenSSL-Dokumentation für EC_KEY_set_private_key()

private_key?

Alias für: private?

public? → true oder false

Source

static VALUE ossl_ec_key_is_public(VALUE self)
{
    OSSL_3_const EC_KEY *ec;

    GetEC(self, ec);

    return EC_KEY_get0_public_key(ec) ? Qtrue : Qfalse;
}

Gibt zurück, ob diese EC-Instanz einen öffentlichen Schlüssel hat. Der öffentliche Schlüssel (EC::Point) kann mit EC#public_key abgerufen werden.

Auch als public_key? alias.

public_key → OpenSSL::PKey::EC::Point

Source

static VALUE ossl_ec_key_get_public_key(VALUE self)
{
    OSSL_3_const EC_KEY *ec;
    const EC_POINT *point;

    GetEC(self, ec);
    if ((point = EC_KEY_get0_public_key(ec)) == NULL)
        return Qnil;

    return ec_point_new(point, EC_KEY_get0_group(ec));
}

Siehe die OpenSSL-Dokumentation für EC_KEY_get0_public_key()

public_key = ec_point

Source

static VALUE ossl_ec_key_set_public_key(VALUE self, VALUE public_key)
{
#ifdef OSSL_HAVE_IMMUTABLE_PKEY
    rb_raise(ePKeyError, "pkeys are immutable on OpenSSL 3.0");
#else
    EC_KEY *ec;
    EC_POINT *point = NULL;

    GetEC(self, ec);
    if (!NIL_P(public_key))
        GetECPoint(public_key, point);

    switch (EC_KEY_set_public_key(ec, point)) {
      case 1:
        break;
      case 0:
        if (point == NULL)
            break;
        /* fallthrough */
      default:
        ossl_raise(ePKeyError, "EC_KEY_set_public_key");
    }

    return public_key;
#endif
}

Siehe die OpenSSL-Dokumentation für EC_KEY_set_public_key()

public_key?

Alias für: public?

to_der → String

Source

static VALUE
ossl_ec_key_to_der(VALUE self)
{
    OSSL_3_const EC_KEY *ec;

    GetEC(self, ec);
    if (EC_KEY_get0_public_key(ec) == NULL)
        ossl_raise(ePKeyError, "can't export - no public key set");
    if (EC_KEY_get0_private_key(ec))
        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 SEC 1/RFC 5915 ECPrivateKey-Format erforderlich ist.

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

to_pem([cipher, password]) → String

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 SEC 1/RFC 5915 ECPrivateKey.

Ein PEM-kodierter Schlüssel sieht so aus:

-----BEGIN EC PRIVATE KEY-----
[...]
-----END EC 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 EC PRIVATE KEY-----
Proc-Type: 4,ENCRYPTED
DEK-Info: AES-128-CBC,733F5302505B34701FC41F5C0746E4C0

[...]
-----END EC 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 SEC 1/RFC 5915 ECPrivateKey-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