vendor/sonata-project/google-authenticator/src/GoogleAuthenticator.php line 144

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. /*
  6.  * This file is part of the Sonata Project package.
  7.  *
  8.  * (c) Thomas Rabaix <thomas.rabaix@sonata-project.org>
  9.  *
  10.  * For the full copyright and license information, please view the LICENSE
  11.  * file that was distributed with this source code.
  12.  */
  14. namespace Sonata\GoogleAuthenticator;
  16. /**
  17.  * @see https://github.com/google/google-authenticator/wiki/Key-Uri-Format
  18.  */
  19. final class GoogleAuthenticator implements GoogleAuthenticatorInterface
  20. {
  21.     /**
  22.      * @var int
  23.      */
  24.     private $passCodeLength;
  26.     /**
  27.      * @var int
  28.      */
  29.     private $secretLength;
  31.     /**
  32.      * @var int
  33.      */
  34.     private $pinModulo;
  36.     /**
  37.      * @var \DateTimeInterface
  38.      */
  39.     private $instanceTime;
  41.     /**
  42.      * @var int
  43.      */
  44.     private $codePeriod;
  46.     /**
  47.      * @var int
  48.      */
  49.     private $periodSize = 30;
  51.     public function __construct(int $passCodeLength = 6, int $secretLength = 10, ?\DateTimeInterface $instanceTime = null, int $codePeriod = 30)
  52.     {
  53.         /*
  54.          * codePeriod is the duration in seconds that the code is valid.
  55.          * periodSize is the length of a period to calculate periods since Unix epoch.
  56.          * periodSize cannot be larger than the codePeriod.
  57.          */
  59.         $this->passCodeLength = $passCodeLength;
  60.         $this->secretLength = $secretLength;
  61.         $this->codePeriod = $codePeriod;
  62.         $this->periodSize = $codePeriod < $this->periodSize ? $codePeriod : $this->periodSize;
  63.         $this->pinModulo = 10 ** $passCodeLength;
  64.         $this->instanceTime = $instanceTime ?? new \DateTimeImmutable();
  65.     }
  67.     /**
  68.      * @param string $secret
  69.      * @param string $code
  70.      * @param int    $discrepancy
  71.      */
  72.     public function checkCode($secret, $code, $discrepancy = 1): bool
  73.     {
  74.         /**
  75.          * Discrepancy is the factor of periodSize ($discrepancy * $periodSize) allowed on either side of the
  76.          * given codePeriod. For example, if a code with codePeriod = 60 is generated at 10:00:00, a discrepancy
  77.          * of 1 will allow a periodSize of 30 seconds on either side of the codePeriod resulting in a valid code
  78.          * from 09:59:30 to 10:00:29.
  79.          *
  80.          * The result of each comparison is stored as a timestamp here instead of using a guard clause
  81.          * (https://refactoring.com/catalog/replaceNestedConditionalWithGuardClauses.html). This is to implement
  82.          * constant time comparison to make side-channel attacks harder. See
  83.          * https://cryptocoding.net/index.php/Coding_rules#Compare_secret_strings_in_constant_time for details.
  84.          * Each comparison uses hash_equals() instead of an operator to implement constant time equality comparison
  85.          * for each code.
  86.          */
  87.         $periods = floor($this->codePeriod / $this->periodSize);
  89.         $result = 0;
  90.         for ($i = -$discrepancy; $i < $periods + $discrepancy; ++$i) {
  91.             $dateTime = new \DateTimeImmutable('@'.($this->instanceTime->getTimestamp() - ($i * $this->periodSize)));
  92.             $result = hash_equals($this->getCode($secret, $dateTime), $code) ? $dateTime->getTimestamp() : $result;
  93.         }
  95.         return $result > 0;
  96.     }
  98.     /**
  99.      * NEXT_MAJOR: add the interface typehint to $time and remove deprecation.
  100.      *
  101.      * @param string                                   $secret
  102.      * @param float|string|int|\DateTimeInterface|null $time
  103.      */
  104.     public function getCode($secret, /* \DateTimeInterface */ $time = null): string
  105.     {
  106.         if (null === $time) {
  107.             $time = $this->instanceTime;
  108.         }
  110.         if ($time instanceof \DateTimeInterface) {
  111.             $timeForCode = floor($time->getTimestamp() / $this->periodSize);
  112.         } else {
  113.             @trigger_error(
  114.                 'Passing anything other than null or a DateTimeInterface to $time is deprecated as of 2.0 '.
  115.                 'and will not be possible as of 3.0.',
  116.                 \E_USER_DEPRECATED
  117.             );
  118.             $timeForCode = $time;
  119.         }
  121.         $base32 = new FixedBitNotation(5, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567', true, true);
  122.         $secret = $base32->decode($secret);
  124.         $timeForCode = str_pad(pack('N', $timeForCode), 8, \chr(0), \STR_PAD_LEFT);
  126.         $hash = hash_hmac('sha1', $timeForCode, $secret, true);
  127.         $offset = \ord(substr($hash, -1));
  128.         $offset &= 0xF;
  130.         $truncatedHash = $this->hashToInt($hash, $offset) & 0x7FFFFFFF;
  132.         return str_pad((string) ($truncatedHash % $this->pinModulo), $this->passCodeLength, '0', \STR_PAD_LEFT);
  133.     }
  135.     /**
  136.      * NEXT_MAJOR: Remove this method.
  137.      *
  138.      * @param string $user
  139.      * @param string $hostname
  140.      * @param string $secret
  141.      *
  142.      * @deprecated deprecated as of 2.1 and will be removed in 3.0. Use Sonata\GoogleAuthenticator\GoogleQrUrl::generate() instead.
  143.      */
  144.     public function getUrl($user, $hostname, $secret): string
  145.     {
  146.         @trigger_error(sprintf(
  147.             'Using %s() is deprecated as of 2.1 and will be removed in 3.0. '.
  148.             'Use Sonata\GoogleAuthenticator\GoogleQrUrl::generate() instead.',
  149.             __METHOD__
  150.         ), \E_USER_DEPRECATED);
  152.         $issuer = \func_get_args()[3] ?? null;
  153.         $accountName = sprintf('%s@%s', $user, $hostname);
  155.         // manually concat the issuer to avoid a change in URL
  156.         $url = GoogleQrUrl::generate($accountName, $secret);
  158.         if ($issuer) {
  159.             $url .= '%26issuer%3D'.$issuer;
  160.         }
  162.         return $url;
  163.     }
  165.     public function generateSecret(): string
  166.     {
  167.         return (new FixedBitNotation(5, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567', true, true))
  168.             ->encode(random_bytes($this->secretLength));
  169.     }
  171.     private function hashToInt(string $bytes, int $start): int
  172.     {
  173.         return unpack('N', substr(substr($bytes, $start), 0, 4))[1];
  174.     }
  175. }
  177. // NEXT_MAJOR: Remove class alias
  178. class_alias('Sonata\GoogleAuthenticator\GoogleAuthenticator', 'Google\Authenticator\GoogleAuthenticator', false);