Class: OpenSSL::X509::Certificate

Relationships & Source Files
Inherits:	Object
Defined in:	ext/openssl/ossl_x509cert.c, ext/openssl/lib/openssl/x509.rb

Overview

Implementation of an X.509 certificate as specified in RFC 5280. Provides access to a certificate’s attributes and allows certificates to be read from a string, but also supports the creation of new certificates from scratch.

Reading a certificate from a file

Certificate is capable of handling DER-encoded certificates and certificates encoded in OpenSSL’s PEM format.

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

Saving a certificate to a file

A certificate may be encoded in DER format

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

or in PEM format

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

X.509 certificates are associated with a private/public key pair, typically a RSA, DSA or ECC key (see also ::OpenSSL::PKey::RSA, ::OpenSSL::PKey::DSA and ::OpenSSL::PKey::EC), the public key itself is stored within the certificate and can be accessed in form of an ::OpenSSL::PKey. Certificates are typically used to be able to associate some form of identity with a key pair, for example web servers serving pages over HTTPs use certificates to authenticate themselves to the user.

The public key infrastructure (PKI) model relies on trusted certificate authorities (“root CAs”) that issue these certificates, so that end users need to base their trust just on a selected few authorities that themselves again vouch for subordinate CAs issuing their certificates to end users.

The ::OpenSSL::X509 module provides the tools to set up an independent PKI, similar to scenarios where the ‘openssl’ command line tool is used for issuing certificates in a private PKI.

Creating a root CA certificate and an end-entity certificate

First, we need to create a “self-signed” root certificate. To do so, we need to generate a key first. Please note that the choice of “1” as a serial number is considered a security flaw for real certificates. Secure choices are integers in the two-digit byte range and ideally not sequential but secure random numbers, steps omitted here to keep the example concise.

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)

The next step is to create the end-entity certificate using the root CA certificate.

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)

Class Method Summary

.new ⇒ cert constructor

Instance Attribute Summary

#extensions ⇒ Array rw
#extensions=([ext...]=> [ext...]) rw
#issuer ⇒ name rw
#issuer=(name) ⇒ name rw
#not_after ⇒ Time rw
#not_after=(time) ⇒ Time rw
#not_before ⇒ Time rw
#not_before=(time) ⇒ Time rw
#public_key ⇒ key rw
#public_key=(key) rw
#serial ⇒ Integer rw
#serial=(integer) ⇒ Integer rw
#subject ⇒ name rw
#subject=(name) ⇒ name rw
#version ⇒ Integer rw
#version=(integer) ⇒ Integer rw

Instance Method Summary

#==(cert2) ⇒ Boolean

Compares the two certificates.
#add_extension(extension) ⇒ extension
#check_private_key(key) ⇒ Boolean

Returns true if key is the corresponding private key to the Subject Public Key Information, false otherwise.
#initialize_copy(other)
#inspect
#pretty_print(q)
#sign(key, digest) ⇒ self
#signature_algorithm ⇒ String
#to_der ⇒ String
#to_pem ⇒ String

Alias for #to_s.
#to_s ⇒ String (also: #to_pem)
#to_text ⇒ String
#verify(key) ⇒ Boolean

Verifies the signature of the certificate, with the public key key.

Constructor Details

.new ⇒ `cert` .new(string) ⇒ `cert`

[ GitHub ]

# File 'ext/openssl/ossl_x509cert.c', line 114


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;
}

Instance Attribute Details

#extensions ⇒ `Array` (rw)

[ GitHub ]

# File 'ext/openssl/ossl_x509cert.c', line 603


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...]) (rw)

[ GitHub ]

# File 'ext/openssl/ossl_x509cert.c', line 629


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;
}

#issuer ⇒ `name` (rw)

[ GitHub ]

# File 'ext/openssl/ossl_x509cert.c', line 382


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=(name) ⇒ `name` (rw)

[ GitHub ]

