Menghasilkan kata sandi acak dalam php

Saya mencoba membuat kata sandi acak di php.

Namun saya mendapatkan semua 'a dan tipe pengembaliannya adalah tipe array dan saya ingin itu menjadi string. Ada ide tentang cara memperbaiki kode?

Terima kasih.

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

Peringatan keamanan : rand()bukan generator nomor pseudorandom yang aman secara kriptografis. Cari di tempat lain untuk membuat string pseudorandom yang aman secara kriptografis di PHP .

Coba ini (gunakan strlensebagai ganti count, karena countpada senar selalu 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:

• Gunakan random_int()dan diberikan di random_str()bawah ini.
• Jika belum random_int(), gunakan random_compat .

Penjelasan:

Karena Anda membuat kata sandi , Anda perlu memastikan bahwa kata sandi yang Anda hasilkan tidak dapat diprediksi, dan satu-satunya cara untuk memastikan properti ini hadir dalam implementasi Anda adalah dengan menggunakan generator nomor pseudorandom (CSPRNG) yang aman secara kriptografi aman .

Persyaratan untuk CSPRNG dapat disesuaikan untuk kasus umum string acak, tetapi tidak ketika keamanan terlibat.

Jawaban sederhana, aman, dan benar untuk pembuatan kata sandi di PHP adalah dengan menggunakan RandomLib dan jangan menemukan kembali roda. Perpustakaan ini telah diaudit oleh para pakar keamanan industri, dan juga saya.

Untuk pengembang yang lebih suka menciptakan solusi Anda sendiri, PHP 7.0.0 akan menyediakan random_int()untuk tujuan ini. Jika Anda masih menggunakan PHP 5.x, kami menulis polyfill PHP 5random_int() agar Anda dapat menggunakan API baru sebelum PHP 7 dirilis. Menggunakan random_int()polyfill kami mungkin lebih aman daripada menulis implementasi Anda sendiri.

Dengan generator integer acak aman di tangan, menghasilkan string acak aman lebih mudah daripada 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;
}

Saya tahu Anda mencoba membuat kata sandi dengan cara tertentu, tetapi Anda mungkin ingin melihat metode ini juga ...

$bytes = openssl_random_pseudo_bytes(2);

$pwd = bin2hex($bytes);

Ini diambil dari situs php.net dan menciptakan string yang dua kali panjang dari angka yang Anda masukkan dalam fungsi openssl_random_pseudo_bytes. Jadi di atas akan membuat kata sandi sepanjang 4 karakter.

Pendeknya...

$pwd = bin2hex(openssl_random_pseudo_bytes(4));

Panjang kata sandi akan dibuat 8 karakter.

Namun perlu dicatat bahwa kata sandi hanya berisi angka 0-9 dan huruf kecil af!

Kode kecil dengan 2 baris.

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

function rand_string( $length ) {

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

}

echo rand_string(8);

dengan rand_string Anda dapat menentukan berapa banyak karakter yang akan dibuat.

Jika Anda menggunakan PHP7, Anda bisa menggunakan random_int()fungsi ini:

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

Jawaban lama di bawah:

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

Dalam satu baris:

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

Taruhan terbaik Anda adalah perpustakaan RandomLib oleh ircmaxell .

Contoh penggunaan:

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

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

Ini menghasilkan string yang lebih kuat acak daripada fungsi keacakan normal seperti shuffle()dan rand()(yang biasanya Anda inginkan untuk informasi sensitif seperti kata sandi, garam dan kunci).

Anda inginkan strlen($alphabet), bukan countdari konstanta alphabet(setara dengan 'alphabet').

Namun, randbukan fungsi acak yang cocok untuk tujuan ini. Hasilnya dapat dengan mudah diprediksi karena secara implisit diunggulkan dengan waktu saat ini. Selain itu, randtidak aman secara kriptografis; Oleh karena itu relatif mudah untuk menentukan keadaan internal dari output.

Sebagai gantinya, baca dari /dev/urandomuntuk mendapatkan data acak kriptografis.

Saya akan memposting jawaban karena beberapa jawaban yang ada sudah dekat tetapi ada satu:

• ruang karakter yang lebih kecil daripada yang Anda inginkan sehingga memaksa kasar lebih mudah atau kata sandi harus lebih panjang untuk entropi yang sama
• sebuah RNG yang tidak dianggap cryptographically aman
• persyaratan untuk beberapa perpustakaan pihak ke-3 dan saya pikir mungkin menarik untuk menunjukkan apa yang diperlukan untuk melakukannya sendiri

Jawaban ini akan menghindari count/strlenmasalah karena keamanan kata sandi yang dihasilkan, setidaknya IMHO, melampaui cara Anda sampai di sana. Saya juga akan menganggap PHP> 5.3.0.

Mari kita pecahkan masalah menjadi beberapa bagian yaitu:

1. gunakan beberapa sumber acak yang aman untuk mendapatkan data acak
2. gunakan data itu dan nyatakan sebagai beberapa string yang dapat dicetak

Untuk bagian pertama, PHP> 5.3.0 menyediakan fungsi openssl_random_pseudo_bytes. Perhatikan bahwa sementara sebagian besar sistem menggunakan algoritma kriptografi yang kuat, Anda harus memeriksa sehingga kami akan menggunakan pembungkus:

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

Untuk bagian kedua, kita akan menggunakan base64_encodekarena mengambil string byte dan akan menghasilkan serangkaian karakter yang memiliki alfabet yang sangat dekat dengan yang ditentukan dalam pertanyaan asli. Jika kami tidak keberatan memiliki +, /dan =karakter muncul di string terakhir dan kami ingin hasil setidaknya $npanjang karakter, kita bisa menggunakan:

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

