AuthnRequest.php

Go to the documentation of this file.

<?php
 
namespace SAML2;
 
use RobRichards\XMLSecLibs\XMLSecEnc;
use RobRichards\XMLSecLibs\XMLSecurityKey;
use SAML2\XML\saml\SubjectConfirmation;
use SAML2\Exception\InvalidArgumentException;
 
class AuthnRequest extends Request
{
    private $nameIdPolicy;
 
    private $forceAuthn;
 
 
    private $ProviderName;
 
 
    private $isPassive;
 
    private $IDPList = array();
 
    private $ProxyCount = null;
 
    private $RequesterID = array();
 
    private $assertionConsumerServiceURL;
 
 
    private $protocolBinding;
 
 
    private $attributeConsumingServiceIndex;
 
    private $assertionConsumerServiceIndex;
 
 
    private $requestedAuthnContext;
 
    private $subjectConfirmation = array();
 
    private $encryptedNameId;
 
    private $nameId;
 
    public function __construct(\DOMElement $xml = null)
    {
        parent::__construct('AuthnRequest', $xml);
 
        $this->nameIdPolicy = array();
        $this->forceAuthn = false;
        $this->isPassive = false;
 
        if ($xml === null) {
            return;
        }
 
        $this->forceAuthn = Utils::parseBoolean($xml, 'ForceAuthn', false);
        $this->isPassive = Utils::parseBoolean($xml, 'IsPassive', false);
 
        if ($xml->hasAttribute('AssertionConsumerServiceURL')) {
            $this->assertionConsumerServiceURL = $xml->getAttribute('AssertionConsumerServiceURL');
        }
 
        if ($xml->hasAttribute('ProtocolBinding')) {
            $this->protocolBinding = $xml->getAttribute('ProtocolBinding');
        }
 
        if ($xml->hasAttribute('AttributeConsumingServiceIndex')) {
            $this->attributeConsumingServiceIndex = (int) $xml->getAttribute('AttributeConsumingServiceIndex');
        }
 
        if ($xml->hasAttribute('AssertionConsumerServiceIndex')) {
            $this->assertionConsumerServiceIndex = (int) $xml->getAttribute('AssertionConsumerServiceIndex');
        }
 
        if ($xml->hasAttribute('ProviderName')) {
            $this->ProviderName = $xml->getAttribute('ProviderName');
        }
 
        $this->parseSubject($xml);
        $this->parseNameIdPolicy($xml);
        $this->parseRequestedAuthnContext($xml);
        $this->parseScoping($xml);
    }
 
    private function parseSubject(\DOMElement $xml)
    {
        $subject = Utils::xpQuery($xml, './saml_assertion:Subject');
        if (empty($subject)) {
            return;
        }
 
        if (count($subject) > 1) {
            throw new \Exception('More than one <saml:Subject> in <saml:AuthnRequest>.');
        }
        $subject = $subject[0];
 
        $nameId = Utils::xpQuery(
            $subject,
            './saml_assertion:NameID | ./saml_assertion:EncryptedID/xenc:EncryptedData'
        );
        if (empty($nameId)) {
            throw new \Exception('Missing <saml:NameID> or <saml:EncryptedID> in <saml:Subject>.');
        } elseif (count($nameId) > 1) {
            throw new \Exception('More than one <saml:NameID> or <saml:EncryptedID> in <saml:Subject>.');
        }
        $nameId = $nameId[0];
        if ($nameId->localName === 'EncryptedData') {
            /* The NameID element is encrypted. */
            $this->encryptedNameId = $nameId;
        } else {
            $this->nameId = new XML\saml\NameID($nameId);
        }
 
        $subjectConfirmation = Utils::xpQuery($subject, './saml_assertion:SubjectConfirmation');
        foreach ($subjectConfirmation as $sc) {
            $this->subjectConfirmation[] = new SubjectConfirmation($sc);
        }
    }
 
    protected function parseNameIdPolicy(\DOMElement $xml)
    {
        $nameIdPolicy = Utils::xpQuery($xml, './saml_protocol:NameIDPolicy');
        if (empty($nameIdPolicy)) {
            return;
        }
 
        $nameIdPolicy = $nameIdPolicy[0];
        if ($nameIdPolicy->hasAttribute('Format')) {
            $this->nameIdPolicy['Format'] = $nameIdPolicy->getAttribute('Format');
        }
        if ($nameIdPolicy->hasAttribute('SPNameQualifier')) {
            $this->nameIdPolicy['SPNameQualifier'] = $nameIdPolicy->getAttribute('SPNameQualifier');
        }
        if ($nameIdPolicy->hasAttribute('AllowCreate')) {
            $this->nameIdPolicy['AllowCreate'] = Utils::parseBoolean($nameIdPolicy, 'AllowCreate', false);
        }
    }
 
