sop / asn1

lib/ASN1/Type/PrimitiveType.php

Indentation +9 added lines, -9 removed lines

@@ -9,13 +9,13 @@
  */
 trait PrimitiveType
 {
-    /**
-     *
-     * @see \ASN1\Element::isConstructed()
-     * @return boolean
-     */
-    public function isConstructed(): bool
-    {
-        return false;
-    }
+	/**
+	 *
+	 * @see \ASN1\Element::isConstructed()
+	 * @return boolean
+	 */
+	public function isConstructed(): bool
+	{
+		return false;
+	}
 }

lib/ASN1/Util/Flags.php

Indentation +119 added lines, -119 removed lines

@@ -11,130 +11,130 @@
  */
 class Flags
 {
-    /**
-     * Flag octets.
-     *
-     * @var string $_flags
-     */
-    protected $_flags;
+	/**
+	 * Flag octets.
+	 *
+	 * @var string $_flags
+	 */
+	protected $_flags;
     
-    /**
-     * Number of flags.
-     *
-     * @var int $_width
-     */
-    protected $_width;
+	/**
+	 * Number of flags.
+	 *
+	 * @var int $_width
+	 */
+	protected $_width;
     
-    /**
-     * Constructor.
-     *
-     * @param number $flags Flags
-     * @param int $width The number of flags. If width is larger than number of
-     *        bits in $flags, zeroes are prepended to flag field.
-     */
-    public function __construct($flags, int $width)
-    {
-        if (!$width) {
-            $this->_flags = "";
-        } else {
-            // calculate number of unused bits in last octet
-            $last_octet_bits = $width % 8;
-            $unused_bits = $last_octet_bits ? 8 - $last_octet_bits : 0;
-            $num = gmp_init($flags);
-            // mask bits outside bitfield width
-            $mask = gmp_sub(gmp_init(1) << $width, 1);
-            $num &= $mask;
-            // shift towards MSB if needed
-            $data = gmp_export($num << $unused_bits, 1,
-                GMP_MSW_FIRST | GMP_BIG_ENDIAN);
-            $octets = unpack("C*", $data);
-            $bits = count($octets) * 8;
-            // pad with zeroes
-            while ($bits < $width) {
-                array_unshift($octets, 0);
-                $bits += 8;
-            }
-            $this->_flags = pack("C*", ...$octets);
-        }
-        $this->_width = $width;
-    }
+	/**
+	 * Constructor.
+	 *
+	 * @param number $flags Flags
+	 * @param int $width The number of flags. If width is larger than number of
+	 *        bits in $flags, zeroes are prepended to flag field.
+	 */
+	public function __construct($flags, int $width)
+	{
+		if (!$width) {
+			$this->_flags = "";
+		} else {
+			// calculate number of unused bits in last octet
+			$last_octet_bits = $width % 8;
+			$unused_bits = $last_octet_bits ? 8 - $last_octet_bits : 0;
+			$num = gmp_init($flags);
+			// mask bits outside bitfield width
+			$mask = gmp_sub(gmp_init(1) << $width, 1);
+			$num &= $mask;
+			// shift towards MSB if needed
+			$data = gmp_export($num << $unused_bits, 1,
+				GMP_MSW_FIRST | GMP_BIG_ENDIAN);
+			$octets = unpack("C*", $data);
+			$bits = count($octets) * 8;
+			// pad with zeroes
+			while ($bits < $width) {
+				array_unshift($octets, 0);
+				$bits += 8;
+			}
+			$this->_flags = pack("C*", ...$octets);
+		}
+		$this->_width = $width;
+	}
     
-    /**
-     * Initialize from BitString.
-     *
-     * @param BitString $bs
-     * @param int $width
-     * @return self
-     */
-    public static function fromBitString(BitString $bs, int $width): self
-    {
-        $num_bits = $bs->numBits();
-        $num = gmp_import($bs->string(), 1, GMP_MSW_FIRST | GMP_BIG_ENDIAN);
-        $num >>= $bs->unusedBits();
-        if ($num_bits < $width) {
-            $num <<= ($width - $num_bits);
-        }
-        return new self(gmp_strval($num, 10), $width);
-    }
+	/**
+	 * Initialize from BitString.
+	 *
+	 * @param BitString $bs
+	 * @param int $width
+	 * @return self
+	 */
+	public static function fromBitString(BitString $bs, int $width): self
+	{
+		$num_bits = $bs->numBits();
+		$num = gmp_import($bs->string(), 1, GMP_MSW_FIRST | GMP_BIG_ENDIAN);
+		$num >>= $bs->unusedBits();
+		if ($num_bits < $width) {
+			$num <<= ($width - $num_bits);
+		}
+		return new self(gmp_strval($num, 10), $width);
+	}
     
-    /**
-     * Check whether a bit at given index is set.
-     * Index 0 is the leftmost bit.
-     *
-     * @param int $idx
-     * @throws \OutOfBoundsException
-     * @return bool
-     */
-    public function test(int $idx): bool
-    {
-        if ($idx >= $this->_width) {
-            throw new \OutOfBoundsException("Index is out of bounds.");
-        }
-        // octet index
-        $oi = (int) floor($idx / 8);
-        $byte = $this->_flags[$oi];
-        // bit index
-        $bi = $idx % 8;
-        // index 0 is the most significant bit in byte
-        $mask = 0x01 << (7 - $bi);
-        return (ord($byte) & $mask) > 0;
-    }
+	/**
+	 * Check whether a bit at given index is set.
+	 * Index 0 is the leftmost bit.
+	 *
+	 * @param int $idx
+	 * @throws \OutOfBoundsException
+	 * @return bool
+	 */
+	public function test(int $idx): bool
+	{
+		if ($idx >= $this->_width) {
+			throw new \OutOfBoundsException("Index is out of bounds.");
+		}
+		// octet index
+		$oi = (int) floor($idx / 8);
+		$byte = $this->_flags[$oi];
+		// bit index
+		$bi = $idx % 8;
+		// index 0 is the most significant bit in byte
+		$mask = 0x01 << (7 - $bi);
+		return (ord($byte) & $mask) > 0;
+	}
     
-    /**
-     * Get flags as an octet string.
-     * Zeroes are appended to the last octet if width is not divisible by 8.
-     *
-     * @return string
-     */
-    public function string(): string
-    {
-        return $this->_flags;
-    }
+	/**
+	 * Get flags as an octet string.
+	 * Zeroes are appended to the last octet if width is not divisible by 8.
+	 *
+	 * @return string
+	 */
+	public function string(): string
+	{
+		return $this->_flags;
+	}
     
-    /**
-     * Get flags as a base 10 integer.
-     *
-     * @return string Integer as a string
-     */
-    public function number(): string
-    {
-        $num = gmp_import($this->_flags, 1, GMP_MSW_FIRST | GMP_BIG_ENDIAN);
-        $last_octet_bits = $this->_width % 8;
-        $unused_bits = $last_octet_bits ? 8 - $last_octet_bits : 0;
-        $num >>= $unused_bits;
-        return gmp_strval($num, 10);
-    }
+	/**
+	 * Get flags as a base 10 integer.
+	 *
+	 * @return string Integer as a string
+	 */
+	public function number(): string
+	{
+		$num = gmp_import($this->_flags, 1, GMP_MSW_FIRST | GMP_BIG_ENDIAN);
+		$last_octet_bits = $this->_width % 8;
+		$unused_bits = $last_octet_bits ? 8 - $last_octet_bits : 0;
+		$num >>= $unused_bits;
+		return gmp_strval($num, 10);
+	}
     
-    /**
-     * Get flags as a BitString.
-     * Unused bits are set accordingly. Trailing zeroes are not stripped.
-     *
-     * @return BitString
-     */
-    public function bitString(): BitString
-    {
-        $last_octet_bits = $this->_width % 8;
-        $unused_bits = $last_octet_bits ? 8 - $last_octet_bits : 0;
-        return new BitString($this->_flags, $unused_bits);
-    }
+	/**
+	 * Get flags as a BitString.
+	 * Unused bits are set accordingly. Trailing zeroes are not stripped.
+	 *
+	 * @return BitString
+	 */
+	public function bitString(): BitString
+	{
+		$last_octet_bits = $this->_width % 8;
+		$unused_bits = $last_octet_bits ? 8 - $last_octet_bits : 0;
+		return new BitString($this->_flags, $unused_bits);
+	}
 }

lib/ASN1/Feature/ElementBase.php

Indentation +68 added lines, -68 removed lines

