[2.2][Security] Add a PRNG (closes #3595)

src/Symfony/Bundle/SecurityBundle/Resources/config/security.xml

@@ -138,5 +138,12 @@
             <argument type="service" id="security.context" />
             <argument type="service" id="security.encoder_factory" />
         </service>
+
+        <!-- Pseudorandom Number Generator -->
+        <service id="security.secure_random" class="Symfony\Component\Security\Core\Util\SecureRandom">
+            <tag name="monolog.logger" channel="security" />
+            <argument>%kernel.cache_dir%/secure_random.seed</argument>
+            <argument type="service" id="logger" on-invalid="ignore" />
+        </service>
     </services>
 </container>

src/Symfony/Bundle/SecurityBundle/Resources/config/security_rememberme.xml

@@ -45,6 +45,12 @@
                  class="%security.authentication.rememberme.services.persistent.class%"
                  parent="security.authentication.rememberme.services.abstract"
                  abstract="true">
+            <argument type="collection" /> <!--  User Providers -->
+            <argument /> <!-- Shared Token Key -->
+            <argument /> <!-- Shared Provider Key -->
+            <argument type="collection" /> <!-- Options -->
+            <argument type="service" id="logger" on-invalid="null" />
+            <argument type="service" id="security.secure_random" />
         </service>
 
         <service id="security.authentication.rememberme.services.simplehash"

src/Symfony/Component/Security/CHANGELOG.md

@@ -4,7 +4,8 @@ CHANGELOG
 2.2.0
 -----
 
-* Added PBKDF2 Password encoder
+ * added secure random number generator
+ * added PBKDF2 Password encoder
 
 2.1.0
 -----

src/Symfony/Component/Security/Core/Encoder/BasePasswordEncoder.php

@@ -11,6 +11,8 @@
 
 namespace Symfony\Component\Security\Core\Encoder;
 
+use Symfony\Component\Security\Core\Util\StringUtils;
+
 /**
  * BasePasswordEncoder is the base class for all password encoders.
  *
@@ -77,15 +79,6 @@ protected function mergePasswordAndSalt($password, $salt)
      */
     protected function comparePasswords($password1, $password2)
     {
-        if (strlen($password1) !== strlen($password2)) {
-            return false;
-        }
-
-        $result = 0;
-        for ($i = 0; $i < strlen($password1); $i++) {
-            $result |= ord($password1[$i]) ^ ord($password2[$i]);
-        }
-
-        return 0 === $result;
+        return StringUtils::equals($password1, $password2);
     }
 }

src/Symfony/Component/Security/Core/Util/SecureRandom.php

@@ -0,0 +1,114 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Security\Core\Util;
+
+use Symfony\Component\HttpKernel\Log\LoggerInterface;
+
+/**
+ * A secure random number generator implementation.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+final class SecureRandom implements SecureRandomInterface
+{
+    private $logger;
+    private $useOpenSsl;
+    private $seed;
+    private $seedUpdated;
+    private $seedLastUpdatedAt;
+    private $seedFile;
+
+    /**
+     * Constructor.
+     *
+     * Be aware that a guessable seed will severely compromise the PRNG
+     * algorithm that is employed.
+     *
+     * @param string          $seedFile
+     * @param LoggerInterface $logger
+     */
+    public function __construct($seedFile = null, LoggerInterface $logger = null)
+    {
+        $this->seedFile = $seedFile;
+        $this->logger = $logger;
+
+        // determine whether to use OpenSSL
+        if (defined('PHP_WINDOWS_VERSION_BUILD') && version_compare(PHP_VERSION, '5.3.4', '<')) {
+            $this->useOpenSsl = false;
+        } elseif (!function_exists('openssl_random_pseudo_bytes')) {
+            if (null !== $this->logger) {
+                $this->logger->notice('It is recommended that you enable the "openssl" extension for random number generation.');
+            }
+            $this->useOpenSsl = false;
+        } else {
+            $this->useOpenSsl = true;
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function nextBytes($nbBytes)
+    {
+        // try OpenSSL
+        if ($this->useOpenSsl) {
+            $bytes = openssl_random_pseudo_bytes($nbBytes, $strong);
+
+            if (false !== $bytes && true === $strong) {
+                return $bytes;
+            }
+
+            if (null !== $this->logger) {
+                $this->logger->info('OpenSSL did not produce a secure random number.');
+            }
+        }
+
+        // initialize seed
+        if (null === $this->seed) {
+            if (null === $this->seedFile) {
+                throw new \RuntimeException('You need to specify a file path to store the seed.');
+            }
+
+            if (is_file($this->seedFile)) {
+                list($this->seed, $this->seedLastUpdatedAt) = $this->readSeed();
+            } else {
+                $this->seed = uniqid(mt_rand(), true);
+                $this->updateSeed();
+            }
+        }
+
+        $bytes = '';
+        while (strlen($bytes) < $nbBytes) {
+            static $incr = 1;
+            $bytes .= hash('sha512', $incr++.$this->seed.uniqid(mt_rand(), true).$nbBytes, true);
+            $this->seed = base64_encode(hash('sha512', $this->seed.$bytes.$nbBytes, true));
+            $this->updateSeed();
+        }
+
+        return substr($bytes, 0, $nbBytes);
+    }
+
+    private function readSeed()
+    {
+        return json_decode(file_get_contents($this->seedFile));
+    }
+
+    private function updateSeed()
+    {
+        if (!$this->seedUpdated && $this->seedLastUpdatedAt < time() - mt_rand(1, 10)) {
+            file_put_contents($this->seedFile, json_encode(array($this->seed, microtime(true))));
+        }
+
+        $this->seedUpdated = true;
+    }
+}

src/Symfony/Component/Security/Core/Util/SecureRandomInterface.php

@@ -0,0 +1,31 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Security\Core\Util;
+
+use Symfony\Component\HttpKernel\Log\LoggerInterface;
+
+/**
+ * Interface that needs to be implemented by all secure random number generators.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+interface SecureRandomInterface
+{
+    /**
+     * Generates the specified number of secure random bytes.
+     *
+     * @param integer $nbBytes
+     *
+     * @return string
+     */
+    public function nextBytes($nbBytes);
+}

