Nostalgila: Tugas Besar Kuliah

Berhubung harddisk MBP sudah kepenuhan, saya melakukan *audit* isi harddisk untuk menentukan mana yang akan tetap dipeliharan dan mana yang akan dibuang. Kebetulan menemukan harddisk external lama dengan kapasitas 40G yang dibeli bertahun-tahun lalu ketika masih kuliah, jaman itu kapasitas 40G sudah termasuk besar loh :).

Nah, rencananya sebagian film-film yang belum ditonton akan dipindahkan ke harddisk external tersebut. Namun sebelum harddisk tersebut juga dibersihkan secara total, saya lihat-lihat dulu isinya. Ternyata banyak juga data-data jadul yang tersimpan, umumnya beragam dokumen tentang hacking seperti artikel-artikel dan tools-tools lama. Biasalah, di download tapi gak sempat dibaca sampai sekarang. Diantara isi harddisk tersebut, ditemukan juga beberapa coding yang saya buat dulu sebagai bagian dari tugas kuliah.

Saat kuliah di STT Telkom dulu, tugas-tugas praktikum maupun tugas kuliah menjelang akhir semester biasanya cukup berat (tentu saja bagi mahasiswa yang baru belajar dan mengenal pelajaran). Sering disebut tugas besar. Biasanya dikerjakan secara kelompok. Dan rentetan tugas besar itu kadang lebih dari dua, sehingga biasanya tidak semua anak mengerjakan semua tugas. Terjadi simbiosis mutualisme dimana satu anak mengerjakan suatu tugas, dan anak yang lain mengerjakan tugas lain secara parallel.

Saya lupa ini tugas besar untuk mata kuliah apa, namun saya ingat betul tugas dari dosen tersebut adalah membuat aplikasi kriptografi sederhana, yaitu implementasi enkripsi DES.

Saya sendiri tidak yakin apakah implementasi tersebut benar atau tidak, karena waktu itu langsung di kumpulkan. Ketika kuliah dulu, saya seringkali berusaha keras untuk memaksakan mengerjakan tugas-tugas programming sendiri, dalam arti bukan modifikasi atau edit dari tugas yang dibuat oleh anak lain. Beberapa rekan memang ada yang sudah lebih dahulu mengenal programming sebelum masuk kuliah, dan mereka biasanya jadi andalan anak-anak satu angkatan sebagai ‘master’ program dimana anak-anak lain tinggal modifikasi beberapa bagian program sedangkan inti / core dari program tersebut diambil dari si ‘master’. Well, walaupun saat itu (dan sampai saat ini sepertinya ;p) saya termasuk bodoh dan tidak dapat menghasilkan program sebaik rekan-rekan yang lebih jago, tapi setidaknya hasil yang dikumpulkan adalah usaha sendiri. Dan sampai saat ini saya belum bisa melupakan ‘euphoria’ saat-saat mengerjakan tugas-tugas tersebut. Saya ingat betul asyiknya merangkai algoritma dari awal, debugging karena coding yang dilakukan masih error, memikirkan solusinya sambil istirahat seperti menjelang tidur ataupun ketika membeli makanan (jadi selama di angkot atau lagi nunggu makanan di warung kelihatan nge-hang). Ketika kuliah dulu internet tidak seperti sekarang mudah didapatkan dan tinggal googling sedikit kita bisa tahu masalah dari program yang sedang kita hadapi. Saat itu untuk mengakses internet harus ke warnet, dan mengerjakan program harus di komputer desktop kost an jadi mau tidak mau trial/error adalah jalan terbaik.

Beberapa tugas besar terutama tugas praktikum umumnya memberikan hasil memuaskan. Dan ketika melihat hasil tersebut, terbayarlah semua jerih payah dan kesulitan serta memberikan rasa bangga tersendiri walaupun program yang dihasilkan sangat sederhana namun hasil kerja keras diri sendiri.

Oh, well, enough nostalgila nya. Berikut ini salah satu tugas besar yang saya temukan di harddisk. Implementasi DES.

des.h

