EncryptedKey::fromKey() - Code Metrics - simplesamlphp/xml-security - Measure and Improve Code Quality continuously with Scrutinizer

EncryptedKey::fromKey() A
last analyzed 2025-10-02 21:52 UTC

↳ Parent: EncryptedKey

Complexity

Conditions	1
Paths	1

Size

Total Lines	37
Code Lines	19

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	19
c	1
b	0
f	0
nc	1
nop	11
dl	0
loc	37
rs	9.6333

How to fix Many Parameters

<?php

declare(strict_types=1);

namespace SimpleSAML\XMLSecurity\XML\xenc;

use DOMElement;
use SimpleSAML\Assert\Assert;
use SimpleSAML\XML\SchemaValidatableElementInterface;
use SimpleSAML\XML\SchemaValidatableElementTrait;
use SimpleSAML\XMLSchema\Exception\InvalidDOMElementException;
use SimpleSAML\XMLSchema\Exception\TooManyElementsException;
use SimpleSAML\XMLSchema\Type\AnyURIValue;
use SimpleSAML\XMLSchema\Type\Base64BinaryValue;
use SimpleSAML\XMLSchema\Type\IDValue;
use SimpleSAML\XMLSchema\Type\StringValue;
use SimpleSAML\XMLSecurity\Alg\Encryption\EncryptionAlgorithmInterface;
use SimpleSAML\XMLSecurity\Exception\InvalidArgumentException;
use SimpleSAML\XMLSecurity\Key\KeyInterface;
use SimpleSAML\XMLSecurity\XML\ds\KeyInfo;

use function strval;

/**
 * Class representing an encrypted key.
 *
 * @package simplesamlphp/xml-security
 */
final class EncryptedKey extends AbstractEncryptedType implements SchemaValidatableElementInterface
{
    use SchemaValidatableElementTrait;



    /**
     * EncryptedKey constructor.
     *
     * @param \SimpleSAML\XMLSecurity\XML\xenc\CipherData $cipherData The CipherData object of this EncryptedData.
     * @param \SimpleSAML\XMLSchema\Type\IDValue|null $id
     *   The Id attribute of this object. Optional.
     * @param \SimpleSAML\XMLSchema\Type\AnyURIValue|null $type
     *   The Type attribute of this object. Optional.
     * @param \SimpleSAML\XMLSchema\Type\StringValue|null $mimeType
     *   The MimeType attribute of this object. Optional.
     * @param \SimpleSAML\XMLSchema\Type\AnyURIValue|null $encoding
     *   The Encoding attribute of this object. Optional.
     * @param \SimpleSAML\XMLSchema\Type\StringValue|null $recipient
     *   The Recipient attribute of this object. Optional.
     * @param \SimpleSAML\XMLSecurity\XML\xenc\CarriedKeyName|null $carriedKeyName
     *   The value of the CarriedKeyName element of this EncryptedData.
     * @param \SimpleSAML\XMLSecurity\XML\xenc\EncryptionMethod|null $encryptionMethod
     *   The EncryptionMethod object of this EncryptedData. Optional.
     * @param \SimpleSAML\XMLSecurity\XML\ds\KeyInfo|null $keyInfo The KeyInfo object of this EncryptedData. Optional.
     * @param \SimpleSAML\XMLSecurity\XML\xenc\ReferenceList|null $referenceList
     *   The ReferenceList object of this EncryptedData. Optional.
     */
    final public function __construct(
        CipherData $cipherData,
        ?IDValue $id = null,
        ?AnyURIValue $type = null,
        ?StringValue $mimeType = null,
        ?AnyURIValue $encoding = null,
        protected ?StringValue $recipient = null,
        protected ?CarriedKeyName $carriedKeyName = null,
        ?EncryptionMethod $encryptionMethod = null,
        ?KeyInfo $keyInfo = null,
        protected ?ReferenceList $referenceList = null,
    ) {
        parent::__construct($cipherData, $id, $type, $mimeType, $encoding, $encryptionMethod, $keyInfo);
    }


