PHP Random::string方法代码示例

 public function addAuthHeaders(BeforeEvent $event)
 {
     /*
      * Get Consumer ID and Private Key from auth and then unset it
      */
     $auth = $event->getClient()->getDefaultOption('auth');
     if ($auth === null) {
         throw new \Exception('Http client is missing \'auth\' parameters', 1466965269);
     }
     $consumerId = $auth[0];
     $privateKey = $auth[1];
     $event->getClient()->setDefaultOption('auth', null);
     /*
      * Get Request URL, method, and timestamp to calculate signature
      */
     $requestUrl = $event->getRequest()->getUrl();
     //decode url back to normal to nextCursor issue. automatic url encoding
     $requestUrl = rawurldecode($requestUrl);
     $event->getRequest()->setUrl($requestUrl);
     $requestMethod = $event->getRequest()->getMethod();
     $timestamp = Utils::getMilliseconds();
     $signature = Signature::calculateSignature($consumerId, $privateKey, $requestUrl, $requestMethod, $timestamp);
     /*
      * Add required headers to request
      */
     $headers = ['WM_SVC.NAME' => 'Walmart Marketplace', 'WM_QOS.CORRELATION_ID' => base64_encode(Random::string(16)), 'WM_SEC.TIMESTAMP' => $timestamp, 'WM_SEC.AUTH_SIGNATURE' => $signature, 'WM_CONSUMER.ID' => $consumerId];
     $currentHeaders = $event->getRequest()->getHeaders();
     unset($currentHeaders['Authorization']);
     $updatedHeaders = array_merge($currentHeaders, $headers);
     $event->getRequest()->setHeaders($updatedHeaders);
 }

 public static function encrypt($encryptionKey, $textInput, $blockType = 'CBC', $urlSafe = false)
 {
     switch ($blockType) {
         case 'CBC':
             $cipher = new Rijndael(Rijndael::MODE_CBC);
             $cipher->setKey($encryptionKey);
             $iv = Random::string($cipher->getBlockLength() >> 3);
             $cipher->setIV($iv);
             break;
         case 'ECB':
             $cipher = new Rijndael(Rijndael::MODE_ECB);
             $cipher->setKey($encryptionKey);
             $iv = '';
             break;
         default:
             throw new \Exception('Unknown encryption blocktype: ' . $blockType, 500);
             break;
     }
     $encryptedResult = $iv . $cipher->encrypt($textInput);
     if ($urlSafe) {
         return Base64URLSafe::urlsafe_b64encode($encryptedResult);
     } else {
         return base64_encode($encryptedResult);
     }
 }

 function testEncryptDir_A128CBCHS256()
 {
     $secret = Random::string(256 / 8);
     $jwe = new JOSE_JWE($this->plain_text);
     $jwe = $jwe->encrypt($secret, 'dir');
     $jwe_decoded = JOSE_JWT::decode($jwe->toString());
     $this->assertEquals($this->plain_text, $jwe_decoded->decrypt($secret)->plain_text);
 }

 /**
  * Takes a set of random values of length 128 bits and asserts all taken
  * values are unique.
  */
 public function testStringUniqueness()
 {
     $values = array();
     for ($i = 0; $i < 10000; ++$i) {
         $rand = Random::string(16);
         $this->assertSame(16, strlen($rand));
         $this->assertArrayNotHasKey($rand, $values, 'Failed asserting that generated value does not exist in set.');
         $values[$rand] = true;
     }
 }

 /**
  * Execute the console command.
  *
  * @return mixed
  */
 public function handle()
 {
     $maxInt = 2147483647;
     $min = new BigInteger(10000000.0);
     $max = new BigInteger($maxInt);
     $prime = $max->randomPrime($min, $max);
     $a = new BigInteger($prime);
     $b = new BigInteger($maxInt + 1);
     if (!($inverse = $a->modInverse($b))) {
         $this->error("An error accured during calculation. Please re-run 'php artisan rocid:generate'.");
         return;
     }
     $random = hexdec(bin2hex(Random::string(4))) & $maxInt;
     $this->info("Generated numbers (Paste these in config/rockid.php) :\nprime: {$prime}\ninverse: {$inverse}\nrandom: {$random}");
 }

 /**
  * Convert a private key to the appropriate format.
  *
  * @access public
  * @param \phpseclib\Math\BigInteger $n
  * @param \phpseclib\Math\BigInteger $e
  * @param \phpseclib\Math\BigInteger $d
  * @param array $primes
  * @param array $exponents
  * @param array $coefficients
  * @param string $password optional
  * @return string
  */
 static function savePrivateKey(BigInteger $n, BigInteger $e, BigInteger $d, $primes, $exponents, $coefficients, $password = '')
 {
     $num_primes = count($primes);
     $raw = array('version' => $num_primes == 2 ? chr(0) : chr(1), 'modulus' => $n->toBytes(true), 'publicExponent' => $e->toBytes(true), 'privateExponent' => $d->toBytes(true), 'prime1' => $primes[1]->toBytes(true), 'prime2' => $primes[2]->toBytes(true), 'exponent1' => $exponents[1]->toBytes(true), 'exponent2' => $exponents[2]->toBytes(true), 'coefficient' => $coefficients[2]->toBytes(true));
     $components = array();
     foreach ($raw as $name => $value) {
         $components[$name] = pack('Ca*a*', self::ASN1_INTEGER, self::_encodeLength(strlen($value)), $value);
     }
     $RSAPrivateKey = implode('', $components);
     if ($num_primes > 2) {
         $OtherPrimeInfos = '';
         for ($i = 3; $i <= $num_primes; $i++) {
             // OtherPrimeInfos ::= SEQUENCE SIZE(1..MAX) OF OtherPrimeInfo
             //
             // OtherPrimeInfo ::= SEQUENCE {
             //     prime             INTEGER,  -- ri
             //     exponent          INTEGER,  -- di
             //     coefficient       INTEGER   -- ti
             // }
             $OtherPrimeInfo = pack('Ca*a*', self::ASN1_INTEGER, self::_encodeLength(strlen($primes[$i]->toBytes(true))), $primes[$i]->toBytes(true));
             $OtherPrimeInfo .= pack('Ca*a*', self::ASN1_INTEGER, self::_encodeLength(strlen($exponents[$i]->toBytes(true))), $exponents[$i]->toBytes(true));
             $OtherPrimeInfo .= pack('Ca*a*', self::ASN1_INTEGER, self::_encodeLength(strlen($coefficients[$i]->toBytes(true))), $coefficients[$i]->toBytes(true));
             $OtherPrimeInfos .= pack('Ca*a*', self::ASN1_SEQUENCE, self::_encodeLength(strlen($OtherPrimeInfo)), $OtherPrimeInfo);
         }
         $RSAPrivateKey .= pack('Ca*a*', self::ASN1_SEQUENCE, self::_encodeLength(strlen($OtherPrimeInfos)), $OtherPrimeInfos);
     }
     $RSAPrivateKey = pack('Ca*a*', self::ASN1_SEQUENCE, self::_encodeLength(strlen($RSAPrivateKey)), $RSAPrivateKey);
     $rsaOID = Hex::decode('300d06092a864886f70d0101010500');
     // hex version of MA0GCSqGSIb3DQEBAQUA
     $RSAPrivateKey = pack('Ca*a*Ca*a*', self::ASN1_INTEGER, "", $rsaOID, 4, self::_encodeLength(strlen($RSAPrivateKey)), $RSAPrivateKey);
     $RSAPrivateKey = pack('Ca*a*', self::ASN1_SEQUENCE, self::_encodeLength(strlen($RSAPrivateKey)), $RSAPrivateKey);
     if (!empty($password) || is_string($password)) {
         $salt = Random::string(8);
         $iterationCount = 2048;
         $crypto = new DES(DES::MODE_CBC);
         $crypto->setPassword($password, 'pbkdf1', 'md5', $salt, $iterationCount);
         $RSAPrivateKey = $crypto->encrypt($RSAPrivateKey);
         $parameters = pack('Ca*a*Ca*N', self::ASN1_OCTETSTRING, self::_encodeLength(strlen($salt)), $salt, self::ASN1_INTEGER, self::_encodeLength(4), $iterationCount);
         $pbeWithMD5AndDES_CBC = "*†H†÷\r";
         $encryptionAlgorithm = pack('Ca*a*Ca*a*', self::ASN1_OBJECT, self::_encodeLength(strlen($pbeWithMD5AndDES_CBC)), $pbeWithMD5AndDES_CBC, self::ASN1_SEQUENCE, self::_encodeLength(strlen($parameters)), $parameters);
         $RSAPrivateKey = pack('Ca*a*Ca*a*', self::ASN1_SEQUENCE, self::_encodeLength(strlen($encryptionAlgorithm)), $encryptionAlgorithm, self::ASN1_OCTETSTRING, self::_encodeLength(strlen($RSAPrivateKey)), $RSAPrivateKey);
         $RSAPrivateKey = pack('Ca*a*', self::ASN1_SEQUENCE, self::_encodeLength(strlen($RSAPrivateKey)), $RSAPrivateKey);
         $RSAPrivateKey = "-----BEGIN ENCRYPTED PRIVATE KEY-----\r\n" . chunk_split(Base64::encode($RSAPrivateKey), 64) . '-----END ENCRYPTED PRIVATE KEY-----';
     } else {
         $RSAPrivateKey = "-----BEGIN PRIVATE KEY-----\r\n" . chunk_split(Base64::encode($RSAPrivateKey), 64) . '-----END PRIVATE KEY-----';
     }
     return $RSAPrivateKey;
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $prime = $input->getArgument('prime');
     // Calculate the inverse.
     $a = new BigInteger($prime);
     $b = new BigInteger(Optimus::MAX_INT + 1);
     if (!($inverse = $a->modInverse($b))) {
         $output->writeln('<error>Invalid prime number</>');
         return;
     }
     $rand = hexdec(bin2hex(Random::string(4))) & Optimus::MAX_INT;
     $output->writeln('Prime: ' . $prime);
     $output->writeln('Inverse: ' . $inverse);
     $output->writeln('Random: ' . $rand);
     $output->writeln('');
     $output->writeln('    new Optimus(' . $prime . ', ' . $inverse . ', ' . $rand . ');');
 }

 public static function encrypt($passphrases_and_keys, $message, $symmetric_algorithm = 9)
 {
     list($cipher, $key_bytes, $key_block_bytes) = self::getCipher($symmetric_algorithm);
     if (!$cipher) {
         throw new Exception("Unsupported cipher");
     }
     $prefix = Random::string($key_block_bytes);
     $prefix .= substr($prefix, -2);
     $key = Random::string($key_bytes);
     $cipher->setKey($key);
     $to_encrypt = $prefix . $message->to_bytes();
     $mdc = new OpenPGP_ModificationDetectionCodePacket(hash('sha1', $to_encrypt . "Ó", true));
     $to_encrypt .= $mdc->to_bytes();
     $encrypted = array(new OpenPGP_IntegrityProtectedDataPacket($cipher->encrypt($to_encrypt)));
     if (!is_array($passphrases_and_keys) && !$passphrases_and_keys instanceof IteratorAggregate) {
         $passphrases_and_keys = (array) $passphrases_and_keys;
     }
     foreach ($passphrases_and_keys as $pass) {
         if ($pass instanceof OpenPGP_PublicKeyPacket) {
             if (!in_array($pass->algorithm, array(1, 2, 3))) {
                 throw new Exception("Only RSA keys are supported.");
             }
             $crypt_rsa = new OpenPGP_Crypt_RSA($pass);
             $rsa = $crypt_rsa->public_key();
             $rsa->setEncryptionMode(CRYPT_RSA_ENCRYPTION_PKCS1);
             $esk = $rsa->encrypt(chr($symmetric_algorithm) . $key . pack('n', self::checksum($key)));
             $esk = pack('n', OpenPGP::bitlength($esk)) . $esk;
             array_unshift($encrypted, new OpenPGP_AsymmetricSessionKeyPacket($pass->algorithm, $pass->fingerprint(), $esk));
         } else {
             if (is_string($pass)) {
                 $s2k = new OpenPGP_S2K(Random::string(10));
                 $cipher->setKey($s2k->make_key($pass, $key_bytes));
                 $esk = $cipher->encrypt(chr($symmetric_algorithm) . $key);
                 array_unshift($encrypted, new OpenPGP_SymmetricSessionKeyPacket($s2k, $esk, $symmetric_algorithm));
             }
         }
     }
     return new OpenPGP_Message($encrypted);
 }

 /**
  * Convert a private key to the appropriate format.
  *
  * @access public
  * @param \phpseclib\Math\BigInteger $n
  * @param \phpseclib\Math\BigInteger $e
  * @param \phpseclib\Math\BigInteger $d
  * @param array $primes
  * @param array $exponents
  * @param array $coefficients
  * @param string $password optional
  * @return string
  */
 static function savePrivateKey(BigInteger $n, BigInteger $e, BigInteger $d, $primes, $exponents, $coefficients, $password = '')
 {
     $num_primes = count($primes);
     $raw = array('version' => $num_primes == 2 ? chr(0) : chr(1), 'modulus' => $n->toBytes(true), 'publicExponent' => $e->toBytes(true), 'privateExponent' => $d->toBytes(true), 'prime1' => $primes[1]->toBytes(true), 'prime2' => $primes[2]->toBytes(true), 'exponent1' => $exponents[1]->toBytes(true), 'exponent2' => $exponents[2]->toBytes(true), 'coefficient' => $coefficients[2]->toBytes(true));
     $components = array();
     foreach ($raw as $name => $value) {
         $components[$name] = pack('Ca*a*', self::ASN1_INTEGER, self::_encodeLength(strlen($value)), $value);
     }
     $RSAPrivateKey = implode('', $components);
     if ($num_primes > 2) {
         $OtherPrimeInfos = '';
         for ($i = 3; $i <= $num_primes; $i++) {
             // OtherPrimeInfos ::= SEQUENCE SIZE(1..MAX) OF OtherPrimeInfo
             //
             // OtherPrimeInfo ::= SEQUENCE {
             //     prime             INTEGER,  -- ri
             //     exponent          INTEGER,  -- di
             //     coefficient       INTEGER   -- ti
             // }
             $OtherPrimeInfo = pack('Ca*a*', self::ASN1_INTEGER, self::_encodeLength(strlen($primes[$i]->toBytes(true))), $primes[$i]->toBytes(true));
             $OtherPrimeInfo .= pack('Ca*a*', self::ASN1_INTEGER, self::_encodeLength(strlen($exponents[$i]->toBytes(true))), $exponents[$i]->toBytes(true));
             $OtherPrimeInfo .= pack('Ca*a*', self::ASN1_INTEGER, self::_encodeLength(strlen($coefficients[$i]->toBytes(true))), $coefficients[$i]->toBytes(true));
             $OtherPrimeInfos .= pack('Ca*a*', self::ASN1_SEQUENCE, self::_encodeLength(strlen($OtherPrimeInfo)), $OtherPrimeInfo);
         }
         $RSAPrivateKey .= pack('Ca*a*', self::ASN1_SEQUENCE, self::_encodeLength(strlen($OtherPrimeInfos)), $OtherPrimeInfos);
     }
     $RSAPrivateKey = pack('Ca*a*', self::ASN1_SEQUENCE, self::_encodeLength(strlen($RSAPrivateKey)), $RSAPrivateKey);
     if (!empty($password) || is_string($password)) {
         $cipher = self::getEncryptionObject(self::$defaultEncryptionAlgorithm);
         $iv = Random::string($cipher->getBlockLength() >> 3);
         $cipher->setKey(self::generateSymmetricKey($password, $iv, $cipher->getKeyLength()));
         $cipher->setIV($iv);
         $iv = strtoupper(bin2hex($iv));
         $RSAPrivateKey = "-----BEGIN RSA PRIVATE KEY-----\r\n" . "Proc-Type: 4,ENCRYPTED\r\n" . "DEK-Info: " . self::$defaultEncryptionAlgorithm . ",{$iv}\r\n" . "\r\n" . chunk_split(base64_encode($cipher->encrypt($RSAPrivateKey)), 64) . '-----END RSA PRIVATE KEY-----';
     } else {
         $RSAPrivateKey = "-----BEGIN RSA PRIVATE KEY-----\r\n" . chunk_split(base64_encode($RSAPrivateKey), 64) . '-----END RSA PRIVATE KEY-----';
     }
     return $RSAPrivateKey;
 }

 /**
  * Initialization
  * Store the initialization vector because it will be needed for
  * further decryption. I don't think necessary to have one iv
  * per server so I don't put the server number in the cookie name.
  *
  * @return void
  */
 public function createIV()
 {
     /* Testsuite shortcut only to allow predictable IV */
     if (!is_null($this->_cookie_iv)) {
         return $this->_cookie_iv;
     }
     if (self::useOpenSSL()) {
         return openssl_random_pseudo_bytes($this->getIVSize());
     } else {
         return Crypt\Random::string($this->getIVSize());
     }
 }

 /**
  * Initialization
  * Store the initialization vector because it will be needed for
  * further decryption. I don't think necessary to have one iv
  * per server so I don't put the server number in the cookie name.
  *
  * @return void
  */
 public function createIV()
 {
     if (self::useOpenSSL()) {
         $this->_cookie_iv = openssl_random_pseudo_bytes($this->getIVSize());
     } else {
         $this->_cookie_iv = Crypt\Random::string($this->getIVSize());
     }
     $GLOBALS['PMA_Config']->setCookie('pma_iv-' . $GLOBALS['server'], base64_encode($this->_cookie_iv));
 }

 private function generateRandomBytes($length)
 {
     return Random::string($length);
 }

 /**
  * @param RedisMailJob|MailJobInterface $mailJob
  *
  * @return string
  */
 protected function createPayload(MailJobInterface $mailJob)
 {
     return json_encode(['id' => $mailJob->isNewRecord() ? sha1(Random::string(32)) : $mailJob->getId(), 'attempt' => $mailJob->getAttempt(), 'message' => $mailJob->getMessage()]);
 }

 /**
  * @param int $length
  *
  * @throws \Exception
  *
  * @return string
  */
 private function generateRandomString($length)
 {
     if (function_exists('random_bytes')) {
         return random_bytes($length);
     } elseif (function_exists('mcrypt_create_iv')) {
         return mcrypt_create_iv($length);
     } elseif (function_exists('openssl_random_pseudo_bytes')) {
         return openssl_random_pseudo_bytes($length);
     } elseif (class_exists('\\phpseclib\\Crypt\\Random')) {
         return \phpseclib\Crypt\Random::string($length);
     } else {
         throw new \Exception('Unable to create a random string');
     }
 }

 /**
  * Wrap a private key appropriately
  *
  * @access public
  * @param string $key
  * @param string $type
  * @param string $password
  * @return string
  */
 static function wrapPrivateKey($key, $type, $password)
 {
     if (empty($password) || !is_string($password)) {
         return "-----BEGIN {$type} PRIVATE KEY-----\r\n" . chunk_split(Base64::encode($key), 64) . "-----END {$type} PRIVATE KEY-----";
     }
     $cipher = self::getEncryptionObject(self::$defaultEncryptionAlgorithm);
     $iv = Random::string($cipher->getBlockLength() >> 3);
     $cipher->setKey(self::generateSymmetricKey($password, $iv, $cipher->getKeyLength() >> 3));
     $cipher->setIV($iv);
     $iv = strtoupper(Hex::encode($iv));
     return "-----BEGIN {$type} PRIVATE KEY-----\r\n" . "Proc-Type: 4,ENCRYPTED\r\n" . "DEK-Info: " . self::$defaultEncryptionAlgorithm . ",{$iv}\r\n" . "\r\n" . chunk_split(Base64::encode($cipher->encrypt($key)), 64) . "-----END {$type} PRIVATE KEY-----";
 }