Surfnet\StepupU2fBundle\Service\RegistrationVerificationResult

Complexity

Total Complexity

25

Size/Duplication

Total Lines	259
Duplicated Lines	8.49 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

22 Methods

Rating	Name	Duplication	Size	Complexity
A	success()	0	7	1
A	deviceReportedError()	22	22	2
A	responseChallengeDidNotMatchRequestChallenge()	0	4	1
A	responseWasNotSignedByDevice()	0	4	1
A	deviceCannotBeTrusted()	0	4	1
A	publicKeyDecodingFailed()	0	4	1
A	appIdMismatch()	0	4	1
A	__construct()	0	4	1
A	wasSuccessful()	0	4	1
A	getRegistration()	0	8	2
A	didDeviceReportABadRequest()	0	4	1
A	wasClientConfigurationUnsupported()	0	4	1
A	wasDeviceAlreadyRegistered()	0	4	1
A	didDeviceTimeOut()	0	4	1
A	didDeviceReportAnUnknownError()	0	4	1
A	didDeviceReportAnyError()	0	4	1
A	didResponseChallengeNotMatchRequestChallenge()	0	4	1
A	wasResponseNotSignedByDevice()	0	4	1
A	canDeviceNotBeTrusted()	0	4	1
A	didPublicKeyDecodingFail()	0	4	1
A	didntAppIdsMatch()	0	4	1
A	didDeviceReportError()	0	4	2

<?php

/**
 * Copyright 2014 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\StepupU2fBundle\Service;

use Surfnet\StepupU2fBundle\Dto\RegisterResponse;
use Surfnet\StepupU2fBundle\Dto\Registration;
use Surfnet\StepupU2fBundle\Exception\InvalidArgumentException;
use Surfnet\StepupU2fBundle\Exception\LogicException;

/**
 * @SuppressWarnings(PHPMD.TooManyPublicMethods)
 */
final class RegistrationVerificationResult
{
    /**
     * Registration was a success.
     */
    const STATUS_SUCCESS = 0;

    /**
     * The response challenge did not match the request challenge.
     */
    const STATUS_UNMATCHED_REGISTRATION_CHALLENGE = 1;

    /**
     * The response was signed by another party than the device, indicating it was tampered with.
     */
    const STATUS_RESPONSE_NOT_SIGNED_BY_DEVICE = 2;

    /**
     * The device has not been manufactured by a trusted party.
     */
    const STATUS_UNTRUSTED_DEVICE = 3;

    /**
     * The decoding of the device's public key failed.
     */
    const STATUS_PUBLIC_KEY_DECODING_FAILED = 4;

    /**
     * The U2F device reported an error.
     *
     * @see \Surfnet\StepupU2fBundle\Dto\RegisterResponse::$errorCode
     * @see \Surfnet\StepupU2fBundle\Dto\RegisterResponse::ERROR_CODE_* constants
     */
    const STATUS_DEVICE_ERROR = 5;

    /**
     * The AppIDs of the server and a message did not match.
     */
    const STATUS_APP_ID_MISMATCH = 6;

    /**
     * @var int
     */
    private $status;

    /**
     * @var Registration|null
     */
    private $registration;

    /**
     * @var int|null
     */
    private $deviceErrorCode;

    /**
     * @param Registration $registration
     * @return RegistrationVerificationResult
     */
    public static function success(Registration $registration)
    {
        $result = new self(self::STATUS_SUCCESS);
        $result->registration = $registration;

        return $result;
    }

    /**
     * @param int $errorCode
     * @return RegistrationVerificationResult
     */
    public static function deviceReportedError($errorCode)

This method seems to be duplicated in your project.

    {
        $validErrorCodes = [
            RegisterResponse::ERROR_CODE_OK,
            RegisterResponse::ERROR_CODE_OTHER_ERROR,
            RegisterResponse::ERROR_CODE_BAD_REQUEST,
            RegisterResponse::ERROR_CODE_CONFIGURATION_UNSUPPORTED,
            RegisterResponse::ERROR_CODE_DEVICE_INELIGIBLE,
            RegisterResponse::ERROR_CODE_TIMEOUT,
        ];

        if (!in_array($errorCode, $validErrorCodes)) {
            throw new InvalidArgumentException(
                sprintf('Device error code (%s) is not one of the known error codes', $errorCode)
            );
        }

        $result = new self(self::STATUS_DEVICE_ERROR);
        $result->deviceErrorCode = $errorCode;

        return $result;
    }

