Генерация случайного пароля в php

Я пытаюсь сгенерировать случайный пароль в php.

Однако я получаю все 'а' и возвращаемый тип имеет тип массив, и я хотел бы, чтобы это была строка. Любые идеи о том, как исправить код?

Спасибо.

function randomPassword() {
    $alphabet = "abcdefghijklmnopqrstuwxyzABCDEFGHIJKLMNOPQRSTUWXYZ0123456789";
    for ($i = 0; $i < 8; $i++) {
        $n = rand(0, count($alphabet)-1);
        $pass[$i] = $alphabet[$n];
    }
    return $pass;
}

Предупреждение о безопасности : rand()не является криптографически безопасным генератором псевдослучайных чисел. Найдите в другом месте для генерации криптографически безопасной псевдослучайной строки в PHP .

Попробуйте это (используйте strlenвместо count, потому что countв строке всегда 1):

function randomPassword() {
    $alphabet = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890';
    $pass = array(); //remember to declare $pass as an array
    $alphaLength = strlen($alphabet) - 1; //put the length -1 in cache
    for ($i = 0; $i < 8; $i++) {
        $n = rand(0, $alphaLength);
        $pass[] = $alphabet[$n];
    }
    return implode($pass); //turn the array into a string
}

Демо: http://codepad.org/UL8k4aYK

TL; DR:

• Используйте random_int()и приведенное random_str()ниже.
• Если у вас нет random_int(), используйте random_compat .

Объяснение:

Поскольку вы генерируете пароль , вам нужно убедиться, что сгенерированный вами пароль непредсказуем, и единственный способ обеспечить наличие этого свойства в вашей реализации - использовать криптографически безопасный генератор псевдослучайных чисел (CSPRNG).

Требование к CSPRNG может быть смягчено для общего случая случайных строк, но не когда речь идет о безопасности.

Простой, безопасный и правильный ответ на генерацию пароля в PHP - это использовать RandomLib и не изобретать велосипед. Эта библиотека была проверена экспертами по безопасности отрасли, а также я.

Для разработчиков, которые предпочитают изобретать собственное решение, PHP 7.0.0 предоставит random_int()для этой цели. Если вы все еще используете PHP 5.x, мы написали полифил для PHP 5,random_int() чтобы вы могли использовать новый API до выхода PHP 7. Использование нашего random_int()polyfill, вероятно, безопаснее, чем написание собственной реализации.

С помощью надежного генератора случайных целых чисел создать безопасную случайную строку проще, чем pie:

<?php
/**
 * Generate a random string, using a cryptographically secure 
 * pseudorandom number generator (random_int)
 * 
 * For PHP 7, random_int is a PHP core function
 * For PHP 5.x, depends on https://github.com/paragonie/random_compat
 * 
 * @param int $length      How many characters do we want?
 * @param string $keyspace A string of all possible characters
 *                         to select from
 * @return string
 */
function random_str(
    $length,
    $keyspace = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
) {
    $str = '';
    $max = mb_strlen($keyspace, '8bit') - 1;
    if ($max < 1) {
        throw new Exception('$keyspace must be at least two characters long');
    }
    for ($i = 0; $i < $length; ++$i) {
        $str .= $keyspace[random_int(0, $max)];
    }
    return $str;
}

Я знаю, что вы пытаетесь сгенерировать свой пароль особым образом, но вы можете посмотреть и на этот метод ...

$bytes = openssl_random_pseudo_bytes(2);

$pwd = bin2hex($bytes);

Он взят с сайта php.net и создает строку, которая вдвое длиннее числа, которое вы вводите в функцию openssl_random_pseudo_bytes. Таким образом, выше будет создать пароль длиной 4 символа.

Коротко...

$pwd = bin2hex(openssl_random_pseudo_bytes(4));

Создайте пароль длиной 8 символов.

Однако обратите внимание, что пароль содержит только цифры 0-9 и строчные буквы af!

Крошечный код с 2 строки.

демо: http://codepad.org/5rHMHwnH

