Algoritma Enkripsi dan Dekripsi RC 6

 

Algoritma Enkripsi dan Dekripsi RC 6

 

Algoritma RC6 seperti juga RC5 merupakan algoritma cipher yang terparameterisasi. RC6 secara tepat ditulis sebagai:

 

RC6 – w / r / b

 

Nilai parameter w, r, dan b menyatakan hal yang sama seperti yang ditunjukkan dalam algoritma RC5. Algoritma RC6 yang dipakai sebagai kandidat AES adalah RC6-32/20/b,(w)yang berarti ukuran word 32 bit,(r) jumlah ronde 20 kali, dengan panjang kunci b ditentukan pengguna.

 

 

Key Expansion Algorithm

 

Algoritma untuk membangkitkan kunci internal sama seperti pada RC5. Nilai konstanta Pw dan Qw yang digunakan juga sama, tetapi ukuran array S tidak sama dengan yang seperti RC5. Ukuran t dari array S dalam RC6 adalah t = 2(r+2), yang berarti terdapat

lebih banyak kunci internal yang dibangkitkan daripada jumlah kunci internal RC5. Berikut

algoritmanya:

 

S[0] = Pw

for i = 1 to (2r + 3) do

S[i] = S[i – 1] + Qw

i = 0

j = 0

A = 0

B = 0

for 3 × max(c, (2r + 4)) times do

S[i] = (S[i] + A + B) <<< 3

A = S[i]

L[i] = (L[j] + A + B) <<< 3

B = L[i]

 

Algoritma Enkripsi

 

Fungsi enkripsi menerima input 1 blok plaintext yang terbagi dalam 4 register yangmasing-masing berupa w-bit word, yaitu A, B, C, dan D. Ciphertext hasil proses terbagi dan disimpan dalam A, B, C, dan D. Dalam proses enkripsi diperlukan tabel kunci S yang dianggap telah didapat dari proses sebelumnya. Secara lebih detil, proses enkripsi dengan RC6 dapat dibagi dalam beberapa langkah. Dalampenjelasan berikut, notasi (A,B,C,D) = (B,C,D,A) berarti adalah operasi assignment yang dilakukan parallel (bersamaan) untuk setiap elemen di ruas kanan ke ruas kiri yang berkorespondensi. Langkah-langkahnya adalah sebagai berikut:

 

1. Mula-mula lakukan half-round loop yang seperti pada RC5:

 

for i = 1 to r do

A = ((AB) <<< B) + S[i]

(A,B) = (B,A)

 

 

2. Lakukan dua proses RC5 secara paralel, yang satu untuk register A, B dan yang lain untuk register C, D.

 

for i = 1 to r do

A = ((A B) <<< B) + S[2i]

C = ((C D) <<< D) + S[2i+1]

(A,B) = (B,A)

(C,D) = (D,C)

 

 

3. Pada tahap pertukaran, daripada menukar A dengan B, dan C dengan D, lakukan permutasi antar keempat register (A,B,C,D) = (B,C,D,A), sehingga komputasi AB bercampur dengan komputasi CD.

 

for i = 1 to r do

A = ((AB) <<< B) + S[2i]

C = ((CD) <<< D) + S[2i+1]

(A,B,C,D) = (B,C,D,A)

 

 

4. Campurkan komputasi AB dengan CD lebih jauh, yaitu dengan mempertukarkan kedua nilai yang menyatakan jumlah rotasi pada masing-masing komputasi.

 

for i = 1 to r do

A = ((AB) <<< D) + S[2i]

C = ((CD) <<< B) + S[2i+1]

(A,B,C,D) = (B,C,D,A)

 

 

