sop / asn1

lib/ASN1/Type/StringType.php

Indentation +41 added lines, -41 removed lines

@@ -11,48 +11,48 @@
  */
 abstract class StringType extends Element
 {
-    /**
-     * String value.
-     *
-     * @var string $_string
-     */
-    protected $_string;
+	/**
+	 * String value.
+	 *
+	 * @var string $_string
+	 */
+	protected $_string;
     
-    /**
-     * Constructor.
-     *
-     * @param string $string
-     * @throws \InvalidArgumentException
-     */
-    public function __construct(string $string)
-    {
-        if (!$this->_validateString($string)) {
-            throw new \InvalidArgumentException(
-                sprintf("Not a valid %s string.",
-                    self::tagToName($this->_typeTag)));
-        }
-        $this->_string = $string;
-    }
+	/**
+	 * Constructor.
+	 *
+	 * @param string $string
+	 * @throws \InvalidArgumentException
+	 */
+	public function __construct(string $string)
+	{
+		if (!$this->_validateString($string)) {
+			throw new \InvalidArgumentException(
+				sprintf("Not a valid %s string.",
+					self::tagToName($this->_typeTag)));
+		}
+		$this->_string = $string;
+	}
     
-    /**
-     * Get the string value.
-     *
-     * @return string
-     */
-    public function string(): string
-    {
-        return $this->_string;
-    }
+	/**
+	 * Get the string value.
+	 *
+	 * @return string
+	 */
+	public function string(): string
+	{
+		return $this->_string;
+	}
     
-    /**
-     * Check whether string is valid for the concrete type.
-     *
-     * @param string $string
-     * @return bool
-     */
-    protected function _validateString(string $string): bool
-    {
-        // Override in derived classes
-        return true;
-    }
+	/**
+	 * Check whether string is valid for the concrete type.
+	 *
+	 * @param string $string
+	 * @return bool
+	 */
+	protected function _validateString(string $string): bool
+	{
+		// Override in derived classes
+		return true;
+	}
 }

lib/ASN1/Type/Tagged/ExplicitlyTaggedType.php

Indentation +43 added lines, -43 removed lines

@@ -14,51 +14,51 @@
  * is not changed.
  */
 class ExplicitlyTaggedType extends ContextSpecificTaggedType implements 
-    ExplicitTagging
+	ExplicitTagging
 {
-    /**
-     * Constructor.
-     *
-     * @param int $tag Tag number
-     * @param Element $element Wrapped element
-     */
-    public function __construct($tag, Element $element)
-    {
-        $this->_typeTag = $tag;
-        $this->_element = $element;
-    }
+	/**
+	 * Constructor.
+	 *
+	 * @param int $tag Tag number
+	 * @param Element $element Wrapped element
+	 */
+	public function __construct($tag, Element $element)
+	{
+		$this->_typeTag = $tag;
+		$this->_element = $element;
+	}
     
-    /**
-     *
-     * @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
-    {
-        return $this->_element->toDER();
-    }
+	/**
+	 *
+	 * @see \ASN1\Element::_encodedContentDER()
+	 * @return string
+	 */
+	protected function _encodedContentDER(): string
+	{
+		return $this->_element->toDER();
+	}
     
-    /**
-     *
-     * {@inheritdoc}
-     * @see \ASN1\Type\Tagged\ExplicitTagging::explicit()
-     * @return UnspecifiedType
-     */
-    public function explicit($expectedTag = null): UnspecifiedType
-    {
-        if (isset($expectedTag)) {
-            $this->_element->expectType($expectedTag);
-        }
-        return new UnspecifiedType($this->_element);
-    }
+	/**
+	 *
+	 * {@inheritdoc}
+	 * @see \ASN1\Type\Tagged\ExplicitTagging::explicit()
+	 * @return UnspecifiedType
+	 */
+	public function explicit($expectedTag = null): UnspecifiedType
+	{
+		if (isset($expectedTag)) {
+			$this->_element->expectType($expectedTag);
+		}
+		return new UnspecifiedType($this->_element);
+	}
 }

