Salsa20 D. J. Bernstein
Hash functions and ciphers

# The Salsa20 core

Software speed
The Salsa20 core is a function from 64-byte strings to 64-byte strings: the Salsa20 core reads a 64-byte string x and produces a 64-byte string Salsa20(x).

The Salsa20 stream cipher has a separate page. The Salsa20 stream cipher uses the Salsa20 core to encrypt data.

The Rumba20 compression function has a separate page. The Rumba20 compression function uses the Salsa20 core to compress a 192-byte string to a 64-byte string.

I originally introduced the Salsa20 core as the "Salsa20 hash function," but this terminology turns out to confuse people who think that "hash function" means "collision-resistant compression function." The Salsa20 core does not compress and is not collision-resistant. If you want a collision-resistant compression function, look at Rumba20. (I wonder what the same people think of the FNV hash function, perfect hash functions, universal hash functions, etc.)

History: I introduced Salsa20 in March 2005. It is a refinement of Salsa10, which I introduced in November 2004.

## Definition of the Salsa20 core

The 64-byte input x to Salsa20 is viewed in little-endian form as 16 words x0, x1, x2, ..., x15 in {0,1,...,2^32-1}. These 16 words are fed through 320 invertible modifications, where each modification changes one word. The resulting 16 words are added to the original x0, x1, x2, ..., x15 respectively modulo 2^32, producing, in little-endian form, the 64-byte output Salsa20(x).

Each modification involves xor'ing into one word a rotated version of the sum of two other words modulo 2^32. Thus the 320 modifications involve, overall, 320 additions, 320 xor's, and 320 rotations. The rotations are all by constant distances.

The entire series of modifications is a series of 10 identical double-rounds. Each double-round is a series of 2 rounds. Each round is a set of 4 parallel quarter-rounds. Each quarter-round modifies 4 words.

The complete function is defined as follows:

```     #define R(a,b) (((a) << (b)) | ((a) >> (32 - (b))))
void salsa20_word_specification(uint32 out,uint32 in)
{
int i;
uint32 x;
for (i = 0;i < 16;++i) x[i] = in[i];
for (i = 20;i > 0;i -= 2) {
x[ 4] ^= R(x[ 0]+x, 7);  x[ 8] ^= R(x[ 4]+x[ 0], 9);
x ^= R(x[ 8]+x[ 4],13);  x[ 0] ^= R(x+x[ 8],18);
x[ 9] ^= R(x[ 5]+x[ 1], 7);  x ^= R(x[ 9]+x[ 5], 9);
x[ 1] ^= R(x+x[ 9],13);  x[ 5] ^= R(x[ 1]+x,18);
x ^= R(x+x[ 6], 7);  x[ 2] ^= R(x+x, 9);
x[ 6] ^= R(x[ 2]+x,13);  x ^= R(x[ 6]+x[ 2],18);
x[ 3] ^= R(x+x, 7);  x[ 7] ^= R(x[ 3]+x, 9);
x ^= R(x[ 7]+x[ 3],13);  x ^= R(x+x[ 7],18);
x[ 1] ^= R(x[ 0]+x[ 3], 7);  x[ 2] ^= R(x[ 1]+x[ 0], 9);
x[ 3] ^= R(x[ 2]+x[ 1],13);  x[ 0] ^= R(x[ 3]+x[ 2],18);
x[ 6] ^= R(x[ 5]+x[ 4], 7);  x[ 7] ^= R(x[ 6]+x[ 5], 9);
x[ 4] ^= R(x[ 7]+x[ 6],13);  x[ 5] ^= R(x[ 4]+x[ 7],18);
x ^= R(x+x[ 9], 7);  x[ 8] ^= R(x+x, 9);
x[ 9] ^= R(x[ 8]+x,13);  x ^= R(x[ 9]+x[ 8],18);
x ^= R(x+x, 7);  x ^= R(x+x, 9);
x ^= R(x+x,13);  x ^= R(x+x,18);
}
for (i = 0;i < 16;++i) out[i] = x[i] + in[i];
}
```
Here in is the sequence of input words, and out is the sequence of output words. The caller handles any necessary endianness conversion and alignment.