@@ -12,79 +12,79 @@
  */
 interface ElementBase extends Encodable
 {
-    /**
-     * Get the class of the ASN.1 type.
-     *
-     * One of <code>Identifier::CLASS_*</code> constants.
-     *
-     * @return int
-     */
-    public function typeClass(): int;
+	/**
+	 * Get the class of the ASN.1 type.
+	 *
+	 * One of <code>Identifier::CLASS_*</code> constants.
+	 *
+	 * @return int
+	 */
+	public function typeClass(): int;
     
-    /**
-     * Check whether the element is constructed.
-     *
-     * Otherwise it's primitive.
-     *
-     * @return bool
-     */
-    public function isConstructed(): bool;
+	/**
+	 * Check whether the element is constructed.
+	 *
+	 * Otherwise it's primitive.
+	 *
+	 * @return bool
+	 */
+	public function isConstructed(): bool;
     
-    /**
-     * Get the tag of the element.
-     *
-     * Interpretation of the tag depends on the context. For example it may
-     * represent a universal type tag or a tag of an implicitly or explicitly
-     * tagged type.
-     *
-     * @return int
-     */
-    public function tag(): int;
+	/**
+	 * Get the tag of the element.
+	 *
+	 * Interpretation of the tag depends on the context. For example it may
+	 * represent a universal type tag or a tag of an implicitly or explicitly
+	 * tagged type.
+	 *
+	 * @return int
+	 */
+	public function tag(): int;
     
-    /**
-     * Check whether the element is a type of a given tag.
-     *
-     * @param int $tag Type tag
-     * @return boolean
-     */
-    public function isType($tag): bool;
+	/**
+	 * Check whether the element is a type of a given tag.
+	 *
+	 * @param int $tag Type tag
+	 * @return boolean
+	 */
+	public function isType($tag): bool;
     
-    /**
-     * Check whether the element is a type of a given tag.
-     *
-     * Throws an exception if expectation fails.
-     *
-     * @param int $tag Type tag
-     * @throws \UnexpectedValueException If the element type differs from the
-     *         expected
-     * @return ElementBase
-     */
-    public function expectType($tag): ElementBase;
+	/**
+	 * Check whether the element is a type of a given tag.
+	 *
+	 * Throws an exception if expectation fails.
+	 *
+	 * @param int $tag Type tag
+	 * @throws \UnexpectedValueException If the element type differs from the
+	 *         expected
+	 * @return ElementBase
+	 */
+	public function expectType($tag): ElementBase;
     
-    /**
-     * Check whether the element is tagged (context specific).
-     *
-     * @return bool
-     */
-    public function isTagged(): bool;
+	/**
+	 * Check whether the element is tagged (context specific).
+	 *
+	 * @return bool
+	 */
+	public function isTagged(): bool;
     
-    /**
-     * Check whether the element is tagged (context specific) and optionally has
-     * a given tag.
-     *
-     * Throws an exception if the element is not tagged or tag differs from
-     * the expected.
-     *
-     * @param int|null $tag Optional type tag
-     * @throws \UnexpectedValueException If expectation fails
-     * @return \ASN1\Type\TaggedType
-     */
-    public function expectTagged($tag = null): TaggedType;
+	/**
+	 * Check whether the element is tagged (context specific) and optionally has
+	 * a given tag.
+	 *
+	 * Throws an exception if the element is not tagged or tag differs from
+	 * the expected.
+	 *
+	 * @param int|null $tag Optional type tag
+	 * @throws \UnexpectedValueException If expectation fails
+	 * @return \ASN1\Type\TaggedType
+	 */
+	public function expectTagged($tag = null): TaggedType;
     
-    /**
-     * Get the object as an abstract Element instance.
-     *
-     * @return \ASN1\Element
-     */
-    public function asElement(): Element;
+	/**
+	 * Get the object as an abstract Element instance.
+	 *
+	 * @return \ASN1\Element
+	 */
+	public function asElement(): Element;
 }

lib/ASN1/Element.php

Indentation +411 added lines, -411 removed lines

@@ -20,439 +20,439 @@
  */
 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;
+	// 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_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 */
-    ];
+	/**
+	 * Mapping from universal type tag to implementation class name.
+	 *
+	 * @internal
+	 *
+	 * @var array
+	 */
+	const MAP_TAG_TO_CLASS = [
+		/* @formatter:off */
+		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 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;
+	/**
+	 * 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 = array(
-        /* @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 */
-    );
+	/**
+	 * Mapping from universal type tag to human readable name.
+	 *
+	 * @internal
+	 *
+	 * @var array
+	 */
+	const MAP_TYPE_TO_NAME = array(
+		/* @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;
+	/**
+	 * Element's type tag.
+	 *
+	 * @var int
+	 */
+	protected $_typeTag;
     
-    /**
-     *
-     * @see \ASN1\Feature\ElementBase::typeClass()
-     * @return int
-     */
-    abstract public function typeClass(): int;
+	/**
+	 *
+	 * @see \ASN1\Feature\ElementBase::typeClass()
+	 * @return int
+	 */
+	abstract public function typeClass(): int;
     
-    /**
-     *
-     * @see \ASN1\Feature\ElementBase::isConstructed()
-     * @return bool
-     */
-    abstract public function isConstructed(): bool;
+	/**
+	 *
+	 * @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;
+	/**
+	 * 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 self
-     */
-    protected static function _decodeFromDER(Identifier $identifier, string $data,
-        int &$offset): ElementBase
-    {
-        throw new \BadMethodCallException(
-            __METHOD__ . " must be implemented in derived class.");
-    }
+	/**
+	 * 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 self
+	 */
+	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 self
-     */
-    public static function fromDER(string $data, int &$offset = null): ElementBase
-    {
-        // decode identifier
-        $idx = $offset ? $offset : 0;
-        $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->tag())), 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 (__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;
-    }
+	/**
+	 * 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 self
+	 */
+	public static function fromDER(string $data, int &$offset = null): ElementBase
+	{
+		// decode identifier
+		$idx = $offset ? $offset : 0;
+		$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->tag())), 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 (__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();
-        $length = new Length(strlen($content));
-        return $identifier->toDER() . $length->toDER() . $content;
-    }
+	/**
+	 *
+	 * @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();
+		$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::tag()
+	 * @return int
+	 */
+	public function tag(): int
+	{
+		return $this->_typeTag;
+	}
     
