JSONGeneralSerializer::unserialize() - Code Metrics - Spomky-Labs/jose - Measure and Improve Code Quality continuously with Scrutinizer

JSONGeneralSerializer::unserialize() C
last analyzed 2017-10-05 20:43 UTC

↳ Parent: JSONGeneralSerializer

Complexity

Conditions	11
Paths	81

Size

Total Lines	31
Code Lines	25

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	31
rs	5.2653
c	0
b	0
f	0
cc	11
eloc	25
nc	81
nop	1

How to fix Complexity

<?php

declare(strict_types=1);

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

namespace Jose\Component\Encryption\Serializer;

use Base64Url\Base64Url;
use Jose\Component\Core\Converter\JsonConverterInterface;
use Jose\Component\Encryption\JWE;
use Jose\Component\Encryption\Recipient;

/**
 * Class JSONGeneralSerializer.
 */
final class JSONGeneralSerializer implements JWESerializerInterface
{
    public const NAME = 'jwe_json_general';

    /**
     * @var JsonConverterInterface
     */
    private $jsonConverter;

    /**
     * JSONFlattenedSerializer constructor.
     *
     * @param JsonConverterInterface $jsonConverter
     */
    public function __construct(JsonConverterInterface $jsonConverter)
    {
        $this->jsonConverter = $jsonConverter;
    }

    /**
     * {@inheritdoc}
     */
    public function displayName(): string
    {
        return 'JWE JSON General';
    }

    /**
     * {@inheritdoc}
     */
    public function name(): string
    {
        return self::NAME;
    }

    /**
     * {@inheritdoc}
     */
    public function serialize(JWE $jwe, ?int $recipientIndex = null): string
    {
        if (0 === $jwe->countRecipients()) {
            throw new \LogicException('No recipient.');
        }

        $data = [
            'ciphertext' => Base64Url::encode($jwe->getCiphertext()),
            'iv' => Base64Url::encode($jwe->getIV()),
            'tag' => Base64Url::encode($jwe->getTag()),
        ];
        if (null !== $jwe->getAAD()) {
            $data['aad'] = Base64Url::encode($jwe->getAAD());
        }
        if (!empty($jwe->getSharedProtectedHeaders())) {
            $data['protected'] = $jwe->getEncodedSharedProtectedHeaders();
        }
        if (!empty($jwe->getSharedHeaders())) {
            $data['unprotected'] = $jwe->getSharedHeaders();
        }
        $data['recipients'] = [];
        foreach ($jwe->getRecipients() as $recipient) {
            $temp = [];
            if (!empty($recipient->getHeaders())) {
                $temp['header'] = $recipient->getHeaders();
            }
            if (null !== $recipient->getEncryptedKey()) {
                $temp['encrypted_key'] = Base64Url::encode($recipient->getEncryptedKey());
            }
            $data['recipients'][] = $temp;
        }

        return $this->jsonConverter->encode($data);
    }

