Stadly\PasswordPolice\Rule\NoReuseRule

Complexity

Total Complexity

19

Size/Duplication

Total Lines	148
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	getViolation()	0	14	6
A	getPositions()	0	16	5
A	getMessage()	0	12	2
A	validate()	0	15	2
A	test()	0	6	1
A	getHashFunction()	0	3	1
A	__construct()	0	4	1
A	addConstraint()	0	9	1

<?php

declare(strict_types=1);

namespace Stadly\PasswordPolice\Rule;

use StableSort\StableSort;
use Stadly\PasswordPolice\Constraint\PositionConstraint;
use Stadly\PasswordPolice\HashFunction;
use Stadly\PasswordPolice\Password;
use Stadly\PasswordPolice\Rule;
use Stadly\PasswordPolice\ValidationError;
use Symfony\Contracts\Translation\LocaleAwareInterface;
use Symfony\Contracts\Translation\TranslatorInterface;

final class NoReuseRule implements Rule
{
    /**
     * @var HashFunction Hash function.
     */
    private $hashFunction;

    /**
     * @var array<PositionConstraint> Rule constraints.
     */
    private $constraints = [];

    /**
     * @param HashFunction $hashFunction Hash function to use when comparing passwords.
     * @param int|null $count Number of former passwords to consider.
     * @param int $first First former password to consider.
     * @param int $weight Constraint weight.
     */
    public function __construct(HashFunction $hashFunction, ?int $count = null, int $first = 0, int $weight = 1)
    {
        $this->hashFunction = $hashFunction;
        $this->addConstraint($count, $first, $weight);
    }

    /**
     * @param int|null $count Number of former passwords to consider.
     * @param int $first First former password to consider.
     * @param int $weight Constraint weight.
     * @return $this
     */
    public function addConstraint(?int $count = null, int $first = 0, int $weight = 1): self
    {
        $this->constraints[] = new PositionConstraint($first, $count, $weight);

        StableSort::usort($this->constraints, static function (PositionConstraint $a, PositionConstraint $b): int {
            return $b->getWeight() <=> $a->getWeight();
        });

        return $this;
    }

    /**
     * @return HashFunction Hash function.
     */
    public function getHashFunction(): HashFunction
    {
        return $this->hashFunction;
    }

    /**
     * Check whether a password is in compliance with the rule.
     *
     * @param Password|string $password Password to check.
     * @param int|null $weight Don't consider constraints with lower weights.
     * @return bool Whether the password is in compliance with the rule.
     */
    public function test($password, ?int $weight = null): bool
    {
        $positions = $this->getPositions($password);
        $constraint = $this->getViolation($positions, $weight);

        return $constraint === null;
    }

    /**
     * Validate that a password is in compliance with the rule.
     *
     * @param Password|string $password Password to validate.
     * @param TranslatorInterface&LocaleAwareInterface $translator Translator for translating messages.
     * @return ValidationError|null Validation error describing why the password is not in compliance with the rule.
     */
    public function validate($password, TranslatorInterface $translator): ?ValidationError
    {
        $positions = $this->getPositions($password);
        $constraint = $this->getViolation($positions);

        if ($constraint !== null) {
            return new ValidationError(
                $this->getMessage($constraint, $translator),
                $password,
                $this,
                $constraint->getWeight()
            );
        }

        return null;
    }

    /**
     * @param array<int> $positions Positions of former passwords matching the password.
     * @param int|null $weight Don't consider constraints with lower weights.
     * @return PositionConstraint|null Constraint violated by the positions.
     */
    private function getViolation(array $positions, ?int $weight = null): ?PositionConstraint
    {
        foreach ($this->constraints as $constraint) {
            if ($weight !== null && $constraint->getWeight() < $weight) {
                continue;
            }
            foreach ($positions as $position) {
                if ($constraint->test($position)) {
                    return $constraint;
                }
            }
        }

        return null;
    }

    /**
     * @param Password|string $password Password to compare with former passwords.
     * @return array<int> Positions of former passwords matching the password.
     */
    private function getPositions($password): array
    {
        $positions = [];

        if ($password instanceof Password) {
            $position = 0;
            foreach ($password->getFormerPasswords() as $formerPassword) {
                $passwordHash = $formerPassword->getHash();
                if ($passwordHash !== null && $this->hashFunction->compare((string)$password, $passwordHash)) {
                    $positions[] = $position;
                }
                ++$position;
            }
        }

        return $positions;
    }

    /**
     * @param PositionConstraint $constraint Constraint that is violated.
     * @param TranslatorInterface&LocaleAwareInterface $translator Translator for translating messages.
     * @return string Message explaining the violation.
     */
    private function getMessage(PositionConstraint $constraint, TranslatorInterface $translator): string
    {
        if ($constraint->getCount() === null) {
            return $translator->trans(
                'Formerly used passwords cannot be reused.'
            );
        }

        return $translator->trans(
            'The most recently used password cannot be reused.|' .
            'The %count% most recently used passwords cannot be reused.',
            ['%count%' => $constraint->getCount()]
        );
    }
}