class OpenSSL::Netscape::SPKI

Eine Implementierung einer einfachen Public-Key-Infrastruktur (ausgesprochen „spooky“). Die Struktur ist definiert als

PublicKeyAndChallenge ::= SEQUENCE {
  spki SubjectPublicKeyInfo,
  challenge IA5STRING
}

SignedPublicKeyAndChallenge ::= SEQUENCE {
  publicKeyAndChallenge PublicKeyAndChallenge,
  signatureAlgorithm AlgorithmIdentifier,
  signature BIT STRING
}

wobei die Definitionen von SubjectPublicKeyInfo und AlgorithmIdentifier in RFC5280 zu finden sind. SPKI wird typischerweise in Browsern zum Erstellen eines öffentlichen/privaten Schlüsselpaars und einer anschließenden Zertifikatsanforderung unter Verwendung des HTML <keygen>-Elements verwendet.

Beispiele

Erstellen einer `SPKI`

key = OpenSSL::PKey::RSA.new 2048
spki = OpenSSL::Netscape::SPKI.new
spki.challenge = "RandomChallenge"
spki.public_key = key.public_key
spki.sign(key, OpenSSL::Digest.new('SHA256'))
#send a request containing this to a server generating a certificate

Überprüfen einer `SPKI`-Anfrage

request = #...
spki = OpenSSL::Netscape::SPKI.new request
unless spki.verify(spki.public_key)
  # signature is invalid
end
#proceed

Öffentliche Klassenmethoden

new([request]) → spki

Source

static VALUE
ossl_spki_initialize(int argc, VALUE *argv, VALUE self)
{
    NETSCAPE_SPKI *spki;
    VALUE buffer;
    const unsigned char *p;

    if (rb_scan_args(argc, argv, "01", &buffer) == 0) {
        return self;
    }
    StringValue(buffer);
    if (!(spki = NETSCAPE_SPKI_b64_decode(RSTRING_PTR(buffer), RSTRING_LENINT(buffer)))) {
        ossl_clear_error();
        p = (unsigned char *)RSTRING_PTR(buffer);
        if (!(spki = d2i_NETSCAPE_SPKI(NULL, &p, RSTRING_LEN(buffer)))) {
            ossl_raise(eSPKIError, NULL);
        }
    }
    NETSCAPE_SPKI_free(DATA_PTR(self));
    SetSPKI(self, spki);

    return self;
}

Parameter

request - optionale Rohdaten der Anfrage, entweder im PEM- oder DER-Format.

Öffentliche Instanzmethoden

challenge → string

Source

static VALUE
ossl_spki_get_challenge(VALUE self)
{
    NETSCAPE_SPKI *spki;

    GetSPKI(self, spki);
    if (ASN1_STRING_length(spki->spkac->challenge) <= 0) {
        OSSL_Debug("Challenge.length <= 0?");
        return rb_str_new(0, 0);
    }

    return asn1str_to_str(spki->spkac->challenge);
}

Gibt die mit dieser SPKI verknüpfte Challenge-Zeichenkette zurück.

challenge = str → string

Source

static VALUE
ossl_spki_set_challenge(VALUE self, VALUE str)
{
    NETSCAPE_SPKI *spki;

    StringValue(str);
    GetSPKI(self, spki);
    if (!ASN1_STRING_set(spki->spkac->challenge, RSTRING_PTR(str),
                         RSTRING_LENINT(str))) {
        ossl_raise(eSPKIError, NULL);
    }

    return str;
}

Parameter

str - die Challenge-Zeichenkette, die für diese Instanz gesetzt werden soll

Setzt die mit der SPKI zu verknüpfende Challenge. Kann vom Server verwendet werden, z. B. um Replays zu verhindern.

public_key → pkey

Source

static VALUE
ossl_spki_get_public_key(VALUE self)
{
    NETSCAPE_SPKI *spki;
    EVP_PKEY *pkey;

    GetSPKI(self, spki);
    if (!(pkey = NETSCAPE_SPKI_get_pubkey(spki))) { /* adds an reference */
        ossl_raise(eSPKIError, NULL);
    }

    return ossl_pkey_wrap(pkey);
}

Gibt den mit der SPKI verknüpften öffentlichen Schlüssel zurück, eine Instanz von OpenSSL::PKey.

public_key = pub → pkey

Source

static VALUE
ossl_spki_set_public_key(VALUE self, VALUE key)
{
    NETSCAPE_SPKI *spki;
    EVP_PKEY *pkey;

    GetSPKI(self, spki);
    pkey = GetPKeyPtr(key);
    ossl_pkey_check_public_key(pkey);
    if (!NETSCAPE_SPKI_set_pubkey(spki, pkey))
        ossl_raise(eSPKIError, "NETSCAPE_SPKI_set_pubkey");
    return key;
}

