JwtAuthenticator::__construct() - Code Metrics - Phauthentic/authentication - Measure and Improve Code Quality continuously with Scrutinizer

JwtAuthenticator::__construct() A
last analyzed 2024-03-17 01:21 UTC

↳ Parent: JwtAuthenticator

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes

Metric	Value
eloc	2
dl	0
loc	5
ccs	3
cts	3
cp	1
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	2
crap	1

<?php

/**
 * CakePHP(tm) : Rapid Development Framework (https://cakephp.org)
 * Copyright (c) Cake Software Foundation, Inc. (https://cakefoundation.org)
 *
 * Licensed under The MIT License
 * For full copyright and license information, please see the LICENSE.txt
 * Redistributions of files must retain the above copyright notice.
 *
 * @copyright     Copyright (c) Cake Software Foundation, Inc. (https://cakefoundation.org)
 * @link          https://cakephp.org CakePHP(tm) Project
 * @since         1.0.0
 * @license       https://opensource.org/licenses/mit-license.php MIT License
 */

namespace Phauthentic\Authentication\Authenticator;

use ArrayObject;
use Phauthentic\Authentication\Identifier\IdentifierInterface;
use Exception;
use Firebase\JWT\JWT;
use Firebase\JWT\Key;
use Psr\Http\Message\ServerRequestInterface;
use stdClass;

/**
 * Jwt Authenticator
 */
class JwtAuthenticator extends TokenAuthenticator
{
    /**
     * Query param
     *
     * @var null|string
     */
    protected ?string $queryParam = 'token';

    /**
     * Header
     *
     * @var null|string
     */
    protected ?string $header = 'Authorization';

    /**
     * Token Prefix
     *
     * @var null|string
     */
    protected ?string $tokenPrefix = 'bearer';

    /**
     * Hashing algorithms
     *
     * @var array<int, string>
     */
    protected array $algorithms = [
        'HS256'
    ];

    /**
     * Return payload
     *
     * @var bool
     */
    protected bool $returnPayload = true;

    /**
     * Secret key
     *
     * @var null|string
     */
    protected ?string $secretKey;

    /**
     * Payload data.
     *
     * @var object|null
     */
    protected ?object $payload = null;

    /**
     * {@inheritDoc}
     */
    public function __construct(IdentifierInterface $identifier, string $secretKey)
    {
        parent::__construct($identifier);

        $this->secretKey = $secretKey;
    }

    /**
     * Sets algorithms to use
     *
     * @param array<int, string> $algorithms List of algorithms
     * @return $this
     */
    public function setAlgorithms(array $algorithms): self
    {
        $this->algorithms = $algorithms;

        return $this;
    }

    /**
     * Sets return payload.
     *
     * @param bool $return Return payload.
     * @return $this
     */
    public function setReturnPayload(bool $return): self
    {
        $this->returnPayload = $return;

        return $this;
    }

    /**
     * Sets secret key.
     *
     * @param string $key Secret key.
     * @return $this
     */
    public function setSecretKey(string $key): self
    {
        $this->secretKey = $key;

        return $this;
    }

    /**
     * Authenticates the identity based on a JWT token contained in a request.
     *
     * @link https://jwt.io/
     * @param \Psr\Http\Message\ServerRequestInterface $request The request that contains login information.
     * @return \Phauthentic\Authentication\Authenticator\ResultInterface
     */
    public function authenticate(ServerRequestInterface $request): ResultInterface
    {
        try {
            $result = $this->getPayload($request);
        } catch (Exception $e) {
            return new Result(
                null,
                Result::FAILURE_CREDENTIALS_INVALID,
                [
                    'message' => $e->getMessage(),
                    'exception' => $e
                ]
            );
        }

        if (!($result instanceof stdClass)) {
            return new Result(null, Result::FAILURE_CREDENTIALS_INVALID);
        }

        $result = json_decode((string)json_encode($result), true);

        $key = IdentifierInterface::CREDENTIAL_JWT_SUBJECT;
        if (empty($result[$key])) {
            return new Result(null, Result::FAILURE_CREDENTIALS_MISSING);
        }

        if ($this->returnPayload) {
            $user = new ArrayObject($result);

            return new Result($user, Result::SUCCESS);
        }

        $user = $this->identifier->identify([
            $key => $result[$key]
        ]);

        if (empty($user)) {
            return new Result(null, Result::FAILURE_IDENTITY_NOT_FOUND, $this->identifier->getErrors());
        }

        return new Result($user, Result::SUCCESS);
    }

    /**
     * Get payload data.
     *
     * @param \Psr\Http\Message\ServerRequestInterface|null $request Request to get authentication information from.
     * @return object|null Payload object on success, null on failure
     */
    public function getPayload(ServerRequestInterface $request = null)
    {
        if (!$request) {
            return $this->payload;
        }

        $payload = null;
        $token = $this->getToken($request);

        if ($token !== null) {
            $payload = $this->decodeToken($token);
        }

        $this->payload = $payload;

        return $this->payload;
    }

    /**
     * Decode JWT token.
     *
     * @param string $token JWT token to decode.
     * @return object|null The JWT's payload as a PHP object, null on failure.
     */
    protected function decodeToken($token)
    {
        return JWT::decode(
            $token,
            new Key((string)$this->secretKey, $this->algorithms[0])
        );
    }
}


