Class: OpenSSL::X509::CRL (Ruby 2.2.2)
Description: Class : OpenSSL::X509::CRL - Ruby 2.2.2

- Home
- Core 2.2.2
- Std-lib 2.2.2
- Downloads

Support for the Ruby 2.2 series has ended. See here for reference.

### Home Classes Methods

### In Files

- openssl/ossl_ssl_session.c

### Parent

Object

### Methods

- ::new
- #add_extension
- #add_revoked
- #extensions
- #extensions=
- #issuer
- #issuer=
- #last_update
- #last_update=
- #next_update
- #next_update=
- #revoked
- #revoked=
- #sign
- #signature_algorithm
- #to_der
- #to_pem
- #to_s
- #to_text
- #verify
- #version
- #version=

### Class/Module Index

Quicksearch

- Integer
- OpenSSL::ASN1
- OpenSSL::ASN1::ASN1Data
- OpenSSL::ASN1::ASN1Error
- OpenSSL::ASN1::Constructive
- OpenSSL::ASN1::ObjectId
- OpenSSL::ASN1::Primitive
- OpenSSL::BN
- OpenSSL::BNError
- OpenSSL::Buffering
- OpenSSL::Cipher
- OpenSSL::Cipher::Cipher
- OpenSSL::Cipher::CipherError
- OpenSSL::Config
- OpenSSL::ConfigError
- OpenSSL::Digest
- OpenSSL::Digest::DigestError
- OpenSSL::Engine
- OpenSSL::Engine::EngineError
- OpenSSL::HMAC
- OpenSSL::HMACError
- OpenSSL::Netscape
- OpenSSL::Netscape::SPKI
- OpenSSL::Netscape::SPKIError
- OpenSSL::OCSP
- OpenSSL::OCSP::BasicResponse
- OpenSSL::OCSP::CertificateId
- OpenSSL::OCSP::OCSPError
- OpenSSL::OCSP::Request
- OpenSSL::OCSP::Response
- OpenSSL::OpenSSLError
- OpenSSL::PKCS12
- OpenSSL::PKCS12::PKCS12Error
- OpenSSL::PKCS5
- OpenSSL::PKCS5::PKCS5Error
- OpenSSL::PKCS7
- OpenSSL::PKCS7::PKCS7Error
- OpenSSL::PKCS7::RecipientInfo
- OpenSSL::PKCS7::SignerInfo
- OpenSSL::PKey
- OpenSSL::PKey::DH
- OpenSSL::PKey::DHError
- OpenSSL::PKey::DSA
- OpenSSL::PKey::DSAError
- OpenSSL::PKey::EC
- OpenSSL::PKey::EC::Group
- OpenSSL::PKey::EC::Group::Error
- OpenSSL::PKey::EC::Point
- OpenSSL::PKey::EC::Point::Error
- OpenSSL::PKey::ECError
- OpenSSL::PKey::PKey
- OpenSSL::PKey::PKeyError
- OpenSSL::PKey::RSA
- OpenSSL::PKey::RSAError
- OpenSSL::Random
- OpenSSL::Random::RandomError
- OpenSSL::SSL
- OpenSSL::SSL::Nonblock
- OpenSSL::SSL::SSLContext
- OpenSSL::SSL::SSLError
- OpenSSL::SSL::SSLErrorWaitReadable
- OpenSSL::SSL::SSLErrorWaitWritable
- OpenSSL::SSL::SSLServer
- OpenSSL::SSL::SSLSocket
- OpenSSL::SSL::Session
- OpenSSL::SSL::Session::SessionError
- OpenSSL::SSL::SocketForwarder
- OpenSSL::X509
- OpenSSL::X509::Attribute
- OpenSSL::X509::AttributeError
- OpenSSL::X509::CRL
- OpenSSL::X509::CRLError
- OpenSSL::X509::Certificate
- OpenSSL::X509::CertificateError
- OpenSSL::X509::Extension
- OpenSSL::X509::ExtensionError
- OpenSSL::X509::ExtensionFactory
- OpenSSL::X509::Name
- OpenSSL::X509::Name::RFC2253DN
- OpenSSL::X509::NameError
- OpenSSL::X509::Request
- OpenSSL::X509::RequestError
- OpenSSL::X509::Revoked
- OpenSSL::X509::RevokedError
- OpenSSL::X509::Store
- OpenSSL::X509::StoreContext
- OpenSSL::X509::StoreError
- unknown

