Loader::convert() - Code Metrics - Inspection of "Logger removed and new interfaces" - Spomky-Labs/jose - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 65e224...f25ceb )

by Florent

created 2016-07-16 08:37 UTC

Loader::convert() B

↳ Parent: Loader

Complexity

Conditions	7
Paths	6

Size

Total Lines	19
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Importance

Changes	4
Bugs	1	Features	1

Metric	Value
c	4
b	1
f	1
dl	0
loc	19
rs	8.2222
cc	7
eloc	11
nc	6
nop	1

<?php

/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2014-2016 Spomky-Labs
 *
 * This software may be modified and distributed under the terms
 * of the MIT license.  See the LICENSE file for details.
 */

namespace Jose;

use Assert\Assertion;
use Jose\Object\JWEInterface;
use Jose\Object\JWKInterface;
use Jose\Object\JWKSet;
use Jose\Object\JWKSetInterface;
use Jose\Object\JWSInterface;
use Jose\Util\JWELoader;
use Jose\Util\JWSLoader;

/**
 * Class able to load JWS or JWE.
 * JWS object can also be verified.
 */
final class Loader implements LoaderInterface
{
    /**
     * {@inheritdoc}
     */
    public function loadAndDecryptUsingKey($input, JWKInterface $jwk, array $allowed_key_encryption_algorithms, array $allowed_content_encryption_algorithms, &$recipient_index = null)
    {
        $jwk_set = new JWKSet();
        $jwk_set->addKey($jwk);

        return $this->loadAndDecrypt($input, $jwk_set, $allowed_key_encryption_algorithms, $allowed_content_encryption_algorithms, $recipient_index);
    }

    /**
     * {@inheritdoc}
     */
    public function loadAndDecryptUsingKeySet($input, JWKSetInterface $jwk_set, array $allowed_key_encryption_algorithms, array $allowed_content_encryption_algorithms, &$recipient_index = null)
    {
        return $this->loadAndDecrypt($input, $jwk_set, $allowed_key_encryption_algorithms, $allowed_content_encryption_algorithms, $recipient_index);
    }

    /**
     * {@inheritdoc}
     */
    public function loadAndVerifySignatureUsingKey($input, JWKInterface $jwk, array $allowed_algorithms, &$signature_index = null)
    {
        $jwk_set = new JWKSet();
        $jwk_set->addKey($jwk);

        return $this->loadAndVerifySignature($input, $jwk_set, $allowed_algorithms, null, $signature_index);
    }

    /**
     * {@inheritdoc}
     */
    public function loadAndVerifySignatureUsingKeySet($input, JWKSetInterface $jwk_set, array $allowed_algorithms, &$signature_index = null)
    {
        return $this->loadAndVerifySignature($input, $jwk_set, $allowed_algorithms, null, $signature_index);
    }

    /**
     * {@inheritdoc}
     */
    public function loadAndVerifySignatureUsingKeyAndDetachedPayload($input, JWKInterface $jwk, array $allowed_algorithms, $detached_payload, &$signature_index = null)
    {
        $jwk_set = new JWKSet();
        $jwk_set->addKey($jwk);

        return $this->loadAndVerifySignature($input, $jwk_set, $allowed_algorithms, $detached_payload, $signature_index);
    }

    /**
     * {@inheritdoc}
     */
    public function loadAndVerifySignatureUsingKeySetAndDetachedPayload($input, JWKSetInterface $jwk_set, array $allowed_algorithms, $detached_payload, &$signature_index = null)
    {
        return $this->loadAndVerifySignature($input, $jwk_set, $allowed_algorithms, $detached_payload, $signature_index);
    }

