Class: OpenSSL::ASN1::Constructive (Ruby 2.7.3)
Description: Class : OpenSSL::ASN1::Constructive - Ruby 2.7.3

### Home Classes Methods

### In Files

- openssl/ossl_asn1.c

### Parent

OpenSSL::ASN1::ASN1Data

### Methods

- ::new
- #each
- #to_der

### Included Modules

- Enumerable

### Class/Module Index

Quicksearch

- IO
- IO::WaitReadable
- IO::WaitWritable
- Integer
- OpenSSL
- 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::ExtConfig
- OpenSSL::HMAC
- OpenSSL::HMACError
- OpenSSL::KDF
- OpenSSL::KDF::KDFError
- 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::OCSP::SingleResponse
- OpenSSL::OpenSSLError
- OpenSSL::PKCS12
- OpenSSL::PKCS12::PKCS12Error
- OpenSSL::PKCS5
- 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::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

No matching classes.

# OpenSSL::ASN1::Constructive

The parent class for all constructed encodings. The value attribute of a `Constructive` is always an Array. Attributes are the same as for `ASN1Data`, with the addition of tagging.

## SET and SEQUENCE¶ ↑

Most constructed encodings come in the form of a SET or a SEQUENCE. These encodings are represented by one of the two sub-classes of Constructive:

- OpenSSL::ASN1::Set

- OpenSSL::ASN1::Sequence

Please note that tagged sequences and sets are still parsed as instances of `ASN1Data`. Find further details on tagged values there.

### Example - constructing a SEQUENCE¶ ↑

    int = OpenSSL::ASN1::Integer.new(1)
    str = OpenSSL::ASN1::PrintableString.new('abc')
    sequence = OpenSSL::ASN1::Sequence.new( [ int, str ] )

### Example - constructing a SET¶ ↑

    int = OpenSSL::ASN1::Integer.new(1)
    str = OpenSSL::ASN1::PrintableString.new('abc')
    set = OpenSSL::ASN1::Set.new( [ int, str ] )

### Attributes

tagging[RW]

May be used as a hint for encoding a value either implicitly or explicitly by setting it either to `:IMPLICIT` or to `:EXPLICIT`. tagging is not set when a ASN.1 structure is parsed using `OpenSSL::ASN1.decode`.

### Public Class Methods

OpenSSL::ASN1::Primitive.new(value [, tag, tagging, tag_class ]) => Primitive click to toggle source

value: is mandatory.

tag: optional, may be specified for tagged values. If no tag is specified, the UNIVERSAL tag corresponding to the `Primitive` sub-class is used by default.

tagging: may be used as an encoding hint to encode a value either explicitly or implicitly, see `ASN1` for possible values.

tag_class: if tag and tagging are `nil` then this is set to `:UNIVERSAL` by default. If either tag or tagging are set then `:CONTEXT_SPECIFIC` is used as the default. For possible values please cf. `ASN1`.

## Example¶ ↑

    int = OpenSSL::ASN1::Integer.new(42)
    zero_tagged_int = OpenSSL::ASN1::Integer.new(42, 0, :IMPLICIT)
    private_explicit_zero_tagged_int = OpenSSL::ASN1::Integer.new(42, 0, :EXPLICIT, :PRIVATE)

                   static VALUE
    ossl_asn1_initialize(int argc, VALUE *argv, VALUE self)
    {
        VALUE value, tag, tagging, tag_class;
        int default_tag;

        rb_scan_args(argc, argv, "13", &value, &tag, &tagging, &tag_class);
        default_tag = ossl_asn1_default_tag(self);

        if (default_tag == -1 || argc > 1) {
            if(NIL_P(tag))
                ossl_raise(eASN1Error, "must specify tag number");
            if(!NIL_P(tagging) && !SYMBOL_P(tagging))
                ossl_raise(eASN1Error, "invalid tagging method");
            if(NIL_P(tag_class)) {
                if (NIL_P(tagging))
                    tag_class = sym_UNIVERSAL;
                else
                    tag_class = sym_CONTEXT_SPECIFIC;
            }
            if(!SYMBOL_P(tag_class))
                ossl_raise(eASN1Error, "invalid tag class");
        }
        else{
            tag = INT2NUM(default_tag);
            tagging = Qnil;
            tag_class = sym_UNIVERSAL;
        }
        ossl_asn1_set_tag(self, tag);
        ossl_asn1_set_value(self, value);
        ossl_asn1_set_tagging(self, tagging);
        ossl_asn1_set_tag_class(self, tag_class);
        ossl_asn1_set_indefinite_length(self, Qfalse);
        if (default_tag == V_ASN1_BIT_STRING)
            rb_ivar_set(self, sivUNUSED_BITS, INT2FIX(0));

        return self;
    }

### Public Instance Methods

each { |asn1| block } => asn1_ary click to toggle source

Calls the given block once for each element in self, passing that element as parameter asn1. If no block is given, an enumerator is returned instead.

## Example¶ ↑

    asn1_ary.each do |asn1|
      puts asn1
    end

                   static VALUE
    ossl_asn1cons_each(VALUE self)
    {
        rb_block_call(ossl_asn1_get_value(self), id_each, 0, 0, 0, 0);

        return self;
    }

to_der => DER-encoded String click to toggle source

See `ASN1Data#to_der` for details.

                   static VALUE
    ossl_asn1cons_to_der(VALUE self)
    {
        VALUE ary, str;
        long i;
        int indef_len;

        indef_len = RTEST(ossl_asn1_get_indefinite_length(self));
        ary = rb_convert_type(ossl_asn1_get_value(self), T_ARRAY, "Array", "to_a");
        str = rb_str_new(NULL, 0);
        for (i = 0; i < RARRAY_LEN(ary); i++) {
            VALUE item = RARRAY_AREF(ary, i);

            if (indef_len && rb_obj_is_kind_of(item, cASN1EndOfContent)) {
                if (i != RARRAY_LEN(ary) - 1)
                    ossl_raise(eASN1Error, "illegal EOC octets in value");

                /*
                 * EOC is not really part of the content, but we required to add one
                 * at the end in the past.
                 */
                break;
            }

            item = ossl_to_der_if_possible(item);
            StringValue(item);
            rb_str_append(str, item);
        }

        return to_der_internal(self, 1, indef_len, str);
    }