/**
* Initialize from ASN.1.
*
* @param Sequence $seq
* @return self
*/
public static function fromASN1(Sequence $seq)
{
$targets = array_map(function (UnspecifiedType $el) {
return Target::fromASN1($el->asTagged());
}, $seq->elements());
return new self(...$targets);
}
/**
* Initialize from ASN.1.
*
* @param Sequence $seq
* @return self
*/
public static function fromASN1(Sequence $seq)
{
$extensions = array_map(function (UnspecifiedType $el) {
return Extension::fromASN1($el->asSequence());
}, $seq->elements());
return new self(...$extensions);
}
/**
* Initialize from ASN.1.
*
* @param Sequence $seq
* @return self
*/
public static function fromASN1(Sequence $seq)
{
$org = DisplayText::fromASN1($seq->at(0)->asString());
$numbers = array_map(function (UnspecifiedType $el) {
return $el->asInteger()->number();
}, $seq->at(1)->asSequence()->elements());
return new self($org, ...$numbers);
}
/**
* Initialize from ASN.1.
*
* @param Sequence $seq
* @return self
*/
public static function fromASN1(Sequence $seq)
{
$type = AttributeType::fromASN1($seq->at(0)->asObjectIdentifier());
$values = array_map(function (UnspecifiedType $el) use($type) {
return AttributeValue::fromASN1ByOID($type->oid(), $el);
}, $seq->at(1)->asSet()->elements());
return new self($type, ...$values);
}
/**
* Initialize from ASN.1.
*
* @param Sequence $seq
* @return self
*/
public static function fromASN1(Sequence $seq)
{
$issuer = GeneralNames::fromASN1($seq->at(0)->asSequence());
$serial = $seq->at(1)->asInteger()->number();
$uid = null;
if ($seq->has(2, Element::TYPE_BIT_STRING)) {
$uid = UniqueIdentifier::fromASN1($seq->at(2)->asBitString());
}
return new self($issuer, $serial, $uid);
}
/**
* Initialize from ASN.1.
*
* @param Sequence $seq
* @return self
*/
public static function fromASN1(Sequence $seq)
{
$subtrees = array_map(function (UnspecifiedType $el) {
return GeneralSubtree::fromASN1($el->asSequence());
}, $seq->elements());
if (!count($subtrees)) {
throw new \UnexpectedValueException("GeneralSubtrees must contain at least one GeneralSubtree.");
}
return new self(...$subtrees);
}
/**
* Initialize from ASN.1.
*
* @param Sequence $seq
* @throws \UnexpectedValueException
* @return self
*/
public static function fromASN1(Sequence $seq)
{
$oid = $seq->at(0)->asObjectIdentifier()->oid();
switch ($oid) {
case self::OID_CPS:
return CPSQualifier::fromQualifierASN1($seq->at(1));
case self::OID_UNOTICE:
return UserNoticeQualifier::fromQualifierASN1($seq->at(1));
}
throw new \UnexpectedValueException("Qualifier {$oid} not supported.");
}
/**
* Initialize from ASN.1.
*
* @param Sequence $seq
* @return self
*/
public static function fromASN1(Sequence $seq)
{
$oid = $seq->at(0)->asObjectIdentifier()->oid();
$qualifiers = array();
if (count($seq) > 1) {
$qualifiers = array_map(function (UnspecifiedType $el) {
return PolicyQualifierInfo::fromASN1($el->asSequence());
}, $seq->at(1)->asSequence()->elements());
}
return new self($oid, ...$qualifiers);
}
protected static function _fromDER($data, $critical)
{
$purposes = array_map(function (UnspecifiedType $el) {
return $el->asObjectIdentifier()->oid();
}, Sequence::fromDER($data)->elements());
return new self($critical, ...$purposes);
}
protected static function _fromDER($data, $critical)
{
$seq = Sequence::fromDER($data);
$path_len = null;
$permitted = null;
$excluded = null;
$permit_unspecified = true;
$idx = 0;
if ($seq->has($idx, Element::TYPE_INTEGER)) {
$path_len = $seq->at($idx++)->asInteger()->number();
}
if ($seq->hasTagged(0)) {
$attr_seq = $seq->getTagged(0)->asImplicit(Element::TYPE_SEQUENCE)->asSequence();
$permitted = array_map(function (UnspecifiedType $el) {
return $el->asObjectIdentifier()->oid();
}, $attr_seq->elements());
$idx++;
}
if ($seq->hasTagged(1)) {
$attr_seq = $seq->getTagged(1)->asImplicit(Element::TYPE_SEQUENCE)->asSequence();
$excluded = array_map(function (UnspecifiedType $el) {
return $el->asObjectIdentifier()->oid();
}, $attr_seq->elements());
$idx++;
}
if ($seq->has($idx, Element::TYPE_BOOLEAN)) {
$permit_unspecified = $seq->at($idx++)->asBoolean()->value();
}
return new self($critical, $path_len, $permitted, $excluded, $permit_unspecified);
}
/**
* Initialize from ASN.1.
*
* @param Sequence $seq
* @return self
*/
public static function fromASN1(Sequence $seq)
{
$attribs = array_map(function (UnspecifiedType $el) {
return Attribute::fromASN1($el->asSequence());
}, $seq->elements());
// cast attributes
$attribs = array_map(function (Attribute $attr) {
$oid = $attr->oid();
if (array_key_exists($oid, self::MAP_OID_TO_CLASS)) {
$cls = self::MAP_OID_TO_CLASS[$oid];
$attr = $attr->castValues($cls);
}
return $attr;
}, $attribs);
return new self(...$attribs);
}
/**
*
* @param string $data
* @param bool $critical
* @return self
*/
protected static function _fromDER($data, $critical)
{
$targets = array_map(function (UnspecifiedType $el) {
return Targets::fromASN1($el->asSequence());
}, Sequence::fromDER($data)->elements());
return new self($critical, ...$targets);
}
protected static function _fromDER($data, $critical)
{
$mappings = array_map(function (UnspecifiedType $el) {
return PolicyMapping::fromASN1($el->asSequence());
}, Sequence::fromDER($data)->elements());
if (!count($mappings)) {
throw new \UnexpectedValueException("PolicyMappings must have at least one mapping.");
}
return new self($critical, ...$mappings);
}
protected static function _fromDER($data, $critical)
{
$policies = array_map(function (UnspecifiedType $el) {
return PolicyInformation::fromASN1($el->asSequence());
}, Sequence::fromDER($data)->elements());
if (!count($policies)) {
throw new \UnexpectedValueException("certificatePolicies must contain" . " at least one PolicyInformation.");
}
return new self($critical, ...$policies);
}
protected static function _fromDER($data, $critical)
{
$attribs = array_map(function (UnspecifiedType $el) {
return Attribute::fromASN1($el->asSequence());
}, Sequence::fromDER($data)->elements());
if (!count($attribs)) {
throw new \UnexpectedValueException("SubjectDirectoryAttributes must have at least one Attribute.");
}
return new self($critical, ...$attribs);
}
protected static function _fromDER($data, $critical)
{
$dps = array_map(function (UnspecifiedType $el) {
return DistributionPoint::fromASN1($el->asSequence());
}, Sequence::fromDER($data)->elements());
if (!count($dps)) {
throw new \UnexpectedValueException("CRLDistributionPoints must have" . " at least one DistributionPoint.");
}
// late static bound, extended by Freshest CRL extension
return new static($critical, ...$dps);
}
protected static function _fromDER($data, $critical)
{
$seq = Sequence::fromDER($data);
$require_explicit_policy = null;
$inhibit_policy_mapping = null;
if ($seq->hasTagged(0)) {
$require_explicit_policy = $seq->getTagged(0)->asImplicit(Element::TYPE_INTEGER)->asInteger()->number();
}
if ($seq->hasTagged(1)) {
$inhibit_policy_mapping = $seq->getTagged(1)->asImplicit(Element::TYPE_INTEGER)->asInteger()->number();
}
return new self($critical, $require_explicit_policy, $inhibit_policy_mapping);
}
protected static function _fromDER($data, $critical)
{
$seq = Sequence::fromDER($data);
$permitted = null;
$excluded = null;
if ($seq->hasTagged(0)) {
$permitted = GeneralSubtrees::fromASN1($seq->getTagged(0)->asImplicit(Element::TYPE_SEQUENCE)->asSequence());
}
if ($seq->hasTagged(1)) {
$excluded = GeneralSubtrees::fromASN1($seq->getTagged(1)->asImplicit(Element::TYPE_SEQUENCE)->asSequence());
}
return new self($critical, $permitted, $excluded);
}
protected static function _fromDER($data, $critical)
{
$seq = Sequence::fromDER($data);
$ca = false;
$path_len = null;
$idx = 0;
if ($seq->has($idx, Element::TYPE_BOOLEAN)) {
$ca = $seq->at($idx++)->asBoolean()->value();
}
if ($seq->has($idx, Element::TYPE_INTEGER)) {
$path_len = $seq->at($idx)->asInteger()->number();
}
return new self($critical, $ca, $path_len);
}
protected static function _fromDER($data, $critical)
{
$seq = Sequence::fromDER($data);
$keyIdentifier = null;
$issuer = null;
$serial = null;
if ($seq->hasTagged(0)) {
$keyIdentifier = $seq->getTagged(0)->asImplicit(Element::TYPE_OCTET_STRING)->asOctetString()->string();
}
if ($seq->hasTagged(1) || $seq->hasTagged(2)) {
if (!$seq->hasTagged(1) || !$seq->hasTagged(2)) {
throw new \UnexpectedValueException("AuthorityKeyIdentifier must have both" . " authorityCertIssuer and authorityCertSerialNumber" . " present or both absent.");
}
$issuer = GeneralNames::fromASN1($seq->getTagged(1)->asImplicit(Element::TYPE_SEQUENCE)->asSequence());
$serial = $seq->getTagged(2)->asImplicit(Element::TYPE_INTEGER)->asInteger()->number();
}
return new self($critical, $keyIdentifier, $issuer, $serial);
}
/**
* Initialize from ASN.1.
*
* @param Sequence $seq
* @return self
*/
public static function fromASN1(Sequence $seq)
{
$base = GeneralName::fromASN1($seq->at(0)->asTagged());
$min = 0;
$max = null;
if ($seq->hasTagged(0)) {
$min = $seq->getTagged(0)->asImplicit(Element::TYPE_INTEGER)->asInteger()->number();
}
if ($seq->hasTagged(1)) {
$max = $seq->getTagged(1)->asImplicit(Element::TYPE_INTEGER)->asInteger()->number();
}
return new self($base, $min, $max);
}
/**
* Initialize from ASN.1.
*
* @param Sequence $seq
* @return self
*/
public static function fromASN1(Sequence $seq)
{
$name = null;
$reasons = null;
$issuer = null;
if ($seq->hasTagged(0)) {
// promoted to explicit tagging because underlying type is CHOICE
$name = DistributionPointName::fromTaggedType($seq->getTagged(0)->asExplicit()->asTagged());
}
if ($seq->hasTagged(1)) {
$reasons = ReasonFlags::fromASN1($seq->getTagged(1)->asImplicit(Element::TYPE_BIT_STRING)->asBitString());
}
if ($seq->hasTagged(2)) {
$issuer = GeneralNames::fromASN1($seq->getTagged(2)->asImplicit(Element::TYPE_SEQUENCE)->asSequence());
}
return new self($name, $reasons, $issuer);
}
/**
* Initialize from ASN.1.
*
* @param Sequence $seq
* @throws \UnexpectedValueException
* @return self
*/
public static function fromASN1(Sequence $seq)
{
$version = $seq->at(0)->asInteger()->number();
if ($version != self::VERSION_1) {
throw new \UnexpectedValueException("Version {$version} not supported.");
}
$subject = Name::fromASN1($seq->at(1)->asSequence());
$pkinfo = PublicKeyInfo::fromASN1($seq->at(2)->asSequence());
$obj = new self($subject, $pkinfo);
if ($seq->hasTagged(0)) {
$obj->_attributes = Attributes::fromASN1($seq->getTagged(0)->asImplicit(Element::TYPE_SET)->asSet());
}
return $obj;
}
/**
* Initialize from ASN.1.
*
* @param Sequence $seq
* @return self
*/
public static function fromASN1(Sequence $seq)
{
$type = $seq->at(0)->asEnumerated()->number();
$oid = null;
$idx = 1;
if ($seq->has($idx, Element::TYPE_OBJECT_IDENTIFIER)) {
$oid = $seq->at($idx++)->asObjectIdentifier()->oid();
}
$algo = AlgorithmIdentifier::fromASN1($seq->at($idx++)->asSequence());
$digest = $seq->at($idx)->asBitString();
$obj = new self($type, $algo, $digest);
$obj->_otherObjectTypeID = $oid;
return $obj;
}
/**
* Initialize from ASN.1.
*
* @param Sequence $seq
*/
public static function fromASN1(Sequence $seq)
{
$cert_id = null;
$entity_name = null;
$digest_info = null;
if ($seq->hasTagged(0)) {
$cert_id = IssuerSerial::fromASN1($seq->getTagged(0)->asImplicit(Element::TYPE_SEQUENCE)->asSequence());
}
if ($seq->hasTagged(1)) {
$entity_name = GeneralNames::fromASN1($seq->getTagged(1)->asImplicit(Element::TYPE_SEQUENCE)->asSequence());
}
if ($seq->hasTagged(2)) {
$digest_info = ObjectDigestInfo::fromASN1($seq->getTagged(2)->asImplicit(Element::TYPE_SEQUENCE)->asSequence());
}
$obj = new self($cert_id, $entity_name);
$obj->_objectDigestInfo = $digest_info;
return $obj;
}
/**
* Initialize from ASN.1.
*
* @param Sequence $seq
* @return self
*/
public static function fromV2ASN1(Sequence $seq)
{
$issuer = null;
$cert_id = null;
$digest_info = null;
if ($seq->has(0, Element::TYPE_SEQUENCE)) {
$issuer = GeneralNames::fromASN1($seq->at(0)->asSequence());
}
if ($seq->hasTagged(0)) {
$cert_id = IssuerSerial::fromASN1($seq->getTagged(0)->asImplicit(Element::TYPE_SEQUENCE)->asSequence());
}
if ($seq->hasTagged(1)) {
$digest_info = ObjectDigestInfo::fromASN1($seq->getTagged(1)->asImplicit(Element::TYPE_SEQUENCE)->asSequence());
}
$obj = new self($issuer);
$obj->_baseCertificateID = $cert_id;
$obj->_objectDigestInfo = $digest_info;
return $obj;
}
/**
* Initialize from DER.
*
* @param string $data
* @return self
*/
public static function fromDER($data)
{
return self::fromASN1(Sequence::fromDER($data));
}
protected static function _fromDER($data, $critical)
{
return new self($critical, GeneralNames::fromASN1(Sequence::fromDER($data)));
}
/**
* Initialize from ASN.1.
*
* @param Sequence $seq
* @throws \UnexpectedValueException
* @return self
*/
public static function fromASN1(Sequence $seq)
{
$version = $seq->at(0)->asInteger()->number();
if ($version != self::VERSION_2) {
throw new \UnexpectedValueException("Version must be 2.");
}
$holder = Holder::fromASN1($seq->at(1)->asSequence());
$issuer = AttCertIssuer::fromASN1($seq->at(2));
$signature = AlgorithmIdentifier::fromASN1($seq->at(3)->asSequence());
if (!$signature instanceof SignatureAlgorithmIdentifier) {
throw new \UnexpectedValueException("Unsupported signature algorithm " . $signature->oid() . ".");
}
$serial = $seq->at(4)->asInteger()->number();
$validity = AttCertValidityPeriod::fromASN1($seq->at(5)->asSequence());
$attribs = Attributes::fromASN1($seq->at(6)->asSequence());
$obj = new self($holder, $issuer, $validity, $attribs);
$obj->_signature = $signature;
$obj->_serialNumber = $serial;
$idx = 7;
if ($seq->has($idx, Element::TYPE_BIT_STRING)) {
$obj->_issuerUniqueID = UniqueIdentifier::fromASN1($seq->at($idx++)->asBitString());
}
if ($seq->has($idx, Element::TYPE_SEQUENCE)) {
$obj->_extensions = Extensions::fromASN1($seq->at($idx++)->asSequence());
}
return $obj;
}
/**
* Initialize from ASN.1.
*
* @param Sequence $seq
* @return self
*/
public static function fromASN1(Sequence $seq)
{
$idx = 0;
if ($seq->hasTagged(0)) {
$idx++;
$version = intval($seq->getTagged(0)->asExplicit()->asInteger()->number());
} else {
$version = self::VERSION_1;
}
$serial = $seq->at($idx++)->asInteger()->number();
$algo = AlgorithmIdentifier::fromASN1($seq->at($idx++)->asSequence());
if (!$algo instanceof SignatureAlgorithmIdentifier) {
throw new \UnexpectedValueException("Unsupported signature algorithm " . $algo->oid() . ".");
}
$issuer = Name::fromASN1($seq->at($idx++)->asSequence());
$validity = Validity::fromASN1($seq->at($idx++)->asSequence());
$subject = Name::fromASN1($seq->at($idx++)->asSequence());
$pki = PublicKeyInfo::fromASN1($seq->at($idx++)->asSequence());
$tbs_cert = new self($subject, $pki, $issuer, $validity);
$tbs_cert->_version = $version;
$tbs_cert->_serialNumber = $serial;
$tbs_cert->_signature = $algo;
if ($seq->hasTagged(1)) {
$tbs_cert->_issuerUniqueID = UniqueIdentifier::fromASN1($seq->getTagged(1)->asImplicit(Element::TYPE_BIT_STRING)->asBitString());
}
if ($seq->hasTagged(2)) {
$tbs_cert->_subjectUniqueID = UniqueIdentifier::fromASN1($seq->getTagged(2)->asImplicit(Element::TYPE_BIT_STRING)->asBitString());
}
if ($seq->hasTagged(3)) {
$tbs_cert->_extensions = Extensions::fromASN1($seq->getTagged(3)->asExplicit()->asSequence());
}
return $tbs_cert;
}