    /**
     * @param string                        $input
     * @param \Jose\Object\JWKSetInterface  $jwk_set
     * @param array                         $allowed_key_encryption_algorithms
     * @param array                         $allowed_content_encryption_algorithms
     * @param null|int                      $recipient_index
     *
     * @return \Jose\Object\JWEInterface
     */
    private function loadAndDecrypt($input, JWKSetInterface $jwk_set, array $allowed_key_encryption_algorithms, array $allowed_content_encryption_algorithms, &$recipient_index = null)
    {
        $jwt = $this->load($input);
        Assertion::isInstanceOf($jwt, JWEInterface::class, 'The input is not a valid JWE');
        $decrypted = Decrypter::createDecrypter($allowed_key_encryption_algorithms, $allowed_content_encryption_algorithms, ['DEF', 'ZLIB', 'GZ']);

        $decrypted->decryptUsingKeySet($jwt, $jwk_set, $recipient_index);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        return $jwt;
    }

    /**
     * @param string                        $input
     * @param \Jose\Object\JWKSetInterface  $jwk_set
     * @param array                         $allowed_algorithms
     * @param string|null                   $detached_payload
     * @param null|int                      $signature_index
     *
     * @return \Jose\Object\JWSInterface
     */
    private function loadAndVerifySignature($input, JWKSetInterface $jwk_set, array $allowed_algorithms, $detached_payload = null, &$signature_index = null)
    {
        $jwt = $this->load($input);

        Assertion::isInstanceOf($jwt, JWSInterface::class, 'The input is not a valid JWS.');
        $verifier = Verifier::createVerifier($allowed_algorithms);

        $verifier->verifyWithKeySet($jwt, $jwk_set, $detached_payload, $signature_index);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        return $jwt;
    }

    /**
     * {@inheritdoc}
     */
    public function load($input)
    {
        $json = $this->convert($input);
        if (array_key_exists('signatures', $json)) {

            return JWSLoader::loadSerializedJsonJWS($json);
        }
        if (array_key_exists('recipients', $json)) {

            return JWELoader::loadSerializedJsonJWE($json);
        }
    }

    /**
     * @param string $input
     *
     * @return array
     */
    private function convert($input)
    {
        if (is_array($data = json_decode($input, true))) {
            if (array_key_exists('signatures', $data) || array_key_exists('recipients', $data)) {

                return $data;
            } elseif (array_key_exists('signature', $data)) {

                return $this->fromFlattenedSerializationSignatureToSerialization($data);
            } elseif (array_key_exists('ciphertext', $data)) {

                return $this->fromFlattenedSerializationRecipientToSerialization($data);
            }
        } elseif (is_string($input)) {

            return $this->fromCompactSerializationToSerialization($input);
        }
        throw new \InvalidArgumentException('Unsupported input');
    }

    /**
     * @param $input
     *
     * @return array
     */
    private function fromFlattenedSerializationRecipientToSerialization($input)
    {
        $recipient = [];
        foreach (['header', 'encrypted_key'] as $key) {
            if (array_key_exists($key, $input)) {
                $recipient[$key] = $input[$key];
            }
        }
        $recipients = [
            'ciphertext' => $input['ciphertext'],
            'recipients' => [$recipient],
        ];
        foreach (['protected', 'unprotected', 'iv', 'aad', 'tag'] as $key) {
            if (array_key_exists($key, $input)) {
                $recipients[$key] = $input[$key];
            }
        }


        return $recipients;
    }

    /**
     * @param $input
     *
     * @return array
     */
    private function fromFlattenedSerializationSignatureToSerialization($input)
    {
        $signature = [
            'signature' => $input['signature'],
        ];
        foreach (['protected', 'header'] as $key) {
            if (array_key_exists($key, $input)) {
                $signature[$key] = $input[$key];
            }
        }

        $temp = [];
        if (!empty($input['payload'])) {
            $temp['payload'] = $input['payload'];
        }
        $temp['signatures'] = [$signature];


        return $temp;
    }

    /**
     * @param string $input
     *
     * @return array
     */
    private function fromCompactSerializationToSerialization($input)
    {
        $parts = explode('.', $input);
        switch (count($parts)) {
            case 3:

                return $this->fromCompactSerializationSignatureToSerialization($parts);
            case 5:

                return $this->fromCompactSerializationRecipientToSerialization($parts);
            default:
                throw new \InvalidArgumentException('Unsupported input');
        }
    }

