Computers are deterministic: they predicably follow instructions. Two computers running the same code at the same time with the same inputs will produce the same output.

In fact, before the introduction of special random number generation CPU instructions, such as RDRAND and RDSEED ^[1], it was theoretically impossible for a computer program to generate random numbers. ^[2]

Node.js and JavaScript have a Math.random() and other programming languages have similar functions. However, these use pseudorandom number generators.

An old example of pseudorandom number generators is the rand48() function in the C programming language standard library. The default implementation uses an update rule, such as the following:

r' = (25214903917 * r + 11) % 281474976710656

Starting with r = 1, the next ten ‘random’ numbers are as follows:

To an untrained eye, these numbers appear to be ‘random’: the third column looks like a list of ‘random’ numbers between 0 and 1. They’re good enough for games and for generating random visualizations.

Node.js (and Chrome) use a more complex function, XorShift128+, defined in the Node.js C++ source code as follows:

It isn’t necessary to understand what this code does. My point is simply that the function is far too simple to use for security purposes. Future numbers can be easily guessed based on older numbers. So, if a website uses Math.random() to generate login codes for SMS messages (i.e., in a multi-factor authentication system), an adversary will be able to predict the login codes sent to users, without needing access to their phones.

While computers cannot generate true random numbers, cryptographically secure pseudorandom numbers (CSPRNG) are considered a safe alternative. CSPRNGs start with a small amount of initial random data (e.g., mouse clicks, keyboard data, network packets). They then use extremely complex update rules to generate an endless stream of numbers that appear random. The rules are chosen so that there is no known technique to predict future values based on their outputs.

Node.js and modern web browsers expose CSPRNGs for situations where secure random numbers are required.

The following code generates 16 cryptographically secure random bytes in Node.js:

A crypto object has also been available in modern web browsers since 2014. The following code generates 16 random numbers in a browser: ^[3]

A one-way hash function transforms any amount of data into a single fixed-length summary. For example, the following table shows the result of using the SHA-256 hash function on different data:

The table above illustrates some desirable properties of a one-way hash:

A good one-way hash algorithm has additional properties:

A one-way hash gets its name from the fact that it works in only one direction: it can go from input to output, but reversing from output to a matching input is nearly impossible.

Most modern one-way hash functions work internally by repeatedly applying simple functions that substitute and permute data. Each operation introduces a little bit of confusion and uncertainty. The result of repeated application of the simple operations is so complex that the only way to go from output to input is to randomly guess-and-check possible inputs.

Two common applications of one-way hash functions are as follows:

Symmetric encryption/decryption is a method for protecting data using a single key or password. The name symmetric comes from the idea that encryption and decryption use the same key. This approach may also be known as secret-key cryptography because the key is a password to keep secret.

The following table demonstrates the result of using the AES-256-CBC symmetric encryption algorithm on various inputs:

Note that changing either the input or the password results in a completely different output. Without the password, the output is meaningless. The password will decrypt the output back into the original text.

If the password is known, then symmetric key encryption is fast during both encryption and decryption. However, if the password is unknown, then it is extremely difficult (i.e., impossible) to find the input from the output. ^[4]

Asymmetric encryption/decryption was invented in the 1970s to protect data using a pair of matching keys. This approach is also called public-key cryptography because one key is usually made public and the other is kept secret. In an asymmetric cryptosystem, the private key decrypts messages encrypted by the public key (and vice-versa).

RSA and elliptic curve cryptography are the two main approaches to public-key cryptography. Both depend on mathematical operations that are easy to compute in one direction, but harder to reverse.

RSA depends on factorization being difficult. For example, using pen-and-paper, most people would be able to multiply 89681 and 96079 to get 8616460799 within a minute or two. However, it might take years to reverse the operation to find the factors of 8616460799, without a computer. ^[5] Computers are faster than people, so RSA depends on massive numbers with over 600 digits (2048 bits).

Elliptic curve cryptography also uses an operation that is difficult to reverse. Elliptic curves are mathematical structures with a group operator. The mathematical symbol ‘+’ is often used to represent this operator, even though it is not ordinary addition. For example, in an elliptic curve, it is easy to combine a value with itself eight times: P = G + G + G + G + G + G + G + G. However, it is difficult to calculate that the group operator was applied eight times when given only G and P. In practice, systems such as Curve25519 apply the group operator many more times. For example, rather than using the one-digit number ‘eight’, elliptic curve systems use 77 digit numbers (256 bit) or greater.

The first step in using an asymmetric cryptosystem, is to generate a public and private key. For example, on my computer, I used the openssl command ^[6] to randomly and securely generate the following RSA private key and its matching public key.

The public key can be safely shared with anyone but the private key must be kept secret. ^[7]

In RSA, there is no difference between ‘encryption’ and ‘decryption’: the same algorithm accepts the private or public key. The following table illustrates the result of encrypting input data.

Notice in the table above that the public key and private key act as opposites of each other. Applying the public key and then the private key will get you back to the input. The input is also recovered if the private key is applied first, followed by the public key. However, applying the public key twice (or any other key) will result in unrelated output.

This public/private key structure makes it possible for two strangers to communicate with each other privately. If I want to send you a private message, I use your public key to encrypt the message. As you are the only person with the matching private key, only you can decrypt the message. You can then reply to me by using my public key to send a response back: only I will be able to decrypt the message with my matching private key.

Asymmetric encryption also makes it possible to create digital signatures. A digital signature is the reverse of an encrypted message: it is a public message from a person that only the sender can generate. If I encrypt a message with my private key, anyone with the public key can decrypt the message. Of course, this doesn’t offer any secrecy to the message. Yet, it tells the world that I sent the message because I am the only person with the private key who could have encrypted the message.