/* Fungsi untuk meng-generate 16 subkeys ( 48 bit ) */

void keygen ( int K[16][48], int input_key_64bit[64] )
{

int key[56];
int i,j;

static int table_PC_1[56] = {
57,49,41,33,25,17,9,
1 ,58,50,42,34,26,18,
10, 2,59,51,43,35,27,
19,11, 3,60,52,44,36,
63,55,47,39,31,23,15,
7 ,62,54,46,38,30,22,
14, 6,61,53,45,37,29,
21,13, 5,28,20,12, 4
};

/* Ubah 64 bit input key menjadi key 56 bit menggunakan tabel PC-1 */
for (i=0;i<64;i++) {
if ( (i!=7) || (i!=15) || (i!=23) || (i!=31) || (i!=39) || (i!=47) || (i!=55) || (i!=63) ) {
for (j=0;j<56;j++) {
if (table_PC_1[j]==(i+1))
break;
}
key[j]=input_key_64bit[i];
}
}

/********************************************************************************************/
/* Key schedulling part, hm...pemilihan nama variabel nya pst membuat bingung yg baca ni =P */
/********************************************************************************************/

int temp[28];
int R,rotate,ada;
int key_L[16][28],key_R[16][28],key_LR[16][56];

/* Tabel rotasi untuk sub-key */
static int sub_key_rotate_table[16] = { 1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1 };

/* Tabel PC-2 */
static int table_PC_2[48] = {
14,17,11,24, 1, 5,
3 ,28,15, 6,21,10,
23,19,12, 4,26, 8,
16, 7,27,20,13, 2,
41,52,31,37,47,55,
30,40,51,45,33,48,
44,49,39,56,34,53,
46,42,50,36,29,32
};

/* Cari key_L(1) s/d key_L(16) dan key_R(1) s/d key_R(16), untuk mencari */
/* key_L(n) maka key_L(n-1) di-rotasi sebanyak jumlah yg t'dapat pada sub_key_rotate_table */
/* sesuai pada urutan nya, dan ini berlaku juga bagi key_R(n). Nanti key_L(n) digabungkan */
/* kembali dengan key_R(n) dan di permutasi membentuk K(n) */
for (R=0;R<16;R++) {
/* Jumlah rotasi */
rotate=sub_key_rotate_table[R];

/* Membagi key menjadi 2 bagian, bagian kiri dan kanan dari key yg sekarang */
for (i=0;i<28;i++)
key_L[R][i]=key[i];
for (i=28;i<56;i++)
key_R[R][i-28]=key[i];

/* Proses Rotasi untuk bagian kiri ( key_L ) */
for (i=0;i<rotate;i++) {
temp[27]=key_L[R][0];
/* Simpan ke variabel sementara */
for (j=0;j<27;j++)
temp[j]=key_L[R][j+1];
/* Pindahkan dari variabel sementara ke variabel key_L, trus ulangi klo di rotate lbh dari 1 */
/* kali, uuuh...coding ny masih kotor niiii =( */
for (j=0;j<28;j++)
key_L[R][j]=temp[j];
}

/* Proses Rotasi untuk bagian kanan ( key_R ) */
for (i=0;i<rotate;i++) {
temp[27]=key_R[R][0];
/* Simpan ke variabel sementara */
for (j=0;j<27;j++)
temp[j]=key_R[R][j+1];
for (j=0;j<28;j++)
key_R[R][j]=temp[j];
}

/* Join ( Gabungkan ) kembali kedua bagian key ( Left & Right ) menjadi satu key 56 bit. */
/* Key ini kemudian akan digunakan pada proses rotasi tahap selanjut nya... */
for (i=0;i<28;i++)
key[i]=key_L[R][i];
for (i=0;i<28;i++)
key[i+28]=key_R[R][i];

} // Akhir dari proses rotasi sub-key

/* Gabungkan key_L[n] (28 bit) dengan key_R[n] (28bit) membentuk key_LR[n] (56 bit). */
/* n disini bernilai 1 s/d 16. */
for (R=0;R<16;R++) {
for (i=0;i<28;i++)
key_LR[R][i]=key_L[R][i];
for (i=0;i<28;i++)
key_LR[R][i+28]=key_R[R][i];
}

/* Permutasikan 16 key_LR[n] (56 bit) tersebut menjadi 16 buah K[n] (48 bit) menggunakan */
/* tabel PC-2 */
for (R=0;R<16;R++) {
/* Hm...variabel "ada" nih utk apa sih? well...t'nyata gak semua 56 bit di subkey awal muncul */
/* nilai nya pada tabel PC-2, oleh karena itu apabila ditemukan posisi di tabel 56 bit pada */
/* tabel PC-2, maka posisi nya dicatat dan variabel "ada" digunakan sbg acuan bahwa nilai */
/* posisi tersebut terdapat di tabel PC-2 dan bisa di masukan ke K[n]. */
ada=0;
for (i=0;i<56;i++) {
for (j=0;j<48;j++) {
if (table_PC_2[j]==(i+1)) {
ada=1;
break;
}
}
if (ada)
K[R][j]=key_LR[R][i];
ada=0;
}
}

} // End of keygen procedure =)

