GOST merupakan blok cipher dari Uni Sovyet, yang merupakan singkatan dari “Gosudarstvennyi Standard” (Russian:государственный стандарт) atau Standar Pemerintah, standar ini bernomor 28147-89 oleh sebab itu metoda ini sering disebut sebagai GOST 28147-89. GOST secara struktural mirip dengan DES.

GOST merupakan blok cipher 64 bit dengan panjang kunci 256 bit. Algoritma ini mengiterasi algoritma enkripsi sederhana sebanyak 32 putaran (round), setiap putaran menggunakan kunci internal. Kunci internal dihasilkan secara sederhana yaitu dari 256 bit kunci yang dibagi menjadi delapan 32 bit blok : k1, k2, …, k8. Setiap putaran menggunakan subkunci yang berbeda, tetapi karena ada 32 putaran maka ke-8 kunci internal tersebut dijadwalkan penggunannya.

Putaran 1 = K1

Putaran 2 = K2 begitu seterusnya dan berulang

Puraran 32 =K8

Untuk mengenkripsi pertama-tama plainteks 64 bit dipecah menjadi 32 bit bagian kiri, L ,dan 32 bit bagian kanan, R. Subkunci (subkey) untuk putaran i adalah K_i. Pada satu putaran ke-i operasinya adalah sebagai berikut :

L_i = R_i-1

R_i = L_i-1 xor f(R_i-1,K_i)

Hasil penjumlahan (dalam modulo 2³²) R_i-1 dengan kunci internal ke-i menghasilkan output yang panjangnya 32 bit. Output ini dibagi menjadi 8 bagian yang masing-masing panjangnya 4-bit. Setiap 4-bit masuk ke dalam kotak s untuk proses subtitusi. 4 bit pertama menjadi s-box pertama, 4 bit kedua menjadi s-box kedua, dan seterusnya. Hasil subtitusi setiap kotak s adalah 4-bit. GOST memiliki 8 buah s-box, setiap kotak berisi 16 elemen nilai. Setiap kotak berisi permutasi angka 0 sampai 15. Setiap elemen di dalam s-box diindeks 0 sampai 15. Arti dari setiap elemen di dalam s-box adalah : masukan s-box berasosiasi dengan indeks elemen, sedangkan luarannya berasosiasi dengan nilai dalam elemen dengan indeks tersebut.

Misal s-box pertama jika inputannya adalah 4-bit yaitu 0000 (yang menyatakan nilai desimal 0), maka outputnya didalam elemen ke-0 yaitu 4 (dalam biner 0100). Hasil subtitusi dar semua s-box digabung menjadi pesan 32-bit kemudian pesan 32-bit inidigeser ke kiri sejauh 11 bit secara sirkuler. Hasilnya kemudian di XOR dengan L_1-1, yang akan menjadi bagian cipherteks kanan yang baru. Proses ini diulang sebayak 32 kali. Pada implementasinya nanti rotasi pada fungsi f dilakukan pada awal saat inisialisasi sekaligus membentuk s-box 32 bit dan dilakukan satu kali saja sehingga lebih menghemat operasi dan dengan demikian mempercepat proses enkripsi/dekripsi. Dekripsi sama dengan enkripsi dengan urutan k_i dibalik.

GOST yang standar pada awalnya tidak didiskusikan bagaimana membangkitkan s-box, yang diketahui hanya bahwa s-box tersebut disediakan oleh seseorang/sesuatu. Sehingga ada spekulasi ( yang mungkin saja benar) bahwa beberapa Soviet organisasi mengirimkan s-box yang baik pada pemerintah secara rahasia dan s-box yang buruk pada penyadap yang dikomunikasikan pada jaringan. Namun pada pembicaraan dengan pembuat chip GOST, termasuk Rusia, menawarkan alternatif lain untuk membangkitkan s-box, yaitu dengan membangkitkan permutasi s-box sendiri dengan menggunakan pembangkit angka acak.

Kebanyakan data tidak bulat dibagi kedalam 64 bit (8 byte), oleh sebab itu dalam blok cipher diperlukan data tambahan pada blok terakhir untuk menggenapi blok menjadi 64 bit, hal ini biasanya disebut padding. Ada beberapa cara untuk melakukan padding, salah satu caranya adalah yang disebut Ciphertext Stealing yang akan digunakan dalam aplikasi dari metoda GOST ini.

II. Kelebihan dan Kelemahan