    protected function parseRequestedAuthnContext(\DOMElement $xml)
    {
        $requestedAuthnContext = Utils::xpQuery($xml, './saml_protocol:RequestedAuthnContext');
        if (empty($requestedAuthnContext)) {
            return;
        }
 
        $requestedAuthnContext = $requestedAuthnContext[0];
 
        $rac = array(
            'AuthnContextClassRef' => array(),
            'Comparison'           => Constants::COMPARISON_EXACT,
        );
 
        $accr = Utils::xpQuery($requestedAuthnContext, './saml_assertion:AuthnContextClassRef');
        foreach ($accr as $i) {
            $rac['AuthnContextClassRef'][] = trim($i->textContent);
        }
 
        if ($requestedAuthnContext->hasAttribute('Comparison')) {
            $rac['Comparison'] = $requestedAuthnContext->getAttribute('Comparison');
        }
 
        $this->requestedAuthnContext = $rac;
    }
 
    protected function parseScoping(\DOMElement $xml)
    {
        $scoping = Utils::xpQuery($xml, './saml_protocol:Scoping');
        if (empty($scoping)) {
            return;
        }
 
        $scoping = $scoping[0];
 
        if ($scoping->hasAttribute('ProxyCount')) {
            $this->ProxyCount = (int) $scoping->getAttribute('ProxyCount');
        }
        $idpEntries = Utils::xpQuery($scoping, './saml_protocol:IDPList/saml_protocol:IDPEntry');
 
        foreach ($idpEntries as $idpEntry) {
            if (!$idpEntry->hasAttribute('ProviderID')) {
                throw new \Exception("Could not get ProviderID from Scoping/IDPEntry element in AuthnRequest object");
            }
            $this->IDPList[] = $idpEntry->getAttribute('ProviderID');
        }
 
        $requesterIDs = Utils::xpQuery($scoping, './saml_protocol:RequesterID');
        foreach ($requesterIDs as $requesterID) {
            $this->RequesterID[] = trim($requesterID->textContent);
        }
    }
 
    public function getNameIdPolicy()
    {
        return $this->nameIdPolicy;
    }
 
 
    public function setNameIdPolicy(array $nameIdPolicy)
    {
        if (isset($nameIdPolicy['Format']) && !is_string($nameIdPolicy['Format'])) {
            throw InvalidArgumentException::invalidType('string', $nameIdPolicy['Format']);
        }
        if (isset($nameIdPolicy['SPNameQualifier']) && !is_string($nameIdPolicy['SPNameQualifier'])) {
            throw InvalidArgumentException::invalidType('string', $nameIdPolicy['SPNameQualifier']);
        }
        if (isset($nameIdPolicy['AllowCreate']) && !is_bool($nameIdPolicy['AllowCreate'])) {
            throw InvalidArgumentException::invalidType('bool', $nameIdPolicy['AllowCreate']);
        }
 
        $this->nameIdPolicy = $nameIdPolicy;
    }
 
 
    public function getForceAuthn()
    {
        return $this->forceAuthn;
    }
 
 
    public function setForceAuthn($forceAuthn)
    {
        assert(is_bool($forceAuthn));
 
        $this->forceAuthn = $forceAuthn;
    }
 
 
    public function getProviderName()
    {
        return $this->ProviderName;
    }
 
 
    public function setProviderName($ProviderName)
    {
        assert(is_string($ProviderName));
 
        $this->ProviderName = $ProviderName;
    }
 
 
    public function getIsPassive()
    {
        return $this->isPassive;
    }
 
 
    public function setIsPassive($isPassive)
    {
        assert(is_bool($isPassive));
 
        $this->isPassive = $isPassive;
    }
 
 
    public function setIDPList($IDPList)
    {
        assert(is_array($IDPList));
        $this->IDPList = $IDPList;
    }
 
 
    public function getIDPList()
    {
        return $this->IDPList;
    }
 
    public function setProxyCount($ProxyCount)
    {
        assert(is_int($ProxyCount));
        $this->ProxyCount = $ProxyCount;
    }
 
    public function getProxyCount()
    {
        return $this->ProxyCount;
    }
 
    public function setRequesterID(array $RequesterID)
    {
        $this->RequesterID = $RequesterID;
    }
 