# File 'ext/openssl/ossl_x509cert.c', line 400


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 ⇒ `Time` (rw)

[ GitHub ]

# File 'ext/openssl/ossl_x509cert.c', line 456


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=(time) ⇒ `Time` (rw)

[ GitHub ]

# File 'ext/openssl/ossl_x509cert.c', line 474


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_set1_notAfter(x509, asn1time)) {
	ASN1_TIME_free(asn1time);
	ossl_raise(eX509CertError, "X509_set_notAfter");
    }
    ASN1_TIME_free(asn1time);

    return time;
}

#not_before ⇒ `Time` (rw)

[ GitHub ]

# File 'ext/openssl/ossl_x509cert.c', line 417


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=(time) ⇒ `Time` (rw)

[ GitHub ]

# File 'ext/openssl/ossl_x509cert.c', line 435


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_set1_notBefore(x509, asn1time)) {
	ASN1_TIME_free(asn1time);
	ossl_raise(eX509CertError, "X509_set_notBefore");
    }
    ASN1_TIME_free(asn1time);

    return time;
}

#public_key ⇒ `key` (rw)

[ GitHub ]

# File 'ext/openssl/ossl_x509cert.c', line 495


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=(key) (rw)

[ GitHub ]

# File 'ext/openssl/ossl_x509cert.c', line 513


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 ⇒ Integer (rw)

[ GitHub ]

# File 'ext/openssl/ossl_x509cert.c', line 294


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

    GetX509(self, x509);

    return asn1integer_to_num(X509_get_serialNumber(x509));
}

#serial=(integer) ⇒ Integer (rw)

[ GitHub ]

# File 'ext/openssl/ossl_x509cert.c', line 308


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;
}

#subject ⇒ `name` (rw)

[ GitHub ]

# File 'ext/openssl/ossl_x509cert.c', line 347


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=(name) ⇒ `name` (rw)

[ GitHub ]

# File 'ext/openssl/ossl_x509cert.c', line 365


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;
}

#version ⇒ Integer (rw)

[ GitHub ]

# File 'ext/openssl/ossl_x509cert.c', line 259


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

    GetX509(self, x509);

    return LONG2NUM(X509_get_version(x509));
}

#version=(integer) ⇒ Integer (rw)

[ GitHub ]

# File 'ext/openssl/ossl_x509cert.c', line 273


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;
}

Instance Method Details

#==(cert2) ⇒ `Boolean`

Compares the two certificates. Note that this takes into account all fields, not just the issuer name and the serial number.

[ GitHub ]

# File 'ext/openssl/ossl_x509cert.c', line 694


static VALUE
ossl_x509_eq(VALUE self, VALUE other)
{
    X509 *a, *b;

    GetX509(self, a);
    if (!rb_obj_is_kind_of(other, cX509Cert))
	return Qfalse;
    GetX509(other, b);

    return !X509_cmp(a, b) ? Qtrue : Qfalse;
}

#add_extension(extension) ⇒ `extension`

[ GitHub ]

# File 'ext/openssl/ossl_x509cert.c', line 658


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) ⇒ `Boolean`

Returns true if key is the corresponding private key to the Subject Public Key Information, false otherwise.

[ GitHub ]

# File 'ext/openssl/ossl_x509cert.c', line 582


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;
}

#initialize_copy(other)

[ GitHub ]

# File 'ext/openssl/ossl_x509cert.c', line 140


static VALUE
ossl_x509_copy(VALUE self, VALUE other)
{
    X509 *a, *b, *x509;

    rb_check_frozen(self);
    if (self == other) return self;

    GetX509(self, a);
    GetX509(other, b);

    x509 = X509_dup(b);
    if (!x509) ossl_raise(eX509CertError, NULL);

    DATA_PTR(self) = x509;
    X509_free(a);

    return self;
}

#inspect

[ GitHub ]

# File 'ext/openssl/ossl_x509cert.c', line 673


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));
}

