HaveIBeenPwnedRule::__construct() - Code Metrics - Stadly/PasswordPolice - Measure and Improve Code Quality continuously with Scrutinizer

HaveIBeenPwnedRule::__construct() A
last analyzed 2020-05-08 06:26 UTC

↳ Parent: HaveIBeenPwnedRule
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	2
CRAP Score	1
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	1
eloc	1
c	1
b	0
f	0
nc	1
nop	3
dl	0
loc	3
ccs	2
cts	2
cp	1
crap	1
rs	10
<?php

declare(strict_types=1);

namespace Stadly\PasswordPolice\Rule;

use Http\Factory\Discovery\HttpClient;
use Http\Factory\Discovery\HttpFactory;
use Psr\Http\Client\ClientExceptionInterface;
use Psr\Http\Client\ClientInterface;
use Psr\Http\Message\RequestFactoryInterface;
use RuntimeException;
use StableSort\StableSort;
use Stadly\PasswordPolice\Constraint\CountConstraint;
use Stadly\PasswordPolice\Rule;
use Stadly\PasswordPolice\ValidationError;
use Symfony\Contracts\Translation\LocaleAwareInterface;
use Symfony\Contracts\Translation\TranslatorInterface;

final class HaveIBeenPwnedRule implements Rule
{
    /**
     * @var array<CountConstraint> Rule constraints.
     */
    private $constraints = [];

    /**
     * @var ClientInterface|null HTTP client for sending requests.
     */
    private $client = null;

    /**
     * @var RequestFactoryInterface|null Request factory for generating HTTP requests.
     */
    private $requestFactory = null;

    /**
     * @param int|null $max Maximum number of appearances in breaches.
     * @param int $min Minimum number of appearances in breaches.
     * @param int $weight Constraint weight.
     */
    public function __construct(?int $max = 0, int $min = 0, int $weight = 1)
    {
        $this->addConstraint($max, $min, $weight);
    }

    /**
     * @param int|null $max Maximum number of appearances in breaches.
     * @param int $min Minimum number of appearances in breaches.
     * @param int $weight Constraint weight.
     * @return $this
     */
    public function addConstraint(?int $max = 0, int $min = 0, int $weight = 1): self
    {
        $this->constraints[] = new CountConstraint($min, $max, $weight);

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

        return $this;
    }

    /**
     * @param ClientInterface $client HTTP client for sending requests.
     */
    public function setClient(ClientInterface $client): void
    {
        $this->client = $client;
    }

    /**
     * @return ClientInterface HTTP client for sending requests.
     * @throws RuntimeException If a client could not be found.
     */
    private function getClient(): ClientInterface
    {
        if ($this->client === null) {
            $client = HttpClient::client();
            $this->client = $client;
        }
        return $this->client;
    }

    /**
     * @param RequestFactoryInterface $requestFactory Request factory for generating HTTP requests.
     */
    public function setRequestFactory(RequestFactoryInterface $requestFactory): void
    {
        $this->requestFactory = $requestFactory;
    }

    /**
     * @return RequestFactoryInterface Request factory for generating HTTP requests.
     * @throws RuntimeException If a request factory could not be found.
     */
    private function getRequestFactory(): RequestFactoryInterface
    {
        if ($this->requestFactory === null) {
            $this->requestFactory = HttpFactory::requestFactory();
        }
        return $this->requestFactory;
    }

    /**
     * @inheritDoc
     */
    public function test($password, ?int $weight = null): bool
    {
        $count = $this->getCount((string)$password);
        $constraint = $this->getViolation($count, $weight);

        return $constraint === null;
    }

    /**
     * @inheritDoc
     */
    public function validate($password, TranslatorInterface $translator): ?ValidationError
    {
        $count = $this->getCount((string)$password);
        $constraint = $this->getViolation($count);

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

        return null;
    }

    /**
     * @param int $count Number of appearances in breaches.
     * @param int|null $weight Don't consider constraints with lower weights.
     * @return CountConstraint|null Constraint violated by the count.
     */
    private function getViolation(int $count, ?int $weight = null): ?CountConstraint
    {
        foreach ($this->constraints as $constraint) {
            if ($weight !== null && $constraint->getWeight() < $weight) {
                continue;
            }
            if (!$constraint->test($count)) {
                return $constraint;
            }
        }

        return null;
    }

    /**
     * @param string $password Password to check in breaches.
     * @return int Number of appearances in breaches.
     * @throws CouldNotUseRuleException If an error occurred.
     */
    private function getCount(string $password): int
    {
        $sha1 = strtoupper(sha1($password));
        $prefix = substr($sha1, 0, 5);
        $suffix = substr($sha1, 5, 35);

        try {
            $requestFactory = $this->getRequestFactory();
            $request = $requestFactory->createRequest('GET', 'https://api.pwnedpasswords.com/range/' . $prefix);

            $client = $this->getClient();

            $response = $client->sendRequest($request);
            $body = $response->getBody();
            $contents = $body->getContents();
            $lines = explode("\r\n", $contents);
            foreach ($lines as $line) {
                if (substr($line, 0, 35) === $suffix) {
                    return (int)substr($line, 36);
                }
            }
            return 0;
        } catch (ClientExceptionInterface | RuntimeException $exception) {
            throw new CouldNotUseRuleException(
                $this,
                'An error occurred while using the Have I Been Pwned? service: ' . $exception->getMessage(),
                $exception
            );
        }
    }

    /**
     * @param CountConstraint $constraint Constraint that is violated.
     * @param int $count Count that violates the constraint.
     * @param TranslatorInterface&LocaleAwareInterface $translator Translator for translating messages.
     * @return string Message explaining the violation.
     */
    private function getMessage(CountConstraint $constraint, int $count, TranslatorInterface $translator): string
    private function getMessage(CountConstraint $constraint, /** @scrutinizer ignore-unused */ int $count, TranslatorInterface $translator): string
    {
        if ($constraint->getMax() === null) {
            return $translator->trans(
                'The password must appear at least once in data breaches.|' .
                'The password must appear at least %count% times in data breaches.',
                ['%count%' => $constraint->getMin()]
            );
        }

        if ($constraint->getMax() === 0) {
            return $translator->trans(
                'The password cannot appear in data breaches.'
            );
        }

        if ($constraint->getMin() === 0) {
            return $translator->trans(
                'The password must appear at most once in data breaches.|' .
                'The password must appear at most %count% times in data breaches.',
                ['%count%' => $constraint->getMax()]
            );
        }

        if ($constraint->getMin() === $constraint->getMax()) {
            return $translator->trans(
                'The password must appear exactly once in data breaches.|' .
                'The password must appear exactly %count% times in data breaches.',
                ['%count%' => $constraint->getMin()]
            );
        }

        return $translator->trans(
            'The password must appear between %min% and %max% times in data breaches.',
            ['%min%' => $constraint->getMin(), '%max%' => $constraint->getMax()]
        );
    }
}

Stadly / PasswordPolice

HaveIBeenPwnedRule::__construct() A last analyzed 2020-05-08 06:26 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

HaveIBeenPwnedRule::__construct() A
last analyzed 2020-05-08 06:26 UTC