5. Daripada menggunakan nilai B dan D secara langsung, RC6 menggunakan hasil transformasi kedua register ini. Hal ini dilakukan untuk tidak mengulangi masalah rotasi seperti pada RC5 di mana tidak seluruh bit dalam data yang berpengaruh dalam rotasi. Oleh karena itu, fungsi transformasi yang dipilih harus dapat memanfaat seluruh bit di dalam data untuk mengatur jumlah bit yang dirotasikan. Fungsi yang dipilih adalah f(x) = x(2x + 1) (mod 2w) yang kemudian diikuti dengan rotasi ke kiri sebanyak 5 bit. Transformasi ini terpilih karena fungsi f(x) yang merupakan fungsi satu-ke-satu memiliki bit-bit orde atas yang menentukan jumlah rotasi yang akan digunakan yang sangat bergantung pada x.

 

for i = 1 to r do

p = (B × (2B + 1)) <<< 5

q = (D × (2D + 1)) <<< 5

A = ((A p) <<< q) + S[2i]

C = ((Cq) <<< p) + S[2i+1]

(A,B,C,D) = (B,C,D,A)

 

 

6. Setelah loop di atas selesai, akan terdapat hasil di mana plaintext bisa menunjukkan bagian input ronde pertama dalam enkripsi dan ciphertext bisa menunjukkan bagian input ronde terakhir dalam enkripsi. Oleh karena itu perlu ditambahkan langkah – langkah di awal dan di akhir loop untuk menyamarkan hubungan ini. Sehingga, terbentuklah algoritma enkripsi RC6 yang sebagai berikut:

 

B = B + S[0]

D = D + S[1]

for i = 1 to r do

p = (B × (2B + 1)) <<< 5

q = (D × (2D + 1)) <<< 5

A = ((Ap) <<< q) + S[2i]

C = ((Cq) <<< p) + S[2i+1]

(A,B,C,D) = (B,C,D,A)

A = A + S[2r + 2]

C = C + S[2r + 3]

 

Perlu diketahui juga, dalam varian baru RC6 jumlah rotasi ke kiri yang mengikuti fungsi kuadrat bukan 5 bit tetapi adalah 2log(w) bit.

 

 

Algoritma Dekripsi

 

Sama seperti pada RC5, algoritma dekripsi RC6 juga merupakan penurunan dari algoritma enkripsi. Algoritmanya sebagai berikut:

 

C = C – S[2r + 3]

A = A – S[2r + 2]

for i = r downto 1 do

(A,B,C,D) = (D,A,B,C)

p = (D × (2D + 1)) <<< 5

q = (B × (2B + 1)) <<< 5

C = ((C – S[2i + 1]) >>> q) p

A = ((A – S[2i]) >>> p) q

D = D – S[1]

B = B – S[0]

Demikianlah algoritma RC 6 yang dapat saya simpulkan,.,,, Untuk coding kedalam bahasa pemrogaman sendiri saya belum mampu,.. tapi saya akan berusaha,.. Oia,bahasa yang baru saya cicipi yakni c, jadi saya mengharapkan masukan dari pembaca,.. baik itu algor diatas maupun source code in c-nya sendiri…

Terimakasih……

Source code in c

#include <stdio.h>
#include <conio.h>
/* RC6 terparameterisasi untuk w-bit words, b bytes of key, and
* r rounds. The AES version of RC6 specifies b=16, 24, or 32;
* w=32; and r=20.
*/

#define w 32 /* word size in bits */
#define r 20 /* berdasarkan taksiran keamanannya */

#define P32 0xB7E15163 /* konstanta ajaib untuk key setup */
#define Q32 0x9E3779B9

/* konstanta turunan */
#define bytes (w / 8) /* bytes per word */
#define c ((b + bytes – 1) / bytes) /* key in words, rounded up */
#define R24 (2 * r + 4)
#define lgw 5 /* log2(w) — wussed out */

/* Rotasi */
#define ROTL(x,y) (((x)<<(y&(w-1))) | ((x)>>(w-(y&(w-1)))))
#define ROTR(x,y) (((x)>>(y&(w-1))) | ((x)<<(w-(y&(w-1)))))