    /**
     * @param array $parts
     *
     * @return array
     */
    private function fromCompactSerializationRecipientToSerialization(array $parts)
    {
        $recipient = [];
        if (!empty($parts[1])) {
            $recipient['encrypted_key'] = $parts[1];
        }

        $recipients = [
            'recipients' => [$recipient],
        ];
        foreach ([0 => 'protected', 2 => 'iv', 3 => 'ciphertext', 4 => 'tag'] as $part => $key) {
            if (!empty($parts[$part])) {
                $recipients[$key] = $parts[$part];
            }
        }


        return $recipients;
    }

    /**
     * @param array $parts
     *
     * @return array
     */
    private function fromCompactSerializationSignatureToSerialization(array $parts)
    {
        $temp = [];

        if (!empty($parts[1])) {
            $temp['payload'] = $parts[1];
        }
        $temp['signatures'] = [[
            'protected' => $parts[0],
            'signature' => $parts[2],
        ]];


        return $temp;
    }
}


1			<?php
2
3			/*
4			* The MIT License (MIT)
5			*
6			* Copyright (c) 2014-2016 Spomky-Labs
7			*
8			* This software may be modified and distributed under the terms
9			* of the MIT license. See the LICENSE file for details.
10			*/
11
12			namespace Jose;
13
14			use Assert\Assertion;
15			use Jose\Object\JWEInterface;
16			use Jose\Object\JWKInterface;
17			use Jose\Object\JWKSet;
18			use Jose\Object\JWKSetInterface;
19			use Jose\Object\JWSInterface;
20			use Jose\Util\JWELoader;
21			use Jose\Util\JWSLoader;
22
23			/**
24			* Class able to load JWS or JWE.
25			* JWS object can also be verified.
26			*/
27			final class Loader implements LoaderInterface
28			{
29			/**
30			* {@inheritdoc}
31			*/
32			public function loadAndDecryptUsingKey($input, JWKInterface $jwk, array $allowed_key_encryption_algorithms, array $allowed_content_encryption_algorithms, &$recipient_index = null)
33			{
34			$jwk_set = new JWKSet();
35			$jwk_set->addKey($jwk);
36
37			return $this->loadAndDecrypt($input, $jwk_set, $allowed_key_encryption_algorithms, $allowed_content_encryption_algorithms, $recipient_index);
38			}
39
40			/**
41			* {@inheritdoc}
42			*/
43			public function loadAndDecryptUsingKeySet($input, JWKSetInterface $jwk_set, array $allowed_key_encryption_algorithms, array $allowed_content_encryption_algorithms, &$recipient_index = null)
44			{
45			return $this->loadAndDecrypt($input, $jwk_set, $allowed_key_encryption_algorithms, $allowed_content_encryption_algorithms, $recipient_index);
46			}
47
48			/**
49			* {@inheritdoc}
50			*/
51			public function loadAndVerifySignatureUsingKey($input, JWKInterface $jwk, array $allowed_algorithms, &$signature_index = null)
52			{
53			$jwk_set = new JWKSet();
54			$jwk_set->addKey($jwk);
55
56			return $this->loadAndVerifySignature($input, $jwk_set, $allowed_algorithms, null, $signature_index);
57			}
58
59			/**
60			* {@inheritdoc}
61			*/
62			public function loadAndVerifySignatureUsingKeySet($input, JWKSetInterface $jwk_set, array $allowed_algorithms, &$signature_index = null)
63			{
64			return $this->loadAndVerifySignature($input, $jwk_set, $allowed_algorithms, null, $signature_index);
65			}
66
67			/**
68			* {@inheritdoc}
69			*/
70			public function loadAndVerifySignatureUsingKeyAndDetachedPayload($input, JWKInterface $jwk, array $allowed_algorithms, $detached_payload, &$signature_index = null)
71			{
72			$jwk_set = new JWKSet();
73			$jwk_set->addKey($jwk);
74
75			return $this->loadAndVerifySignature($input, $jwk_set, $allowed_algorithms, $detached_payload, $signature_index);
76			}
77
78			/**
79			* {@inheritdoc}
80			*/
81			public function loadAndVerifySignatureUsingKeySetAndDetachedPayload($input, JWKSetInterface $jwk_set, array $allowed_algorithms, $detached_payload, &$signature_index = null)
82			{
83			return $this->loadAndVerifySignature($input, $jwk_set, $allowed_algorithms, $detached_payload, $signature_index);
84			}
85
86			/**
87			* @param string $input
88			* @param \Jose\Object\JWKSetInterface $jwk_set
89			* @param array $allowed_key_encryption_algorithms
90			* @param array $allowed_content_encryption_algorithms
91			* @param null\|int $recipient_index
92			*
93			* @return \Jose\Object\JWEInterface
94			*/
95			private function loadAndDecrypt($input, JWKSetInterface $jwk_set, array $allowed_key_encryption_algorithms, array $allowed_content_encryption_algorithms, &$recipient_index = null)
96			{
97			$jwt = $this->load($input);
98			Assertion::isInstanceOf($jwt, JWEInterface::class, 'The input is not a valid JWE');
99			$decrypted = Decrypter::createDecrypter($allowed_key_encryption_algorithms, $allowed_content_encryption_algorithms, ['DEF', 'ZLIB', 'GZ']);
100
101			$decrypted->decryptUsingKeySet($jwt, $jwk_set, $recipient_index);
			0 ignored issues – show Bug introduced 2016-04-05 22:18 UTC by Report Bug Copy Issue Report It seems like `$jwt` defined by `$this->load($input)` on line `97` can also be of type `object<Jose\Object\JWSInterface>`; however, `Jose\Decrypter::decryptUsingKeySet()` does only seem to accept `object<Jose\Object\JWEInterface>`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
102
103			return $jwt;
104			}
105
106			/**
107			* @param string $input
108			* @param \Jose\Object\JWKSetInterface $jwk_set
109			* @param array $allowed_algorithms
110			* @param string\|null $detached_payload
111			* @param null\|int $signature_index
112			*
113			* @return \Jose\Object\JWSInterface
114			*/
115			private function loadAndVerifySignature($input, JWKSetInterface $jwk_set, array $allowed_algorithms, $detached_payload = null, &$signature_index = null)
116			{
117			$jwt = $this->load($input);
			0 ignored issues – show Bug Compatibility introduced 2016-04-05 22:18 UTC by Report Bug Copy Issue Report The expression `$this->load($input);` of type `Jose\Object\JWSInterface\|Jose\Object\JWEInterface` adds the type `Jose\Object\JWEInterface` to the return on line 123 which is incompatible with the return type documented by `Jose\Loader::loadAndVerifySignature` of type `Jose\Object\JWSInterface`. Loading history...
118			Assertion::isInstanceOf($jwt, JWSInterface::class, 'The input is not a valid JWS.');
119			$verifier = Verifier::createVerifier($allowed_algorithms);
120
121			$verifier->verifyWithKeySet($jwt, $jwk_set, $detached_payload, $signature_index);
			0 ignored issues – show Bug introduced 2016-04-05 22:18 UTC by Report Bug Copy Issue Report It seems like `$jwt` defined by `$this->load($input)` on line `117` can also be of type `object<Jose\Object\JWEInterface>`; however, `Jose\Verifier::verifyWithKeySet()` does only seem to accept `object<Jose\Object\JWSInterface>`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
122
123			return $jwt;
124			}
125
126			/**
127			* {@inheritdoc}
128			*/
129			public function load($input)
130			{
131			$json = $this->convert($input);
132			if (array_key_exists('signatures', $json)) {
133
134			return JWSLoader::loadSerializedJsonJWS($json);
135			}
136			if (array_key_exists('recipients', $json)) {
137
138			return JWELoader::loadSerializedJsonJWE($json);
139			}
140			}
141
142			/**
143			* @param string $input
144			*
145			* @return array
146			*/
147			private function convert($input)
148			{
149			if (is_array($data = json_decode($input, true))) {
150			if (array_key_exists('signatures', $data) \|\| array_key_exists('recipients', $data)) {
151
152			return $data;
153			} elseif (array_key_exists('signature', $data)) {
154
155			return $this->fromFlattenedSerializationSignatureToSerialization($data);
156			} elseif (array_key_exists('ciphertext', $data)) {
157
158			return $this->fromFlattenedSerializationRecipientToSerialization($data);
159			}
160			} elseif (is_string($input)) {
161
162			return $this->fromCompactSerializationToSerialization($input);
163			}
164			throw new \InvalidArgumentException('Unsupported input');
165			}
166
167			/**
168			* @param $input
169			*
170			* @return array
171			*/
172			private function fromFlattenedSerializationRecipientToSerialization($input)
173			{
174			$recipient = [];
175			foreach (['header', 'encrypted_key'] as $key) {
176			if (array_key_exists($key, $input)) {
177			$recipient[$key] = $input[$key];
178			}
179			}
180			$recipients = [
181			'ciphertext' => $input['ciphertext'],
182			'recipients' => [$recipient],
183			];
184			foreach (['protected', 'unprotected', 'iv', 'aad', 'tag'] as $key) {
185			if (array_key_exists($key, $input)) {
186			$recipients[$key] = $input[$key];
187			}
188			}
189
190
191			return $recipients;
192			}
193
194			/**
195			* @param $input
196			*
197			* @return array
198			*/
199			private function fromFlattenedSerializationSignatureToSerialization($input)
200			{
201			$signature = [
202			'signature' => $input['signature'],
203			];
204			foreach (['protected', 'header'] as $key) {
205			if (array_key_exists($key, $input)) {
206			$signature[$key] = $input[$key];
207			}
208			}
209
210			$temp = [];
211			if (!empty($input['payload'])) {
212			$temp['payload'] = $input['payload'];
213			}
214			$temp['signatures'] = [$signature];
215
216
217			return $temp;
218			}
219
220			/**
221			* @param string $input
222			*
223			* @return array
224			*/
225			private function fromCompactSerializationToSerialization($input)
226			{
227			$parts = explode('.', $input);
228			switch (count($parts)) {
229			case 3:
230
231			return $this->fromCompactSerializationSignatureToSerialization($parts);
232			case 5:
233
234			return $this->fromCompactSerializationRecipientToSerialization($parts);
235			default:
236			throw new \InvalidArgumentException('Unsupported input');
237			}
238			}
239
240			/**
241			* @param array $parts
242			*
243			* @return array
244			*/
245			private function fromCompactSerializationRecipientToSerialization(array $parts)
246			{
247			$recipient = [];
248			if (!empty($parts[1])) {
249			$recipient['encrypted_key'] = $parts[1];
250			}
251
252			$recipients = [
253			'recipients' => [$recipient],
254			];
255			foreach ([0 => 'protected', 2 => 'iv', 3 => 'ciphertext', 4 => 'tag'] as $part => $key) {
256			if (!empty($parts[$part])) {
257			$recipients[$key] = $parts[$part];
258			}
259			}
260
261
262			return $recipients;
263			}
264
265			/**
266			* @param array $parts
267			*
268			* @return array
269			*/
270			private function fromCompactSerializationSignatureToSerialization(array $parts)
271			{
272			$temp = [];
273
274			if (!empty($parts[1])) {
275			$temp['payload'] = $parts[1];
276			}
277			$temp['signatures'] = [[
278			'protected' => $parts[0],
279			'signature' => $parts[2],
280			]];
281
282
283			return $temp;
284			}
285			}
286

Spomky-Labs / jose

Push — master ( 65e224...f25ceb )

Loader::convert() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like