Class: RASN1::Types::Base Abstract

Inherits:
Object
  • Object
show all
Defined in:
lib/rasn1/types/base.rb

Overview

This class is abstract.

This is base class for all ASN.1 types.

Subclasses SHOULD define:

  • a TAG constant defining ASN.1 tag number,

  • a private method #value_to_der converting its #value to DER,

  • a private method #der_to_value converting DER into #value.

Define an optional value

An optional value may be defined using :optional key from #initialize:

Integer.new(:int, optional: true)

An optional value implies:

  • while parsing, if decoded tag is not optional expected tag, no ASN1Error is raised, and parser tries net tag,

  • while encoding, if #value is nil, this value is not encoded.

Define a default value

A default value may be defined using :default key from #initialize:

Integer.new(:int, default: 0)

A default value implies:

  • while parsing, if decoded tag is not expected tag, no ASN1Error is raised and parser sets default value to this tag. Then parser tries nex tag,

  • while encoding, if #value is equal to default value, this value is not encoded.

Define a tagged value

ASN.1 permits to define tagged values. By example:

-- context specific tag
CType ::= [0] EXPLICIT INTEGER
-- application specific tag
AType ::= [APPLICATION 1] EXPLICIT INTEGER
-- private tag
PType ::= [PRIVATE 2] EXPLICIT INTEGER

These types may be defined as:

ctype = RASN1::Types::Integer.new(:ctype, explicit: 0)                      # with explicit, default #asn1_class is :context
atype = RASN1::Types::Integer.new(:atype, explicit: 1, class: :application)
ptype = RASN1::Types::Integer.new(:ptype, explicit: 2, class: :private)

Sometimes, an EXPLICIT type should be CONSTRUCTED. To do that, use :constructed option:

ptype = RASN1::Types::Integer.new(:ptype, explicit: 2, class: :private, constructed: true)

Implicit tagged values may also be defined:

ctype_implicit = RASN1::Types::Integer.new(:ctype, implicit: 0)

Author:

  • Sylvain Daubert

Direct Known Subclasses

Any, Choice, Constructed, Primitive

Constant Summary collapse

CLASSES =

Allowed ASN.1 tag classes

{
 universal:   0x00,
 application: 0x40,
 context:     0x80,
 private:     0xc0
}
MAX_TAG =

Maximum ASN.1 tag number

0x1e
INDEFINITE_LENGTH =

Length value for indefinite length

0x80

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(name, options = {}) ⇒ Base

Returns a new instance of Base.

Parameters:

  • name (Symbol, String) —

    name for this tag in grammar

  • options (Hash) (defaults to: {})

Options Hash (options):

  • :class (Symbol) —

    ASN.1 tag class. Default value is :universal. If :explicit or :implicit: is defined, default value is :context.

  • :optional (::Boolean) —

    define this tag as optional. Default is false

  • :default (Object) —

    default value for DEFAULT tag

  • :value (Object) —

    value to set

  • :implicit (::Integer) —

    define an IMPLICIT tagged type

  • :explicit (::Integer) —

    define an EXPLICIT tagged type

  • :constructed (::Boolean) —

    if true, set type as constructed. May only be used when :explicit is defined, else it is discarded.



90
91
92
93
94
95
 
# File 'lib/rasn1/types/base.rb', line 90

def initialize(name, options={})
  @name = name
  @constructed = nil

  set_options options
end

Instance Attribute Details

#asn1_class ⇒ Symbol (readonly)

Returns:

  • (Symbol) 


64
65
66
 
# File 'lib/rasn1/types/base.rb', line 64

def asn1_class
  @asn1_class
end

#default ⇒ Object? (readonly)

Returns default value, if defined.

Returns:

  • (Object, nil) —

    default value, if defined



66
67
68
 
# File 'lib/rasn1/types/base.rb', line 66

def default
  @default
end

#name ⇒ Symbol, String

Returns:

  • (Symbol, String) 


62
63
64
 
# File 'lib/rasn1/types/base.rb', line 62

def name
  @name
end

#value ⇒ Object

Get value or default value



103
104
105
106
107
108
109
 
# File 'lib/rasn1/types/base.rb', line 103

def value
  if @value.nil?
    @default
  else
    @value
  end
end

Class Method Details

.type ⇒ String

Get ASN.1 type