Parameter

pub - der öffentliche Schlüssel, der für diese Instanz gesetzt werden soll

Setzt den mit der SPKI zu verknüpfenden öffentlichen Schlüssel, eine Instanz von OpenSSL::PKey. Dies sollte der öffentliche Schlüssel sein, der zum privaten Schlüssel gehört, der zum Signieren der SPKI verwendet wird.

sign(key, digest) → spki

Source

static VALUE
ossl_spki_sign(VALUE self, VALUE key, VALUE digest)
{
    NETSCAPE_SPKI *spki;
    EVP_PKEY *pkey;
    const EVP_MD *md;
    VALUE md_holder;

    pkey = GetPrivPKeyPtr(key); /* NO NEED TO DUP */
    md = ossl_evp_md_fetch(digest, &md_holder);
    GetSPKI(self, spki);
    if (!NETSCAPE_SPKI_sign(spki, pkey, md))
        ossl_raise(eSPKIError, "NETSCAPE_SPKI_sign");

    return self;
}

Parameter

key - der private Schlüssel, der zum Signieren dieser Instanz verwendet werden soll
digest - der Digest, der zum Signieren dieser Instanz verwendet werden soll

Zum Signieren einer SPKI sollte der private Schlüssel, der dem für diese Instanz gesetzten öffentlichen Schlüssel entspricht, zusätzlich zu einem Digest-Algorithmus in Form eines OpenSSL::Digest verwendet werden. Der private Schlüssel sollte eine Instanz von OpenSSL::PKey sein.

to_der → DER-kodierte Zeichenkette

Source

static VALUE
ossl_spki_to_der(VALUE self)
{
    NETSCAPE_SPKI *spki;
    VALUE str;
    long len;
    unsigned char *p;

    GetSPKI(self, spki);
    if ((len = i2d_NETSCAPE_SPKI(spki, NULL)) <= 0)
        ossl_raise(eSPKIError, "i2d_NETSCAPE_SPKI");
    str = rb_str_new(0, len);
    p = (unsigned char *)RSTRING_PTR(str);
    if (i2d_NETSCAPE_SPKI(spki, &p) <= 0)
        ossl_raise(eSPKIError, "i2d_NETSCAPE_SPKI");
    ossl_str_adjust(str, p);

    return str;
}

Gibt die DER-Kodierung dieser SPKI zurück.

to_pem → PEM-kodierte Zeichenkette

Source

static VALUE
ossl_spki_to_pem(VALUE self)
{
    NETSCAPE_SPKI *spki;
    char *data;
    VALUE str;

    GetSPKI(self, spki);
    if (!(data = NETSCAPE_SPKI_b64_encode(spki))) {
        ossl_raise(eSPKIError, NULL);
    }
    str = ossl_buf2str(data, rb_long2int(strlen(data)));

    return str;
}

Gibt die PEM-Kodierung dieser SPKI zurück.

Auch alias: to_s

to_s

Alias für: to_pem

to_text → string

Source

static VALUE
ossl_spki_print(VALUE self)
{
    NETSCAPE_SPKI *spki;
    BIO *out;

    GetSPKI(self, spki);
    if (!(out = BIO_new(BIO_s_mem()))) {
        ossl_raise(eSPKIError, NULL);
    }
    if (!NETSCAPE_SPKI_print(out, spki)) {
        BIO_free(out);
        ossl_raise(eSPKIError, NULL);
    }

    return ossl_membio2str(out);
}

Gibt eine textuelle Darstellung dieser SPKI zurück, nützlich für Debugging-Zwecke.

verify(key) → boolean

Source

static VALUE
ossl_spki_verify(VALUE self, VALUE key)
{
    NETSCAPE_SPKI *spki;
    EVP_PKEY *pkey;

    GetSPKI(self, spki);
    pkey = GetPKeyPtr(key);
    ossl_pkey_check_public_key(pkey);
    switch (NETSCAPE_SPKI_verify(spki, pkey)) {
      case 0:
        ossl_clear_error();
        return Qfalse;
      case 1:
        return Qtrue;
      default:
        ossl_raise(eSPKIError, "NETSCAPE_SPKI_verify");
    }
}

Parameter

key - der öffentliche Schlüssel, der zum Überprüfen der SPKI-Signatur verwendet werden soll

Gibt true zurück, wenn die Signatur gültig ist, andernfalls false. Zum Überprüfen einer SPKI sollte der in der SPKI enthaltene öffentliche Schlüssel verwendet werden.

class OpenSSL::Netscape::SPKI

Überprüfen einer SPKI-Anfrage

Überprüfen einer `SPKI`-Anfrage