класс OpenSSL::ASN1::Constructive

Родитель:: OpenSSL::ASN1::ASN1Data
Включенные модули:: Enumerable

Базовый класс для всех составных кодировок. Атрибут value Constructive всегда является Array. Атрибуты такие же, как и для ASN1Data, с добавлением tagging.

SET и SEQUENCE

Большинство составных кодировок представлены в виде SET или SEQUENCE. Эти кодировки представлены одним из двух подклассов Constructive:

OpenSSL::ASN1::Set
OpenSSL::ASN1::Sequence

Обратите внимание, что помеченные последовательности и множества по-прежнему парсятся как экземпляры ASN1Data. Дополнительные сведения о помеченных значениях см. в Find.

Пример — создание SEQUENCE

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

Пример — создание SET

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

Примитивные значения бесконечной длины

Constructive используется напрямую только в случае кодировок примитивных значений бесконечной длины. Эти кодировки всегда являются составными, а содержимое value Array представляет собой либо универсальные частичные кодировки значения конечной длины, либо снова составные кодировки бесконечной длины (т. е. примитивные кодировки бесконечной длины могут быть рекурсивно составлены с другим значением бесконечной длины в уже значении бесконечной длины). Каждая частичная кодировка должна иметь тот же универсальный тип, что и общая кодировка. Значение общей кодировки состоит из конкатенации каждой частичной кодировки, взятой в порядке следования. Массив value внешнего значения бесконечной длины должен завершаться экземпляром OpenSSL::ASN1::EndOfContent.

Обратите внимание, что невозможно закодировать Constructive без установленного атрибута infinite_length в значение true. Вместо этого используйте OpenSSL::ASN1::Sequence или OpenSSL::ASN1::Set в этих случаях.

Пример — OCTET STRING бесконечной длины

partial1 = OpenSSL::ASN1::OctetString.new("\x01")
partial2 = OpenSSL::ASN1::OctetString.new("\x02")
inf_octets = OpenSSL::ASN1::Constructive.new( [ partial1,
                                                partial2,
                                                OpenSSL::ASN1::EndOfContent.new ],
                                              OpenSSL::ASN1::OCTET_STRING,
                                              nil,
                                              :UNIVERSAL )
# The real value of inf_octets is "\x01\x02", i.e. the concatenation
# of partial1 and partial2
inf_octets.infinite_length = true
der = inf_octets.to_der
asn1 = OpenSSL::ASN1.decode(der)
puts asn1.infinite_length # => true

Атрибуты

tagging[RW]

Может использоваться как подсказка для кодирования значения неявно или явно, установив его либо в :IMPLICIT, либо в :EXPLICIT. tagging не устанавливается при парсинге структуры ASN.1 с помощью OpenSSL::ASN1.decode.

Открытые методы класса

OpenSSL::ASN1::Primitive.new( value [, tag, tagging, tag_class ]) → Primitive Показать исходный код

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

    rb_scan_args(argc, argv, "13", &value, &tag, &tagging, &tag_class);
    if(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 = ID2SYM(sUNIVERSAL);
            else
                tag_class = ID2SYM(sCONTEXT_SPECIFIC);
        }
        if(!SYMBOL_P(tag_class))
            ossl_raise(eASN1Error, "invalid tag class");
        if(!NIL_P(tagging) && SYM2ID(tagging) == sIMPLICIT && NUM2INT(tag) > 31)
            ossl_raise(eASN1Error, "tag number for Universal too large");
    }
    else{
        tag = INT2NUM(ossl_asn1_default_tag(self));
        tagging = Qnil;
        tag_class = ID2SYM(sUNIVERSAL);
    }
    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_infinite_length(self, Qfalse);

    return self;
}

value: обязательно.

tag: необязательно, может быть указано для помеченных значений. Если tag не указано, используется универсальная метка, соответствующая подклассу Primitive по умолчанию.

tagging: может использоваться как подсказка для кодирования значения явно или неявно, см. ASN1 для возможных значений.