1. Kelebihan

- Kecepatan dari metoda ini cukup baik, tidak secepat Blowfish tetapi lebih cepat dari Idea. Untuk kecepatan enkripsi di memori sebesar 5MB data adalah : 3.492,620 Kbyte/detik pada Pentium Pro 200 MHz dan 2.466,700 Kbyte/detik pada Pentium MMX 200 MHz.

- GOST adalah cipher yang aman jika dibandingkan dengan DES, karena jumlah putaran dan panjang kunci yang lebih banyak dari DES.

- Belum ada publikasi kripanalisis tentang GOST

- Tidak ada cara yang lebih baik untuk “membuka” GOST selain brute force attack

1. Kelemahan

- Kelemahan GOST yang diketahui sampai saat ini adalah karena key schedule-nya yang sederhana, sehingga pada keadaan tertentu menjadi titik lemahnya terhadap metoda kriptanalisis seperti Related-key Cryptanalysis. Tetapi hal ini dapat diatasi dengan melewatkan kunci kepada fungsi hash yang kuat secara kriptografi seperti SHA-1, kemudian menggunakan hasil hash untuk input inisialisasi kunci.

- Kelemahan GOST dibanding DES adalah bahwa GOST tidak memiliki perluasan permutasi yang tetap, tidak seperti DES, oleh karena itu tidak dapat dihilangkan permutasi yang lemah.

III. Daftar Pustaka
Munir, Rinaldi. Kriptografy. Penerbit Informatika. 2006
Sukarmawan, Budi. Metode Enkripsi GOST. 1999
Shneier, Bruce. Applied Crypyography 2^nd. John Wiley & Sons.1996

1. Koefisien Determinasi Berganda

Seandainya kita ingin menghitung nilai variansi pada himpunan variable tak bebas Y₁,…, Y_n yang berkorespondensi dengan nilai X₁,…, X_n. Perhitungan stastistik yang biasanya digunakan untuk menghitung nilai tersebut adalah . Variasi nilai Y_i didapat dari 2 faktor. Pertama karena perbedaan nilai input X_i dan yang kedua karena walaupun tidak ada nilai yang berbeda dimasukkan dalam account, tetap saja variabel Y_i mempunyai variansi sebesar σ² mengakibatkan persamaan tersebut tidak sama_.

Berapa banyak variasi pada variabel tidak bebas karena nilai input yang berbeda, dan berapa yang dibutuhkan untuk variansi yang melekat pada variabel tidak bebas meskipun nilai input dimasukkan dalam account. Note rumus ini untuk menghitung sisa variansi pada variable tidak bebas karena input yang berbeda dimasukkan dalam account. Sehingga, merepresaentasikan jumlah variasi pada variable tidak bebas yang didapat karena perbedaan nilai input, sehingga R² didefinisikan:

untuk merepresentasikan proporsi dari variansi yang dihasilkan dari nilai input yang berbeda. R² disebut koefisien determinasi…

Nilai koefisien determinasi akan berkisar dari 0 dan 1, nilai ini mengidikasikan besar tidaknya pengaruh dari suatu nilai input.

Misal bentuk persamaan yang kita gunakan adalah Y = b₀ + b₁X₁ + b₂X₂. Untuk keperluan ilustrasi ditulis sebagai berikut Y_i = b_y.12 + b_y1.2X_1i + b_y2.1X_2i.

Dengan besar sehingga…

r_y1 = koefisien korelasi sederhana antara Y dan X₁

r_y2 = koefisien korelasi sederhana antara Y dan X₂

r₁₂ = koefisien korelasi sederhana antara X₁ dan X₂

adalah kofisien korelasi berganda antara Y dengan X₂ dan X₁, digunakan untuk mengukur besarnya kontribusi variasi X₂ dan X₁ terhadap variasi Y pada persamaan tersebut. r² disebut koefisien determinasi sederhana, biasannya digunakan untuk menghitung besarnya kontribusi variasi X terhadap variasi Y. Keduanya digunakan untuk menentukan apakah garis regresi linier sederhana Y terhadap X dan garis regresi linier berganda Y terhadap X₂dan X₁ sudah cocok atau tepat untuk digunakan sebagai pendekatan atas suatu hubungan linier antarvariabel berdasarkan hasil observasi. Makin besar nilai r² dan , berarti semakin tepat suatu garis linier digunakan sebagai suatu pendekatan.

