X509\Certificate\CertificateChain

Complexity

Total Complexity

12

Size/Duplication

Total Lines	130
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

100%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	fromPEMs()	0	8	1
A	fromPEMString()	0	5	1
A	certificates()	0	4	1
A	endEntityCertificate()	0	7	2
A	trustAnchorCertificate()	0	7	2
A	certificationPath()	0	4	1
A	toPEMString()	0	8	1
A	count()	0	4	1
A	getIterator()	0	4	1

<?php

declare(strict_types = 1);

namespace X509\Certificate;

use Sop\CryptoEncoding\PEM;
use Sop\CryptoEncoding\PEMBundle;
use X509\CertificationPath\CertificationPath;

/**
 * Ordered list of certificates from the end-entity to the trust anchor.
 */
class CertificateChain implements \Countable, \IteratorAggregate
{
    /**
     * List of certificates in a chain.
     *
     * @var Certificate[]
     */
    protected $_certs;
    
    /**
     * Constructor.
     *
     * @param Certificate ...$certs List of certificates, end-entity first
     */
    public function __construct(Certificate ...$certs)
    {
        $this->_certs = $certs;
    }
    
    /**
     * Initialize from a list of PEMs.
     *
     * @param PEM ...$pems
     * @return self
     */
    public static function fromPEMs(PEM ...$pems): self
    {
        $certs = array_map(
            function (PEM $pem) {
                return Certificate::fromPEM($pem);
            }, $pems);
        return new self(...$certs);
    }
    
    /**
     * Initialize from a string containing multiple PEM blocks.
     *
     * @param string $str
     * @return self
     */
    public static function fromPEMString(string $str): self
    {
        $pems = PEMBundle::fromString($str)->all();
        return self::fromPEMs(...$pems);
    }
    
    /**
     * Get all certificates in a chain ordered from the end-entity certificate
     * to the trust anchor.
     *
     * @return Certificate[]
     */
    public function certificates(): array
    {
        return $this->_certs;
    }
    
    /**
     * Get the end-entity certificate.
     *
     * @throws \LogicException
     * @return Certificate
     */
    public function endEntityCertificate(): Certificate
    {
        if (!count($this->_certs)) {
            throw new \LogicException("No certificates.");
        }
        return $this->_certs[0];
    }
    
    /**
     * Get the trust anchor certificate.
     *
     * @throws \LogicException
     * @return Certificate
     */
    public function trustAnchorCertificate(): Certificate
    {
        if (!count($this->_certs)) {
            throw new \LogicException("No certificates.");
        }
        return $this->_certs[count($this->_certs) - 1];
    }
    
    /**
     * Convert certificate chain to certification path.
     *
     * @return CertificationPath
     */
    public function certificationPath(): CertificationPath
    {
        return CertificationPath::fromCertificateChain($this);
    }
    
    /**
     * Convert certificate chain to string of PEM blocks.
     *
     * @return string
     */
    public function toPEMString(): string
    {
        return implode("\n",
            array_map(
                function (Certificate $cert) {
                    return $cert->toPEM()->string();
                }, $this->_certs));
    }
    
    /**
     *
     * @see \Countable::count()
     * @return int
     */
    public function count(): int
    {
        return count($this->_certs);
    }
    
    /**
     * Get iterator for certificates.
     *
     * @see \IteratorAggregate::getIterator()
     * @return \ArrayIterator
     */
    public function getIterator(): \ArrayIterator
    {
        return new \ArrayIterator($this->_certs);
    }
}