Password

// A password generator: sixteen characters, each drawn straight from the operating system's
// entropy, from an alphabet chosen so nobody misreads the result.
//
// Two decisions carry the whole program.
//
// Where the randomness comes from. A seeded generator such as `Pcg64Dxsm` is predictable by
// design, so a password made from one is only as secret as its seed. Here every character comes
// from the Entropy package directly, and every request is checked: if the system has no
// randomness to give, the program stops rather than invent some.
//
// How a random byte becomes a character. A byte has 256 values and the alphabet has 57
// characters, and 57 does not divide 256. Taking `byte % 57` would make the first 28 characters
// (256 - 4 * 57 of them) a little more likely than the rest. So a byte from the uneven top of the
// range is thrown away and another is drawn: rejection sampling. Every character is then exactly
// as likely as every other.
//
// The result has 16 * log2(57), about 93 bits of strength. The output differs on every run.
import Entropy::{ EntropyError, Fill };
import Io::PrintLine;

// Lowercase, uppercase and digits, without the look-alikes l, I, O, 0 and 1. A character that
// can be misread costs more in mistyped passwords than it adds in strength.
const Alphabet = "abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789";

// An index into the alphabet, every one equally likely, or why no entropy was available.
func DrawIndex() -> uint ! EntropyError {
    let count = Alphabet.length;
    // The largest multiple of `count` that fits in a byte's 256 values: 228 for 57 characters.
    // Bytes below it split evenly among the characters; bytes from it upwards are rejected.
    let limit = 256 - 256 % count;
    loop {
        var drawn: byte = 0;
        Fill(@drawn as *var opaque, 1)?;
        if (drawn as uint) < limit {
            return (drawn as uint) % count;
        }
    }
}

func Reason(error: EntropyError) -> char8[..] {
    return match error {
        EntropyError::Unsupported => "this system has no entropy source",
        EntropyError::Interrupted => "the request was interrupted",
        EntropyError::Failed => "the system refused",
        EntropyError::TooLarge => "too many bytes in one request"
    };
}

func Main() -> int {
    PrintLine("alphabet  {} ({} characters)", Alphabet, Alphabet.length);

    // The password is built in full before any of it is printed, so a failure halfway leaves
    // nothing on the screen that could be mistaken for a shorter password.
    var password: char8[16];
    for i in 0..password.length {
        let index = DrawIndex() catch {
            error => {
                PrintLine("no password: {}", Reason(error));
                return 1;
            }
        };
        password[i] = Alphabet[index];
    }

    // `PrintLine` prints text views, not fixed-size arrays, so `password[..]` views the whole
    // array. The view is writable, because the array is `var`, and it prints just the same.
    PrintLine("password  {}", password[..]);
    return 0;
}