LAPORAN TUGAS PENGGANTI ETS

KRIPTOGRAFI

Disusun Oleh:

Mamnuah (06111540000001)

Rika Nurhanipah (06111540000054)

DEPARTEMEN MATEMATIKA
FAKULTAS KOMPUTASI DAN SAINS DATA
INSTITUT TEKNOLOGI SEPULUH NOPEMBER

Tahun 2018
 BAB I

DESKRIPSI TUGAS

Tanggal : 18 April 2018

 BAB III
“ENKRIPSI DAN DESKRIPSI ALGORITMA DES”

Skema global dari algoritma DES adalah sebagai berikut:

1. Blok plainteks dipermutasi dengan matriks permutasi awal (initial permutation

atau IP).
2. Hasil permutasi awal kemudian di-enciphering- sebanyak 16 kali (16 putaran).
Setiap putaran menggunakan kunci internal yang berbeda.
3. Hasil enciphering kemudian dipermutasi dengan matriks permutasi balikan
(invers initial permutation atau IP-1 ) menjadi blok cipherteks.
ENKRIPSI DES
Di dalam proses enciphering, blok plainteks terbagi menjadi dua bagian, kiri (L) dan kanan
(R), yang masing-masing panjangnya 32 bit. Kedua bagian ini masuk ke dalam 16 putaran
DES. Pada setiap putaran i, blok R merupakan masukan untuk fungsi transformasi yang disebut
f. Pada fungsi f, blok R dikombinasikan dengan kunci internal Ki. Keluaran dai fungsi f di-
XOR-kan dengan blok L untuk mendapatkan blok R yang baru. Sedangkan blok L yang baru
langsung diambil dari blok R sebelumnya. Ini adalah satu putaran DES. Secara lengkap proses
Enkripsi dengan menggunakan DES ditunjukan pada skema berikut :
Algoritma DES memerlukan sebuah kunci yang panjang bloknya 64 bit di setiap blok
DES digunakan untuk mengamankan data pada perangkat lunak dan keras negara tersebut.
Berikut desain input-output algoritma DES
Dapat dilihat bahwa ada dua input untuk fungsi enkripsi, yaitu plaintext dengan panjang 64-
bit dan kunci dengan panjang 56-bit. Untuk mengenkripsi data dengan menggunakan algoritma
DES, dimulai dengan membagi bit dari teks tersebut kedalam blok-blok dengan ukuran blok
sebesar 64-bit, yang kemudian disebut blok plaintext. Adapun penjelasan langkah-langkah
enkripsi DES dijelaskan sebagai berikut :
A. Permutasi Awal
Sebelum putaran pertama, terhadap blok plainteks dilakukan permutasi awal (initial
permutation atau IP). Tujuan permutasi awal adalah mengacak plainteks sehingga urutan bit-
biit di dalamnya berubah. Pengacakan dilakukan dengan menggunakan matriks permutasi awal
berikut ini:

B. Pembangkitan Kunci Internal

Pada proses enchipering akan dilakukan proses pemutaran sebanyak 16 kali, oleh karena
itu dibutuhkan 16 buah kunci. 16 buah kunci tersebut dibangkitkan dari kunci eksternal.
Masukan kunci (input key) K dispesifikasikan sebagai 64-bit kunci (key), kunci eksternal ini
akan menjadi masukan untuk permutasi dengan menggunakan matriks permutasi choice one
(PC-1) berikut ini:
8 buah bit yaitu bit 8, 16, 24, 32, 40, 48, 56, dan 64 digunakan sebagai parity bit. Parity
bit tersebut akan mereduksi ukuran efektif key dari 64-bit menjadi 56-bit. Selanjutnya, 56 bit
yang tersisa ini dibagi menjadi dua bagian, yaitu bagian kiri (C0) dan bagian kanan (D0).
Selanjutnya kedua bagian digeser ke kiri (left shifting) sepanjang satu atau dua bit sesuai tabel
pergeseran berikut ini :

Setelah pergeseran bit, maka masing-masing Ci dan Di akan dipermutasi kembali

dengan menggunakan matriks PC-2 berikut :

Berikut ini merupakan skema yang menjelaskan proses pembangkitan kunci-kunci internal
DES :
C. Enciphering
Seperti sudah dijelaskan sebelumnya, setiap blok plaintext mengalami 16 kali
putaran enchipering. Secara matematis, satu putaran DES dinyatakan sebagai berikut :

Adapun langkah-langkah enchipering dapat dilihat pada skema berikut :

Adapun penjelasan dari skema diatas adalah :
 E merupakan fungsi ekspansi yang memperluas blok Ri-1 yang panjangnya 32-bit