The 3/4Faktor ini disebabkan oleh fakta bahwa base64 encoding menghasilkan string yang memiliki panjang setidaknya sepertiga lebih besar dari byte string yang. Hasilnya akan tepat untuk $nmenjadi kelipatan 4 dan hingga 3 karakter lebih lama. Karena karakter tambahan sebagian besar merupakan karakter padding =, jika kita karena suatu alasan memiliki batasan bahwa kata sandi menjadi panjang yang tepat, maka kita dapat memotongnya sesuai dengan panjang yang kita inginkan. Ini terutama karena untuk yang diberikan $n, semua kata sandi akan diakhiri dengan nomor yang sama, sehingga penyerang yang memiliki akses ke kata sandi hasil, akan memiliki hingga 2 karakter lebih sedikit untuk ditebak.

Untuk kredit tambahan, jika kami ingin memenuhi spesifikasi persis seperti dalam pertanyaan OP maka kami harus melakukan sedikit lebih banyak pekerjaan. Saya akan melupakan pendekatan konversi basis di sini dan pergi dengan yang cepat dan kotor. Keduanya harus menghasilkan lebih banyak keacakan daripada yang akan digunakan dalam hasil karena 62 alfabet panjang entri.

Untuk karakter tambahan dalam hasil, kita bisa membuangnya dari string yang dihasilkan. Jika kita mulai dengan 8 byte dalam string-byte kita, maka hingga sekitar 25% dari karakter base64 akan menjadi karakter yang "tidak diinginkan" ini, sehingga dengan hanya membuang karakter ini menghasilkan string yang tidak lebih pendek dari yang diinginkan OP. Kemudian kita cukup memotongnya untuk mencapai panjang yang tepat:

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

Jika Anda menghasilkan kata sandi yang lebih panjang, karakter padding =membentuk proporsi hasil perantara yang lebih kecil dan lebih kecil sehingga Anda dapat menerapkan pendekatan yang lebih ramping, jika mengeringkan kumpulan entropi yang digunakan untuk PRNG menjadi perhatian.

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

misalnya. e0m6ngefmj4

EDIT

Seperti yang saya sebutkan di komentar, panjangnya berarti bahwa serangan brute force akan bekerja lebih baik terhadapnya daripada serangan waktu sehingga tidak benar-benar relevan untuk khawatir tentang "seberapa aman generator acak itu." Keamanan, khusus untuk kasus penggunaan ini, perlu melengkapi kegunaan sehingga solusi di atas sebenarnya cukup baik untuk masalah yang diperlukan.

Namun, untuk berjaga-jaga jika Anda menemukan jawaban ini saat mencari generator string acak yang aman (seperti yang saya asumsikan sebagian orang berdasarkan pada tanggapannya), untuk sesuatu seperti membuat token, berikut adalah tampilan generator kode-kode tersebut:

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

Satu lagi (hanya 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)), "=");
}

Menjadi sedikit lebih pintar:

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

periksa di sini .

Gunakan kode sederhana ini untuk menghasilkan kata sandi yang kuat 12 panjang

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

Coba ini dengan Huruf Besar, Huruf Kecil, Numerik dan Karakter Khusus

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
}

Katakanlah kita membutuhkan 10 Digit Pass

echo generatePassword(10);  

Output Contoh:

, IZCQ_IV \ 7

@wlqsfhT (d

1! 8 + 1 \ 4 @ uD

Satu cepat Format sederhana, bersih dan konsisten jika itu yang Anda inginkan

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

Ini didasarkan pada jawaban lain pada halaman ini, https://stackoverflow.com/a/21498316/525649

Jawaban ini hanya menghasilkan karakter hex 0-9,a-f,. Untuk sesuatu yang tidak terlihat seperti hex, coba ini:

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 mengembalikan penyebaran karakter alfanumerik yang lebih luas
• rtrimmenghapus =terkadang di akhir

Contoh:

• 32eFVfGDg891Be5e7293e54z1D23110M3ZU3FMjb30Z9a740Ej0jz4
• b280R72b48eOm77a25YCj093DE5d9549Gc73Jg8TdD9Z0Nj4b98760
• 051b33654C0Eg201cfW0e6NA4b9614ze8D2FN49E12Y0zY557aUCb8
• y67Q86ffd83G0z00M0Z152f7O2ADcY313gD7a774fc5FF069zdb5b7

Ini tidak dapat dikonfigurasi untuk membuat antarmuka untuk pengguna, tetapi untuk beberapa tujuan tidak apa-apa. Tambah jumlah karakter untuk menjelaskan kurangnya karakter khusus.

1. Buat file dengan kode ini di dalamnya.

2. Sebut saja seperti di komentar.

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

Saya membuat skrip kata sandi yang lebih komprehensif dan aman. Ini akan membuat kombinasi dua huruf besar, dua huruf kecil, dua angka, dan dua karakter khusus. Total 8 karakter.

$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

Menghasilkan kata sandi yang kuat dengan panjang 8 yang mengandung setidaknya satu huruf kecil, satu huruf besar, satu digit, dan satu karakter khusus. Anda dapat mengubah panjang kode juga.

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

Fungsi ini akan menghasilkan kata sandi berdasarkan aturan dalam parameter

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

Inilah pendapat saya tentang pembantu pembuatan kata sandi acak polos.

Ini memastikan bahwa kata sandi memiliki angka, huruf besar dan kecil serta minimal 3 karakter khusus.

Panjang kata sandi antara 11 dan 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);
}