Element::hasIndefiniteLength() - Code Metrics - Inspection of "Add separate context specific type" - sop/asn1 - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 977674...95c197 )

by Joni

created 2019-05-05 07:19 UTC

Element::hasIndefiniteLength() A

↳ Parent: Element

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	4
ccs	2
cts	2
cp	1
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0
crap	1

<?php
declare(strict_types = 1);

namespace ASN1;

use ASN1\Component\Identifier;
use ASN1\Component\Length;
use ASN1\Exception\DecodeException;
use ASN1\Feature\ElementBase;
use ASN1\Type\Constructed;
use ASN1\Type\Primitive;
use ASN1\Type\StringType;
use ASN1\Type\TaggedType;
use ASN1\Type\TimeType;
use ASN1\Type\UnspecifiedType;
use ASN1\Type\Tagged\ApplicationType;
use ASN1\Type\Tagged\ContextSpecificType;
use ASN1\Type\Tagged\PrivateType;

/**
 * Base class for all ASN.1 type elements.
 */
abstract class Element implements ElementBase
{
    // Universal type tags
    const TYPE_EOC = 0x00;
    const TYPE_BOOLEAN = 0x01;
    const TYPE_INTEGER = 0x02;
    const TYPE_BIT_STRING = 0x03;
    const TYPE_OCTET_STRING = 0x04;
    const TYPE_NULL = 0x05;
    const TYPE_OBJECT_IDENTIFIER = 0x06;
    const TYPE_OBJECT_DESCRIPTOR = 0x07;
    const TYPE_EXTERNAL = 0x08;
    const TYPE_REAL = 0x09;
    const TYPE_ENUMERATED = 0x0a;
    const TYPE_EMBEDDED_PDV = 0x0b;
    const TYPE_UTF8_STRING = 0x0c;
    const TYPE_RELATIVE_OID = 0x0d;
    const TYPE_SEQUENCE = 0x10;
    const TYPE_SET = 0x11;
    const TYPE_NUMERIC_STRING = 0x12;
    const TYPE_PRINTABLE_STRING = 0x13;
    const TYPE_T61_STRING = 0x14;
    const TYPE_VIDEOTEX_STRING = 0x15;
    const TYPE_IA5_STRING = 0x16;
    const TYPE_UTC_TIME = 0x17;
    const TYPE_GENERALIZED_TIME = 0x18;
    const TYPE_GRAPHIC_STRING = 0x19;
    const TYPE_VISIBLE_STRING = 0x1a;
    const TYPE_GENERAL_STRING = 0x1b;
    const TYPE_UNIVERSAL_STRING = 0x1c;
    const TYPE_CHARACTER_STRING = 0x1d;
    const TYPE_BMP_STRING = 0x1e;
    
    /**
     * Mapping from universal type tag to implementation class name.
     *
     * @internal
     *
     * @var array
     */
    const MAP_TAG_TO_CLASS = [ /* @formatter:off */
        self::TYPE_EOC => Primitive\EOC::class,
        self::TYPE_BOOLEAN => Primitive\Boolean::class,
        self::TYPE_INTEGER => Primitive\Integer::class,
        self::TYPE_BIT_STRING => Primitive\BitString::class,
        self::TYPE_OCTET_STRING => Primitive\OctetString::class,
        self::TYPE_NULL => Primitive\NullType::class,
        self::TYPE_OBJECT_IDENTIFIER => Primitive\ObjectIdentifier::class,
        self::TYPE_OBJECT_DESCRIPTOR => Primitive\ObjectDescriptor::class,
        self::TYPE_REAL => Primitive\Real::class,
        self::TYPE_ENUMERATED => Primitive\Enumerated::class,
        self::TYPE_UTF8_STRING => Primitive\UTF8String::class,
        self::TYPE_RELATIVE_OID => Primitive\RelativeOID::class,
        self::TYPE_SEQUENCE => Constructed\Sequence::class,
        self::TYPE_SET => Constructed\Set::class,
        self::TYPE_NUMERIC_STRING => Primitive\NumericString::class,
        self::TYPE_PRINTABLE_STRING => Primitive\PrintableString::class,
        self::TYPE_T61_STRING => Primitive\T61String::class,
        self::TYPE_VIDEOTEX_STRING => Primitive\VideotexString::class,
        self::TYPE_IA5_STRING => Primitive\IA5String::class,
        self::TYPE_UTC_TIME => Primitive\UTCTime::class,
        self::TYPE_GENERALIZED_TIME => Primitive\GeneralizedTime::class,
        self::TYPE_GRAPHIC_STRING => Primitive\GraphicString::class,
        self::TYPE_VISIBLE_STRING => Primitive\VisibleString::class,
        self::TYPE_GENERAL_STRING => Primitive\GeneralString::class,
        self::TYPE_UNIVERSAL_STRING => Primitive\UniversalString::class,
        self::TYPE_CHARACTER_STRING => Primitive\CharacterString::class,
        self::TYPE_BMP_STRING => Primitive\BMPString::class
        /* @formatter:on */
    ];
    