    /**
     * @return RegistrationVerificationResult
     */
    public static function responseChallengeDidNotMatchRequestChallenge()
    {
        return new self(self::STATUS_UNMATCHED_REGISTRATION_CHALLENGE);
    }

    /**
     * @return RegistrationVerificationResult
     */
    public static function responseWasNotSignedByDevice()
    {
        return new self(self::STATUS_RESPONSE_NOT_SIGNED_BY_DEVICE);
    }

    /**
     * @return RegistrationVerificationResult
     */
    public static function deviceCannotBeTrusted()
    {
        return new self(self::STATUS_UNTRUSTED_DEVICE);
    }

    /**
     * @return RegistrationVerificationResult
     */
    public static function publicKeyDecodingFailed()
    {
        return new self(self::STATUS_PUBLIC_KEY_DECODING_FAILED);
    }

    /**
     * @return RegistrationVerificationResult
     */
    public static function appIdMismatch()
    {
        return new self(self::STATUS_APP_ID_MISMATCH);
    }

    /**
     * @param int $status
     */
    private function __construct($status)
    {
        $this->status = $status;
    }

    /**
     * @return bool
     */
    public function wasSuccessful()
    {
        return $this->status === self::STATUS_SUCCESS;
    }

    /**
     * @return Registration|null
     */
    public function getRegistration()
    {
        if (!$this->wasSuccessful()) {
            throw new LogicException('The registration was unsuccessful and the registration data is not available');
        }

        return $this->registration;
    }

    /**
     * @return bool
     */
    public function didDeviceReportABadRequest()
    {
        return $this->didDeviceReportError(RegisterResponse::ERROR_CODE_BAD_REQUEST);
    }

    /**
     * @return bool
     */
    public function wasClientConfigurationUnsupported()
    {
        return $this->didDeviceReportError(RegisterResponse::ERROR_CODE_CONFIGURATION_UNSUPPORTED);
    }

    /**
     * @return bool
     */
    public function wasDeviceAlreadyRegistered()
    {
        return $this->didDeviceReportError(RegisterResponse::ERROR_CODE_DEVICE_INELIGIBLE);
    }

    /**
     * @return bool
     */
    public function didDeviceTimeOut()
    {
        return $this->didDeviceReportError(RegisterResponse::ERROR_CODE_TIMEOUT);
    }

    /**
     * @return bool
     */
    public function didDeviceReportAnUnknownError()
    {
        return $this->didDeviceReportError(RegisterResponse::ERROR_CODE_OTHER_ERROR);
    }

    /**
     * @return bool
     */
    public function didDeviceReportAnyError()
    {
        return $this->status === self::STATUS_DEVICE_ERROR;
    }

    /**
     * @return bool
     */
    public function didResponseChallengeNotMatchRequestChallenge()
    {
        return $this->status === self::STATUS_UNMATCHED_REGISTRATION_CHALLENGE;
    }

    /**
     * @return bool
     */
    public function wasResponseNotSignedByDevice()
    {
        return $this->status === self::STATUS_RESPONSE_NOT_SIGNED_BY_DEVICE;
    }

    /**
     * @return bool
     */
    public function canDeviceNotBeTrusted()
    {
        return $this->status === self::STATUS_UNTRUSTED_DEVICE;
    }

    /**
     * @return bool
     */
    public function didPublicKeyDecodingFail()
    {
        return $this->status === self::STATUS_PUBLIC_KEY_DECODING_FAILED;
    }

    /**
     * @return bool
     */
    public function didntAppIdsMatch()
    {
        return $this->status === self::STATUS_APP_ID_MISMATCH;
    }

    /**
     * @param int $errorCode
     * @return bool
     */
    private function didDeviceReportError($errorCode)
    {
        return $this->status === self::STATUS_DEVICE_ERROR && $this->deviceErrorCode === $errorCode;
    }
}