Generowanie losowego hasła w php

Próbuję wygenerować losowe hasło w php.

Jednak dostaję wszystkie „a”, a zwracanym typem jest tablica typów i chciałbym, aby był to ciąg znaków. Wszelkie pomysły na poprawienie kodu?

Dzięki.

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

Ostrzeżenie bezpieczeństwa : rand()nie jest kryptograficznie bezpiecznym generatorem liczb pseudolosowych. Szukaj gdzie indziej, aby wygenerować kryptograficznie bezpieczny ciąg pseudolosowy w PHP .

Spróbuj tego (użyj strlenzamiast count, ponieważ countna ciąg jest zawsze 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
}

Demo: http://codepad.org/UL8k4aYK

TL; DR:

• Użyj random_int()i podane random_str()poniżej.
• Jeśli nie masz random_int(), użyj random_compat .

Wyjaśnienie:

Ponieważ generujesz hasło , musisz upewnić się, że hasło, które generujesz, jest nieprzewidywalne, a jedynym sposobem zapewnienia obecności tej właściwości w implementacji jest zastosowanie kryptograficznie bezpiecznego generatora liczb pseudolosowych (CSPRNG).

Wymóg dotyczący CSPRNG można złagodzić w ogólnym przypadku losowych ciągów, ale nie w przypadku zabezpieczeń.

Prostą, bezpieczną i poprawną odpowiedzią na generowanie haseł w PHP jest użycie RandomLib i nie wymyślanie koła na nowo. Ta biblioteka została zbadana przez ekspertów branży bezpieczeństwa, a także przeze mnie.

Dla programistów, którzy wolą wymyślić własne rozwiązanie, PHP 7.0.0 zapewni random_int()do tego celu. Jeśli nadal korzystasz z PHP 5.x, napisaliśmy polifill dla PHP 5random_int() , abyś mógł używać nowego API przed wydaniem PHP 7. Korzystanie z naszego random_int()wypełniacza jest prawdopodobnie bezpieczniejsze niż napisanie własnej implementacji.

Mając pod ręką bezpieczny generator losowych liczb całkowitych, wygenerowanie bezpiecznego ciągu losowego jest łatwiejsze niż ciasto:

<?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;
}

Wiem, że próbujesz wygenerować hasło w określony sposób, ale możesz również przyjrzeć się tej metodzie ...

$bytes = openssl_random_pseudo_bytes(2);

$pwd = bin2hex($bytes);

Jest pobierany ze strony php.net i tworzy ciąg, który jest dwa razy dłuższy niż liczba podana w funkcji openssl_random_pseudo_bytes. Tak więc powyższe utworzy hasło o długości 4 znaków.

W skrócie...

$pwd = bin2hex(openssl_random_pseudo_bytes(4));

Utworzy hasło o długości 8 znaków.

Pamiętaj jednak, że hasło zawiera tylko cyfry 0–9 i małe litery af!

Mały kod z 2 liniami.

demo: http://codepad.org/5rHMHwnH

function rand_string( $length ) {

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

}

echo rand_string(8);

za pomocą rand_string możesz określić, ile znaków będzie tworzonych.

Jeśli korzystasz z PHP7, możesz użyć random_int()funkcji:

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;
}

Stara odpowiedź poniżej:

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;
}

W jednej linii:

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

Twój najlepszy zakład to biblioteka RandomLib firmy ircmaxell .

Przykład użycia:

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

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

Tworzy ciągi, które są silniej losowe niż normalne funkcje losowości, takie jak shuffle()i rand()(to jest to, czego zazwyczaj potrzebujesz dla poufnych informacji, takich jak hasła, sole i klucze).

Chcesz strlen($alphabet), a nie countstałej alphabet(odpowiednik 'alphabet').

Nie randjest to jednak odpowiednia funkcja losowa do tego celu. Jego wynik można łatwo przewidzieć, ponieważ jest domyślnie zaszczepiony bieżącym czasem. Ponadto randnie jest kryptograficznie bezpieczny; dlatego stosunkowo łatwo jest ustalić jego stan wewnętrzny na podstawie wyjścia.

Zamiast tego czytaj od, /dev/urandomaby uzyskać kryptograficznie losowe dane.

Zamierzam opublikować odpowiedź, ponieważ niektóre z istniejących odpowiedzi są bliskie, ale mają jedną z:

• mniejsza przestrzeń znaków, niż chciałeś, aby wymuszenie brutalne było łatwiejsze lub hasło musi być dłuższe dla tej samej entropii
• RNG , że nie uważa się za bezpieczne kryptograficznie
• wymaganie dotyczące biblioteki innej firmy i pomyślałem, że może być interesujące, aby pokazać, co trzeba zrobić, aby to zrobić samodzielnie

Ta odpowiedź obejdzie count/strlen problem, ponieważ bezpieczeństwo wygenerowanego hasła, przynajmniej IMHO, wykracza poza to, jak się tam dostaniesz. Zakładam też, że PHP> 5.3.0.

Podzielmy problem na części składowe, które są:

1. użyj bezpiecznego źródła losowości, aby uzyskać losowe dane
2. użyj tych danych i przedstaw je jako ciąg znaków do wydrukowania

W pierwszej części PHP> 5.3.0 udostępnia tę funkcję openssl_random_pseudo_bytes. Zauważ, że chociaż większość systemów używa silnego algorytmu kryptograficznego, musisz to sprawdzić, abyśmy użyli opakowania:

/**
 * @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;
}

W drugiej części wykorzystamy, base64_encodeponieważ zajmuje ona ciąg bajtów i tworzy serię znaków, których alfabet jest bardzo zbliżony do alfabetu podanego w pierwotnym pytaniu. Jeśli nie przeszkadza nam to +, /a =znaki pojawiają się w końcowym ciągu znaków i chcemy uzyskać wynik o $ndługości co najmniej znaków, możemy po prostu użyć:

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

3/4Czynnikiem jest to spowodowane faktem, że base64 kodującego wyników w ciąg, który ma długość co najmniej jedną trzecią większy niż ciąg bajtów. Wynik będzie dokładny, ponieważ w przeciwnym $nrazie będzie wielokrotnością 4 i maksymalnie 3 znaków. Ponieważ dodatkowe znaki to głównie znak dopełniający =, jeśli z jakiegoś powodu mieliśmy ograniczenie, że hasło ma dokładną długość, możemy je skrócić do żądanej długości. Jest tak szczególnie dlatego, że dla danego $nhasła wszystkie hasła kończą się taką samą liczbą, aby osoba atakująca, która miała dostęp do hasła wynikowego, mogła zgadnąć maksymalnie 2 znaki.

Aby uzyskać dodatkowy kredyt, jeśli chcielibyśmy spełnić dokładną specyfikację jak w pytaniu PO, musielibyśmy wykonać trochę więcej pracy. Mam zamiar zrezygnować z podstawowego podejścia do konwersji i przejść do szybkiego i brudnego. Oba muszą generować więcej losowości, niż i tak zostanie użyte w wyniku z powodu alfabetu o długości 62 pozycji.

W przypadku dodatkowych znaków w wyniku możemy po prostu odrzucić je z powstałego ciągu. Jeśli zaczniemy od 8 bajtów w naszym łańcuchu bajtów, wówczas około 25% znaków base64 będzie tymi „niepożądanymi” znakami, więc po prostu odrzucenie tych znaków spowoduje, że łańcuch nie będzie krótszy niż oczekiwany PO. Następnie możemy po prostu go przyciąć, aby uzyskać dokładną długość:

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

W przypadku generowania dłuższych haseł znak wypełniający =stanowi coraz mniejszą część wyniku pośredniego, dzięki czemu można zastosować bardziej uproszczone podejście, jeśli problem dotyczy wyczerpania puli entropii używanej przez PRNG.

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

na przykład. e0m6ngefmj4

EDYTOWAĆ

Jak wspomniałem w komentarzach, długość oznacza, że ​​ataki z użyciem siły brutalnej działałyby przeciwko niemu lepiej niż ataki na czas, więc nie ma sensu martwić się o „jak bezpieczny był losowy generator”. Bezpieczeństwo, szczególnie w tym przypadku użycia, musi uzupełniać użyteczność, więc powyższe rozwiązanie jest w rzeczywistości wystarczające dla wymaganego problemu.

Jednak na wypadek, gdybyś natknął się na tę odpowiedź podczas wyszukiwania bezpiecznego generatora ciągów losowych (jak zakładam, niektórzy ludzie oparli się na odpowiedziach), na przykład w celu generowania tokenów, oto jak mógłby wyglądać generator takich kodów:

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);
    }
}

Kolejny (tylko 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)), "=");
}

Być trochę mądrzejszym:

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

sprawdź tutaj .

Użyj tego prostego kodu do wygenerowania med-strong hasła o długości 12

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

Spróbuj tego z wielkimi literami, małymi literami, cyframi i znakami specjalnymi

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
}

Powiedzmy, że potrzebujemy 10 cyfr

echo generatePassword(10);  

Przykładowe dane wyjściowe:

, IZCQ_IV \ 7

@wlqsfhT (d

1! 8 + 1 \ 4 @ uD

Szybki. Prosty, czysty i spójny format, jeśli tego chcesz

$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);

Jest to oparte na innej odpowiedzi na tej stronie, https://stackoverflow.com/a/21498316/525649

Ta odpowiedź generuje tylko znaki HEX, 0-9,a-f. Aby uzyskać coś, co nie wygląda jak hex, spróbuj tego:

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 zwraca szerszy zakres znaków alfanumerycznych
• rtrimusuwa =czasem na końcu

Przykłady:

• 32eFVfGDg891Be5e7293e54z1D23110M3ZU3FMjb30Z9a740Ej0jz4
• b280R72b48eOm77a25YCj093DE5d9549Gc73Jg8TdD9Z0Nj4b98760
• 051b33654C0Eg201cfW0e6NA4b9614ze8D2FN49E12Y0zY557aUCb8
• y67Q86ffd83G0z00M0Z152f7O2ADcY313gD7a774fc5FF069zdb5b7

Nie jest to zbyt konfigurowalne do tworzenia interfejsu dla użytkowników, ale do niektórych celów jest to w porządku. Zwiększ liczbę znaków, aby uwzględnić brak znaków specjalnych.

1. Utwórz plik z tym kodem.

2. Nazwij to jak w komentarzach.

   <?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);
       }
   
   }
   
   ?>

Stworzyłem bardziej kompleksowy i bezpieczny skrypt hasła. Spowoduje to utworzenie kombinacji dwóch wielkich liter, dwóch małych liter, dwóch cyfr i dwóch znaków specjalnych. Łącznie 8 znaków.

$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

Generuje silne hasło o długości 8 zawierające co najmniej jedną małą literę, jedną wielką literę, jedną cyfrę i jeden znak specjalny. Możesz także zmienić długość w kodzie.

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();

Ta funkcja wygeneruje hasło na podstawie reguł w parametrach

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;
}

Oto mój przypadkowy pomocnik w generowaniu zwykłego hasła.

Zapewnia, że ​​hasło ma cyfry, wielkie i małe litery, a także co najmniej 3 znaki specjalne.

Długość hasła będzie wynosić od 11 do 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);
}