    public function getRequesterID()
    {
        return $this->RequesterID;
    }
 
    public function getAssertionConsumerServiceURL()
    {
        return $this->assertionConsumerServiceURL;
    }
 
    public function setAssertionConsumerServiceURL($assertionConsumerServiceURL)
    {
        assert(is_string($assertionConsumerServiceURL) || is_null($assertionConsumerServiceURL));
 
        $this->assertionConsumerServiceURL = $assertionConsumerServiceURL;
    }
 
    public function getProtocolBinding()
    {
        return $this->protocolBinding;
    }
 
    public function setProtocolBinding($protocolBinding)
    {
        assert(is_string($protocolBinding) || is_null($protocolBinding));
 
        $this->protocolBinding = $protocolBinding;
    }
 
    public function getAttributeConsumingServiceIndex()
    {
        return $this->attributeConsumingServiceIndex;
    }
 
    public function setAttributeConsumingServiceIndex($attributeConsumingServiceIndex)
    {
        assert(is_int($attributeConsumingServiceIndex) || is_null($attributeConsumingServiceIndex));
 
        $this->attributeConsumingServiceIndex = $attributeConsumingServiceIndex;
    }
 
    public function getAssertionConsumerServiceIndex()
    {
        return $this->assertionConsumerServiceIndex;
    }
 
    public function setAssertionConsumerServiceIndex($assertionConsumerServiceIndex)
    {
        assert(is_int($assertionConsumerServiceIndex) || is_null($assertionConsumerServiceIndex));
 
        $this->assertionConsumerServiceIndex = $assertionConsumerServiceIndex;
    }
 
    public function getRequestedAuthnContext()
    {
        return $this->requestedAuthnContext;
    }
 
    public function setRequestedAuthnContext($requestedAuthnContext)
    {
        assert(is_array($requestedAuthnContext) || is_null($requestedAuthnContext));
 
        $this->requestedAuthnContext = $requestedAuthnContext;
    }
 
    public function getNameId()
    {
        if ($this->encryptedNameId !== null) {
            throw new \Exception('Attempted to retrieve encrypted NameID without decrypting it first.');
        }
 
        return $this->nameId;
    }
 
    public function setNameId($nameId)
    {
        assert(is_array($nameId) || is_null($nameId) || $nameId instanceof XML\saml\NameID);
 
        if (is_array($nameId)) {
            $nameId = XML\saml\NameID::fromArray($nameId);
        }
        $this->nameId = $nameId;
    }
 
    public function encryptNameId(XMLSecurityKey $key)
    {
        /* First create a XML representation of the NameID. */
        $doc  = new \DOMDocument();
        $root = $doc->createElement('root');
        $doc->appendChild($root);
        $this->nameId->toXML($root);
        $nameId = $root->firstChild;
 
        Utils::getContainer()->debugMessage($nameId, 'encrypt');
 
        /* Encrypt the NameID. */
        $enc = new XMLSecEnc();
        $enc->setNode($nameId);
        // @codingStandardsIgnoreStart
        $enc->type = XMLSecEnc::Element;
        // @codingStandardsIgnoreEnd
 
        $symmetricKey = new XMLSecurityKey(XMLSecurityKey::AES128_CBC);
        $symmetricKey->generateSessionKey();
        $enc->encryptKey($key, $symmetricKey);
 
        $this->encryptedNameId = $enc->encryptNode($symmetricKey);
        $this->nameId          = null;
    }
 
    public function decryptNameId(XMLSecurityKey $key, array $blacklist = array())
    {
        if ($this->encryptedNameId === null) {
            /* No NameID to decrypt. */
            return;
        }
 
        $nameId = Utils::decryptElement($this->encryptedNameId, $key, $blacklist);
        Utils::getContainer()->debugMessage($nameId, 'decrypt');
        $this->nameId = new XML\saml\NameID($nameId);
 
        $this->encryptedNameId = null;
    }
 
    public function getSubjectConfirmation()
    {
        return $this->subjectConfirmation;
    }
 
    public function setSubjectConfirmation(array $subjectConfirmation)
    {
        $this->subjectConfirmation = $subjectConfirmation;
    }
 