No matching classes.

# OpenSSL::X509::CRL

### Public Class Methods

new(p1 = v1) click to toggle source

                   static VALUE
    ossl_x509crl_initialize(int argc, VALUE *argv, VALUE self)
    {
        BIO *in;
        X509_CRL *crl, *x = DATA_PTR(self);
        VALUE arg;

        if (rb_scan_args(argc, argv, "01", &arg) == 0) {
            return self;
        }
        arg = ossl_to_der_if_possible(arg);
        in = ossl_obj2bio(arg);
        crl = PEM_read_bio_X509_CRL(in, &x, NULL, NULL);
        DATA_PTR(self) = x;
        if (!crl) {
            OSSL_BIO_reset(in);
            crl = d2i_X509_CRL_bio(in, &x);
            DATA_PTR(self) = x;
        }
        BIO_free(in);
        if (!crl) ossl_raise(eX509CRLError, NULL);

        return self;
    }

### Public Instance Methods

add_extension(p1) click to toggle source

                   static VALUE
    ossl_x509crl_add_extension(VALUE self, VALUE extension)
    {
        X509_CRL *crl;
        X509_EXTENSION *ext;

        GetX509CRL(self, crl);
        ext = DupX509ExtPtr(extension);
        if (!X509_CRL_add_ext(crl, ext, -1)) { /* DUPs ext - FREE it */
            X509_EXTENSION_free(ext);
            ossl_raise(eX509CRLError, NULL);
        }
        X509_EXTENSION_free(ext);

        return extension;
    }

add_revoked(p1) click to toggle source

                   static VALUE
    ossl_x509crl_add_revoked(VALUE self, VALUE revoked)
    {
        X509_CRL *crl;
        X509_REVOKED *rev;

        GetX509CRL(self, crl);
        rev = DupX509RevokedPtr(revoked);
        if (!X509_CRL_add0_revoked(crl, rev)) { /* NO DUP - don't free! */
            ossl_raise(eX509CRLError, NULL);
        }
        X509_CRL_sort(crl);

        return revoked;
    }

extensions() click to toggle source

Gets X509v3 extensions as array of X509Ext objects

                   static VALUE
    ossl_x509crl_get_extensions(VALUE self)
    {
        X509_CRL *crl;
        int count, i;
        X509_EXTENSION *ext;
        VALUE ary;

        GetX509CRL(self, crl);
        count = X509_CRL_get_ext_count(crl);
        if (count < 0) {
            OSSL_Debug("count < 0???");
            return rb_ary_new();
        }
        ary = rb_ary_new2(count);
        for (i=0; i<count; i++) {
            ext = X509_CRL_get_ext(crl, i); /* NO DUP - don't free! */
            rb_ary_push(ary, ossl_x509ext_new(ext));
        }

        return ary;
    }

extensions=(p1) click to toggle source

Sets X509_EXTENSIONs

                   static VALUE
    ossl_x509crl_set_extensions(VALUE self, VALUE ary)
    {
        X509_CRL *crl;
        X509_EXTENSION *ext;
        int i;

        Check_Type(ary, T_ARRAY);
        /* All ary members should be X509 Extensions */
        for (i=0; i<RARRAY_LEN(ary); i++) {
            OSSL_Check_Kind(RARRAY_PTR(ary)[i], cX509Ext);
        }
        GetX509CRL(self, crl);
        sk_X509_EXTENSION_pop_free(crl->crl->extensions, X509_EXTENSION_free);
        crl->crl->extensions = NULL;
        for (i=0; i<RARRAY_LEN(ary); i++) {
            ext = DupX509ExtPtr(RARRAY_PTR(ary)[i]);
            if(!X509_CRL_add_ext(crl, ext, -1)) { /* DUPs ext - FREE it */
                X509_EXTENSION_free(ext);
                ossl_raise(eX509CRLError, NULL);
            }
            X509_EXTENSION_free(ext);
        }

        return ary;
    }

issuer() click to toggle source

                   static VALUE
    ossl_x509crl_get_issuer(VALUE self)
    {
        X509_CRL *crl;

        GetX509CRL(self, crl);

        return ossl_x509name_new(X509_CRL_get_issuer(crl)); /* NO DUP - don't free */
    }