    /**
     * Pseudotype for all string types.
     *
     * May be used as an expectation parameter.
     *
     * @var int
     */
    const TYPE_STRING = -1;
    
    /**
     * Pseudotype for all time types.
     *
     * May be used as an expectation parameter.
     *
     * @var int
     */
    const TYPE_TIME = -2;
    
    /**
     * Mapping from universal type tag to human readable name.
     *
     * @internal
     *
     * @var array
     */
    const MAP_TYPE_TO_NAME = [ /* @formatter:off */
        self::TYPE_EOC => "EOC",
        self::TYPE_BOOLEAN => "BOOLEAN",
        self::TYPE_INTEGER => "INTEGER",
        self::TYPE_BIT_STRING => "BIT STRING",
        self::TYPE_OCTET_STRING => "OCTET STRING",
        self::TYPE_NULL => "NULL",
        self::TYPE_OBJECT_IDENTIFIER => "OBJECT IDENTIFIER",
        self::TYPE_OBJECT_DESCRIPTOR => "ObjectDescriptor",
        self::TYPE_EXTERNAL => "EXTERNAL",
        self::TYPE_REAL => "REAL",
        self::TYPE_ENUMERATED => "ENUMERATED",
        self::TYPE_EMBEDDED_PDV => "EMBEDDED PDV",
        self::TYPE_UTF8_STRING => "UTF8String",
        self::TYPE_RELATIVE_OID => "RELATIVE-OID",
        self::TYPE_SEQUENCE => "SEQUENCE",
        self::TYPE_SET => "SET",
        self::TYPE_NUMERIC_STRING => "NumericString",
        self::TYPE_PRINTABLE_STRING => "PrintableString",
        self::TYPE_T61_STRING => "T61String",
        self::TYPE_VIDEOTEX_STRING => "VideotexString",
        self::TYPE_IA5_STRING => "IA5String",
        self::TYPE_UTC_TIME => "UTCTime",
        self::TYPE_GENERALIZED_TIME => "GeneralizedTime",
        self::TYPE_GRAPHIC_STRING => "GraphicString",
        self::TYPE_VISIBLE_STRING => "VisibleString",
        self::TYPE_GENERAL_STRING => "GeneralString",
        self::TYPE_UNIVERSAL_STRING => "UniversalString",
        self::TYPE_CHARACTER_STRING => "CHARACTER STRING",
        self::TYPE_BMP_STRING => "BMPString",
        self::TYPE_STRING => "Any String",
        self::TYPE_TIME => "Any Time"
        /* @formatter:on */
    ];
    
    /**
     * Element's type tag.
     *
     * @var int
     */
    protected $_typeTag;
    
    /**
     * Whether type shall be encoded with indefinite length.
     *
     * @var bool
     */
    protected $_indefiniteLength = false;
    
    /**
     *
     * @see \ASN1\Feature\ElementBase::typeClass()
     * @return int
     */
    abstract public function typeClass(): int;
    
    /**
     *
     * @see \ASN1\Feature\ElementBase::isConstructed()
     * @return bool
     */
    abstract public function isConstructed(): bool;
    
    /**
     * Get the content encoded in DER.
     *
     * Returns the DER encoded content without identifier and length header
     * octets.
     *
     * @return string
     */
    abstract protected function _encodedContentDER(): string;
    
    /**
     * Decode type-specific element from DER.
     *
     * @param Identifier $identifier Pre-parsed identifier
     * @param string $data DER data
     * @param int $offset Offset in data to the next byte after identifier
     * @throws DecodeException If decoding fails
     * @return ElementBase
     */
    protected static function _decodeFromDER(Identifier $identifier,
        string $data, int &$offset): ElementBase
    {
        throw new \BadMethodCallException(
            __METHOD__ . " must be implemented in derived class.");
    }
    