    /**
     * Get the value of the CarriedKeyName property.
     *
     * @return \SimpleSAML\XMLSecurity\XML\xenc\CarriedKeyName|null
     */
    public function getCarriedKeyName(): ?CarriedKeyName
    {
        return $this->carriedKeyName;
    }


    /**
     * Get the value of the Recipient attribute.
     *
     * @return \SimpleSAML\XMLSchema\Type\StringValue|null
     */
    public function getRecipient(): ?StringValue
    {
        return $this->recipient;
    }


    /**
     * Get the ReferenceList object.
     *
     * @return \SimpleSAML\XMLSecurity\XML\xenc\ReferenceList|null
     */
    public function getReferenceList(): ?ReferenceList
    {
        return $this->referenceList;
    }


    /**
     * @param \SimpleSAML\XMLSecurity\Alg\Encryption\EncryptionAlgorithmInterface $decryptor The decryptor to use
     * to decrypt the key.
     *
     * @return string The decrypted key.
     */
    public function decrypt(EncryptionAlgorithmInterface $decryptor): string
    {
        $cipherValue =  $this->getCipherData()->getCipherValue();
        Assert::notNull(
            $cipherValue,
            'Decrypting keys by reference is not supported.',
            InvalidArgumentException::class,
        );

        Assert::eq(
            $decryptor->getAlgorithmId(),
            $this->getEncryptionMethod()?->getAlgorithm(),
            'Decryptor algorithm does not match algorithm used.',
            InvalidArgumentException::class,
        );

        return $decryptor->decrypt(base64_decode($cipherValue->getContent()->getValue(), true));
    }


    /**
     * Create an EncryptedKey by encrypting a given key.
     *
     * @param \SimpleSAML\XMLSecurity\Key\KeyInterface $keyToEncrypt The key to encrypt.
     * @param \SimpleSAML\XMLSecurity\Alg\Encryption\EncryptionAlgorithmInterface $encryptor The encryptor to use.
     * @param \SimpleSAML\XMLSecurity\XML\xenc\EncryptionMethod $encryptionMethod
     *   The EncryptionMethod object of this EncryptedData. Optional.
     * @param \SimpleSAML\XMLSchema\Type\IDValue|null $id The Id attribute of this object. Optional.
     * @param \SimpleSAML\XMLSchema\Type\AnyURIValue|null $type The Type attribute of this object. Optional.
     * @param \SimpleSAML\XMLSchema\Type\StringValue|null $mimeType
     *   The MimeType attribute of this object. Optional.
     * @param \SimpleSAML\XMLSchema\Type\AnyURIValue|null $encoding
     *   The Encoding attribute of this object. Optional.
     * @param \SimpleSAML\XMLSchema\Type\StringValue|null $recipient
     *   The Recipient attribute of this object. Optional.
     * @param \SimpleSAML\XMLSecurity\XML\xenc\CarriedKeyName|null $carriedKeyName
     *   The value of the CarriedKeyName element of this EncryptedData.
     * @param \SimpleSAML\XMLSecurity\XML\ds\KeyInfo|null $keyInfo The KeyInfo object of this EncryptedData. Optional.
     * @param \SimpleSAML\XMLSecurity\XML\xenc\ReferenceList|null $referenceList
     *   The ReferenceList object of this EncryptedData. Optional.
     *
     * @return \SimpleSAML\XMLSecurity\XML\xenc\EncryptedKey The new EncryptedKey object.
     */
    public static function fromKey(
        KeyInterface $keyToEncrypt,
        EncryptionAlgorithmInterface $encryptor,
        EncryptionMethod $encryptionMethod,
        ?IDValue $id = null,
        ?AnyURIValue $type = null,
        ?StringValue $mimeType = null,
        ?AnyURIValue $encoding = null,
        ?StringValue $recipient = null,
        ?CarriedKeyName $carriedKeyName = null,
        ?KeyInfo $keyInfo = null,
        ?ReferenceList $referenceList = null,
    ): EncryptedKey {
        Assert::eq(
            $encryptor->getAlgorithmId(),
            $encryptionMethod->getAlgorithm()->getValue(),
            'Encryptor algorithm and encryption method do not match.',
            InvalidArgumentException::class,
        );

        return new self(
            new CipherData(
                new CipherValue(
                    Base64BinaryValue::fromString(base64_encode(
                        $encryptor->encrypt($keyToEncrypt->getMaterial()),
                    )),
                ),
            ),
            $id,
            $type,
            $mimeType,
            $encoding,
            $recipient,
            $carriedKeyName,
            $encryptionMethod,
            $keyInfo,
            $referenceList,
        );
    }


