SanzSkuy at 06:06, 23 March 2025

2025-03-23T06:06:17Z

← Older revision		Revision as of 06:06, 23 March 2025
Line 1:		Line 1:
	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.		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.		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.		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.

SanzSkuy at 06:03, 23 March 2025

2025-03-23T06:03:30Z

← Older revision		Revision as of 06:03, 23 March 2025
Line 6:		Line 6:

	= Implementasi Python =		= Implementasi Python =
	Contoh kita ingin mengenkripsi plaintext "~~malware~~" dengan key "secret"		Contoh kita ingin mengenkripsi plaintext "Machine Learning" dengan key "secret"

	<syntaxhighlight lang="python">		<syntaxhighlight lang="python">

SanzSkuy: Created page with "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 rever..."

2025-03-23T06:03:13Z

Created page with "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 rever..."

New page

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 "malware" dengan key "secret"

<syntaxhighlight lang="python">
# 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]

</syntaxhighlight>

== 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.
<syntaxhighlight lang="python">
# 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]
</syntaxhighlight>

Contoh ouput setelah looping 3x

<syntaxhighlight>

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
-----------------------
</syntaxhighlight>

== 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.

<syntaxhighlight lang="python">
# 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])
</syntaxhighlight>

Contoh 3x loop
<syntaxhighlight>
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
-----------------------
</syntaxhighlight>

Finalisasi
<syntaxhighlight lang="python">
# 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
</syntaxhighlight>

Decrypt

<syntaxhighlight lang="python">
# 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
</syntaxhighlight>

RC4 Algorithm - Revision history

SanzSkuy at 06:06, 23 March 2025

SanzSkuy at 06:03, 23 March 2025