menjadi 48-bit. Fungsi ekspansi ini direalisasikan melalui tabel berikut :

 Selanjutnya hasil ekspansi yaitu E(Ri-1), yang panjangnya 48-bit di XOR kan dengan Ki
yang panjangnya juga 48-bit dan menghasilkan vektor A yang panjangnya 48-bit.
 Vektor A kemudia dikelompokkan menjadi 8 kelompok yang masing-masing
panjangnya 6 bit dan menjadi masukkan bagi proses substitusi. Proses substitusi dilakukan
dengan menggunakan 8 buah kotak-s (s-box). Setiap kotak-s menerima 6 bit masukkan dan
menghasilkan keluaran 4 bit. Kelompok 6 bit pertama akan menggunakan s1, 6 bit selanjutnya
akan menggunakan s2, dan seterusnya. Bit awal dan akhir menentukan baris dan 4 bit ditengah
akan menentukan kolom yang akan dipilih.
Kedelapan kotak S (s-box) adalah :
Contoh pencarian output dari kotak s adalah :
Bit 100110 = keluaran dari kotak-s adalah kotak-s pertama, baris ke 2 dan kolom ke3 yaitu 8
(1000).

Keluaran proses substitusi adalah vector B yang panjangnya 48 bit. Vector B menjadi
masukan untuk proses permutasi. Adapun tujuan dari proses permutasi adalah untuk mengacak
hasil proses substitusi kotak-S. Hasil permutasi dinyatakan dalam fungsi f(Ri-1,Ki). Permutasi
ini dilakukan dengan menggunakan matriks permutasi sebagai berikut :

DEKRIPSI DES
DES memiliki proses yang sama untuk algoritma enkripsi dan dekripisinya. Proses
pendekripsian juga dilakukan dengan menggunakan cipher Feistel sebanyak 16 round, dengan
pada masing-masing round mengerjakan proses yang sama. Yang membedakan hanya urutan
kunci dan juga input masukannya yang berupa ciphertext.
Pada round pertama, yang digunakan adalah K16, round kedua menggunakan K15, dan
seterusnya hingga round terakhir akan menggunakan K1. Ciphertext yang digunakan yaitu
berupa L16R16 yang diperoleh dari hasil permutasi invers IP-1 terhadap ciphertext sebenarnya
(y) kemudian menukar 32 bit pertama dengan 32 bit terakhir dari hasil tersebut.

Proses dekripsi dilakukan dengan cara berkebalikan dari proses enkripsi, yaitu
dengan menggunakan L16 R16 untuk menemukan L0 R0 atau plaintext.

Atau dapat ditunjukkan dengan gambar berikut untuk proses setiap round-nya.

Maka dari itu, untuk mendapatkan L0 R0 bisa digunakan langkah berikut :

Cara untuk mendapatkan plainteks kembali yaitu:
x = IP-1 (RD0 LD0)

BAB VI
“ PEMBAHASAN DAN SIMULASI “

private void resetActionPerformed(java.awt.event.ActionEvent evt) {

msg.setText(null);
key.setText(null);
hasilen.setText(null);
hasildek.setText(null);
bytemsg.setText(null);
bytekey.setText(null);
}

private void enkripsiActionPerformed(java.awt.event.ActionEvent evt) {

ETSKRIPTO a = new ETSKRIPTO();
String x = msg.getText();
String y = key.getText();
if(x.isEmpty()||y.isEmpty()){
JOptionPane.showMessageDialog(null, "message/key tidak boleh kosong");
}
 else{
byte[] message = a.hexStringToByteArray(x);
String b = a.printBytes(message);
bytemsg.setText(b);
byte[] kunci = a.hexStringToByteArray(y);
String c = a.printBytes(kunci);
bytekey.setText(c);
byte[] cipher = a.crypt(message, kunci, "encrypt");
String m = a.printBytes(cipher);
hasilen.setText(m);
}
}

private void dekripsiActionPerformed(java.awt.event.ActionEvent evt) {

ETSKRIPTO a = new ETSKRIPTO();
String x = msg.getText();
String y = key.getText();
if(x.isEmpty()||y.isEmpty()){
JOptionPane.showMessageDialog(null, "message/key tidak boleh kosong");
}
else{
byte[] message = a.hexStringToByteArray(x);
byte[] kunci = a.hexStringToByteArray(y);
byte[] cipher = a.crypt(message, kunci, "encrypt");
byte[] result = a.crypt(cipher, kunci, "decrypt");
String m = a.printBytes(result);
hasildek.setText(m);
}
}

