**Salsa20** dan saudara terdekatnya, **ChaCha**, adalah penyandian aliran yang dikembangkan oleh Daniel J. Bernstein. Salsa20, sandi aslinya, didesain pada tahun 2005, lalu dikumpulkan ke eSTREAM oleh Bernstein. ChaCha adalah perubahan dari Salsa20 yang dipublikasikan pada tahun 2008. Ia menggunakan fungsi ronde baru yang meningkatkan penghamburan dan meningkatkan kinerja pada beberapa arsitektur.

Kedua penyandian tersebut dibangun dari fungsi acak semu berdasarkan operasi tambah-putar-XOR (ARX). Tugas utamanya adalah pemetaan sebuah kunci 256 bit, sebuah *nonce* 64 bit, dan sebuah pencacah 64 bit ke blok aliran kunci 512 bit (ada pula versi Salsa yang menggunakan kunci 128 bit). Hal ini memberikan Salsa20 dan Chaca keuntungan, yaitu pengguna dapat langsung menuju ke lokasi tertentu dalam aliran kunci dalam waktu tetap (konstan). Salsa20 menawarkan kecepatan 4–14 siklus per bita dalam perangkat lunak pada prosesor x86 dan kinerja perangkat keras yang cukup. Sandi ini tidak dipatenkan, bahkan Bernstein telah menulis beberapa implementasi dalam domain publik yang dioptimalkan untuk arsitektur pada umumnya.

Struktur
--------

Secara internal, penyandian ini menggunakan penjumlahan per bit dengan (⊕ atau XOR), penjumlahan 32 bit dengan mod 232 (⊞), dan operasi geseran melingkar berjarak tetap (<<<). Penggunaan operasi tambah-putar-XOR menghindari peluang serangan pewaktuan dalam penerapan perangkat lunak. Status internalnya terdiri dari 16 kata 32 bit yang disusun dalam matriks 4×4.

|  |  |  |  |
| --- | --- | --- | --- |
| 0 | 1 | 2 | 3 |
| 4 | 5 | 6 | 7 |
| 8 | 9 | 10 | 11 |
| 12 | 13 | 14 | 15 |

Status internalnya terdiri dari   delapan kata untuk kunci,   dua kata untuk letak aliran,   dua kata untuk nilai yang dipakai sekali (*nonce*; intinya bit-bit tambahan untuk letak aliran), dan   empat kata tetapan:

Status awal Salsa20| "expa" | Kunci | Kunci | Kunci |
| Kunci | "nd 3" | *Nonce* | *Nonce* |
| Letak | Letak | "2-by" | Kunci |
| Kunci | Kunci | Kunci | "te k" |

Kata-kata tetapan berbunyi "expand 32-byte k" dalam ASCII (empat kata tersebut adalah "expa", "nd 3", "2-by", dan "te k"). Ini adalah contoh bilangan tanpa tujuan khusus. Inti operasi dalam Salsa20 adalah seperempat ronde `QR(a, b, c, d)` yang menerima empat kata sebagai masukan dan menghasilkan empat kata:

```
b ^= (a + d) <<< 7;
c ^= (b + a) <<< 9;
d ^= (c + b) <<< 13;
a ^= (d + c) <<< 18;
```

Ronde bernomor ganjil menerapkan `QR(a, b, c, d)` kepada tiap kolom dalam matriks 4×4, sedangkan ronde bernomor genap menerapkannya kepada tiap baris. Dua ronde berturutan (ronde kolom dan ronde baris) disebut sebagai ronde ganda:

```
// Ronde ganjil
QR( 0,  4,  8, 12)	// kolom 1
QR( 5,  9, 13,  1)	// kolom 2
QR(10, 14,  2,  6)	// kolom 3
QR(15,  3,  7, 11)	// kolom 4
// Ronde genap
QR( 0,  1,  2,  3)	// baris 1
QR( 5,  6,  7,  4)	// baris 2
QR(10, 11,  8,  9)	// baris 3
QR(15, 12, 13, 14)	// baris 4
```

Berikut penerapan Salsa20 dalam C/C++.

```
#include <stdint.h>
#define ROTL(a,b) (((a) << (b)) | ((a) >> (32 - (b))))
#define QR(a, b, c, d)( \
 b ^= ROTL(a + d, 7), \
 c ^= ROTL(b + a, 9), \
 d ^= ROTL(c + b,13), \
 a ^= ROTL(d + c,18))
#define ROUNDS 20
 
void salsa20\_block(uint32\_t out[16], uint32\_t const in[16])
{
 int i;
 uint32\_t x[16];

 for (i = 0; i < 16; ++i)
 x[i] = in[i];
 // 10 perulangan × 2 ronde/perulangan = 20 ronde
 for (i = 0; i < ROUNDS; i += 2) {
 // Ronde ganjil
 QR(x[ 0], x[ 4], x[ 8], x[12]); // kolom 1
 QR(x[ 5], x[ 9], x[13], x[ 1]); // kolom 2
 QR(x[10], x[14], x[ 2], x[ 6]); // kolom 3
 QR(x[15], x[ 3], x[ 7], x[11]); // kolom 4
 // Ronde genap
 QR(x[ 0], x[ 1], x[ 2], x[ 3]); // baris 1
 QR(x[ 5], x[ 6], x[ 7], x[ 4]); // baris 2
 QR(x[10], x[11], x[ 8], x[ 9]); // baris 3
 QR(x[15], x[12], x[13], x[14]); // baris 4
 }
 for (i = 0; i < 16; ++i)
 out[i] = x[i] + in[i];
}

```

