класс 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 = sym_UNIVERSAL;
            else
                tag_class = sym_CONTEXT_SPECIFIC;
        }
        if(!SYMBOL_P(tag_class))
            ossl_raise(eASN1Error, "invalid tag class");
        if (tagging == sym_IMPLICIT && NUM2INT(tag) > 31)
            ossl_raise(eASN1Error, "tag number for Universal too large");
    }
    else{
        tag = INT2NUM(ossl_asn1_default_tag(self));
        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_infinite_length(self, Qfalse);

    return self;
}

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

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

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

tag_class: если tag и tagging установлены в nil , то это устанавливается в :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_block_call(ossl_asn1_get_value(self), id_each, 0, 0, 0, 0);

    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 (rb_obj_class(self) == cASN1Sequence ||
            rb_obj_class(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 (rb_obj_class(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 = ASN1_object_size(constructed, RSTRING_LENINT(value), tag);
    length = ASN1_object_size(constructed, seq_len, tn);
    str = rb_str_new(0, length);
    p = (unsigned char *)RSTRING_PTR(str);
    if(tc == V_ASN1_UNIVERSAL)
        ASN1_put_object(&p, constructed, RSTRING_LENINT(value), tn, tc);
    else{
        if(explicit){
            ASN1_put_object(&p, constructed, seq_len, tn, tc);
            ASN1_put_object(&p, constructed, RSTRING_LENINT(value), tag, V_ASN1_UNIVERSAL);
        }
        else{
            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.