class OpenSSL::X509::Certificate

Parent:: Object

Реализация сертификата X.509, как указано в RFC 5280. Предоставляет доступ к атрибутам сертификата и позволяет читать сертификаты из строки, но также поддерживает создание новых сертификатов с нуля.

Чтение сертификата из файла

Certificate способен обрабатывать DER-кодированные сертификаты и сертификаты в формате PEM OpenSSL.

raw = File.read "cert.cer" # DER- or PEM-encoded
certificate = OpenSSL::X509::Certificate.new raw

Сохранение сертификата в файл

Сертификат может быть закодирован в формате DER

cert = ...
File.open("cert.cer", "wb") { |f| f.print cert.to_der }

или в формате PEM

cert = ...
File.open("cert.pem", "wb") { |f| f.print cert.to_pem }

Сертификаты X.509 связаны с парой открытый/закрытый ключ, обычно RSA, DSA или ECC (см. также OpenSSL::PKey::RSA, OpenSSL::PKey::DSA и OpenSSL::PKey::EC), сам открытый ключ хранится в сертификате и может быть получен в виде OpenSSL::PKey. Сертификаты обычно используются для присвоения какой-либо формы идентификации паре ключ, например, веб-серверы, обслуживающие страницы по протоколу HTTPs, используют сертификаты для проверки подлинности самих себя для пользователя.

Модель инфраструктуры открытых ключей (PKI) опирается на доверенные центры сертификации («корневые ЦС»), которые выдают эти сертификаты, поэтому конечным пользователям нужно доверять только небольшому количеству авторитетов, которые сами заявляют о подчинённых ЦС, выдающих свои сертификаты конечным пользователям.

Модуль OpenSSL::X509 предоставляет инструменты для настройки независимой PKI, аналогично сценариям, где инструмент командной строки «openssl» используется для выдачи сертификатов в частной PKI.

Создание сертификата корневого ЦС и сертификата конечного пользователя

Сначала нам нужно создать «самоподписанный» корневой сертификат. Для этого нам сначала нужно сгенерировать ключ. Обратите внимание, что выбор «1» в качестве серийного номера считается уязвимостью для реальных сертификатов. Безопасные варианты — целые числа в диапазоне двухзначных байтов и, желательно, не последовательные, а безопасные случайные числа, этапы пропускаются здесь, чтобы сохранить пример кратким.

root_key = OpenSSL::PKey::RSA.new 2048 # the CA's public/private key
root_ca = OpenSSL::X509::Certificate.new
root_ca.version = 2 # cf. RFC 5280 - to make it a "v3" certificate
root_ca.serial = 1
root_ca.subject = OpenSSL::X509::Name.parse "/DC=org/DC=ruby-lang/CN=Ruby CA"
root_ca.issuer = root_ca.subject # root CA's are "self-signed"
root_ca.public_key = root_key.public_key
root_ca.not_before = Time.now
root_ca.not_after = root_ca.not_before + 2 * 365 * 24 * 60 * 60 # 2 years validity
ef = OpenSSL::X509::ExtensionFactory.new
ef.subject_certificate = root_ca
ef.issuer_certificate = root_ca
root_ca.add_extension(ef.create_extension("basicConstraints","CA:TRUE",true))
root_ca.add_extension(ef.create_extension("keyUsage","keyCertSign, cRLSign", true))
root_ca.add_extension(ef.create_extension("subjectKeyIdentifier","hash",false))
root_ca.add_extension(ef.create_extension("authorityKeyIdentifier","keyid:always",false))
root_ca.sign(root_key, OpenSSL::Digest::SHA256.new)

Следующим шагом является создание сертификата конечного пользователя с использованием сертификата корневого ЦС.

key = OpenSSL::PKey::RSA.new 2048
cert = OpenSSL::X509::Certificate.new
cert.version = 2
cert.serial = 2
cert.subject = OpenSSL::X509::Name.parse "/DC=org/DC=ruby-lang/CN=Ruby certificate"
cert.issuer = root_ca.subject # root CA is the issuer
cert.public_key = key.public_key
cert.not_before = Time.now
cert.not_after = cert.not_before + 1 * 365 * 24 * 60 * 60 # 1 years validity
ef = OpenSSL::X509::ExtensionFactory.new
ef.subject_certificate = cert
ef.issuer_certificate = root_ca
cert.add_extension(ef.create_extension("keyUsage","digitalSignature", true))
cert.add_extension(ef.create_extension("subjectKeyIdentifier","hash",false))
cert.sign(root_key, OpenSSL::Digest::SHA256.new)

