# class OpenSSL::ASN1::Primitive

The parent class for all primitive encodings. Attributes are the same as for `ASN1Data`, with the addition of `tagging`. `Primitive` values can never be infinite length encodings, thus it is not possible to set the `infinite_length` attribute for `Primitive` and its sub-classes.

## `Primitive` sub-classes and their mapping to Ruby classes¶ ↑

- OpenSSL::ASN1::EndOfContent <=> `value` is always `nil`

- OpenSSL::ASN1::Boolean <=> `value` is a `Boolean`

- OpenSSL::ASN1::Integer <=> `value` is an `OpenSSL::BN`

- OpenSSL::ASN1::BitString <=> `value` is a `String`

- OpenSSL::ASN1::OctetString <=> `value` is a `String`

- OpenSSL::ASN1::Null <=> `value` is always `nil`

- OpenSSL::ASN1::Object <=> `value` is a `String`

- OpenSSL::ASN1::Enumerated <=> `value` is an `OpenSSL::BN`

- OpenSSL::ASN1::UTF8String <=> `value` is a `String`

- OpenSSL::ASN1::NumericString <=> `value` is a `String`

- OpenSSL::ASN1::PrintableString <=> `value` is a `String`

- OpenSSL::ASN1::T61String <=> `value` is a `String`

- OpenSSL::ASN1::VideotexString <=> `value` is a `String`

- OpenSSL::ASN1::IA5String <=> `value` is a `String`

- OpenSSL::ASN1::UTCTime <=> `value` is a `Time`

- OpenSSL::ASN1::GeneralizedTime <=> `value` is a `Time`

- OpenSSL::ASN1::GraphicString <=> `value` is a `String`

- OpenSSL::ASN1::ISO64String <=> `value` is a `String`

- OpenSSL::ASN1::GeneralString <=> `value` is a `String`

- OpenSSL::ASN1::UniversalString <=> `value` is a `String`

- OpenSSL::ASN1::BMPString <=> `value` is a `String`

## OpenSSL::ASN1::BitString¶ ↑

### Additional attributes¶ ↑

`unused_bits`: if the underlying BIT STRING's length is a multiple of 8 then `unused_bits` is 0. Otherwise `unused_bits` indicates the number of bits that are to be ignored in the final octet of the `BitString`'s `value`.

## `OpenSSL::ASN1::ObjectId`¶ ↑

NOTE: While `OpenSSL::ASN1::ObjectId.new` will allocate a new `ObjectId`, it is not typically allocated this way, but rather that are received from parsed `ASN1` encodings.

### Additional attributes¶ ↑

- `sn`: the short name as defined in <openssl/objects.h>.

- `ln`: the long name as defined in <openssl/objects.h>.

- `oid`: the object identifier as a `String`, e.g. “1.2.3.4.5”

- `short_name`: alias for `sn`.

- `long_name`: alias for `ln`.

## Examples¶ ↑

With the `Exception` of OpenSSL::ASN1::EndOfContent, each `Primitive` class constructor takes at least one parameter, the `value`.

### Creating EndOfContent¶ ↑

    eoc = OpenSSL::ASN1::EndOfContent.new

### Creating any other `Primitive`¶ ↑

    prim = <class>.new(value) # <class> being one of the sub-classes except EndOfContent
    prim_zero_tagged_implicit = <class>.new(value, 0, :IMPLICIT)
    prim_zero_tagged_explicit = <class>.new(value, 0, :EXPLICIT)

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

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

### Public Instance Methods

to_der → DER-encoded String click to toggle source

See `ASN1Data#to_der` for details. *

    static VALUE
    ossl_asn1prim_to_der(VALUE self)
    {
        ASN1_TYPE *asn1;
        int tn, tc, explicit;
        long len, reallen;
        unsigned char *buf, *p;
        VALUE str;

        tn = NUM2INT(ossl_asn1_get_tag(self));
        tc = ossl_asn1_tag_class(self);
        explicit = ossl_asn1_is_explicit(self);
        asn1 = ossl_asn1_get_asn1type(self);

        len = ASN1_object_size(1, i2d_ASN1_TYPE(asn1, NULL), tn);
        if(!(buf = OPENSSL_malloc(len))){
            ASN1_TYPE_free(asn1);
            ossl_raise(eASN1Error, "cannot alloc buffer");
        }
        p = buf;
        if (tc == V_ASN1_UNIVERSAL) {
            i2d_ASN1_TYPE(asn1, &p);
        } else if (explicit) {
            ASN1_put_object(&p, 1, i2d_ASN1_TYPE(asn1, NULL), tn, tc);
            i2d_ASN1_TYPE(asn1, &p);
        } else {
            i2d_ASN1_TYPE(asn1, &p);
            *buf = tc | tn | (*buf & V_ASN1_CONSTRUCTED);
        }
        ASN1_TYPE_free(asn1);
        reallen = p - buf;
        assert(reallen <= len);
        str = ossl_buf2str((char *)buf, rb_long2int(reallen)); /* buf will be free in ossl_buf2str */

        return str;
    }