/* DES Process */

void des( int K[16][48], int Message[64], int chipertext[64] )
{

/************************************************************************************************/
/* */
/* Definisi tabel-tabel yang digunakan pada proses enkripsi menggunakan DES. Well...aku gak */
/* tau ini tabel berlaku selama nya sampe sekarang atau tidak, i just copy these table from */
/* reference i got on internet...so, i don't know if the table has changed or hasn't now...=P */
/* */
/************************************************************************************************/

/* Tabel Initial Permutation, untuk permutasi Message */
int table_IP[64] = {
58,50,42,34,26,18,10, 2,
60,52,44,36,28,20,12, 4,
62,54,46,38,30,22,14, 6,
64,56,48,40,32,24,16, 8,
57,49,41,33,25,17, 9, 1,
59,51,43,35,27,19,11, 3,
61,53,45,37,29,21,13, 5,
63,55,47,39,31,23,15, 7
};

/* Tabel inverse Initial Permutation, mengembalikan proses Initial Permutasi */
int table_IP_inverse[64] = {
40, 8,48,16,56,24,64,32,
39, 7,47,15,55,23,63,31,
38, 6,46,14,54,22,62,30,
37, 5,45,13,53,21,61,29,
36, 4,44,12,52,20,60,28,
35, 3,43,11,51,19,59,27,
34, 2,42,10,50,18,58,26,
33, 1,41, 9,49,17,57,25
};

/* Tabel E-bit-selection */
static int table_E_bit_selection[48] = {
32, 1, 2, 3, 4, 5,
4 , 5, 6, 7, 8, 9,
8 , 9,10,11,12,13,
12,13,14,15,16,17,
16,17,18,19,20,21,
20,21,22,23,24,25,
24,25,26,27,28,29,
28,29,30,31,32, 1
};

/* Tabel "S Boxes" */
static int S_Boxes[8][64]= {
/* Tabel S[0] */
{ 14, 4,13, 1, 2,15,11, 8, 3,10, 6,12, 5, 9, 0, 7,
0 ,15, 7, 4,14, 2,13, 1,10, 6,12,11, 9, 5, 3, 8,
4 , 1,14, 8,13, 6, 2,11,15,12, 9, 7, 3,10, 5, 0,
15,12, 8, 2, 4, 9, 1, 7, 5,11, 3,14,10, 0, 6,13 },
/* Tabel S[1] */
{ 15, 1, 8,14, 6,11, 3, 4, 9, 7, 2,13,12, 0, 5,10,
3 ,13, 4, 7,15, 2, 8,14,12, 0, 1,10, 6, 9,11, 5,
0 ,14, 7,11,10, 4,13, 1, 5, 8,12, 6, 9, 3, 2,15,
13, 8,10, 1, 3,15, 4, 2,11, 6, 7,12, 0, 5,14, 9 },
/* Tabel S[2] */
{ 10, 0, 9,14, 6, 3,15, 5, 1,13,12, 7,11, 4, 2, 8,
13, 7, 0, 9, 3, 4, 6,10, 2, 8, 5,14,12,11,15, 1,
13, 6, 4, 9, 8,15, 3, 0,11, 1, 2,12, 5,10,14, 7,
1 ,10,13, 0, 6, 9, 8, 7, 4,15,14, 3,11, 5, 2,12 },
/* Tabel S[3] */
{ 7,13,14, 3, 0, 6, 9,10, 1, 2, 8, 5,11,12, 4,15,
13, 8,11, 5, 6,15, 0, 3, 4, 7, 2,12, 1,10,14, 9,
10, 6, 9, 0,12,11, 7,13,15, 1, 3,14, 5, 2, 8, 4,
3,15, 0, 6,10, 1,13, 8, 9, 4, 5,11,12, 7, 2,14 },
/* Tabel S[4] */
{ 2 ,12, 4, 1, 7,10,11, 6, 8, 5, 3,15,13, 0,14, 9,
14,11, 2,12, 4, 7,13, 1, 5, 0,15,10, 3, 9, 8, 6,
4 , 2, 1,11,10,13, 7, 8,15, 9,12, 5, 6, 3, 0,14,
11, 8,12, 7, 1,14, 2,13, 6,15, 0, 9,10, 4, 5, 3 },
/* Tabel S[5] */
{ 12, 1,10,15, 9, 2, 6, 8, 0,13, 3, 4,14, 7, 5,11,
10,15, 4, 2, 7,12, 9, 5, 6, 1,13,14, 0,11, 3, 8,
9 ,14,15, 5, 2, 8,12, 3, 7, 0, 4,10, 1,13,11, 6,
4 , 3, 2,12, 9, 5,15,10,11,14, 1, 7, 6, 0,8 ,13 },
/* Tabel S[6] */
{ 4 ,11, 2,14,15, 0, 8,13, 3,12, 9, 7, 5,10, 6, 1,
13, 0,11, 7, 4, 9, 1,10,14, 3, 5,12, 2,15, 8, 6,
1 , 4,11,13,12, 3, 7,14,10,15, 6, 8, 0, 5, 9, 2,
6 ,11,13, 8, 1, 4,10, 7, 9, 5, 0,15,14, 2, 3,12 },
/* Tabel S[7] */
{ 13, 2, 8, 4, 6,15,11, 1,10, 9, 3,14, 5, 0,12, 7,
1 ,15,13, 8,10, 3, 7, 4,12, 5, 6,11, 0,14, 9, 2,
7 ,11, 4, 1, 9,12,14, 2, 0, 6,10,13,15, 3, 5, 8,
2 , 1,14, 7, 4,10, 8,13,15,12, 9, 0, 3, 5, 6,11}
};

/* Tabel Permutasi ( digunakan pada final stage untuk mendapatkan nilai f )*/
static int table_P[32] = {
16, 7,20,21,
29,12,28,17,
1 ,15,23,26,
5 ,18,31,10,
2 , 8,24,14,
32,27, 3, 9,
19,13,30, 6,
22,11, 4,25
};

int i,j;
int Ln[32],Rn[32]; // M dibagi menjadi 2 bagian dan ditampung pada kedua variabel ini
int n;
int temp[32];
int E_Rn[48]; // Menampung 48 bit hasil expand R[n-1] dari tabel E-bit selection
int XOR_Out[48]; // Menampung hasil "K[n]+E_R[n-1]"
int group,bit_row[2],bit_column[4],counter;
int row,column; // Menampung data desimal untuk baris dan kolom
int SBoxes_Out[32],output;
int f[32];
//int chipertext[64]; // Hasil akhir enkripsi di simpan disini =)
int M[64]; // Variabel untuk menyimpan message yang telah melalui permutasi

/* =================================================== */
/* Hm...let's begin the DES encryption process now =) */
/* =================================================== */

/* Proses initial permutasi dari Message awal ke M ( Message yang sudah di initial permutasi ) */
for (i=0;i<64;i++) {
for (j=0;j<64;j++)
if (table_IP[j]==(i+1))
break;
M[j]=Message[i];

}

/* 16 iteration parts */
for (n=0;n<16;n++) {

/* Bagi M menjadi 2 bagian, Ln memegang bag. kiri dan Rn memegang bag. kanan */
for (i=0;i<32;i++)
Ln[i]=M[i];
for (i=0;i<32;i++)
Rn[i]=M[i+32];

/***********************************************************************/
/* */
/* Next...ini rumus nya : */
/* Ln=R[n-1]; */
/* Rn=L[n-1]+f(R[n-1],Kn) */
/* */
/***********************************************************************/

/* Ln=R[n-1], tp simpan dulu Ln ke variabel sementara krn akan digunakan utk menghitung Rn */
for (i=0;i<32;i++)
temp[i]=Ln[i];
for (i=0;i<32;i++)
Ln[i]=Rn[i];

/* Sekarang hitung Rn. Untuk menghitung f(R[n-1],Kn) maka pertama-tama expand blok R[n-1] yang */
/* semula 32 bit menjadi 48 bit dengan menggunakan tabel "E-bit selection", penggunaan nya sama */
/* seperti menggunakan tabel permutasi =) */

for (i=0;i<48;i++) {
for (j=0;j<32;j++)
if (table_E_bit_selection[i]==(j+1))
break;
E_Rn[i]=Rn[j];

}

/* E_R[n-1] merupakan hasil expand dari R[n-1], yaitu tiap 4 bit akan di expand menjadi 6 bit */
/* Langkah selanjut nya adalah melakukan operasi penjumlahan "Kn+E_R[n-1]", yaitu hasil */
/* expand E_R[n-1] dijumlahkan dengan Kn sehingga E_R[0]+K1,E_R[1]+K2,...dst */
/* Dalam operasi bit, penjumlahan sama dengan operasi XOR =) */

for (i=0;i<48;i++)
XOR_Out[i]=E_Rn[i] ^ K[n][i];

/* Selanjut nya...hasil XOR diatas yang berjumlah 48 bit akan dimasukan ke "S boxes" untuk */
/* kemudian didapatkan hasil yang berjumlah 32 bit, dengan kata lain hasil XOR tsb yang apabila */
/* dikelompokan menjadi 8 kelompok masing-masing kelompok berjumlah 6 bit setelah di masukan */
/* ke "S boxes" maka akan dihasilkan 8 kelompok dengan masing-masing kelompok berjumlah 4 bit */

counter=0; // Variabel ini menampung nilai counter utk mengelompokan 6 bit - 6 bit dr XOR_Output
for (group=0;group<8;group++) {
bit_row[0]=XOR_Out[counter*6]; // Bit pertama dari kelompok 6 bit
bit_row[1]=XOR_Out[(counter*6)+5]; // Bit terakhir dari kelompok 6 bit
for (i=0;i<4;i++)
bit_column[i]=XOR_Out[(counter*6)+(i+1)]; // Menyimpan bit ke-2 s/d ke-5
row=2*bit_row[0]+bit_row[1]; // Hitung nilai desimal untuk data baris
column=8*bit_column[0]+4*bit_column[1]+2*bit_column[2]+bit_column[3];
output=S_Boxes[group][(16*row)+column]; // Lookup tabel "S Boxes"

/* Isi ke variabel yang menampung data keluaran dari "S Boxes" */
SBoxes_Out[(group*4)+3] = ( output & 1 ) ? 1 : 0;
SBoxes_Out[(group*4)+2] = ( output & 2 ) ? 1 : 0;
SBoxes_Out[(group*4)+1] = ( output & 4 ) ? 1 : 0;
SBoxes_Out[(group*4)] = ( output & 8 ) ? 1 : 0;
counter++;

}

/* Selesai menghitung nilai f?well...not yet, output dr tabel "S Boxes" di permutasi dengan */
/* menggunakan table Permutasi ( table_P ) baru kemudian di dapatkan nilai f...fiuuuh, panjang */
/* ya....=P */
for (i=0;i<32;i++) {
for (j=0;j<32;j++)
if ((i+1)==table_P[j])
break;
f[j]=SBoxes_Out[i];
}

/* Selanjut nya yg t'akhir yaitu menghitung Rn = L[n-1] + f (R[n-1]+Kn) */
for (i=0;i<32;i++)
Rn[i] = temp[i] ^ f[i];

/* Proses looping di lakukan 16x, maka selanjutnya gabungkan Ln & Rn kembali membentuk M */
for (i=0;i<32;i++)
M[i]=Ln[i];
for (i=0;i<32;i++)
M[i+32]=Rn[i];

} // End of 16 interation parts, fiuuuh....( fiuuh again?!!!) =P

/* Setelah melalui 16x iterasi, maka didapatkan L16 dan R16. Selanjut nya gabungkan kedua bagian */
/* tersebut dengan urutan terbalik ( reverse ), yaitu menjadi R16L16 membentuk M akhir */
for (i=0;i<32;i++)
M[i]=Rn[i];
for (i=0;i<32;i++)
M[i+32]=Ln[i];

/* Last..., wew...at least...=P !!!!! */
/* Lakukan proses permutasi M ke tabel IPinverse dan simpan hasil nya di chipertext */
for (i=0;i<64;i++) {
for (j=0;j<64;j++)
if (table_IP_inverse[j]==(i+1))
break;
/* Here we go, hasil enkripsi Message dengan DES menghasilkan chipertext =) */
chipertext[j]=M[i];
}

/* ======================================================== */
/* EOF */
/* ======================================================== */

}