-    /**
-     *
-     * @see \ASN1\Feature\ElementBase::isType()
-     * @return bool
-     */
-    public function isType($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::isType()
+	 * @return bool
+	 */
+	public function isType($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($tag): ElementBase
-    {
-        if (!$this->isType($tag)) {
-            throw new \UnexpectedValueException(
-                sprintf("%s expected, got %s.", self::tagToName($tag),
-                    $this->_typeDescriptorString()));
-        }
-        return $this;
-    }
+	/**
+	 *
+	 * @see \ASN1\Feature\ElementBase::expectType()
+	 * @return ElementBase
+	 */
+	public function expectType($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($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 concrete type of a given tag.
+	 *
+	 * @param int $tag
+	 * @return bool
+	 */
+	private function _isConcreteType($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($tag): bool
-    {
-        switch ($tag) {
-            case self::TYPE_STRING:
-                return $this instanceof StringType;
-            case self::TYPE_TIME:
-                return $this instanceof TimeType;
-        }
-        return false;
-    }
+	/**
+	 * Check whether the element is a pseudotype.
+	 *
+	 * @param int $tag
+	 * @return bool
+	 */
+	private function _isPseudoType($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::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;
-    }
+	/**
+	 *
+	 * @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;
+	}
     
-    /**
-     *
-     * @see \ASN1\Feature\ElementBase::asElement()
-     * @return Element
-     */
-    final public function asElement(): Element
-    {
-        return $this;
-    }
+	/**
+	 *
+	 * @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);
-    }
+	/**
+	 * 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
-    {
-        // tagged type
-        if ($identifier->isContextSpecific()) {
-            return TaggedType::class;
-        }
-        // universal class
-        if ($identifier->isUniversal()) {
-            return self::_determineUniversalImplClass(
-                intval($identifier->tag()));
-        }
-        throw new \UnexpectedValueException(
-            sprintf("%s %d not implemented.",
-                Identifier::classToName($identifier->typeClass()),
-                $identifier->tag()));
-    }
+	/**
+	 * Determine the class that implements the type.
+	 *
+	 * @param Identifier $identifier
+	 * @return string Class name
+	 */
+	protected static function _determineImplClass(Identifier $identifier): string
+	{
+		// tagged type
+		if ($identifier->isContextSpecific()) {
+			return TaggedType::class;
+		}
+		// universal class
+		if ($identifier->isUniversal()) {
+			return self::_determineUniversalImplClass(
+				intval($identifier->tag()));
+		}
+		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($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];
-    }
+	/**
+	 * 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($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 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($tag): string
-    {
-        if (!array_key_exists($tag, self::MAP_TYPE_TO_NAME)) {
-            return "TAG $tag";
-        }
-        return self::MAP_TYPE_TO_NAME[$tag];
-    }
+	/**
+	 * Get human readable name for an universal tag.
+	 *
+	 * @param int $tag
+	 * @return string
+	 */
+	public static function tagToName($tag): string
+	{
+		if (!array_key_exists($tag, self::MAP_TYPE_TO_NAME)) {
+			return "TAG $tag";
+		}
+		return self::MAP_TYPE_TO_NAME[$tag];
+	}
 }

lib/ASN1/Component/Identifier.php

Indentation +260 added lines, -260 removed lines

@@ -12,285 +12,285 @@
  */
 class Identifier implements Encodable
 {
-    // Type class enumerations
-    const CLASS_UNIVERSAL = 0b00;
-    const CLASS_APPLICATION = 0b01;
-    const CLASS_CONTEXT_SPECIFIC = 0b10;
-    const CLASS_PRIVATE = 0b11;
+	// Type class enumerations
+	const CLASS_UNIVERSAL = 0b00;
+	const CLASS_APPLICATION = 0b01;
+	const CLASS_CONTEXT_SPECIFIC = 0b10;
+	const CLASS_PRIVATE = 0b11;
     
-    /**
-     * Mapping from type class to human readable name.
-     *
-     * @internal
-     *
-     * @var array
-     */
-    const MAP_CLASS_TO_NAME = [ /* @formatter:off */
-        self::CLASS_UNIVERSAL => "UNIVERSAL", 
-        self::CLASS_APPLICATION => "APPLICATION", 
-        self::CLASS_CONTEXT_SPECIFIC => "CONTEXT SPECIFIC", 
-        self::CLASS_PRIVATE => "PRIVATE",
-        /* @formatter:on */
-    ];
+	/**
+	 * Mapping from type class to human readable name.
+	 *
+	 * @internal
+	 *
+	 * @var array
+	 */
+	const MAP_CLASS_TO_NAME = [ /* @formatter:off */
+		self::CLASS_UNIVERSAL => "UNIVERSAL", 
+		self::CLASS_APPLICATION => "APPLICATION", 
+		self::CLASS_CONTEXT_SPECIFIC => "CONTEXT SPECIFIC", 
+		self::CLASS_PRIVATE => "PRIVATE",
+		/* @formatter:on */
+	];
     
-    // P/C enumerations
-    const PRIMITIVE = 0b0;
-    const CONSTRUCTED = 0b1;
+	// P/C enumerations
+	const PRIMITIVE = 0b0;
+	const CONSTRUCTED = 0b1;
     
-    /**
-     * Type class.
-     *
-     * @var int
-     */
-    private $_class;
+	/**
+	 * Type class.
+	 *
+	 * @var int
+	 */
+	private $_class;
     
-    /**
-     * Primitive or Constructed.
-     *
-     * @var int
-     */
-    private $_pc;
+	/**
+	 * Primitive or Constructed.
+	 *
+	 * @var int
+	 */
+	private $_pc;
     
-    /**
-     * Content type tag.
-     *
-     * @var int|string
-     */
-    private $_tag;
+	/**
+	 * Content type tag.
+	 *
+	 * @var int|string
+	 */
+	private $_tag;
     
-    /**
-     * Constructor.
-     *
-     * @param int $class Type class
-     * @param int $pc Primitive / Constructed
-     * @param int|string $tag Type tag number
-     */
-    public function __construct(int $class, int $pc, $tag)
-    {
-        $this->_class = 0b11 & $class;
-        $this->_pc = 0b1 & $pc;
-        $this->_tag = $tag;
-    }
+	/**
+	 * Constructor.
+	 *
+	 * @param int $class Type class
+	 * @param int $pc Primitive / Constructed
+	 * @param int|string $tag Type tag number
+	 */
+	public function __construct(int $class, int $pc, $tag)
+	{
+		$this->_class = 0b11 & $class;
+		$this->_pc = 0b1 & $pc;
+		$this->_tag = $tag;
+	}
     
-    /**
-     * Decode identifier component 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 identifier. If null, start from
-     *        offset 0.
-     * @throws DecodeException If decoding fails
-     * @return self
-     */
-    public static function fromDER(string $data, int &$offset = null): self
-    {
-        $idx = $offset ? $offset : 0;
-        $datalen = strlen($data);
-        if ($idx >= $datalen) {
-            throw new DecodeException("Invalid offset.");
-        }
-        $byte = ord($data[$idx++]);
-        // bits 8 and 7 (class)
-        // 0 = universal, 1 = application, 2 = context-specific, 3 = private
-        $class = (0b11000000 & $byte) >> 6;
-        // bit 6 (0 = primitive / 1 = constructed)
-        $pc = (0b00100000 & $byte) >> 5;
-        // bits 5 to 1 (tag number)
-        $tag = (0b00011111 & $byte);
-        // long-form identifier
-        if (0x1f == $tag) {
-            $tag = self::_decodeLongFormTag($data, $idx);
-        }
-        if (isset($offset)) {
-            $offset = $idx;
-        }
-        return new self($class, $pc, $tag);
-    }
+	/**
+	 * Decode identifier component 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 identifier. If null, start from
+	 *        offset 0.
+	 * @throws DecodeException If decoding fails
+	 * @return self
+	 */
+	public static function fromDER(string $data, int &$offset = null): self
+	{
+		$idx = $offset ? $offset : 0;
+		$datalen = strlen($data);
+		if ($idx >= $datalen) {
+			throw new DecodeException("Invalid offset.");
+		}
+		$byte = ord($data[$idx++]);
+		// bits 8 and 7 (class)
+		// 0 = universal, 1 = application, 2 = context-specific, 3 = private
+		$class = (0b11000000 & $byte) >> 6;
+		// bit 6 (0 = primitive / 1 = constructed)
+		$pc = (0b00100000 & $byte) >> 5;
+		// bits 5 to 1 (tag number)
+		$tag = (0b00011111 & $byte);
+		// long-form identifier
+		if (0x1f == $tag) {
+			$tag = self::_decodeLongFormTag($data, $idx);
+		}
+		if (isset($offset)) {
+			$offset = $idx;
+		}
+		return new self($class, $pc, $tag);
+	}
     
-    /**
-     * Parse long form tag.
-     *
-     * @param string $data DER data
-     * @param int $offset Reference to the variable containing offset to data
-     * @throws DecodeException If decoding fails
-     * @return string Tag number
-     */
-    private static function _decodeLongFormTag(string $data, int &$offset): string
-    {
-        $datalen = strlen($data);
-        $tag = gmp_init(0, 10);
-        while (true) {
-            if ($offset >= $datalen) {
-                throw new DecodeException(
-                    "Unexpected end of data while decoding" .
-                         " long form identifier.");
-            }
-            $byte = ord($data[$offset++]);
-            $tag <<= 7;
-            $tag |= 0x7f & $byte;
-            // last byte has bit 8 set to zero
-            if (!(0x80 & $byte)) {
-                break;
-            }
-        }
-        return gmp_strval($tag, 10);
-    }
+	/**
+	 * Parse long form tag.
+	 *
+	 * @param string $data DER data
+	 * @param int $offset Reference to the variable containing offset to data
+	 * @throws DecodeException If decoding fails
+	 * @return string Tag number
+	 */
+	private static function _decodeLongFormTag(string $data, int &$offset): string
+	{
+		$datalen = strlen($data);
+		$tag = gmp_init(0, 10);
+		while (true) {
+			if ($offset >= $datalen) {
+				throw new DecodeException(
+					"Unexpected end of data while decoding" .
+						 " long form identifier.");
+			}
+			$byte = ord($data[$offset++]);
+			$tag <<= 7;
+			$tag |= 0x7f & $byte;
+			// last byte has bit 8 set to zero
+			if (!(0x80 & $byte)) {
+				break;
+			}
+		}
+		return gmp_strval($tag, 10);
+	}
     
-    /**
-     *
-     * @see Encodable::toDER()
-     * @return string
-     */
-    public function toDER(): string
-    {
-        $bytes = [];
-        $byte = $this->_class << 6 | $this->_pc << 5;
-        $tag = gmp_init($this->_tag, 10);
-        if ($tag < 0x1f) {
-            $bytes[] = $byte | $tag;
-        } else { // long-form identifier
-            $bytes[] = $byte | 0x1f;
-            $octets = [];
-            for (; $tag > 0; $tag >>= 7) {
-                array_push($octets, gmp_intval(0x80 | ($tag & 0x7f)));
-            }
-            // last octet has bit 8 set to zero
-            $octets[0] &= 0x7f;
-            foreach (array_reverse($octets) as $octet) {
-                $bytes[] = $octet;
-            }
-        }
-        return pack("C*", ...$bytes);
-    }
+	/**
+	 *
+	 * @see Encodable::toDER()
+	 * @return string
+	 */
+	public function toDER(): string
+	{
+		$bytes = [];
+		$byte = $this->_class << 6 | $this->_pc << 5;
+		$tag = gmp_init($this->_tag, 10);
+		if ($tag < 0x1f) {
+			$bytes[] = $byte | $tag;
+		} else { // long-form identifier
+			$bytes[] = $byte | 0x1f;
+			$octets = [];
+			for (; $tag > 0; $tag >>= 7) {
+				array_push($octets, gmp_intval(0x80 | ($tag & 0x7f)));
+			}
+			// last octet has bit 8 set to zero
+			$octets[0] &= 0x7f;
+			foreach (array_reverse($octets) as $octet) {
+				$bytes[] = $octet;
+			}
+		}
+		return pack("C*", ...$bytes);
+	}
     
-    /**
-     * Get class of the type.
-     *
-     * @return int
-     */
-    public function typeClass(): int
-    {
-        return $this->_class;
-    }
+	/**
+	 * Get class of the type.
+	 *
+	 * @return int
+	 */
+	public function typeClass(): int
+	{
+		return $this->_class;
+	}
     
-    /**
-     * Get P/C.
-     *
-     * @return int
-     */
-    public function pc(): int
-    {
-        return $this->_pc;
-    }
+	/**
+	 * Get P/C.
+	 *
+	 * @return int
+	 */
+	public function pc(): int
+	{
+		return $this->_pc;
+	}
     
-    /**
-     * Get the tag number.
-     *
-     * @return int|string
-     */
-    public function tag()
-    {
-        return $this->_tag;
-    }
+	/**
+	 * Get the tag number.
+	 *
+	 * @return int|string
+	 */
+	public function tag()
+	{
+		return $this->_tag;
+	}
     
-    /**
-     * Check whether type is of an universal class.
-     *
-     * @return boolean
-     */
-    public function isUniversal(): bool
-    {
-        return self::CLASS_UNIVERSAL == $this->_class;
-    }
+	/**
+	 * Check whether type is of an universal class.
+	 *
+	 * @return boolean
+	 */
+	public function isUniversal(): bool
+	{
+		return self::CLASS_UNIVERSAL == $this->_class;
+	}
     
-    /**
-     * Check whether type is of an application class.
-     *
-     * @return boolean
-     */
-    public function isApplication(): bool
-    {
-        return self::CLASS_APPLICATION == $this->_class;
-    }
+	/**
+	 * Check whether type is of an application class.
+	 *
+	 * @return boolean
+	 */
+	public function isApplication(): bool
+	{
+		return self::CLASS_APPLICATION == $this->_class;
+	}
     
-    /**
-     * Check whether type is of a context specific class.
-     *
-     * @return boolean
-     */
-    public function isContextSpecific(): bool
-    {
-        return self::CLASS_CONTEXT_SPECIFIC == $this->_class;
-    }
+	/**
+	 * Check whether type is of a context specific class.
+	 *
+	 * @return boolean
+	 */
+	public function isContextSpecific(): bool
+	{
+		return self::CLASS_CONTEXT_SPECIFIC == $this->_class;
+	}
     
-    /**
-     * Check whether type is of a private class.
-     *
-     * @return boolean
-     */
-    public function isPrivate(): bool
-    {
-        return self::CLASS_PRIVATE == $this->_class;
-    }
+	/**
+	 * Check whether type is of a private class.
+	 *
+	 * @return boolean
+	 */
+	public function isPrivate(): bool
+	{
+		return self::CLASS_PRIVATE == $this->_class;
+	}
     
-    /**
-     * Check whether content is primitive type.
-     *
-     * @return boolean
-     */
-    public function isPrimitive(): bool
-    {
-        return self::PRIMITIVE == $this->_pc;
-    }
+	/**
+	 * Check whether content is primitive type.
+	 *
+	 * @return boolean
+	 */
+	public function isPrimitive(): bool
+	{
+		return self::PRIMITIVE == $this->_pc;
+	}
     
-    /**
-     * Check hether content is constructed type.
-     *
-     * @return boolean
-     */
-    public function isConstructed(): bool
-    {
-        return self::CONSTRUCTED == $this->_pc;
-    }
+	/**
+	 * Check hether content is constructed type.
+	 *
+	 * @return boolean
+	 */
+	public function isConstructed(): bool
+	{
+		return self::CONSTRUCTED == $this->_pc;
+	}
     
-    /**
-     * Get self with given type class.
-     *
-     * @param int $class One of <code>CLASS_*</code> enumerations
-     * @return self
-     */
-    public function withClass(int $class): self
-    {
-        $obj = clone $this;
-        $obj->_class = $class;
-        return $obj;
-    }
+	/**
+	 * Get self with given type class.
+	 *
+	 * @param int $class One of <code>CLASS_*</code> enumerations
+	 * @return self
+	 */
+	public function withClass(int $class): self
+	{
+		$obj = clone $this;
+		$obj->_class = $class;
+		return $obj;
+	}
     
-    /**
-     * Get self with given type tag.
-     *
-     * @param int|string $tag Tag number
-     * @return self
-     */
-    public function withTag(int $tag): self
-    {
-        $obj = clone $this;
-        $obj->_tag = $tag;
-        return $obj;
-    }
+	/**
+	 * Get self with given type tag.
+	 *
+	 * @param int|string $tag Tag number
+	 * @return self
+	 */
+	public function withTag(int $tag): self
+	{
+		$obj = clone $this;
+		$obj->_tag = $tag;
+		return $obj;
+	}
     
-    /**
-     * Get human readable name of the type class.
-     *
-     * @param int $class
-     * @return string
-     */
-    public static function classToName(int $class): string
-    {
-        if (!array_key_exists($class, self::MAP_CLASS_TO_NAME)) {
-            return "CLASS $class";
-        }
-        return self::MAP_CLASS_TO_NAME[$class];
-    }
+	/**
+	 * Get human readable name of the type class.
+	 *
+	 * @param int $class
+	 * @return string
+	 */
+	public static function classToName(int $class): string
+	{
+		if (!array_key_exists($class, self::MAP_CLASS_TO_NAME)) {
+			return "CLASS $class";
+		}
+		return self::MAP_CLASS_TO_NAME[$class];
+	}
 }

lib/ASN1/Component/Length.php

Indentation +179 added lines, -179 removed lines

@@ -12,192 +12,192 @@
  */
 class Length implements Encodable
 {
-    /**
-     * Length.
-     *
-     * @var int|string
-     */
-    private $_length;
+	/**
+	 * Length.
+	 *
+	 * @var int|string
+	 */
+	private $_length;
     
-    /**
-     * Whether length is indefinite.
-     *
-     * @var boolean
-     */
-    private $_indefinite;
+	/**
+	 * Whether length is indefinite.
+	 *
+	 * @var boolean
+	 */
+	private $_indefinite;
     
-    /**
-     * Constructor.
-     *
-     * @param int|string $length Length
-     * @param boolean $indefinite Whether length is indefinite
-     */
-    public function __construct($length, bool $indefinite = false)
-    {
-        $this->_length = $length;
-        $this->_indefinite = $indefinite;
-    }
+	/**
+	 * Constructor.
+	 *
+	 * @param int|string $length Length
+	 * @param boolean $indefinite Whether length is indefinite
+	 */
+	public function __construct($length, bool $indefinite = false)
+	{
+		$this->_length = $length;
+		$this->_indefinite = $indefinite;
+	}
     
-    /**
-     * Decode length component 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 length component. If null, start
-     *        from offset 0.
-     * @throws DecodeException If decoding fails
-     * @return self
-     */
-    public static function fromDER(string $data, int &$offset = null): self
-    {
-        $idx = $offset ? $offset : 0;
-        $datalen = strlen($data);
-        if ($idx >= $datalen) {
-            throw new DecodeException("Invalid offset.");
-        }
-        $indefinite = false;
-        $byte = ord($data[$idx++]);
-        // bits 7 to 1
-        $length = (0x7f & $byte);
-        // long form
-        if (0x80 & $byte) {
-            if (!$length) {
-                $indefinite = true;
-            } else {
-                if ($idx + $length > $datalen) {
-                    throw new DecodeException("Too many length octets.");
-                }
-                $length = self::_decodeLongFormLength($length, $data, $idx);
-            }
-        }
-        if (isset($offset)) {
-            $offset = $idx;
-        }
-        return new self($length, $indefinite);
-    }
+	/**
+	 * Decode length component 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 length component. If null, start
+	 *        from offset 0.
+	 * @throws DecodeException If decoding fails
+	 * @return self
+	 */
+	public static function fromDER(string $data, int &$offset = null): self
+	{
+		$idx = $offset ? $offset : 0;
+		$datalen = strlen($data);
+		if ($idx >= $datalen) {
+			throw new DecodeException("Invalid offset.");
+		}
+		$indefinite = false;
+		$byte = ord($data[$idx++]);
+		// bits 7 to 1
+		$length = (0x7f & $byte);
+		// long form
+		if (0x80 & $byte) {
+			if (!$length) {
+				$indefinite = true;
+			} else {
+				if ($idx + $length > $datalen) {
+					throw new DecodeException("Too many length octets.");
+				}
+				$length = self::_decodeLongFormLength($length, $data, $idx);
+			}
+		}
+		if (isset($offset)) {
+			$offset = $idx;
+		}
+		return new self($length, $indefinite);
+	}
     
-    /**
-     * Decode long form length.
-     *
-     * @param int $length Number of octets
-     * @param string $data Data
-     * @param int $offset Reference to the variable containing offset to the
-     *        data.
-     * @throws DecodeException If decoding fails
-     * @return string Integer as a string
-     */
-    private static function _decodeLongFormLength(int $length, string $data,
-        int &$offset): string
-    {
-        // first octet must not be 0xff (spec 8.1.3.5c)
-        if ($length == 127) {
-            throw new DecodeException("Invalid number of length octets.");
-        }
-        $num = gmp_init(0, 10);
-        while (--$length >= 0) {
-            $byte = ord($data[$offset++]);
-            $num <<= 8;
-            $num |= $byte;
-        }
+	/**
+	 * Decode long form length.
+	 *
+	 * @param int $length Number of octets
+	 * @param string $data Data
+	 * @param int $offset Reference to the variable containing offset to the
+	 *        data.
+	 * @throws DecodeException If decoding fails
+	 * @return string Integer as a string
+	 */
+	private static function _decodeLongFormLength(int $length, string $data,
+		int &$offset): string
+	{
+		// first octet must not be 0xff (spec 8.1.3.5c)
+		if ($length == 127) {
+			throw new DecodeException("Invalid number of length octets.");
+		}
+		$num = gmp_init(0, 10);
+		while (--$length >= 0) {
+			$byte = ord($data[$offset++]);
+			$num <<= 8;
+			$num |= $byte;
+		}
         
-        return gmp_strval($num);
-    }
+		return gmp_strval($num);
+	}
     
-    /**
-     * Decode length from DER.
-     *
-     * Throws an exception if length doesn't match with expected or if data
-     * doesn't contain enough bytes.
-     *
-     * @see self::fromDER
-     * @param string $data DER data
-     * @param int $offset Reference to the offset variable
-     * @param int|null $expected Expected length, null to bypass checking
-     * @throws DecodeException If decoding or expectation fails
-     * @return self
-     */
-    public static function expectFromDER(string $data, int &$offset,
-        int $expected = null): self
-    {
-        $idx = $offset;
-        $length = self::fromDER($data, $idx);
-        // DER encoding must have definite length (spec 10.1)
-        if ($length->isIndefinite()) {
-            throw new DecodeException("DER encoding must have definite length.");
-        }
-        // if certain length was expected
-        if (isset($expected) && $expected != $length->_length) {
-            throw new DecodeException(
-                sprintf("Expected length %d, got %d.", $expected,
-                    $length->_length));
-        }
-        // check that enough data is available
-        if (strlen($data) < $idx + $length->_length) {
-            throw new DecodeException(
-                sprintf("Length %d overflows data, %d bytes left.",
-                    $length->_length, strlen($data) - $idx));
-        }
-        $offset = $idx;
-        return $length;
-    }
+	/**
+	 * Decode length from DER.
+	 *
+	 * Throws an exception if length doesn't match with expected or if data
+	 * doesn't contain enough bytes.
+	 *
+	 * @see self::fromDER
+	 * @param string $data DER data
+	 * @param int $offset Reference to the offset variable
+	 * @param int|null $expected Expected length, null to bypass checking
+	 * @throws DecodeException If decoding or expectation fails
+	 * @return self
+	 */
+	public static function expectFromDER(string $data, int &$offset,
+		int $expected = null): self
+	{
+		$idx = $offset;
+		$length = self::fromDER($data, $idx);
+		// DER encoding must have definite length (spec 10.1)
+		if ($length->isIndefinite()) {
+			throw new DecodeException("DER encoding must have definite length.");
+		}
+		// if certain length was expected
+		if (isset($expected) && $expected != $length->_length) {
+			throw new DecodeException(
+				sprintf("Expected length %d, got %d.", $expected,
+					$length->_length));
+		}
+		// check that enough data is available
+		if (strlen($data) < $idx + $length->_length) {
+			throw new DecodeException(
+				sprintf("Length %d overflows data, %d bytes left.",
+					$length->_length, strlen($data) - $idx));
+		}
+		$offset = $idx;
+		return $length;
+	}
     
-    /**
-     *
-     * @see Encodable::toDER()
-     * @throws \DomainException If length is too large to encode
-     * @return string
-     */
-    public function toDER(): string
-    {
-        $bytes = [];
-        if ($this->_indefinite) {
-            $bytes[] = 0x80;
-        } else {
-            $num = gmp_init($this->_length, 10);
-            // long form
-            if ($num > 127) {
-                $octets = [];
-                for (; $num > 0; $num >>= 8) {
-                    $octets[] = gmp_intval(0xff & $num);
-                }
-                $count = count($octets);
-                // first octet must not be 0xff
-                if ($count >= 127) {
-                    throw new \DomainException("Too many length octets.");
-                }
-                $bytes[] = 0x80 | $count;
-                foreach (array_reverse($octets) as $octet) {
-                    $bytes[] = $octet;
-                }
-            } else { // short form
-                $bytes[] = gmp_intval($num);
-            }
-        }
-        return pack("C*", ...$bytes);
-    }
+	/**
+	 *
+	 * @see Encodable::toDER()
+	 * @throws \DomainException If length is too large to encode
+	 * @return string
+	 */
+	public function toDER(): string
+	{
+		$bytes = [];
+		if ($this->_indefinite) {
+			$bytes[] = 0x80;
+		} else {
+			$num = gmp_init($this->_length, 10);
+			// long form
+			if ($num > 127) {
+				$octets = [];
+				for (; $num > 0; $num >>= 8) {
+					$octets[] = gmp_intval(0xff & $num);
+				}
+				$count = count($octets);
+				// first octet must not be 0xff
+				if ($count >= 127) {
+					throw new \DomainException("Too many length octets.");
+				}
+				$bytes[] = 0x80 | $count;
+				foreach (array_reverse($octets) as $octet) {
+					$bytes[] = $octet;
+				}
+			} else { // short form
+				$bytes[] = gmp_intval($num);
+			}
+		}
+		return pack("C*", ...$bytes);
+	}
     
-    /**
-     * Get the length.
-     *
-     * @throws \LogicException If length is indefinite
-     * @return int|string
-     */
-    public function length()
-    {
-        if ($this->_indefinite) {
-            throw new \LogicException("Length is indefinite.");
-        }
-        return $this->_length;
-    }
+	/**
+	 * Get the length.
+	 *
+	 * @throws \LogicException If length is indefinite
+	 * @return int|string
+	 */
+	public function length()
+	{
+		if ($this->_indefinite) {
+			throw new \LogicException("Length is indefinite.");
+		}
+		return $this->_length;
+	}
     
-    /**
-     * Whether length is indefinite.
-     *
-     * @return boolean
-     */
-    public function isIndefinite(): bool
-    {
-        return $this->_indefinite;
-    }
+	/**
+	 * Whether length is indefinite.
+	 *
+	 * @return boolean
+	 */
+	public function isIndefinite(): bool
+	{
+		return $this->_indefinite;
+	}
 }

lib/ASN1/Type/TaggedType.php

Indentation +77 added lines, -77 removed lines

@@ -17,85 +17,85 @@
  */
 abstract class TaggedType extends Element
 {
-    /**
-     *
-     * {@inheritdoc}
-     */
-    protected static function _decodeFromDER(Identifier $identifier, string $data,
-        int &$offset): ElementBase
-    {
-        $idx = $offset;
-        $type = new DERTaggedType($identifier, $data, $idx);
-        $length = Length::expectFromDER($data, $idx);
-        $offset = $idx + $length->length();
-        return $type;
-    }
+	/**
+	 *
+	 * {@inheritdoc}
+	 */
+	protected static function _decodeFromDER(Identifier $identifier, string $data,
+		int &$offset): ElementBase
+	{
+		$idx = $offset;
+		$type = new DERTaggedType($identifier, $data, $idx);
+		$length = Length::expectFromDER($data, $idx);
+		$offset = $idx + $length->length();
+		return $type;
+	}
     
-    /**
-     * Check whether element supports explicit tagging.
-     *
-     * @param int|null $expectedTag Optional outer tag expectation
-     * @throws \UnexpectedValueException If expectation fails
-     * @return ExplicitTagging
-     */
-    public function expectExplicit(int $expectedTag = null): ExplicitTagging
-    {
-        $el = $this;
-        if (!$el instanceof ExplicitTagging) {
-            throw new \UnexpectedValueException(
-                "Element doesn't implement explicit tagging.");
-        }
-        if (isset($expectedTag)) {
-            $el->expectTagged($expectedTag);
-        }
-        return $el;
-    }
+	/**
+	 * Check whether element supports explicit tagging.
+	 *
+	 * @param int|null $expectedTag Optional outer tag expectation
+	 * @throws \UnexpectedValueException If expectation fails
+	 * @return ExplicitTagging
+	 */
+	public function expectExplicit(int $expectedTag = null): ExplicitTagging
+	{
+		$el = $this;
+		if (!$el instanceof ExplicitTagging) {
+			throw new \UnexpectedValueException(
+				"Element doesn't implement explicit tagging.");
+		}
+		if (isset($expectedTag)) {
+			$el->expectTagged($expectedTag);
+		}
+		return $el;
+	}
     
-    /**
-     * Get the wrapped inner element employing explicit tagging.
-     *
-     * @param int|null $expectedTag Optional outer tag expectation
-     * @throws \UnexpectedValueException If expectation fails
-     * @return UnspecifiedType
-     */
-    public function asExplicit($expectedTag = null): UnspecifiedType
-    {
-        return $this->expectExplicit($expectedTag)->explicit();
-    }
+	/**
+	 * Get the wrapped inner element employing explicit tagging.
+	 *
+	 * @param int|null $expectedTag Optional outer tag expectation
+	 * @throws \UnexpectedValueException If expectation fails
+	 * @return UnspecifiedType
+	 */
+	public function asExplicit($expectedTag = null): UnspecifiedType
+	{
+		return $this->expectExplicit($expectedTag)->explicit();
+	}
     
-    /**
-     * Check whether element supports implicit tagging.
-     *
-     * @param int|null $expectedTag Optional outer tag expectation
-     * @throws \UnexpectedValueException If expectation fails
-     * @return ImplicitTagging
-     */
-    public function expectImplicit($expectedTag = null): ImplicitTagging
-    {
-        $el = $this;
-        if (!$el instanceof ImplicitTagging) {
-            throw new \UnexpectedValueException(
-                "Element doesn't implement implicit tagging.");
-        }
-        if (isset($expectedTag)) {
-            $el->expectTagged($expectedTag);
-        }
-        return $el;
-    }
+	/**
+	 * Check whether element supports implicit tagging.
+	 *
+	 * @param int|null $expectedTag Optional outer tag expectation
+	 * @throws \UnexpectedValueException If expectation fails
+	 * @return ImplicitTagging
+	 */
+	public function expectImplicit($expectedTag = null): ImplicitTagging
+	{
+		$el = $this;
+		if (!$el instanceof ImplicitTagging) {
+			throw new \UnexpectedValueException(
+				"Element doesn't implement implicit tagging.");
+		}
+		if (isset($expectedTag)) {
+			$el->expectTagged($expectedTag);
+		}
+		return $el;
+	}
     
-    /**
-     * Get the wrapped inner element employing implicit tagging.
-     *
-     * @param int $tag Type tag of the inner element
-     * @param int|null $expectedTag Optional outer tag expectation
-     * @param int $expectedClass Optional inner type class expectation
-     * @throws \UnexpectedValueException If expectation fails
-     * @return UnspecifiedType
-     */
-    public function asImplicit($tag, $expectedTag = null,
-        int $expectedClass = Identifier::CLASS_UNIVERSAL): UnspecifiedType
-    {
-        return $this->expectImplicit($expectedTag)->implicit($tag,
-            $expectedClass);
-    }
+	/**
+	 * Get the wrapped inner element employing implicit tagging.
+	 *
+	 * @param int $tag Type tag of the inner element
+	 * @param int|null $expectedTag Optional outer tag expectation
+	 * @param int $expectedClass Optional inner type class expectation
+	 * @throws \UnexpectedValueException If expectation fails
+	 * @return UnspecifiedType
+	 */
+	public function asImplicit($tag, $expectedTag = null,
+		int $expectedClass = Identifier::CLASS_UNIVERSAL): UnspecifiedType
+	{
+		return $this->expectImplicit($expectedTag)->implicit($tag,
+			$expectedClass);
+	}
 }

lib/ASN1/Type/Constructed/Set.php

Indentation +48 added lines, -48 removed lines

@@ -12,54 +12,54 @@
  */
 class Set extends Structure
 {
-    /**
-     * Constructor
-     *
-     * @param Element[] $elements Any number of elements
-     */
-    public function __construct(Element ...$elements)
-    {
-        $this->_typeTag = self::TYPE_SET;
-        parent::__construct(...$elements);
-    }
+	/**
+	 * Constructor
+	 *
+	 * @param Element[] $elements Any number of elements
+	 */
+	public function __construct(Element ...$elements)
+	{
+		$this->_typeTag = self::TYPE_SET;
+		parent::__construct(...$elements);
+	}
     
-    /**
-     * Sort by canonical ascending order.
-     * Used for DER encoding of SET type.
-     *
-     * @return self
-     */
-    public function sortedSet(): self
-    {
-        $obj = clone $this;
-        usort($obj->_elements,
-            function (Element $a, Element $b) {
-                if ($a->typeClass() != $b->typeClass()) {
-                    return $a->typeClass() < $b->typeClass() ? -1 : 1;
-                }
-                if ($a->tag() == $b->tag()) {
-                    return 0;
-                }
-                return $a->tag() < $b->tag() ? -1 : 1;
-            });
-        return $obj;
-    }
+	/**
+	 * Sort by canonical ascending order.
+	 * Used for DER encoding of SET type.
+	 *
+	 * @return self
+	 */
+	public function sortedSet(): self
+	{
+		$obj = clone $this;
+		usort($obj->_elements,
+			function (Element $a, Element $b) {
+				if ($a->typeClass() != $b->typeClass()) {
+					return $a->typeClass() < $b->typeClass() ? -1 : 1;
+				}
+				if ($a->tag() == $b->tag()) {
+					return 0;
+				}
+				return $a->tag() < $b->tag() ? -1 : 1;
+			});
+		return $obj;
+	}
     
-    /**
-     * Sort by encoding ascending order.
-     * Used for DER encoding of SET OF type.
-     *
-     * @return self
-     */
-    public function sortedSetOf(): self
-    {
-        $obj = clone $this;
-        usort($obj->_elements,
-            function (Element $a, Element $b) {
-                $a_der = $a->toDER();
-                $b_der = $b->toDER();
-                return strcmp($a_der, $b_der);
-            });
-        return $obj;
-    }
+	/**
+	 * Sort by encoding ascending order.
+	 * Used for DER encoding of SET OF type.
+	 *
+	 * @return self
+	 */
+	public function sortedSetOf(): self
+	{
+		$obj = clone $this;
+		usort($obj->_elements,
+			function (Element $a, Element $b) {
+				$a_der = $a->toDER();
+				$b_der = $b->toDER();
+				return strcmp($a_der, $b_der);
+			});
+		return $obj;
+	}
 }

lib/ASN1/Type/Structure.php

Indentation +310 added lines, -310 removed lines

@@ -14,336 +14,336 @@
  * Base class for the constructed types.
  */
 abstract class Structure extends Element implements 
-    \Countable,
-    \IteratorAggregate
+	\Countable,
+	\IteratorAggregate
 {
-    use UniversalClass;
+	use UniversalClass;
     
-    /**
-     * Array of elements in the structure.
-     *
-     * @var Element[] $_elements
-     */
-    protected $_elements;
+	/**
+	 * Array of elements in the structure.
+	 *
+	 * @var Element[] $_elements
+	 */
+	protected $_elements;
     
-    /**
-     * Lookup table for the tagged elements.
-     *
-     * @var TaggedType[]|null $_taggedMap
-     */
-    private $_taggedMap;
+	/**
+	 * Lookup table for the tagged elements.
+	 *
+	 * @var TaggedType[]|null $_taggedMap
+	 */
+	private $_taggedMap;
     
-    /**
-     * Cache variable of elements wrapped into UnspecifiedType objects.
-     *
-     * @var UnspecifiedType[]|null $_unspecifiedTypes
-     */
-    private $_unspecifiedTypes;
+	/**
+	 * Cache variable of elements wrapped into UnspecifiedType objects.
+	 *
+	 * @var UnspecifiedType[]|null $_unspecifiedTypes
+	 */
+	private $_unspecifiedTypes;
     
-    /**
-     * Constructor.
-     *
-     * @param Element[] $elements Any number of elements
-     */
-    public function __construct(Element ...$elements)
-    {
-        $this->_elements = $elements;
-    }
+	/**
+	 * Constructor.
+	 *
+	 * @param Element[] $elements Any number of elements
+	 */
+	public function __construct(Element ...$elements)
+	{
+		$this->_elements = $elements;
+	}
     
-    /**
-     * Clone magic method.
-     */
-    public function __clone()
-    {
-        // clear cache-variables
-        $this->_taggedMap = null;
-        $this->_unspecifiedTypes = null;
-    }
+	/**
+	 * Clone magic method.
+	 */
+	public function __clone()
+	{
+		// clear cache-variables
+		$this->_taggedMap = null;
+		$this->_unspecifiedTypes = null;
+	}
     
-    /**
-     *
-     * @see \ASN1\Element::isConstructed()
-     * @return bool
-     */
-    public function isConstructed(): bool
-    {
-        return true;
-    }
+	/**
+	 *
+	 * @see \ASN1\Element::isConstructed()
+	 * @return bool
+	 */
+	public function isConstructed(): bool
+	{
+		return true;
+	}
     
-    /**
-     *
-     * @see \ASN1\Element::_encodedContentDER()
-     * @return string
-     */
-    protected function _encodedContentDER(): string
-    {
-        $data = "";
-        foreach ($this->_elements as $element) {
-            $data .= $element->toDER();
-        }
-        return $data;
-    }
+	/**
+	 *
+	 * @see \ASN1\Element::_encodedContentDER()
+	 * @return string
+	 */
+	protected function _encodedContentDER(): string
+	{
+		$data = "";
+		foreach ($this->_elements as $element) {
+			$data .= $element->toDER();
+		}
+		return $data;
+	}
     
-    /**
-     *
-     * {@inheritdoc}
-     * @see \ASN1\Element::_decodeFromDER()
-     * @return self
-     */
-    protected static function _decodeFromDER(Identifier $identifier, string $data,
-        int &$offset): ElementBase
-    {
-        $idx = $offset;
-        if (!$identifier->isConstructed()) {
-            throw new DecodeException(
-                "Structured element must have constructed bit set.");
-        }
-        $length = Length::expectFromDER($data, $idx);
-        $end = $idx + $length->length();
-        $elements = [];
-        while ($idx < $end) {
-            $elements[] = Element::fromDER($data, $idx);
-            // check that element didn't overflow length
-            if ($idx > $end) {
-                throw new DecodeException(
-                    "Structure's content overflows length.");
-            }
-        }
-        $offset = $idx;
-        // return instance by static late binding
-        return new static(...$elements);
-    }
+	/**
+	 *
+	 * {@inheritdoc}
+	 * @see \ASN1\Element::_decodeFromDER()
+	 * @return self
+	 */
+	protected static function _decodeFromDER(Identifier $identifier, string $data,
+		int &$offset): ElementBase
+	{
+		$idx = $offset;
+		if (!$identifier->isConstructed()) {
+			throw new DecodeException(
+				"Structured element must have constructed bit set.");
+		}
+		$length = Length::expectFromDER($data, $idx);
+		$end = $idx + $length->length();
+		$elements = [];
+		while ($idx < $end) {
+			$elements[] = Element::fromDER($data, $idx);
+			// check that element didn't overflow length
+			if ($idx > $end) {
+				throw new DecodeException(
+					"Structure's content overflows length.");
+			}
+		}
+		$offset = $idx;
+		// return instance by static late binding
+		return new static(...$elements);
+	}
     
-    /**
-     * Explode DER structure to DER encoded components that it contains.
-     *
-     * @param string $data
-     * @throws DecodeException
-     * @return string[]
-     */
-    public static function explodeDER(string $data): array
-    {
-        $offset = 0;
-        $identifier = Identifier::fromDER($data, $offset);
-        if (!$identifier->isConstructed()) {
-            throw new DecodeException("Element is not constructed.");
-        }
-        $length = Length::expectFromDER($data, $offset);
-        $end = $offset + $length->length();
-        $parts = [];
-        while ($offset < $end) {
-            // start of the element
-            $idx = $offset;
-            // skip identifier
-            Identifier::fromDER($data, $offset);
-            // decode element length
-            $length = Length::expectFromDER($data, $offset);
-            // extract der encoding of the element
-            $parts[] = substr($data, $idx, $offset - $idx + $length->length());
-            // update offset over content
-            $offset += $length->length();
-        }
-        return $parts;
-    }
+	/**
+	 * Explode DER structure to DER encoded components that it contains.
+	 *
+	 * @param string $data
+	 * @throws DecodeException
+	 * @return string[]
+	 */
+	public static function explodeDER(string $data): array
+	{
+		$offset = 0;
+		$identifier = Identifier::fromDER($data, $offset);
+		if (!$identifier->isConstructed()) {
+			throw new DecodeException("Element is not constructed.");
+		}
+		$length = Length::expectFromDER($data, $offset);
+		$end = $offset + $length->length();
+		$parts = [];
+		while ($offset < $end) {
+			// start of the element
+			$idx = $offset;
+			// skip identifier
+			Identifier::fromDER($data, $offset);
+			// decode element length
+			$length = Length::expectFromDER($data, $offset);
+			// extract der encoding of the element
+			$parts[] = substr($data, $idx, $offset - $idx + $length->length());
+			// update offset over content
+			$offset += $length->length();
+		}
+		return $parts;
+	}
     
-    /**
-     * Get self with an element at the given index replaced by another.
-     *
-     * @param int $idx Element index
-     * @param Element $el New element to insert into the structure
-     * @throws \OutOfBoundsException
-     * @return self
-     */
-    public function withReplaced(int $idx, Element $el): self
-    {
-        if (!isset($this->_elements[$idx])) {
-            throw new \OutOfBoundsException(
-                "Structure doesn't have element at index $idx.");
-        }
-        $obj = clone $this;
-        $obj->_elements[$idx] = $el;
-        return $obj;
-    }
+	/**
+	 * Get self with an element at the given index replaced by another.
+	 *
+	 * @param int $idx Element index
+	 * @param Element $el New element to insert into the structure
+	 * @throws \OutOfBoundsException
+	 * @return self
+	 */
+	public function withReplaced(int $idx, Element $el): self
+	{
+		if (!isset($this->_elements[$idx])) {
+			throw new \OutOfBoundsException(
+				"Structure doesn't have element at index $idx.");
+		}
+		$obj = clone $this;
+		$obj->_elements[$idx] = $el;
+		return $obj;
+	}
     
-    /**
-     * Get self with an element inserted before the given index.
-     *
-     * @param int $idx Element index
-     * @param Element $el New element to insert into the structure
-     * @throws \OutOfBoundsException
-     * @return self
-     */
-    public function withInserted(int $idx, Element $el): self
-    {
-        if (count($this->_elements) < $idx || $idx < 0) {
-            throw new \OutOfBoundsException("Index $idx is out of bounds.");
-        }
-        $obj = clone $this;
-        array_splice($obj->_elements, $idx, 0, [$el]);
-        return $obj;
-    }
+	/**
+	 * Get self with an element inserted before the given index.
+	 *
+	 * @param int $idx Element index
+	 * @param Element $el New element to insert into the structure
+	 * @throws \OutOfBoundsException
+	 * @return self
+	 */
+	public function withInserted(int $idx, Element $el): self
+	{
+		if (count($this->_elements) < $idx || $idx < 0) {
+			throw new \OutOfBoundsException("Index $idx is out of bounds.");
+		}
+		$obj = clone $this;
+		array_splice($obj->_elements, $idx, 0, [$el]);
+		return $obj;
+	}
     
-    /**
-     * Get self with an element appended to the end.
-     *
-     * @param Element $el Element to insert into the structure
-     * @return self
-     */
-    public function withAppended(Element $el): self
-    {
-        $obj = clone $this;
-        array_push($obj->_elements, $el);
-        return $obj;
-    }
+	/**
+	 * Get self with an element appended to the end.
+	 *
+	 * @param Element $el Element to insert into the structure
+	 * @return self
+	 */
+	public function withAppended(Element $el): self
+	{
+		$obj = clone $this;
+		array_push($obj->_elements, $el);
+		return $obj;
+	}
     
-    /**
-     * Get self with an element prepended in the beginning.
-     *
-     * @param Element $el Element to insert into the structure
-     * @return self
-     */
-    public function withPrepended(Element $el): self
-    {
-        $obj = clone $this;
-        array_unshift($obj->_elements, $el);
-        return $obj;
-    }
+	/**
+	 * Get self with an element prepended in the beginning.
+	 *
+	 * @param Element $el Element to insert into the structure
+	 * @return self
+	 */
+	public function withPrepended(Element $el): self
+	{
+		$obj = clone $this;
+		array_unshift($obj->_elements, $el);
+		return $obj;
+	}
     
-    /**
-     * Get self with an element at the given index removed.
-     *
-     * @param int $idx Element index
-     * @throws \OutOfBoundsException
-     * @return self
-     */
-    public function withoutElement($idx): self
-    {
-        if (!isset($this->_elements[$idx])) {
-            throw new \OutOfBoundsException(
-                "Structure doesn't have element at index $idx.");
-        }
-        $obj = clone $this;
-        array_splice($obj->_elements, $idx, 1);
-        return $obj;
-    }
+	/**
+	 * Get self with an element at the given index removed.
+	 *
+	 * @param int $idx Element index
+	 * @throws \OutOfBoundsException
+	 * @return self
+	 */
+	public function withoutElement($idx): self
+	{
+		if (!isset($this->_elements[$idx])) {
+			throw new \OutOfBoundsException(
+				"Structure doesn't have element at index $idx.");
+		}
+		$obj = clone $this;
+		array_splice($obj->_elements, $idx, 1);
+		return $obj;
+	}
     
-    /**
-     * Get elements in the structure.
-     *
-     * @return UnspecifiedType[]
-     */
-    public function elements(): array
-    {
-        if (!isset($this->_unspecifiedTypes)) {
-            $this->_unspecifiedTypes = array_map(
-                function (Element $el) {
-                    return new UnspecifiedType($el);
-                }, $this->_elements);
-        }
-        return $this->_unspecifiedTypes;
-    }
+	/**
+	 * Get elements in the structure.
+	 *
+	 * @return UnspecifiedType[]
+	 */
+	public function elements(): array
+	{
+		if (!isset($this->_unspecifiedTypes)) {
+			$this->_unspecifiedTypes = array_map(
+				function (Element $el) {
+					return new UnspecifiedType($el);
+				}, $this->_elements);
+		}
+		return $this->_unspecifiedTypes;
+	}
     
-    /**
-     * Check whether the structure has an element at the given index, optionally
-     * satisfying given tag expectation.
-     *
-     * @param int $idx Index 0..n
-     * @param int|null $expectedTag Optional type tag expectation
-     * @return bool
-     */
-    public function has(int $idx, $expectedTag = null): bool
-    {
-        if (!isset($this->_elements[$idx])) {
-            return false;
-        }
-        if (isset($expectedTag)) {
-            if (!$this->_elements[$idx]->isType($expectedTag)) {
-                return false;
-            }
-        }
-        return true;
-    }
+	/**
+	 * Check whether the structure has an element at the given index, optionally
+	 * satisfying given tag expectation.
+	 *
+	 * @param int $idx Index 0..n
+	 * @param int|null $expectedTag Optional type tag expectation
+	 * @return bool
+	 */
+	public function has(int $idx, $expectedTag = null): bool
+	{
+		if (!isset($this->_elements[$idx])) {
+			return false;
+		}
+		if (isset($expectedTag)) {
+			if (!$this->_elements[$idx]->isType($expectedTag)) {
+				return false;
+			}
+		}
+		return true;
+	}
     
-    /**
-     * Get the element at the given index, optionally checking that the element
-     * has a given tag.
-     *
-     * NOTE! Expectation checking is deprecated and should be done
-     * with UnspecifiedType.
-     *
-     * @param int $idx Index 0..n
-     * @param int|null $expectedTag Optional type tag expectation
-     * @throws \OutOfBoundsException If element doesn't exists
-     * @throws \UnexpectedValueException If expectation fails
-     * @return UnspecifiedType
-     */
-    public function at(int $idx, $expectedTag = null): UnspecifiedType
-    {
-        if (!isset($this->_elements[$idx])) {
-            throw new \OutOfBoundsException(
-                "Structure doesn't have an element at index $idx.");
-        }
-        $element = $this->_elements[$idx];
-        if (isset($expectedTag)) {
-            $element->expectType($expectedTag);
-        }
-        return new UnspecifiedType($element);
-    }
+	/**
+	 * Get the element at the given index, optionally checking that the element
+	 * has a given tag.
+	 *
+	 * NOTE! Expectation checking is deprecated and should be done
+	 * with UnspecifiedType.
+	 *
+	 * @param int $idx Index 0..n
+	 * @param int|null $expectedTag Optional type tag expectation
+	 * @throws \OutOfBoundsException If element doesn't exists
+	 * @throws \UnexpectedValueException If expectation fails
+	 * @return UnspecifiedType
+	 */
+	public function at(int $idx, $expectedTag = null): UnspecifiedType
+	{
+		if (!isset($this->_elements[$idx])) {
+			throw new \OutOfBoundsException(
+				"Structure doesn't have an element at index $idx.");
+		}
+		$element = $this->_elements[$idx];
+		if (isset($expectedTag)) {
+			$element->expectType($expectedTag);
+		}
+		return new UnspecifiedType($element);
+	}
     
-    /**
-     * Check whether the structure contains a context specific element with a
-     * given tag.
-     *
-     * @param int $tag Tag number
-     * @return boolean
-     */
-    public function hasTagged($tag): bool
-    {
-        // lazily build lookup map
-        if (!isset($this->_taggedMap)) {
-            $this->_taggedMap = [];
-            foreach ($this->_elements as $element) {
-                if ($element->isTagged()) {
-                    $this->_taggedMap[$element->tag()] = $element;
-                }
-            }
-        }
-        return isset($this->_taggedMap[$tag]);
-    }
+	/**
+	 * Check whether the structure contains a context specific element with a
+	 * given tag.
+	 *
+	 * @param int $tag Tag number
+	 * @return boolean
+	 */
+	public function hasTagged($tag): bool
+	{
+		// lazily build lookup map
+		if (!isset($this->_taggedMap)) {
+			$this->_taggedMap = [];
+			foreach ($this->_elements as $element) {
+				if ($element->isTagged()) {
+					$this->_taggedMap[$element->tag()] = $element;
+				}
+			}
+		}
+		return isset($this->_taggedMap[$tag]);
+	}
     
-    /**
-     * Get a context specific element tagged with a given tag.
-     *
-     * @param int $tag
-     * @throws \LogicException If tag doesn't exists
-     * @return TaggedType
-     */
-    public function getTagged($tag): TaggedType
-    {
-        if (!$this->hasTagged($tag)) {
-            throw new \LogicException("No tagged element for tag $tag.");
-        }
-        return $this->_taggedMap[$tag];
-    }
+	/**
+	 * Get a context specific element tagged with a given tag.
+	 *
+	 * @param int $tag
+	 * @throws \LogicException If tag doesn't exists
+	 * @return TaggedType
+	 */
+	public function getTagged($tag): TaggedType
+	{
+		if (!$this->hasTagged($tag)) {
+			throw new \LogicException("No tagged element for tag $tag.");
+		}
+		return $this->_taggedMap[$tag];
+	}
     
-    /**
-     *
-     * @see \Countable::count()
-     * @return int
-     */
-    public function count(): int
-    {
-        return count($this->_elements);
-    }
+	/**
+	 *
+	 * @see \Countable::count()
+	 * @return int
+	 */
+	public function count(): int
+	{
+		return count($this->_elements);
+	}
     
-    /**
-     * Get an iterator for the UnspecifiedElement objects.
-     *
-     * @see \IteratorAggregate::getIterator()
-     * @return \ArrayIterator
-     */
-    public function getIterator(): \ArrayIterator
-    {
-        return new \ArrayIterator($this->elements());
-    }
+	/**
+	 * Get an iterator for the UnspecifiedElement objects.
+	 *
+	 * @see \IteratorAggregate::getIterator()
+	 * @return \ArrayIterator
+	 */
+	public function getIterator(): \ArrayIterator
+	{
+		return new \ArrayIterator($this->elements());
+	}
 }