    /**
     * {@inheritdoc}
     */
    public function unserialize(string $input): JWE
    {
        $data = $this->jsonConverter->decode($input);
        if (!is_array($data) || !array_key_exists('ciphertext', $data) || !array_key_exists('recipients', $data)) {
            throw new \InvalidArgumentException('Unsupported input.');
        }

        $ciphertext = Base64Url::decode($data['ciphertext']);
        $iv = Base64Url::decode($data['iv']);
        $tag = Base64Url::decode($data['tag']);
        $aad = array_key_exists('aad', $data) ? Base64Url::decode($data['aad']) : null;
        $encodedSharedProtectedHeader = array_key_exists('protected', $data) ? $data['protected'] : null;
        $sharedProtectedHeader = $encodedSharedProtectedHeader ? $this->jsonConverter->decode(Base64Url::decode($encodedSharedProtectedHeader)) : [];
        $sharedHeader = array_key_exists('unprotected', $data) ? $data['unprotected'] : [];
        $recipients = [];
        foreach ($data['recipients'] as $recipient) {
            $encryptedKey = array_key_exists('encrypted_key', $recipient) ? Base64Url::decode($recipient['encrypted_key']) : null;
            $header = array_key_exists('header', $recipient) ? $recipient['header'] : [];
            $recipients[] = Recipient::create($header, $encryptedKey);
        }

        return JWE::create(
            $ciphertext,
            $iv,
            $tag,
            $aad,
            $sharedHeader,
            $sharedProtectedHeader,
            $encodedSharedProtectedHeader,
            $recipients);
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/*
6			* The MIT License (MIT)
7			*
8			* Copyright (c) 2014-2017 Spomky-Labs
9			*
10			* This software may be modified and distributed under the terms
11			* of the MIT license. See the LICENSE file for details.
12			*/
13
14			namespace Jose\Component\Encryption\Serializer;
15
16			use Base64Url\Base64Url;
17			use Jose\Component\Core\Converter\JsonConverterInterface;
18			use Jose\Component\Encryption\JWE;
19			use Jose\Component\Encryption\Recipient;
20
21			/**
22			* Class JSONGeneralSerializer.
23			*/
24			final class JSONGeneralSerializer implements JWESerializerInterface
25			{
26			public const NAME = 'jwe_json_general';
27
28			/**
29			* @var JsonConverterInterface
30			*/
31			private $jsonConverter;
32
33			/**
34			* JSONFlattenedSerializer constructor.
35			*
36			* @param JsonConverterInterface $jsonConverter
37			*/
38			public function __construct(JsonConverterInterface $jsonConverter)
39			{
40			$this->jsonConverter = $jsonConverter;
41			}
42
43			/**
44			* {@inheritdoc}
45			*/
46			public function displayName(): string
47			{
48			return 'JWE JSON General';
49			}
50
51			/**
52			* {@inheritdoc}
53			*/
54			public function name(): string
55			{
56			return self::NAME;
57			}
58
59			/**
60			* {@inheritdoc}
61			*/
62			public function serialize(JWE $jwe, ?int $recipientIndex = null): string
63			{
64			if (0 === $jwe->countRecipients()) {
65			throw new \LogicException('No recipient.');
66			}
67
68			$data = [
69			'ciphertext' => Base64Url::encode($jwe->getCiphertext()),
70			'iv' => Base64Url::encode($jwe->getIV()),
71			'tag' => Base64Url::encode($jwe->getTag()),
72			];
73			if (null !== $jwe->getAAD()) {
74			$data['aad'] = Base64Url::encode($jwe->getAAD());
75			}
76			if (!empty($jwe->getSharedProtectedHeaders())) {
77			$data['protected'] = $jwe->getEncodedSharedProtectedHeaders();
78			}
79			if (!empty($jwe->getSharedHeaders())) {
80			$data['unprotected'] = $jwe->getSharedHeaders();
81			}
82			$data['recipients'] = [];
83			foreach ($jwe->getRecipients() as $recipient) {
84			$temp = [];
85			if (!empty($recipient->getHeaders())) {
86			$temp['header'] = $recipient->getHeaders();
87			}
88			if (null !== $recipient->getEncryptedKey()) {
89			$temp['encrypted_key'] = Base64Url::encode($recipient->getEncryptedKey());
90			}
91			$data['recipients'][] = $temp;
92			}
93
94			return $this->jsonConverter->encode($data);
95			}
96
97			/**
98			* {@inheritdoc}
99			*/
100			public function unserialize(string $input): JWE
101			{
102			$data = $this->jsonConverter->decode($input);
103			if (!is_array($data) \|\| !array_key_exists('ciphertext', $data) \|\| !array_key_exists('recipients', $data)) {
104			throw new \InvalidArgumentException('Unsupported input.');
105			}
106
107			$ciphertext = Base64Url::decode($data['ciphertext']);
108			$iv = Base64Url::decode($data['iv']);
109			$tag = Base64Url::decode($data['tag']);
110			$aad = array_key_exists('aad', $data) ? Base64Url::decode($data['aad']) : null;
111			$encodedSharedProtectedHeader = array_key_exists('protected', $data) ? $data['protected'] : null;
112			$sharedProtectedHeader = $encodedSharedProtectedHeader ? $this->jsonConverter->decode(Base64Url::decode($encodedSharedProtectedHeader)) : [];
113			$sharedHeader = array_key_exists('unprotected', $data) ? $data['unprotected'] : [];
114			$recipients = [];
115			foreach ($data['recipients'] as $recipient) {
116			$encryptedKey = array_key_exists('encrypted_key', $recipient) ? Base64Url::decode($recipient['encrypted_key']) : null;
117			$header = array_key_exists('header', $recipient) ? $recipient['header'] : [];
118			$recipients[] = Recipient::create($header, $encryptedKey);
119			}
120
121			return JWE::create(
122			$ciphertext,
123			$iv,
124			$tag,
125			$aad,
126			$sharedHeader,
127			$sharedProtectedHeader,
128			$encodedSharedProtectedHeader,
129			$recipients);
130			}
131			}
132

Spomky-Labs / jose

JSONGeneralSerializer::unserialize() C last analyzed 2017-10-05 20:43 UTC

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like

JSONGeneralSerializer::unserialize() C
last analyzed 2017-10-05 20:43 UTC