1. Koefisien Korelasi Parsial

r_y1.2 = koefisien korelasi parsial antara Y dan X₁, keduanya sudah bebas dari pengaruh X₂ (X₂ konstan)

r_y2.1 = koefisien korelasi parsial antara Y dan X₂, keduanya sudah bebas dari pengaruh X₁ (X₁ konstan)

Untuk menghitung keduannya, terlebih dahulu hitung pengaruh linier dari X₂ terhadap Y dan X₁. Regresi linier sederhana Y terhadap X_{2 :}

Y_i = b_y2 + b_y2X_2i + e_i atau y_i = b_y2x_2i + e_i

,

Regresi linier sederhana X_i terhadap X₂ : X_1i = b₁₂ + b₁₂X_2i + f_i atau…

x_1i = b₁₂x_2i + f_i 

Koefisien korelasi parsial antara Y dan X_1, apabila X₂ konstant, merupakan koefisien korelasi sederhana antara e_i dan f_i yaitu sebagai berikut:

Ingat, untuk hubungan dua variable Y dan X,

Y_i = bx_i + e_i 

Dan untuk penyebut (b):

Sehingga, rumus r_y1.2 menjadi sebagai berikut:

]]> http://ahriev.wordpress.com/2008/06/09/koefisien-determinasi-berganda-dan-parsial/feed/ 9 ahriev http://ahriev.wordpress.com/2007/12/28/11/ http://ahriev.wordpress.com/2007/12/28/11/#comments Fri, 28 Dec 2007 06:48:39 +0000 ahriev http://ahriev.wordpress.com/2007/12/28/11/ ]]> #include <stdio.h>
/* ——————————————————-
RC5 — Blok cipher yang didisain oleh Ron Rivest. Implementasi ini digunakan pada publik, namun RC5 **sudah dipatenkan. Silahkan berkonsultasi dengan Rivest atau RSA Data Security untuk detail yang lebih jauh. Program ini untuk implementasi RC5-32/r/b pengguna dapat menetukan r dan b sendiri. (r = banyaknya putaran(rotasi), b = banyaknya bytes dalam kunci)
——————————————————- */
typedef unsigned char u1;
typedef unsigned long u4;

/* untuk mengetahui banyaknya rotasi dan banyaknya sub-kunci */
typedef struct {
u4 *xk;
int nr;
} rc5_ctx;

/* jika mungkin, subkey tersebut sebaiknya digantikan dengan instruksi rotasi
Untuk Turbo C++, hal ini dapat diselesaikan dengan _lrotl and _lrotr. */

#define ROTL32(X,C) (((X)<<(C))|((X)>>(32-(C))))
#define ROTR32(X,C) (((X)>>(C))|((X)<<(32-(C))))

/* prototype untuk bekerja sama dengan operasi dasar

RC5 */
void rc5_init(rc5_ctx *, int);
void rc5_destroy(rc5_ctx *);
void rc5_key(rc5_ctx *, u1 *, int);
void rc5_encrypt(rc5_ctx *, u4 *, int);
void rc5_decrypt(rc5_ctx *, u4 *, int);

/* implementasi fungsi untuk RC5 */

/* scrub out semua nilai yang sensitif */
void rc5_destroy(rc5_ctx *c){
int i;
for(i=0;i<(c->nr)*2+2;i++) c->xk[i]=0;
free(c->xk);
}

/* mengalokasikan memori untuk konteks xk rc5 dan sebagainya */
void rc5_init(rc5_ctx *c, int rounds){
c->nr = rounds;
c->xk = (u4 *) malloc(4*(rounds*2+2));
}

/* rc5_encrypt(context,data_ptr,count_of_blocks_to_encrypt)
Fungsi ini mengenkripsi beberapa blok dengan RC5 dalam model ECB.Untuk kunci sendiri (berapa banyk putaran dan berapa banyak kunci) di set pada rc5_key() pada program ini. Padding terhadap blok yang kurang merupakan kewajiban pengguna. Fungsi ini hanya mengenkripsi 64-bit blok yang dimasukkan pengguna ECB (Electronic Code Book)
*/
void rc5_encrypt(rc5_ctx *c, u4 *data, int blocks){
u4 *d,*sk;
int h,i,rc;

d = data;
sk = (c->xk)+2;
for(h=0;h<blocks;h++){
d[0] += c->xk[0];
d[1] += c->xk[1];
for(i=0;i<c->nr*2;i+=2){
d[0] ^= d[1];
rc = d[1] & 31;
d[0] = ROTL32(d[0],rc);
d[0] += sk[i];
d[1] ^= d[0];
rc = d[0] & 31;
d[1] = ROTL32(d[1],rc);
d[1] += sk[i+1];
/*printf(“Round %03d : %08lx %08lx sk= %08lx %08lx\n”,i/2,
d[0],d[1],sk[i],sk[i+1]);*/
}
d+=2;
}
}

