Generazione di una password casuale in php

Sto cercando di generare una password casuale in php.

Tuttavia sto ottenendo tutte le "a" e il tipo restituito è di tipo array e vorrei che fosse una stringa. Qualche idea su come correggere il codice?

Grazie.

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

Avviso di sicurezza : rand()non è un generatore di numeri pseudocasuali crittograficamente sicuro. Cerca altrove per generare una stringa pseudocasuale crittograficamente sicura in PHP .

Prova questo (usa strleninvece di count, perché countsu una stringa è sempre 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:

• Utilizzare random_int()e il dato di random_str()seguito.
• Se non lo hai random_int(), usa random_compat .

Spiegazione:

Poiché si sta generando una password , è necessario assicurarsi che la password generata sia imprevedibile e l'unico modo per garantire che questa proprietà sia presente nella propria implementazione è utilizzare un generatore di numeri pseudocasuali crittograficamente sicuro (CSPRNG).

Il requisito per un CSPRNG può essere rilassato per il caso generale di stringhe casuali, ma non quando è coinvolta la sicurezza.

La risposta semplice, sicura e corretta alla generazione di password in PHP è usare RandomLib e non reinventare la ruota. Questa biblioteca è stata verificata da esperti della sicurezza del settore e da me stesso.

Per gli sviluppatori che preferiscono inventare la propria soluzione, PHP 7.0.0 fornirà random_int()a tale scopo. Se sei ancora su PHP 5.x, abbiamo scritto un polyfill per PHP 5 inrandom_int() modo da poter utilizzare la nuova API prima che PHP 7 venga rilasciato. L'uso del nostro random_int()polyfill è probabilmente più sicuro che scrivere la propria implementazione.

Con un generatore di numeri interi casuali sicuri a portata di mano, generare una stringa casuale sicura è più semplice della torta:

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

So che stai cercando di generare la tua password in un modo specifico, ma potresti voler esaminare anche questo metodo ...

$bytes = openssl_random_pseudo_bytes(2);

$pwd = bin2hex($bytes);

È preso dal sito php.net e crea una stringa che è il doppio della lunghezza del numero inserito nella funzione openssl_random_pseudo_bytes. Quindi quanto sopra creerebbe una password di 4 caratteri.

In breve...

$pwd = bin2hex(openssl_random_pseudo_bytes(4));

Creerebbe una password lunga 8 caratteri.

Si noti tuttavia che la password contiene solo numeri 0-9 e lettere maiuscole af!

Codice minuscolo con 2 righe.

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

function rand_string( $length ) {

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

}

echo rand_string(8);

con rand_string puoi definire la quantità di caratteri che verrà creata.

Se sei su PHP7 puoi usare la random_int()funzione:

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

Vecchia risposta di seguito:

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

In una riga:

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

La tua scommessa migliore è la libreria RandomLib di ircmaxell .

Esempio di utilizzo:

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

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

Produce stringhe che sono più fortemente casuali delle normali funzioni di casualità come shuffle()e rand()(che è ciò che generalmente si desidera per informazioni sensibili come password, sali e chiavi).

Tu vuoi strlen($alphabet) , non countdella costante alphabet(equivalente a 'alphabet').

Però, rand non è una funzione casuale adatta per questo scopo. Il suo output può essere facilmente previsto poiché è implicitamente seminato con l'ora corrente. Inoltre, randnon è crittograficamente sicuro; è quindi relativamente facile determinare il suo stato interno dall'output.

Invece, leggi da /dev/urandomper ottenere dati crittograficamente casuali.

Pubblicherò una risposta perché alcune delle risposte esistenti sono vicine ma hanno una di:

• uno spazio di caratteri più piccolo di quello che volevi, in modo che sia la forza bruta sia più facile o la password debba essere più lunga per la stessa entropia
• un RNG che non è considerato sicuro dal punto di vista crittografico
• un requisito per alcune librerie di terze parti e ho pensato che potrebbe essere interessante mostrare cosa potrebbe essere necessario per farlo da soli

Questa risposta aggirerà il count/strlenproblema poiché la sicurezza della password generata, almeno IMHO, trascende il modo in cui ci si arriva. Presumo anche PHP> 5.3.0.

Suddividiamo il problema nelle parti costituenti che sono:

1. utilizzare una fonte sicura di casualità per ottenere dati casuali
2. usa quei dati e rappresentali come una stringa stampabile

Per la prima parte, PHP> 5.3.0 fornisce la funzione openssl_random_pseudo_bytes. Si noti che mentre la maggior parte dei sistemi utilizza un algoritmo crittograficamente forte, è necessario verificare quindi utilizzeremo un wrapper:

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

Per la seconda parte, useremo base64_encodepoiché richiede una stringa di byte e produrrà una serie di caratteri che hanno un alfabeto molto vicino a quello specificato nella domanda originale. Se non ci dispiace avere +, /e i =caratteri compaiono nella stringa finale e vogliamo un risultato lungo almeno $ncaratteri, potremmo semplicemente usare:

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

Il 3/4fattore è dovuto al fatto che la codifica base64 genera una stringa che ha una lunghezza di almeno un terzo maggiore della stringa di byte. Il risultato sarà esatto per $nessere un multiplo di 4 e fino a 3 caratteri più a lungo altrimenti. Poiché i caratteri extra sono prevalentemente il carattere di riempimento =, se per qualche motivo avessimo il vincolo che la password fosse una lunghezza esatta, allora possiamo troncarla nella lunghezza che vogliamo. Ciò è dovuto in particolare al fatto che, per un dato periodo $n, tutte le password terminerebbero con lo stesso numero di queste, in modo che un utente malintenzionato che aveva accesso a una password risultante avrebbe un massimo di 2 caratteri da indovinare.

Per ulteriore credito, se volessimo soddisfare le specifiche esatte come nella domanda del PO, dovremmo fare un po 'più di lavoro. Ho intenzione di rinunciare all'approccio di conversione di base qui e andare con uno veloce e sporco. Entrambi devono generare una casualità maggiore di quella che verrà comunque utilizzata nel risultato a causa dell'alfabeto lungo di 62 voci.

Per i caratteri extra nel risultato, possiamo semplicemente scartarli dalla stringa risultante. Se iniziamo con 8 byte nella nostra stringa di byte, fino a circa il 25% dei caratteri base64 sarebbero questi caratteri "indesiderabili", in modo che scartare semplicemente questi caratteri si traduca in una stringa non più corta dell'OP desiderato. Quindi possiamo semplicemente troncarlo per arrivare alla lunghezza esatta:

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

Se si generano password più lunghe, il carattere di riempimento =costituisce una proporzione sempre più piccola del risultato intermedio in modo da poter implementare un approccio più snello, se il drenaggio del pool di entropia utilizzato per il PRNG è un problema.

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

per esempio. e0m6ngefmj4

MODIFICARE

Come ho già detto nei commenti, la lunghezza significa che gli attacchi di forza bruta funzionerebbero meglio contro di esso rispetto agli attacchi di temporizzazione, quindi non è rilevante preoccuparsi di "quanto fosse sicuro il generatore casuale". La sicurezza, in particolare per questo caso d'uso, deve integrare l'usabilità, quindi la soluzione di cui sopra è in realtà abbastanza buona per il problema richiesto.

Tuttavia, nel caso in cui ti sei imbattuto in questa risposta durante la ricerca di un generatore di stringhe casuali sicuro (come presumo che alcune persone abbiano basato sulle risposte), per qualcosa come la generazione di token, ecco come apparirebbe un generatore di tali codici:

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

Un altro (solo 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)), "=");
}