    public function toUnsignedXML()
    {
        $root = parent::toUnsignedXML();
 
        if ($this->forceAuthn) {
            $root->setAttribute('ForceAuthn', 'true');
        }
 
        if ($this->ProviderName !== null) {
            $root->setAttribute('ProviderName', $this->ProviderName);
        }
 
        if ($this->isPassive) {
            $root->setAttribute('IsPassive', 'true');
        }
 
        if ($this->assertionConsumerServiceIndex !== null) {
            $root->setAttribute('AssertionConsumerServiceIndex', $this->assertionConsumerServiceIndex);
        } else {
            if ($this->assertionConsumerServiceURL !== null) {
                $root->setAttribute('AssertionConsumerServiceURL', $this->assertionConsumerServiceURL);
            }
            if ($this->protocolBinding !== null) {
                $root->setAttribute('ProtocolBinding', $this->protocolBinding);
            }
        }
 
        if ($this->attributeConsumingServiceIndex !== null) {
            $root->setAttribute('AttributeConsumingServiceIndex', $this->attributeConsumingServiceIndex);
        }
 
        $this->addSubject($root);
 
        if (!empty($this->nameIdPolicy)) {
            $nameIdPolicy = $this->document->createElementNS(Constants::NS_SAMLP, 'NameIDPolicy');
            if (array_key_exists('Format', $this->nameIdPolicy)) {
                $nameIdPolicy->setAttribute('Format', $this->nameIdPolicy['Format']);
            }
            if (array_key_exists('SPNameQualifier', $this->nameIdPolicy)) {
                $nameIdPolicy->setAttribute('SPNameQualifier', $this->nameIdPolicy['SPNameQualifier']);
            }
            if (array_key_exists('AllowCreate', $this->nameIdPolicy)) {
                $nameIdPolicy->setAttribute('AllowCreate', ($this->nameIdPolicy['AllowCreate']) ? 'true' : 'false');
            }
            $root->appendChild($nameIdPolicy);
        }
 
        $rac = $this->requestedAuthnContext;
        if (!empty($rac) && !empty($rac['AuthnContextClassRef'])) {
            $e = $this->document->createElementNS(Constants::NS_SAMLP, 'RequestedAuthnContext');
            $root->appendChild($e);
            if (isset($rac['Comparison']) && $rac['Comparison'] !== Constants::COMPARISON_EXACT) {
                $e->setAttribute('Comparison', $rac['Comparison']);
            }
            foreach ($rac['AuthnContextClassRef'] as $accr) {
                Utils::addString($e, Constants::NS_SAML, 'AuthnContextClassRef', $accr);
            }
        }
 
        if ($this->ProxyCount !== null || count($this->IDPList) > 0 || count($this->RequesterID) > 0) {
            $scoping = $this->document->createElementNS(Constants::NS_SAMLP, 'Scoping');
            $root->appendChild($scoping);
            if ($this->ProxyCount !== null) {
                $scoping->setAttribute('ProxyCount', $this->ProxyCount);
            }
            if (count($this->IDPList) > 0) {
                $idplist = $this->document->createElementNS(Constants::NS_SAMLP, 'IDPList');
                foreach ($this->IDPList as $provider) {
                    $idpEntry = $this->document->createElementNS(Constants::NS_SAMLP, 'IDPEntry');
                    if (is_string($provider)) {
                        $idpEntry->setAttribute('ProviderID', $provider);
                    } elseif (is_array($provider)) {
                        foreach ($provider as $attribute => $value) {
                            if (in_array($attribute, array(
                                'ProviderID',
                                'Loc',
                                'Name'
                            ))) {
                                $idpEntry->setAttribute($attribute, $value);
                            }
                        }
                    }
                    $idplist->appendChild($idpEntry);
                }
                $scoping->appendChild($idplist);
            }
            if (count($this->RequesterID) > 0) {
                Utils::addStrings($scoping, Constants::NS_SAMLP, 'RequesterID', false, $this->RequesterID);
            }
        }
 
        return $root;
    }
 
    private function addSubject(\DOMElement $root)
    {
        // If there is no nameId (encrypted or not) there is nothing to create a subject for
        if ($this->nameId === null && $this->encryptedNameId === null) {
            return;
        }
 
        $subject = $root->ownerDocument->createElementNS(Constants::NS_SAML, 'saml:Subject');
        $root->appendChild($subject);
 
        if ($this->encryptedNameId === null) {
            $this->nameId->toXML($subject);
        } else {
            $eid = $subject->ownerDocument->createElementNS(Constants::NS_SAML, 'saml:EncryptedID');
            $eid->appendChild($subject->ownerDocument->importNode($this->encryptedNameId, true));
            $subject->appendChild($eid);
        }
 
        foreach ($this->subjectConfirmation as $sc) {
            $sc->toXML($subject);
        }
    }
}