function rand_string( $length ) {

    $chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
    return substr(str_shuffle($chars),0,$length);

}

echo rand_string(8);

с помощью rand_string вы можете определить, сколько символов будет создано.

Если вы используете PHP7, вы можете использовать random_int()функцию:

function generate_password($length = 20){
  $chars =  'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.
            '0123456789`-=~!@#$%^&*()_+,./<>?;:[]{}\|';

  $str = '';
  $max = strlen($chars) - 1;

  for ($i=0; $i < $length; $i++)
    $str .= $chars[random_int(0, $max)];

  return $str;
}

Старый ответ ниже:

function generate_password($length = 20){
  $chars =  'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.
            '0123456789`-=~!@#$%^&*()_+,./<>?;:[]{}\|';

  $str = '';
  $max = strlen($chars) - 1;

  for ($i=0; $i < $length; $i++)
    $str .= $chars[mt_rand(0, $max)];

  return $str;
}

В одной строке:

substr(str_shuffle('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789') , 0 , 10 )

Ваш лучший выбор - библиотека RandomLib от ircmaxell .

Пример использования:

$factory = new RandomLib\Factory;
$generator = $factory->getGenerator(new SecurityLib\Strength(SecurityLib\Strength::MEDIUM));

$passwordLength = 8; // Or more
$randomPassword = $generator->generateString($passwordLength);

Он генерирует строки, которые более строго случайны, чем обычные функции случайности, такие как shuffle()и rand()(что обычно требуется для конфиденциальной информации, такой как пароли, соли и ключи).

Вы хотите strlen($alphabet), а не countпостоянной alphabet(эквивалентно 'alphabet').

Однако randне подходит случайная функция для этой цели. Его вывод можно легко предсказать, так как он неявно засеян текущим временем. Дополнительно,rand не является криптографически безопасным; поэтому относительно легко определить его внутреннее состояние по выходным данным.

Вместо этого читайте, /dev/urandomчтобы получить криптографически случайные данные.

Я собираюсь опубликовать ответ, потому что некоторые из существующих ответов близки, но имеют один из:

• Меньшее пространство символов, чем вы хотели, так что или грубое принуждение проще, или пароль должен быть длиннее для той же энтропии
• RNG , не считается криптографический безопасными
• требование для какой-то сторонней библиотеки, и я подумал, что было бы интересно показать, что нужно сделать, чтобы сделать это самостоятельно

Этот ответ обойдет count/strlenпроблему, поскольку безопасность сгенерированного пароля, по крайней мере, ИМХО, выходит за рамки того, как вы туда попали. Я также собираюсь предположить, PHP> 5.3.0.

Давайте разберем проблему на составные части, которые:

1. использовать какой-то безопасный источник случайности, чтобы получить случайные данные
2. использовать эти данные и представить его как некоторую печатную строку

Для первой части PHP> 5.3.0 предоставляет функцию openssl_random_pseudo_bytes. Обратите внимание, что хотя большинство систем используют криптографически стойкий алгоритм, вы должны проверить, чтобы мы использовали оболочку:

/**
 * @param int $length
 */
function strong_random_bytes($length)
{
    $strong = false; // Flag for whether a strong algorithm was used
    $bytes = openssl_random_pseudo_bytes($length, $strong);

    if ( ! $strong)
    {
        // System did not use a cryptographically strong algorithm 
        throw new Exception('Strong algorithm not available for PRNG.');
    }        

    return $bytes;
}

Для второй части мы будем использовать, base64_encodeпоскольку она принимает байтовую строку и создает последовательность символов, алфавит которых очень близок к алфавиту, указанному в исходном вопросе. Если мы не возражаем против этого +, /и =в последней строке появляются символы, и мы хотим, чтобы результат был длиной не менее $nсимволов, мы могли бы просто использовать:

base64_encode(strong_random_bytes(intval(ceil($n * 3 / 4))));