Методы публичного класса

new → cert Показать исходный код

new(string) → cert

static VALUE
ossl_x509_initialize(int argc, VALUE *argv, VALUE self)
{
    BIO *in;
    X509 *x509, *x = DATA_PTR(self);
    VALUE arg;

    if (rb_scan_args(argc, argv, "01", &arg) == 0) {
        /* create just empty X509Cert */
        return self;
    }
    arg = ossl_to_der_if_possible(arg);
    in = ossl_obj2bio(&arg);
    x509 = PEM_read_bio_X509(in, &x, NULL, NULL);
    DATA_PTR(self) = x;
    if (!x509) {
        OSSL_BIO_reset(in);
        x509 = d2i_X509_bio(in, &x);
        DATA_PTR(self) = x;
    }
    BIO_free(in);
    if (!x509) ossl_raise(eX509CertError, NULL);

    return self;
}

Методы публичного экземпляра

add_extension(extension) → extension Показать исходный код

static VALUE
ossl_x509_add_extension(VALUE self, VALUE extension)
{
    X509 *x509;
    X509_EXTENSION *ext;

    GetX509(self, x509);
    ext = GetX509ExtPtr(extension);
    if (!X509_add_ext(x509, ext, -1)) { /* DUPs ext - FREE it */
        ossl_raise(eX509CertError, NULL);
    }

    return extension;
}

check_private_key(key) Показать исходный код

static VALUE
ossl_x509_check_private_key(VALUE self, VALUE key)
{
    X509 *x509;
    EVP_PKEY *pkey;

    /* not needed private key, but should be */
    pkey = GetPrivPKeyPtr(key); /* NO NEED TO DUP */
    GetX509(self, x509);
    if (!X509_check_private_key(x509, pkey)) {
        ossl_clear_error();
        return Qfalse;
    }

    return Qtrue;
}

Проверяет, является ли 'key' закрытым ключом для данного сертификата

extensions → [extension...] Показать исходный код

static VALUE
ossl_x509_get_extensions(VALUE self)
{
    X509 *x509;
    int count, i;
    X509_EXTENSION *ext;
    VALUE ary;

    GetX509(self, x509);
    count = X509_get_ext_count(x509);
    if (count < 0) {
        return rb_ary_new();
    }
    ary = rb_ary_new2(count);
    for (i=0; i<count; i++) {
        ext = X509_get_ext(x509, i); /* NO DUP - don't free! */
        rb_ary_push(ary, ossl_x509ext_new(ext));
    }

    return ary;
}

extensions = [ext...] → [ext...] Показать исходный код

static VALUE
ossl_x509_set_extensions(VALUE self, VALUE ary)
{
    X509 *x509;
    X509_EXTENSION *ext;
    long i;

    Check_Type(ary, T_ARRAY);
    /* All ary's members should be X509Extension */
    for (i=0; i<RARRAY_LEN(ary); i++) {
        OSSL_Check_Kind(RARRAY_AREF(ary, i), cX509Ext);
    }
    GetX509(self, x509);
    while ((ext = X509_delete_ext(x509, 0)))
        X509_EXTENSION_free(ext);
    for (i=0; i<RARRAY_LEN(ary); i++) {
        ext = GetX509ExtPtr(RARRAY_AREF(ary, i));
        if (!X509_add_ext(x509, ext, -1)) { /* DUPs ext */
            ossl_raise(eX509CertError, NULL);
        }
    }

    return ary;
}

inspect() Показать исходный код

static VALUE
ossl_x509_inspect(VALUE self)
{
    return rb_sprintf("#<%"PRIsVALUE": subject=%+"PRIsVALUE", "
                      "issuer=%+"PRIsVALUE", serial=%+"PRIsVALUE", "
                      "not_before=%+"PRIsVALUE", not_after=%+"PRIsVALUE">",
                      rb_obj_class(self),
                      ossl_x509_get_subject(self),
                      ossl_x509_get_issuer(self),
                      ossl_x509_get_serial(self),
                      ossl_x509_get_not_before(self),
                      ossl_x509_get_not_after(self));
}

issuer → имя Показать исходный код

static VALUE
ossl_x509_get_issuer(VALUE self)
{
    X509 *x509;
    X509_NAME *name;

    GetX509(self, x509);
    if(!(name = X509_get_issuer_name(x509))) { /* NO DUP - don't free! */
        ossl_raise(eX509CertError, NULL);
    }

    return ossl_x509name_new(name);
}