lib/ASN1/Type/Tagged/ImplicitTagging.php

Indentation +9 added lines, -9 removed lines

@@ -13,13 +13,13 @@
  */
 interface ImplicitTagging extends ElementBase
 {
-    /**
-     * Get implicitly tagged wrapped element.
-     *
-     * @param int $tag Tag of the element
-     * @param int $class Expected type class of the element
-     * @throws \UnexpectedValueException If expectation fails
-     * @return \ASN1\Type\UnspecifiedType
-     */
-    public function implicit($tag, int $class = Identifier::CLASS_UNIVERSAL): UnspecifiedType;
+	/**
+	 * Get implicitly tagged wrapped element.
+	 *
+	 * @param int $tag Tag of the element
+	 * @param int $class Expected type class of the element
+	 * @throws \UnexpectedValueException If expectation fails
+	 * @return \ASN1\Type\UnspecifiedType
+	 */
+	public function implicit($tag, int $class = Identifier::CLASS_UNIVERSAL): UnspecifiedType;
 }

lib/ASN1/Type/Tagged/ImplicitlyTaggedType.php

Indentation +48 added lines, -48 removed lines

@@ -16,56 +16,56 @@
  * decoding the data.
  */
 class ImplicitlyTaggedType extends ContextSpecificTaggedType implements 
-    ImplicitTagging
+	ImplicitTagging
 {
-    /**
-     * Constructor.
-     *
-     * @param int $tag
-     * @param Element $element
-     */
-    public function __construct($tag, Element $element)
-    {
-        $this->_typeTag = $tag;
-        $this->_element = $element;
-    }
+	/**
+	 * Constructor.
+	 *
+	 * @param int $tag
+	 * @param Element $element
+	 */
+	public function __construct($tag, Element $element)
+	{
+		$this->_typeTag = $tag;
+		$this->_element = $element;
+	}
     
-    /**
-     *
-     * @see \ASN1\Element::isConstructed()
-     * @return bool
-     */
-    public function isConstructed(): bool
-    {
-        // depends on the underlying type
-        return $this->_element->isConstructed();
-    }
+	/**
+	 *
+	 * @see \ASN1\Element::isConstructed()
+	 * @return bool
+	 */
+	public function isConstructed(): bool
+	{
+		// depends on the underlying type
+		return $this->_element->isConstructed();
+	}
     
-    /**
-     *
-     * @see \ASN1\Element::_encodedContentDER()
-     * @return string
-     */
-    protected function _encodedContentDER(): string
-    {
-        return $this->_element->_encodedContentDER();
-    }
+	/**
+	 *
+	 * @see \ASN1\Element::_encodedContentDER()
+	 * @return string
+	 */
+	protected function _encodedContentDER(): string
+	{
+		return $this->_element->_encodedContentDER();
+	}
     
-    /**
-     *
-     * {@inheritdoc}
-     * @see \ASN1\Type\Tagged\ImplicitTagging::implicit()
-     * @return UnspecifiedType
-     */
-    public function implicit($tag, int $class = Identifier::CLASS_UNIVERSAL): UnspecifiedType
-    {
-        $this->_element->expectType($tag);
-        if ($this->_element->typeClass() != $class) {
-            throw new \UnexpectedValueException(
-                sprintf("Type class %s expected, got %s.",
-                    Identifier::classToName($class),
-                    Identifier::classToName($this->_element->typeClass())));
-        }
-        return new UnspecifiedType($this->_element);
-    }
+	/**
+	 *
+	 * {@inheritdoc}
+	 * @see \ASN1\Type\Tagged\ImplicitTagging::implicit()
+	 * @return UnspecifiedType
+	 */
+	public function implicit($tag, int $class = Identifier::CLASS_UNIVERSAL): UnspecifiedType
+	{
+		$this->_element->expectType($tag);
+		if ($this->_element->typeClass() != $class) {
+			throw new \UnexpectedValueException(
+				sprintf("Type class %s expected, got %s.",
+					Identifier::classToName($class),
+					Identifier::classToName($this->_element->typeClass())));
+		}
+		return new UnspecifiedType($this->_element);
+	}
 }