1		<?php
2
3		/**
4		* CakePHP(tm) : Rapid Development Framework (https://cakephp.org)
5		* Copyright (c) Cake Software Foundation, Inc. (https://cakefoundation.org)
6		*
7		* Licensed under The MIT License
8		* For full copyright and license information, please see the LICENSE.txt
9		* Redistributions of files must retain the above copyright notice.
10		*
11		* @copyright Copyright (c) Cake Software Foundation, Inc. (https://cakefoundation.org)
12		* @link https://cakephp.org CakePHP(tm) Project
13		* @since 1.0.0
14		* @license https://opensource.org/licenses/mit-license.php MIT License
15		*/
16
17		namespace Phauthentic\Authentication\Authenticator;
18
19		use ArrayObject;
20		use Phauthentic\Authentication\Identifier\IdentifierInterface;
21		use Exception;
22		use Firebase\JWT\JWT;
23		use Firebase\JWT\Key;
24		use Psr\Http\Message\ServerRequestInterface;
25		use stdClass;
26
27		/**
28		* Jwt Authenticator
29		*/
30		class JwtAuthenticator extends TokenAuthenticator
31		{
32		/**
33		* Query param
34		*
35		* @var null\|string
36		*/
37		protected ?string $queryParam = 'token';
38
39		/**
40		* Header
41		*
42		* @var null\|string
43		*/
44		protected ?string $header = 'Authorization';
45
46		/**
47		* Token Prefix
48		*
49		* @var null\|string
50		*/
51		protected ?string $tokenPrefix = 'bearer';
52
53		/**
54		* Hashing algorithms
55		*
56		* @var array<int, string>
57		*/
58		protected array $algorithms = [
59		'HS256'
60		];
61
62		/**
63		* Return payload
64		*
65		* @var bool
66		*/
67		protected bool $returnPayload = true;
68
69		/**
70		* Secret key
71		*
72		* @var null\|string
73		*/
74		protected ?string $secretKey;
75
76		/**
77		* Payload data.
78		*
79		* @var object\|null
80		*/
81		protected ?object $payload = null;
82
83		/**
84	28	* {@inheritDoc}
85		*/
86	28	public function __construct(IdentifierInterface $identifier, string $secretKey)
87		{
88	28	parent::__construct($identifier);
89	28
90		$this->secretKey = $secretKey;
91		}
92
93		/**
94		* Sets algorithms to use
95		*
96		* @param array<int, string> $algorithms List of algorithms
97		* @return $this
98		*/
99		public function setAlgorithms(array $algorithms): self
100		{
101		$this->algorithms = $algorithms;
102
103		return $this;
104		}
105
106		/**
107		* Sets return payload.
108		*
109		* @param bool $return Return payload.
110	4	* @return $this
111		*/
112	4	public function setReturnPayload(bool $return): self
113		{
114	4	$this->returnPayload = $return;
115
116		return $this;
117		}
118
119		/**
120		* Sets secret key.
121		*
122		* @param string $key Secret key.
123		* @return $this
124		*/
125		public function setSecretKey(string $key): self
126		{
127		$this->secretKey = $key;
128
129		return $this;
130		}
131
132		/**
133		* Authenticates the identity based on a JWT token contained in a request.
134		*
135		* @link https://jwt.io/
136		* @param \Psr\Http\Message\ServerRequestInterface $request The request that contains login information.
137	28	* @return \Phauthentic\Authentication\Authenticator\ResultInterface
138		*/
139		public function authenticate(ServerRequestInterface $request): ResultInterface
140	28	{
141	4	try {
142	4	$result = $this->getPayload($request);
143	4	} catch (Exception $e) {
144	4	return new Result(
145		null,
146	4	Result::FAILURE_CREDENTIALS_INVALID,
147	4	[
148		'message' => $e->getMessage(),
149		'exception' => $e
150		]
151		);
152	24	}
153	4
154		if (!($result instanceof stdClass)) {
155		return new Result(null, Result::FAILURE_CREDENTIALS_INVALID);
156	20	}
157
158	20	$result = json_decode((string)json_encode($result), true);
159	20
160	4	$key = IdentifierInterface::CREDENTIAL_JWT_SUBJECT;
161		if (empty($result[$key])) {
162		return new Result(null, Result::FAILURE_CREDENTIALS_MISSING);
163	16	}
164	12
165		if ($this->returnPayload) {
166	12	$user = new ArrayObject($result);
167
168		return new Result($user, Result::SUCCESS);
169	4	}
170	4
171		$user = $this->identifier->identify([
172		$key => $result[$key]
173	4	]);
174
175		if (empty($user)) {
176		return new Result(null, Result::FAILURE_IDENTITY_NOT_FOUND, $this->identifier->getErrors());
177	4	}
178
179		return new Result($user, Result::SUCCESS);
180		}
181
182		/**
183		* Get payload data.
184		*
185		* @param \Psr\Http\Message\ServerRequestInterface\|null $request Request to get authentication information from.
186	20	* @return object\|null Payload object on success, null on failure
187		*/
188	20	public function getPayload(ServerRequestInterface $request = null)
189	4	{
190		if (!$request) {
191		return $this->payload;
192	20	}
193	20
194		$payload = null;
195	20	$token = $this->getToken($request);
196	20
197		if ($token !== null) {
198		$payload = $this->decodeToken($token);
199	16	}
200
201	16	$this->payload = $payload;
202
203		return $this->payload;
204		}
205
206		/**
207		* Decode JWT token.
208		*
209		* @param string $token JWT token to decode.
210	20	* @return object\|null The JWT's payload as a PHP object, null on failure.
211		*/
212	20	protected function decodeToken($token)
213	20	{
214	20	return JWT::decode(
215	20	$token,
216		new Key((string)$this->secretKey, $this->algorithms[0])
217		);
218		}
219		}
220

Phauthentic / authentication

JwtAuthenticator::__construct() A last analyzed 2024-03-17 01:21 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

JwtAuthenticator::__construct() A
last analyzed 2024-03-17 01:21 UTC