Random password generator

Here are two code samples that a programmer who is not familiar with the limitations of the random number generators in standard programming libraries might implement:

# include <time.h>
# include <stdio.h>
# include <stdlib.h>

int
main(void)
{
    /* Length of the password */
    unsigned short int length = 8;

    /* Seed number for rand() */
    srand((unsigned int) time(0));

    /* ASCII characters 33 to 126 */
    while (length--) {
        putchar(rand() % 94 + 33);
    }

    printf("\n");

    return EXIT_SUCCESS;
}

function pass_gen(int $length = 8): string
{
    $pass = array();
    for ($i = 0; $i < $length; $i++) {
        $pass[] = chr(mt_rand(32, 126));
    }

    return implode($pass);
}

A variety of methods exist for generating strong, cryptographically secure random passwords. On Unix platforms /dev/random and /dev/urandom are commonly used, either programmatically or in conjunction with a program such as makepasswd.[7] Windows programmers can use the Cryptographic Application Programming Interface function CryptGenRandom. The Java programming language includes a class called SecureRandom. Another possibility is to derive randomness by measuring some external phenomenon, such as timing user keyboard input.

Many computer systems already have an application (typically named "apg") to implement FIPS 181.[8] FIPS 181—Automated Password Generator—describes a standard process for converting random bits (from a hardware random number generator) into somewhat pronounceable "words" suitable for a passphrase.[9] However, in 1994 an attack on the FIPS 181 algorithm was discovered, such that an attacker can expect, on average, to break into 1% of accounts that have passwords based on the algorithm, after searching just 1.6 million passwords. This is due to the non-uniformity in the distribution of passwords generated, which can be addressed by using longer passwords or by modifying the algorithm.[10][11]

function mkpw() { LC_ALL=C tr -dc '[:graph:]' < /dev/urandom | head -c ${1:-16}; echo; }

String[] symbols = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"};
int length = 10;
Random random = SecureRandom.getInstanceStrong();    // as of JDK 8, this should return the strongest algorithm available to the JVM
StringBuilder sb = new StringBuilder(length);
for (int i = 0; i < length; i++) {
    int indexRandom = random.nextInt(symbols.length);
    sb.append(symbols[indexRandom]);
}
String password = sb.toString();

import * as crypto from "crypto";

function generate(length = 16) {
  const uppercase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
  const lowercase = "abcdefghijklmnopqrstuvwxyz";
  const numbers = "0123456789";
  const symbols = "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~";
  const all = uppercase + lowercase + numbers + symbols;
  let password = "";
  for (let index = 0; index < length; index++) {
    const randomNumber = crypto.randomInt(all.length);
    password += all.charAt(randomNumber);
  }
  return password;
}

function generate(length = 12) {
    var uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
    var lowercase = 'abcdefghijklmnopqrstuvwxyz';
    var numbers = '0123456789';
    var symbols = '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~';
    var all = uppercase + lowercase + numbers + symbols;
    var password = '';
    for (var index = 0; index < length; index++) {
        var character = Math.floor(Math.random() * all.length);
        password += all.charAt(character);
    }
    return password;
}

use Crypt::Random::Source qw(get_strong);

while(length($out) < 15) {
    my $a = get_strong(1);
    $a =~ s/[^[:graph:]]//g;
    $out .= $a;
}
print $out;

#!/usr/bin/env python3
import random, string
myrg = random.SystemRandom()
length = 10
alphabet = string.ascii_letters + string.digits
password = str().join(myrg.choice(alphabet) for _ in range(length))
print(password)

	1	2	3	4	5	6
1	a	b	c	d	e	f
2	g	h	i	j	k	l
3	m	n	o	p	q	r
4	s	t	u	v	w	x
5	y	z	0	1	2	3
6	4	5	6	7	8	9

Random password generators normally output a string of symbols of specified length. These can be individual characters from some character set, syllables designed to form pronounceable passwords, or words from some word list to form a passphrase. The program can be customized to ensure the resulting password complies with the local password policy, say by always producing a mix of letters, numbers and special characters. Such policies typically reduce strength slightly below the formula that follows, because symbols are no longer independently produced.

The Password strength of a random password against a particular attack (brute-force search), can be calculated by computing the information entropy of the random process that produced it. If each symbol in the password is produced independently and with uniform probability, the entropy in bits is given by the formula

${\displaystyle H=L\,\log _{2}N=L{\log N \over \log 2}}$

where N is the number of possible symbols and L is the number of symbols in the password. The function log₂ is the base-2 logarithm. H is typically measured in bits.[19][20]

Entropy per symbol for different symbol sets

Symbol set	Symbol count N	Entropy per symbol H
Arabic numerals (0–9) (e.g. PIN)	10	3.32 bits
Hexadecimal numerals (0–9, A–F) (e.g. WEP key)	16	4.00 bits
Case insensitive Latin alphabet (a–z or A–Z)	26	4.70 bits
Case insensitive alphanumeric (a–z or A–Z, 0–9)	36	5.17 bits
Case sensitive Latin alphabet (a–z, A–Z)	52	5.70 bits
Case sensitive alphanumeric (a–z, A–Z, 0–9)	62	5.95 bits
All ASCII printable characters	95	6.55 bits
Diceware word list	7776	12.9 bits

Any password generator is limited by the state space of the pseudo-random number generator used if it is based on one. Thus a password generated using a 32-bit generator is limited to 32 bits entropy, regardless of the number of characters the password contains.

Note, however, that a different type of attack might succeed against a password evaluated as 'very strong' by the above calculation.

A large number of password generator programs and websites are available on the Internet. Their quality varies and can be hard to assess if there is no clear description of the source of randomness that is used and if source code is not provided to allow claims to be checked. Furthermore, and probably most importantly, transmitting candidate passwords over the Internet raises obvious security concerns, particularly if the connection to the password generation site's program is not properly secured or if the site is compromised in some way. Without a secure channel, it is not possible to prevent eavesdropping, especially over public networks such as the Internet. A possible solution to this issue is to generate the password using a client-side programming language such as JavaScript. The advantage of this approach is that the generated password stays in the client computer and is not transmitted to or from an external server.

• Cryptographically secure pseudorandom number generator
• Diceware
• Hardware random number generator
• Key size
• Password length parameter
• Password manager

• Cryptographically Secure Random number on Windows without using CryptoAPI from MSDN
• RFC 4086 on Randomness Recommendations for Security (Replaces earlier RFC 1750.)