RC4 adalah algoritma enkripsi yang sering digunakan oleh pembuat malware karena kesederhanaannya dan keamanannya yang cukup baik dibandingkan algoritma sederhana lainnya. Berbeda dengan beberapa algoritma enkripsi lain yang tersedia dalam API Windows, RC4 tidak disediakan secara bawaan dalam sistem operasi, sehingga para pembuat malware harus mengimplementasikannya sendiri dalam kode mereka.

Karena diimplementasikan secara manual, RC4 bisa sulit dikenali bagi para reverse engineer pemula yang menganalisis kode malware. Algoritma ini bersifat simetris, yang berarti menggunakan satu kunci rahasia untuk proses enkripsi dan dekripsi. RC4 terdiri dari dua tahap utama: Key-Scheduling Algorithm (KSA) yang mengatur kunci, dan Pseudo-Random Generation Algorithm (PRGA) yang menghasilkan aliran data terenkripsi.

Dalam konteks reverse engineering, memahami bagaimana RC4 diimplementasikan dalam kode berbahaya bisa membantu dalam mendeteksi dan menganalisis malware yang menggunakannya untuk menyembunyikan komunikasi atau data berbahaya.

Implementasi Python

Contoh kita ingin mengenkripsi plaintext "Machine Learning" dengan key "secret"

# Kunci yang digunakan untuk enkripsi/dekripsi
key = "secret"

# Plaintext yang akan dienkripsi
plaintext = "Machine Learning"

# Konversi key ke dalam bentuk list ASCII
key = [ord(c) for c in key]
print(f"ASCII key : {key}")

# Konversi plaintext ke dalam bentuk list ASCII
plaintext = [ord(c) for c in plaintext]
print(f"ASCII plaintext : {plaintext}")


# Output:
# ASCII key : [115, 101, 99, 114, 101, 116]
# ASCII plaintext : [77, 97, 99, 104, 105, 110, 101, 32, 76, 101, 97, 114, 110, 105, 110, 103]

Key-scheduling algorithm

Bagian key-scheduling dalam algoritma RC4 bertugas untuk membentuk array berisi 256 byte berdasarkan secret key yang diberikan. Array ini bisa dianggap sebagai versi yang lebih besar dari key awal. Nantinya, array ini akan digunakan dalam proses enkripsi dan dekripsi untuk mengubah data asli menjadi ciphertext dan sebaliknya.

# Proses KSA (Key-Scheduling Algorithm)

# Inisialisasi S-box
S = list(range(256))

j = 0
for i in range(256):
    j = (j + S[i] + key[i % len(key)]) % 256
    S[i], S[j] = S[j], S[i]

Contoh ouput setelah looping 3x

j = (j + S[i] + key[i % len(key)]) % 256
j = (0 + 0 + key[0 % 6]) % 256
j = (0 + key[0]) % 256
j = (0 + 115) % 256
j = (115) % 256
j = 115

SWAP
S[0] = 0
S[115] = 115
to
S[0] = 115
S[115] = 0
-----------------------

j = (j + S[i] + key[i % len(key)]) % 256
j = (115 + 1 + key[1 % 6]) % 256
j = (116 + key[1]) % 256
j = (116 + 101) % 256
j = (217) % 256
j = 217

SWAP
S[1] = 1
S[217] = 217
to
S[1] = 217
S[217] = 1
-----------------------

j = (j + S[i] + key[i % len(key)]) % 256
j = (217 + 2 + key[2 % 6]) % 256
j = (219 + key[2]) % 256
j = (219 + 99) % 256
j = (318) % 256
j = 62

SWAP
S[2] = 2
S[62] = 62
to
S[2] = 62
S[62] = 2
-----------------------

Proses PRGA (Pseudo-Random Generation Algorithm)

Bagian pseudo-random generation (PRGA) dari algoritma RC4 berfungsi untuk menghasilkan nilai acak semu yang digunakan dalam proses enkripsi dan dekripsi. Proses ini masih melibatkan pertukaran byte seperti pada tahap key-scheduling, tetapi dengan tambahan operasi XOR antara nilai yang dihasilkan dan byte dari data yang akan dienkripsi atau didekripsi.

# Proses PRGA (Pseudo-Random Generation Algorithm)
i = 0
j = 0
keystream = []
for _ in range(len(plaintext)):
    i = (i + 1) % 256
    j = (j + S[i]) % 256
    S[i], S[j] = S[j], S[i]
    keystream.append(S[t])

Contoh 3x loop

i = (i + 1) % 256
i = (0 + 1) % 256
i = (1) % 256
i = 1
i = 1

j = (j + S[i]) % 256
j = (0 + 208) % 256
j = (208) % 256
j = 208
j = 208

SWAP
S[1] = 208
S[208] = 39
to
S[1] = 39
S[208] = 208

t = (S[i] + S[j]) % 256
t = (39 + 208) % 256
t = (247) % 256
t = 247
S[t] = 237
-----------------------

i = (i + 1) % 256
i = (1 + 1) % 256
i = (2) % 256
i = 2
i = 2

j = (j + S[i]) % 256
j = (208 + 198) % 256
j = (406) % 256
j = 150
j = 150

SWAP
S[2] = 198
S[150] = 251
to
S[2] = 251
S[150] = 198

t = (S[i] + S[j]) % 256
t = (251 + 198) % 256
t = (449) % 256
t = 193
S[t] = 54
-----------------------

i = (i + 1) % 256
i = (2 + 1) % 256
i = (3) % 256
i = 3
i = 3

j = (j + S[i]) % 256
j = (150 + 20) % 256
j = (170) % 256
j = 170
j = 170

SWAP
S[3] = 20
S[170] = 147
to
S[3] = 147
S[170] = 20

t = (S[i] + S[j]) % 256
t = (147 + 20) % 256
t = (167) % 256
t = 167
S[t] = 210
-----------------------

Finalisasi

# XOR antara keystream dan plaintext untuk mendapatkan ciphertext
ciphertext = [plaintext[k] ^ keystream[k] for k in range(len(plaintext))]
ciphertext = [hex(c) for c in ciphertext]

# Menampilkan hasil enkripsi
print("Ciphertext:", ' '.join(map(str, ciphertext)))

# Output:
# Ciphertext: 0xa0 0x57 0xb1 0x74 0xeb 0xca 0xb3 0x86 0x7e 0xae 0xda 0xae 0x9d 0x8f 0x9b 0x50

Decrypt

# Proses dekripsi dengan XOR antara ciphertext dan keystream yang sama
decrypted = [int(ciphertext[k], 0) ^ keystream[k] for k in range(len(ciphertext))]

# Mengonversi kembali hasil dekripsi ke string
decrypted_text = ''.join(chr(c) for c in decrypted)

# Menampilkan hasil dekripsi
print("Decrypted:", decrypted_text)

# Output:
# Decrypted: Machine Learning