issuer=(p1) click to toggle source

                   static VALUE
    ossl_x509crl_set_issuer(VALUE self, VALUE issuer)
    {
        X509_CRL *crl;

        GetX509CRL(self, crl);

        if (!X509_CRL_set_issuer_name(crl, GetX509NamePtr(issuer))) { /* DUPs name */
            ossl_raise(eX509CRLError, NULL);
        }
        return issuer;
    }

last_update() click to toggle source

                   static VALUE
    ossl_x509crl_get_last_update(VALUE self)
    {
        X509_CRL *crl;

        GetX509CRL(self, crl);

        return asn1time_to_time(X509_CRL_get_lastUpdate(crl));
    }

last_update=(p1) click to toggle source

                   static VALUE
    ossl_x509crl_set_last_update(VALUE self, VALUE time)
    {
        X509_CRL *crl;
        time_t sec;

        sec = time_to_time_t(time);
        GetX509CRL(self, crl);
        if (!X509_time_adj(crl->crl->lastUpdate, 0, &sec)) {
            ossl_raise(eX509CRLError, NULL);
        }

        return time;
    }

next_update() click to toggle source

                   static VALUE
    ossl_x509crl_get_next_update(VALUE self)
    {
        X509_CRL *crl;

        GetX509CRL(self, crl);

        return asn1time_to_time(X509_CRL_get_nextUpdate(crl));
    }

next_update=(p1) click to toggle source

                   static VALUE
    ossl_x509crl_set_next_update(VALUE self, VALUE time)
    {
        X509_CRL *crl;
        time_t sec;

        sec = time_to_time_t(time);
        GetX509CRL(self, crl);
        /* This must be some thinko in OpenSSL */
        if (!(crl->crl->nextUpdate = X509_time_adj(crl->crl->nextUpdate, 0, &sec))){
            ossl_raise(eX509CRLError, NULL);
        }

        return time;
    }

revoked() click to toggle source

                   static VALUE
    ossl_x509crl_get_revoked(VALUE self)
    {
        X509_CRL *crl;
        int i, num;
        X509_REVOKED *rev;
        VALUE ary, revoked;

        GetX509CRL(self, crl);
        num = sk_X509_REVOKED_num(X509_CRL_get_REVOKED(crl));
        if (num < 0) {
            OSSL_Debug("num < 0???");
            return rb_ary_new();
        }
        ary = rb_ary_new2(num);
        for(i=0; i<num; i++) {
            /* NO DUP - don't free! */
            rev = sk_X509_REVOKED_value(X509_CRL_get_REVOKED(crl), i);
            revoked = ossl_x509revoked_new(rev);
            rb_ary_push(ary, revoked);
        }

        return ary;
    }

revoked=(p1) click to toggle source

                   static VALUE
    ossl_x509crl_set_revoked(VALUE self, VALUE ary)
    {
        X509_CRL *crl;
        X509_REVOKED *rev;
        int i;

        Check_Type(ary, T_ARRAY);
        /* All ary members should be X509 Revoked */
        for (i=0; i<RARRAY_LEN(ary); i++) {
            OSSL_Check_Kind(RARRAY_PTR(ary)[i], cX509Rev);
        }
        GetX509CRL(self, crl);
        sk_X509_REVOKED_pop_free(crl->crl->revoked, X509_REVOKED_free);
        crl->crl->revoked = NULL;
        for (i=0; i<RARRAY_LEN(ary); i++) {
            rev = DupX509RevokedPtr(RARRAY_PTR(ary)[i]);
            if (!X509_CRL_add0_revoked(crl, rev)) { /* NO DUP - don't free! */
                ossl_raise(eX509CRLError, NULL);
            }
        }
        X509_CRL_sort(crl);

        return ary;
    }

sign(p1, p2) click to toggle source

                   static VALUE
    ossl_x509crl_sign(VALUE self, VALUE key, VALUE digest)
    {
        X509_CRL *crl;
        EVP_PKEY *pkey;
        const EVP_MD *md;

        GetX509CRL(self, crl);
        pkey = GetPrivPKeyPtr(key); /* NO NEED TO DUP */
        md = GetDigestPtr(digest);
        if (!X509_CRL_sign(crl, pkey, md)) {
            ossl_raise(eX509CRLError, NULL);
        }

        return self;
    }

