Random Byte Generator

What does a random byte generator do?

It produces random bytes, the 8-bit values from 0 to 255 that every file and network message is built from. This tool asks your browser's cryptographic random source for 1 to 256 bytes and prints them as decimal numbers separated by spaces. Each value is used as delivered, so all 256 values are exactly equally likely.

Generating bytes

1. Set Bytes to the number you need (1 to 256; the default is 16).
2. Click Generate.
3. Copy the line of numbers.

Sixteen bytes is 128 bits, the size of an AES-128 key or a UUID. Thirty-two bytes is 256 bits.

Example: 16 bytes, read three ways

A 16-byte run returned:

112 3 182 81 225 232 238 177 2 75 42 10 109 183 148 128

Here are a few of those bytes in hex and binary, and what each would mean if a program tried to read the sequence as UTF-8 text (RFC 3629):

That mix is the point. Random bytes contain control characters, line breaks, high-bit values and broken multi-byte sequences, exactly the things that trip up code which assumes its input is clean text.

Turning the output into code

Swap the spaces for commas and wrap the result in your language's array syntax:

const bytes = new Uint8Array([112, 3, 182, 81, 225, 232, 238, 177]);

data = bytes([112, 3, 182, 81, 225, 232, 238, 177])

unsigned char data[] = {112, 3, 182, 81, 225, 232, 238, 177};

Decimal is the one format every language accepts in an array literal without a prefix, which is why this tool uses it rather than hex.

Fuzzing text decoders with random bytes

A quick way to test a parser, decoder or file importer is to feed it random bytes and make sure it fails cleanly instead of crashing or producing garbage silently. Some numbers worth knowing:

• Half of all random bytes are 128 or above, outside ASCII. The chance that 16 random bytes are all ASCII is 1 in 65,536.
• RFC 3629 states that the byte values C0, C1 and F5 to FF never appear in valid UTF-8. That's 13 of the 256 values, and the chance that at least one of them turns up in 16 random bytes is about 57%.
• Even without those values, continuation bytes (128 to 191) appearing without a lead byte break most sequences. When we decoded 100,000 random 16-byte blocks with a strict UTF-8 decoder, more than 99.9% were rejected.

A good decoder should report an error for these. The decimal to ASCII converter shows another common behaviour: it reads each number as a character code, so 182 becomes ¶ (the Latin-1 reading) instead of an error.

Where the bytes come from

The tool calls crypto.getRandomValues on a Uint8Array of the length you chose and joins the values with spaces. MDN describes this source as a pseudo-random generator seeded with enough entropy to be suitable for cryptographic purposes; the designs behind such generators are covered by NIST SP 800-90A. Unlike the site's number-range generators, there's no rejection sampling here because none is needed: the range you want (0 to 255) is exactly what one byte holds.

The bytes are generated on your device and aren't uploaded or logged.

Good uses

To read individual values in other bases, use the decimal to hex and decimal to binary converters, one number at a time. If you'd rather have the bytes as a single compact string, the random hex generator is the better fit.