unsigned int S[R24 – 1]; /* penjadwalan kunci*/

void rc6_key_setup(unsigned char *K, int b)
{
int i, j, s, v;
unsigned int L[(32 + bytes – 1) / bytes];
unsigned int A, B;

L[c – 1] = 0;
for (i = b – 1; i >= 0; i–)
L[i / bytes] = (L[i / bytes] << 8) + K[i];

S[0] = P32;
for (i = 1; i <= 2 * r + 3; i++)
S[i] = S[i – 1] + Q32;

A = B = i = j = 0;
v = R24;
if (c > v) v = c;
v *= 3;

for (s = 1; s <= v; s++)
{
A = S[i] = ROTL(S[i] + A + B, 3);
B = L[j] = ROTL(L[j] + A + B, A + B);
i = (i + 1) % R24;
j = (j + 1) % c;
}
}

void rc6_block_encrypt(unsigned int *pt, unsigned int *ct)
{
unsigned int A, B, C, D, t, u, x;
int i, j;

A = pt[0];
B = pt[1];
C = pt[2];
D = pt[3];
B += S[0];
D += S[1];
for (i = 2; i <= 2 * r; i += 2)
{
t = ROTL(B * (2 * B + 1), lgw);
u = ROTL(D * (2 * D + 1), lgw);
A = ROTL(A ^ t, u) + S[i];
C = ROTL(C ^ u, t) + S[i + 1];
x = A;
A = B;
B = C;
C = D;
D = x;
}
A += S[2 * r + 2];
C += S[2 * r + 3];
ct[0] = A;
ct[1] = B;
ct[2] = C;
ct[3] = D;
}

void rc6_block_decrypt(unsigned int *ct, unsigned int *pt)
{
unsigned int A, B, C, D, t, u, x;
int i, j;

A = ct[0];
B = ct[1];
C = ct[2];
D = ct[3];
C -= S[2 * r + 3];
A -= S[2 * r + 2];
for (i = 2 * r; i >= 2; i -= 2)
{
x = D;
D = C;
C = B;
B = A;
A = x;
u = ROTL(D * (2 * D + 1), lgw);
t = ROTL(B * (2 * B + 1), lgw);
C = ROTR(C – S[i + 1], t) ^ u;
A = ROTR(A – S[i], u) ^ t;
}
D -= S[1];
B -= S[0];
pt[0] = A;
pt[1] = B;
pt[2] = C;
pt[3] = D;
}

struct test_struct
{
int keylen;
unsigned char key[32];
unsigned int pt[4];
unsigned int ct[4];
} tests[] =
{
{ 16, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
{0x00000000, 0x00000000, 0x00000000, 0x00000000},
{0x36a5c38f, 0x78f7b156, 0x4edf29c1, 0x1ea44898},
},

{ 16, {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
0x01, 0x12, 0x23, 0x34, 0x45, 0x56, 0x67, 0x78},
{0x35241302, 0x79685746, 0xbdac9b8a, 0xf1e0dfce},
{0x2f194e52, 0x23c61547, 0x36f6511f, 0x183fa47e},
},

{ 24, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
{0x00000000, 0x00000000, 0x00000000, 0x00000000},
{0xcb1bd66c, 0x38300b19, 0x163f8a4e, 0x82ae9086},
},

{ 24, {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
0x01, 0x12, 0x23, 0x34, 0x45, 0x56, 0x67, 0x78,
0x89, 0x9a, 0xab, 0xbc, 0xcd, 0xde, 0xef, 0xf0},
{0x35241302, 0x79685746, 0xbdac9b8a, 0xf1e0dfce},
{0xd0298368, 0x0405e519, 0x2ae9521e, 0xd49152f9},
},

{ 32, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
{0x00000000, 0x00000000, 0x00000000, 0x00000000},
{0x05bd5f8f, 0xa85fd110, 0xda3ffa93, 0xc27e856e},
},

{ 32, {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
0x01, 0x12, 0x23, 0x34, 0x45, 0x56, 0x67, 0x78,
0x89, 0x9a, 0xab, 0xbc, 0xcd, 0xde, 0xef, 0xf0,
0x10, 0x32, 0x54, 0x76, 0x98, 0xba, 0xdc, 0xfe},
{0x35241302, 0x79685746, 0xbdac9b8a, 0xf1e0dfce},
{0x161824c8, 0x89e4d7f0, 0xa116ad20, 0x485d4e67},
},

{ 0,
}
};