Этот 3/4фактор связан с тем, что в результате кодирования base64 получается строка, длина которой как минимум на треть больше, чем строка байтов. Результат будет точным для $nкратности от 4 до 3 символов длиннее, в противном случае. Поскольку дополнительные символы являются преимущественно символом заполнения =, если у нас по какой-то причине было ограничение, что пароль должен быть точной длины, то мы можем усечь его до желаемой длины. Это особенно связано с тем, что для заданного значения $nвсе пароли заканчиваются одинаковым числом, так что злоумышленнику, имеющему доступ к результирующему паролю, будет угадано до 2 символов меньше.

Для дополнительного кредита, если бы мы хотели выполнить точную спецификацию, как в вопросе ОП, то нам пришлось бы сделать немного больше работы. Я собираюсь отказаться от базового подхода к конвертации и перейти к быстрому и грязному. Оба должны генерировать больше случайности, чем в любом случае будет использоваться в результате из-за длинного алфавита из 62 записей.

Для дополнительных символов в результате мы можем просто отбросить их из полученной строки. Если мы начнем с 8 байтов в нашей байтовой строке, то примерно 25% символов base64 будут этими «нежелательными» символами, так что простое отбрасывание этих символов приведет к тому, что строка будет не короче, чем хотел OP. Тогда мы можем просто обрезать его, чтобы получить точную длину:

$dirty_pass = base64_encode(strong_random_bytes(8)));
$pass = substr(str_replace(['/', '+', '='], ['', '', ''], $dirty_pass, 0, 8);

Если вы генерируете более длинные пароли, символ заполнения =формирует все меньшую и меньшую пропорцию промежуточного результата, чтобы вы могли реализовать более узкий подход, если проблема заключается в опустошении пула энтропии, используемого для PRNG.

base_convert(uniqid('pass', true), 10, 36);

например. e0m6ngefmj4

РЕДАКТИРОВАТЬ

Как я упоминал в комментариях, длина означает, что атаки методом "грубой силы" будут работать лучше, чем атаки по времени, поэтому не стоит беспокоиться о том, "насколько безопасен генератор случайных чисел". Безопасность, особенно для этого варианта использования, должна дополнять удобство использования, поэтому приведенное выше решение на самом деле достаточно хорошо для требуемой проблемы.

Однако на тот случай, если вы наткнулись на этот ответ при поиске безопасного генератора случайных строк (как я полагаю, некоторые люди основали на ответах), например, для генерации токенов, вот как будет выглядеть генератор таких кодов:

function base64urlEncode($data) {
    return rtrim(strtr(base64_encode($data), '+/', '-_'), '=');
}

function secureId($length = 32) {

    if (function_exists('openssl_random_pseudo_bytes')) {
        $bytes = openssl_random_pseudo_bytes($length);
        return rtrim(strtr(base64_encode($bytes), '+/', '0a'), '=');
    }
    else { // fallback to system bytes

        error_log("Missing support for openssl_random_pseudo_bytes");

        $pr_bits = '';

        $fp = @fopen('/dev/urandom', 'rb');
        if ($fp !== false) {
            $pr_bits .= @fread($fp, $length);
            @fclose($fp);
        }

        if (strlen($pr_bits) < $length) {
            error_log('unable to read /dev/urandom');
            throw new \Exception('unable to read /dev/urandom');
        }

        return base64urlEncode($pr_bits);
    }
}

Еще один (только Linux)

function randompassword()
{
    $fp = fopen ("/dev/urandom", 'r');
    if (!$fp) { die ("Can't access /dev/urandom to get random data. Aborting."); }
    $random = fread ($fp, 1024); # 1024 bytes should be enough
    fclose ($fp);
    return trim (base64_encode ( md5 ($random, true)), "=");
}

Быть немного умнее:

function strand($length){
  if($length > 0)
    return chr(rand(33, 126)) . strand($length - 1);
}

проверьте это здесь .

Используйте этот простой код для создания надежного пароля длиной 12

$password_string = '!@#$%*&abcdefghijklmnpqrstuwxyzABCDEFGHJKLMNPQRSTUWXYZ23456789';
$password = substr(str_shuffle($password_string), 0, 12);

Попробуйте это с заглавными буквами, маленькими буквами, цифрами и специальными символами

function generatePassword($_len) {

    $_alphaSmall = 'abcdefghijklmnopqrstuvwxyz';            // small letters
    $_alphaCaps  = strtoupper($_alphaSmall);                // CAPITAL LETTERS
    $_numerics   = '1234567890';                            // numerics
    $_specialChars = '`~!@#$%^&*()-_=+]}[{;:,<.>/?\'"\|';   // Special Characters

    $_container = $_alphaSmall.$_alphaCaps.$_numerics.$_specialChars;   // Contains all characters
    $password = '';         // will contain the desired pass

    for($i = 0; $i < $_len; $i++) {                                 // Loop till the length mentioned
        $_rand = rand(0, strlen($_container) - 1);                  // Get Randomized Length
        $password .= substr($_container, $_rand, 1);                // returns part of the string [ high tensile strength ;) ] 
    }

    return $password;       // Returns the generated Pass
}

Допустим, нам нужен 10-значный пропуск

echo generatePassword(10);  

Пример выходных данных:

, IZCQ_IV \ 7

@wlqsfhT (д

1! 8 + 1 \ 4 @ UD

Быстрая Простой, чистый и последовательный формат, если это то, что вы хотите

$pw = chr(mt_rand(97,122)).mt_rand(0,9).chr(mt_rand(97,122)).mt_rand(10,99).chr(mt_rand(97,122)).mt_rand(100,999);

Это основано на другом ответе на этой странице, https://stackoverflow.com/a/21498316/525649

Этот ответ генерирует только шестнадцатеричные символы 0-9,a-f. Для чего-то, что не похоже на hex, попробуйте это:

str_shuffle(
  rtrim(
    base64_encode(bin2hex(openssl_random_pseudo_bytes(5))),
    '='
  ). 
  strtoupper(bin2hex(openssl_random_pseudo_bytes(7))).
  bin2hex(openssl_random_pseudo_bytes(13))
)

• base64_encode возвращает более широкое распространение буквенно-цифровых символов
• rtrimудаляет =иногда в конце

Примеры:

• 32eFVfGDg891Be5e7293e54z1D23110M3ZU3FMjb30Z9a740Ej0jz4
• b280R72b48eOm77a25YCj093DE5d9549Gc73Jg8TdD9Z0Nj4b98760
• 051b33654C0Eg201cfW0e6NA4b9614ze8D2FN49E12Y0zY557aUCb8
• y67Q86ffd83G0z00M0Z152f7O2ADcY313gD7a774fc5FF069zdb5b7

Это не очень настраивается для создания интерфейса для пользователей, но для некоторых целей это нормально. Увеличьте количество символов для учета отсутствия специальных символов.

1. Создайте файл с этим кодом.

2. Назовите это как в комментариях.

   <?php 
   
   /**
   * @usage  :
   *       include_once($path . '/Password.php');
   *       $Password = new Password;
   *       $pwd = $Password->createPassword(10);
   *       return $pwd;
   * 
   */
   
   class Password {
   
       public function createPassword($length = 15) {
           $response = [];
           $response['pwd'] = $this->generate($length);
           $response['hashPwd'] = $this->hashPwd( $response['pwd'] );
           return $response;
       }
   
       private function generate($length = 15) {
           $chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*(){}/?,><";
           return substr(str_shuffle($chars),0,$length);
       }
   
       private function hashPwd($pwd) {
           return hash('sha256', $pwd);
       }
   
   }
   
   ?>

Я создал более полный и безопасный сценарий пароля. Это создаст комбинацию из двух прописных, двух строчных, двух цифр и двух специальных символов. Всего 8 символов.

$char = [range('A','Z'),range('a','z'),range(0,9),['*','%','$','#','@','!','+','?','.']];
$pw = '';
for($a = 0; $a < count($char); $a++)
{
    $randomkeys = array_rand($char[$a], 2);
    $pw .= $char[$a][$randomkeys[0]].$char[$a][$randomkeys[1]];
}
$userPassword = str_shuffle($pw);

//define a function. It is only 3 lines!   
function generateRandomPassword($length = 5){
    $chars = "0123456789bcdfghjkmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ";
    return substr(str_shuffle($chars),0,$length);
}

//usage
echo generateRandomPassword(5); //random password legth: 5
echo generateRandomPassword(6); //random password legth: 6
echo generateRandomPassword(7); //random password legth: 7

Создает надежный пароль длиной 8, содержащий как минимум одну строчную букву, одну заглавную букву, одну цифру и один специальный символ. Вы можете изменить длину в коде тоже.

function checkForCharacterCondition($string) {
    return (bool) preg_match('/(?=.*([A-Z]))(?=.*([a-z]))(?=.*([0-9]))(?=.*([~`\!@#\$%\^&\*\(\)_\{\}\[\]]))/', $string);
}

$j = 1;

function generate_pass() {
    global $j;
    $allowedCharacters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ~`!@#$%^&*()_{}[]';
    $pass = '';
    $length = 8;
    $max = mb_strlen($allowedCharacters, '8bit') - 1;
    for ($i = 0; $i < $length; ++$i) {
        $pass .= $allowedCharacters[random_int(0, $max)];
    }

    if (checkForCharacterCondition($pass)){
        return '<br><strong>Selected password: </strong>'.$pass;
    }else{
        echo 'Iteration '.$j.':  <strong>'.$pass.'</strong>  Rejected<br>';
        $j++;
        return generate_pass();
    }

}

echo generate_pass();

Эта функция будет генерировать пароль на основе правил в параметрах

function random_password( $length = 8, $characters = true, $numbers = true, $case_sensitive = true, $hash = true ) {

    $password = '';

    if($characters)
    {
        $charLength = $length;
        if($numbers) $charLength-=2;
        if($case_sensitive) $charLength-=2;
        if($hash) $charLength-=2;
        $chars = "abcdefghijklmnopqrstuvwxyz";
        $password.= substr( str_shuffle( $chars ), 0, $charLength );
    }

    if($numbers)
    {
        $numbersLength = $length;
        if($characters) $numbersLength-=2;
        if($case_sensitive) $numbersLength-=2;
        if($hash) $numbersLength-=2;
        $chars = "0123456789";
        $password.= substr( str_shuffle( $chars ), 0, $numbersLength );
    }

    if($case_sensitive)
    {
        $UpperCaseLength = $length;
        if($characters) $UpperCaseLength-=2;
        if($numbers) $UpperCaseLength-=2;
        if($hash) $UpperCaseLength-=2;
        $chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
        $password.= substr( str_shuffle( $chars ), 0, $UpperCaseLength );
    }

    if($hash)
    {
        $hashLength = $length;
        if($characters) $hashLength-=2;
        if($numbers) $hashLength-=2;
        if($case_sensitive) $hashLength-=2;
        $chars = "!@#$%^&*()_-=+;:,.?";
        $password.= substr( str_shuffle( $chars ), 0, $hashLength );
    }

    $password = str_shuffle( $password );
    return $password;
}

Вот мой случайный помощник генерации простого пароля.

Это гарантирует, что пароль имеет цифры, прописные и строчные буквы, а также минимум 3 специальных символа.

Длина пароля будет от 11 до 30.

function plainPassword(): string
{
    $numbers = array_rand(range(0, 9), rand(3, 9));
    $uppercase = array_rand(array_flip(range('A', 'Z')), rand(2, 8));
    $lowercase = array_rand(array_flip(range('a', 'z')), rand(3, 8));
    $special = array_rand(array_flip(['@', '#', '$', '!', '%', '*', '?', '&']), rand(3, 5));

    $password = array_merge(
        $numbers,
        $uppercase,
        $lowercase,
        $special
    );

    shuffle($password);

    return implode($password);
}