    /**
     * @inheritDoc
     *
     * @throws \SimpleSAML\XMLSchema\Exception\InvalidDOMElementException
     *   If the qualified name of the supplied element is wrong
     */
    public static function fromXML(DOMElement $xml): static
    {
        Assert::same($xml->localName, 'EncryptedKey', InvalidDOMElementException::class);
        Assert::same($xml->namespaceURI, EncryptedKey::NS, InvalidDOMElementException::class);

        $cipherData = CipherData::getChildrenOfClass($xml);
        Assert::count(
            $cipherData,
            1,
            'No or more than one CipherData element found in <xenc:EncryptedKey>.',
            TooManyElementsException::class,
        );

        $encryptionMethod = EncryptionMethod::getChildrenOfClass($xml);
        Assert::maxCount(
            $encryptionMethod,
            1,
            'No more than one EncryptionMethod element allowed in <xenc:EncryptedKey>.',
            TooManyElementsException::class,
        );

        $keyInfo = KeyInfo::getChildrenOfClass($xml);
        Assert::maxCount(
            $keyInfo,
            1,
            'No more than one KeyInfo element allowed in <xenc:EncryptedKey>.',
            TooManyElementsException::class,
        );

        $referenceLists = ReferenceList::getChildrenOfClass($xml);
        Assert::maxCount(
            $keyInfo,
            1,
            'Only one ReferenceList element allowed in <xenc:EncryptedKey>.',
            TooManyElementsException::class,
        );

        $carriedKeyNames = CarriedKeyName::getChildrenOfClass($xml);
        Assert::maxCount(
            $carriedKeyNames,
            1,
            'Only one CarriedKeyName element allowed in <xenc:EncryptedKey>.',
            TooManyElementsException::class,
        );

        return new static(
            $cipherData[0],
            self::getOptionalAttribute($xml, 'Id', IDValue::class, null),
            self::getOptionalAttribute($xml, 'Type', AnyURIValue::class, null),
            self::getOptionalAttribute($xml, 'MimeType', StringValue::class, null),
            self::getOptionalAttribute($xml, 'Encoding', AnyURIValue::class, null),
            self::getOptionalAttribute($xml, 'Recipient', StringValue::class, null),
            array_pop($carriedKeyNames),
            array_pop($encryptionMethod),
            array_pop($keyInfo),
            array_pop($referenceLists),
        );
    }