int
main()
{
unsigned int ct[4], pt[4];
int i;
struct test_struct *p;

for (p = tests, i = 1; p->keylen; p++, i++)
{

rc6_key_setup(p->key, p->keylen);
rc6_block_encrypt(p->pt, ct);
printf(“Test %d: %08x %08x %08x %08x\n”,
i, ct[0], ct[1], ct[2], ct[3]);
printf(“Should be: %08x %08x %08x %08x\n”,
p->ct[0], p->ct[1], p->ct[2], p->ct[3]);
rc6_block_decrypt(ct, pt);
printf(“Plain: %08x %08x %08x %08x\n”,
pt[0], pt[1], pt[2], pt[3]);
printf(“Should be: %08x %08x %08x %08x\n\n”,
p->pt[0], p->pt[1], p->pt[2], p->pt[3]);
}

getch();
}
atau klik
rc6-gi2h.c

13 pemikiran pada “Algoritma Enkripsi dan Dekripsi RC 6

  1. sebenernya saya sendiri menulis tentang kriptografi juga buat tugas kuliah, dan bisa dibilang saya awam sekali pengetahuannya, mungkin justru saya yang mau bertanya, “apa sih kriptografi itu sebener-benernya??”
    tapi btw, makasih untuk komennya setelah membaca postingan saya, terima kasih apresiasinya dan kalo kamu berkenan, saya bisa minta bantuannya untuk memperluas pengetahuan saya tentang dunia cyber kan???
    makasih..

  2. salam kenal aku juna Kuliah bidang IT tapi ga ngerti tentang enkripsi dan dekripsi saya minta bantuannya kirim emailin saya minta di ajarin. he………he……….
    sebelumnya thank

  3. salam saya ahmad lagi ngerjain TA tentang MMB nih minta tolong di bantu penjelasannyauntuk algoritma MMB .
    terima kasih.

  4. saya mau tanya nih, coding program vb dibawah ini menggunakan algoritma apa ya?

    ‘ DECODE PASSWORD.
    Function Decode_Pass(p_str As String) As String
    Dim bb As String
    Dim bbb As String
    Dim AA As String
    Dim aaa As String

    For i = 1 To Len(p_str) Step 1
    A = Mid(p_str, i, 1)
    b = Asc(Mid(p_str, i, 1))
    KeyAscii = b
    bb = KeyAscii
    bbb = bbb + bb & ” ”
    c = Chr(Asc(Mid(p_str, i, 1)) * 2)
    hasil = hasil + c

    strs = Chr(Asc(Mid(p_str, i, 1)) * 2)
    KeyAscii = Asc(strs)
    AA = KeyAscii
    aaa = aaa + AA & ” ”

    ‘ strs = strs + Chr(Asc(Mid(p_str, i, 1)) * 2)
    Next i
    Decode_Pass = hasil
    End Function

Tinggalkan Balasan

Isikan data di bawah atau klik salah satu ikon untuk log in:

Logo WordPress.com

You are commenting using your WordPress.com account. Logout / Ubah )

Gambar Twitter

You are commenting using your Twitter account. Logout / Ubah )

Foto Facebook

You are commenting using your Facebook account. Logout / Ubah )

Foto Google+

You are commenting using your Google+ account. Logout / Ubah )

Connecting to %s