Pada baris terakhir, larik yang telah tercampur ditambahkan, kata demi kata, ke larik asal untuk mendapatkan blok aliran kunci 64 bita. Hal ini penting karena ronde pencampuran ini dengan sendirinya bisa dibalik (*invertible*). Dengan kata lain, operasi yang dibalik bisa menghasilkan matriks 4×4 asal, termasuk kuncinya. Penambahan larik yang telah tercampur ke asalnya membuatnya tidak mungkin untuk memulihkan input. (Teknik ini juga dipakai dalam fungsi hash dari MD4 sampai SHA-2.)

Salsa20 melakukan 20 ronde pencampuran dari inputnya. Namun, pengurangan ronde pada varian Salsa20/8 dan Salsa20/12 dengan 8 dan 12 ronde juga dikenalkan.

Analisis kriptografi Salsa20
----------------------------

Varian ChaCha
-------------

Pada tahun 2008, Bernstein memublikasikan keluarga **ChaCha** yang bersaudara dengan Salsa dan bertujuan untuk meningkatkan penghamburan per ronde sekaligus memiliki kinerja yang sama atau lebih baik. Makalah Aumasson dkk. juga menyerang ChaCha dan berhasil hingga satu ronde lebih sedikit: untuk 256 bit, ChaCha6 dengan kompleksitas 2139 dan ChaCha7 dengan kompleksitas 2248. Untuk 128 bit, ChaCha6 dalam 2107 juga tercapai, tetapi mengeklaim bahwa serangan tersebut gagal memecahkan ChaCha7 128 bit.

Seperti Salsa20, status awal ChaCha terdiri dari 128 bit tetapan, 256 bit kunci, 64 bit pencacah, dan 64 bit nilai yang hanya dipakai sekali (*nonce*) dan ditata sebagai matriks 4×4 dari kata 32 bit. Namun, ChaCha menata ulang beberapa kata dalam status awalnya:

Status awal of ChaCha| "expa" | "nd 3" | "2-by" | "te k" |
| Kunci | Kunci | Kunci | Kunci |
| Kunci | Kunci | Kunci | Kunci |
| Letak | Letak | *Nonce* | *Nonce* |

Tetapan yang dipakai sama dengan Salsa20 ("expand 32-byte k"). ChaCha mengganti seperempat ronde Salsa20 `QR(a, b, c, d)` dengan berikut:

```
a += b; d ^= a; d <<<= 16;
c += d; b ^= c; b <<<= 12;
a += b; d ^= a; d <<<= 8;
c += d; b ^= c; b <<<= 7;
```

Perhatikan bahwa versi ini memperbarui tiap kata dua kali, sedangkan seperempat ronde Salsa20 hanya memperbarui tiap kata sekali. Selain itu, seperempat ronde ChaCha menghamburkan perubahan lebih cepat. Rata-rata, setelah mengganti satu bit input, seperempat ronde Salsa20 akan mengganti 8 bit keluaran, sedangkan ChaCha akan mengganti 12,5 bit keluaran.

Seperempat ronde ChaCha memiliki jumlah pertambahan, XOR, dan geseran melingkar yang sama dengan seperempat ronde Salsa20. Namun, karena dua geseran melingkar kelipatan 8, ada pengoptimalan pada beberapa arsitektur, termasuk x86. Terlebih lagi, pemformatan input telah ditata untuk mendukung pengoptimalan penerapan SSE yang efisien. Alih-alih pergantian ronde kolom dan ronde baris, yang dipakai adalah pergantian ronde kolom dan diagonal. Seperti Salsa20, ChaCha menata enam belas kata 32 bit dalam matriks 4×4. Berikut indeks elemen matriks dari 0 sampai 15.

|  |  |  |  |
| --- | --- | --- | --- |
| 0 | 1 | 2 | 3 |
| 4 | 5 | 6 | 7 |
| 8 | 9 | 10 | 11 |
| 12 | 13 | 14 | 15 |

ChaCha20 menggunakan 10 perulangan ronde ganda. Ronde ganda ChaCha adalah sebagai berikut:

```
// Ronde ganil
QR(0, 4,  8, 12)	// kolom 1
QR(1, 5,  9, 13)	// kolom 2
QR(2, 6, 10, 14)	// kolom 3
QR(3, 7, 11, 15)	// kolom 4
// Ronde genap
QR(0, 5, 10, 15)	// diagonal 1 (diagonal utama)
QR(1, 6, 11, 12)	// diagonal 2
QR(2, 7,  8, 13)	// diagonal 3
QR(3, 4,  9, 14)	// diagonal 4
```

Berikut penerapan ChaCha20 dalam C/C++.