/* Procedure utk konversi dari desimal ke biner */

void dec2bin( int decimal, int biner[8] )
{

/* Konversi dari bilangan desimal ke bilangan biner */
biner[7]= ( decimal & 1 ) ? 1:0;
biner[6]= ( decimal & 2 ) ? 1:0;
biner[5]= ( decimal & 4 ) ? 1:0;
biner[4]= ( decimal & 8 ) ? 1:0;
biner[3]= ( decimal & 16 ) ? 1:0;
biner[2]= ( decimal & 32 ) ? 1:0;
biner[1]= ( decimal & 64 ) ? 1:0;
biner[0]= ( decimal & 128 ) ? 1:0;

}

/* Fungsi utk konversi dari biner ke desimal */

int bin2dec( int biner[8] )
{

int decimal;

/* Konversi dari bilangan biner ke bilangan desimal */
decimal = (128*biner[0]) + (64*biner[1]) + (32*biner[2]) + (16*biner[3]) + (8*biner[4]) +
(4*biner[5]) + (2*biner[6]) + (1*biner[7]);

return decimal;

}

encrypt.c

#include
#include "des.h"

void AUTHOR()
{

printf(" ============================================================================== \n");
printf(" * Cyb3rh3b * \n");
printf(" * * \n");
printf(" * Program enkripsi dengan menggunakan algoritma DES * \n");
printf(" * * \n");
printf(" * * \n");
printf(" ============================================================================== \n");

}