lib/ASN1/Type/TimeType.php

Indentation +77 added lines, -77 removed lines

@@ -11,87 +11,87 @@
  */
 abstract class TimeType extends Element
 {
-    /**
-     * UTC timezone.
-     *
-     * @var string
-     */
-    const TZ_UTC = "UTC";
+	/**
+	 * UTC timezone.
+	 *
+	 * @var string
+	 */
+	const TZ_UTC = "UTC";
     
-    /**
-     * Date and time.
-     *
-     * @var \DateTimeImmutable $_dateTime
-     */
-    protected $_dateTime;
+	/**
+	 * Date and time.
+	 *
+	 * @var \DateTimeImmutable $_dateTime
+	 */
+	protected $_dateTime;
     
-    /**
-     * Constructor.
-     *
-     * @param \DateTimeImmutable $dt
-     */
-    public function __construct(\DateTimeImmutable $dt)
-    {
-        $this->_dateTime = $dt;
-    }
+	/**
+	 * Constructor.
+	 *
+	 * @param \DateTimeImmutable $dt
+	 */
+	public function __construct(\DateTimeImmutable $dt)
+	{
+		$this->_dateTime = $dt;
+	}
     
-    /**
-     * Initialize from datetime string.
-     *
-     * @param string $time Time string
-     * @param string|null $tz Timezone, if null use default.
-     * @throws \RuntimeException
-     * @return self
-     */
-    public static function fromString(string $time, string $tz = null): self
-    {
-        try {
-            if (!isset($tz)) {
-                $tz = date_default_timezone_get();
-            }
-            return new static(
-                new \DateTimeImmutable($time, self::_createTimeZone($tz)));
-        } catch (\Exception $e) {
-            throw new \RuntimeException(
-                "Failed to create DateTime: " .
-                     self::_getLastDateTimeImmutableErrorsStr(), 0, $e);
-        }
-    }
+	/**
+	 * Initialize from datetime string.
+	 *
+	 * @param string $time Time string
+	 * @param string|null $tz Timezone, if null use default.
+	 * @throws \RuntimeException
+	 * @return self
+	 */
+	public static function fromString(string $time, string $tz = null): self
+	{
+		try {
+			if (!isset($tz)) {
+				$tz = date_default_timezone_get();
+			}
+			return new static(
+				new \DateTimeImmutable($time, self::_createTimeZone($tz)));
+		} catch (\Exception $e) {
+			throw new \RuntimeException(
+				"Failed to create DateTime: " .
+					 self::_getLastDateTimeImmutableErrorsStr(), 0, $e);
+		}
+	}
     
-    /**
-     * Get the date and time.
-     *
-     * @return \DateTimeImmutable
-     */
-    public function dateTime(): \DateTimeImmutable
-    {
-        return $this->_dateTime;
-    }
+	/**
+	 * Get the date and time.
+	 *
+	 * @return \DateTimeImmutable
+	 */
+	public function dateTime(): \DateTimeImmutable
+	{
+		return $this->_dateTime;
+	}
     
-    /**
-     * Create DateTimeZone object from string.
-     *
-     * @param string $tz
-     * @throws \UnexpectedValueException If timezone is invalid
-     * @return \DateTimeZone
-     */
-    protected static function _createTimeZone($tz): \DateTimeZone
-    {
-        try {
-            return new \DateTimeZone($tz);
-        } catch (\Exception $e) {
-            throw new \UnexpectedValueException("Invalid timezone.", 0, $e);
-        }
-    }
+	/**
+	 * Create DateTimeZone object from string.
+	 *
+	 * @param string $tz
+	 * @throws \UnexpectedValueException If timezone is invalid
+	 * @return \DateTimeZone
+	 */
+	protected static function _createTimeZone($tz): \DateTimeZone
+	{
+		try {
+			return new \DateTimeZone($tz);
+		} catch (\Exception $e) {
+			throw new \UnexpectedValueException("Invalid timezone.", 0, $e);
+		}
+	}
     
-    /**
-     * Get last error caused by DateTimeImmutable.
-     *
-     * @return string
-     */
-    protected static function _getLastDateTimeImmutableErrorsStr(): string
-    {
-        $errors = \DateTimeImmutable::getLastErrors()["errors"];
-        return implode(", ", $errors);
-    }
+	/**
+	 * Get last error caused by DateTimeImmutable.
+	 *
+	 * @return string
+	 */
+	protected static function _getLastDateTimeImmutableErrorsStr(): string
+	{
+		$errors = \DateTimeImmutable::getLastErrors()["errors"];
+		return implode(", ", $errors);
+	}
 }