issuer = имя → имя Показать исходный код

static VALUE
ossl_x509_set_issuer(VALUE self, VALUE issuer)
{
    X509 *x509;

    GetX509(self, x509);
    if (!X509_set_issuer_name(x509, GetX509NamePtr(issuer))) { /* DUPs name */
        ossl_raise(eX509CertError, NULL);
    }

    return issuer;
}

not_after → время Показать исходный код

static VALUE
ossl_x509_get_not_after(VALUE self)
{
    X509 *x509;
    const ASN1_TIME *asn1time;

    GetX509(self, x509);
    if (!(asn1time = X509_get0_notAfter(x509))) {
        ossl_raise(eX509CertError, NULL);
    }

    return asn1time_to_time(asn1time);
}

not_after = время → время Показать исходный код

static VALUE
ossl_x509_set_not_after(VALUE self, VALUE time)
{
    X509 *x509;
    ASN1_TIME *asn1time;

    GetX509(self, x509);
    asn1time = ossl_x509_time_adjust(NULL, time);
    if (!X509_set_notAfter(x509, asn1time)) {
        ASN1_TIME_free(asn1time);
        ossl_raise(eX509CertError, "X509_set_notAfter");
    }
    ASN1_TIME_free(asn1time);

    return time;
}

not_before → время Показать исходный код

static VALUE
ossl_x509_get_not_before(VALUE self)
{
    X509 *x509;
    const ASN1_TIME *asn1time;

    GetX509(self, x509);
    if (!(asn1time = X509_get0_notBefore(x509))) {
        ossl_raise(eX509CertError, NULL);
    }

    return asn1time_to_time(asn1time);
}

not_before = время → время Показать исходный код

static VALUE
ossl_x509_set_not_before(VALUE self, VALUE time)
{
    X509 *x509;
    ASN1_TIME *asn1time;

    GetX509(self, x509);
    asn1time = ossl_x509_time_adjust(NULL, time);
    if (!X509_set_notBefore(x509, asn1time)) {
        ASN1_TIME_free(asn1time);
        ossl_raise(eX509CertError, "X509_set_notBefore");
    }
    ASN1_TIME_free(asn1time);

    return time;
}

pretty_print(q) Показать исходный код

# File ext/openssl/lib/openssl/x509.rb, line 163
def pretty_print(q)
  q.object_group(self) {
    q.breakable
    q.text 'subject='; q.pp self.subject; q.text ','; q.breakable
    q.text 'issuer='; q.pp self.issuer; q.text ','; q.breakable
    q.text 'serial='; q.pp self.serial; q.text ','; q.breakable
    q.text 'not_before='; q.pp self.not_before; q.text ','; q.breakable
    q.text 'not_after='; q.pp self.not_after
  }
end

public_key → ключ Показать исходный код

static VALUE
ossl_x509_get_public_key(VALUE self)
{
    X509 *x509;
    EVP_PKEY *pkey;

    GetX509(self, x509);
    if (!(pkey = X509_get_pubkey(x509))) { /* adds an reference */
        ossl_raise(eX509CertError, NULL);
    }

    return ossl_pkey_new(pkey); /* NO DUP - OK */
}

public_key = ключ Показать исходный код

static VALUE
ossl_x509_set_public_key(VALUE self, VALUE key)
{
    X509 *x509;
    EVP_PKEY *pkey;

    GetX509(self, x509);
    pkey = GetPKeyPtr(key);
    ossl_pkey_check_public_key(pkey);
    if (!X509_set_pubkey(x509, pkey))
        ossl_raise(eX509CertError, "X509_set_pubkey");
    return key;
}

serial → целое число Показать исходный код

static VALUE
ossl_x509_get_serial(VALUE self)
{
    X509 *x509;

    GetX509(self, x509);

    return asn1integer_to_num(X509_get_serialNumber(x509));
}

serial = целое число → целое число Показать исходный код

static VALUE
ossl_x509_set_serial(VALUE self, VALUE num)
{
    X509 *x509;

    GetX509(self, x509);
    X509_set_serialNumber(x509, num_to_asn1integer(num, X509_get_serialNumber(x509)));

    return num;
}

sign(ключ, дайджест) → self Показать исходный код

static VALUE
ossl_x509_sign(VALUE self, VALUE key, VALUE digest)
{
    X509 *x509;
    EVP_PKEY *pkey;
    const EVP_MD *md;

    pkey = GetPrivPKeyPtr(key); /* NO NEED TO DUP */
    md = GetDigestPtr(digest);
    GetX509(self, x509);
    if (!X509_sign(x509, pkey, md)) {
        ossl_raise(eX509CertError, NULL);
    }

    return self;
}