void wait()
{

printf("Processing...........\n");
sleep(5);
}

int main( int argc, char *argv[] )
{

int input_key_64bit[64] = {
0,0,0,1,0,0,1,1,
0,0,1,1,0,1,0,0,
0,1,0,1,0,1,1,1,
0,1,1,1,1,0,0,1,
1,0,0,1,1,0,1,1,
1,0,1,1,1,1,0,0,
1,1,0,1,1,1,1,1,
1,1,1,1,0,0,0,1
};

/* 64 bit contoh Message yang akan di enkripsi */
int Message[64] = {
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0
};

int K[16][48]; // 16 Key untuk encrpt dan decrypt disimpan disini =)
int chipertext[64]; // chipertext disimpan disini
int i,j,k,byte,index;
int binary_char[8]; // Variabel penampung data biner sementara
int c;
int char_sum; // Jumlah karakter yang telah dibaca
FILE *fp;
FILE *fm; // Pointer file Message
FILE *fc; // Pointer file chipertext

/* Usage : encrypte */
if ( argc != 2 ) {
AUTHOR();
printf("Usage : encrypt ");
printf("\n\n\n");
printf(" merupakan nama file yang akan di enkripsi! \n");
exit(1);
}

/* Check apakah file "key.des" yang menyimpan key enkripsi ada */
if ((fp = fopen("key.des","r")) == NULL ) {
AUTHOR();
printf("\n");
printf("Error : File \"key.des\" tidak bisa di buka. Buat dulu file yang menyimpan key ini dengan menggunakan keygen\n");
exit(1);
}

/* Load key dari file "key.des" ke K[][] */
else {

index=0;byte=0;
while ((( c = getc(fp) ) != EOF) && c!= 10) {
dec2bin(c,binary_char);
for (i=0;i<8;i++)
K[index][(8*byte)+i]=binary_char[i];
byte++;
if (byte==6) {
byte=0;
index++;
}
}

fclose(fp);
} // End of key load

/* Check apakah file "Message.chiper" dapat dibuat, file ini yang akan menampung hasil encrypt */
if ((fc = fopen("Message.chiper","w")) == NULL) {
AUTHOR();
printf("\n");
printf("Error : File \"Message.chiper\" tidak dapat dibuat");
printf("\n");
exit(1);
}

/* Buka file "Message" yang akan di enkripsi */
if ((fm = fopen(argv[1],"r")) == NULL) {
AUTHOR();
printf("\n");
fprintf(stderr,"Error : File %s tidak dapat di buka",argv[1]);
exit(1);
}
/* Proses enkripsi */
else {
AUTHOR();
wait();
char_sum=0;
while((( c = getc(fm) ) != EOF ) && c != 10 ) {
dec2bin(c,binary_char);
for (i=0;i<8;i++)
Message[i+(char_sum*8)]=binary_char[i];
/* Naikan jumlah karakter yang telah dibaca dari file */
char_sum++;
/* Apabila sudah dibaca 8 karakter (64 bit) maka lakukan proses enkripsi */
if ( char_sum == 8 ) {
/* Encrypt it! */
des( K, Message, chipertext );
/* Tulis chipertext ke file "Message.chiper" */
for (i=0;i<8;i++)
for(j=0;j<8;j++) {
binary_char[j]=chipertext[(i*8)+j];
c=bin2dec(binary_char);
putc(c,fc);
}
/* Kembalikan jumlah karakter yang telah dibaca ke nol */
char_sum=0;
/* Kembalikan data Message sehingga berisi nol, tujuan nya?Agar apabila jumlah karakter */
/* yang akan dibaca selanjut nya kurang dari 64 bit maka sisa bit nya bernilai nol */
for (i=0;i<64;i++)
Message[i]=0;
}

} // End of while process ( pembacaan dari file message yang akan di enkripsi )

/* Apabila pembacaan dari file selesai dan ternyata jumlah karakter yang sudah terbaca kurang */
/* dari 64 bit, maka jalankan proses ini... */
if ( char_sum ) {
des(K, Message, chipertext);
for (i=0;i<char_sum;i++)
for (j=0;j<8;j++) {
binary_char[j]=chipertext[(i*8)+j];
c=bin2dec(binary_char);
putc(c,fc);
}
}

/* Tutup kembali semua file */
fclose(fm);
fclose(fc);

}

printf("Finish...............=)!\n");
printf("Hasil enkripsi disimpan pada file \"Message.chiper\". Enjoy it !!! \n");

/*

for (i=0;i<64;i++) {
printf("%d ",chipertext[i]);
if (!((i+1)%8)) printf ("\n");
}
*/

return 0;

}