#pretty_print(q)

[ GitHub ]

# File 'ext/openssl/lib/openssl/x509.rb', line 182


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

#sign(key, digest) ⇒ `self`

[ GitHub ]

# File 'ext/openssl/ossl_x509cert.c', line 531


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 = ossl_evp_get_digestbyname(digest);
    GetX509(self, x509);
    if (!X509_sign(x509, pkey, md)) {
	ossl_raise(eX509CertError, NULL);
    }

    return self;
}

#signature_algorithm ⇒ `String`

[ GitHub ]

# File 'ext/openssl/ossl_x509cert.c', line 323


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;
}

#to_der ⇒ `String`

[ GitHub ]

# File 'ext/openssl/ossl_x509cert.c', line 164


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_s ⇒ `String` #to_pem ⇒ `String`

Alias for #to_s.

#to_s ⇒ `String` Also known as: #to_pem

[ GitHub ]

# File 'ext/openssl/ossl_x509cert.c', line 188


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_text ⇒ `String`

[ GitHub ]

# File 'ext/openssl/ossl_x509cert.c', line 212


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(key) ⇒ `Boolean`

Verifies the signature of the certificate, with the public key key. key must be an instance of ::OpenSSL::PKey.

[ GitHub ]

# File 'ext/openssl/ossl_x509cert.c', line 555


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);
    }
}

Class: OpenSSL::X509::Certificate

Overview

Reading a certificate from a file

Saving a certificate to a file

Creating a root CA certificate and an end-entity certificate

Class Method Summary

Instance Attribute Summary

Instance Method Summary

Constructor Details

.new ⇒ cert .new(string) ⇒ cert

Instance Attribute Details

#extensions ⇒ Array (rw)

#extensions=([ext...]=> [ext...]) (rw)

#issuer ⇒ name (rw)

#issuer=(name) ⇒ name (rw)

#not_after ⇒ Time (rw)

#not_after=(time) ⇒ Time (rw)

#not_before ⇒ Time (rw)

#not_before=(time) ⇒ Time (rw)

#public_key ⇒ key (rw)

#public_key=(key) (rw)

#serial ⇒ Integer (rw)

#serial=(integer) ⇒ Integer (rw)

#subject ⇒ name (rw)

#subject=(name) ⇒ name (rw)

#version ⇒ Integer (rw)

#version=(integer) ⇒ Integer (rw)

Instance Method Details

#==(cert2) ⇒ Boolean

#add_extension(extension) ⇒ extension

#check_private_key(key) ⇒ Boolean

#initialize_copy(other)

#inspect

#pretty_print(q)

#sign(key, digest) ⇒ self

#signature_algorithm ⇒ String

#to_der ⇒ String

#to_s ⇒ String #to_pem ⇒ String

#to_s ⇒ String Also known as: #to_pem

#to_text ⇒ String

#verify(key) ⇒ Boolean

.new ⇒ `cert` .new(string) ⇒ `cert`

#extensions ⇒ `Array` (rw)

#issuer ⇒ `name` (rw)

#issuer=(name) ⇒ `name` (rw)

#not_after ⇒ `Time` (rw)

#not_after=(time) ⇒ `Time` (rw)

#not_before ⇒ `Time` (rw)

#not_before=(time) ⇒ `Time` (rw)

#public_key ⇒ `key` (rw)

#subject ⇒ `name` (rw)

#subject=(name) ⇒ `name` (rw)

#==(cert2) ⇒ `Boolean`

#add_extension(extension) ⇒ `extension`

#check_private_key(key) ⇒ `Boolean`

#sign(key, digest) ⇒ `self`

#signature_algorithm ⇒ `String`

#to_der ⇒ `String`

#to_s ⇒ `String` #to_pem ⇒ `String`

#to_s ⇒ `String` Also known as: #to_pem

#to_text ⇒ `String`

#verify(key) ⇒ `Boolean`