    /**
     * @inheritDoc
     */
    public function toXML(?DOMElement $parent = null): DOMElement
    {
        $e = parent::toXML($parent);

        if ($this->getRecipient() !== null) {
            $e->setAttribute('Recipient', strval($this->getRecipient()));
        }

        $this->getReferenceList()?->toXML($e);
        $this->getCarriedKeyName()?->toXML($e);

        return $e;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace SimpleSAML\XMLSecurity\XML\xenc;
6
7			use DOMElement;
8			use SimpleSAML\Assert\Assert;
9			use SimpleSAML\XML\SchemaValidatableElementInterface;
10			use SimpleSAML\XML\SchemaValidatableElementTrait;
11			use SimpleSAML\XMLSchema\Exception\InvalidDOMElementException;
12			use SimpleSAML\XMLSchema\Exception\TooManyElementsException;
13			use SimpleSAML\XMLSchema\Type\AnyURIValue;
14			use SimpleSAML\XMLSchema\Type\Base64BinaryValue;
15			use SimpleSAML\XMLSchema\Type\IDValue;
16			use SimpleSAML\XMLSchema\Type\StringValue;
17			use SimpleSAML\XMLSecurity\Alg\Encryption\EncryptionAlgorithmInterface;
18			use SimpleSAML\XMLSecurity\Exception\InvalidArgumentException;
19			use SimpleSAML\XMLSecurity\Key\KeyInterface;
20			use SimpleSAML\XMLSecurity\XML\ds\KeyInfo;
21
22			use function strval;
23
24			/**
25			* Class representing an encrypted key.
26			*
27			* @package simplesamlphp/xml-security
28			*/
29			final class EncryptedKey extends AbstractEncryptedType implements SchemaValidatableElementInterface
30			{
31			use SchemaValidatableElementTrait;
			0 ignored issues – show introduced 2024-12-19 20:23 UTC by Report Bug Copy Issue Report The trait `SimpleSAML\XML\SchemaValidatableElementTrait` requires some properties which are not provided by `SimpleSAML\XMLSecurity\XML\xenc\EncryptedKey`: `$message`, `$line` Loading history...
32
33
34			/**
35			* EncryptedKey constructor.
36			*
37			* @param \SimpleSAML\XMLSecurity\XML\xenc\CipherData $cipherData The CipherData object of this EncryptedData.
38			* @param \SimpleSAML\XMLSchema\Type\IDValue\|null $id
39			* The Id attribute of this object. Optional.
40			* @param \SimpleSAML\XMLSchema\Type\AnyURIValue\|null $type
41			* The Type attribute of this object. Optional.
42			* @param \SimpleSAML\XMLSchema\Type\StringValue\|null $mimeType
43			* The MimeType attribute of this object. Optional.
44			* @param \SimpleSAML\XMLSchema\Type\AnyURIValue\|null $encoding
45			* The Encoding attribute of this object. Optional.
46			* @param \SimpleSAML\XMLSchema\Type\StringValue\|null $recipient
47			* The Recipient attribute of this object. Optional.
48			* @param \SimpleSAML\XMLSecurity\XML\xenc\CarriedKeyName\|null $carriedKeyName
49			* The value of the CarriedKeyName element of this EncryptedData.
50			* @param \SimpleSAML\XMLSecurity\XML\xenc\EncryptionMethod\|null $encryptionMethod
51			* The EncryptionMethod object of this EncryptedData. Optional.
52			* @param \SimpleSAML\XMLSecurity\XML\ds\KeyInfo\|null $keyInfo The KeyInfo object of this EncryptedData. Optional.
53			* @param \SimpleSAML\XMLSecurity\XML\xenc\ReferenceList\|null $referenceList
54			* The ReferenceList object of this EncryptedData. Optional.
55			*/
56			final public function __construct(
57			CipherData $cipherData,
58			?IDValue $id = null,
59			?AnyURIValue $type = null,
60			?StringValue $mimeType = null,
61			?AnyURIValue $encoding = null,
62			protected ?StringValue $recipient = null,
63			protected ?CarriedKeyName $carriedKeyName = null,
64			?EncryptionMethod $encryptionMethod = null,
65			?KeyInfo $keyInfo = null,
66			protected ?ReferenceList $referenceList = null,
67			) {
68			parent::__construct($cipherData, $id, $type, $mimeType, $encoding, $encryptionMethod, $keyInfo);
69			}
70
71
72			/**
73			* Get the value of the CarriedKeyName property.
74			*
75			* @return \SimpleSAML\XMLSecurity\XML\xenc\CarriedKeyName\|null
76			*/
77			public function getCarriedKeyName(): ?CarriedKeyName
78			{
79			return $this->carriedKeyName;
80			}
81
82
83			/**
84			* Get the value of the Recipient attribute.
85			*
86			* @return \SimpleSAML\XMLSchema\Type\StringValue\|null
87			*/
88			public function getRecipient(): ?StringValue
89			{
90			return $this->recipient;
91			}
92
93
94			/**
95			* Get the ReferenceList object.
96			*
97			* @return \SimpleSAML\XMLSecurity\XML\xenc\ReferenceList\|null
98			*/
99			public function getReferenceList(): ?ReferenceList
100			{
101			return $this->referenceList;
102			}
103
104
105			/**
106			* @param \SimpleSAML\XMLSecurity\Alg\Encryption\EncryptionAlgorithmInterface $decryptor The decryptor to use
107			* to decrypt the key.
108			*
109			* @return string The decrypted key.
110			*/
111			public function decrypt(EncryptionAlgorithmInterface $decryptor): string
112			{
113			$cipherValue = $this->getCipherData()->getCipherValue();
114			Assert::notNull(
115			$cipherValue,
116			'Decrypting keys by reference is not supported.',
117			InvalidArgumentException::class,
118			);
119
120			Assert::eq(
121			$decryptor->getAlgorithmId(),
122			$this->getEncryptionMethod()?->getAlgorithm(),
123			'Decryptor algorithm does not match algorithm used.',
124			InvalidArgumentException::class,
125			);
126
127			return $decryptor->decrypt(base64_decode($cipherValue->getContent()->getValue(), true));
128			}
129
130
131			/**
132			* Create an EncryptedKey by encrypting a given key.
133			*
134			* @param \SimpleSAML\XMLSecurity\Key\KeyInterface $keyToEncrypt The key to encrypt.
135			* @param \SimpleSAML\XMLSecurity\Alg\Encryption\EncryptionAlgorithmInterface $encryptor The encryptor to use.
136			* @param \SimpleSAML\XMLSecurity\XML\xenc\EncryptionMethod $encryptionMethod
137			* The EncryptionMethod object of this EncryptedData. Optional.
138			* @param \SimpleSAML\XMLSchema\Type\IDValue\|null $id The Id attribute of this object. Optional.
139			* @param \SimpleSAML\XMLSchema\Type\AnyURIValue\|null $type The Type attribute of this object. Optional.
140			* @param \SimpleSAML\XMLSchema\Type\StringValue\|null $mimeType
141			* The MimeType attribute of this object. Optional.
142			* @param \SimpleSAML\XMLSchema\Type\AnyURIValue\|null $encoding
143			* The Encoding attribute of this object. Optional.
144			* @param \SimpleSAML\XMLSchema\Type\StringValue\|null $recipient
145			* The Recipient attribute of this object. Optional.
146			* @param \SimpleSAML\XMLSecurity\XML\xenc\CarriedKeyName\|null $carriedKeyName
147			* The value of the CarriedKeyName element of this EncryptedData.
148			* @param \SimpleSAML\XMLSecurity\XML\ds\KeyInfo\|null $keyInfo The KeyInfo object of this EncryptedData. Optional.
149			* @param \SimpleSAML\XMLSecurity\XML\xenc\ReferenceList\|null $referenceList
150			* The ReferenceList object of this EncryptedData. Optional.
151			*
152			* @return \SimpleSAML\XMLSecurity\XML\xenc\EncryptedKey The new EncryptedKey object.
153			*/
154			public static function fromKey(
155			KeyInterface $keyToEncrypt,
156			EncryptionAlgorithmInterface $encryptor,
157			EncryptionMethod $encryptionMethod,
158			?IDValue $id = null,
159			?AnyURIValue $type = null,
160			?StringValue $mimeType = null,
161			?AnyURIValue $encoding = null,
162			?StringValue $recipient = null,
163			?CarriedKeyName $carriedKeyName = null,
164			?KeyInfo $keyInfo = null,
165			?ReferenceList $referenceList = null,
166			): EncryptedKey {
167			Assert::eq(
168			$encryptor->getAlgorithmId(),
169			$encryptionMethod->getAlgorithm()->getValue(),
170			'Encryptor algorithm and encryption method do not match.',
171			InvalidArgumentException::class,
172			);
173
174			return new self(
175			new CipherData(
176			new CipherValue(
177			Base64BinaryValue::fromString(base64_encode(
178			$encryptor->encrypt($keyToEncrypt->getMaterial()),
179			)),
180			),
181			),
182			$id,
183			$type,
184			$mimeType,
185			$encoding,
186			$recipient,
187			$carriedKeyName,
188			$encryptionMethod,
189			$keyInfo,
190			$referenceList,
191			);
192			}
193
194
195			/**
196			* @inheritDoc
197			*
198			* @throws \SimpleSAML\XMLSchema\Exception\InvalidDOMElementException
199			* If the qualified name of the supplied element is wrong
200			*/
201			public static function fromXML(DOMElement $xml): static
202			{
203			Assert::same($xml->localName, 'EncryptedKey', InvalidDOMElementException::class);
204			Assert::same($xml->namespaceURI, EncryptedKey::NS, InvalidDOMElementException::class);
205
206			$cipherData = CipherData::getChildrenOfClass($xml);
207			Assert::count(
208			$cipherData,
209			1,
210			'No or more than one CipherData element found in <xenc:EncryptedKey>.',
211			TooManyElementsException::class,
212			);
213
214			$encryptionMethod = EncryptionMethod::getChildrenOfClass($xml);
215			Assert::maxCount(
216			$encryptionMethod,
217			1,
218			'No more than one EncryptionMethod element allowed in <xenc:EncryptedKey>.',
219			TooManyElementsException::class,
220			);
221
222			$keyInfo = KeyInfo::getChildrenOfClass($xml);
223			Assert::maxCount(
224			$keyInfo,
225			1,
226			'No more than one KeyInfo element allowed in <xenc:EncryptedKey>.',
227			TooManyElementsException::class,
228			);
229
230			$referenceLists = ReferenceList::getChildrenOfClass($xml);
231			Assert::maxCount(
232			$keyInfo,
233			1,
234			'Only one ReferenceList element allowed in <xenc:EncryptedKey>.',
235			TooManyElementsException::class,
236			);
237
238			$carriedKeyNames = CarriedKeyName::getChildrenOfClass($xml);
239			Assert::maxCount(
240			$carriedKeyNames,
241			1,
242			'Only one CarriedKeyName element allowed in <xenc:EncryptedKey>.',
243			TooManyElementsException::class,
244			);
245
246			return new static(
247			$cipherData[0],
248			self::getOptionalAttribute($xml, 'Id', IDValue::class, null),
249			self::getOptionalAttribute($xml, 'Type', AnyURIValue::class, null),
250			self::getOptionalAttribute($xml, 'MimeType', StringValue::class, null),
251			self::getOptionalAttribute($xml, 'Encoding', AnyURIValue::class, null),
252			self::getOptionalAttribute($xml, 'Recipient', StringValue::class, null),
253			array_pop($carriedKeyNames),
254			array_pop($encryptionMethod),
255			array_pop($keyInfo),
256			array_pop($referenceLists),
257			);
258			}
259
260
261			/**
262			* @inheritDoc
263			*/
264			public function toXML(?DOMElement $parent = null): DOMElement
265			{
266			$e = parent::toXML($parent);
267
268			if ($this->getRecipient() !== null) {
269			$e->setAttribute('Recipient', strval($this->getRecipient()));
270			}
271
272			$this->getReferenceList()?->toXML($e);
273			$this->getCarriedKeyName()?->toXML($e);
274
275			return $e;
276			}
277			}
278

simplesamlphp / xml-security

EncryptedKey::fromKey() A last analyzed 2025-10-02 21:52 UTC

Complexity

Size

Duplication

Importance

How to fix Many Parameters

Many Parameters

Duplication Side-by-Side

Filter issues like

EncryptedKey::fromKey() A
last analyzed 2025-10-02 21:52 UTC