keygen.c

#include
#include "des.h"

void AUTHOR()
{

printf(" ============================================================================== \n");
printf(" * * \n");
printf(" * Key Generator untuk mendapatkan key yang akan digunakan pada enkripsi DES * \n");
printf(" * * \n");
printf(" * * \n");
printf(" ============================================================================== \n");

}

int main( int argc, char *argv[] )
{

FILE *fp;
int input_key_64bit[64];
int K[16][48];
int buffer[64];
int binary_char[8];
int char_sum;
int i,j,k,l,c,a;

/* Print author name =P */
AUTHOR();
/* Usage : $ keygen */
if ( argc != 2 ) {
printf("Usage : keygen \n");
printf("\n\n");
printf(" merupakan file berisi 8 karakter yang akan dijadikan key \n");
exit(0);
}

if ((fp = fopen(argv[1],"r")) == NULL) {
printf("\n");
fprintf(stderr,"Error: File %s tidak bisa di buka",argv[1]);
exit(1);
}

else {
char_sum=0;
while((( c = getc(fp) ) != EOF ) && c != 10) {
dec2bin(c,binary_char);
for (i=0;i<8;i++)
input_key_64bit[i+(char_sum*8)]=binary_char[i];
char_sum++;

}
fclose(fp);
}

/* Generate key */
keygen(K,input_key_64bit);

if ((fp = fopen("key.des","w")) == NULL) {
printf("\n");
fprintf(stderr,"Error: File \"key.des\" tidak bisa di buat");
exit(1);
}

for (i=0;i<16;i++)
for (j=0;j<6;j++) {
for (k=0;k<8;k++)
binary_char[k]=K[i][(j*8)+k];
/* Ubah dari biner ke char */
c=bin2dec(binary_char);
/* Tulis karakter ke file */
putc(c,fp);
}

puts("Processing.....");

k=1;
for (i=0;i<5;i++) {
for (j=0;j<k;j++)
printf("#");
printf("\n");
sleep(1);
k+=3;
}

printf("\n");
printf("Key telah berhasil dibuat dan dimasukan pada file \"key.des\" \n");
fclose(fp);

return 0;

}

