class OpenSSL::ASN1::Constructive - Documentation for Ruby 4.0
Description: class OpenSSL::ASN1::Constructive: The parent class for all constructed encodings. The _value_ attribute of a Constructive is always an Array.
Keywords: ruby,class,OpenSSL::ASN1::Constructive

🔍

No recent searches

# class 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
Source

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

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)

### Public Instance Methods

each { |asn1| block } → asn1_ary
Source

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

        return self;
    }

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

to_der → DER-encoded String
Source

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

See `ASN1Data#to_der` for details.