Class: OpenSSL::ASN1::Primitive (Ruby 2.3.7)
Description: Class : OpenSSL::ASN1::Primitive - Ruby 2.3.7

- Home
- Core 2.3.7
- Std-lib 2.3.7
- Downloads

Support for the Ruby 2.3 series has ended. See here for reference.

### Home Classes Methods

### In Files

- openssl/ossl_asn1.c

### Parent

OpenSSL::ASN1::ASN1Data

### Methods

- ::new
- #to_der

### Class/Module Index

Quicksearch

- Integer
- 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::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::OpenSSLError
- OpenSSL::PKCS12
- OpenSSL::PKCS12::PKCS12Error
- OpenSSL::PKCS5
- OpenSSL::PKCS5::PKCS5Error
- 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::SSLContext::ExtConfig
- OpenSSL::SSL::SSLError
- OpenSSL::SSL::SSLErrorWaitReadable
- OpenSSL::SSL::SSLErrorWaitWritable
- OpenSSL::SSL::SSLServer
- OpenSSL::SSL::SSLSocket
- OpenSSL::SSL::SSLSocket::ExtConfig
- 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
- unknown

No matching classes.

# 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 a `Number`

- 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 a `Number`

- 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 ::new will allocate a new ObjectId, it is not typically allocated this way, but rather that are received from parsed ASN1 encodings.

While ::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 = 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;
    }

### Public Instance Methods

to_der => DER-encoded String click to toggle source

See OpenSSL::ASN1::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 = ossl_asn1_object_size(1, ossl_i2d_ASN1_TYPE(asn1, NULL), tn);
        if(!(buf = OPENSSL_malloc(len))){
            ossl_ASN1_TYPE_free(asn1);
            ossl_raise(eASN1Error, "cannot alloc buffer");
        }
        p = buf;
        if (tc == V_ASN1_UNIVERSAL) {
            ossl_i2d_ASN1_TYPE(asn1, &p);
        } else if (explicit) {
            ossl_asn1_put_object(&p, 1, ossl_i2d_ASN1_TYPE(asn1, NULL), tn, tc);
            ossl_i2d_ASN1_TYPE(asn1, &p);
        } else {
            ossl_i2d_ASN1_TYPE(asn1, &p);
            *buf = tc | tn | (*buf & V_ASN1_CONSTRUCTED);
        }
        ossl_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;
    }