private void saveActionPerformed(java.awt.event.ActionEvent evt) {

if (hasilen.getText().isEmpty()){
JOptionPane.showMessageDialog(null, "hasil enkrisi tidak bisa disimpan karena hasil enkrip
kosong");
}
else{
String a = hasilen.getText();
String b = hasildek.getText();
simpan(a,b);
JOptionPane.showMessageDialog(null, "hasil enkrip berhasil disimpan");
}
}

public class ETSKRIPTO {

/* Permutasi awal */
final int[] IP = {
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
};
/* Invers dari permutasi awal*/
final int[] IIP = {
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
};
/* Permutasi Ekspansi */
final int[] E = {
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
};
/* Fungsi Permutasi */
final int[] P = {
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
};
/* Kotak-S */
final int[] S1 = {
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
};
final int[] S2 = {
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
};
 final int[] S3 = {
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
};
final int[] S4 = {
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
};
final int[] S5 = {
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
};
final int[] S6 = {
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
};
final int[] S7 = {
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
};
final int[] S8 = {
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
};
/* Matriks Pemutasi Kompresi PC1 */
final int[] PC1 = {
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
};
/* Matriks Pemutasi Kompresi PC2 */
final int[] PC2 = {
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
};
/* Jumlah pergeseran pada setiap putaran */
final int[] SHIFTS = {
1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1
};

public ETSKRIPTO() {
}

private byte[] performXOR(byte[] one, byte[] two) {

byte[] result = new byte[one.length];
for (int i = 0 ; i < one.length ; i++) {
result[i] = (byte) (one[i] ^ two[i]);
}
return result;
}

private byte[] permute(byte[] input, int[] mapping) {

int byteCount = 1 + (mapping.length - 1) / 8;
byte[] output = new byte[byteCount];
int pos;

for (int i = 0 ; i < mapping.length ; i++) {

pos = mapping[i] - 1;
int value = getBitFromArray(input, pos);
setBitInArray(output, i, value);
}
return output;
}

private int getBitFromArray(byte[] array, int pos) {

int value;
int bytePos = pos / 8;
int bitPos = pos % 8;
value = (array[bytePos] >> (8 - (bitPos + 1))) & 0x0001;
return value;
}

private void setBitInArray(byte[] input, int pos, int value) {

int bytePos = pos / 8;
int bitPos = pos % 8;
byte old = input[bytePos];
old = (byte) (((0xFF7F >> bitPos) & old) & 0x00FF);
byte newByte = (byte) ((value << (8 - (bitPos + 1))) | old);
input[bytePos] = newByte;
 }

private byte[] hexStringToByteArray(String string) {

int length = string.length();
int n = (int)Math.ceil((length + 1) / 2);
byte[] result = new byte[n];
for (int i = length - 1; i >= 0 ; i -= 2) {
if (i == 0) {
result[i / 2] = (byte) ((Character.digit('0', 16) << 4)
+ Character.digit(string.charAt(i), 16));
} else {
result[i / 2] = (byte) ((Character.digit(string.charAt(i - 1), 16) << 4)
+ Character.digit(string.charAt(i), 16));
}
}
return result;
}

private String printBytes(byte[] input) {

String m = "";
for (int i = 0 ; i < input.length; i++) {
m = m + (byteToBits(input[i])+ "\n");

}
return m;
}

private String byteToBits(byte b) {

StringBuffer buffer = new StringBuffer();
for (int i = 0 ; i < 8 ; i++)
buffer.append((int)(b >> (8-(i+1)) & 0x0001));
return buffer.toString();
}

private byte[] getBits(byte[] input, int startPos, int length) {

int noOfBytes = (length-1)/8 + 1;
byte[] output = new byte[noOfBytes];
for (int i = 0 ; i < length ; i++) {
int value = getBitFromArray(input, startPos + i);
setBitInArray(output, i, value);
}
return output;
}

private byte[] rotateLeft(byte[] input, int step, int length) {

int noOfBytes = (length - 1) / 8 + 1;
byte[] output = new byte[noOfBytes];
for (int i = 0 ; i < length ; i++) {
int value = getBitFromArray(input, (i + step) % length);
setBitInArray(output, i, value);
}
 return output;
}

private byte[] concatBits(byte[] one, int oneLength,

byte[] two, int twoLength) {
int noOfBytes = (oneLength + twoLength - 1) / 8 + 1;
byte[] output = new byte[noOfBytes];
int i = 0, j = 0;
for (; i < oneLength ; i++) {
int value = getBitFromArray(one, i);
setBitInArray(output, j, value);
j++;
}
for (i = 0 ; i < twoLength ; i++) {
int value = getBitFromArray(two, i);
setBitInArray(output, j, value);
j++;
}
return output;
}

private byte[][] getSubKeys(byte[] masterKey) {

int noOfSubKeys = SHIFTS.length;
int keySize = PC1.length;
byte[] key = permute(masterKey, PC1);
byte[][] subKeys = new byte[noOfSubKeys][keySize];
byte[] leftHalf = getBits(key, 0, keySize/2);
byte[] rightHalf = getBits(key, keySize/2, keySize/2);
for (int i = 0 ; i < noOfSubKeys ; i++) {
leftHalf = rotateLeft(leftHalf, SHIFTS[i], keySize/2);
rightHalf = rotateLeft(rightHalf, SHIFTS[i], keySize/2);
byte[] subKey = concatBits(leftHalf, keySize/2, rightHalf, keySize/2);
subKeys[i] = permute(subKey, PC2);
}
return subKeys;
}

public byte[] crypt(byte[] message, byte[] key, String operation) {

if (message.length < 8) {
System.out.println("Message should be atleast 64 bits");
System.exit(1);
}
if (key.length != 8) {
System.out.println("Key should be 64 bits");
System.exit(1);
}
int length = message.length;
int n = (length + 7)/8 * 8;
byte[] cipher = new byte[n];
if (length == 8) {
return cryptText(message, key, operation);
 }
int i = 0;
int k = 0;
while (i < length) {
byte[] block = new byte[8];
byte[] result = new byte[8];
int j = 0;
for (; j < 8 && i < length; j++, i++) {
block[j] = message[i];
}
while (j < 8) {
block[j++] = 0x00;
}
System.out.println("BLOCK: ");
printBytes(block);
result = cryptText(block, key, operation);
System.out.println("RESULT: ");
printBytes(result);
for (j = 0 ; j < 8 && k < cipher.length; j++, k++) {
cipher[k] = result[j];
}
}
return cipher;
}

public byte[] cryptText(byte[] message, byte[] key, String operation) {

if (message.length != 8) {
System.out.println("Message should be 64 bits");
System.exit(1);
}
if (key.length != 8) {
System.out.println("Key should be 64 bits");
System.exit(1);
}
byte[] result = null;
int blockSize = IP.length;
byte[][] subKeys = getSubKeys(key);
int noOfRounds = subKeys.length;
/**
* Initial Permutation
*/
message = permute(message, IP);
/**
* Split message into two halves
*/
byte[] leftHalf = getBits(message, 0, blockSize/2);
byte[] rightHalf = getBits(message, blockSize/2, blockSize/2);
for (int i = 0 ; i < noOfRounds ; i++) {
byte[] temp = rightHalf;
/**
* Expansion
 */
rightHalf = permute(rightHalf, E);
/**
* XOR rightHalf with roundKey
*/
byte[] roundKey = null;
if (operation.equalsIgnoreCase("encrypt")) {
roundKey = subKeys[i];
} else if (operation.equalsIgnoreCase("decrypt")) {
roundKey = subKeys[noOfRounds - i - 1];
} else {
System.out.println("Unsupported operation");
System.exit(0);
}
rightHalf = performXOR(rightHalf, roundKey);
/**
* Kotak-S
*/
rightHalf = sBox(rightHalf);
/**
* Permutasi
*/
rightHalf = permute(rightHalf, P);
/**
* XOR sisi kanan dan sisi kiri
*/
rightHalf = performXOR(rightHalf, leftHalf);
/**
* L(i) = R(i-1)
*/
leftHalf = temp;
}
byte[] concatHalves = concatBits(rightHalf, blockSize/2, leftHalf, blockSize/2);
/**
* Invers dari permutasi awal
*/
result = permute(concatHalves, IIP);
return result;
}

private byte[] sBox(byte[] input) {

/**
* membagi input ke dalam 6-bit blok
*/
input = split(input,6);
byte[] output = new byte[input.length/2];
int leftHalf = 0;
for (int i = 0; i < input.length ; i++) {
byte block = input[i];
int row = 2 * (block >> 7 & 0x0001) + (block >> 2 & 0x0001);
int col = block >> 3 & 0x000F;
 int[] selectedSBox = getSBox(i);
int rightHalf = selectedSBox[16 * row + col];
if (i % 2 == 0) {
leftHalf = rightHalf;
} else {
output[i/2] = (byte) (16 * leftHalf + rightHalf);
leftHalf = 0;
}
}
return output;
}

private int[] getSBox(int i) {

switch (i) {
case 0: return S1;
case 1: return S2;
case 2: return S3;
case 3: return S4;
case 4: return S5;
case 5: return S6;
case 6: return S7;
case 7: return S8;
default: return null;
}
}

private byte[] split(byte[] input, int length) {

int noOfBytes = (8 * input.length - 1) / length + 1;
byte[] output = new byte[noOfBytes];
for (int i = 0 ; i < noOfBytes ; i++) {
for (int j = 0; j < length ; j++) {
int value = getBitFromArray(input, length * i + j);

setBitInArray(output, 8 * i + j, value);
}
}
return output;
}
}
public static String simpan(String enkrip, String dekrip) {
String teks = enkrip;
String tt = dekrip;
String path = "hasilrunningETS.txt";
try {
FileWriter fw = new FileWriter(path);
BufferedWriter bw = new BufferedWriter(fw);
bw.write("hasil enkripsi");
bw.write("\n"+teks);
bw.write("\n hasil dekripsi");
bw.write("\n"+tt);
bw.close();
 } catch (Exception e) {
}
return "";
}

public static void main(String args[]) {

/* Set the Nimbus look and feel */
//<editor-fold defaultstate="collapsed" desc=" Look and feel setting code (optional) ">
/* If Nimbus (introduced in Java SE 6) is not available, stay with the default look and feel.
* For details see http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/plaf.html
*/
try {
for (javax.swing.UIManager.LookAndFeelInfo info :
javax.swing.UIManager.getInstalledLookAndFeels()) {
if ("Nimbus".equals(info.getName())) {
javax.swing.UIManager.setLookAndFeel(info.getClassName());
break;
}
}
} catch (ClassNotFoundException ex) {

java.util.logging.Logger.getLogger(GUI_ETS_KRIPTO.class.getName()).log(java.util.logging.Level.SEVE
RE, null, ex);
} catch (InstantiationException ex) {

java.util.logging.Logger.getLogger(GUI_ETS_KRIPTO.class.getName()).log(java.util.logging.Level.SEVE
RE, null, ex);
} catch (IllegalAccessException ex) {

java.util.logging.Logger.getLogger(GUI_ETS_KRIPTO.class.getName()).log(java.util.logging.Level.SEVE
RE, null, ex);
} catch (javax.swing.UnsupportedLookAndFeelException ex) {

java.util.logging.Logger.getLogger(GUI_ETS_KRIPTO.class.getName()).log(java.util.logging.Level.SEVE
RE, null, ex);
}
//</editor-fold>

/* Create and display the form */

java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new GUI_ETS_KRIPTO().setVisible(true);
}
});
}

