class OpenSSL::X509::Name

Ein X.509-Name repräsentiert einen Hostnamen, eine E-Mail-Adresse oder eine andere Entität, die mit einem öffentlichen Schlüssel verbunden ist.

Sie können ein Name erstellen, indem Sie einen Distinguished Name String parsen oder den Distinguished Name als Array bereitstellen.

name = OpenSSL::X509::Name.parse_rfc2253 'DC=example,CN=nobody'

name = OpenSSL::X509::Name.new [['CN', 'nobody'], ['DC', 'example']]

Constants

COMPAT

Ein Flag für to_s.

Bricht den zurückgegebenen Namen bei einer Länge von mehr als 80 Zeichen in mehrere Zeilen um.

DEFAULT_OBJECT_TYPE

Der Standard-Objekttyp für Namenseinträge.

MULTILINE

Ein Flag für to_s.

Gibt ein mehrzeiliges Format zurück.

OBJECT_TYPE_TEMPLATE

Die Standard-Objekttypvorlage für Namenseinträge.

ONELINE

Ein Flag für to_s.

Gibt ein besser lesbares Format als RFC2253 zurück.

RFC2253

Ein Flag für to_s.

Gibt einen Namen im RFC2253-Format zurück.

Öffentliche Klassenmethoden

X509::Name.new → name

X509::Name.new(der) → name

X509::Name.new(distinguished_name) → name

X509::Name.new(distinguished_name, template) → name

Source

static VALUE
ossl_x509name_initialize(int argc, VALUE *argv, VALUE self)
{
    X509_NAME *name;
    VALUE arg, template;

    GetX509Name(self, name);
    if (rb_scan_args(argc, argv, "02", &arg, &template) == 0) {
        return self;
    }
    else {
        VALUE tmp = rb_check_array_type(arg);
        if (!NIL_P(tmp)) {
            VALUE args;
            if(NIL_P(template)) template = OBJECT_TYPE_TEMPLATE;
            args = rb_ary_new3(2, self, template);
            rb_block_call(tmp, rb_intern("each"), 0, 0, ossl_x509name_init_i, args);
        }
        else{
            const unsigned char *p;
            VALUE str = ossl_to_der_if_possible(arg);
            X509_NAME *x;
            StringValue(str);
            p = (unsigned char *)RSTRING_PTR(str);
            x = d2i_X509_NAME(&name, &p, RSTRING_LEN(str));
            DATA_PTR(self) = name;
            if(!x){
                ossl_raise(eX509NameError, NULL);
            }
        }
    }

    return self;
}

Erstellt einen neuen Name.

Ein Name kann aus einem DER-codierten String der, einem Array, das einen distinguished_name repräsentiert, oder einem distinguished_name zusammen mit einer template erstellt werden.

name = OpenSSL::X509::Name.new [['CN', 'nobody'], ['DC', 'example']]

name = OpenSSL::X509::Name.new name.to_der

Siehe add_entry für eine Beschreibung des Inhalts des distinguished_name Arrays

parse (str, template=OBJECT_TYPE_TEMPLATE)

Alias für: parse_openssl

parse_openssl (str, template=OBJECT_TYPE_TEMPLATE)

Source

# File ext/openssl/lib/openssl/x509.rb, line 305
def parse_openssl(str, template=OBJECT_TYPE_TEMPLATE)
  if str.start_with?("/")
    # /A=B/C=D format
    ary = str[1..-1].split("/").map { |i| i.split("=", 2) }
  else
    # Comma-separated
    ary = str.split(",").map { |i| i.strip.split("=", 2) }
  end
  self.new(ary, template)
end

Parst die String-Repräsentation eines Distinguished Name. Zwei verschiedene Formen werden unterstützt

OpenSSL-Format (X509_NAME_oneline()), das von to_s verwendet wird. Zum Beispiel: /DC=com/DC=example/CN=nobody
OpenSSL-Format (X509_NAME_print()), das von #to_s(OpenSSL::X509::Name::COMPAT) verwendet wird. Zum Beispiel: DC=com, DC=example, CN=nobody

Keine davon ist standardisiert und weist Eigenheiten und Inkonsistenzen bei der Behandlung von Escapes oder mehrwertigen RDNs auf.