/* rc5_decrypt(context,data_ptr,count_of_blocks_to_decrypt)
Fungsi ini mendekripsi beberapa blok dengan RC5 dalam model ECB. Padding blok yang lebih pendek merupakan kewajiban pengguna
*/
void rc5_decrypt(rc5_ctx *c, u4 *data, int blocks){
u4 *d,*sk;
int h,i,rc;

d = data;
sk = (c->xk)+2;
for(h=0;h<blocks;h++){
for(i=c->nr*2-2;i>=0;i-=2){
/*printf(“Round %03d: %08lx %08lx sk: %08lx %08lx\n”,
i/2,d[0],d[1],sk[i],sk[i+1]); */
d[1] -= sk[i+1];
rc = d[0] & 31;
d[1] = ROTR32(d[1],rc);
d[1] ^= d[0];

d[0] -= sk[i];
rc = d[1] & 31;
d[0] = ROTR32(d[0],rc);
d[0] ^= d[1];
}
d[0] -= c->xk[0];
d[1] -= c->xk[1];
d+=2;
}
}

/*
rc5_key(context,key_pointer,key_len,rounds)
Fungsi ini merupakan implementasi algoritma penjadwalan kunci RC5 untuk panjang kunci dan banyak putaran yang telah ditentukan. Penjadwalan kunci lebih kompleks pada kode C, tapi secara konsep seperti ini:
1. Padding kunci ke 32-bit word yang selanjutnya
2. Inisialisasi array kunci yang diperluas ke pseudorandom nilai yang telah didefinis ikan sebelumnya
3. Inisialisasi dua nilai berantai, A dan B menjadi 0
4. Lakukan beberapa langkah ke array kunci yang diperluas dan yang sudah dipadding, tambahkan A dan B ke masukkan kunci yang telah diperluas sesudahnya lalu geser ke kiri sebanyak 3-bit, dan setting A ke entry tersebut kemudian tambahkan A dan B ke masukkan kunci yang telah dipadding yang selanjutnya dan rotasikan ini dengan rotating (A + B) mod 32 bits dan setting B sebagai hasilnya
*/
void rc5_key(rc5_ctx *c, u1 *key, int keylen){
u4 *pk,A,B; /* kunci yang sudah di padding */
int xk_len, pk_len, i, num_steps,rc;
u1 *cp;

xk_len = c->nr*2 + 2;
pk_len = keylen/4;
if((keylen%4)!=0) pk_len += 1;

pk = (u4 *) malloc(pk_len * 4);
if(pk==NULL) {
printf(“An error occurred!\n”);
exit(-1);
}

/* inisialisasi pk — ini seharusnya bekerja pada mesin Intel */
for(i=0;i<pk_len;i++) pk[i]=0;
cp = (u1 *)pk;
for(i=0;i<keylen;i++) cp[i]=key[i];

/* inisialisasi xk. */
c->xk[0] = 0xb7e15163; /* P32 */
for(i=1;i<xk_len;i++) c->xk[i] = c->xk[i-1] + 0x9e3779b9; /* Q32 */

/* TEST */
A = B = 0;
for(i=0;i<xk_len;i++) {
A = A + c->xk[i];
B = B ^ c->xk[i];
}

/* Perluasan kunci menjadi xk */
if(pk_len>xk_len) num_steps = 3*pk_len;else num_steps = 3*xk_len;

A = B = 0;
for(i=0;i<num_steps;i++){
A = c->xk[i%xk_len] = ROTL32(c->xk[i%xk_len] + A + B,3);
rc = (A+B) & 31;
B = pk[i%pk_len] = ROTL32(pk[i%pk_len] + A + B,rc);

}

/* “clobber” data yang sensitif, sebelum memastikan kebutuhan memori */
for(i=0;i<pk_len;i++) pk[i] =0;

free(pk);
}