readme.first

Cara penggunaan:

1. Generate key dengan menggunakan program keygen, input dari keygen merupakan file (
diberikan contoh file "key.txt" ) yang didalam nya terdapat 8 karakter

2. Hasil generate adalah file key.des

3. Encrypt message dengan program "encrypt" dengan input file Message (nama file
bebas, dalam contoh diberikan nama file "Message" ) yang akan di enkripsi, hasil
enkripsi akan disimpan dalam file "Message.chiper"

Attachment: DES_113010102_113010119.zip

Diantara seluruh tugas, ada satu tugas yang sangat berkesan, yaitu untuk praktikum struktur data semester 2. Saat itu dengan bermodalkan buku programming C nya “abdul kadir” dan membaca contoh membuat tampilan grafikal (dengan cara melukis pada crt dan menghapus berulang kali), akhirnya bisa menghasilkan aplikasi database sederhana (intinya adalah struktur data dengan menggunakan pointer pada C) dengan tampilan grafis seperti lotus. Saat itu memberikan tampilan grafikal bisa dibilang sangat tidak umum karena program yang digunakan adalah turbo c dan tugas besar lain (yang saya tau, gak tau juga klo ada yang lain) umumnya menggunakan tampilan command line berbasis dos. Sayangnya sampai sekarang saya tidak menyimpan archive nya karena memang tugas tersebut dibuat pada semester 2 yang berarti sekitar pertengahan tahun 2002. Kalau tidak salah saat itu penyimpanan data menggunakan usb stick masih baru muncul, sehingga belum ada harddisk external yang dapat menyimpan data untuk jangka waktu lama (setelah selesai mengumpulkan tugas langsung dihapus), dan saya juga memformat komputer desktop yang digunakan saat itu berulang kali karena mulai mempelajari sistem operasi. Saya jadi bertanya-tanya apakah di STT Telkom data-data tugas besar setiap angkatan masih disimpan dengan rapi ya?!

Oh, mengenai program yang dibuat dulu, seandainya saya sudah mengenal security pasti akan jauh lebih menarik. Karena bahkan dosen ataupun senior pembimbing lab mengajarkan penggunaan ‘strcpy’ ;).

Advertisements

One thought on “Nostalgila: Tugas Besar Kuliah

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s