Die Verwendung dieser Methode wird in neuen Anwendungen nicht empfohlen. Siehe Name.parse_rfc2253 und to_utf8 für die Alternative.

Auch als: parse aliased

parse_rfc2253 (str, template=OBJECT_TYPE_TEMPLATE)

Source

# File ext/openssl/lib/openssl/x509.rb, line 286
def parse_rfc2253(str, template=OBJECT_TYPE_TEMPLATE)
  ary = OpenSSL::X509::Name::RFC2253DN.scan(str)
  self.new(ary, template)
end

Parst die UTF-8-String-Repräsentation eines Distinguished Name gemäß RFC 2253.

Siehe auch to_utf8 für die umgekehrte Operation.

Vergleicht diesen Name mit other und gibt 0 zurück, wenn sie gleich sind, und -1 oder +1, wenn sie größer oder kleiner sind. Gibt nil zurück, wenn sie nicht vergleichbar sind (d. h. unterschiedliche Typen).

Alias für: cmp

add_entry(oid, value [, type] [, loc: -1, set: 0]) → self

Source

static
VALUE ossl_x509name_add_entry(int argc, VALUE *argv, VALUE self)
{
    X509_NAME *name;
    VALUE oid, value, type, opts, kwargs[2];
    static ID kwargs_ids[2];
    const char *oid_name;
    int loc = -1, set = 0;

    if (!kwargs_ids[0]) {
        kwargs_ids[0] = rb_intern_const("loc");
        kwargs_ids[1] = rb_intern_const("set");
    }
    rb_scan_args(argc, argv, "21:", &oid, &value, &type, &opts);
    rb_get_kwargs(opts, kwargs_ids, 0, 2, kwargs);
    oid_name = StringValueCStr(oid);
    StringValue(value);
    if(NIL_P(type)) type = rb_aref(OBJECT_TYPE_TEMPLATE, oid);
    if (kwargs[0] != Qundef)
        loc = NUM2INT(kwargs[0]);
    if (kwargs[1] != Qundef)
        set = NUM2INT(kwargs[1]);
    GetX509Name(self, name);
    if (!X509_NAME_add_entry_by_txt(name, oid_name, NUM2INT(type),
                                    (unsigned char *)RSTRING_PTR(value),
                                    RSTRING_LENINT(value), loc, set))
        ossl_raise(eX509NameError, "X509_NAME_add_entry_by_txt");
    return self;
}

Fügt diesem Namen einen neuen Eintrag mit dem angegebenen oid und value hinzu. Der oid ist ein Objektidentifikator, der in ASN.1 definiert ist. Einige gängige OIDs sind

C: Country Name
CN: Common Name
DC: Domain Component
O: Organization Name
OU: Organizational Unit Name
ST: State or Province Name

Die optionalen Schlüsselwortparameter loc und set geben an, wo das neue Attribut eingefügt werden soll. Einzelheiten finden Sie im Handbuch von X509_NAME_add_entry(3). loc hat den Standardwert -1 und set den Standardwert 0. Dies hängt einen einwertigen RDN am Ende an.

cmp(other) → -1 | 0 | 1 | nil

Source

static VALUE
ossl_x509name_cmp(VALUE self, VALUE other)
{
    int result;

    if (!rb_obj_is_kind_of(other, cX509Name))
        return Qnil;

    result = ossl_x509name_cmp0(self, other);
    if (result < 0) return INT2FIX(-1);
    if (result > 0) return INT2FIX(1);

    return INT2FIX(0);
}

Auch als: <=> aliased

eql?(other) → true | false

Source

static VALUE
ossl_x509name_eql(VALUE self, VALUE other)
{
    if (!rb_obj_is_kind_of(other, cX509Name))
        return Qfalse;

    return ossl_x509name_cmp0(self, other) == 0 ? Qtrue : Qfalse;
}

Gibt true zurück, wenn name und other auf denselben Hash-Schlüssel verweisen.

hash → integer

Source

static VALUE
ossl_x509name_hash(VALUE self)
{
    X509_NAME *name;
    unsigned long hash;

    GetX509Name(self, name);

    hash = X509_NAME_hash(name);

    return ULONG2NUM(hash);
}