    /**
     * Decode element from DER data.
     *
     * @param string $data DER encoded data
     * @param int|null $offset Reference to the variable that contains offset
     *        into the data where to start parsing. Variable is updated to
     *        the offset next to the parsed element. If null, start from offset
     *        0.
     * @throws DecodeException If decoding fails
     * @throws \UnexpectedValueException If called in the context of an expected
     *         type, but decoding yields another type
     * @return ElementBase
     */
    public static function fromDER(string $data, int &$offset = null): ElementBase
    {
        $idx = $offset ?? 0;
        // decode identifier
        $identifier = Identifier::fromDER($data, $idx);
        // determine class that implements type specific decoding
        $cls = self::_determineImplClass($identifier);
        try {
            // decode remaining element
            $element = $cls::_decodeFromDER($identifier, $data, $idx);
        } catch (\LogicException $e) {
            // rethrow as a RuntimeException for unified exception handling
            throw new DecodeException(
                sprintf("Error while decoding %s.",
                    self::tagToName($identifier->intTag())), 0, $e);
        }
        // if called in the context of a concrete class, check
        // that decoded type matches the type of a calling class
        $called_class = get_called_class();
        if (self::class != $called_class) {
            if (!$element instanceof $called_class) {
                throw new \UnexpectedValueException(
                    sprintf("%s expected, got %s.", $called_class,
                        get_class($element)));
            }
        }
        // update offset for the caller
        if (isset($offset)) {
            $offset = $idx;
        }
        return $element;
    }
    
    /**
     *
     * @see \ASN1\Feature\Encodable::toDER()
     * @return string
     */
    public function toDER(): string
    {
        $identifier = new Identifier($this->typeClass(),
            $this->isConstructed() ? Identifier::CONSTRUCTED : Identifier::PRIMITIVE,
            $this->_typeTag);
        $content = $this->_encodedContentDER();
        if ($this->_indefiniteLength) {
            $length = new Length(0, true);
            $eoc = new Primitive\EOC();
            return $identifier->toDER() . $length->toDER() . $content .
                $eoc->toDER();
        } else {
            $length = new Length(strlen($content));
            return $identifier->toDER() . $length->toDER() . $content;
        }
    }
    
    /**
     *
     * @see \ASN1\Feature\ElementBase::tag()
     * @return int
     */
    public function tag(): int
    {
        return $this->_typeTag;
    }
    
    /**
     *
     * @see \ASN1\Feature\ElementBase::isType()
     * @return bool
     */
    public function isType(int $tag): bool
    {
        // if element is context specific
        if ($this->typeClass() == Identifier::CLASS_CONTEXT_SPECIFIC) {
            return false;
        }
        // negative tags identify an abstract pseudotype
        if ($tag < 0) {
            return $this->_isPseudoType($tag);
        }
        return $this->_isConcreteType($tag);
    }
    
    /**
     *
     * @see \ASN1\Feature\ElementBase::expectType()
     * @return ElementBase
     */
    public function expectType(int $tag): ElementBase
    {
        if (!$this->isType($tag)) {
            throw new \UnexpectedValueException(
                sprintf("%s expected, got %s.", self::tagToName($tag),
                    $this->_typeDescriptorString()));
        }
        return $this;
    }
    
    /**
     * Check whether the element is a concrete type of a given tag.
     *
     * @param int $tag
     * @return bool
     */
    private function _isConcreteType(int $tag): bool
    {
        // if tag doesn't match
        if ($this->tag() != $tag) {
            return false;
        }
        // if type is universal check that instance is of a correct class
        if ($this->typeClass() == Identifier::CLASS_UNIVERSAL) {
            $cls = self::_determineUniversalImplClass($tag);
            if (!$this instanceof $cls) {
                return false;
            }
        }
        return true;
    }
    
    /**
     * Check whether the element is a pseudotype.
     *
     * @param int $tag
     * @return bool
     */
    private function _isPseudoType(int $tag): bool
    {
        switch ($tag) {
            case self::TYPE_STRING:
                return $this instanceof StringType;
            case self::TYPE_TIME:
                return $this instanceof TimeType;
        }
        return false;
    }
    
    /**
     *
     * @see \ASN1\Feature\ElementBase::isTagged()
     * @return bool
     */
    public function isTagged(): bool
    {
        return $this instanceof TaggedType;
    }
    