lib/ASN1/Component/Length.php

Indentation +204 added lines, -204 removed lines

@@ -12,219 +12,219 @@
  */
 class Length implements Encodable
 {
-    /**
-     * Length.
-     *
-     * @var string
-     */
-    private $_length;
+	/**
+	 * Length.
+	 *
+	 * @var string
+	 */
+	private $_length;
     
-    /**
-     * Whether length is indefinite.
-     *
-     * @var boolean
-     */
-    private $_indefinite;
+	/**
+	 * Whether length is indefinite.
+	 *
+	 * @var boolean
+	 */
+	private $_indefinite;
     
-    /**
-     * Length as an integer type.
-     *
-     * @internal Lazily initialized
-     * @var int
-     */
-    private $_intLength;
+	/**
+	 * Length as an integer type.
+	 *
+	 * @internal Lazily initialized
+	 * @var int
+	 */
+	private $_intLength;
     
-    /**
-     * Constructor.
-     *
-     * @param int|string $length Length
-     * @param boolean $indefinite Whether length is indefinite
-     */
-    public function __construct($length, bool $indefinite = false)
-    {
-        $this->_length = strval($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 = strval($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->intLength()) {
-            throw new DecodeException(
-                sprintf("Expected length %d, got %d.", $expected,
-                    $length->intLength()));
-        }
-        // check that enough data is available
-        if (strlen($data) < $idx + $length->intLength()) {
-            throw new DecodeException(
-                sprintf("Length %d overflows data, %d bytes left.",
-                    $length->intLength(), 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->intLength()) {
+			throw new DecodeException(
+				sprintf("Expected length %d, got %d.", $expected,
+					$length->intLength()));
+		}
+		// check that enough data is available
+		if (strlen($data) < $idx + $length->intLength()) {
+			throw new DecodeException(
+				sprintf("Length %d overflows data, %d bytes left.",
+					$length->intLength(), 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 string Length as an integer string
-     */
-    public function length(): string
-    {
-        if ($this->_indefinite) {
-            throw new \LogicException("Length is indefinite.");
-        }
-        return $this->_length;
-    }
+	/**
+	 * Get the length.
+	 *
+	 * @throws \LogicException If length is indefinite
+	 * @return string Length as an integer string
+	 */
+	public function length(): string
+	{
+		if ($this->_indefinite) {
+			throw new \LogicException("Length is indefinite.");
+		}
+		return $this->_length;
+	}
     
-    /**
-     * Get the length as an integer.
-     *
-     * @throws \LogicException If length is indefinite
-     * @throws \RuntimeException If length overflows integer size
-     * @return int
-     */
-    public function intLength(): int
-    {
-        if (!isset($this->_intLength)) {
-            $num = gmp_init($this->length(), 10);
-            if (gmp_cmp($num, gmp_init(PHP_INT_MAX, 10)) >= 0) {
-                throw new \RuntimeException("Integer overflow.");
-            }
-            $this->_intLength = gmp_intval($num);
-        }
-        return $this->_intLength;
-    }
+	/**
+	 * Get the length as an integer.
+	 *
+	 * @throws \LogicException If length is indefinite
+	 * @throws \RuntimeException If length overflows integer size
+	 * @return int
+	 */
+	public function intLength(): int
+	{
+		if (!isset($this->_intLength)) {
+			$num = gmp_init($this->length(), 10);
+			if (gmp_cmp($num, gmp_init(PHP_INT_MAX, 10)) >= 0) {
+				throw new \RuntimeException("Integer overflow.");
+			}
+			$this->_intLength = gmp_intval($num);
+		}
+		return $this->_intLength;
+	}
     
-    /**
-     * 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)->intLength();
-        $offset = $idx + $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)->intLength();
+		$offset = $idx + $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/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->intLength();
-        $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->intLength();
+		$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)->intLength();
-        $end = $offset + $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)->intLength();
-            // extract der encoding of the element
-            $parts[] = substr($data, $idx, $offset - $idx + $length);
-            // update offset over content
-            $offset += $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)->intLength();
+		$end = $offset + $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)->intLength();
+			// extract der encoding of the element
+			$parts[] = substr($data, $idx, $offset - $idx + $length);
+			// update offset over content
+			$offset += $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());
+	}
 }

lib/ASN1/Type/PrimitiveString.php

Indentation +35 added lines, -35 removed lines

@@ -14,41 +14,41 @@
  */
 abstract class PrimitiveString extends StringType
 {
-    use PrimitiveType;
+	use PrimitiveType;
     
-    /**
-     *
-     * @see \ASN1\Element::_encodedContentDER()
-     * @return string
-     */
-    protected function _encodedContentDER(): string
-    {
-        return $this->_string;
-    }
+	/**
+	 *
+	 * @see \ASN1\Element::_encodedContentDER()
+	 * @return string
+	 */
+	protected function _encodedContentDER(): string
+	{
+		return $this->_string;
+	}
     
-    /**
-     *
-     * {@inheritdoc}
-     * @see \ASN1\Element::_decodeFromDER()
-     * @return self
-     */
-    protected static function _decodeFromDER(Identifier $identifier, string $data,
-        int &$offset): ElementBase
-    {
-        $idx = $offset;
-        if (!$identifier->isPrimitive()) {
-            throw new DecodeException("DER encoded string must be primitive.");
-        }
-        $length = Length::expectFromDER($data, $idx)->intLength();
-        $str = $length ? substr($data, $idx, $length) : "";
-        // substr should never return false, since length is
-        // checked by Length::expectFromDER.
-        assert(is_string($str), "substr");
-        $offset = $idx + $length;
-        try {
-            return new static($str);
-        } catch (\InvalidArgumentException $e) {
-            throw new DecodeException($e->getMessage(), 0, $e);
-        }
-    }
+	/**
+	 *
+	 * {@inheritdoc}
+	 * @see \ASN1\Element::_decodeFromDER()
+	 * @return self
+	 */
+	protected static function _decodeFromDER(Identifier $identifier, string $data,
+		int &$offset): ElementBase
+	{
+		$idx = $offset;
+		if (!$identifier->isPrimitive()) {
+			throw new DecodeException("DER encoded string must be primitive.");
+		}
+		$length = Length::expectFromDER($data, $idx)->intLength();
+		$str = $length ? substr($data, $idx, $length) : "";
+		// substr should never return false, since length is
+		// checked by Length::expectFromDER.
+		assert(is_string($str), "substr");
+		$offset = $idx + $length;
+		try {
+			return new static($str);
+		} catch (\InvalidArgumentException $e) {
+			throw new DecodeException($e->getMessage(), 0, $e);
+		}
+	}
 }