SmsRecoveryTokenService::verifyAuthentication() - Code Metrics - Inspection of "Require SMS recovery token authentication" - OpenConext/Stepup-SelfService - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — develop (#290)

by Michiel

created 2023-05-25 13:39 UTC

SmsRecoveryTokenService::verifyAuthentication() A

↳ Parent: SmsRecoveryTokenService

Complexity

Conditions	4
Paths	4

Size

Total Lines	19
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	4
eloc	11
nc	4
nop	1
dl	0
loc	19
rs	9.9
c	0
b	0
f	0

<?php

/**
 * Copyright 2022 SURFnet bv
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

namespace Surfnet\StepupSelfService\SelfServiceBundle\Service;

use Surfnet\StepupBundle\Command\SendRecoveryTokenSmsChallengeCommand as StepupSendRecoveryTokenSmsChallengeCommand;
use Surfnet\StepupBundle\Command\VerifyPossessionOfPhoneForRecoveryTokenCommand;
use Surfnet\StepupBundle\Service\Exception\TooManyChallengesRequestedException;
use Surfnet\StepupBundle\Service\SmsRecoveryTokenService as StepupSmsRecoveryTokenService;
use Surfnet\StepupBundle\Value\PhoneNumber\InternationalPhoneNumber;
use Surfnet\StepupBundle\Value\PhoneNumber\PhoneNumber;
use Surfnet\StepupMiddlewareClientBundle\Identity\Command\ProvePhoneRecoveryTokenPossessionCommand;
use Surfnet\StepupMiddlewareClientBundle\Uuid\Uuid;
use Surfnet\StepupSelfService\SelfServiceBundle\Command\SendRecoveryTokenSmsAuthenticationChallengeCommand;
use Surfnet\StepupSelfService\SelfServiceBundle\Command\SendRecoveryTokenSmsChallengeCommand;
use Surfnet\StepupSelfService\SelfServiceBundle\Command\VerifySmsRecoveryTokenChallengeCommand;
use Surfnet\StepupSelfService\SelfServiceBundle\Service\SelfAssertedTokens\ProofOfPossessionResult;
use Surfnet\StepupSelfService\SelfServiceBundle\Service\SelfAssertedTokens\RecoveryTokenState;
use Symfony\Component\Translation\TranslatorInterface;

/**
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */
class SmsRecoveryTokenService
{
    public const REGISTRATION_RECOVERY_TOKEN_ID = 'registration';

    private $smsService;

    private $translator;

    private $commandService;

    private $stateHandler;

    public function __construct(
        StepupSmsRecoveryTokenService $smsService,
        TranslatorInterface $translator,
        CommandService $commandService,
        RecoveryTokenState $stateHandler
    ) {
        $this->smsService = $smsService;
        $this->translator = $translator;
        $this->commandService = $commandService;
        $this->stateHandler = $stateHandler;
    }

    public function getOtpRequestsRemainingCount(string $identifier): int
    {
        return $this->smsService->getOtpRequestsRemainingCount($identifier);
    }

    public function getMaximumOtpRequestsCount(): int
    {
        return $this->smsService->getMaximumOtpRequestsCount();
    }

    public function hasSmsVerificationState(string $secondFactorId): bool
    {
        return $this->smsService->hasSmsVerificationState($secondFactorId);
    }

    public function clearSmsVerificationState(string $secondFactorId): void
    {
        $this->smsService->clearSmsVerificationState($secondFactorId);
    }

    public function authenticate(SendRecoveryTokenSmsAuthenticationChallengeCommand $command): bool
    {
        $stepupCommand = new StepupSendRecoveryTokenSmsChallengeCommand();
        $stepupCommand->phoneNumber = $command->identifier;
        $stepupCommand->body = $this->translator->trans('ss.registration.sms.challenge_body');
        $stepupCommand->identity = $command->identity;
        $stepupCommand->institution = $command->institution;
        $stepupCommand->recoveryTokenId = $command->recoveryTokenId;

        return $this->smsService->sendChallenge($stepupCommand);
    }

    /**
     * @return bool Whether SMS sending did not fail.
     * @throws TooManyChallengesRequestedException
     */
    public function sendChallenge(SendRecoveryTokenSmsChallengeCommand $command): bool
    {
        $phoneNumber = new InternationalPhoneNumber(
            $command->country->getCountryCode(),
            new PhoneNumber($command->subscriber)
        );

        $stepupCommand = new StepupSendRecoveryTokenSmsChallengeCommand();
        $stepupCommand->phoneNumber = $phoneNumber;
        $stepupCommand->body = $this->translator->trans('ss.registration.sms.challenge_body');
        $stepupCommand->identity = $command->identity;
        $stepupCommand->institution = $command->institution;
        $stepupCommand->recoveryTokenId = $command->recoveryTokenId;

        return $this->smsService->sendChallenge($stepupCommand);
    }

    public function provePossession(VerifySmsRecoveryTokenChallengeCommand $challengeCommand): ProofOfPossessionResult
    {
        $stepupCommand = new VerifyPossessionOfPhoneForRecoveryTokenCommand();
        $stepupCommand->challenge = $challengeCommand->challenge;
        $stepupCommand->recoveryTokenId = $challengeCommand->recoveryTokenId;

        $verification = $this->smsService->verifyPossession($stepupCommand);

        if ($verification->didOtpExpire()) {
            return ProofOfPossessionResult::challengeExpired();
        }
        if ($verification->wasAttemptedTooManyTimes()) {
            return ProofOfPossessionResult::tooManyAttempts();
        }
        if (!$verification->wasSuccessful()) {
            return ProofOfPossessionResult::incorrectChallenge();
        }

        $command = new ProvePhoneRecoveryTokenPossessionCommand();
        $command->identityId = $challengeCommand->identity;
        $command->recoveryTokenId = Uuid::generate();
        $command->phoneNumber = $verification->getPhoneNumber();

        $result = $this->commandService->execute($command);

        if (!$result->isSuccessful()) {
            return ProofOfPossessionResult::proofOfPossessionCommandFailed();
        }

        return ProofOfPossessionResult::recoveryTokenCreated($command->recoveryTokenId);
    }

    public function wasTokenCreatedDuringSecondFactorRegistration()
    {
        return $this->stateHandler->wasRecoveryTokenCreatedDuringSecondFactorRegistration();
    }

    public function forgetTokenCreatedDuringSecondFactorRegistration()
    {
        $this->stateHandler->forgetTokenCreatedDuringSecondFactorRegistration();
    }

    public function tokenCreatedDuringSecondFactorRegistration()
    {
        $this->stateHandler->tokenCreatedDuringSecondFactorRegistration();
    }

    public function forgetRecoveryTokenState()
    {
        $this->stateHandler->forget();
    }

    public function verifyAuthentication(VerifySmsRecoveryTokenChallengeCommand $command): ProofOfPossessionResult
    {
        $stepupCommand = new VerifyPossessionOfPhoneForRecoveryTokenCommand();
        $stepupCommand->challenge = $command->challenge;
        $stepupCommand->recoveryTokenId = $command->recoveryTokenId;

        $verification = $this->smsService->verifyPossession($stepupCommand);

        if ($verification->didOtpExpire()) {
            return ProofOfPossessionResult::challengeExpired();
        }
        if ($verification->wasAttemptedTooManyTimes()) {
            return ProofOfPossessionResult::tooManyAttempts();
        }
        if (!$verification->wasSuccessful()) {
            return ProofOfPossessionResult::incorrectChallenge();
        }

        return ProofOfPossessionResult::recoveryTokenVerified();
    }
}


1			<?php
2
3			/**
4			* Copyright 2022 SURFnet bv
5			*
6			* Licensed under the Apache License, Version 2.0 (the "License");
7			* you may not use this file except in compliance with the License.
8			* You may obtain a copy of the License at
9			*
10			* http://www.apache.org/licenses/LICENSE-2.0
11			*
12			* Unless required by applicable law or agreed to in writing, software
13			* distributed under the License is distributed on an "AS IS" BASIS,
14			* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15			* See the License for the specific language governing permissions and
16			* limitations under the License.
17			*/
18
19			namespace Surfnet\StepupSelfService\SelfServiceBundle\Service;
20
21			use Surfnet\StepupBundle\Command\SendRecoveryTokenSmsChallengeCommand as StepupSendRecoveryTokenSmsChallengeCommand;
22			use Surfnet\StepupBundle\Command\VerifyPossessionOfPhoneForRecoveryTokenCommand;
23			use Surfnet\StepupBundle\Service\Exception\TooManyChallengesRequestedException;
24			use Surfnet\StepupBundle\Service\SmsRecoveryTokenService as StepupSmsRecoveryTokenService;
25			use Surfnet\StepupBundle\Value\PhoneNumber\InternationalPhoneNumber;
26			use Surfnet\StepupBundle\Value\PhoneNumber\PhoneNumber;
27			use Surfnet\StepupMiddlewareClientBundle\Identity\Command\ProvePhoneRecoveryTokenPossessionCommand;
28			use Surfnet\StepupMiddlewareClientBundle\Uuid\Uuid;
29			use Surfnet\StepupSelfService\SelfServiceBundle\Command\SendRecoveryTokenSmsAuthenticationChallengeCommand;
30			use Surfnet\StepupSelfService\SelfServiceBundle\Command\SendRecoveryTokenSmsChallengeCommand;
31			use Surfnet\StepupSelfService\SelfServiceBundle\Command\VerifySmsRecoveryTokenChallengeCommand;
32			use Surfnet\StepupSelfService\SelfServiceBundle\Service\SelfAssertedTokens\ProofOfPossessionResult;
33			use Surfnet\StepupSelfService\SelfServiceBundle\Service\SelfAssertedTokens\RecoveryTokenState;
34			use Symfony\Component\Translation\TranslatorInterface;
35
36			/**
37			* @SuppressWarnings(PHPMD.CouplingBetweenObjects)
38			*/
39			class SmsRecoveryTokenService
40			{
41			public const REGISTRATION_RECOVERY_TOKEN_ID = 'registration';
42
43			private $smsService;
44
45			private $translator;
46
47			private $commandService;
48
49			private $stateHandler;
50
51			public function __construct(
52			StepupSmsRecoveryTokenService $smsService,
53			TranslatorInterface $translator,
54			CommandService $commandService,
55			RecoveryTokenState $stateHandler
56			) {
57			$this->smsService = $smsService;
58			$this->translator = $translator;
59			$this->commandService = $commandService;
60			$this->stateHandler = $stateHandler;
61			}
62
63			public function getOtpRequestsRemainingCount(string $identifier): int
64			{
65			return $this->smsService->getOtpRequestsRemainingCount($identifier);
66			}
67
68			public function getMaximumOtpRequestsCount(): int
69			{
70			return $this->smsService->getMaximumOtpRequestsCount();
71			}
72
73			public function hasSmsVerificationState(string $secondFactorId): bool
74			{
75			return $this->smsService->hasSmsVerificationState($secondFactorId);
76			}
77
78			public function clearSmsVerificationState(string $secondFactorId): void
79			{
80			$this->smsService->clearSmsVerificationState($secondFactorId);
81			}
82
83			public function authenticate(SendRecoveryTokenSmsAuthenticationChallengeCommand $command): bool
84			{
85			$stepupCommand = new StepupSendRecoveryTokenSmsChallengeCommand();
86			$stepupCommand->phoneNumber = $command->identifier;
87			$stepupCommand->body = $this->translator->trans('ss.registration.sms.challenge_body');
88			$stepupCommand->identity = $command->identity;
89			$stepupCommand->institution = $command->institution;
90			$stepupCommand->recoveryTokenId = $command->recoveryTokenId;
91
92			return $this->smsService->sendChallenge($stepupCommand);
93			}
94
95			/**
96			* @return bool Whether SMS sending did not fail.
97			* @throws TooManyChallengesRequestedException
98			*/
99			public function sendChallenge(SendRecoveryTokenSmsChallengeCommand $command): bool
100			{
101			$phoneNumber = new InternationalPhoneNumber(
102			$command->country->getCountryCode(),
103			new PhoneNumber($command->subscriber)
104			);
105
106			$stepupCommand = new StepupSendRecoveryTokenSmsChallengeCommand();
107			$stepupCommand->phoneNumber = $phoneNumber;
108			$stepupCommand->body = $this->translator->trans('ss.registration.sms.challenge_body');
109			$stepupCommand->identity = $command->identity;
110			$stepupCommand->institution = $command->institution;
111			$stepupCommand->recoveryTokenId = $command->recoveryTokenId;
112
113			return $this->smsService->sendChallenge($stepupCommand);
114			}
115
116			public function provePossession(VerifySmsRecoveryTokenChallengeCommand $challengeCommand): ProofOfPossessionResult
117			{
118			$stepupCommand = new VerifyPossessionOfPhoneForRecoveryTokenCommand();
119			$stepupCommand->challenge = $challengeCommand->challenge;
120			$stepupCommand->recoveryTokenId = $challengeCommand->recoveryTokenId;
121
122			$verification = $this->smsService->verifyPossession($stepupCommand);
123
124			if ($verification->didOtpExpire()) {
125			return ProofOfPossessionResult::challengeExpired();
126			}
127			if ($verification->wasAttemptedTooManyTimes()) {
128			return ProofOfPossessionResult::tooManyAttempts();
129			}
130			if (!$verification->wasSuccessful()) {
131			return ProofOfPossessionResult::incorrectChallenge();
132			}
133
134			$command = new ProvePhoneRecoveryTokenPossessionCommand();
135			$command->identityId = $challengeCommand->identity;
136			$command->recoveryTokenId = Uuid::generate();
137			$command->phoneNumber = $verification->getPhoneNumber();
138
139			$result = $this->commandService->execute($command);
140
141			if (!$result->isSuccessful()) {
142			return ProofOfPossessionResult::proofOfPossessionCommandFailed();
143			}
144
145			return ProofOfPossessionResult::recoveryTokenCreated($command->recoveryTokenId);
146			}
147
148			public function wasTokenCreatedDuringSecondFactorRegistration()
149			{
150			return $this->stateHandler->wasRecoveryTokenCreatedDuringSecondFactorRegistration();
151			}
152
153			public function forgetTokenCreatedDuringSecondFactorRegistration()
154			{
155			$this->stateHandler->forgetTokenCreatedDuringSecondFactorRegistration();
156			}
157
158			public function tokenCreatedDuringSecondFactorRegistration()
159			{
160			$this->stateHandler->tokenCreatedDuringSecondFactorRegistration();
161			}
162
163			public function forgetRecoveryTokenState()
164			{
165			$this->stateHandler->forget();
166			}
167
168			public function verifyAuthentication(VerifySmsRecoveryTokenChallengeCommand $command): ProofOfPossessionResult
169			{
170			$stepupCommand = new VerifyPossessionOfPhoneForRecoveryTokenCommand();
171			$stepupCommand->challenge = $command->challenge;
172			$stepupCommand->recoveryTokenId = $command->recoveryTokenId;
173
174			$verification = $this->smsService->verifyPossession($stepupCommand);
175
176			if ($verification->didOtpExpire()) {
177			return ProofOfPossessionResult::challengeExpired();
178			}
179			if ($verification->wasAttemptedTooManyTimes()) {
180			return ProofOfPossessionResult::tooManyAttempts();
181			}
182			if (!$verification->wasSuccessful()) {
183			return ProofOfPossessionResult::incorrectChallenge();
184			}
185
186			return ProofOfPossessionResult::recoveryTokenVerified();
187			}
188			}
189

OpenConext / Stepup-SelfService

Pull Request — develop (#290)

SmsRecoveryTokenService::verifyAuthentication() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like