```
#define ROTL(a,b) (((a) << (b)) | ((a) >> (32 - (b))))
#define QR(a, b, c, d) ( \
 a += b, d ^= a, d = ROTL(d,16), \
 c += d, b ^= c, b = ROTL(b,12), \
 a += b, d ^= a, d = ROTL(d, 8), \
 c += d, b ^= c, b = ROTL(b, 7))
#define ROUNDS 20
 
void chacha\_block(uint32\_t out[16], uint32\_t const in[16])
{
 int i;
 uint32\_t x[16];

 for (i = 0; i < 16; ++i) 
 x[i] = in[i];
 // 10 perulangan × 2 ronde/perulangan = 20 ronde
 for (i = 0; i < ROUNDS; i += 2) {
 // Ronde ganjil
 QR(x[0], x[4], x[ 8], x[12]); // kolom 0
 QR(x[1], x[5], x[ 9], x[13]); // kolom 1
 QR(x[2], x[6], x[10], x[14]); // kolom 2
 QR(x[3], x[7], x[11], x[15]); // kolom 3
 // Ronde genap
 QR(x[0], x[5], x[10], x[15]); // diagonal 1 (diagonal utama)
 QR(x[1], x[6], x[11], x[12]); // diagonal 2
 QR(x[2], x[7], x[ 8], x[13]); // diagonal 3
 QR(x[3], x[4], x[ 9], x[14]); // diagonal 4
 }
 for (i = 0; i < 16; ++i)
 out[i] = x[i] + in[i];
}

```

ChaCha adalah dasar dari fungsi hash BLAKE, salah satu finalis dalam kompetisi fungsi hash NIST, dan turunan BLAKE2/3 yang diatur agar jauh lebih cepat. Ia juga menentukan varian dengan enam belas kata 64 bit (1024 bit status) dengan tetapan rotasi yang sesuai.

### Adopsi ChaCha20

Lihat pula
----------

* Speck, penyandian tambah-putar-XOR yang dikembangkan oleh NSA

Referensi
---------

1. 1 2  Daniel J. Bernstein (24 Desember 2007). "The Salsa20 family of stream ciphers" (PDF).
2. 1 2  Daniel J. Bernstein (16 Mei 2013). "Snuffle 2005: the Salsa20 encryption function".
3. 1 2  Jean-Philippe Aumasson, Simon Fischer, Shahram Khazaei, Willi Meier, dan Christian Rechberger (14 Maret 2008). "New Features of Latin Dances" (PDF). Pemeliharaan CS1: Menggunakan parameter penulis (link)
4. 1 2 3 4  Bernstein, Daniel (28 Januari 2008). "ChaCha, a variant of Salsa20" (PDF). Diakses tanggal 3 Juni 2018.
5. ↑  "Salsa20: Software speed". 11 Mei 2007.
6. ↑  Daniel J. Bernstein (25 April 2008). "The ChaCha family of stream ciphers".
7. ↑  Neves, Samuel (7 Oktober 2009). "Faster ChaCha implementations for Intel processors". Diarsipkan dari versi asli tanggal 2017-03-28. Diakses tanggal 7 September 2016. two of these constants are multiples of 8; this allows for a 1 instruction rotation in Core2 and later Intel CPUs using the **pshufb** instruction
8. ↑  Y. Nir (Check Point), A. Langley (Google Inc.) (Mei 2015). "ChaCha20 and Poly1305 for IETF Protocols: RFC 7539". Pemeliharaan CS1: Menggunakan parameter penulis (link)

Pranala luar
------------

* (Inggris) Snuffle 2005: the Salsa20 encryption function
* (Inggris) Salsa20 specification (PDF)
* (Inggris) Salsa20/8 and Salsa20/12 (PDF)
* (Inggris) The eSTREAM Project: Salsa20 Diarsipkan 2016-04-05 di Wayback Machine.
* (Inggris) The ChaCha family of stream ciphers
* (Inggris) Salsa20 Usage & Deployment

| * l
* b
* s
Penyandian aliran |
| --- |
| Sandi yang dipakai luas | 
* A5/1
* A5/2
* E0
* Crypto-1
* RC4
* ChaCha

 |
| Portofolio eSTREAM | 

|  |  |
| --- | --- |
| Perangkat lunak | 
* HC-256
* Rabbit
* Salsa20
* SOSEMANUK

 |
| Perangkat keras | 
* Grain
* MICKEY
* Trivium

 |

 |
| Sandi lainnya | 
* Achterbahn
* F-FCSR
* FISH
* ISAAC
* MUGI
* ORYX
* Panama
* Phelix
* Pike
* Py
* QUAD
* Scream
* SEAL
* SNOW
* SOBER
* SOBER-128
* VEST
* VMPC
* WAKE

 |
| Teori | 
* Penyandian blok dalam mode aliran
* Register geser
* LFSR
* NLFSR
* Pembangkit penyusutan
* Fungsi T
* Vektor inisialisasi

 |
| Penyerangan(analisis kriptografi) | 
* Kekebalan korelasi
* Serangan korelasi
* Serangan penyandian aliran

 |