signature_algorithm() click to toggle source

                   static VALUE
    ossl_x509crl_get_signature_algorithm(VALUE self)
    {
        X509_CRL *crl;
        BIO *out;
        BUF_MEM *buf;
        VALUE str;

        GetX509CRL(self, crl);
        if (!(out = BIO_new(BIO_s_mem()))) {
            ossl_raise(eX509CRLError, NULL);
        }
        if (!i2a_ASN1_OBJECT(out, crl->sig_alg->algorithm)) {
            BIO_free(out);
            ossl_raise(eX509CRLError, NULL);
        }
        BIO_get_mem_ptr(out, &buf);
        str = rb_str_new(buf->data, buf->length);
        BIO_free(out);
        return str;
    }

to_der() click to toggle source

                   static VALUE
    ossl_x509crl_to_der(VALUE self)
    {
        X509_CRL *crl;
        BIO *out;
        BUF_MEM *buf;
        VALUE str;

        GetX509CRL(self, crl);
        if (!(out = BIO_new(BIO_s_mem()))) {
            ossl_raise(eX509CRLError, NULL);
        }
        if (!i2d_X509_CRL_bio(out, crl)) {
            BIO_free(out);
            ossl_raise(eX509CRLError, NULL);
        }
        BIO_get_mem_ptr(out, &buf);
        str = rb_str_new(buf->data, buf->length);
        BIO_free(out);

        return str;
    }

to_pem() click to toggle source

                   static VALUE
    ossl_x509crl_to_pem(VALUE self)
    {
        X509_CRL *crl;
        BIO *out;
        BUF_MEM *buf;
        VALUE str;

        GetX509CRL(self, crl);
        if (!(out = BIO_new(BIO_s_mem()))) {
            ossl_raise(eX509CRLError, NULL);
        }
        if (!PEM_write_bio_X509_CRL(out, crl)) {
            BIO_free(out);
            ossl_raise(eX509CRLError, NULL);
        }
        BIO_get_mem_ptr(out, &buf);
        str = rb_str_new(buf->data, buf->length);
        BIO_free(out);

        return str;
    }

Also aliased as: to_s
to_s() click to toggle source
Alias for: to_pem
to_text() click to toggle source

                   static VALUE
    ossl_x509crl_to_text(VALUE self)
    {
        X509_CRL *crl;
        BIO *out;
        BUF_MEM *buf;
        VALUE str;

        GetX509CRL(self, crl);
        if (!(out = BIO_new(BIO_s_mem()))) {
            ossl_raise(eX509CRLError, NULL);
        }
        if (!X509_CRL_print(out, crl)) {
            BIO_free(out);
            ossl_raise(eX509CRLError, NULL);
        }
        BIO_get_mem_ptr(out, &buf);
        str = rb_str_new(buf->data, buf->length);
        BIO_free(out);

        return str;
    }

verify(p1) click to toggle source

                   static VALUE
    ossl_x509crl_verify(VALUE self, VALUE key)
    {
        X509_CRL *crl;
        int ret;

        GetX509CRL(self, crl);
        if ((ret = X509_CRL_verify(crl, GetPKeyPtr(key))) < 0) {
            ossl_raise(eX509CRLError, NULL);
        }
        if (ret == 1) {
            return Qtrue;
        }

        return Qfalse;
    }

version() click to toggle source

                   static VALUE
    ossl_x509crl_get_version(VALUE self)
    {
        X509_CRL *crl;
        long ver;

        GetX509CRL(self, crl);
        ver = X509_CRL_get_version(crl);

        return LONG2NUM(ver);
    }

version=(p1) click to toggle source

                   static VALUE
    ossl_x509crl_set_version(VALUE self, VALUE version)
    {
        X509_CRL *crl;
        long ver;

        if ((ver = NUM2LONG(version)) < 0) {
            ossl_raise(eX509CRLError, "version must be >= 0!");
        }
        GetX509CRL(self, crl);
        if (!X509_CRL_set_version(crl, ver)) {
            ossl_raise(eX509CRLError, NULL);
        }

        return version;
    }