    /**
     *
     * @see \ASN1\Feature\ElementBase::expectTagged()
     * @return TaggedType
     */
    public function expectTagged($tag = null): TaggedType
    {
        if (!$this->isTagged()) {
            throw new \UnexpectedValueException(
                sprintf("Context specific element expected, got %s.",
                    Identifier::classToName($this->typeClass())));
        }
        if (isset($tag) && $this->tag() != $tag) {
            throw new \UnexpectedValueException(
                sprintf("Tag %d expected, got %d.", $tag, $this->tag()));
        }
        return $this;
    }
    
    /**
     * Whether element has indefinite length.
     *
     * @return bool
     */
    public function hasIndefiniteLength(): bool
    {
        return $this->_indefiniteLength;
    }
    
    /**
     * Get self with indefinite length encoding set.
     *
     * @param bool $indefinite True for indefinite length, false for definite
     *        length
     * @return self
     */
    public function withIndefiniteLength(bool $indefinite = true): self
    {
        $obj = clone $this;
        $obj->_indefiniteLength = $indefinite;
        return $obj;
    }
    
    /**
     *
     * @see \ASN1\Feature\ElementBase::asElement()
     * @return Element
     */
    final public function asElement(): Element
    {
        return $this;
    }
    
    /**
     * Get element decorated with UnspecifiedType object.
     *
     * @return UnspecifiedType
     */
    public function asUnspecified(): UnspecifiedType
    {
        return new UnspecifiedType($this);
    }
    
    /**
     * Determine the class that implements the type.
     *
     * @param Identifier $identifier
     * @return string Class name
     */
    protected static function _determineImplClass(Identifier $identifier): string
    {
        switch ($identifier->typeClass()) {
            case Identifier::CLASS_UNIVERSAL:
                return self::_determineUniversalImplClass($identifier->intTag());
            case Identifier::CLASS_CONTEXT_SPECIFIC:
                return ContextSpecificType::class;
            case Identifier::CLASS_APPLICATION:
                return ApplicationType::class;
            case Identifier::CLASS_PRIVATE:
                return PrivateType::class;
        }
        throw new \UnexpectedValueException(
            sprintf("%s %d not implemented.",
                Identifier::classToName($identifier->typeClass()),
                $identifier->tag()));
    }
    
    /**
     * Determine the class that implements an universal type of the given tag.
     *
     * @param int $tag
     * @throws \UnexpectedValueException
     * @return string Class name
     */
    protected static function _determineUniversalImplClass(int $tag): string
    {
        if (!array_key_exists($tag, self::MAP_TAG_TO_CLASS)) {
            throw new \UnexpectedValueException(
                "Universal tag $tag not implemented.");
        }
        return self::MAP_TAG_TO_CLASS[$tag];
    }
    
    /**
     * Get textual description of the type for debugging purposes.
     *
     * @return string
     */
    protected function _typeDescriptorString(): string
    {
        if ($this->typeClass() == Identifier::CLASS_UNIVERSAL) {
            return self::tagToName($this->_typeTag);
        }
        return sprintf("%s TAG %d", Identifier::classToName($this->typeClass()),
            $this->_typeTag);
    }
    
    /**
     * Get human readable name for an universal tag.
     *
     * @param int $tag
     * @return string
     */
    public static function tagToName(int $tag): string
    {
        if (!array_key_exists($tag, self::MAP_TYPE_TO_NAME)) {
            return "TAG $tag";
        }
        return self::MAP_TYPE_TO_NAME[$tag];
    }
}


