PHP Factory::getMediumStrengthGenerator方法代碼示例

 /**
  * Generate a medium-strength random string of the given length.
  *
  * @param int $length length of the generated string
  * @param string $characters characters to use to generate the string
  * @return string
  */
 public function generateString($length, $characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ')
 {
     if (is_null($this->_factory)) {
         $this->_factory = new \RandomLib\Factory();
         $this->_generator = $this->_factory->getMediumStrengthGenerator();
     }
     return $this->_generator->generateString($length, $characters);
 }

 public function getGenerator($strength)
 {
     switch ($strength) {
         case 'low':
             return $this->factory->getLowStrengthGenerator();
         case 'medium':
             return $this->factory->getMediumStrengthGenerator();
         case 'high':
             throw new \InvalidArgumentException('"high" strength is currently unavailable');
         default:
             throw new \InvalidArgumentException('Could not find a generator for the specified strength');
     }
 }

 /**
  * Create a medium strength key
  *
  * Generates a medium strength random number of size $bytes and hash with the
  * algorithm specified in $hash.
  *
  * @param string  $hash  hash function to use
  * @param integer $bytes the number of random bytes to generate
  *
  * @return string hashed token
  */
 public static function generateKey($hash = 'sha512', $bytes = 128)
 {
     $factory = new Factory();
     $generator = $factory->getMediumStrengthGenerator();
     $token = hash($hash, $generator->generate($bytes));
     return $token;
 }

 /**
  * @param Request $request
  *
  * @return \Symfony\Component\HttpFoundation\JsonResponse
  */
 public function saveTokenAction(Request $request)
 {
     $apiToken = new ApiToken();
     $apiToken->setUser($this->getUser());
     $formBuilder = $this->createFormBuilder($apiToken, array('action' => $this->generateUrl('api_key_create'), 'data_class' => 'CSBill\\UserBundle\\Entity\\ApiToken'));
     $formBuilder->add('name');
     $form = $formBuilder->getForm();
     $form->handleRequest($request);
     $response = array();
     if ($form->isValid()) {
         $factory = new Factory();
         $generator = $factory->getMediumStrengthGenerator();
         $token = $generator->generateString(64, Generator::CHAR_ALNUM);
         $apiToken->setToken($token);
         $this->save($apiToken);
         $response['status'] = 0;
         $response['token'] = array('token' => $apiToken->getToken(), 'name' => $apiToken->getName(), 'id' => $apiToken->getId());
         return $this->json($response);
     } else {
         $response['status'] = 1;
     }
     $content = $this->renderView('CSBillUserBundle:Api:create.html.twig', array('form' => $form->createView()));
     $response['content'] = $content;
     return $this->json($response);
 }

 function let(Factory $factory, Generator $low, Generator $medium)
 {
     $factory->getMediumStrengthGenerator()->willReturn($medium);
     $factory->getLowStrengthGenerator()->willReturn($low);
     $this->beConstructedWith($factory);
     $defaults = ['length' => 32, 'chars' => '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', 'strength' => 'medium'];
     $this->setOptions($defaults);
 }

 public function testGetSetKeyGenerator()
 {
     $this->assertInstanceOf('QueryAuth\\KeyGenerator', $this->requestSigner->getKeyGenerator());
     $randomFactory = new RandomFactory();
     $keyGenerator = new KeyGenerator($randomFactory->getMediumStrengthGenerator());
     $this->requestSigner->setKeyGenerator($keyGenerator);
     $this->assertSame($keyGenerator, $this->requestSigner->getKeyGenerator());
 }

 public function __construct(Generator $generator = null)
 {
     $this->generator = $generator;
     if ($this->generator == null) {
         $factory = new Factory();
         $this->generator = $factory->getMediumStrengthGenerator();
     }
 }

 /**
  * Generates a random number in the provided range, where all possible values are equally likely. (Even distribution.)
  *
  * NOTE: If $max is more than PHP_INT_MAX or $min is less than PHP_INT_MIN, no additional entropy will be gained for
  * the random number, and the distribution will become less evenly distributed across all possible values due to
  * rounding.
  *
  * @param $min
  * @param $max
  * @return NumberInterface
  */
 public function random($min = 0, $max = PHP_INT_MAX)
 {
     $min = Numbers::makeOrDont(Numbers::IMMUTABLE, $min);
     $max = Numbers::makeOrDont(Numbers::IMMUTABLE, $max);
     $difference = new ImmutableNumber(BCProvider::add($max->absValue(), $min->absValue()));
     $randFactory = new Factory();
     if ($max->compare(PHP_INT_MAX) != 1 && $min->compare(PHP_INT_MIN) != -1 && $difference->compare(PHP_INT_MAX) != 1) {
         $x = $randFactory->getMediumStrengthGenerator()->generateInt($min, $max);
         return Numbers::makeFromBase10($this->numberType, $x, null, $this->contextBase);
     } else {
         $x = $randFactory->getMediumStrengthGenerator()->generateInt();
         $fraction = BCProvider::divide($x, PHP_INT_MAX);
         $addedValue = BCProvider::multiply($fraction, $difference->getValue());
         $randVal = Numbers::makeFromBase10($this->numberType, BCProvider::add($min->getValue(), $addedValue), null, $this->contextBase);
         return $randVal->round();
     }
 }

 function __construct()
 {
     parent::__construct();
     $factory = new RandomLib();
     $this->RandomLib = $factory->getMediumStrengthGenerator();
     $this->load->module('template');
     $this->load->module('categories');
 }

 public static function generateLink($event)
 {
     $model = $event->getModel();
     if (!$model->link) {
         $factory = new Factory();
         $generator = $factory->getMediumStrengthGenerator();
         $model->link = $generator->generateString(32, Generator::CHAR_ALNUM);
     }
 }

 public function getAlternativeGenerator()
 {
     if (isset($this->generator)) {
         return $this->generator;
     }
     $factory = new RandomLib\Factory();
     $this->generator = $factory->getMediumStrengthGenerator();
     return $this->generator;
 }

 public function getAlternativeGenerator()
 {
     if (isset($this->generator)) {
         return $this->generator;
     }
     $factory = new RandomLib\Factory();
     $factory->registerSource('HashTiming', '\\SecurityMultiTool\\Random\\Source\\HashTiming');
     $this->generator = $factory->getMediumStrengthGenerator();
     return $this->generator;
 }

 /**
  * @covers RandomLib\Factory::getMediumStrengthGenerator
  * @covers RandomLib\Factory::getGenerator
  * @covers RandomLib\Factory::findMixer
  * @covers RandomLib\Factory::findSources
  */
 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);
     }
 }

 /**
  * Retrieve a fallback/alternative RNG generator
  *
  * @return RandomLib\Generator
  */
 public static function getAlternativeGenerator()
 {
     if (null !== static::$generator) {
         return static::$generator;
     }
     if (!class_exists('RandomLib\\Factory')) {
         throw new Exception\RuntimeException('The RandomLib fallback pseudorandom number generator (PRNG) ' . ' must be installed in the absence of the OpenSSL and ' . 'Mcrypt extensions');
     }
     $factory = new RandomLib\Factory();
     $factory->registerSource('HashTiming', 'Zend\\Math\\Source\\HashTiming');
     static::$generator = $factory->getMediumStrengthGenerator();
     return static::$generator;
 }

 public function login(Request $request, Response $response, array $arguments)
 {
     $body = $request->getParsedBody();
     $user = User::where('email', $body['email'])->first();
     if (!$user) {
         return $response->withJson(['message' => 'no_such_email'], 400);
     }
     if (!password_verify($body['password'], $user->password)) {
         return $response->withJson(['message' => 'incorrect_password'], 400);
     }
     $factory = new Factory();
     $generator = $factory->getMediumStrengthGenerator();
     $tokenValue = $generator->generateString(128, Generator::CHAR_ALNUM);
     $token = new UserToken();
     $token->value = $tokenValue;
     $user->user_tokens()->save($token);
     $output = ['user' => $user, 'token' => $token->value];
     return $response->withJson($output, 200);
 }