Returns:

  • (String) 


72
73
74
75
 
# File 'lib/rasn1/types/base.rb', line 72

def self.type
  return @type if @type
  @type = self.to_s.gsub(/.*::/, '').gsub(/([a-z0-9])([A-Z])/, '\1 \2').upcase
end

Instance Method Details

#constructed? ⇒ ::Boolean

Returns true if this is a constructed type.

Returns:

  • (::Boolean) —

    true if this is a constructed type



153
154
155
 
# File 'lib/rasn1/types/base.rb', line 153

def constructed?
  !!((self.class < Constructed) ||  @constructed)
end

#explicit? ⇒ ::Boolean?

Say if a tagged type is explicit

Returns:

  • (::Boolean, nil) —

    return nil if not tagged, return true if explicit, else false



125
126
127
 
# File 'lib/rasn1/types/base.rb', line 125

def explicit?
  @tag.nil? ? @tag : @tag == :explicit
end

#implicit? ⇒ ::Boolean?

Say if a tagged type is implicit

Returns:

  • (::Boolean, nil) —

    return nil if not tagged, return true if implicit, else false



132
133
134
 
# File 'lib/rasn1/types/base.rb', line 132

def implicit?
  @tag.nil? ? @tag : @tag == :implicit
end

#initialize_copy(other) ⇒ Object

Used by #dup and #clone. Deep copy @value.



98
99
100
 
# File 'lib/rasn1/types/base.rb', line 98

def initialize_copy(other)
  @value = @value.nil? ? nil : @value.dup
end

#optional? ⇒ ::Boolean

Returns:

  • (::Boolean) 


112
113
114
 
# File 'lib/rasn1/types/base.rb', line 112

def optional?
  @optional
end

#parse!(der, ber: false) ⇒ Integer

This method is abstract.

This method SHOULD be partly implemented by subclasses to parse data. Subclasses SHOULD respond to #der_to_value.

Parse a DER string. This method updates object.

Parameters:

  • der (String) —

    DER string

  • ber (Boolean) (defaults to: false) —

    if true, accept BER encoding

Returns:

  • (Integer) —

    total number of parsed bytes

Raises:



181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
 
# File 'lib/rasn1/types/base.rb', line 181

def parse!(der, ber: false)
  return 0 unless check_tag(der)

  total_length, data = get_data(der, ber)
  if explicit?
    # Delegate to #explicit type to generate sub-tag
    type = explicit_type
    type.parse!(data)
    @value = type.value
  else
    der_to_value(data, ber: ber)
  end

  total_length
end

#primitive? ⇒ ::Boolean

Returns true if this is a primitive type.

Returns:

  • (::Boolean) —

    true if this is a primitive type



148
149
150
 
# File 'lib/rasn1/types/base.rb', line 148

def primitive?
  (self.class < Primitive) && !@constructed
end

#tag ⇒ Integer

Get tag value

Returns:



165
166
167
168
169
170
171
172
 
# File 'lib/rasn1/types/base.rb', line 165

def tag
  pc = if  @constructed.nil?
         self.class::ASN1_PC
       else
         Constructed::ASN1_PC
       end
  (@tag_value || self.class::TAG) | CLASSES[@asn1_class] | pc
end

#tagged? ⇒ ::Boolean

Say if this type is tagged or not

Returns:

  • (::Boolean) 


118
119
120
 
# File 'lib/rasn1/types/base.rb', line 118

def tagged?
  !@tag.nil?
end

#to_der ⇒ String

This method is abstract.

This method SHOULD be partly implemented by subclasses, which SHOULD respond to #value_to_der.

Returns DER-formated string.

Returns:

  • (String) —

    DER-formated string



139
140
141
142
143
144
145
 
# File 'lib/rasn1/types/base.rb', line 139

def to_der
  if self.class.const_defined?('TAG')
    build_tag
  else
    raise NotImplementedError, 'should be implemented by subclasses'
  end
end

#type ⇒ String

Get ASN.1 type

Returns:

  • (String) 


159
160
161
 
# File 'lib/rasn1/types/base.rb', line 159

def type
  self.class.type
end

#value_size ⇒ Integer

Give size in octets of encoded value

Returns:



199
200
201
 
# File 'lib/rasn1/types/base.rb', line 199

def value_size
  value_to_der.size
end