1		<?php
2		declare(strict_types = 1);
3
4		namespace ASN1;
5
6		use ASN1\Component\Identifier;
7		use ASN1\Component\Length;
8		use ASN1\Exception\DecodeException;
9		use ASN1\Feature\ElementBase;
10		use ASN1\Type\Constructed;
11		use ASN1\Type\Primitive;
12		use ASN1\Type\StringType;
13		use ASN1\Type\TaggedType;
14		use ASN1\Type\TimeType;
15		use ASN1\Type\UnspecifiedType;
16		use ASN1\Type\Tagged\ApplicationType;
17		use ASN1\Type\Tagged\ContextSpecificType;
18		use ASN1\Type\Tagged\PrivateType;
19
20		/**
21		* Base class for all ASN.1 type elements.
22		*/
23		abstract class Element implements ElementBase
24		{
25		// Universal type tags
26		const TYPE_EOC = 0x00;
27		const TYPE_BOOLEAN = 0x01;
28		const TYPE_INTEGER = 0x02;
29		const TYPE_BIT_STRING = 0x03;
30		const TYPE_OCTET_STRING = 0x04;
31		const TYPE_NULL = 0x05;
32		const TYPE_OBJECT_IDENTIFIER = 0x06;
33		const TYPE_OBJECT_DESCRIPTOR = 0x07;
34		const TYPE_EXTERNAL = 0x08;
35		const TYPE_REAL = 0x09;
36		const TYPE_ENUMERATED = 0x0a;
37		const TYPE_EMBEDDED_PDV = 0x0b;
38		const TYPE_UTF8_STRING = 0x0c;
39		const TYPE_RELATIVE_OID = 0x0d;
40		const TYPE_SEQUENCE = 0x10;
41		const TYPE_SET = 0x11;
42		const TYPE_NUMERIC_STRING = 0x12;
43		const TYPE_PRINTABLE_STRING = 0x13;
44		const TYPE_T61_STRING = 0x14;
45		const TYPE_VIDEOTEX_STRING = 0x15;
46		const TYPE_IA5_STRING = 0x16;
47		const TYPE_UTC_TIME = 0x17;
48		const TYPE_GENERALIZED_TIME = 0x18;
49		const TYPE_GRAPHIC_STRING = 0x19;
50		const TYPE_VISIBLE_STRING = 0x1a;
51		const TYPE_GENERAL_STRING = 0x1b;
52		const TYPE_UNIVERSAL_STRING = 0x1c;
53		const TYPE_CHARACTER_STRING = 0x1d;
54		const TYPE_BMP_STRING = 0x1e;
55
56		/**
57		* Mapping from universal type tag to implementation class name.
58		*
59		* @internal
60		*
61		* @var array
62		*/
63		const MAP_TAG_TO_CLASS = [ /* @formatter:off */
64		self::TYPE_EOC => Primitive\EOC::class,
65		self::TYPE_BOOLEAN => Primitive\Boolean::class,
66		self::TYPE_INTEGER => Primitive\Integer::class,
67		self::TYPE_BIT_STRING => Primitive\BitString::class,
68		self::TYPE_OCTET_STRING => Primitive\OctetString::class,
69		self::TYPE_NULL => Primitive\NullType::class,
70		self::TYPE_OBJECT_IDENTIFIER => Primitive\ObjectIdentifier::class,
71		self::TYPE_OBJECT_DESCRIPTOR => Primitive\ObjectDescriptor::class,
72		self::TYPE_REAL => Primitive\Real::class,
73		self::TYPE_ENUMERATED => Primitive\Enumerated::class,
74		self::TYPE_UTF8_STRING => Primitive\UTF8String::class,
75		self::TYPE_RELATIVE_OID => Primitive\RelativeOID::class,
76		self::TYPE_SEQUENCE => Constructed\Sequence::class,
77		self::TYPE_SET => Constructed\Set::class,
78		self::TYPE_NUMERIC_STRING => Primitive\NumericString::class,
79		self::TYPE_PRINTABLE_STRING => Primitive\PrintableString::class,
80		self::TYPE_T61_STRING => Primitive\T61String::class,
81		self::TYPE_VIDEOTEX_STRING => Primitive\VideotexString::class,
82		self::TYPE_IA5_STRING => Primitive\IA5String::class,
83		self::TYPE_UTC_TIME => Primitive\UTCTime::class,
84		self::TYPE_GENERALIZED_TIME => Primitive\GeneralizedTime::class,
85		self::TYPE_GRAPHIC_STRING => Primitive\GraphicString::class,
86		self::TYPE_VISIBLE_STRING => Primitive\VisibleString::class,
87		self::TYPE_GENERAL_STRING => Primitive\GeneralString::class,
88		self::TYPE_UNIVERSAL_STRING => Primitive\UniversalString::class,
89		self::TYPE_CHARACTER_STRING => Primitive\CharacterString::class,
90		self::TYPE_BMP_STRING => Primitive\BMPString::class
91		/* @formatter:on */
92		];
93
94		/**
95		* Pseudotype for all string types.
96		*
97		* May be used as an expectation parameter.
98		*
99		* @var int
100		*/
101		const TYPE_STRING = -1;
102
103		/**
104		* Pseudotype for all time types.
105		*
106		* May be used as an expectation parameter.
107		*
108		* @var int
109		*/
110		const TYPE_TIME = -2;
111
112		/**
113		* Mapping from universal type tag to human readable name.
114		*
115		* @internal
116		*
117		* @var array
118		*/
119		const MAP_TYPE_TO_NAME = [ /* @formatter:off */
120		self::TYPE_EOC => "EOC",
121		self::TYPE_BOOLEAN => "BOOLEAN",
122		self::TYPE_INTEGER => "INTEGER",
123		self::TYPE_BIT_STRING => "BIT STRING",
124		self::TYPE_OCTET_STRING => "OCTET STRING",
125		self::TYPE_NULL => "NULL",
126		self::TYPE_OBJECT_IDENTIFIER => "OBJECT IDENTIFIER",
127		self::TYPE_OBJECT_DESCRIPTOR => "ObjectDescriptor",
128		self::TYPE_EXTERNAL => "EXTERNAL",
129		self::TYPE_REAL => "REAL",
130		self::TYPE_ENUMERATED => "ENUMERATED",
131		self::TYPE_EMBEDDED_PDV => "EMBEDDED PDV",
132		self::TYPE_UTF8_STRING => "UTF8String",
133		self::TYPE_RELATIVE_OID => "RELATIVE-OID",
134		self::TYPE_SEQUENCE => "SEQUENCE",
135		self::TYPE_SET => "SET",
136		self::TYPE_NUMERIC_STRING => "NumericString",
137		self::TYPE_PRINTABLE_STRING => "PrintableString",
138		self::TYPE_T61_STRING => "T61String",
139		self::TYPE_VIDEOTEX_STRING => "VideotexString",
140		self::TYPE_IA5_STRING => "IA5String",
141		self::TYPE_UTC_TIME => "UTCTime",
142		self::TYPE_GENERALIZED_TIME => "GeneralizedTime",
143		self::TYPE_GRAPHIC_STRING => "GraphicString",
144		self::TYPE_VISIBLE_STRING => "VisibleString",
145		self::TYPE_GENERAL_STRING => "GeneralString",
146		self::TYPE_UNIVERSAL_STRING => "UniversalString",
147		self::TYPE_CHARACTER_STRING => "CHARACTER STRING",
148		self::TYPE_BMP_STRING => "BMPString",
149		self::TYPE_STRING => "Any String",
150		self::TYPE_TIME => "Any Time"
151		/* @formatter:on */
152		];
153
154		/**
155		* Element's type tag.
156		*
157		* @var int
158		*/
159		protected $_typeTag;
160
161		/**
162		* Whether type shall be encoded with indefinite length.
163		*
164		* @var bool
165		*/
166		protected $_indefiniteLength = false;
167
168		/**
169		*
170		* @see \ASN1\Feature\ElementBase::typeClass()
171		* @return int
172		*/
173		abstract public function typeClass(): int;
174
175		/**
176		*
177		* @see \ASN1\Feature\ElementBase::isConstructed()
178		* @return bool
179		*/
180		abstract public function isConstructed(): bool;
181
182		/**
183		* Get the content encoded in DER.
184		*
185		* Returns the DER encoded content without identifier and length header
186		* octets.
187		*
188		* @return string
189		*/
190		abstract protected function _encodedContentDER(): string;
191
192		/**
193		* Decode type-specific element from DER.
194		*
195		* @param Identifier $identifier Pre-parsed identifier
196		* @param string $data DER data
197		* @param int $offset Offset in data to the next byte after identifier
198		* @throws DecodeException If decoding fails
199		* @return ElementBase
200		*/
201	1	protected static function _decodeFromDER(Identifier $identifier,
202		string $data, int &$offset): ElementBase
203		{
204	1	throw new \BadMethodCallException(
205	1	__METHOD__ . " must be implemented in derived class.");
206		}
207
208		/**
209		* Decode element from DER data.
210		*
211		* @param string $data DER encoded data
212		* @param int\|null $offset Reference to the variable that contains offset
213		* into the data where to start parsing. Variable is updated to
214		* the offset next to the parsed element. If null, start from offset
215		* 0.
216		* @throws DecodeException If decoding fails
217		* @throws \UnexpectedValueException If called in the context of an expected
218		* type, but decoding yields another type
219		* @return ElementBase
220		*/
221	227	public static function fromDER(string $data, int &$offset = null): ElementBase
222		{
223	227	$idx = $offset ?? 0;
224		// decode identifier
225	227	$identifier = Identifier::fromDER($data, $idx);
226		// determine class that implements type specific decoding
227	227	$cls = self::_determineImplClass($identifier);
228		try {
229		// decode remaining element
230	226	$element = $cls::_decodeFromDER($identifier, $data, $idx);
231	41	} catch (\LogicException $e) {
232		// rethrow as a RuntimeException for unified exception handling
233	1	throw new DecodeException(
234	1	sprintf("Error while decoding %s.",
235	1	self::tagToName($identifier->intTag())), 0, $e);
236		}
237		// if called in the context of a concrete class, check
238		// that decoded type matches the type of a calling class
239	187	$called_class = get_called_class();
240	187	if (self::class != $called_class) {
241	158	if (!$element instanceof $called_class) {
242	1	throw new \UnexpectedValueException(
243	1	sprintf("%s expected, got %s.", $called_class,
244	1	get_class($element)));
245		}
246		}
247		// update offset for the caller
248	186	if (isset($offset)) {
249	23	$offset = $idx;
250		}
251	186	return $element;
252		}
253
254		/**
255		*
256		* @see \ASN1\Feature\Encodable::toDER()
257		* @return string
258		*/
259	130	public function toDER(): string
260		{
261	130	$identifier = new Identifier($this->typeClass(),
262	130	$this->isConstructed() ? Identifier::CONSTRUCTED : Identifier::PRIMITIVE,
263	130	$this->_typeTag);
264	130	$content = $this->_encodedContentDER();
265	130	if ($this->_indefiniteLength) {
266	1	$length = new Length(0, true);
267	1	$eoc = new Primitive\EOC();
268	1	return $identifier->toDER() . $length->toDER() . $content .
269	1	$eoc->toDER();
270		} else {
271	130	$length = new Length(strlen($content));
272	130	return $identifier->toDER() . $length->toDER() . $content;
273		}
274		}
275
276		/**
277		*
278		* @see \ASN1\Feature\ElementBase::tag()
279		* @return int
280		*/
281	109	public function tag(): int
282		{
283	109	return $this->_typeTag;
284		}
285
286		/**
287		*
288		* @see \ASN1\Feature\ElementBase::isType()
289		* @return bool
290		*/
291	27	public function isType(int $tag): bool
292		{
293		// if element is context specific
294	27	if ($this->typeClass() == Identifier::CLASS_CONTEXT_SPECIFIC) {
295	2	return false;
296		}
297		// negative tags identify an abstract pseudotype
298	25	if ($tag < 0) {
299	4	return $this->_isPseudoType($tag);
300		}
301	21	return $this->_isConcreteType($tag);
302		}
303
304		/**
305		*
306		* @see \ASN1\Feature\ElementBase::expectType()
307		* @return ElementBase
308		*/
309	16	public function expectType(int $tag): ElementBase
310		{
311	16	if (!$this->isType($tag)) {
312	6	throw new \UnexpectedValueException(
313	6	sprintf("%s expected, got %s.", self::tagToName($tag),
314	6	$this->_typeDescriptorString()));
315		}
316	10	return $this;
317		}
318
319		/**
320		* Check whether the element is a concrete type of a given tag.
321		*
322		* @param int $tag
323		* @return bool
324		*/
325	21	private function _isConcreteType(int $tag): bool
326		{
327		// if tag doesn't match
328	21	if ($this->tag() != $tag) {
329	9	return false;
330		}
331		// if type is universal check that instance is of a correct class
332	16	if ($this->typeClass() == Identifier::CLASS_UNIVERSAL) {
333	16	$cls = self::_determineUniversalImplClass($tag);
334	16	if (!$this instanceof $cls) {
335	1	return false;
336		}
337		}
338	15	return true;
339		}
340
341		/**
342		* Check whether the element is a pseudotype.
343		*
344		* @param int $tag
345		* @return bool
346		*/
347	4	private function _isPseudoType(int $tag): bool
348		{
349		switch ($tag) {
350	4	case self::TYPE_STRING:
351	1	return $this instanceof StringType;
352	3	case self::TYPE_TIME:
353	2	return $this instanceof TimeType;
354		}
355	1	return false;
356		}
357
358		/**
359		*
360		* @see \ASN1\Feature\ElementBase::isTagged()
361		* @return bool
362		*/
363	20	public function isTagged(): bool
364		{
365	20	return $this instanceof TaggedType;
366		}
367
368		/**
369		*
370		* @see \ASN1\Feature\ElementBase::expectTagged()
371		* @return TaggedType
372		*/
373	13	public function expectTagged($tag = null): TaggedType
374		{
375	13	if (!$this->isTagged()) {
376	1	throw new \UnexpectedValueException(
377	1	sprintf("Context specific element expected, got %s.",
378	1	Identifier::classToName($this->typeClass())));
379		}
380	12	if (isset($tag) && $this->tag() != $tag) {
381	5	throw new \UnexpectedValueException(
382	5	sprintf("Tag %d expected, got %d.", $tag, $this->tag()));
383		}
384	7	return $this;
385		}
386
387		/**
388		* Whether element has indefinite length.
389		*
390		* @return bool
391		*/
392	1	public function hasIndefiniteLength(): bool
393		{
394	1	return $this->_indefiniteLength;
395		}
396
397		/**
398		* Get self with indefinite length encoding set.
399		*
400		* @param bool $indefinite True for indefinite length, false for definite
401		* length
402		* @return self
403		*/
404	1	public function withIndefiniteLength(bool $indefinite = true): self
405		{
406	1	$obj = clone $this;
407	1	$obj->_indefiniteLength = $indefinite;
408	1	return $obj;
409		}
410
411		/**
412		*
413		* @see \ASN1\Feature\ElementBase::asElement()
414		* @return Element
415		*/
416	49	final public function asElement(): Element
417		{
418	49	return $this;
419		}
420
421		/**
422		* Get element decorated with UnspecifiedType object.
423		*
424		* @return UnspecifiedType
425		*/
426	36	public function asUnspecified(): UnspecifiedType
427		{
428	36	return new UnspecifiedType($this);
429		}
430
431		/**
432		* Determine the class that implements the type.
433		*
434		* @param Identifier $identifier
435		* @return string Class name
436		*/
437	230	protected static function _determineImplClass(Identifier $identifier): string
438		{
439	230	switch ($identifier->typeClass()) {
440	230	case Identifier::CLASS_UNIVERSAL:
441	212	return self::_determineUniversalImplClass($identifier->intTag());
442	34	case Identifier::CLASS_CONTEXT_SPECIFIC:
443	27	return ContextSpecificType::class;
444	7	case Identifier::CLASS_APPLICATION:
445	3	return ApplicationType::class;
446	4	case Identifier::CLASS_PRIVATE:
447	3	return PrivateType::class;
448		}
449	1	throw new \UnexpectedValueException(
450	1	sprintf("%s %d not implemented.",
451	1	Identifier::classToName($identifier->typeClass()),
452	1	$identifier->tag()));
453		}
454
455		/**
456		* Determine the class that implements an universal type of the given tag.
457		*
458		* @param int $tag
459		* @throws \UnexpectedValueException
460		* @return string Class name
461		*/
462	223	protected static function _determineUniversalImplClass(int $tag): string
463		{
464	223	if (!array_key_exists($tag, self::MAP_TAG_TO_CLASS)) {
465	1	throw new \UnexpectedValueException(
466	1	"Universal tag $tag not implemented.");
467		}
468	222	return self::MAP_TAG_TO_CLASS[$tag];
469		}
470
471		/**
472		* Get textual description of the type for debugging purposes.
473		*
474		* @return string
475		*/
476	6	protected function _typeDescriptorString(): string
477		{
478	6	if ($this->typeClass() == Identifier::CLASS_UNIVERSAL) {
479	4	return self::tagToName($this->_typeTag);
480		}
481	2	return sprintf("%s TAG %d", Identifier::classToName($this->typeClass()),
482	2	$this->_typeTag);
483		}
484
485		/**
486		* Get human readable name for an universal tag.
487		*
488		* @param int $tag
489		* @return string
490		*/
491	48	public static function tagToName(int $tag): string
492		{
493	48	if (!array_key_exists($tag, self::MAP_TYPE_TO_NAME)) {
494	1	return "TAG $tag";
495		}
496	47	return self::MAP_TYPE_TO_NAME[$tag];
497		}
498		}
499

sop / asn1

GitHub Access Token became invalid

Push — master ( 977674...95c197 )

Element::hasIndefiniteLength() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like