BlitzPHP\Security\Hashing\Hasher

Complexity

Total Complexity

13

Size/Duplication

Total Lines	115
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes	2
Bugs	1	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	make()	0	3	1
A	verifyConfiguration()	0	3	1
A	check()	0	3	1
A	needsRehash()	0	3	1
A	isHashed()	0	3	1
A	__construct()	0	6	1
A	info()	0	3	1
A	driver()	0	7	2
A	initialize()	0	19	4

<?php

/**
 * This file is part of Blitz PHP framework.
 *
 * (c) 2022 Dimitri Sitchet Tomkeu <devcode.dst@gmail.com>
 *
 * For the full copyright and license information, please view
 * the LICENSE file that was distributed with this source code.
 */

namespace BlitzPHP\Security\Hashing;

use BlitzPHP\Contracts\Security\HasherInterface;
use BlitzPHP\Exceptions\HashingException;

/**
 * Gestionnaire de hashage de BlitzPHP
 */
class Hasher implements HasherInterface
{
    /**
     * Le hasheur que nous utilisons
     */
    protected ?HasherInterface $hasher = null;

    /**
     * Le pilote utilisé
     */
    protected string $driver = '';

    /**
     * Pilotes aux classes de gestionnaires, par ordre de préférence
     */
    protected array $drivers = [
        'bcrypt',
        'argon',
        'argon2id',
    ];

    /**
     * Constructeur
     */
    public function __construct(protected ?object $config = null)
    {
        $config ??= (object) config('hashing');

        $this->config = $config;
        $this->driver = $config->driver;
    }

    /**
     * {@inheritDoc}
     */
    public function info(string $hashedValue): array
    {
        return $this->driver()->info($hashedValue);
    }

    /**
     * {@inheritDoc}
     */
    public function make(string $value, array $options = []): string
    {
        return $this->driver()->make($value, $options);
    }

    /**
     * {@inheritDoc}
     */
    public function check(string $value, string $hashedValue, array $options = []): bool
    {
        return $this->driver()->check($value, $hashedValue, $options);
    }

    /**
     * {@inheritDoc}
     */
    public function needsRehash(string $hashedValue, array $options = []): bool
    {
        return $this->driver()->needsRehash($hashedValue, $options);
    }

    /**
     * Détermine si une chaîne donnée est déjà hachée.
     */
    public function isHashed(string $value): bool
    {
        return $this->driver()->info($value)['algo'] !== null;
    }

    /**
     * Vérifie que la configuration est inférieure ou égale à ce qui est configuré.
     *
     * @internal
     */
    public function verifyConfiguration(array $value): bool
    {
        return $this->driver()->verifyConfiguration($value);

The method verifyConfiguration() does not exist on BlitzPHP\Contracts\Security\HasherInterface. It seems like you code against a sub-type of said class. However, the method does not exist in BlitzPHP\Security\Hashing\Handlers\BaseHandler. Are you sure you never get one of those?

    }

    /**
     * Initialiser ou réinitialiser le hasheur
     *
     * @throws HashingException
     */
    public function initialize(?object $config = null): HasherInterface
    {
        if ($config) {
            $this->driver = $config->driver;
        }

        if ($this->driver === '') {
            throw HashingException::noDriverRequested();
        }

        if (! in_array($this->driver, $this->drivers, true)) {
            throw HashingException::unKnownHandler($this->driver);
        }

        $handlerName  = 'BlitzPHP\\Security\\Hashing\\Handlers\\' . ucfirst($this->driver) . 'Handler';
        $params       = (array) $config;
        $this->hasher = new $handlerName($params[$this->driver]);

        return $this->hasher;

The expression return $this->hasher could return the type null which is incompatible with the type-hinted return BlitzPHP\Contracts\Security\HasherInterface. Consider adding an additional type-check to rule them out.

    }

    private function driver(): HasherInterface
    {
        if (null === $this->hasher) {
            $this->hasher = $this->initialize($this->config);
        }

        return $this->hasher;
    }
}