tag_class: если tag и tagging установлены, то это устанавливается в :UNIVERSAL по умолчанию. Если установлены либо tag, либо tagging, то используется :CONTEXT_SPECIFIC по умолчанию. Для возможных значений см. ASN1.

Пример

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)

Открытые методы экземпляра

each { |asn1| block } → asn1_ary Показать исходный код

static VALUE
ossl_asn1cons_each(VALUE self)
{
    rb_ary_each(ossl_asn1_get_value(self));
    return self;
}

Вызывает block один раз для каждого элемента в self, передавая этот элемент в качестве параметра asn1. Если блок не задан, возвращается перечислитель вместо него.

Пример

asn1_ary.each do |asn1|
  puts asn1
end

to_der → DER-encoded String Показать исходный код

static VALUE
ossl_asn1cons_to_der(VALUE self)
{
    int tag, tn, tc, explicit, constructed = 1;
    int found_prim = 0, seq_len;
    long length;
    unsigned char *p;
    VALUE value, str, inf_length;

    tn = NUM2INT(ossl_asn1_get_tag(self));
    tc = ossl_asn1_tag_class(self);
    inf_length = ossl_asn1_get_infinite_length(self);
    if (inf_length == Qtrue) {
        VALUE ary, example;
        constructed = 2;
        if (CLASS_OF(self) == cASN1Sequence ||
            CLASS_OF(self) == cASN1Set) {
            tag = ossl_asn1_default_tag(self);
        }
        else { /* must be a constructive encoding of a primitive value */
            ary = ossl_asn1_get_value(self);
            if (!rb_obj_is_kind_of(ary, rb_cArray))
                ossl_raise(eASN1Error, "Constructive value must be an Array");
            /* Recursively descend until a primitive value is found.
            The overall value of the entire constructed encoding
            is of the type of the first primitive encoding to be
            found. */
            while (!found_prim){
                example = rb_ary_entry(ary, 0);
                if (rb_obj_is_kind_of(example, cASN1Primitive)){
                    found_prim = 1;
                }
                else {
                    /* example is another ASN1Constructive */
                    if (!rb_obj_is_kind_of(example, cASN1Constructive)){
                        ossl_raise(eASN1Error, "invalid constructed encoding");
                        return Qnil; /* dummy */
                    }
                    ary = ossl_asn1_get_value(example);
                }
            }
            tag = ossl_asn1_default_tag(example);
        }
    }
    else {
        if (CLASS_OF(self) == cASN1Constructive)
            ossl_raise(eASN1Error, "Constructive shall only be used with infinite length");
        tag = ossl_asn1_default_tag(self);
    }
    explicit = ossl_asn1_is_explicit(self);
    value = join_der(ossl_asn1_get_value(self));

    seq_len = ossl_asn1_object_size(constructed, RSTRING_LENINT(value), tag);
    length = ossl_asn1_object_size(constructed, seq_len, tn);
    str = rb_str_new(0, length);
    p = (unsigned char *)RSTRING_PTR(str);
    if(tc == V_ASN1_UNIVERSAL)
        ossl_asn1_put_object(&p, constructed, RSTRING_LENINT(value), tn, tc);
    else{
        if(explicit){
            ossl_asn1_put_object(&p, constructed, seq_len, tn, tc);
            ossl_asn1_put_object(&p, constructed, RSTRING_LENINT(value), tag, V_ASN1_UNIVERSAL);
        }
        else{
            ossl_asn1_put_object(&p, constructed, RSTRING_LENINT(value), tn, tc);
        }
    }
    memcpy(p, RSTRING_PTR(value), RSTRING_LEN(value));
    p += RSTRING_LEN(value);

    /* In this case we need an additional EOC (one for the explicit part and
     * one for the Constructive itself. The EOC for the Constructive is
     * supplied by the user, but that for the "explicit wrapper" must be
     * added here.
     */
    if (explicit && inf_length == Qtrue) {
        ASN1_put_eoc(&p);
    }
    ossl_str_adjust(str, p);

    return str;
}

См. OpenSSL::ASN1::ASN1Data#to_der для получения подробностей.

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