Der zurückgegebene Hash-Wert ist für die Verwendung als Dateiname eines Zertifikats in einem CA-Pfad geeignet.

hash_old → integer

Source

static VALUE
ossl_x509name_hash_old(VALUE self)
{
    X509_NAME *name;
    unsigned long hash;

    GetX509Name(self, name);

    hash = X509_NAME_hash_old(name);

    return ULONG2NUM(hash);
}

Gibt einen MD5-basierten Hash zurück, der in OpenSSL 0.9.X verwendet wird.

pretty_print (q)

Source

# File ext/openssl/lib/openssl/x509.rb, line 319
def pretty_print(q)
  q.object_group(self) {
    q.text ' '
    q.text to_s(OpenSSL::X509::Name::RFC2253)
  }
end

to_a → [[name, data, type], ...]

Source

static VALUE
ossl_x509name_to_a(VALUE self)
{
    X509_NAME *name;
    int entries;
    VALUE ret;

    GetX509Name(self, name);
    entries = X509_NAME_entry_count(name);
    ret = rb_ary_new_capa(entries);
    for (int i = 0; i < entries; i++) {
        const X509_NAME_ENTRY *entry = X509_NAME_get_entry(name, i);
        if (!entry)
            ossl_raise(eX509NameError, "X509_NAME_get_entry");
        const ASN1_OBJECT *obj = X509_NAME_ENTRY_get_object(entry);
        VALUE vname = ossl_asn1obj_to_string(obj);
        const ASN1_STRING *data = X509_NAME_ENTRY_get_data(entry);
        VALUE vdata = asn1str_to_str(data);
        VALUE type = INT2NUM(ASN1_STRING_type(data));
        rb_ary_push(ret, rb_ary_new_from_args(3, vname, vdata, type));
    }
    return ret;
}

Gibt eine Array-Repräsentation des Distinguished Name zurück, die für die Übergabe an ::new geeignet ist.

to_der → string

Source

static VALUE
ossl_x509name_to_der(VALUE self)
{
    X509_NAME *name;
    VALUE str;
    long len;
    unsigned char *p;

    GetX509Name(self, name);
    if((len = i2d_X509_NAME(name, NULL)) <= 0)
        ossl_raise(eX509NameError, NULL);
    str = rb_str_new(0, len);
    p = (unsigned char *)RSTRING_PTR(str);
    if(i2d_X509_NAME(name, &p) <= 0)
        ossl_raise(eX509NameError, NULL);
    ossl_str_adjust(str, p);

    return str;
}

Konvertiert den Namen in eine DER-Codierung

to_s → String

to_s(format) → string

Source

static VALUE
ossl_x509name_to_s(int argc, VALUE *argv, VALUE self)
{
    rb_check_arity(argc, 0, 1);
    /* name.to_s(nil) was allowed */
    if (!argc || NIL_P(argv[0]))
        return ossl_x509name_to_s_old(self);
    else
        return x509name_print(self, NUM2ULONG(argv[0]));
}

Gibt eine String-Repräsentation des Distinguished Name zurück. format ist einer der folgenden Werte:

Wenn format weggelassen wird, wird das weitgehend fehlerhafte und traditionelle OpenSSL-Format (X509_NAME_oneline()-Format) gewählt.

Die Verwendung dieser Methode wird nicht empfohlen. Keines der Formate außer OpenSSL::X509::Name::RFC2253 ist standardisiert und kann ein inkonsistentes Verhalten über OpenSSL-Versionen hinweg zeigen.

Es wird empfohlen, stattdessen to_utf8 zu verwenden, was dem Aufruf von name.to_s(OpenSSL::X509::Name::RFC2253).force_encoding("UTF-8") entspricht.

to_utf8 → string

Source

static VALUE
ossl_x509name_to_utf8(VALUE self)
{
    VALUE str = x509name_print(self, XN_FLAG_RFC2253 & ~ASN1_STRFLGS_ESC_MSB);
    rb_enc_associate_index(str, rb_utf8_encindex());
    return str;
}

Gibt eine UTF-8-Repräsentation des Distinguished Name zurück, wie in RFC 2253 spezifiziert.