Program ini dijalankan pada compileler bahasa C atau C++ (bisadisesuaikan). Untuk fungsi utama (main) dapat dibentuk sendiri dari fungsi-fungsi di atas, sesuai kebutuhan dan keinginan masing-masing. Selamat mencoba….

-Ahriev The Catz-
Daftar pustaka:
Bruce Scheiner, Applied Cryptography

B. Gambar satu putaran di dalam RC5

Padding dapat dilakukan dengan menambahkan 0 semua, 1 semua atau 0 dan 1 secara berselang seling sampai panjang blok sesuai dengan blok yang ditentukan.

Terdapat tiga operasi yaitu XOR, penambahan (addition) dan perputaran (rotation). Rotasi (perputaran) merupakan operasi yang waktunya konstan untuk kebanyakan prosesor dan variabel rotasi merupakan fungsi yang non-linier. Rotasi ini bergantung pada kunci dan data. Ada dua macam rotasi yaitu x <<< y (berarti menggeser bit-bit di dalam x sejauh y bit ke kiri secara silkuler) dan x>>>y (berarti menggeser bit-bit di dalam x sejauh y bit ke kanan secara silkuler). Struktur umum algoritma menggunakan jaringan feistel.

Pembentukan Kunci Internal

Kunci internal ada sebanyak 2r+2 buah yang maig-masing disimpan di dalam elemen-elemen larik yang dilabeli sebagai S[1],S[1],…,S[t-1] dengan t = 2r+2. Setiap elemen larik panjangnya satu word (1 word = w bit ). Pembentukan kunci internal lebih rumit. Mula-mula, semua byte dari kunci eksternal, K[0...b-1], disalin ke dalam larik Lc word, L[0...b-1] lalu padding dengan sejumlah 0 jika perlu (padding terjadi jika b bukan kelipatan w). Kemudian inisialisasi larik S sebagai berikut: yang berukuran

S[0]<-P_{w
for i <- 1 to t – 1 do}
S[i] <- S[i - 1] + Q_w
endfor

yang dalam hal ini P_w dan Q_w (dalam hexadesimal) berbeda-beda tergantung w sebagai berikut:

Konstanta P_w dan Q_w diasarkan pada representasi bilangan alan e dan φ dalam biner,

P_w = Odd [(e - 2) 2 ]

Q_w = Odd [(φ - 2) 2 ^w]

Akhirnya campurkan L dan S sebagai berikut:

i <- 0

j <- 0

X <- 0

Y <- 0

n <- 3 * max (r,c)

for k <- 1 to n do

S[i] <- (S[i] + X+ Y) <<< 3

X <- S[i]

i <- (1 + 1) mod (t)

L[j] <- (L[j] + X+ Y) <<< (X+ Y)

Y <- L[i]

j <- (j +1) mod (c)

endfor

Enkripsi

Misalkan yang ditinjau RC5 denganukuran blok 64-bit dan jumlah rotasi r. Enkripsi menggunakan kunci internal S ³² ) dengan S₀ dan S₁:

A <- A + S[0]

B <- B + S[1]

Seanjutnya untuk setiap rotasi dari 1 sampai r dilakukanoprasi XOR, penggeseran ke kiri secara silkulern dan penjumlahan dalam modulo 2³² dengan kunci internal sebagai berikut:

for i <- to r do A

A <- ((A XOR B)<<< B) + S [2i]

B <- ((B XOR A)<<< A) + S [2i + 1]

endfor

Cipherteks pada rotasi terakhir disimpan di dalam A dan B. Gabungan keduanya adalah blok palin teks yang berukuran 64-bit. Proses enkripsi satu rotasi dipelihatkan pada gambar di bawah ini.

Dekripsi

Dekripsi berkebalikan dengan enkripsi. Mula-mula bagi blok cipherteks menjadi dua bagian, A dan B, yang masing-masing panjangnya 32-bit. Selanjutnya untuk setiap putaran dari 1 sampai r dilakukan operasi pengurangan dalam modulo 232 dengan kunci internal, penggeseran ke kanan secar silkuler (rotasi) dan operasi XOR sebagi berikut:

for i <- to r do

B <- ((B – S [2i + 1]) >>> A) XOR A

A <- ((A – S [2i]) >>> B) XOR B

endfor

B <- B + S [1]

A <- A + S[0]

2 be continued……..

sumber:

Applied Cryptography (Bruce Schneier)

Kriptografi (Rinaldi Munir)

Wikipedia