Essere un po 'più intelligenti:

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

controllalo qui .

Utilizzare questo semplice codice per generare una lunghezza di password 12 di livello medio

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

Prova questo con lettere maiuscole, lettere minuscole, numeri numerici e caratteri speciali

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
}

Diciamo che abbiamo bisogno di 10 cifre

echo generatePassword(10);  

Esempi di output:

, IZCQ_IV \ 7

@wlqsfhT (d

1! 8 + 1 \ 4 @ uD

Uno veloce. Formato semplice, pulito e coerente se è quello che vuoi

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

Questo si basa su un'altra risposta in questa pagina, https://stackoverflow.com/a/21498316/525649

Questa risposta genera caratteri esadecimali solo, 0-9,a-f. Per qualcosa che non sembra esadecimale, prova questo:

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 restituisce una più ampia diffusione di caratteri alfanumerici
• rtrimrimuove il =talvolta alla fine

Esempi:

• 32eFVfGDg891Be5e7293e54z1D23110M3ZU3FMjb30Z9a740Ej0jz4
• b280R72b48eOm77a25YCj093DE5d9549Gc73Jg8TdD9Z0Nj4b98760
• 051b33654C0Eg201cfW0e6NA4b9614ze8D2FN49E12Y0zY557aUCb8
• y67Q86ffd83G0z00M0Z152f7O2ADcY313gD7a774fc5FF069zdb5b7

Questo non è molto configurabile per la creazione di un'interfaccia per gli utenti, ma per alcuni scopi va bene. Aumenta il numero di caratteri per tenere conto della mancanza di caratteri speciali.

1. Crea un file con questo codice al suo interno.

2. Chiamalo come nei commenti.

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

Ho creato uno script di password più completo e sicuro. Ciò creerà una combinazione di due lettere maiuscole, due minuscole, due numeri e due caratteri speciali. Totale 8 caratteri.

$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

Genera una password complessa di lunghezza 8 contenente almeno una lettera minuscola, una lettera maiuscola, una cifra e un carattere speciale. Puoi anche modificare la lunghezza nel codice.

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

Questa funzione genererà una password in base alle regole nei parametri

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

Ecco la mia opinione sull'aiutante di generazione casuale di password semplici.

Assicura che la password contenga numeri, lettere maiuscole e minuscole e un minimo di 3 caratteri speciali.

La lunghezza della password sarà compresa tra 11 e 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);
}