pax_global_header00006660000000000000000000000064124557655610014532gustar00rootroot0000000000000052 comment=13efa4368bb2ac88bb3b1459b487d907de4dbf7c RandomLib-1.1.0/000077500000000000000000000000001245576556100134005ustar00rootroot00000000000000RandomLib-1.1.0/.gitignore000066400000000000000000000000061245576556100153640ustar00rootroot00000000000000vendorRandomLib-1.1.0/.travis.yml000066400000000000000000000002641245576556100155130ustar00rootroot00000000000000language: php php: - 5.6 - 5.5 - 5.4 - 5.3 - hhvm before_script: - composer install --prefer-source script: vendor/bin/phpunit --configuration phpunit.xml.dist test RandomLib-1.1.0/LICENSE000066400000000000000000000020371245576556100144070ustar00rootroot00000000000000Copyright (c) 2011 The Authors Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. RandomLib-1.1.0/README.md000066400000000000000000000066061245576556100146670ustar00rootroot00000000000000RandomLib ========= A library for generating random numbers and strings of various strengths. This library is useful in security contexts. Usage ----- ### Factory A factory is used to get generators of varying strength: ```php $factory = new RandomLib\Factory; $generator = $factory->getGenerator(new SecurityLib\Strength(SecurityLib\Strength::MEDIUM)); ``` A factory can be configured with additional mixers and sources but can be used out of the box to create both medium and low strength generators. Convenience methods are provided for creating high, medium, and low strength generators. Example: ```php $generator = $factory->getMediumStrengthGenerator(); ``` #### $factory->getLowStrengthGenerator() Convenience method to get a low strength random number generator. Low Strength should be used anywhere that random strings are needed in a non-cryptographical setting. They are not strong enough to be used as keys or salts. They are however useful for one-time use tokens. #### $factory->getMediumStrengthGenerator() Convenience method to get a medium strength random number generator. Medium Strength should be used for most needs of a cryptographic nature. They are strong enough to be used as keys and salts. However, they do take some time and resources to generate, so they should not be over-used #### $factory->getHighStrengthGenerator() Convenience method to get a high strength random number generator. High Strength keys should ONLY be used for generating extremely strong cryptographic keys. Generating them is very resource intensive and may take several minutes or more depending on the requested size. **There are currently no mixers shipped with this package that are capable of creating a high space generator. This will not work out of the box!** ### Generator A generator is used to generate random numbers and strings. Example: ```php // Generate a random string that is 32 bytes in length. $bytes = $generator->generate(32); // Generate a whole number between 5 and 15. $randomInt = $generator->generateInt(5, 15); // Generate a 32 character string that only contains the letters // 'a', 'b', 'c', 'd', 'e', and 'f'. $randomString = $generator->generateString(32, 'abcdef'); ``` #### $generator->generate($size) Generate a random byte string of the requested size. #### $generator->generateInt($min = 0, $max = PHP_INT_MAX) Generate a random integer with the given range. If range (`$max - $min`) is zero, `$max` will be used. #### $generator->generateString($length, $characters = '') Generate a random string of specified length. This uses the supplied character list for generating the new result string. The list of characters should be specified as a string containing each allowed character. If no character list is specified, the following list of characters is used: 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ./ **Examples:** ```php // Give the character list 'abcdef': print $generator->generateString(32, 'abcdef')."\n"; // One would expect to receive output that only contained those // characters: // // adaeabecfbddcdaeedaedfbbcdccccfe // adfbfdbfddadbfcbbefebcacbefafffa // ceeadbcabecbccacdcaabbdccfadbafe // abadcffabdcacdbcbafcaecabafcdbbf // dbdbddacdeaceabfaefcbfafebcacdca ``` License ------- MIT, see LICENSE. Community --------- If you have questions or want to help out, join us in the **#php.security** channel on **irc.freenode.net**. RandomLib-1.1.0/composer.json000066400000000000000000000015701245576556100161250ustar00rootroot00000000000000{ "name": "ircmaxell/random-lib", "type": "library", "description": "A Library For Generating Secure Random Numbers", "keywords": ["random", "random-numbers", "random-strings", "cryptography"], "homepage": "https://github.com/ircmaxell/RandomLib", "license": "MIT", "minimum-stability": "dev", "authors": [ { "name": "Anthony Ferrara", "email": "ircmaxell@ircmaxell.com", "homepage": "http://blog.ircmaxell.com" } ], "require-dev": { "mikey179/vfsStream": "1.1.*", "phpunit/phpunit": "3.7.*" }, "require": { "ircmaxell/security-lib": "1.0.*@dev", "php": ">=5.3.2" }, "autoload": { "psr-0": { "RandomLib": "lib" } }, "extra": { "branch-alias": { "dev-master": "1.0.x-dev" } } } RandomLib-1.1.0/composer.lock000066400000000000000000000427021245576556100161060ustar00rootroot00000000000000{ "_readme": [ "This file locks the dependencies of your project to a known state", "Read more about it at http://getcomposer.org/doc/01-basic-usage.md#composer-lock-the-lock-file" ], "hash": "53736b08b02df322ee3639370e576800", "packages": [ { "name": "ircmaxell/security-lib", "version": "dev-master", "source": { "type": "git", "url": "https://github.com/ircmaxell/SecurityLib.git", "reference": "d63da10d863b819289059de850c920b1cd98204d" }, "dist": { "type": "zip", "url": "https://api.github.com/repos/ircmaxell/SecurityLib/zipball/d63da10d863b819289059de850c920b1cd98204d", "reference": "d63da10d863b819289059de850c920b1cd98204d", "shasum": "" }, "require": { "php": ">=5.3.2" }, "require-dev": { "mikey179/vfsstream": "1.1.*" }, "type": "library", "extra": { "branch-alias": { "dev-master": "1.0.x-dev" } }, "autoload": { "psr-0": { "SecurityLib": "lib" } }, "notification-url": "https://packagist.org/downloads/", "license": [ "MIT" ], "authors": [ { "name": "Anthony Ferrara", "email": "ircmaxell@ircmaxell.com", "homepage": "http://blog.ircmaxell.com" } ], "description": "A Base Security Library", "homepage": "https://github.com/ircmaxell/PHP-SecurityLib", "time": "2013-07-30 17:43:34" } ], "packages-dev": [ { "name": "mikey179/vfsStream", "version": "v1.1.0", "source": { "type": "git", "url": "https://github.com/mikey179/vfsStream.git", "reference": "fc0fe8f4d0b527254a2dc45f0c265567c881d07e" }, "dist": { "type": "zip", "url": "https://api.github.com/repos/mikey179/vfsStream/zipball/fc0fe8f4d0b527254a2dc45f0c265567c881d07e", "reference": "fc0fe8f4d0b527254a2dc45f0c265567c881d07e", "shasum": "" }, "require": { "php": ">=5.3.0" }, "type": "library", "autoload": { "psr-0": { "org\\bovigo\\vfs": "src/main/php" } }, "notification-url": "https://packagist.org/downloads/", "license": [ "BSD" ], "homepage": "http://vfs.bovigo.org/", "time": "2012-08-25 12:49:29" }, { "name": "phpunit/php-code-coverage", "version": "1.2.x-dev", "source": { "type": "git", "url": "https://github.com/sebastianbergmann/php-code-coverage.git", "reference": "10c5b2c8b72a801eaad0031cd6a6a3686909c5a9" }, "dist": { "type": "zip", "url": "https://api.github.com/repos/sebastianbergmann/php-code-coverage/zipball/10c5b2c8b72a801eaad0031cd6a6a3686909c5a9", "reference": "10c5b2c8b72a801eaad0031cd6a6a3686909c5a9", "shasum": "" }, "require": { "php": ">=5.3.3", "phpunit/php-file-iterator": ">=1.3.0@stable", "phpunit/php-text-template": ">=1.1.1@stable", "phpunit/php-token-stream": ">=1.1.3@stable" }, "require-dev": { "phpunit/phpunit": "3.7.*@dev" }, "suggest": { "ext-dom": "*", "ext-xdebug": ">=2.0.5" }, "type": "library", "extra": { "branch-alias": { "dev-master": "1.2.x-dev" } }, "autoload": { "classmap": [ "PHP/" ] }, "notification-url": "https://packagist.org/downloads/", "include-path": [ "" ], "license": [ "BSD-3-Clause" ], "authors": [ { "name": "Sebastian Bergmann", "email": "sb@sebastian-bergmann.de", "role": "lead" } ], "description": "Library that provides collection, processing, and rendering functionality for PHP code coverage information.", "homepage": "https://github.com/sebastianbergmann/php-code-coverage", "keywords": [ "coverage", "testing", "xunit" ], "time": "2013-11-01 09:17:11" }, { "name": "phpunit/php-file-iterator", "version": "dev-master", "source": { "type": "git", "url": "https://github.com/sebastianbergmann/php-file-iterator.git", "reference": "acd690379117b042d1c8af1fafd61bde001bf6bb" }, "dist": { "type": "zip", "url": "https://api.github.com/repos/sebastianbergmann/php-file-iterator/zipball/acd690379117b042d1c8af1fafd61bde001bf6bb", "reference": "acd690379117b042d1c8af1fafd61bde001bf6bb", "shasum": "" }, "require": { "php": ">=5.3.3" }, "type": "library", "autoload": { "classmap": [ "File/" ] }, "notification-url": "https://packagist.org/downloads/", "include-path": [ "" ], "license": [ "BSD-3-Clause" ], "authors": [ { "name": "Sebastian Bergmann", "email": "sb@sebastian-bergmann.de", "role": "lead" } ], "description": "FilterIterator implementation that filters files based on a list of suffixes.", "homepage": "https://github.com/sebastianbergmann/php-file-iterator/", "keywords": [ "filesystem", "iterator" ], "time": "2013-10-10 15:34:57" }, { "name": "phpunit/php-text-template", "version": "dev-master", "source": { "type": "git", "url": "https://github.com/sebastianbergmann/php-text-template.git", "reference": "1eeef106193d2f8c539728e566bb4793071a9e18" }, "dist": { "type": "zip", "url": "https://api.github.com/repos/sebastianbergmann/php-text-template/zipball/1eeef106193d2f8c539728e566bb4793071a9e18", "reference": "1eeef106193d2f8c539728e566bb4793071a9e18", "shasum": "" }, "require": { "php": ">=5.3.3" }, "type": "library", "autoload": { "classmap": [ "Text/" ] }, "notification-url": "https://packagist.org/downloads/", "include-path": [ "" ], "license": [ "BSD-3-Clause" ], "authors": [ { "name": "Sebastian Bergmann", "email": "sb@sebastian-bergmann.de", "role": "lead" } ], "description": "Simple template engine.", "homepage": "https://github.com/sebastianbergmann/php-text-template/", "keywords": [ "template" ], "time": "2013-01-07 10:56:17" }, { "name": "phpunit/php-timer", "version": "dev-master", "source": { "type": "git", "url": "https://github.com/sebastianbergmann/php-timer.git", "reference": "19689d4354b295ee3d8c54b4f42c3efb69cbc17c" }, "dist": { "type": "zip", "url": "https://api.github.com/repos/sebastianbergmann/php-timer/zipball/19689d4354b295ee3d8c54b4f42c3efb69cbc17c", "reference": "19689d4354b295ee3d8c54b4f42c3efb69cbc17c", "shasum": "" }, "require": { "php": ">=5.3.3" }, "type": "library", "autoload": { "classmap": [ "PHP/" ] }, "notification-url": "https://packagist.org/downloads/", "include-path": [ "" ], "license": [ "BSD-3-Clause" ], "authors": [ { "name": "Sebastian Bergmann", "email": "sb@sebastian-bergmann.de", "role": "lead" } ], "description": "Utility class for timing", "homepage": "https://github.com/sebastianbergmann/php-timer/", "keywords": [ "timer" ], "time": "2013-08-02 07:42:54" }, { "name": "phpunit/php-token-stream", "version": "dev-master", "source": { "type": "git", "url": "https://github.com/sebastianbergmann/php-token-stream.git", "reference": "292f4d5772dad5a12775be69f4a8dd663b20f103" }, "dist": { "type": "zip", "url": "https://api.github.com/repos/sebastianbergmann/php-token-stream/zipball/292f4d5772dad5a12775be69f4a8dd663b20f103", "reference": "292f4d5772dad5a12775be69f4a8dd663b20f103", "shasum": "" }, "require": { "ext-tokenizer": "*", "php": ">=5.3.3" }, "type": "library", "extra": { "branch-alias": { "dev-master": "1.2-dev" } }, "autoload": { "classmap": [ "PHP/" ] }, "notification-url": "https://packagist.org/downloads/", "include-path": [ "" ], "license": [ "BSD-3-Clause" ], "authors": [ { "name": "Sebastian Bergmann", "email": "sb@sebastian-bergmann.de", "role": "lead" } ], "description": "Wrapper around PHP's tokenizer extension.", "homepage": "https://github.com/sebastianbergmann/php-token-stream/", "keywords": [ "tokenizer" ], "time": "2013-10-21 14:03:39" }, { "name": "phpunit/phpunit", "version": "3.7.x-dev", "source": { "type": "git", "url": "https://github.com/sebastianbergmann/phpunit.git", "reference": "92e8faf88773fa173b0ab2425ba4ade434c58c5d" }, "dist": { "type": "zip", "url": "https://api.github.com/repos/sebastianbergmann/phpunit/zipball/92e8faf88773fa173b0ab2425ba4ade434c58c5d", "reference": "92e8faf88773fa173b0ab2425ba4ade434c58c5d", "shasum": "" }, "require": { "ext-dom": "*", "ext-pcre": "*", "ext-reflection": "*", "ext-spl": "*", "php": ">=5.3.3", "phpunit/php-code-coverage": "~1.2.1", "phpunit/php-file-iterator": ">=1.3.1", "phpunit/php-text-template": ">=1.1.1", "phpunit/php-timer": ">=1.0.4", "phpunit/phpunit-mock-objects": "~1.2.0", "symfony/yaml": "~2.0" }, "require-dev": { "pear-pear/pear": "1.9.4" }, "suggest": { "ext-json": "*", "ext-simplexml": "*", "ext-tokenizer": "*", "phpunit/php-invoker": ">=1.1.0,<1.2.0" }, "bin": [ "composer/bin/phpunit" ], "type": "library", "extra": { "branch-alias": { "dev-master": "3.7.x-dev" } }, "autoload": { "classmap": [ "PHPUnit/" ] }, "notification-url": "https://packagist.org/downloads/", "include-path": [ "", "../../symfony/yaml/" ], "license": [ "BSD-3-Clause" ], "authors": [ { "name": "Sebastian Bergmann", "email": "sebastian@phpunit.de", "role": "lead" } ], "description": "The PHP Unit Testing framework.", "homepage": "http://www.phpunit.de/", "keywords": [ "phpunit", "testing", "xunit" ], "time": "2013-12-29 07:28:17" }, { "name": "phpunit/phpunit-mock-objects", "version": "1.2.x-dev", "source": { "type": "git", "url": "https://github.com/sebastianbergmann/phpunit-mock-objects.git", "reference": "3e40f3b3f18c044a24688fe406440d7fd537744a" }, "dist": { "type": "zip", "url": "https://api.github.com/repos/sebastianbergmann/phpunit-mock-objects/zipball/3e40f3b3f18c044a24688fe406440d7fd537744a", "reference": "3e40f3b3f18c044a24688fe406440d7fd537744a", "shasum": "" }, "require": { "php": ">=5.3.3", "phpunit/php-text-template": ">=1.1.1@stable" }, "require-dev": { "pear-pear/pear": "1.9.4", "phpunit/phpunit": "3.7.*@dev" }, "suggest": { "ext-soap": "*" }, "type": "library", "extra": { "branch-alias": { "dev-master": "1.2.x-dev" } }, "autoload": { "classmap": [ "PHPUnit/" ] }, "notification-url": "https://packagist.org/downloads/", "include-path": [ "" ], "license": [ "BSD-3-Clause" ], "authors": [ { "name": "Sebastian Bergmann", "email": "sb@sebastian-bergmann.de", "role": "lead" } ], "description": "Mock Object library for PHPUnit", "homepage": "https://github.com/sebastianbergmann/phpunit-mock-objects/", "keywords": [ "mock", "xunit" ], "time": "2013-07-23 04:42:59" }, { "name": "symfony/yaml", "version": "dev-master", "target-dir": "Symfony/Component/Yaml", "source": { "type": "git", "url": "https://github.com/symfony/Yaml.git", "reference": "9921872611710df49cf035c259e5a461ea2d0f8c" }, "dist": { "type": "zip", "url": "https://api.github.com/repos/symfony/Yaml/zipball/9921872611710df49cf035c259e5a461ea2d0f8c", "reference": "9921872611710df49cf035c259e5a461ea2d0f8c", "shasum": "" }, "require": { "php": ">=5.3.3" }, "type": "library", "extra": { "branch-alias": { "dev-master": "2.5-dev" } }, "autoload": { "psr-0": { "Symfony\\Component\\Yaml\\": "" } }, "notification-url": "https://packagist.org/downloads/", "license": [ "MIT" ], "authors": [ { "name": "Fabien Potencier", "email": "fabien@symfony.com" }, { "name": "Symfony Community", "homepage": "http://symfony.com/contributors" } ], "description": "Symfony Yaml Component", "homepage": "http://symfony.com", "time": "2014-01-07 13:29:57" } ], "aliases": [ ], "minimum-stability": "dev", "stability-flags": { "ircmaxell/security-lib": 20 }, "platform": { "php": ">=5.3.2" }, "platform-dev": [ ] } RandomLib-1.1.0/lib/000077500000000000000000000000001245576556100141465ustar00rootroot00000000000000RandomLib-1.1.0/lib/RandomLib/000077500000000000000000000000001245576556100160155ustar00rootroot00000000000000RandomLib-1.1.0/lib/RandomLib/AbstractMixer.php000066400000000000000000000065671245576556100213140ustar00rootroot00000000000000 * @copyright 2011 The Authors * @license http://www.opensource.org/licenses/mit-license.html MIT License * @version Build @@version@@ */ namespace RandomLib; /** * An abstract mixer to implement a common mixing strategy * * @see http://tools.ietf.org/html/rfc4086#section-5.2 * @category PHPSecurityLib * @package Random * @author Anthony Ferrara */ abstract class AbstractMixer implements \RandomLib\Mixer { /** * Get the block size (the size of the individual blocks used for the mixing) * * @return int The block size */ abstract protected function getPartSize(); /** * Mix 2 parts together using one method * * @param string $part1 The first part to mix * @param string $part2 The second part to mix * * @return string The mixed data */ abstract protected function mixParts1($part1, $part2); /** * Mix 2 parts together using another different method * * @param string $part1 The first part to mix * @param string $part2 The second part to mix * * @return string The mixed data */ abstract protected function mixParts2($part1, $part2); /** * Mix the provided array of strings into a single output of the same size * * All elements of the array should be the same size. * * @param array $parts The parts to be mixed * * @return string The mixed result */ public function mix(array $parts) { if (empty($parts)) { return ''; } $len = strlen($parts[0]); $parts = $this->normalizeParts($parts); $stringSize = count($parts[0]); $partsSize = count($parts); $result = ''; $offset = 0; for ($i = 0; $i < $stringSize; $i++) { $stub = $parts[$offset][$i]; for ($j = 1; $j < $partsSize; $j++) { $newKey = $parts[($j + $offset) % $partsSize][$i]; //Alternately mix the output for each source if ($j % 2 == 1) { $stub ^= $this->mixParts1($stub, $newKey); } else { $stub ^= $this->mixParts2($stub, $newKey); } } $result .= $stub; $offset = ($offset + 1) % $partsSize; } return substr($result, 0, $len); } /** * Normalize the part array and split it block part size. * * This will make all parts the same length and a multiple * of the part size * * @param array $parts The parts to normalize * * @return array The normalized and split parts */ protected function normalizeParts(array $parts) { $blockSize = $this->getPartSize(); $callback = function($value) { return strlen($value); }; $maxSize = max(array_map($callback, $parts)); if ($maxSize % $blockSize != 0) { $maxSize += $blockSize - ($maxSize % $blockSize); } foreach ($parts as &$part) { $part = str_pad($part, $maxSize, chr(0)); $part = str_split($part, $blockSize); } return $parts; } } RandomLib-1.1.0/lib/RandomLib/Factory.php000066400000000000000000000141011245576556100201320ustar00rootroot00000000000000 * @copyright 2011 The Authors * @license http://www.opensource.org/licenses/mit-license.html MIT License * @version Build @@version@@ */ namespace RandomLib; use SecurityLib\Strength; /** * The Random Factory * * Use this factory to instantiate random number generators, sources and mixers. * * @category PHPPasswordLib * @package Random * @author Anthony Ferrara */ class Factory extends \SecurityLib\AbstractFactory { /** * @var array A list of available random number mixing strategies */ protected $mixers = array(); /** * @var array A list of available random number sources */ protected $sources = array(); /** * Build a new instance of the factory, loading core mixers and sources * * @return void */ public function __construct() { $this->loadMixers(); $this->loadSources(); } /** * Get a generator for the requested strength * * @param Strength $strength The requested strength of the random number * * @return Generator The instantiated generator * @throws RuntimeException If an appropriate mixing strategy isn't found */ public function getGenerator(\SecurityLib\Strength $strength) { $sources = $this->getSources(); $newSources = array(); foreach ($sources as $source) { if ($strength->compare($source::getStrength()) <= 0) { $newSources[] = new $source; } } $mixer = $this->findMixer($strength); return new Generator($newSources, $mixer); } /** * Get a high strength random number generator * * High Strength keys should ONLY be used for generating extremely strong * cryptographic keys. Generating them is very resource intensive and may * take several minutes or more depending on the requested size. * * @return Generator The instantiated generator */ public function getHighStrengthGenerator() { return $this->getGenerator(new Strength(Strength::HIGH)); } /** * Get a low strength random number generator * * Low Strength should be used anywhere that random strings are needed in a * non-cryptographical setting. They are not strong enough to be used as * keys or salts. They are however useful for one-time use tokens. * * @return Generator The instantiated generator */ public function getLowStrengthGenerator() { return $this->getGenerator(new Strength(Strength::LOW)); } /** * Get a medium strength random number generator * * Medium Strength should be used for most needs of a cryptographic nature. * They are strong enough to be used as keys and salts. However, they do * take some time and resources to generate, so they should not be over-used * * @return Generator The instantiated generator */ public function getMediumStrengthGenerator() { return $this->getGenerator(new Strength(Strength::MEDIUM)); } /** * Get all loaded mixing strategies * * @return array An array of mixers */ public function getMixers() { return $this->mixers; } /** * Get all loaded random number sources * * @return array An array of sources */ public function getSources() { return $this->sources; } /** * Register a mixing strategy for this factory instance * * @param string $name The name of the stategy * @param string $class The class name of the implementation * * @return Factory $this The current factory instance */ public function registerMixer($name, $class) { $this->registerType( 'mixers', __NAMESPACE__ . '\\Mixer', $name, $class ); return $this; } /** * Register a random number source for this factory instance * * Note that this class must implement the Source interface * * @param string $name The name of the stategy * @param string $class The class name of the implementation * * @return Factory $this The current factory instance */ public function registerSource($name, $class) { $this->registerType( 'sources', __NAMESPACE__ . '\\Source', $name, $class ); return $this; } /** * Find a mixer based upon the requested strength * * @param Strength $strength The strength mixer to find * * @return Mixer The found mixer * @throws RuntimeException if a valid mixer cannot be found */ protected function findMixer(\SecurityLib\Strength $strength) { $newMixer = null; $fallback = null; foreach ($this->getMixers() as $mixer) { if ($strength->compare($mixer::getStrength()) == 0) { $newMixer = new $mixer; } elseif ($strength->compare($mixer::getStrength()) == 1) { $fallback = new $mixer; } } if (is_null($newMixer)) { if (is_null($fallback)) { throw new \RuntimeException('Could not find mixer'); } return $fallback; } return $newMixer; } /** * Load all core mixing strategies * * @return void */ protected function loadMixers() { $this->loadFiles( __DIR__ . '/Mixer', __NAMESPACE__ . '\\Mixer\\', array($this, 'registerMixer') ); } /** * Load all core random number sources * * @return void */ protected function loadSources() { $this->loadFiles( __DIR__ . '/Source', __NAMESPACE__ . '\\Source\\', array($this, 'registerSource') ); } } RandomLib-1.1.0/lib/RandomLib/Generator.php000077500000000000000000000240631245576556100204640ustar00rootroot00000000000000 * @author Timo Hamina * @copyright 2011 The Authors * @license http://www.opensource.org/licenses/mit-license.html MIT License * @version Build @@version@@ */ namespace RandomLib; use SecurityLib\BaseConverter; /** * The Random Number Generator Class * * Use this factory to generate cryptographic quality random numbers (strings) * * @category PHPPasswordLib * @package Random * @author Anthony Ferrara * @author Timo Hamina */ class Generator { /** * @const Flag for uppercase letters */ const CHAR_UPPER = 1; /** * @const Flag for lowercase letters */ const CHAR_LOWER = 2; /** * @const Flag for alpha characters (combines UPPER + LOWER) */ const CHAR_ALPHA = 3; // CHAR_UPPER | CHAR_LOWER /** * @const Flag for digits */ const CHAR_DIGITS = 4; /** * @const Flag for alpha numeric characters */ const CHAR_ALNUM = 7; // CHAR_ALPHA | CHAR_DIGITS /** * @const Flag for uppercase hexadecimal symbols */ const CHAR_UPPER_HEX = 12; // 8 | CHAR_DIGITS /** * @const Flag for lowercase hexidecimal symbols */ const CHAR_LOWER_HEX = 20; // 16 | CHAR_DIGITS /** * @const Flag for base64 symbols */ const CHAR_BASE64 = 39; // 32 | CHAR_ALNUM /** * @const Flag for additional symbols accessible via the keyboard */ const CHAR_SYMBOLS = 64; /** * @const Flag for brackets */ const CHAR_BRACKETS = 128; /** * @const Flag for punctuation marks */ const CHAR_PUNCT = 256; /** * @const Flag for upper/lower-case and digits but without "B8G6I1l|0OQDS5Z2" */ const EASY_TO_READ = 512; /** * @var Mixer The mixing strategy to use for this generator instance */ protected $mixer = null; /** * @var array An array of random number sources to use for this generator */ protected $sources = array(); /** * @var array The different characters, by Flag */ protected $charArrays = array( self::CHAR_UPPER => 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', self::CHAR_LOWER => 'abcdefghijklmnopqrstuvwxyz', self::CHAR_DIGITS => '0123456789', self::CHAR_UPPER_HEX => 'ABCDEF', self::CHAR_LOWER_HEX => 'abcdef', self::CHAR_BASE64 => '+/', self::CHAR_SYMBOLS => '!"#$%&\'()* +,-./:;<=>?@[\]^_`{|}~', self::CHAR_BRACKETS => '()[]{}<>', self::CHAR_PUNCT => ',.;:', ); /** * @internal * @private * @const string Ambiguous characters for "Easy To Read" sets */ const AMBIGUOUS_CHARS = 'B8G6I1l|0OQDS5Z2()[]{}:;,.'; /** * Build a new instance of the generator * * @param array $sources An array of random data sources to use * @param Mixer $mixer The mixing strategy to use for this generator */ public function __construct(array $sources, Mixer $mixer) { foreach ($sources as $source) { $this->addSource($source); } $this->mixer = $mixer; } /** * Add a random number source to the generator * * @param Source $source The random number source to add * * @return Generator $this The current generator instance */ public function addSource(Source $source) { $this->sources[] = $source; return $this; } /** * Generate a random number (string) of the requested size * * @param int $size The size of the requested random number * * @return string The generated random number (string) */ public function generate($size) { $seeds = array(); foreach ($this->sources as $source) { $seeds[] = $source->generate($size); } return $this->mixer->mix($seeds); } /** * Generate a random integer with the given range * * @param int $min The lower bound of the range to generate * @param int $max The upper bound of the range to generate * * @return int The generated random number within the range */ public function generateInt($min = 0, $max = PHP_INT_MAX) { $tmp = (int) max($max, $min); $min = (int) min($max, $min); $max = $tmp; $range = $max - $min; if ($range == 0) { return $max; } elseif ($range > PHP_INT_MAX || is_float($range) || $range < 0) { /** * This works, because PHP will auto-convert it to a float at this point, * But on 64 bit systems, the float won't have enough precision to * actually store the difference, so we need to check if it's a float * and hence auto-converted... */ throw new \RangeException( 'The supplied range is too great to generate' ); } $bits = $this->countBits($range) + 1; $bytes = (int) max(ceil($bits / 8), 1); if ($bits == 63) { /** * Fixes issue #22 * @see https://github.com/ircmaxell/RandomLib/issues/22 */ $mask = 0x7fffffffffffffff; } else { $mask = (int) (pow(2, $bits) - 1); } /** * The mask is a better way of dropping unused bits. Basically what it does * is to set all the bits in the mask to 1 that we may need. Since the max * range is PHP_INT_MAX, we will never need negative numbers (which would * have the MSB set on the max int possible to generate). Therefore we * can just mask that away. Since pow returns a float, we need to cast * it back to an int so the mask will work. * * On a 64 bit platform, that means that PHP_INT_MAX is 2^63 - 1. Which * is also the mask if 63 bits are needed (by the log(range, 2) call). * So if the computed result is negative (meaning the 64th bit is set), the * mask will correct that. * * This turns out to be slightly better than the shift as we don't need to * worry about "fixing" negative values. */ do { $test = $this->generate($bytes); $result = hexdec(bin2hex($test)) & $mask; } while ($result > $range); return $result + $min; } /** * Generate a random string of specified length. * * This uses the supplied character list for generating the new result * string. * * @param int $length The length of the generated string * @param mixed $characters String: An optional list of characters to use * Integer: Character flags * * @return string The generated random string */ public function generateString($length, $characters = '') { if (is_int($characters)) { // Combine character sets $characters = $this->expandCharacterSets($characters); } if ($length == 0 || strlen($characters) == 1) { return ''; } elseif (empty($characters)) { // Default to base 64 $characters = $this->expandCharacterSets(self::CHAR_BASE64); } // determine how many bytes to generate // This is basically doing floor(log(strlen($characters))) // But it's fixed to work properly for all numbers $len = strlen($characters); // The max call here fixes an issue where we under-generate in cases // where less than 8 bits are needed to represent $len $bytes = $length * ceil(($this->countBits($len)) / 8); // determine mask for valid characters $mask = 256 - (256 % $len); $result = ''; do { $rand = $this->generate($bytes); for ($i = 0; $i < $bytes; $i++) { if (ord($rand[$i]) >= $mask) { continue; } $result .= $characters[ord($rand[$i]) % $len]; } } while (strlen($result) < $length); // We may over-generate, since we always use the entire buffer return substr($result, 0, $length); } /** * Get the Mixer used for this instance * * @return Mixer the current mixer */ public function getMixer() { return $this->mixer; } /** * Get the Sources used for this instance * * @return Source[] the current mixer */ public function getSources() { return $this->sources; } /** * Count the minimum number of bits to represent the provided number * * This is basically floor(log($number, 2)) * But avoids float precision issues * * @param int $number The number to count * * @return int The number of bits */ protected function countBits($number) { $log2 = 0; while ($number >>= 1) { $log2++; } return $log2; } /** * Expand a character set bitwise spec into a string character set * * This will also replace EASY_TO_READ characters if the flag is set * * @param int $spec The spec to expand (bitwise combination of flags) * * @return string The expanded string */ protected function expandCharacterSets($spec) { $combined = ''; if ($spec == self::EASY_TO_READ) { $spec |= self::CHAR_ALNUM; } foreach ($this->charArrays as $flag => $chars) { if ($flag == self::EASY_TO_READ) { // handle this later continue; } if (($spec & $flag) === $flag) { $combined .= $chars; } } if ($spec & self::EASY_TO_READ) { // remove ambiguous characters $combined = str_replace(str_split(self::AMBIGUOUS_CHARS), '', $combined); } return count_chars($combined, 3); } } RandomLib-1.1.0/lib/RandomLib/Mixer.php000066400000000000000000000024731245576556100176200ustar00rootroot00000000000000 * @copyright 2011 The Authors * @license http://www.opensource.org/licenses/mit-license.html MIT License * @version Build @@version@@ */ namespace RandomLib; /** * The Mixer strategy interface. * * All mixing strategies must implement this interface * * @category PHPPasswordLib * @package Random * @author Anthony Ferrara * @codeCoverageIgnore */ interface Mixer { /** * Return an instance of Strength indicating the strength of the mixer * * @return Strength An instance of one of the strength classes */ public static function getStrength(); /** * Test to see if the mixer is available * * @return boolean If the mixer is available on the system */ public static function test(); /** * Mix the provided array of strings into a single output of the same size * * All elements of the array should be the same size. * * @param array $parts The parts to be mixed * * @return string The mixed result */ public function mix(array $parts); } RandomLib-1.1.0/lib/RandomLib/Mixer/000077500000000000000000000000001245576556100171015ustar00rootroot00000000000000RandomLib-1.1.0/lib/RandomLib/Mixer/Hash.php000066400000000000000000000051301245576556100204740ustar00rootroot00000000000000 * @copyright 2011 The Authors * @license http://www.opensource.org/licenses/mit-license.html MIT License * @version Build @@version@@ */ namespace RandomLib\Mixer; use \SecurityLib\Strength; /** * The Hash medium strength mixer class * * This class implements a mixer based upon the recommendations in RFC 4086 * section 5.2 * * @see http://tools.ietf.org/html/rfc4086#section-5.2 * @category PHPCryptLib * @package Random * @subpackage Mixer * @author Anthony Ferrara */ class Hash extends \RandomLib\AbstractMixer { /** * @var string The hash instance to use */ protected $hash = null; /** * Build the hash mixer * * @param string $hash The hash instance to use (defaults to sha512) * * @return void */ public function __construct($hash = 'sha512') { $this->hash = $hash; } /** * Return an instance of Strength indicating the strength of the source * * @return Strength An instance of one of the strength classes */ public static function getStrength() { return new Strength(Strength::MEDIUM); } /** * Test to see if the mixer is available * * @return boolean If the mixer is available on the system */ public static function test() { return true; } /** * Get the block size (the size of the individual blocks used for the mixing) * * @return int The block size */ protected function getPartSize() { return strlen(hash($this->hash, '', true)); } /** * Mix 2 parts together using one method * * @param string $part1 The first part to mix * @param string $part2 The second part to mix * * @return string The mixed data */ protected function mixParts1($part1, $part2) { return hash_hmac($this->hash, $part1, $part2, true); } /** * Mix 2 parts together using another different method * * @param string $part1 The first part to mix * @param string $part2 The second part to mix * * @return string The mixed data */ protected function mixParts2($part1, $part2) { return hash_hmac($this->hash, $part2, $part1, true); } } RandomLib-1.1.0/lib/RandomLib/Source.php000066400000000000000000000023461245576556100177730ustar00rootroot00000000000000 * @copyright 2011 The Authors * @license http://www.opensource.org/licenses/mit-license.html MIT License * @version Build @@version@@ */ namespace RandomLib; /** * The Random Number Source interface. * * All random number sources must implement this interface * * @category PHPPasswordLib * @package Random * @author Anthony Ferrara * @codeCoverageIgnore */ interface Source { /** * Return an instance of Strength indicating the strength of the source * * @return Strength An instance of one of the strength classes */ public static function getStrength(); /** * Generate a random string of the specified size * * Note: If the source fails to generate enough data, the result must be * padded to the requested length. * * @param int $size The size of the requested random string * * @return string A string of the requested size */ public function generate($size); } RandomLib-1.1.0/lib/RandomLib/Source/000077500000000000000000000000001245576556100172555ustar00rootroot00000000000000RandomLib-1.1.0/lib/RandomLib/Source/CAPICOM.php000066400000000000000000000032461245576556100210460ustar00rootroot00000000000000 * @copyright 2011 The Authors * @license http://www.opensource.org/licenses/mit-license.html MIT License * @version Build @@version@@ */ namespace RandomLib\Source; use SecurityLib\Strength; /** * The Capicom Random Number Source * * This uses the Windows CapiCom Com object to generate random numbers * * @category PHPCryptLib * @package Random * @subpackage Source * @author Anthony Ferrara * @codeCoverageIgnore */ class CAPICOM implements \RandomLib\Source { /** * Return an instance of Strength indicating the strength of the source * * @return Strength An instance of one of the strength classes */ public static function getStrength() { return new Strength(Strength::MEDIUM); } /** * Generate a random string of the specified size * * @param int $size The size of the requested random string * * @return string A string of the requested size */ public function generate($size) { if (!class_exists('\\COM', false)) { return str_repeat(chr(0), $size); } try { $util = new \COM('CAPICOM.Utilities.1'); $data = base64_decode($util->GetRandom($size, 0)); return str_pad($data, $size, chr(0)); } catch (\Exception $e) { unset($e); return str_repeat(chr(0), $size); } } } RandomLib-1.1.0/lib/RandomLib/Source/MTRand.php000066400000000000000000000035631245576556100211220ustar00rootroot00000000000000 * @copyright 2011 The Authors * @license http://www.opensource.org/licenses/mit-license.html MIT License * @version Build @@version@@ */ namespace RandomLib\Source; use SecurityLib\Strength; /** * The MTRand Random Number Source * * This source generates low strength random numbers by using the internal * mt_rand() function. By itself it is quite weak. However when combined with * other sources it does provide significant benefit. * * @category PHPCryptLib * @package Random * @subpackage Source * @author Anthony Ferrara * @codeCoverageIgnore */ class MTRand implements \RandomLib\Source { /** * Return an instance of Strength indicating the strength of the source * * @return Strength An instance of one of the strength classes */ public static function getStrength() { // Detect if Suhosin Hardened PHP patch is applied if (defined('S_ALL')) { return new Strength(Strength::MEDIUM); } else { return new Strength(Strength::LOW); } } /** * Generate a random string of the specified size * * @param int $size The size of the requested random string * * @return string A string of the requested size */ public function generate($size) { $result = ''; for ($i = 0; $i < $size; $i++) { $result .= chr((mt_rand() ^ mt_rand()) % 256); } return $result; } } RandomLib-1.1.0/lib/RandomLib/Source/MicroTime.php000066400000000000000000000077341245576556100216710ustar00rootroot00000000000000 * @copyright 2011 The Authors * @license http://www.opensource.org/licenses/mit-license.html MIT License * @version Build @@version@@ */ namespace RandomLib\Source; use SecurityLib\Strength; /** * The Microtime Random Number Source * * This uses the current micro-second (looped several times) for a **very** weak * random number source. This is only useful when combined with several other * stronger sources * * @category PHPCryptLib * @package Random * @subpackage Source * @author Anthony Ferrara * @codeCoverageIgnore */ final class MicroTime implements \RandomLib\Source { /** * A static counter to ensure unique hashes and prevent state collisions * @var int A counter */ private static $counter = null; /** * The current state of the random number generator. * @var string The state of the PRNG */ private static $state = ''; /** * Return an instance of Strength indicating the strength of the source * * @return Strength An instance of one of the strength classes */ public static function getStrength() { return new Strength(Strength::VERYLOW); } public function __construct() { $state = self::$state; if (function_exists('posix_times')) { $state .= serialize(posix_times()); } if (!defined('HHVM_VERSION') && function_exists('zend_thread_id')) { $state .= zend_thread_id(); } if (function_exists('hphp_get_thread_id')) { $state .= hphp_get_thread_id(); } $state .= getmypid() . memory_get_usage(); $state .= serialize($_ENV); $state .= serialize($_SERVER); $state .= count(debug_backtrace(false)); self::$state = hash('sha512', $state, true); if (is_null(self::$counter)) { list( , self::$counter) = unpack("i", substr(self::$state, 0, 4)); $seed = $this->generate(strlen(dechex(PHP_INT_MAX))); list( , self::$counter) = unpack("i", $seed); } } /** * Generate a random string of the specified size * * @param int $size The size of the requested random string * * @return string A string of the requested size */ public function generate($size) { $result = ''; $seed = microtime() . memory_get_usage(); self::$state = hash('sha512', self::$state . $seed, true); /** * Make the generated randomness a bit better by forcing a GC run which * should complete in a indeterminate amount of time, hence improving * the strength of the randomness a bit. It's still not crypto-safe, * but at least it's more difficult to predict. */ gc_collect_cycles(); for ($i = 0; $i < $size; $i += 8) { $seed = self::$state . microtime() . pack('Ni', $i, self::counter()); self::$state = hash('sha512', $seed, true); /** * We only use the first 8 bytes here to prevent exposing the state * in its entirety, which could potentially expose other random * generations in the future (in the same process)... */ $result .= substr(self::$state, 0, 8); } return substr($result, 0, $size); } private static function counter() { if (self::$counter >= PHP_INT_MAX) { self::$counter = -1 * PHP_INT_MAX - 1; } else { self::$counter++; } return self::$counter; } } RandomLib-1.1.0/lib/RandomLib/Source/OpenSSL.php000066400000000000000000000034021245576556100212500ustar00rootroot00000000000000 * @copyright 2011 The Authors * @license http://www.opensource.org/licenses/mit-license.html MIT License * @version Build @@version@@ */ namespace RandomLib\Source; use SecurityLib\Strength; /** * The OpenSSL Random Number Source * * This uses the OS's secure generator to generate high strength numbers * * @category PHPCryptLib * @package Random * @subpackage Source * @author Anthony Ferrara * @codeCoverageIgnore */ class OpenSSL implements \RandomLib\Source { /** * Return an instance of Strength indicating the strength of the source * * @return Strength An instance of one of the strength classes */ public static function getStrength() { return new Strength(Strength::HIGH); } /** * Generate a random string of the specified size * * @param int $size The size of the requested random string * * @return string A string of the requested size */ public function generate($size) { if (!function_exists('openssl_random_pseudo_bytes') || $size < 1) { return str_repeat(chr(0), $size); } /** * Note, normally we would check the return of of $crypto_strong to * ensure that we generated a good random string. However, since we're * using this as one part of many sources a low strength random number * shouldn't be much of an issue. */ return openssl_random_pseudo_bytes($size); } } RandomLib-1.1.0/lib/RandomLib/Source/Rand.php000066400000000000000000000035421245576556100206560ustar00rootroot00000000000000 * @copyright 2011 The Authors * @license http://www.opensource.org/licenses/mit-license.html MIT License * @version Build @@version@@ */ namespace RandomLib\Source; use SecurityLib\Strength; /** * The Rand Random Number Source * * This source generates low strength random numbers by using the internal * rand() function. By itself it is quite weak. However when combined with * other sources it does provide significant benefit. * * @category PHPCryptLib * @package Random * @subpackage Source * @author Anthony Ferrara * @codeCoverageIgnore */ class Rand implements \RandomLib\Source { /** * Return an instance of Strength indicating the strength of the source * * @return Strength An instance of one of the strength classes */ public static function getStrength() { // Detect if Suhosin Hardened PHP patch is applied if (defined('S_ALL')) { return new Strength(Strength::LOW); } else { return new Strength(Strength::VERYLOW); } } /** * Generate a random string of the specified size * * @param int $size The size of the requested random string * * @return string A string of the requested size */ public function generate($size) { $result = ''; for ($i = 0; $i < $size; $i++) { $result .= chr((rand() ^ rand()) % 256); } return $result; } } RandomLib-1.1.0/lib/RandomLib/Source/Random.php000066400000000000000000000021731245576556100212110ustar00rootroot00000000000000 * @copyright 2011 The Authors * @license http://www.opensource.org/licenses/mit-license.html MIT License * @version Build @@version@@ */ namespace RandomLib\Source; use SecurityLib\Strength; /** * The Random Random Number Source * * This uses the *nix /dev/random device to generate high strength numbers * * @category PHPCryptLib * @package Random * @subpackage Source * @author Anthony Ferrara * @codeCoverageIgnore */ class Random extends URandom { /** * @var string The file to read from */ protected $file = '/dev/random'; /** * Return an instance of Strength indicating the strength of the source * * @return Strength An instance of one of the strength classes */ public static function getStrength() { return new Strength(Strength::HIGH); } } RandomLib-1.1.0/lib/RandomLib/Source/URandom.php000066400000000000000000000034711245576556100213400ustar00rootroot00000000000000 * @copyright 2011 The Authors * @license http://www.opensource.org/licenses/mit-license.html MIT License * @version Build @@version@@ */ namespace RandomLib\Source; use SecurityLib\Strength; /** * The URandom Random Number Source * * This uses the *nix /dev/urandom device to generate medium strength numbers * * @category PHPCryptLib * @package Random * @subpackage Source * @author Anthony Ferrara * @codeCoverageIgnore */ class URandom implements \RandomLib\Source { /** * @var string The file to read from */ protected $file = '/dev/urandom'; /** * Return an instance of Strength indicating the strength of the source * * @return Strength An instance of one of the strength classes */ public static function getStrength() { return new Strength(Strength::MEDIUM); } /** * Generate a random string of the specified size * * @param int $size The size of the requested random string * * @return string A string of the requested size */ public function generate($size) { if ($size == 0 || !@file_exists($this->file)) { return str_repeat(chr(0), $size); } $file = fopen($this->file, 'rb'); if (!$file) { return str_repeat(chr(0), $size); } if (function_exists('stream_set_read_buffer')) { stream_set_read_buffer($file, 0); } $result = fread($file, $size); fclose($file); return $result; } } RandomLib-1.1.0/lib/RandomLib/Source/UniqID.php000066400000000000000000000027351245576556100211260ustar00rootroot00000000000000 * @copyright 2011 The Authors * @license http://www.opensource.org/licenses/mit-license.html MIT License * @version Build @@version@@ */ namespace RandomLib\Source; use SecurityLib\Strength; /** * The UniqID Random Number Source * * This uses the internal `uniqid()` function to generate low strength random * numbers. * * @category PHPCryptLib * @package Random * @subpackage Source * @author Anthony Ferrara * @codeCoverageIgnore */ class UniqID implements \RandomLib\Source { /** * Return an instance of Strength indicating the strength of the source * * @return Strength An instance of one of the strength classes */ public static function getStrength() { return new Strength(Strength::LOW); } /** * Generate a random string of the specified size * * @param int $size The size of the requested random string * * @return string A string of the requested size */ public function generate($size) { $result = ''; while (strlen($result) < $size) { $result = uniqid($result, true); } return substr($result, 0, $size); } } RandomLib-1.1.0/phpunit.xml.dist000066400000000000000000000016531245576556100165600ustar00rootroot00000000000000 test/Unit lib/ RandomLib-1.1.0/test/000077500000000000000000000000001245576556100143575ustar00rootroot00000000000000RandomLib-1.1.0/test/Mocks/000077500000000000000000000000001245576556100154335ustar00rootroot00000000000000RandomLib-1.1.0/test/Mocks/AbstractMock.php000066400000000000000000000017761245576556100205340ustar00rootroot00000000000000 * @copyright 2011 The Authors * @license http://opensource.org/licenses/bsd-license.php New BSD License * @license http://www.gnu.org/licenses/lgpl-2.1.html LGPL v 2.1 */ namespace RandomLibTest\Mocks; /** * The interface that all hash implementations must implement * * @category PHPPasswordLib * @package Hash * @author Anthony Ferrara */ class AbstractMock { protected $callbacks = array(); public static function init() {} public function __construct(array $callbacks = array()) { $this->callbacks = $callbacks; } public function __call($name, array $args = array()) { if (isset($this->callbacks[$name])) { return call_user_func_array($this->callbacks[$name], $args); } return null; } } RandomLib-1.1.0/test/Mocks/Random/000077500000000000000000000000001245576556100166535ustar00rootroot00000000000000RandomLib-1.1.0/test/Mocks/Random/Generator.php000066400000000000000000000031321245576556100213110ustar00rootroot00000000000000 * @copyright 2011 The Authors * @license http://opensource.org/licenses/bsd-license.php New BSD License * @license http://www.gnu.org/licenses/lgpl-2.1.html LGPL v 2.1 */ namespace RandomLibTest\Mocks\Random; /** * The Mixer strategy interface. * * All mixing strategies must implement this interface * * @category PHPPasswordLib * @package Random * @author Anthony Ferrara */ class Generator extends \RandomLib\Generator { protected $callbacks = array(); public static function init() {} public function __construct(array $callbacks = array()) { $this->callbacks = $callbacks; } public function __call($name, array $args = array()) { if (isset($this->callbacks[$name])) { return call_user_func_array($this->callbacks[$name], $args); } return null; } public function addSource(\PasswordLib\Random\Source $source) { return $this->__call('addSource', array($source)); } public function generate($size) { return $this->__call('generate', array($size)); } public function generateInt($min = 0, $max = \PHP_INT_MAX) { return $this->__call('generateInt', array($min, $max)); } public function generateString($length, $chars = '') { return $this->__call('generateString', array($length, $chars)); } } RandomLib-1.1.0/test/Mocks/Random/Mixer.php000066400000000000000000000034041245576556100204510ustar00rootroot00000000000000 * @copyright 2011 The Authors * @license http://opensource.org/licenses/bsd-license.php New BSD License * @license http://www.gnu.org/licenses/lgpl-2.1.html LGPL v 2.1 */ namespace RandomLibTest\Mocks\Random; use SecurityLib\Strength; /** * The Mixer strategy interface. * * All mixing strategies must implement this interface * * @category PHPPasswordLib * @package Random * @author Anthony Ferrara */ class Mixer extends \RandomLibTest\Mocks\AbstractMock implements \RandomLib\Mixer { public static $strength = null; public static $test = true; public static function init() { static::$strength = new Strength(Strength::HIGH); static::$test = true; } /** * Return an instance of Strength indicating the strength of the mixer * * @return Strength An instance of one of the strength classes */ public static function getStrength() { return static::$strength; } /** * Test to see if the mixer is available * * @return boolean If the mixer is available on the system */ public static function test() { return static::$test; } /** * Mix the provided array of strings into a single output of the same size * * All elements of the array should be the same size. * * @param array $parts The parts to be mixed * * @return string The mixed result */ public function mix(array $parts) { return $this->__call('mix', array($parts)); } } RandomLib-1.1.0/test/Mocks/Random/Source.php000066400000000000000000000031371245576556100206300ustar00rootroot00000000000000 * @copyright 2011 The Authors * @license http://opensource.org/licenses/bsd-license.php New BSD License * @license http://www.gnu.org/licenses/lgpl-2.1.html LGPL v 2.1 */ namespace RandomLibTest\Mocks\Random; use SecurityLib\Strength; /** * The Random Number Source interface. * * All random number sources must implement this interface * * @category PHPPasswordLib * @package Random * @author Anthony Ferrara */ class Source extends \RandomLibTest\Mocks\AbstractMock implements \RandomLib\Source { public static $strength = null; public static function init() { static::$strength = new Strength(Strength::VERYLOW); } /** * Return an instance of Strength indicating the strength of the source * * @return Strength An instance of one of the strength classes */ public static function getStrength() { return static::$strength; } /** * Generate a random string of the specified size * * Note: If the source fails to generate enough data, the result must be * padded to the requested length. * * @param int $size The size of the requested random string * * @return string A string of the requested size */ public function generate($size) { return $this->__call('generate', array($size)); } } RandomLib-1.1.0/test/Unit/000077500000000000000000000000001245576556100152765ustar00rootroot00000000000000RandomLib-1.1.0/test/Unit/RandomLib/000077500000000000000000000000001245576556100171455ustar00rootroot00000000000000RandomLib-1.1.0/test/Unit/RandomLib/FactoryTest.php000066400000000000000000000026411245576556100221300ustar00rootroot00000000000000assertTrue($factory instanceof Factory); } public function testGetGeneratorFallback() { $factory = new Factory; $generator = $factory->getGenerator(new Strength(Strength::VERYLOW)); $mixer = call_user_func(array( get_class($generator->getMixer()), 'getStrength' )); $this->assertTrue($mixer->compare(new Strength(Strength::LOW)) <= 0); } /** * @covers RandomLib\Factory::getMediumStrengthGenerator * @covers RandomLib\Factory::getGenerator * @covers RandomLib\Factory::findMixer */ public function testGetMediumStrengthGenerator() { $factory = new Factory; $generator = $factory->getMediumStrengthGenerator(); $this->assertTrue($generator instanceof Generator); $mixer = call_user_func(array( get_class($generator->getMixer()), 'getStrength' )); $this->assertTrue($mixer->compare(new Strength(Strength::MEDIUM)) <= 0); foreach ($generator->getSources() as $source) { $strength = call_user_func(array(get_class($source), 'getStrength')); $this->assertTrue($strength->compare(new Strength(Strength::MEDIUM)) >= 0); } } } RandomLib-1.1.0/test/Unit/RandomLib/GeneratorStringTest.php000066400000000000000000000066051245576556100236420ustar00rootroot00000000000000[]{}"), array("CHAR_SYMBOLS", " !\"#$%&'()*+,-./:;<=>?@[\]^_`{|}~"), array("CHAR_PUNCT", ",.:;"), array("CHAR_ALPHA", implode("", array_merge(range("A", "Z"), range("a", "z")))), array("CHAR_ALNUM", implode("", array_merge(range(0, 9), range("A", "Z"), range("a", "z")))), array("CHAR_ALPHA | PUNCT", ",.:;ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", Generator::CHAR_ALPHA | Generator::CHAR_PUNCT), array("CHAR_LOWER | EASY_TO_READ", "abcdefghijkmnopqrstuvwxyz", Generator::CHAR_LOWER | Generator::EASY_TO_READ), array("CHAR_DIGITS | EASY_TO_READ", "3479", Generator::CHAR_DIGITS | Generator::EASY_TO_READ), ); } public function setUp() { $source1 = $this->getMock('RandomLib\Source'); $source1->expects($this->any()) ->method('generate') ->will($this->returnCallback(function ($size) { $r = ''; for ($i = 0; $i < $size; $i++) { $r .= chr($i % 256); } return $r; } )); $source2 = $this->getMock('RandomLib\Source'); $source2->expects($this->any()) ->method('generate') ->will($this->returnCallback(function ($size) { $r = ''; for ($i = 0; $i < $size; $i++) { $r .= chr(0); } return $r; } )); $this->mixer = $this->getMock('RandomLib\Mixer'); $this->mixer->expects($this->any()) ->method('mix') ->will($this->returnCallback(function(array $sources) { if (empty($sources)) return ''; $start = array_pop($sources); return array_reduce( $sources, function($el1, $el2) { return $el1 ^ $el2; }, $start ); })); $this->sources = array($source1, $source2); $this->generator = new Generator($this->sources, $this->mixer); } /** * @dataProvider provideCharCombinations */ public function testScheme($schemeName, $expected, $scheme = 0) { // test for overspecification by doubling the expected amount if (!$scheme) { $scheme = constant("RandomLib\Generator::$schemeName"); } $chars = $this->generator->generateString(strlen($expected) * 2, $scheme); $this->assertEquals($expected . $expected, $chars, sprintf("Testing Generator::%s failed", $schemeName)); } } RandomLib-1.1.0/test/Unit/RandomLib/GeneratorTest.php000066400000000000000000000120341245576556100224440ustar00rootroot00000000000000getMock('RandomLib\Source'); $source1->expects($this->any()) ->method('generate') ->will($this->returnCallback(function ($size) { $r = ''; for ($i = 0; $i < $size; $i++) { $r .= chr($i); } return $r; } )); $source2 = $this->getMock('RandomLib\Source'); $source2->expects($this->any()) ->method('generate') ->will($this->returnCallback(function ($size) { $r = ''; for ($i = $size - 1; $i >= 0; $i--) { $r .= chr($i); } return $r; } )); $this->mixer = $this->getMock('RandomLib\Mixer'); $this->mixer->expects($this->any()) ->method('mix') ->will($this->returnCallback(function(array $sources) { if (empty($sources)) return ''; $start = array_pop($sources); return array_reduce( $sources, function($el1, $el2) { return $el1 ^ $el2; }, $start ); })); $this->sources = array($source1, $source2); $this->generator = new Generator($this->sources, $this->mixer); } public function testConstruct() { $this->assertTrue($this->generator instanceof Generator); } public function testGetMixer() { $this->assertSame($this->mixer, $this->generator->getMixer()); } public function testGetSources() { $this->assertSame($this->sources, $this->generator->getSources()); } /** * @dataProvider provideGenerate */ public function testGenerate($size, $expect) { $this->assertEquals($expect, $this->generator->generate($size)); } /** * @dataProvider provideGenerateInt */ public function testGenerateInt($min, $max, $expect) { $this->assertEquals($expect, $this->generator->generateInt($min, $max)); } /** * @dataProvider provideGenerateIntRangeTest */ public function testGenerateIntRange($min, $max) { $n = $this->generator->generateInt($min, $max); $this->assertTrue($min <= $n); $this->assertTrue($max >= $n); } /** * @expectedException RangeException */ public function testGenerateIntFail() { $n = $this->generator->generateInt(-1, PHP_INT_MAX); } /** */ public function testGenerateIntLargeTest() { $bits = 30; $expected = 50529027; if (PHP_INT_MAX > 4000000000) { $bits = 55; $expected = 1693273676973062; } $n = $this->generator->generateInt(0, (int) pow(2, $bits)); $this->assertEquals($expected, $n); } /** * @dataProvider provideGenerateStringTest */ public function testGenerateString($length, $chars, $expected) { $n = $this->generator->generateString($length, $chars); $this->assertEquals($expected, $n); } /** * This test checks for issue #22: * @see https://github.com/ircmaxell/RandomLib/issues/22 */ public function testGenerateLargeRange() { if (PHP_INT_MAX < pow(2, 32)) { $this->markTestSkipped("Only test on 64 bit platforms"); } $this->assertEquals(506381209866536711, $this->generator->generateInt(0, PHP_INT_MAX)); } } RandomLib-1.1.0/test/Unit/RandomLib/Mixer/000077500000000000000000000000001245576556100202315ustar00rootroot00000000000000RandomLib-1.1.0/test/Unit/RandomLib/Mixer/HashTest.php000077500000000000000000000025551245576556100224770ustar00rootroot00000000000000assertTrue($hash instanceof \RandomLib\Mixer); } public function testGetStrength() { $strength = new Strength(Strength::MEDIUM); $actual = Hash::getStrength(); $this->assertEquals($actual, $strength); } public function testTest() { $actual = Hash::test(); $this->assertTrue($actual); } /** * @dataProvider provideMix */ public function testMix($parts, $result) { $mixer = new Hash('md5'); $actual = $mixer->mix($parts); $this->assertEquals($result, bin2hex($actual)); } } RandomLib-1.1.0/test/Unit/RandomLib/Source/000077500000000000000000000000001245576556100204055ustar00rootroot00000000000000RandomLib-1.1.0/test/Unit/RandomLib/Source/CAPICOMTest.php000066400000000000000000000015031245576556100230300ustar00rootroot00000000000000 0 ? str_repeat(chr(0), $i) : chr(0); $data[] = array($i, $not); } return $data; } /** */ public function testGetStrength() { $strength = new Strength(Strength::MEDIUM); $actual = CAPICOM::getStrength(); $this->assertEquals($actual, $strength); } /** * @dataProvider provideGenerate * @group slow */ public function testGenerate($length, $not) { $rand = new CAPICOM; $stub = $rand->generate($length); $this->assertEquals($length, strlen($stub)); } } RandomLib-1.1.0/test/Unit/RandomLib/Source/MTRandTest.php000066400000000000000000000017171245576556100231110ustar00rootroot00000000000000 0 ? str_repeat(chr(0), $i) : chr(0); $data[] = array($i, $not); } return $data; } /** */ public function testGetStrength() { if (defined('S_ALL')) { $strength = new Strength(Strength::MEDIUM); } else { $strength = new Strength(Strength::LOW); } $actual = MTRand::getStrength(); $this->assertEquals($actual, $strength); } /** * @dataProvider provideGenerate */ public function testGenerate($length, $not) { $rand = new MTRand; $stub = $rand->generate($length); $this->assertEquals($length, strlen($stub)); $this->assertNotEquals($not, $stub); } } RandomLib-1.1.0/test/Unit/RandomLib/Source/MicroTimeTest.php000066400000000000000000000023111245576556100236430ustar00rootroot00000000000000 0 ? str_repeat(chr(0), $i) : chr(0); $data[] = array($i, $not); } return $data; } /** * Test the initialization of the static counter (!== 0) */ public function testCounterNotNull() { $rand = new MicroTime; $reflection_class = new \ReflectionClass("RandomLib\Source\MicroTime"); $static = $reflection_class->getStaticProperties(); $this->assertTrue($static['counter'] !== 0); } /** */ public function testGetStrength() { $strength = new Strength(Strength::VERYLOW); $actual = MicroTime::getStrength(); $this->assertEquals($actual, $strength); } /** * @dataProvider provideGenerate */ public function testGenerate($length, $not) { $rand = new MicroTime; $stub = $rand->generate($length); $this->assertEquals($length, strlen($stub)); $this->assertNotEquals($not, $stub); } } RandomLib-1.1.0/test/Unit/RandomLib/Source/RandTest.php000066400000000000000000000017101245576556100226410ustar00rootroot00000000000000 0 ? str_repeat(chr(0), $i) : chr(0); $data[] = array($i, $not); } return $data; } /** */ public function testGetStrength() { if (defined('S_ALL')) { $strength = new Strength(Strength::LOW); } else { $strength = new Strength(Strength::VERYLOW); } $actual = Rand::getStrength(); $this->assertEquals($actual, $strength); } /** * @dataProvider provideGenerate */ public function testGenerate($length, $not) { $rand = new Rand; $stub = $rand->generate($length); $this->assertEquals($length, strlen($stub)); $this->assertNotEquals($not, $stub); } } RandomLib-1.1.0/test/Unit/RandomLib/Source/URandomTest.php000066400000000000000000000017771245576556100233370ustar00rootroot00000000000000 0 ? str_repeat(chr(0), $i) : chr(0); $data[] = array($i, $not); } return $data; } /** */ public function testGetStrength() { $strength = new Strength(Strength::MEDIUM); $actual = URandom::getStrength(); $this->assertEquals($actual, $strength); } /** * @dataProvider provideGenerate * @group slow */ public function testGenerate($length, $not) { $rand = new URandom; $stub = $rand->generate($length); $this->assertEquals($length, strlen($stub)); if (file_exists('/dev/urandom')) { $this->assertNotEquals($not, $stub); } else { $this->assertEquals(str_repeat(chr(0), $length), $stub); } } } RandomLib-1.1.0/test/Unit/RandomLib/Source/UniqIDTest.php000066400000000000000000000015261245576556100231130ustar00rootroot00000000000000 0 ? str_repeat(chr(0), $i) : chr(0); $data[] = array($i, $not); } return $data; } /** */ public function testGetStrength() { $strength = new Strength(Strength::LOW); $actual = UniqID::getStrength(); $this->assertEquals($actual, $strength); } /** * @dataProvider provideGenerate */ public function testGenerate($length, $not) { $rand = new UniqID; $stub = $rand->generate($length); $this->assertEquals($length, strlen($stub)); $this->assertNotEquals($not, $stub); } } RandomLib-1.1.0/test/Vectors/000077500000000000000000000000001245576556100160045ustar00rootroot00000000000000RandomLib-1.1.0/test/Vectors/Random/000077500000000000000000000000001245576556100172245ustar00rootroot00000000000000RandomLib-1.1.0/test/Vectors/Random/GeneratorTest.php000066400000000000000000000127011245576556100225240ustar00rootroot00000000000000getLowStrengthGenerator(); $sources = $generator->getSources(); $ret = array(); $ret[] = array(new Generator($sources, new \RandomLib\Mixer\Hash), 10000, 'hash'); return $ret; } /** * This test asserts that the algorithm that generates the integers does not * actually introduce any bias into the generated numbers. If this test * passes, the generated integers from the generator will be as unbiased as * the sources that provide the data. * * @dataProvider provideGenerateInt */ public function testGenerateInt($min, $max, $offset = 0) { $generator = $this->getGenerator($max - $min + $offset); for ($i = $max; $i >= $min; $i--) { $this->assertEquals($i, $generator->generateInt($min, $max)); } } /** * This generator generates two bytes at a time, and uses each 8 bit segment of * the generated byte as a coordinate on a grid (so 01011010 would be the * coordinate (0101, 1010) or (5, 10). These are used as inputs to a MonteCarlo * algorithm for the integral of y=x over a 15x15 grid. The expected answer is * 1/2 * 15 * 15 (or 1/2 * base * height, since the result is a triangle). * Therefore, if we get an answer close to that, we know the generator is good. * * Now, since the area under the line should be equal to the area above the line. * Therefore, the ratio of the two areas should be equal. This way, we can avoid * computing total to figure out the areas. * * I have set the bounds on the test to be 80% and 120%. Meaning that I will * consider the test valid and unbiased if the number of random elements that * fall under (inside) of the line and the number that fall outside of the line * are at most 20% apart. * * Since testing randomness is not reliable or repeatable, I will only fail the * test in two different scenarios. The first is if after the iterations the * outside or the inside is 0. The chances of that happening are so low that * if it happens, it's relatively safe to assume that something bad happened. The * second scenario happens when the ratio is outside of the 20% tolerance. If * that happens, I will re-run the entire test. If that test is outside of the 20% * tolerance, then the test will fail * * * @dataProvider provideGenerators */ public function testGenerate(\RandomLib\Generator $generator, $times) { $ratio = $this->doTestGenerate($generator, $times); if ($ratio < 0.8 || $ratio > 1.2) { $ratio2 = $this->doTestGenerate($generator, $times); if ($ratio2 > 1.2 || $ratio2 < 0.8) { $this->fail( sprintf( 'The test failed multiple runs with final ratios %f and %f', $ratio, $ratio2 ) ); } } } protected function doTestGenerate(\RandomLib\Generator $generator, $times) { $inside = 0; $outside = 0; $on = 0; for ($i = 0; $i < $times; $i++) { $byte = $generator->generate(2); $byte = unpack('n', $byte); $byte = array_shift($byte); $xCoord = ($byte >> 8); $yCoord = ($byte & 0xFF); if ($xCoord < $yCoord) { $outside++; } elseif ($xCoord == $yCoord) { $on++; } else { $inside++; } } $this->assertGreaterThan(0, $outside, 'Outside Is 0'); $this->assertGreaterThan(0, $inside, 'Inside Is 0'); $ratio = $inside / $outside; return $ratio; } public function getGenerator($random) { $source1 = new Source(array( 'generate' => function ($size) use (&$random) { $ret = pack('N', $random); $random--; return substr($ret, -1 * $size); } )); $sources = array($source1); $mixer = new Mixer(array( 'mix'=> function(array $sources) { if (empty($sources)) return ''; return array_pop($sources); } )); return new Generator($sources, $mixer); } } RandomLib-1.1.0/test/bootstrap.php000066400000000000000000000024501245576556100171060ustar00rootroot00000000000000 * @copyright 2011 The Authors * @license http://opensource.org/licenses/bsd-license.php New BSD License * @license http://www.gnu.org/licenses/lgpl-2.1.html LGPL v 2.1 */ namespace RandomLibTest; ini_set('memory_limit', '1G'); /** * The simple autoloader for the PasswordLibTest libraries. * * This does not use the PRS-0 standards due to the namespace prefix and directory * structure * * @param string $class The class name to load * * @return void */ spl_autoload_register(function ($class) { $nslen = strlen(__NAMESPACE__); if (substr($class, 0, $nslen) != __NAMESPACE__) { //Only autoload libraries from this package return; } $path = substr(str_replace('\\', '/', $class), $nslen); $path = __DIR__ . $path . '.php'; if (file_exists($path)) { require $path; } }); define('PATH_ROOT', dirname(__DIR__)); require_once dirname(__DIR__) . '/vendor/autoload.php';