src/Symfony/Component/Security/Core/Util/StringUtils.php

@@ -0,0 +1,48 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Security\Core\Util;
+
+/**
+ * String utility functions.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+final class StringUtils
+{
+    final private function __construct()
+    {
+    }
+
+    /**
+     * Compares two strings.
+     *
+     * This method implements a constant-time algorithm to compare strings.
+     *
+     * @param string $str1 The first string
+     * @param string $str2 The second string
+     *
+     * @return Boolean true if the two strings are the same, false otherwise
+     */
+    public static function equals($str1, $str2)
+    {
+        if (strlen($str1) !== $c = strlen($str2)) {
+            return false;
+        }
+
+        $result = 0;
+        for ($i = 0; $i < $c; $i++) {
+            $result |= ord($str1[$i]) ^ ord($str2[$i]);
+        }
+
+        return 0 === $result;
+    }
+}

src/Symfony/Component/Security/Http/RememberMe/PersistentTokenBasedRememberMeServices.php

@@ -19,6 +19,7 @@
 use Symfony\Component\Security\Core\Exception\CookieTheftException;
 use Symfony\Component\Security\Core\Authentication\RememberMe\PersistentToken;
 use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
+use Symfony\Component\Security\Core\Util\SecureRandomInterface;
 
 /**
  * Concrete implementation of the RememberMeServicesInterface which needs
@@ -30,6 +31,24 @@
 class PersistentTokenBasedRememberMeServices extends AbstractRememberMeServices
 {
     private $tokenProvider;
+    private $secureRandom;
+
+    /**
+     * Constructor.
+     *
+     * @param array                 $userProviders
+     * @param string                $key
+     * @param string                $providerKey
+     * @param array                 $options
+     * @param LoggerInterface       $logger
+     * @param SecureRandomInterface $secureRandom
+     */
+    public function __construct(array $userProviders, $key, $providerKey, array $options = array(), LoggerInterface $logger = null, SecureRandomInterface $secureRandom)
+    {
+        parent::__construct($userProviders, $key, $providerKey, $options, $logger);
+
+        $this->secureRandom = $secureRandom;
+    }
 
     /**
      * Sets the token provider
@@ -79,7 +98,7 @@ protected function processAutoLoginCookie(array $cookieParts, Request $request)
         }
 
         $series = $persistentToken->getSeries();
-        $tokenValue = $this->generateRandomValue();
+        $tokenValue = $this->secureRandom->nextBytes(64);
         $this->tokenProvider->updateToken($series, $tokenValue, new \DateTime());
         $request->attributes->set(self::COOKIE_ATTR_NAME,
             new Cookie(
@@ -101,8 +120,8 @@ protected function processAutoLoginCookie(array $cookieParts, Request $request)
      */
     protected function onLoginSuccess(Request $request, Response $response, TokenInterface $token)
     {
-        $series = $this->generateRandomValue();
-        $tokenValue = $this->generateRandomValue();
+        $series = $this->secureRandom->nextBytes(64);
+        $tokenValue = $this->secureRandom->nextBytes(64);
 
         $this->tokenProvider->createNewToken(
             new PersistentToken(
@@ -126,26 +145,4 @@ protected function onLoginSuccess(Request $request, Response $response, TokenInt
             )
         );
     }
-
-    /**
-     * Generates a cryptographically strong random value
-     *
-     * @return string
-     */
-    protected function generateRandomValue()
-    {
-        if (function_exists('openssl_random_pseudo_bytes')) {
-            $bytes = openssl_random_pseudo_bytes(64, $strong);
-
-            if (true === $strong && false !== $bytes) {
-                return base64_encode($bytes);
-            }
-        }
-
-        if (null !== $this->logger) {
-            $this->logger->warn('Could not produce a cryptographically strong random value. Please install/update the OpenSSL extension.');
-        }
-
-        return base64_encode(hash('sha512', uniqid(mt_rand(), true), true));
-    }
 }

src/Symfony/Component/Security/Tests/Core/Util/ClassUtilsTest.php

@@ -1,5 +1,14 @@
 <?php
 
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
 namespace Symfony\Component\Security\Tests\Core\Util
 {
     use Symfony\Component\Security\Core\Util\ClassUtils;