signature_algorithm → строка Показать исходный код

static VALUE
ossl_x509_get_signature_algorithm(VALUE self)
{
    X509 *x509;
    BIO *out;
    VALUE str;

    GetX509(self, x509);
    out = BIO_new(BIO_s_mem());
    if (!out) ossl_raise(eX509CertError, NULL);

    if (!i2a_ASN1_OBJECT(out, X509_get0_tbs_sigalg(x509)->algorithm)) {
        BIO_free(out);
        ossl_raise(eX509CertError, NULL);
    }
    str = ossl_membio2str(out);

    return str;
}

subject → имя Показать исходный код

static VALUE
ossl_x509_get_subject(VALUE self)
{
    X509 *x509;
    X509_NAME *name;

    GetX509(self, x509);
    if (!(name = X509_get_subject_name(x509))) { /* NO DUP - don't free! */
        ossl_raise(eX509CertError, NULL);
    }

    return ossl_x509name_new(name);
}

subject = имя → имя Показать исходный код

static VALUE
ossl_x509_set_subject(VALUE self, VALUE subject)
{
    X509 *x509;

    GetX509(self, x509);
    if (!X509_set_subject_name(x509, GetX509NamePtr(subject))) { /* DUPs name */
        ossl_raise(eX509CertError, NULL);
    }

    return subject;
}

to_der → строка Показать исходный код

static VALUE
ossl_x509_to_der(VALUE self)
{
    X509 *x509;
    VALUE str;
    long len;
    unsigned char *p;

    GetX509(self, x509);
    if ((len = i2d_X509(x509, NULL)) <= 0)
        ossl_raise(eX509CertError, NULL);
    str = rb_str_new(0, len);
    p = (unsigned char *)RSTRING_PTR(str);
    if (i2d_X509(x509, &p) <= 0)
        ossl_raise(eX509CertError, NULL);
    ossl_str_adjust(str, p);

    return str;
}

to_pem → строка Показать исходный код

static VALUE
ossl_x509_to_pem(VALUE self)
{
    X509 *x509;
    BIO *out;
    VALUE str;

    GetX509(self, x509);
    out = BIO_new(BIO_s_mem());
    if (!out) ossl_raise(eX509CertError, NULL);

    if (!PEM_write_bio_X509(out, x509)) {
        BIO_free(out);
        ossl_raise(eX509CertError, NULL);
    }
    str = ossl_membio2str(out);

    return str;
}

Также алиасировано как: to_s

to_s()

Псевдоним для: to_pem

to_text → строка Показать исходный код

static VALUE
ossl_x509_to_text(VALUE self)
{
    X509 *x509;
    BIO *out;
    VALUE str;

    GetX509(self, x509);

    out = BIO_new(BIO_s_mem());
    if (!out) ossl_raise(eX509CertError, NULL);

    if (!X509_print(out, x509)) {
        BIO_free(out);
        ossl_raise(eX509CertError, NULL);
    }
    str = ossl_membio2str(out);

    return str;
}

verify(ключ) → true | false Показать исходный код

static VALUE
ossl_x509_verify(VALUE self, VALUE key)
{
    X509 *x509;
    EVP_PKEY *pkey;

    GetX509(self, x509);
    pkey = GetPKeyPtr(key);
    ossl_pkey_check_public_key(pkey);
    switch (X509_verify(x509, pkey)) {
      case 1:
        return Qtrue;
      case 0:
        ossl_clear_error();
        return Qfalse;
      default:
        ossl_raise(eX509CertError, NULL);
    }
}

Проверяет, что подпись сертификата была создана с помощью закрытого ключа этого открытого ключа 'key'

version → целое число Показать исходный код

static VALUE
ossl_x509_get_version(VALUE self)
{
    X509 *x509;

    GetX509(self, x509);

    return LONG2NUM(X509_get_version(x509));
}

version = целое число → целое число Показать исходный код

static VALUE
ossl_x509_set_version(VALUE self, VALUE version)
{
    X509 *x509;
    long ver;

    if ((ver = NUM2LONG(version)) < 0) {
        ossl_raise(eX509CertError, "version must be >= 0!");
    }
    GetX509(self, x509);
    if (!X509_set_version(x509, ver)) {
        ossl_raise(eX509CertError, NULL);
    }

    return version;
}

Ruby Core © 1993–2017 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.