// Variables declaration - do not modify

private javax.swing.JTextArea bytekey;
 private javax.swing.JTextArea bytemsg;
private javax.swing.JButton dekripsi;
private javax.swing.JButton enkripsi;
private javax.swing.JButton exit;
private javax.swing.JTextArea hasildek;
private javax.swing.JTextArea hasilen;
private javax.swing.JLabel jLabel1;
private javax.swing.JLabel jLabel2;
private javax.swing.JLabel jLabel3;
private javax.swing.JLabel jLabel4;
private javax.swing.JLabel jLabel5;
private javax.swing.JLabel jLabel6;
private javax.swing.JLabel jLabel7;
private javax.swing.JLabel jLabel8;
private javax.swing.JLabel jLabel9;
private javax.swing.JPanel jPanel1;
private javax.swing.JPanel jPanel2;
private javax.swing.JPanel jPanel3;
private javax.swing.JScrollPane jScrollPane1;
private javax.swing.JScrollPane jScrollPane2;
private javax.swing.JScrollPane jScrollPane3;
private javax.swing.JScrollPane jScrollPane4;
private javax.swing.JScrollPane jScrollPane6;
private javax.swing.JTextField key;
private javax.swing.JTextArea msg;
private javax.swing.JButton reset;
private javax.swing.JButton save;
}
 a. Hasil running

b. Hasil running setelah plainteks dan kunci diganti

 BAB V
“KESIMPULAN DAN SARAN”

Output yang dihasilkan berupa hasil bilangan biner yang sudah di XOR kan,dimana kunci yang
diberikan sudah ditentukan yaitu hanya dibatasi sampai 15 s/d 16 karakter dan plainteksnya
hanya bisa dibatasi minimal 16 karakter .Kekurangan dari algoritma ini adalah cipherteks yang
dihasilkan tidak dalam bentuk karakter sehingga masih perlu dikonversi menggunakan tabel
ASCII dan juga dalam penyimpanan hasil enkripsi masih ada kekurangan berupa tidak
tersimpannya(hilang) hasil running sebelumnya jika kita menyimpan hasil runingg yang baru.