implementasi enkripsi dan dekripsi … · random key is generated using a random num ber generator,...

i

IMPLEMENTASI ENKRIPSI DAN DEKRIPSI

DOKUMEN MENGGUNAKAN ALGORITMA ONE

TIME PAD DENGAN PEMBANGKIT BILANGAN

ACAK MERSENNE TWISTER

Skripsi

Diajukan Untuk Memenuhi Salah Satu Syarat

Memperoleh Gelar Sarjana Komputer Program Studi Teknik Informatika

Oleh:

Fidelis Asterina Surya Prasetya

105314021

PROGRAM STUDI TEKNIK INFORMATIKA

JURUSAN TEKNIK INFORMATIKA

FAKULTAS SAINS DAN TEKNOLOGI

UNIVERSITAS SANATA DHARMA

YOGYAKARTA

2016

PLAGIAT MERUPAKAN TINDAKAN TIDAK TERPUJIPLAGIAT MERUPAKAN TINDAKAN TIDAK TERPUJI

ii

IMPLEMENTATION CONVENTIONAL

ENCRYPTION ALGORITHM USING ONE TIME PAD

WITH THE MERSENNE TWISTER RANDOM

NUMBER GENERATOR

A Thesis

Presented as Partial Fulfillment of the Requirements

To Obtain the Sarjana Komputer Degree

In Informatics Engineering Study Program

By:

Fidelis Asterina Surya Prasetya

105314021

INFORMATICS ENGINEERING STUDY PROGRAM

FACULTY OF SCIENCE AND TECHNOLOGY

SANATA DHARMA UNIVERSITY

YOGYAKARTA

2016


HALAMAN MOTTO

“Never Give Up, God Never Give Up On You”


ABSTRAK

Pada dasarnya melakukan pengiriman data tanpa melakukan pengamanan

pada konten dari data yang dikirim, dapat menyebabkan adanya penyadapan pada

jalur pengirimannya. Data penting yang berformat .txt mudah sekali untuk disadap

dan data berformat .doc dapat disandikan menggunakan password namun fitur

tersebut memiliki kelemahan yaitu adanya aplikasi yang dapat digunakan untuk

membobol file yang telah terenkripsi. Untuk itulah peranan teknologi keamanan

informasi benar - benar dibutuhkan. Salah satu teknik untuk pengamanan data

adalah dengan menggunakan algoritma penyandian data.

Algoritma One Time Pad merupakan algoritma sederhana dan unbreakable

dikarenakan algoritma One Time Pad memiliki barisan kunci acak yang

ditambahkan ke pesan plaintext yang tidak acak untuk menghasilkan chipertext

yang seluruhnya acak. Kunci acak tersebut dibangkitkan menggunakan metode

pembangkit bilangan acak antara lain Mersenne Twister. Mersenne Twister

menghasilkan bilangan acak yang memiliki distribusi yang sangat bagus,

pembangkitan bilangan yang sangat cepat dan menggunakan memori yang efisien.

Pada tugas akhir ini penulis mencari tahu presentase keberhasilan

implementasi algoritma One Time Pad untuk mengenkripsi dan mendekripsi berkas

dokumen dalam bentuk .txt,.doc.

Hasil penelitian yang dilakukan sebanyak 10 pengujian memperlihatkan

bahwa presentase keberhasilan implementasi algoritma One Time Pad untuk

mengenkripsi dan mendekripsi berkas dokumen dalam bentuk .txt,.doc adalah

100% serta lama proses enkripsi dekripsi didasarkan pada randomnya kunci acak

yang digunakan dalam proses tersebut.

Kata Kunci : kriptografi, Mersenne Twister, One Time Pad


ABSTRACT

Basically perform data transmission without providing security on the

content of the data sent, may cause tapping on shipping lanes. Important data format

easy to be tapped .txt and .doc formatted data can be encrypted using a password

but the feature has the disadvantage of their application that can be used to break

into files that have been encrypted. For that role of information security technology

really - really needed. One technique for data security is to use the data encryption

algorithms.

One Time Pad algorithm is an algorithm because the algorithm is simple

and unbreakable One Time Pad has rows of random keys that are added to the

plaintext message that is not random to produce ciphertext which is entirely

random. Random key is generated using a random number generator, among others

Mersenne Twister. Mersenne Twister random number which has resulted in a very

good distribution, generation numbers are very fast and uses memory efficiently.

In this thesis the author to find out the percentage of successful

implementation of One Time Pad algorithm to encrypt and decrypt the document

file in the form of .txt, .doc.

Results of research conducted as many as 10 test showed that the percentage

of successful implementation of One Time Pad algorithm to encrypt and decrypt

the document file in the form of .txt, .doc is 100% and the long process of

encryption decryption randomnya based on random keys that are used in the

process.

Keywords: cryptography, Mersenne Twister, One Time Pad


KATA PENGANTAR

Puji dan syukur kepada Tuhan Yesus Kristus, atas segala berkat dan karunia

sehingga penulis dapat menyelesaikan penelitian tugas akhir dengan judul

“Implementasi Enkripsi dan Dekripsi Dokumen Menggunakan Algoritma One

Time Pad Dengan Pembangkit Bilangan Acak Mersenne Twister” dengan baik.

Tugas ini ditulis sebagai salah satu syarat memperoleh gelar sarjana komputer

program studi Teknik Informatika, Fakultas Sains dan Teknologi Universitas

Sanata Dharma.

Penelitian ini tidak dapat berjalan dengan baik tanpa adanya dukungan,

semangat, motivasi dan bantuan dalam bentuk apapun yang telah diberikan oleh

banyak pihak. Untuk itu penulis mengucapkan terimakasih yang sebesar-besarnya

kepada:

1. Tuhan Yesus Kristus, dan Bunda Maria, telah memberkati serta

membimbing penulis sehingga dapat menyelesaikan tugas akhir ini.

2. Ibu Paulina Heruningsih Prima Rosa, S.Si., M.Sc. selaku Dekan Fakultas

Sains dan Teknologi.

3. Ibu Dr. Anastasia Rita Widiarti, M.Kom selaku Ketua Program Studi Teknik

Informatika.

4. Ibu Dr. Anastasia Rita Widiarti, M.Kom selaku dosen pembimbing yang

telah dengan sabar membimbing dan memberikan kesabaran, waktu,

kebaikan, dan motivasi.

5. Bapak Bambang Soelistijanto, Ph.D dan Bapak Eko Hari Permadi,S.Si.,

M.Kom selaku dosen penguji atas kritik dan saran yang telah diberikan.

6. Ibu Agnes Maria Polina S.Kom., M.Sc. selaku Dosen Pembimbing

Akademik.

7. Seluruh dosen yang mendidik dan memberikan ilmu pengetahuan

berharga selama penulis belajar di Universitas Sanata Dharma

Yogyakarta.


8. Kedua orang tua tercinta YB. Suryadi dan Tri Yuli Prasetyaningsih.

Terimakasih untuk setiap doa, kasih sayang, perhatian, dan dukungan

yang selalu diberikan kepada saya.

9. Adik tersayang Balissa Rosarina Surya Prasetya. Terimakasih untuk

dukungan yang selalu diberikan kepada saya.

10. Engelbert Eric dan Felisitas Brillianti. Terimakasih untuk segala bantuan

yang selalu diberikan kepada saya.

11. Kristoforus Sugiarto Adji Soenarso, S.Farm, Apt. Terimakasih untuk

segala dukungan dan bantuan yang selalu diberikan.

12. Verena Pratita Adji, Felisitas Brillianti, Ria Riska Topurmera, dan

Yustina Ayu. Terimakasih untuk persahabatan serta dukungan kalian.

13. Seluruh teman-teman kuliah Teknik Informatika 2010 (HMPS).

Terimakasih untuk kebersamaan kita selama menjalani masa

perkuliahan.

14. Pihak-pihak lain yang telah membantu penulis dalam menyelesaikan

tugas akhir ini, yang tidak dapat disebutkan satu per satu.

Penelitian tugas akhir ini masih memiliki banyak kekurangan. Untuk itu

penulis sangat membutuhkan kritik dan saran untuk perbaikan dimasa yang akan

datang. Semoga penelitian tugas akhir ini dapat membawa manfaat bagi semua

pihak.

Yogyakarta, 18 Januari 2016

Fidelis Asterina Surya P


DAFTAR ISI

HALAMAN JUDUL ........................................................................................... i

HALAMAN PERSETUJUAN ........................................................................... iii

HALAMAN PENGESAHAN ............................................................................ iv

HALAMAN MOTTO .......................................................................................... v

PERNYATAAN KEASLIAN KARYA .............................................................. vi

PERNYATAAN PERSETUJUAN PUBLIKASI ................................................ vii

ABSTRAK ..................................................................................................... viii

ABSTRACT ...................................................................................................... ix

KATA PENGANTAR .........................................................................................x

DAFTAR ISI ..................................................................................................... xii

DAFTAR GAMBAR ......................................................................................... xv

DAFTAR TABEL ............................................................................................ xvi

BAB I PENDAHULUAN .................................................................................... 1

1.1 Latar Belakang .............................................................................................. 1

1.2 Rumusan Masalah ......................................................................................... 2

1.3 Tujuan ........................................................................................................... 2

1.4 Batasan Masalah ........................................................................................... 3

1.5 Metodologi Penelitian ................................................................................... 3

1.6 Sistematika Penulisan .................................................................................... 4

BAB II LANDASAN TEORI .............................................................................. 5

2.1 Kriptografi ..................................................................................................... 5

2.2 Komponen Kriptografi ................................................................................... 6

2.3 Kunci Simetris dan Asimetris ......................................................................... 7

2.4 Algoritma One Time Pad ............................................................................... 8

2.4.1 Proses Enkripsi dan Dekripsi ................................................................ 8

2.5 Pembangkit Bilangan Acak ............................................................................ 9

2.6 Pembangkit Bilangan Acak Semu .................................................................. 9

2.7 Mersenne Twister ......................................................................................... 11

BAB III ANALISA DAN PERANCANGAN .................................................... 13


3.1 Enkripsi Pada One Time Pad ........................................................................ 13

3.1.1 Kebutuhan Input ................................................................................. 13

3.1.2 Kebutuhan Proses ............................................................................... 13

3.1.3 Kebutuhan Output .............................................................................. 13

3.2 Dekripsi Pada One Time Pad ........................................................................ 13

3.2.1 Kebutuhan Input ................................................................................. 13

3.2.2 Kebutuhan Proses ............................................................................... 13

3.2.3 Kebutuhan Output .............................................................................. 14

3.3 Diagram Alir Sistem .................................................................................... 14

3.3.1 Diagram Alir Enkripsi ........................................................................ 14

3.3.2 Diagram Alir Dekripsi ........................................................................ 15

3.4 Analisis Algoritma One Time Pad ................................................................ 16

3.4.1 Algoritma Enkripsi ............................................................................. 16

3.4.2 Algoritma Dekripsi ............................................................................. 18

3.4.3 Algoritma Mersenne Twister .............................................................. 20

3.5 Perancangan Antar Muka ............................................................................. 21

3.5.1 Tampilan Halaman Awal .................................................................... 21

3.5.2 Tampilan Halaman Enkripsi ............................................................... 21

3.5.3 Tampilan Halaman Dekripsi ............................................................... 22

3.6 Rancangan Input Dokumen .......................................................................... 23

3.6.1 Berformat .txt ..................................................................................... 23

3.6.2 Berformat .doc ................................................................................... 24

BAB IV HASIL DAN PEMBAHASAN ............................................................ 25

4.1 Implementasi Antar Muka ............................................................................ 25

4.1.1 Implementasi Halaman Awal .............................................................. 25

4.1.2 Implementasi Halaman Enkripsi ......................................................... 26

4.1.3 Implementasi Halaman Dekripsi ......................................................... 28

4.2 Hasil Pengujian ............................................................................................ 34

4.3 Pembahasan ................................................................................................. 38

4.3.1 Enkripsi .............................................................................................. 38

4.3.2 Dekripsi ............................................................................................. 40


4.4 Analisa ......................................................................................................... 42

4.5 Kelebihan Algoritma One Time Pad ............................................................. 44

4.6 Kekurangan Algoritma One Time Pad .......................................................... 44

BAB V KESIMPULAN DAN SARAN.............................................................. 45

5.1 Kesimpulan .................................................................................................. 45

5.2 Saran ............................................................................................................ 45

DAFTAR PUSTAKA ........................................................................................ 46

LAMPIRAN ...................................................................................................... 47


DAFTAR GAMBAR

Gambar 2.1 Enkripsi Dekeripsi Sederhana ........................................................... 5

Gambar 2.2 Enkripsi dan Dekripsi dengan Kunci Publik ...................................... 8

Gambar 2.3 Skema PNRG ................................................................................. 11

Gambar 3.1 Diagram Alir Enkripsi..................................................................... 15

Gambar 3.2 Diagram Alir Dekripsi .................................................................... 16

Gambar 3.3 Algoritma Enkripsi ......................................................................... 17

Gambar 3.4 Algoritma Dekripsi ......................................................................... 19

Gambar 3.5 Tampilan Halaman Awal ................................................................ 21

Gambar 3.6 Tampilan Halaman Enkripsi............................................................ 22

Gambar 3.7 Tampilan Halaman Dekripsi ........................................................... 23

Gambar 4.1 Tampilan Halaman Awal ................................................................ 25

Gambar 4.2 Kotak Dialog saat Memilih Dokumen ............................................. 26

Gambar 4.3 Tampilan Isi Dokumen dan Kunci Acak.......................................... 27

Gambar 4.4 Tampilan Hasil Enkripsi dan Lama Proses ...................................... 27

Gambar 4.5 Tampilan Save Dialog..................................................................... 28

Gambar 4.6 Pesan Ketika Proses Penyimpanan Hasil Enkripsi Berhasil Dilakukan

............................................................................................................. 28

Gambar 4.7 Kotak Dialog saat Memilih Dokumen ............................................. 29

Gambar 4.8 Tampilan Isi Ciphertext dan Kunci Acak yang Tersimpan .............. 30

Gambar 4.9 Tampilan Hasil Dekripsi dan Lama Proses ..................................... 30

Gambar 4.10 Tampilan Save Dialog ................................................................... 31

Gambar 4.11 Pesan Ketika Proses Penyimpanan Hasil Dekripsi Berhasil

Dilakukan ...................................................................................... 31


DAFTAR TABEL

Tabel 4.1 Kandidat Plaintext berformat .txt ........................................................ 33

Tabel 4.2 Kandidat Kunci untuk Plaintext berformat .txt .................................... 34

Tabel 4.3 Kandidat Plaintext berformat .doc ...................................................... 34

Tabel 4.4 Kandidat Kunci untuk Plaintext berformat .doc .................................. 35

Tabel 4.5 Ciphertext Proses Enkripsi berformat .txt ........................................... 36

Tabel 4.6 Ciphertext Proses Enkripsi berformat .doc .......................................... 36

Tabel 4.7 Proses Enkripsi ................................................................................... 37

Tabel 4.8 Proses Dekripsi................................................................................... 39

Tabel 4.9 Keberhasilan Enkripsi Dekripsi Berformat .txt.................................... 41

Tabel 4.10 Keberhasilan Enkripsi Dekripsi Berformat .doc ................................ 41

Tabel 4.11 Lama Proses Enkripsi ....................................................................... 42

Tabel 4.12 Lama Proses Dekripsi ....................................................................... 43


1

BAB I

PENDAHULUAN

1.1 Latar Belakang

Perkembangan teknologi informasi yang semakin pesat telah

mempengaruhi seluruh aspek kehidupan dan memberikan banyak sekali

keuntungan. Selain itu ada juga aspek – aspek dari sisi negatif dari

kemajuan sistem informasi tersebut. Pada dasarnya melakukan pengiriman

data tanpa melakukan pengamanan pada konten dari data yang dikirim,

dapat menyebabkan adanya penyadapan pada jalur pengirimannya.

Data penting yang berformat .txt seperti berkas teks biasa, skrip, kode

sumber program (source code program), berkas konfigurasi atau gambar

(ASCII art) mudah sekali untuk disadap ketika proses pengiriman

dikarenakan tidak adanya sistem untuk penyandian berkas tersebut. Untuk

data berformat .doc dapat disandikan menggunakan password karena

Miscrosoft Word memiliki fitur enkripsi. Namun fitur enkripsi Ms Word

tersebut memiliki kelemahan yaitu adanya aplikasi yang dapat digunakan

untuk membobol file yang telah terenkripsi.

Untuk itulah peranan teknologi keamanan informasi benar - benar

dibutuhkan. Salah satu cara yang bisa digunakan adalah menyandikan

(mengenkripsi) informasi atau data rahasia yang akan dikirim, sehingga

pihak yang tidak berkepentingan tidak dapat membaca informasi tersebut,

pihak tersebut sulit bahkan tidak dapat memahami isi informasi tersebut.

Salah satu teknik untuk pengamanan data adalah dengan

menggunakan algoritma penyandian data. Algoritma penyandian data saat

ini semakin banyak jumlahnya, sejalan dengan berkembangnya ilmu yang

mempelajari penyandian data tersebut. Ilmu ini biasa disebut Kriptografi.

Kriptografi akan mengonversi data asli (plaintext) ke dalam bentuk

data sandi (ciphertext) yang tidak dapat dikenali untuk menjaga kerahasiaan

data. Proses ini disebut enkripsi. Hasil enkripsi disebut ciphertext (teks


2

terenkripsi). Kemudian ciphertext akan didekripsi dengan kunci yang sama

menjadi plaintext kembali. Proses ini disebut dekripsi.

Metode kriptografi yang digunakan dalam tugas akhir ini yaitu

Algoritma One Time Pad. Algoritma One Time Pad merupakan algoritma

sederhana dan unbreakable yang sampai saat ini dinyatakan aman karena

masih belum ada serangan yang benar-benar dapat mematahkan algoritma

ini. Hal ini dikarenakan algoritma One Time Pad memiliki barisan kunci

acak yang ditambahkan ke pesan plaintext yang tidak acak untuk

menghasilkan chipertext yang seluruhnya acak. Beberapa barisan kunci

yang digunakan untuk mendeskripsi ciphertext mungkin menghasilkan

plaintext yang mempunyai makna. Kunci acak tersebut dibangkitkan

menggunakan metode pembangkit bilangan acak Mersenne Twister,

Mersenne Twister menghasilkan bilangan acak yang memiliki distribusi

yang sangat bagus, pembangkitan bilangan yang sangat cepat dan

menggunakan memori yang efisien.

1.2 Rumusan Masalah

Berdasarkan latar belakang di atas, maka yang menjadi rumusan

masalah adalah sebagai berikut :

1. Berapa presentase keberhasilan pengujian implementasi algoritma One

Time Pad dalam mengenkripsi dan mendekripsi berkas dokumen

(.txt,.doc)?

1.3 Tujuan

Tujuan penelitian ini adalah untuk mengetahui presentase

keberhasilan implementasi algoritma One Time Pad untuk mengenkripsi

dan mendekripsi berkas dokumen (.txt,.doc).


3

1.4 Batasan Masalah

Batasan masalah dalam penelitian ini adalah:

1. Program ini dibuat untuk pemakaian single user.

2. Program diimplementasikan untuk mengenkripsi dan mendekripsi

berkas dokumen .txt dan .doc.

3. Program hanya bisa disimpan dalam berkas dokumen .txtdan .doc.

4. Tidak membahas manajemen kunci.

1.5 Metodologi Penelitian

1.5.1 Studi Literatur

Mengenal prinsip enkripsi dan dekripsi sebagai pengetahuan dasar

untuk memecahkan masalah.

Mengenal dan memahami Algoritma One Time Pad dan proses

kerjanya.

Mengenal dan memahami metode Mersenne Twister dan proses

kerjanya.

1.5.2 Analisis Sistem

Membuat gambaran mengenai data dan proses serta kebutuhan

sistem yang diperlukan dalam mengimplementasikan program.

1.5.3 Perancangan Sistem

Perancangan meliputi : desain form – form yang digunakan beserta

tombol – tombol yang digunakan pada setiap form.

1.5.4 Pembuatan Program

Tahap ini adalah penerapan desain ke dalam bentuk program dengan

memanfaatkan bahasa pemrograman yang ada, yaitu Java.

1.5.5 Uji Coba Program

Menganalisis apakah program sesuai dengan algoritma yang

digunakan dan dapat berjalan dengan baik untuk mengekripsi dan

mendekripsi berkas dokumen (.txt,.doc)


4

1.6 Sistematika Penulisan

BAB I PENDAHULUAN

Berisi latar belakang masalah, rumusan masalah, tujuan

penulisan, batasan masalah, metodologi penulisan, dan

sistematika penulisan.

BAB III LANDASAN TEORI

Berisi tentang pengertian kriptografi, algoritma kriptografi,

algoritma One Time Pad dan pembangkit bilangan acak dengan

metode Mersenne Twister.

BAB III ANALISIS DAN PERANCANGAN

Berisi tentang perancangan sistem berupa diagram alir enkripsi

dan dekripsi menggunakan Algoritma One Time Pad. Bab ini juga

beriai tentang rancangan desain user interface, serta dukungan

hardware dan software terhadap program yang telah dibuat.

BAB IV ANALISIS DAN PERANCANGAN

Berisi tentang cara kerja untuk melakukan enkripsi dekripsi

dokumen menggunakan algoritma One Time Pad.

BAB V ANALISIS DAN PERANCANGAN

Berisi tentang kesimpulan atas analisa dan saran berdasarkan hasil

yang telah dilaksanakan.


5

BAB II

LANDASAN TEORI

2.1 Kriptografi

Kriptografi berasal dari bahasa Yunani yaitu Crypto dan Graphia

yang berarti penulisan rahasia (www.criptography.com). Kriptografi

(cryptography) berarti ilmu dan seni penyimpanan pesan, data, atau

informasi secara aman sehingga informasi tersebut tidak dapat diketahui

pihak yang tidak sah.

Kriptografi mentransformasikan data asli (plaintext) ke dalam bentuk

data sandi (ciphertext) yang tidak dapat dikenali untuk menjaga kerahasiaan

data. Ciphertext inilah yang kemudian dikirimkan oleh pengirim (sender)

kepada penerima (receiver). Setelah sampai di penerima, ciphertext tersebut

ditransformasikan kembali ke dalam bentuk plaintext agar dikenali. Proses

transformasi dari plaintext menjadi ciphertext disebut enkripsi (encryption),

sedangkan proses mentransformasikan kembali ciphertext menjadi plaintext

disebut proses dekripsi (decryption) (Iswanti, 2003).

Kriptografi menggunakan suatu algoritma (cipher) dan kunci (key)

untuk mengenkripsi dan mendekripsi data. Cipher adalah fungsi matematika

yang digunakan untuk mengenkripsi dan mendekripsi, sedangkan kunci

merupakan sederetan bit yang diperlukan untuk mengenkripsi dan

mendekripsi data. Secara sederhana dapat digambarkan sebagai berikut:

Plaintext Enkripsi Ciphertext Dekripsi Plaintext

Kunci

Gambar 2.1 Enkripsi Dekripsi Sederhana

Secara umum, enkripsi dan dekripsi dapat diterangkan sebagai berikut :

EK (M) = C (Proses Enkripsi)

DK (C) = M (Proses Dekripsi)


6

Pada proses enkripsi, pesan M akan disandikan dengan kunci K

sehingga menghasilkan pesan C. Untuk proses dekripsi, pesan C akan

diuraikan dengan menggunakan kunci K sehingga akan menghasilkan pesan

M yang sama seperti sebelumnya (Iswanti, 2003).

Pesan yang diamankan bergantung pada kunci yang digunakan, dan

bukan pada algoritma yang digunakan. Oleh karena itu, walaupun

algoritma- algoritma yang digunakan tersebut dapat dipublikasikan, namun

selama kunci yang dipakai tidak diketahui, maka pesan pesan tetap tidak

bisa dibaca (Kurniawan, 2004).

2.2 Komponen Kriptografi

Pada dasarnya, kriptografi terdiri dari beberapa komponen sebagai

berikut (Amelia, 2007) :

1. Algoritma, merupakan himpunan aturan matematis yang digunakan

dalam enkripsi dan dekripsi.

2. Enkripsi, adalah transformasi data ke dalam bentuk yang tidak dapat

terbaca tanpa sebuah kunci tertentu.

3. Dekripsi, merupakan kebalikan dari enkripsi, yaitu transformasi data

terenkripsi kembali ke bentuknya semula.

4. Kunci (Key), digunakan pada saat melakukan enkripsi dan dekripsi.

Pada kriptografi modern, keamanan enkripsi tergantung pada kunci,

dan tidak tergantung kepada algoritmanya apakah dilihat orang lain

atau tidak.

5. Pesan asli (Plaintext), disebut juga dengan clear-text, merupakan teks

asli yang akan diproses menggunakan algoritma kriptografi tertentu

untuk menjadi ciphertext.

6. Ciphertext, merupakan pesan yang telah melalui proses enkripsi yang

merupakan himpunan karakter acak.

7. Kriptologi, merupakan studi tentang kriptografi dan kriptanalisis.

8. Kriptanalisis (Cryptanalysist), merupakan aksi memecahkan

mekanisme kriptografi dengan cara menganalisisnya untuk


7

menemukan kelemahan dari suatu algoritma kriptografi sehingga

akhirnya dapat ditemukan kunci atau teks asli.

9. Kriptosistem, adalah perangkat keras atau implementasi perangkat

lunak kriptografi yang diperlukan dalam mentransformasi sebuah

pesan asli menjadi ciphertext dan juga sebaliknya.

2.3 Kunci Simetris dan Asimetris

Berdasarkan kunci yang dipakai, algoritma kriptografi dapat

dibedakan menjadi 2, yaitu:

a. Kunci Tunggal (Symmetric Algorithm)

Algoritma simetris (konvensial) adalah algoritma yang menggunakan

satu kunci yang sama untuk proses enkripsi dan dekripsi. Jika misalkan A

ingin mengirim pesan kepada B, maka pesan tersebut akan dienkrip dengan

menggunakan suatu kunci. Jika B menerima pesan tersebut, maka B harus

mendeskrip pesan dengan menggunakan kunci yang sama dengan kunci

yang digunakan oleh A. Keuntungan algoritma simetris yaitu memiliki

kecepatan proses enkripsi dan dekripsi, daripada menggunakan kunci

publik. Kelemahan kunci simeris yaitu kunci yang digunakan hanya satu,

sehingga jika kunci disergap ditengah jalan atau sudah ditebak orang lain,

maka sistem ini sudah tidak aman lagi (Raharjo, 2004).

b. Kunci Publik (Public Key Algorithms)

Algoritma kunci umum adalah algoritma yang menggunakan kunci

yang berbeda untuk proses enkripsi dan dekripsinya. Jika A ingin mengirim

pesan kepada B, maka A akan mengenkripsi pesan tersebut dengan

menggunakan kunci publik dari B. Jika B menerima pesan dari A, maka B

akan mendekrip pesan tersebut dengan menggunakan kunci pribadi dari B

sendiri. Keuntungan kunci publik yaitu memberikan jaminan keamanan

dalam melakukan pertukaran informasi karena kunci yang dipublikasikan

adalah kunci publik, sedangkan kunci rahasia tidak pernah disebarkan

secara umum. Kunci umum (public key) dapat diketahui oleh setiap orang

dibuat untuk enkripsi, sedangkan kunci pribadi (private key) hanya


8

diketahui oleh pihak yang sah (Raharjo, 2002). Contohnya RSA, Elgamal,

Diffie-Hellman.

Plaintext Enkripsi Ciphertext Dekripsi Plaintext

Kunci Publik Kunci Privat

Gambar 2.2 Enkripsi dan Dekripsi dengan Kunci Publik

2.4 Algoritma One Time Pad

One Time Pad adalah saah satu metode kriptografi dengan algoritma

jenis simetri. Metode ktiptografi ini ditemukan pada tahun 1917 oleh Major

Yoseph Mouborgne dan Gilbert Vernam pada perang dunia ke dua. Metode

ini telah diklaim sebagai satu - satunya algoritma kriptografi sempurna yang

tidak dapat dipecahkan. Suatu algoritma dikatakan aman, apabila tidak ada

cara untuk menemukan plaintext-nya. Sampai saat ini, hanya algoritma One

Time Pad (OTP) yang dinyatakan tidak dapat dipecahkan meskipun

diberikan sumber daya yang tidak terbatas (Febryan, 2014).

2.4.1 Proses Enkripsi dan Dekripsi

Prinsip enkripsi pada algoritma ini adalah dengan

mengkombinasikan masing-masing karakter pada plaintext dengan

satu karakter pada kunci. Oleh karena itu, panjang kunci harus sama

dengan panjang plaintext. Enkripsi dapat dinyatakan sebagai

penjumlahan modulo 256 (menggunakan kode ASCII 8 bit) dari satu

karakter plaintext dengan satu karakter kunci OTP (Bilqis. 2012):

ci = (pi + ki) mod 256 (2.1)

Dalam hal ini, pi adalah plaintext ke-I, ki adalah kunci ke-I, dan

ci adalah huruf ciphertext ke-i. Panjang kunci sama dengan panjang

plaintext, sehingga tidak ada kebutuhan mengulang penggunaan kunci

selama proses enkripsi. Setelah pengirim mengenkripsikan pesan

dengan kunci, ia menghancurkan kunci tersebut. Penerimaan pesan

menggunakan kunci yang sama untuk mendekripsikan karakter-


9

dkarakter ciphertext menjadi karakter-karakter plaintext dengan

persamaan:

pi = (ci – ki) mod 256 (2.2)

2.5 Pembangkit Bilangan Acak

Pembangkit Bilangan Acak atau Random Number Generator (RNG)

adalah suatu peralatan komputasional yang dirancang untuk menghasilkan

suatu urutan nilai tersebut dapat dianggap sebagai suatu keadaan acak

(random). RNG ini tidak dapat diterapkan dalam prakteknya. Bilangan acak

yang dihasilkan oleh komputer sekalipun tidak benar – benar acak dan

kebanyakan bilangan acak yang diterapkan dalam kriptograsi juga tidak

benar – benar acak, tetapi hanya berupa acak semu. Ini berarti bahwa

bilangan acak yang dihasilkan itu dapat ditebak susunan atau urutan

nilainya. Dalam kriptografi, bilangan acak sering dibangkitkan dengan

menggunakan pembangkit bilangan acak semu atau Pseudo Random

Number Generator (PRNG) (Bilqis,2012).

2.6 Pembangkit Bilangan Acak Semu

Pembangkit Bilangan Acak Semu atau Pseudo Random Number

Generator (PRNG) merupakan suatu algoritma yang menghasilkan suatu

urutan nilai dimana elemen – elemennya bergantung pada setiap nilai yang

dihasilkan. Output dari PRNG tidak betul – betul acak, tetapi hanya mirip

dengan properti dari nilai acak. Hal ini didukung oleh penelitian

sebelumnya. (Douglas, 1995) menyimpulkan dari beberapa algoritma untuk

membangkitkan bilanga acak semu, tidak ada yang benar – benar dapat

menghasilkan bilangan acak secara sempurna dalam arti benar – benar acak

dan tanpa ada perulangan selama pembangkit yang digunakan adalah

komputer yang memiliki sifat deterministik dan bilangan benar – benar acak

hanya dapat dihasilkan oleh perangkat keras (hardware).

Menurut ( Candra, 2010) beberapa syarat penting yang harus dipenuhi

oleh bilangan acak adalah seperti berikut :


10

1. Dapat diulang. Sekumpulan (barisan) bilangan yang sama harus bisa

diperoleh (diulang) dengan menggunakan seed yang sama, hal ini

kadang – kadang diperlukan untuk pemeriksaan dan penelusuran

program (debugging).

2. Keacakan. Barisan bilangan harus memenuhi syarat keacakan secara

seragam (uniform) yang dapat diuji melalui uji statistika.

3. Periode panjang. Karena pada dasarnya bilangan acak itu merupakan

barisan berulang dengan berbagai periode, maka periode pengulangan

harus sangat besar atau lama melebihi banyaknya bilangan acak yang

diperlukan.

Tidak peka seed. Sekalipun barisan bilangannya bergantung pada seed

tetapi sifat keacakan dan periodisasi sedapat mungkin tidak bergantung pada

seed-nya.

Secara umum, sebuah PRNG didefinisikan sebagai algoritma

kriptografi yang digunakan untuk menghasilkan bilangan secara acak.

Pengertian acak sendiri adalah bilangan yang dihasilkan dalam setiap waktu

tidaklah sama. Sebuah PRNG memiliki sebuah kondisi awal K yang rahasia.

Saat digunakan, PNRG harus membangkitkan output acak yang tidak dapat

diidentifikasi oleh kriptanalis yang tidak tahu dan tidak dapat menebak

kondisi awal K. Dalam hal ini, PRNG memiliki kesamaan dengan cipher

aliran. Akan tetapi, sebuah PRNG harus mampu mengubah kondisi awalnya

dengan memproses input sehingga tidak dapat diprediksi oleh kriptanalis.

Umumnya PRNG memiliki kondisi awal yang tidak sengaja dapat ditebak

oleh kriptanalis dan harus mengalami banyak proses sebelum kondisinya

aman dan rahasia. Patut dipahami bahwa sebuah input untuk PRNG

mrmiliki informasi rahasia yang tidak diketahui oleh kriptanalis. Input –

input ini umumnya diperoleh dari proses – proses fisik, interaksi user

dengan mesin, atau proses eksternal lain yang sulit diprediksi. Dalam desain

dan implementasi harus dapat dipastikan bahwa input – input ini memiliki

cukup jaminan keamanan dan kerahasiaan.


11

Kebanyakan algoritma dari PRNG ditujukan untuk mengahasilkan

suatu sampel yang secara seragam terdistribusi. PRNG ini sering digunakan

dalam kriptografo pada proses pembentukan kunci dari metode kriptografi.

Tingkat kerumitan dari PRNG menentukan tingkat keamanan dari metode

kriptografi. Semakin rumit PRNG yang digunakan maka semakin tinggi

tingkat keamanan dari metode kriptografi (Richard A, 2005).

PRNG

Bilangan acak semu

Input seed rahasia

Gambar 2.3 Skema Dasar PRNG

Semua deretan bilangan acak yang dibangkitkan dari rumus

matematika, serumit apapun, dianggap sebagai deret acak semu, karena

dapat diulang pembangkitnya. Sementara itu, banyak produk software yang

dinyataan sebagai produk yang aman karena menggunakan bilangan acak

semacam OTP (One Time Pad). Namun karena OTP ini dibangkitkan dari

bilangan acak semu, maka keamanan yang diperoleh juga semu.

2.7 Mersenne Twister

Mersenne Twister merupakan suatu pseudo random number generator

yang dikembangkan pada tahun 1997 oleh Makoto Matsumoto dan Takuji

Nishimura. Algoritma ini menawarkan generasi yang cepat dari bilangan

acak kualitas tinggi, telah dirancang secara khusus untuk mengatasi setiap

cacat yang ditemukan pada algoritma terdahulu.

Terdapat dua varian dari algoritma, yang paling baru dan lebih umum

dipakai adalah Mersenne Twister MT 1993. Algoritma ini mempunyai

properti sebagai berikut :


12

a. Dirancang untuk mempunyai suatu periode kolosal 129937 – 1.

Periode ini menjelaskan sesuai dengan namanya, suatu Mersenne

prime, dan beberapa jaminan atas algoritma bergantung pada

penggunaan internal dari Mersenne prime.

b. Mersenne Twister mempunyai suatu equidistribution dimensional

high order. Ini berarti secara default, terdapat korelasi serial yang

dapat diabaikan anatara nilai suksesif dalam deret output.

c. Algoritma lebih cepat daripda algoritma yang ada tetapi

menggunakan generator yang lebih statistikal.

d. Algoritma ini bersifat statistikal secara acak dalam semua bit

outputnya.

Algoritma ini sendiri merupakan suatu twisted generalised shift

feedback register atau TGSFR. Kata “twist” merupakan suatu

transformasi di mana menjamin equididtribution dari nilai yang

digenerasi dalam 623 dimensi (Devi, 2008).


13

BAB III

ANALISA DAN PERANCANGAN

3.1 Enkripsi pada One Time Pad

3.1.1. Kebutuhan Input :

1. Beberapa kalimat atau teks panjang sebagai plaintext.

2. Menggunakan beberapa huruf atau simbol acak sebagai key.

3.1.2 Kebutuhan Proses :

1. Proses enkripsi sebuah plaintext dengan key menggunakan tabel

ASCII yang sudah ada.

2. Kemudian sesuaikan setiap huruf pada plaintext dengan huruf atau

simbol yang menjadi key, yaitu dengan mengubah menjadi

bilangan desimal yang kemudian dijumlahkan lalu dimodulo 256.

3.1.3 Kebutuhan Output :

Hasil penjumlahan yang telah dimodulo 256 kemudian diubah

kembali menjadi huruf atau simbol. Hasil tersebut merupakan

output dari enkripsi One Time Pad yang menjadi ciphertext.

3.2 Dekripsi pada One Time Pad

3.2.1 Kebutuhan Input :

1. Beberapa kalimat atau teks panjang sebagai ciphertext

2. Menggunakan beberapa huruf atau simbol acak yang sama dengan

yang digunakan untuk enkripsi.

3.2.2 Kebutuhan Proses :

1. Proses dekripsi sebuah ciphertext dengan key yang sama

menggunakan tabel ASCII yang sudah ada.

2. Kemudian sesuaikan setiap huruf pada ciphertext dengan huruf

atau simbol yang menjadi key yang sama, yaitu dengan mengubah

menjadi bilangan desimal yang kemudian dikurangi lalu dimodulo

256.


14

3.2.3 Kebutuhan Output :

Hasil pengurangan yang telah dimodulo 256 kemudian

diubah kembali menjadi huruf atau simbol. Hasil tersebut

merupakan output dari dekripsi One Time Pad yang menjadi

plaintext kembali

3.3 Diagram Alir Sistem

3.3.1 Diagram Alir Sistem Enkripsi

Gambar 3.1 adalah diagram alir dari sistem enkripsi yang dimulai

dengan mencari plaintext berkas asli kemudian memasukkan kunci

random setelah itu dilakukan proses enkripsi yang menghasilkan

ciphertext lalu disimpan.


15

Cari plaintext

Mulai

Masukkan kunci

random

Enkripsi

Ciphertext

Simpan

Selesai

Gambar 3.1 Diagram Alir Enkripsi

3.3.2 Diagram Alir Sistem Dekripsi

Gambar 3.2 adalah diagram alir dari sistem dekripsi yang dimulai

dengan mencari chipertext kemudian memasukkan kunci random

setelah itu dilakukan proses dekripsi yang menghasilkan plaintext lalu

disimpan.


16

Cari ciphertext

Mulai

Masukkan kunci

random

Dekripsi

Plaintext

Simpan

Selesai

Gambar 3.2 Diagram Alir Dekripsi

3.4 Analisis Algoritma One Time Pad

3.4.1 Algoritma Enkripsi

Pada gambar 3.3 adalah diagram alir dari enkripsi yang dimulai

dengan inisialisasi im atau integer message, inisialisasi ik atau integer

key serta inisialisasi data dimana data merupakan integer dari

message.length. Selanjutnya menentukan i=0 yang kemudian lalu


17

diproses dengan data[i] = (im[i] + ik[i])%256 jika i < message.length

maka akan dilakukan looping dan jika tidak maka return.

Start

Insialisasi im

Insialisasi ik

i = 0

data[i] = (im[i] + ik[i])%256

i < message.length

End

Ya

Tidak

Return

Insialisasi data

Gambar 3.3 Algoritma Enkripsi


18

3.4.2 Algoritma Dekripsi

Pada gambar 3.4 adalah diagram alir dari dekripsi yang dimulai

dengan inisialisasi im atau integer message, inisialisasi ik atau integer

key serta inisialisasi data dimana data merupakan integer dari

message.length.. Selanjutnya menentukan i=0 yang kemudian lalu

diproses dengan data[i] = (im[i] - ik[i])%256 jika i < message.length

maka akan dilakukan looping dan jika tidak maka return.


19

Start

Insialisasi im

Insialisasi ik

i = 0

data[i] = (im[i] - ik[i])%256

i < message.length

Return

End

Ya

Tidak

Inisialisasi data

Gambar 3.4 Algoritma Dekripsi


20

3.4.3 Algoritma Mersenne Twister ( Archana Jagannatam)

Berikut adalah agoritma untuk kelas Mersenne Twister :

1. Step 0

Tentukan bitmask untuk upper dan lower bits

U ← ,

2. Step 1

Tentukan array x dengan nilai bukan 0

x[0], x[1], ............, x[n-1]

3. Step 2

Hitung ( ), dimana the upper bits digabungkan dengan the

lower bits x[i+1]

y ← (x[i] AND u) OR (x[(i +1)mod n] AND ll)

4. Step 3

Hitung langkah selanjutnya

5. Step 4

Kali x[i] dengan mengganti matrik T untuk persamaan distribusi

yang lebih baik

y ← x[i]

y ← y ⊕ ( y >> u)

y ← y ⊕ (( y << s) & b)

y ← y ⊕ (( y << t) & c)

z ← y ⊕ ( y >> l)

output y

6. Step 5

Tambahkan i dengan 1

i ← (i +1)mod n

7. Step 6

Ulangi proses langsung ke step 2


21

3.5 Perancangan Antarmuka

3.5.1 Tampilan Halaman Awal

Halaman awal pada Gambar 3.1 adalah tampilan pertama saat

sistem dijalankan. Pada halaman ini terdapat button Enkripsi dan Dekripsi.

Jika user menekan button Enkripsi, maka sistem akan menampilkan

halaman selanjutnya, yaitu Halaman Enkripsi. Dan jika user menekan

button Dekripsi, maka sistem akan menampilkan halaman selanjutnya,

yaitu Halaman Dekripsi.

Gambar 3.5 Tampilan Halaman Awal

3.5.2 Tampilan Halaman Enkripsi

Halaman Enkripsi pada Gambar 3.2 adalah tampilan untuk proses

enkripsi. Pada halaman ini terdapat button “Browse” yang digunakan untuk

mencari dokumen untuk dienkripsi. Button “Genarate Key” digunakan

untuk menampilkan kunci acak, lalu button “Proses” yang digunakan untuk

menampilkan hasil enkripsi serta lamanya proses enkripsi. Button

“Simpan” yang digunakan untuk menyimpan hasil enkripsi. Button

“Kembali” yang digunakan untuk kembali ke halaman awal.


22

Gambar 3.6 Tampilan Halaman Enkripsi

3.5.3 Tampilan Halaman Dekripsi

Halaman Dekripsi pada Gambar 3.3 adalah tampilan untuk proses

dekripsi. Pada halaman ini terdapat button “Browse” yang digunakan untuk

mencari dokumen untuk didekripsi. Button “Genarate Key” digunakan

untuk menampilkan kunci acak, lalu button “Proses” yang digunakan untuk

menampilkan hasil dekripsi serta lamanya proses dekripsi. Button

“Simpan” yang digunakan untuk menyimpan hasil dekripsi. Button

“Kembali” yang digunakan untuk kembali ke halaman awal.


23

Gambar 3.7 Tampilan Halaman Dekripsi

3.6 Perancangan Input Dokumen

3.6.1 Berformat .txt

Berikut kandidat plaintext untuk dokumen yang berformat .txt dan

.doc dimana nanti akan menggunakan kunci acak yang berbeda :

1. Engkau selalu hadir dalam setiap langkah ku

2. I want him to be the only man that I’ll love for the rest of my life

3. Fidelis Asterina

4. File_output_stream = new FileOutputstream(f)

5. key[i] = (char) (key[i] - 72);

6. private static final int MATRIX_A = 0x9908b0df;


24

7. Tujuan penelitian ini adalah untuk mengimplementasikan algoritma

One Time Pad untuk mengenkripsi dan mendekripsi berkas

dokumen (.txt,.doc) dan Mersenne Twister sebagai pembangkit

kunci.

8. MersenneTwisterFast other = (MersenneTwisterFast) o;

9. for (int x = 0; x < mt.length; x++) {

10. Batasan masalah dalam penelitian ini adalah:

3.6.2 Berformat .doc

Berikut kandidat plaintext untuk dokumen yang berformat .doc :

1. Give him the best of me till the day that i die

2. JOptionPane.showMessageDialog(this, "Penyimpanan Hasil

Dekripsi Telah Berhasil Disimpan!! di " + filename);

3. Allah Bapa sungguh besar kasih Mu,, Engkau selalu hadir dalam

setiap langkah ku,,

4. Universitas Sanata Dharma

5. for (;k!=0; k--){

6. Algoritma penyandian

7. Algortima

8. FileWriter outFile = new FileWriter(f);

PrintWriter out = new PrintWriter(outFile, true);

9. THIS PLAINTEXT

10. TEKNIK INFORMATIKA FAKULTAS SAINS DAN

TEKNOLOGI


25

BAB IV

HASIL DAN PEMBAHASAN

4.1 Implementasi Antarmuka

Implementasi program ini dilakukan dengan menggunakan NetBeans IDE

6.9.1 pada komputer dengan spesifikasi processor Intel Core i3 2,27 GHz,RAM

4.00 GB, dan hardisk 320 GB. Program ini dibuat sesuai dengan perancangan

yang dibuat pada bab sebelumnya. Dan program ini dibuat dengan menggunakan

bahasa pemrograman Java.

4.1.1. Implementasi Halaman Awal

Halaman awal adalah tampilan yang pertama kali keluar pada saat

program dijalankan. Pada halaman ini terdapat tombol “Enkripsi” dan

“Dekripsi”. Jika user ingin menggunakan program untuk mengenkripsi

dokumen, maka user harus menekan tombol “Enkripsi”. Dan jika user

ingin menggunakan program untuk mendekripsi dokumen, maka user

harus menekan tombol “Dekripsi”.

Gambar 4.1 Tampilan Halaman Awal


26

4.1.2 Implementasi Halaman Enkripsi

Halaman enkripsi akan muncul setelah user menekan tombol

“Enkripsi”. Pada halaman enkripsi ini terdapat tombol “Browse”, tombol

“Generate Key”, tombol “Proses”, tombol “Simpan”,tpmbol “Kembali”, text

area “plainArea”, text area “enkripKey”, text area “hasilEnkrip”, dan text

area “LamaEnkrip”.

Jika user ingin mengenkripsi dokumen maka user menekan tombol

“Browse” untuk mencari dokumen yang akan dienkripsi seperti di bawah

ini.

Gambar 4.2 Kotak Dialog saat memilih Dokumen

Setelah memilih file kemudian pengguna menekan tombol “Open”.

Setelah menekan tombol “Open” maka dokumen tersebut akan ditampilkan,

kemudian user menekan tombol “Generate Key” maka kunci acak akan

ditampilkan seperti di bawah ini.


27

Gambar 4.3 Tampilan Isi Dokumen dan Kunci Acak

Kemudian user melakukan proses enkripsi dengan menekan tombol

“Proses” maka hasil dari proses akan muncul serta lamanya proses tersebut

dilakukan.

Gambar 4.4 Tampilan Hasil Enkripsi dan Lama Proses


28

Selanjutnya user dapat menyimpan hasil enkripsi dengan menekan

tombol “Simpan”. Hasil enkripsi dapat disimpan dengan format .txt dan

.doc.

Gambar 4.5 Tampilan Save Dialog

Setelah selesai menyimpan, jika dokumen berhasil disimpan akan

muncul pesan "Penyimpanan Hasil Enkripsi dan Key Telah Berhasil

Disimpan!! di .........". Titik-titik tersebut berisi direktori tempat dokumen

disimpan.

Gambar 4.6 Pesan Ketika Proses Penyimpanan Hasil Enkripsi

Berhasil Dilakukan

4.1.3 Implementasi Halaman Dekripsi

Halaman dekripsi akan muncul setelah user menekan tombol

“Dekripsi”. Pada halaman dekripsi ini terdapat tombol “Browse”, tombol

“Browse”, tombol “Proses”, tombol “Simpan”,tombol “Kembali”, text area


29

“cipherArea”, text area “dekripKey”, text area “hasilDekripsi”, dan text area

“LamaDekripsi”. Jika user ingin mendekripsi dokumen maka user menekan

tombol “Browse” untuk mencari dokumen yang akan didekripsi seperti di

bawah ini.

Gambar 4.7 Kotak Dialog saat memilih Dokumen

Setelah memilih file kemudian pengguna menekan tombol “Open”.

Setelah menekan tombol “Open” maka dokumen tersebut akan ditampilkan,

kemudian user menekan tombol “Browse” untuk mencari kunci yang

disimpan setelah itu menekan tombol “Open”, maka tampilan akan seperti

di bawah ini.


30

Gambar 4.8 Tampilan Isi Ciphertext dan Kunci Acak yang Tersimpan

Kemudian user melakukan proses dekripsi dengan menekan tombol

“Proses” maka hasil dari proses akan muncul serta lamanya proses tersebut

dilakukan.

Gambar 4.9 Tampilan Hasil Dekripsi dan Lama Proses


31

Selanjutnya user dapat menyimpan hasil dekripsi dengan menekan

tombol “Simpan”. Hasil enkripsi dapat disimpan dengan format .txt dan

.doc.

Gambar 4.10 Tampilan Save Dialog

Setelah selesai menyimpan, jika dokumen berhasil disimpan akan

muncul pesan "Penyimpanan Hasil Dekripsi Telah Berhasil Disimpan!! di

.........." Titik-titik tersebut berisi direktori tempat dokumen disimpan.

Gambar 4.11 Pesan Ketika Proses Penyimpanan Hasil Dekripsi

Berhasil Dilakukan


32

Berikut listing program beberapa proses yang terdapat pada tombol - tombol

di Form Tampilan :

1. Tombol Generate Key

Berikut baris – baris perintah untuk menampilkan kunci secara acak,

dimana kelas Mersenne Twister sudah ada :

2. Proses Enkripsi

Berikut baris – baris perintah untuk proses enkripsi :

3. Proses Enkripsi

Berikut baris – baris perintah untuk proses dekripsi :

public static String genKey(int length) { MersenneTwisterFast rand = new MersenneTwisterFast();

char[] key = new char[length]; for (int i = 0; i < length; i++) { key[i] = (char) rand.nextInt(132);

if ((int) key[i] < 97) { key[i] = (char) (key[i] + 72);

} if ((int) key[i] > 122) { key[i] = (char) (key[i] - 72);

} }

return new String(key); }

public static String encrypt(String message, String key) { if (message.length() != key.length()) {

error("Lengths must be equal"); }

int[] im = charArrayToInt(message.toCharArray()); int[] ik = charArrayToInt(key.toCharArray()); int[] data = new int[message.length()];

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

data[i] = (im[i] + ik[i])%256; }

return new String(intArrayToChar(data)); }


33

4.2 Hasil Pengujian

Berikut ini adalah kandidat plaintext berformat .txt yang akan dienkripsi :

Tabel 4.1 Kandidat Plaintext berformat .txt

No Plaintext

1 Engkau selalu hadir dalam setiap langkah ku

2 I want him to be the only man that I’ll love for the rest of my life

3 Fidelis Asterina

4 File_output_stream = new FileOutputstream(f)

5 key[i] = (char) (key[i] - 72);

6 private static final int MATRIX_A = 0x9908b0df;

7 Tujuan penelitian ini adalah untuk mengimplementasikan algoritma One

Time Pad untuk mengenkripsi dan mendekripsi berkas dokumen (.txt,.doc) dan Mersenne Twister sebagai pembangkit kunci.

8 MersenneTwisterFast other = (MersenneTwisterFast) o;

9 for (int x = 0; x < mt.length; x++) {

10 Batasan masalah dalam penelitian ini adalah:

public static String decrypt(String message, String key) { if (message.length() != key.length()) {

error("Lengths must be equal"); }

int[] im = charArrayToInt(message.toCharArray()); int[] ik = charArrayToInt(key.toCharArray()); int[] data = new int[message.length()];

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

data[i] = (im[i] - ik[i])%256; }



34

Berikut ini adalah kandidat kunci untuk plaintetx berformat .txt yang mana

panjang kunci sama dengan panjang plaintext :

Tabel 4.2 Kandidat Kunci untuk Plaintext berformat .txt

No Kunci

1 ofnPZo[\MG6qV[P<f;h_FbieiOy>SyMHeKgUfEi@\6l

2 TybGYUiKD<JcmjV[slqcJo]rRòZ;78oQo:Ooc8oabrer8T`_buhQ599QM

D<Y\ie8z=L

3 ]_IU8Ug6VnX7d7W

4 5i85KP=z;SprP]ETktbFm8<SMqhecZOOIW_9<ccOTfr5

5 P[dig7`<[aZQQWAUM]`^Xr3;kW4v34

6 9>X4LH\yyrKG[XZW]Qf[NgX3hvc6eZ^kwzex\rvrYcRM93

7 rW[YVsX:6]uY5s[VtxaxmcSWuOtj`[bvNsmAJjlPGHVsCa@Ze]KiUj^q

FP8JYaKEhEMbiP\=P8zmN7kXiM3aP@whS[HsWWr:sHxN6Fm[6tJQI

3m3Y78VeL`pbfpD6Pj:n_xsmMAu_r_z_y^9CzSzmGkts^zJZì5VT_PiD

YdE[UsxfmwGO8oHOF;W@5

8 RdQYwh\e[z9?xxtm`X_XZ:wsriiZ6xjkxi4ty>;sTpn_;_R\dzkg

9 emTls^Zv4M@gvuy_XSrgÔq[TE7sdN:xbvK:R

10 bKHR7vqqXy]e4`4p89c4IzmwfVORSxr5jbW;KZ;8goNQ

Berikut ini adalah kandidat plaintext berformat .doc yang akan dienkripsi :

Tabel 4.3 Kandidat Plaintext berformat .doc

No Plaintext

1 Give him the best of me till the day that i die

2 JOptionPane.showMessageDialog(this, "Penyimpanan Hasil Dekripsi Telah Berhasil Disimpan!! di " + filename);

3 Allah Bapa sungguh besar kasih Mu,, Engkau selalu hadir dalam setiap

langkah ku,,

4 Universitas Sanata Dharma


35

5 for (;k!=0; k--){

6 Algoritma penyandian

7 Algoritma

8 FileWriter outFile = new FileWriter(f);

PrintWriter out = new PrintWriter(outFile, true);

9 THIS PLAINTEXT

10 TEKNIK INFORMATIKA FAKULTAS SAINS DAN TEKNOLOGI

Berikut ini adalah kandidat kunci untuk plaintetx berformat .doc yang

mana panjang kunci sama dengan panjang plaintext :

Tabel 4.4 Kandidat Kunci untuk Plaintext berformat .doc

No Kunci

1 wrV5l5AvrRIybaR;iR]vFnOBlYC;_sdgy\t7QC:3ivhKurYkx7dzP

2 6zSZe><kSUwRpDA6Fqdxp`k\e5gpyZUN;t_fZ54tZ\TTU3[:IPGOx[UL

w8BbS``TxV:K_Vy_b4d`SJqIqt`NdMLs3fKyYgUJW?kY`POHrYv:=Bd

3 ZyHIoUlQc4rVIIE3Z`ruP7Huo\LgURJ_KH]gV6i6mPN\7`[OhJgLbW7A

vWCV<y^^\:HCd_@VJO9WZIlM^X\3Y

4 NlF>WeBv6P]b4O6dMH3Y\x_TYWgU@

5 5TQEk]hNLM^5kGrAv]Ui oOa@

6 V8?oqOBVdZLasvsuCOqv`bvWIHp

7 9_m\7W8abn9Fk4Ev

8 zn>sze6>nZW\f?mPwTvkbKxh?]an9dBy4B[WZnriLs^WFKLoPR:KHIT

T^;8M:QRK8Zf4TkmqvLUNbCuvXnZwtvzjvy_vVT

9 :XPi9s4b:VuVbv`:rQ

10 sAWYiS^@t>fmTq?@3@T9d=arbr;X@wxXDVU4LJsI_8o9^fu4QZl


36

Berikut ini adalah hasil dari proses enkripsi dari plaintext berformat .txt :

Tabel 4.5 Ciphertext Proses Enkripsi berformat .txt

No Ciphertext

1 ´ÔÕ»»ä{Ï²³ÝË{¸Ê¤ÚªÃÕÆÖoì£Çâ® ·ÈÃÍ°Ê¨|¡á

2 Ù¨ÇÉ³©j×Ü¸ÀàÙÈjÞËÞËÜ»©W¬×²ãZÏ¤ÍÑèÊÃÒÖÝÍq§¬Åm³¢yÉâ¤ã£±

3 £Èº¤¾ÚVáÌÖ ÅÓ

4 Ò¤ª¿²î«ÈäÑÃÑ·¹Ìá¦¡Êm·ÑÑÈ©ÄÃ¹ÌÓ°ÕÈ°ÁØ^

5 »ÀÝÄÐy{½¹²ÉjuuÈÅ×³Û[wk¨\o

6 ©°Áª¼Áìæ¬»Ä»z½Æ¿ÇÇnÐÆ§Ã¤·£¶Ê ¢ê¯«´}

7 ÆÌÅÎ·áxªËÚÅçÄ·âÊæÖ´»Ö»ÕÒÐÐêÃÞ®¯ØÓ¹´¸ÂØ°Æ®ÎÆÐ´Ô¶Ø~Ò²·§

¼ÂÕ ¦»Ç¤ÅªµXÊÎ²WàÆÝÂ½¥åÏ¸É³åÀÇå£¬Ù¼V³ÒÉÙµÃ²£àyÈÐÓÆÕÛ

¹£µØZìëáyoÙÎÕÃÚÌYßÅíÒµÙÙ²ñ³ÍÔÎ§vÇÄ²Ê«ºÍeËºàÚÇÛÞ²¸¬³Ä´ÀnU

8 ÉÃÌÜÖÊÊ¯ñ¢²ìÝæ³ÁËÓxÉ®ßØä¦z ÅÏÝëÎ¢âÞ²ÜÇäÓÑÀÅÐÚ¢

9 ËÜÆÇÈêTÅ`¤¥´Ðs®ËÃÇ¹³çÌZð¡tZÍ

10 ¤¬¼³ª×ßÅÚÐÆ ÁÏ¶ÝÜÔ»»»ÇáÓ£ËÅ¤k»ÓÐ¶

Berikut ini adalah hasil dari proses enkripsi dari plaintext berformat .doc :

Tabel 4.6 Ciphertext Proses Enkripsi berformat .doc

No Ciphertext

1 ¾ÛÌªãÆ±ÞÃ·®ÝrÌÜfÛ´bàÂ¯§çÌÌÀÕ°q·¢ÝÑkÙÛ¾xDnZ

2 ÉÃÎÎª»´ÃÜã¬°Ö×ëÑÇÐ ÎÓßàÉ¶¤ç|âÓÅÁÄ¶¡¼¨i ÂáÇuÜ£´ËÃÓÉtÌ»¦¬

Çv»ÄÔÅÓ¼¶ÚçÉ»Ô®ºT¯âyuuw¥ÔÅÅ¾°µ×±GGOn

3 å´ª×u®²ÓÉ¾·¬ÏÈ×µª©çÇÚ¾ºj¬Àt¤Ð¡ÎÅnÏÌ¼»ÝjÏÆÀ©aÚ¸¯·©ÑÃÐ£

©³Ë¡Ä±º¿z áyef@c

4 £Ú¯´¼×µßª±Ð°¤ÅÁ©SÄÙÑÁºdqbJ

5 ÃÃe¹lnU¬£~Ù|YnJ

6 ¤¦Þã ¶ÃÅz¼ÆáïÔã§¸ÒäodSUz

7 zËÔË©À¬ÎÃFPx>R

8 À×ªØÑ×²ÓÌwËÛ³³¹ã¹¨¹Ýß_£ÊÚ»´â¨§ÍÀvVÃÐÀ´¿£á¹Æ½h¸ÉÈ~xX»ÈrªÃ

Ô¨«ÝÖåÛ¾}½×·»ßÄÓèèïÏ´lc^


37

9 ¼YÃ£¤ÉºÊmD[

10 Ç¢§²~Âµ¿¡²~t¥¶¾¶³x¸Á¦vujÇª¾¾A[gv

4.3 Pembahasan

4.3.1 Enkripsi

Pada proses enkripsi ini, plaintext yang berupa huruf atau simbol

akan diubah menjadi bilangan desimal yang kemudian dijumlahkan

dengan kunci acak yang juga diubah menjadi bilangan desimal setelah itu

dimodulo 256. Kemudian hasil penjumlahan tersebut diubah ke huruf atau

simbol. Pengubahan dari huruf atau simbol menjadi bilangan desimal atau

sebaliknya ini menggunakan tabel ASCII (lampiran).

Contoh :

Plaintext :

Universitas Sanata Dharma

Kunci :

8@NajlJRkMa3^b`7[xi8_VqoU

Berikut proses plaintext dan kunci diubah menjadi bilangan

desimal berdasarkan tabel ASCII. Untuk mengubah huruf U pada plaintext

dapat dilihat di tabel ASCII dimana bilangan desimal untuk huruf U

adalah 85. Kemudian untuk huruf n bilangan desimalnya adalah 110.

Proses untuk semua plaintext dilakukan seperti itu berdasarkan tabel

ASCII. Untuk proses kunci yang diubah menjadi bilangan desimal

dilakukan sama seperti untuk proses plaintext sehingga didapatkan hasil

berupa bilangan desimal yang kemudian dijumlahkan lalu dimodulo 256

seperti tabel di bawah ini :

Tabel 4.7 Proses Enkripsi

Penjumlahan

(pi + ki) mod 256

Hasil

Penjumlahan

Huruf /

Simbol

(85 + 56) mod 256 141 (no symbol)


38

(110 + 64) mod 256 174 ®

(105 + 78) mod 256 183 ·

(118 + 97) mod 256 215 ×

(101 + 106) mod 256 207 Ï

(114 + 108) mod 256 222 Þ

(115 + 74) mod 256 189 ½

(105 + 82) mod 256 187 »

(116 + 107) mod 256 223 ß

(97 + 77) mod 256 174 ®

(115 + 97) mod 256 212 Ô

(32 + 51) mod 256 83 S

(83 + 94) mod 256 177 ±

(97 + 98) mod 256 195 Ã

(110 + 145) mod 256 255 Î

(97 + 55) mod 256 152 ˜

(116 + 91) mod 256 207 Ï

(97 + 55) mod 256 312 Ù

(32 + 105) mod 256 137 ‰

(68 + 56) mod 256 124 |

(104 + 45) mod 256 149 •

(97 + 86) mod 256 183 ·

(114 + 113) mod 256 227 ã

(109 + 111) mod 256 220 Ü

(97 + 85) mod 256 182 ¶

Setelah proses enkripsi selesai, maka didapatlah ciphertext sebagai

berikut :

Ciphertext :

•®·×ÏÞ½»ß®ÔS±ÃÎ˜ÏÙ‰|Ç·ãÜ¶


39

4.3.2 Dekripsi

Pada proses dekripsi ini, ciphertext yang berupa huruf atau simbol

akan diubah menjadi bilangan desimal yang kemudian dikurangkan

dengan kunci acak yang juga diubah menjadi bilangan desimal setelah itu

dimodulo 256. Kemudian hasil pengurangan tersebut diubah ke huruf atau

simbol. Pengubahan dari huruf atau simbol menjadi bilangan desimal atau

sebaliknya ini menggunakan tabel ASCII (lampiran).

Dari proses enkripsi di atas akan didapatkan hasil enkripsi sebagai

berikut :

Contoh :

Ciphertext :

®·×ÏÞ½»ß®ÔS±ÃÎ˜ÏÙ‰ |Ç·ãÜ¶

Kunci :

8@NajlJRkMa3^b`7[xi8_VqoU

Berikut proses ciphertext dan kunci diubah menjadi bilangan

desimal berdasarkan tabel ASCII. Untuk mengubah karakter (no symbol)

pada ciphertext dapat dilihat di tabel ASCII dimana bilangan desimal

untuk huruf (no symbol) adalah 141. Kemudian untuk huruf ® bilangan

desimalnya adalah 174. Proses untuk semua ciphertext dilakukan seperti

itu berdasarkan tabel ASCII. Untuk proses kunci yang diubah menjadi

bilangan desimal dilakukan sama seperti untuk proses ciphertext

didapatkan hasil berupa bilangan desimal yang kemudian dikurangi lalu

dimodulo 256 seperti tabel di bawah ini :

Tabel 4.8 Proses Dekripsi

Pengurangan

(ci - ki) mod 256

Hasil

Pengurangan

Huruf /

Simbol

(141 - 56) mod 256 85 U

(174 - 64) mod 256 110 n

(183 - 78) mod 256 105 i

(215 - 97) mod 256 118 v


40

(207 - 106) mod 256 101 e

(222 - 108) mod 256 114 r

(189 - 74) mod 256 115 s

(187 - 82) mod 256 105 i

(223 - 107) mod 256 116 t

(174 - 77) mod 256 97 a

(212 - 97) mod 256 115 s

(83- 51) mod 256 32 (spasi)

(177 - 94) mod 256 83 S

(195 - 98) mod 256 97 a

(255 - 145) mod 256 110 n

(152 - 55) mod 256 97 a

(207 - 91) mod 256 116 t

(312 - 55) mod 256 97 a

(137 - 105) mod 256 32 (spasi)

(124 - 56) mod 256 68 D

(149 - 45) mod 256 104 h

(183 - 86) mod 256 97 a

(227 - 113) mod 256 114 r

(220 - 111) mod 256 109 m

(182 - 85) mod 256 97 a

Setelah proses dekripsi selesai, maka didapatlah plaintext yang

berisi sama dengan plaintext awal sebelum proses enkripsi sebagai berikut :

Plaintext :

Universitas Sanata Dharma


41

4.4 Analisa

Berdasarkan pada hasil pengujian yang dapat dilihat pada halaman

lampiran dihasilkan hasil benar dan salah. Hasil dikatakan benar jika ciphertext

yang didekripsi menghasilkan plaintext yang sama dengan berkas asli. Dan hasil

dikatakan salah jika ciphertext yang didekripsi tidak menghasilkan plaintext yang

sama dengan berkas asli atau tidak dapat dilakukan proses dekripsi. Di bawah ini

adalah tabel keberhasilan enkripsi dekripsi dokumen:

Tabel 4.9 Keberhasilan Enkripsi Dekripsi Format .txt

No Pengujian Hasil Keterangan

1 01.txt Benar -

2 02.txt Benar -

3 03.txt Benar -

4 04.txt Benar -

5 05.txt Benar -

6 06.txt Benar -

7 07.txt Benar -

8 08.txt Benar -

9 09.txt Benar -

10 10.txt Benar -

Tabel 4.10 Keberhasilan Enkripsi Dekripsi Format .doc

No Pengujian Hasil Keterangan

1 01.doc Benar -

2 02.doc Benar -

3 03.doc Benar -

4 04.doc Benar -

5 05.doc Benar -

6 06.doc Benar -

7 07.doc Benar -

8 08.doc Benar -


42

9 09.doc Benar -

10 10.doc Benar -

Dilihat dari tabel 4.9 dapat diketahui bahwa presentasi keberhasilan

enkripsi dekripsi dokumen untuk format .txt adalah 100% meski ada beberapa

simbol yang tidak terbaca. Dari tabel 4.10 dapat diketahui bahwa presentasi

keberhasilan enkripsi dekripsi dokumen untuk format .doc adalah 100% karena

adanya chipertext dan key yang memiliki panjang yang tidak sama sehingga tidak

dapat dilakukan proses dekripsi.

Sehingga dapat dianalisis bahwa program enkripsi dekripsi dokumen

dengan algoritma One Time Pad ternyata telah berjalan sesuai dengan algoritma

yang ada dan dapat berfungsi dengan baik meski ada beberapa pengujian dimana

beberapa huruf / simbol tidak terbaca diprogram saat akan dilakukan proses

dekripsi, tetapi hal itu tidak mengganggu proses dekripsi dan isi dokumen hasil

dekripsi tetap sama dengan berkas asli sebelum dilakukan proses enkripsi.

Berdasarkan pada hasil pengujian yang dapat dilihat pada halaman

lampiran dapat dilihat juga lamanya dari proses enkripsi dan lamanya dari proses

dekripsi. Dapat dilihat lamanya proses tidak bergantung pada format berkas

namun bergantung pada randomnya key yang didapatkan. Di bawah ini adalah

Tabel 4.11 dan Tabel 4.12 yang merupakan tabel lama proses enkripsi dekripsi

dokumen:

Tabel 4.11 Lama Proses Enkripsi

No Nama File Lama proses berformat

.txt .doc

1 file1 0,01072 0,00322326

2 file2 0,00244338 0,00358603

3 file3 0,00281067 0,00488268

4 file4 0,00488268 0,00282336

5 file5 0,00374817 0,00223776

6 file6 0,00401131 0,00228939

7 file7 0,00130253 0,00040896


43

8 file8 0,00162997 0,00191756

9 file9 0,00041847 0,00037001

10 file10 0,00024954 0,0003211

Rata - rata 0,00322 0,002206011

Tabel 4.12 Lama Proses Dekripsi

No Nama File Lama proses berformat

.txt .doc

1 file1 0,004684768 0,002998179

2 file2 0,002670282 0,001715574

3 file3 0,002136769 0,001937946

4 file4 0,000336955 0,001612767

5 file5 0,000454256 0,002295283

6 file6 0,005159856 0,001222822

7 file7 0,003030788 0,000376358

8 file8 0,002007693 0,002003617

9 file9 0,003011313 0,000502716

10 file10 0,002533507 0,001274905

Rata - rata 0,002602619 0,001594017

4.5 Kelebihan Algoritma One Time Pad

Kelebihan dari menggunakan Algoritma One Time Pad adalah sebagai

berikut :

1. Kunci acak yang hanya dapat digunakan sekali saja.

2. Melakukan proses enkripsi dekripsi dengan kunci yang berbeda akan

menghasilkan plaintext yang berbeda pula dari berkas asli.

3. Hanya cocok untuk pesan berukuran kecil.

4.6 Kekurangan Algoritma One Time Pad

Kekurangan dari menggunakan Algoritma One Time Pad adalah sebagai

berikut :

1. Adanya masalah dalam penyimpanan kunci, pendistribusian kunci

serta pengiriman kunci karena panjang kunci = panjang pesan.


44

BAB V

KESIMPULAN DAN SARAN

5.1 Kesimpulan

Berdasarkan pengujian yang dilakukan sebanyak 10 kali, maka

presentase keberhasilan untuk berkas dokumen berformat .txt adalah 100%

dimana berkas dokumen asli sama dengan berkas dokumen setelah proses

dekripsi. Presentase keberhasilan untuk berkas dokumen berformat .doc

adalah 100%. Maka dapat disimpulkan bahwa algoritma One Time Pad

dapat mengenkripsi dan mendekripsi berkas dokumen (.txt, .doc) dengan

benar. Lamanya proses enkripsi bergantung pada randomnya kunci acak

yang digunakan. Dibutuhkan waktu rata – rata 0,00322 detik untuk

melakukan proses enkripsi dokumen berformat .txt dan 0,002206011 detik

untuk melakukan proses enkripsi dokumen berformat .doc. Untuk proses

dekripsi dokumen berformat .txt dibutuhkan waktu rata – rata 0,002602619

detik dan 0,001594017 detik untuk melakukan proses dekripsi dokumen

berformat .doc.

5.2 Saran

Dari hasil analisis pada tugas akhir ini, penulis memberikan saran untuk

perbaikan dan pengembangan program lebih lanjut antara lain :

1. Program dapat melakukan enkripsi dekripsi dokumen untuk semua

tipe file.

2. Kunci yang tersimpan dapat terhapus otomatis setelah kunci

tersebut digunakan.

DAFTAR PUSTAKA


45

Astutik, Amelia. 2007. Algoritma Enkripsi One Time Pad untuk Sistem Pengamanan

Access Database Server. Skripsi. Semarang, Indonesia : Universitas Negeri

Semarang.

Bilqis. 2012. Analisis dan Perancangan Aplikasi Pesan Rahasia Menggunakan

Algoritma One TimePad (OTP) Dengan Pembangkit Bilangan Acak Linear

Congruential Generator (LCG). Skripsi. Medan, Indonesia : Universitas Sumatera

Utara

Iswanti. 2003. Sistem Keamanan Data dengan Metode Public Key Cryptography.

Penerbit ITB. Bandung .

Kurniawan, Yusuf. 2004. Kriptografi: Keamanan Internet dan Jaringan Komunikasi.

Penerbit Informatika. Bandung.

Raharjo, Budi. 2002. Keamanan Sistem Informasi Berbasis Internet. PT. Insan

Indonesia –Bandung & PT INDOCISC –Jakarta.

Septian, Devi Agung. 2008. Simulasi Proses Pembangkitan Deret Bilangan Acak Semu

Menggunakan Generator Beth Piper Step dan Go (LSFR). Skripsi. Bandung :

UNIKOM.

Winaryo, Febryan Christy. 2014. Implementasi Modifikasi Kriptografi One Time Pad

(OTP) untuk Pengamanan Data File. Skripsi. Salatiga, Indonesia : Universitas

Kristen Satya Wacana.

www.ascii-code.com yang diakses pada tanggal 16 Februari 2015


46

LAMPIRAN


LAMPIRAN 1

Pengujian Program

A. Uji Coba Berkas Dokumen Berformat .txt

1. Pengujian 01 :

Berkas asli

Key

Ciphertext, hasil proses enkripsi


Plaintext, hasil proses dekripsi

2. Pengujian 02 :

Berkas asli

Key




3. Pengujian 03 :

Berkas asli

Key




4. Pengujian 04 :

Berkas asli

Key




5. Pengujian 05 :

Berkas asli

Key




6. Pengujian 06 :

Berkas asli

Key




7. Pengujian 07 :

Berkas asli

Key




8. Pengujian 08 :

Berkas asli

Key




9. Pengujian 09 :

Berkas asli

Key




10. Pengujian 10 :

Berkas asli

Key




B. Uji Coba Berkas Dokumen Berformat .doc

1. Pengujian 01 :

Berkas asli

Key




2. Pengujian 02 :

Berkas asli

Key




3. Pengujian 03 :

Berkas asli

Key




4. Pengujian 04 :

Berkas asli

Key




5. Pengujian 05 :

Berkas asli

Key




6. Pengujian 06 :

Berkas asli

Key




7. Pengujian 07 :

Berkas asli

Key




8. Pengujian 08 :

Berkas asli

Key




9. Pengujian 09 :

Berkas asli

Key




10. Pengujian 10 :

Berkas asli

Key



LAMPIRAN 2

Listing Program

1. Implementasi Kelas HalamanAwal.java

package skripsiotp;

public class HalamanAwal extends javax.swing.JFrame {

public HalamanAwal() { initComponents(); setLocationRelativeTo(this);

setTitle("Halaman Awal");

} @SuppressWarnings("unchecked")

private void initComponents() {

jPanel1 = new javax.swing.JPanel(); jButton1 = new javax.swing.JButton();

jButton2 = new javax.swing.JButton(); jLabel1 = new javax.swing.JLabel();

jLabel2 = new javax.swing.JLabel(); jLabel3 = new javax.swing.JLabel(); jLabel4 = new javax.swing.JLabel();

javax.swing.GroupLayout jPanel1Layout = new

javax.swing.GroupLayout(jPanel1); jPanel1.setLayout(jPanel1Layout); jPanel1Layout.setHorizontalGroup(

jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADI

NG) .addGap(0, 100, Short.MAX_VALUE) );

jPanel1Layout.setVerticalGroup(

jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) .addGap(0, 100, Short.MAX_VALUE)

);


setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);

jButton1.setText("Enkripsi"); jButton1.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) { jButton1ActionPerformed(evt); }

});

jButton2.setText("Dekripsi"); jButton2.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) {

jButton2ActionPerformed(evt); }

}); jLabel1.setFont(new java.awt.Font("Times New Roman", 1, 24));

jLabel1.setText("KEAMANAN DATA");

jLabel2.setFont(new java.awt.Font("Times New Roman", 1, 14)); jLabel2.setText("Fidelis Asterina Surya P");

jLabel3.setFont(new java.awt.Font("Times New Roman", 1, 14)); jLabel3.setText("105314021");

jLabel4.setFont(new java.awt.Font("Times New Roman", 1, 18)); jLabel4.setText("Universitas Sanata Dharma");

javax.swing.GroupLayout layout = new

javax.swing.GroupLayout(getContentPane()); getContentPane().setLayout(layout); layout.setHorizontalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(layout.createSequentialGroup() .addGap(169, 169, 169) .addComponent(jLabel3)

.addContainerGap(188, Short.MAX_VALUE)) .addGroup(layout.createSequentialGroup()

.addGap(130, 130, 130) .addComponent(jLabel2) .addContainerGap(141, Short.MAX_VALUE))

.addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()


.addGap(83, 83, 83)

.addComponent(jButton1) .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, 95,

Short.MAX_VALUE) .addComponent(jButton2)

.addGap(104, 104, 104)) .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()

.addContainerGap(102, Short.MAX_VALUE) .addComponent(jLabel1)

.addGap(103, 103, 103)) .addGroup(layout.createSequentialGroup() .addGap(94, 94, 94)

.addComponent(jLabel4) .addContainerGap(114, Short.MAX_VALUE))

); layout.setVerticalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) .addGroup(javax.swing.GroupLayout.Alignment.TRAILING,

layout.createSequentialGroup() .addContainerGap() .addComponent(jLabel1,

javax.swing.GroupLayout.PREFERRED_SIZE, 58, javax.swing.GroupLayout.PREFERRED_SIZE)

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, 119, Short.MAX_VALUE)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BAS

ELINE) .addComponent(jButton2) .addComponent(jButton1))

.addGap(18, 18, 18) .addComponent(jLabel2)

.addGap(18, 18, 18) .addComponent(jLabel3) .addGap(36, 36, 36)

.addComponent(jLabel4) .addContainerGap())

); pack();

}// </editor-fold>


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

HalamanEnkripsi enk = new HalamanEnkripsi(); enk.setVisible(true); this.dispose();

}

private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) { HalamanDekripsi dek = new HalamanDekripsi();

dek.setVisible(true); this.dispose();

}

public static void main(String args[]) { java.awt.EventQueue.invokeLater(new Runnable() {

public void run() { new HalamanAwal().setVisible(true); }

}); }

private javax.swing.JButton jButton1; private javax.swing.JButton jButton2;

private javax.swing.JLabel jLabel1; private javax.swing.JLabel jLabel2;

private javax.swing.JLabel jLabel3; private javax.swing.JLabel jLabel4; private javax.swing.JPanel jPanel1;

}

2. Implementasi Kelas HalamanEnkripsi.java

package skripsiotp; import java.io.BufferedReader;

import java.io.BufferedWriter; import java.io.File;

import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream;

import java.io.FileReader; import java.io.FileWriter;

import java.io.IOException; import java.io.PrintWriter; import java.util.logging.Level;


import java.util.logging.Logger;

import javax.swing.JFileChooser; import javax.swing.JOptionPane; import javax.swing.filechooser.FileNameExtensionFilter;

import org.apache.poi.hwpf.extractor.WordExtractor;

public class HalamanEnkripsi extends javax.swing.JFrame { /** Creates new form HalamanEnkripsi */

public HalamanEnkripsi() { initComponents();

} private OneTimePad otp = new OneTimePad();

@SuppressWarnings("unchecked")

private void initComponents() {

jLabel1 = new javax.swing.JLabel(); jPanel1 = new javax.swing.JPanel();

jLabel2 = new javax.swing.JLabel(); jScrollPane1 = new javax.swing.JScrollPane(); enkripsiKey = new javax.swing.JTextArea();

PlainButton = new javax.swing.JButton(); jLabel3 = new javax.swing.JLabel();

jScrollPane2 = new javax.swing.JScrollPane(); plainArea = new javax.swing.JTextArea(); GenerateKey = new javax.swing.JButton();

prosesEnkripsi = new javax.swing.JButton(); jLabel4 = new javax.swing.JLabel();

jScrollPane3 = new javax.swing.JScrollPane(); hasilEnkripsi = new javax.swing.JTextArea(); jLabel5 = new javax.swing.JLabel();

LamaEnkrip = new javax.swing.JTextField(); jLabel6 = new javax.swing.JLabel();

simpanEnkripsi = new javax.swing.JButton(); jButton1 = new javax.swing.JButton();


jLabel1.setFont(new java.awt.Font("Times New Roman", 1, 14)); jLabel1.setText("Enkripsi");


jPanel1.setBorder(javax.swing.BorderFactory.createLineBorder(new

java.awt.Color(0, 0, 0))); jLabel2.setFont(new java.awt.Font("Times New Roman", 1, 12));

jLabel2.setText("Plaintext");

enkripsiKey.setColumns(20); enkripsiKey.setRows(5); jScrollPane1.setViewportView(enkripsiKey);

PlainButton.setText("Browse");

PlainButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) { PlainButtonActionPerformed(evt);

} });

jLabel3.setFont(new java.awt.Font("Times New Roman", 1, 12)); jLabel3.setText("Key");

plainArea.setColumns(20);

plainArea.setRows(5); jScrollPane2.setViewportView(plainArea);

GenerateKey.setText("Generate Key"); GenerateKey.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) { GenerateKeyActionPerformed(evt); }

});

prosesEnkripsi.setText("Proses"); prosesEnkripsi.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) {

prosesEnkripsiActionPerformed(evt); }

}); jLabel4.setFont(new java.awt.Font("Tahoma", 1, 11));

jLabel4.setText("Output");

hasilEnkripsi.setColumns(20); hasilEnkripsi.setRows(5); jScrollPane3.setViewportView(hasilEnkripsi);

jLabel5.setFont(new java.awt.Font("Times New Roman", 0, 12));


jLabel5.setText("Lama Proses");

jLabel6.setText("detik");

simpanEnkripsi.setText("Simpan"); simpanEnkripsi.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) { simpanEnkripsiActionPerformed(evt); }

});

jButton1.setText("Kembali"); jButton1.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) {

jButton1ActionPerformed(evt); }

}); javax.swing.GroupLayout jPanel1Layout = new

javax.swing.GroupLayout(jPanel1); jPanel1.setLayout(jPanel1Layout);

jPanel1Layout.setHorizontalGroup( jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADI

NG) .addGroup(jPanel1Layout.createSequentialGroup()

.addContainerGap() .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignm

ent.LEADING) .addGroup(jPanel1Layout.createSequentialGroup()

.addComponent(jLabel2) .addGap(336, 336, 336)) .addGroup(jPanel1Layout.createSequentialGroup()

.addComponent(prosesEnkripsi)

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, 298, Short.MAX_VALUE) .addComponent(GenerateKey)

.addContainerGap()) .addGroup(javax.swing.GroupLayout.Alignment.TRAILING,

jPanel1Layout.createSequentialGroup() .addComponent(PlainButton) .addContainerGap())

.addGroup(jPanel1Layout.createSequentialGroup() .addComponent(jLabel5)


.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) .addComponent(LamaEnkrip, javax.swing.GroupLayout.PREFERRED_SIZE, 331,

javax.swing.GroupLayout.PREFERRED_SIZE)

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED) .addComponent(jLabel6) .addContainerGap(43, Short.MAX_VALUE))

.addGroup(javax.swing.GroupLayout.Alignment.TRAILING, jPanel1Layout.createSequentialGroup()

.addComponent(jScrollPane3, javax.swing.GroupLayout.DEFAULT_SIZE, 462, Short.MAX_VALUE) .addContainerGap())


.addContainerGap(433, Short.MAX_VALUE)) .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, jPanel1Layout.createSequentialGroup()

.addComponent(jButton1)

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, 326, Short.MAX_VALUE) .addComponent(simpanEnkripsi)

.addContainerGap()) .addGroup(jPanel1Layout.createSequentialGroup()

.addComponent(jLabel3) .addContainerGap(451, Short.MAX_VALUE)) .addGroup(jPanel1Layout.createSequentialGroup()

.addComponent(jScrollPane1, javax.swing.GroupLayout.DEFAULT_SIZE, 462, Short.MAX_VALUE)

.addContainerGap()))) .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignm

ent.LEADING) .addGroup(jPanel1Layout.createSequentialGroup()

.addContainerGap() .addComponent(jScrollPane2, javax.swing.GroupLayout.DEFAULT_SIZE, 462, Short.MAX_VALUE)

.addContainerGap())) );

jPanel1Layout.setVerticalGroup( jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADI

NG) .addGroup(jPanel1Layout.createSequentialGroup()


.addContainerGap()

.addComponent(jLabel2) .addGap(97, 97, 97) .addComponent(PlainButton)


.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) .addComponent(jScrollPane1,


.addGap(18, 18, 18) .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignm

ent.BASELINE) .addComponent(prosesEnkripsi)

.addComponent(GenerateKey)) .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)

.addComponent(jLabel4)

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) .addComponent(jScrollPane3, javax.swing.GroupLayout.PREFERRED_SIZE, 68,

javax.swing.GroupLayout.PREFERRED_SIZE) .addGap(25, 25, 25)

.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)

.addComponent(jLabel5) .addComponent(LamaEnkrip,

javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)

.addComponent(jLabel6))



.addComponent(simpanEnkripsi) .addComponent(jButton1)) .addContainerGap())


.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) .addGroup(jPanel1Layout.createSequentialGroup()

.addGap(41, 41, 41) .addComponent(jScrollPane2,

javax.swing.GroupLayout.PREFERRED_SIZE, 65, javax.swing.GroupLayout.PREFERRED_SIZE) .addContainerGap(370, Short.MAX_VALUE)))

);

javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane()); getContentPane().setLayout(layout);

layout.setHorizontalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) .addGroup(layout.createSequentialGroup() .addContainerGap()

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEA

DING) .addComponent(jPanel1, javax.swing.GroupLayout.DEFAULT_SIZE,

javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE) .addComponent(jLabel1))

.addContainerGap()) ); layout.setVerticalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(layout.createSequentialGroup() .addContainerGap() .addComponent(jLabel1)

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)

.addComponent(jPanel1, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE) .addContainerGap())

);

pack(); }// </editor-fold>

private void PlainButtonActionPerformed(java.awt.event.ActionEvent evt) { JFileChooser fileChooser = new JFileChooser();


fileChooser.setVisible(true);

int returnValue = fileChooser.showOpenDialog(null); if (returnValue == JFileChooser.APPROVE_OPTION) { String namaFile = fileChooser.getSelectedFile().getPath();

String[] cut_namafile = namaFile.split("\\."); if (cut_namafile[1].equals("txt")) {

File txt = fileChooser.getSelectedFile(); String line = ""; try {

BufferedReader br = new BufferedReader(new FileReader(txt)); while ((line = br.readLine()) != null) {

plainArea.setText(line); } } catch (IOException ex) {

Logger.getLogger(HalamanEnkripsi.class.getName()).log(Level.SEVERE, null,

ex); } } else if (cut_namafile[1].equals("doc")) {

File doc = fileChooser.getSelectedFile();

try { WordExtractor we = new WordExtractor(new FileInputStream(doc)); } catch (IOException ex) {

Logger.getLogger(HalamanEnkripsi.class.getName()).log(Level.SEVERE, null,

ex); } }

} }

private void GenerateKeyActionPerformed(java.awt.event.ActionEvent evt) { String key = otp.genKey(plainArea.getText().length());

enkripsiKey.setText(key); }

private void prosesEnkripsiActionPerformed(java.awt.event.ActionEvent evt) { long t1 = System.nanoTime();

String message = plainArea.getText(); String key = enkripsiKey.getText();

if (message.length() != key.length()) { hasilEnkripsi.setText("Panjang pesan dan kunci harus sama!");

} else { hasilEnkripsi.setText(otp.encrypt(message, key));


}

long t2 = System.nanoTime(); LamaEnkrip.setText("" + (t2 - t1) * java.lang.Math.pow(10, -9)); }

private void simpanEnkripsiActionPerformed(java.awt.event.ActionEvent evt)

{ JFileChooser fileChooser = new JFileChooser(new File("E:/")); fileChooser.setFileFilter(new FileNameExtensionFilter("Microsoft Word

(*.doc)", "doc")); fileChooser.setFileFilter(new FileNameExtensionFilter("Text Documents

(*.txt)", "txt")); FileOutputStream file_output_stream; int returnValue = fileChooser.showSaveDialog(this);

if (returnValue == JFileChooser.APPROVE_OPTION) {

String filename = fileChooser.getSelectedFile().getPath(); String extension = fileChooser.getFileFilter().getDescription(); if (extension.equals("Microsoft Word (*.doc)")) {

File f = new File(filename + ".doc"); try {

file_output_stream = new FileOutputStream(f); } catch (FileNotFoundException e) { e.printStackTrace();

return; }

try { BufferedWriter bfw = new BufferedWriter(new FileWriter(f)); String outputEnkripsi = hasilEnkripsi.getText();

String[] cut_namaFile = outputEnkripsi.split("\\n"); FileWriter outFile = new FileWriter(f);

PrintWriter out = new PrintWriter(outFile, true); for (int i = 0; i < cut_namaFile.length; i++) { out.println("" + cut_namaFile[i].toString());

} file_output_stream.close();

} catch (IOException ie) { JOptionPane.showMessageDialog(this, "Penyimpanan Hasil Enkripsi Gagal Disimpan!!");

} } else if (extension.equals("Text Documents (*.txt)")) {

File f = new File(filename + ".txt"); try { file_output_stream = new FileOutputStream(f);

} catch (FileNotFoundException e) { e.printStackTrace();


return;

} try { String outputEnkripsi = hasilEnkripsi.getText();

String[] cut_namafile = outputEnkripsi.split("\\n");

FileWriter outFile = new FileWriter(f); PrintWriter out = new PrintWriter(outFile, true); for (int i = 0; i < cut_namafile.length; i++) {

out.println("" + cut_namafile[i].toString()); }

file_output_stream.close(); } catch (IOException ie) {

JOptionPane.showMessageDialog(this, "Penyimpanan Hasil Enkripsi Gagal Disimpan!!");

} } File outKey = new File(filename + ".key");

try { PrintWriter pw = new PrintWriter(outKey);

pw.write(enkripsiKey.getText()); pw.flush(); pw.close();

} catch (FileNotFoundException ex) { ex.printStackTrace();

} JOptionPane.showMessageDialog(this, "Penyimpanan Hasil Enkripsi dan

Key Telah Berhasil Disimpan!! di " + filename); simpanEnkripsi.setEnabled(true);

} } private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {

HalamanAwal awal = new HalamanAwal(); awal.setVisible(true);

this.dispose(); }

public static void main(String args[]) { java.awt.EventQueue.invokeLater(new Runnable() {

public void run() { new HalamanEnkripsi().setVisible(true); }

}); }


private javax.swing.JButton GenerateKey; private javax.swing.JTextField LamaEnkrip; private javax.swing.JButton PlainButton;

private javax.swing.JTextArea enkripsiKey; private javax.swing.JTextArea hasilEnkripsi;

private javax.swing.JButton jButton1; private javax.swing.JLabel jLabel1; private javax.swing.JLabel jLabel2;


private javax.swing.JLabel jLabel5; private javax.swing.JLabel jLabel6; private javax.swing.JPanel jPanel1;

private javax.swing.JScrollPane jScrollPane1; private javax.swing.JScrollPane jScrollPane2;

private javax.swing.JScrollPane jScrollPane3; private javax.swing.JTextArea plainArea; private javax.swing.JButton prosesEnkripsi;

private javax.swing.JButton simpanEnkripsi;

} 3. Implementasi Kelas HalamanDekripsi.java

package skripsiotp;

import java.io.BufferedReader; import java.io.BufferedWriter;

import java.io.File; import java.io.FileFilter; import java.io.FileNotFoundException;

import java.io.FileOutputStream; import java.io.FileReader;

import java.io.FileWriter; import java.io.IOException; import java.io.PrintWriter;

import java.util.logging.Level; import java.util.logging.Logger;

import javax.swing.JFileChooser; import javax.swing.JOptionPane; import javax.swing.filechooser.FileNameExtensionFilter;

public class HalamanDekripsi extends javax.swing.JFrame { public HalamanDekripsi() {


initComponents();

} private OneTimePad otp = new OneTimePad();

private void initComponents() { jLabel1 = new javax.swing.JLabel();

jPanel1 = new javax.swing.JPanel(); jLabel2 = new javax.swing.JLabel();

jScrollPane1 = new javax.swing.JScrollPane(); dekripsiKey = new javax.swing.JTextArea(); CipherButton = new javax.swing.JButton();

jLabel3 = new javax.swing.JLabel(); jScrollPane2 = new javax.swing.JScrollPane();

cipherArea = new javax.swing.JTextArea(); KeyButton = new javax.swing.JButton(); prosesDekripsi = new javax.swing.JButton();

jLabel4 = new javax.swing.JLabel(); jScrollPane3 = new javax.swing.JScrollPane();

hasilDekripsi = new javax.swing.JTextArea(); jLabel5 = new javax.swing.JLabel(); LamaDekripsi = new javax.swing.JTextField();

jLabel6 = new javax.swing.JLabel(); simpanDekripsi = new javax.swing.JButton();

jButton1 = new javax.swing.JButton();


jLabel1.setFont(new java.awt.Font("Times New Roman", 1, 14)); // NOI18N jLabel1.setText("Dekripsi");

jPanel1.setBorder(javax.swing.BorderFactory.createLineBorder(new java.awt.Color(0, 0, 0)));

jLabel2.setFont(new java.awt.Font("Times New Roman", 1, 12)); // NOI18N jLabel2.setText("Ciphertext");

dekripsiKey.setColumns(20);

dekripsiKey.setRows(5); jScrollPane1.setViewportView(dekripsiKey);

CipherButton.setText("Browse"); CipherButton.addActionListener(new java.awt.event.ActionListener() {


public void actionPerformed(java.awt.event.ActionEvent evt) {

CipherButtonActionPerformed(evt); } });

jLabel3.setFont(new java.awt.Font("Times New Roman", 1, 12)); // NOI18N

jLabel3.setText("Key"); cipherArea.setColumns(20);

cipherArea.setRows(5); jScrollPane2.setViewportView(cipherArea);

KeyButton.setText("Browse"); KeyButton.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) { KeyButtonActionPerformed(evt);

} });

prosesDekripsi.setText("Proses"); prosesDekripsi.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) { prosesDekripsiActionPerformed(evt); }

});

jLabel4.setFont(new java.awt.Font("Tahoma", 1, 11)); // NOI18N jLabel4.setText("Output");

hasilDekripsi.setColumns(20); hasilDekripsi.setRows(5);

jScrollPane3.setViewportView(hasilDekripsi); jLabel5.setFont(new java.awt.Font("Times New Roman", 0, 12)); // NOI18N

jLabel5.setText("Lama Proses");

jLabel6.setText("detik"); simpanDekripsi.setText("Simpan");

simpanDekripsi.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) {

simpanDekripsiActionPerformed(evt); } });

jButton1.setText("Kembali");


jButton1.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) { jButton1ActionPerformed(evt); }

});

javax.swing.GroupLayout jPanel1Layout = new javax.swing.GroupLayout(jPanel1); jPanel1.setLayout(jPanel1Layout);

jPanel1Layout.setHorizontalGroup(

jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) .addGroup(jPanel1Layout.createSequentialGroup()

.addContainerGap()

.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) .addGroup(jPanel1Layout.createSequentialGroup()

.addComponent(jLabel2) .addGap(336, 336, 336))

.addGroup(jPanel1Layout.createSequentialGroup() .addComponent(prosesDekripsi)


.addComponent(KeyButton) .addContainerGap()) .addGroup(javax.swing.GroupLayout.Alignment.TRAILING,

jPanel1Layout.createSequentialGroup() .addComponent(CipherButton)

.addContainerGap()) .addGroup(jPanel1Layout.createSequentialGroup() .addComponent(jLabel5)


.addComponent(LamaDekripsi, javax.swing.GroupLayout.PREFERRED_SIZE, 331, javax.swing.GroupLayout.PREFERRED_SIZE)

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)

.addComponent(jLabel6) .addContainerGap(43, Short.MAX_VALUE)) .addGroup(javax.swing.GroupLayout.Alignment.TRAILING,

jPanel1Layout.createSequentialGroup()


.addComponent(jScrollPane3,

javax.swing.GroupLayout.DEFAULT_SIZE, 462, Short.MAX_VALUE) .addContainerGap()) .addGroup(jPanel1Layout.createSequentialGroup()

.addComponent(jLabel4) .addContainerGap(433, Short.MAX_VALUE))

.addGroup(javax.swing.GroupLayout.Alignment.TRAILING, jPanel1Layout.createSequentialGroup() .addComponent(jButton1)

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED,

326, Short.MAX_VALUE) .addComponent(simpanDekripsi) .addContainerGap())


.addContainerGap(451, Short.MAX_VALUE)) .addGroup(jPanel1Layout.createSequentialGroup() .addComponent(jScrollPane1,

javax.swing.GroupLayout.DEFAULT_SIZE, 462, Short.MAX_VALUE) .addContainerGap())))

.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(jPanel1Layout.createSequentialGroup() .addContainerGap()

.addComponent(jScrollPane2, javax.swing.GroupLayout.DEFAULT_SIZE, 462, Short.MAX_VALUE) .addContainerGap()))

); jPanel1Layout.setVerticalGroup(

jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(jPanel1Layout.createSequentialGroup() .addContainerGap()

.addComponent(jLabel2) .addGap(97, 97, 97) .addComponent(CipherButton)


.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) .addComponent(jScrollPane1,



.addGap(18, 18, 18)


.addComponent(prosesDekripsi) .addComponent(KeyButton))

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED) .addComponent(jLabel4)


.addComponent(jScrollPane3, javax.swing.GroupLayout.PREFERRED_SIZE, 68, javax.swing.GroupLayout.PREFERRED_SIZE)

.addGap(25, 25, 25)

.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE) .addComponent(jLabel5)

.addComponent(LamaDekripsi, javax.swing.GroupLayout.PREFERRED_SIZE,

javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE) .addComponent(jLabel6))

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, 25,

Short.MAX_VALUE) .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignm

ent.BASELINE) .addComponent(simpanDekripsi)

.addComponent(jButton1)) .addContainerGap())

.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(jPanel1Layout.createSequentialGroup() .addGap(41, 41, 41) .addComponent(jScrollPane2,


.addContainerGap(377, Short.MAX_VALUE))) );

javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());


getContentPane().setLayout(layout);

layout.setHorizontalGroup( layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(layout.createSequentialGroup() .addContainerGap()

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addComponent(jLabel1) .addComponent(jPanel1,

javax.swing.GroupLayout.Alignment.TRAILING, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))

.addContainerGap()) );

layout.setVerticalGroup( layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(layout.createSequentialGroup() .addContainerGap()

.addComponent(jLabel1) .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)

.addComponent(jPanel1, javax.swing.GroupLayout.PREFERRED_SIZE,

javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE) .addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE,

Short.MAX_VALUE)) );

pack(); }// </editor-fold>

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

JFileChooser fileChooser = new JFileChooser(); fileChooser.setVisible(true); int returnValue = fileChooser.showOpenDialog(null);

if (returnValue == JFileChooser.APPROVE_OPTION) {

String namaFile = fileChooser.getSelectedFile().getPath(); String[] cut_namafile = namaFile.split("\\."); if (cut_namafile[1].equals("txt")) {

File txt = fileChooser.getSelectedFile();


String line = "";

try { BufferedReader br = new BufferedReader(new FileReader(txt)); while ((line = br.readLine()) != null) {

cipherArea.setText(line); }

} catch (IOException ex) { Logger.getLogger(HalamanDekripsi.class.getName()).log(Level.SEVERE, null,

ex); }

} else if (cut_namafile[1].equals("doc")) { File doc = fileChooser.getSelectedFile();

String line = ""; try {

BufferedReader br = new BufferedReader(new FileReader(doc)); while ((line = br.readLine()) != null) { cipherArea.setText(line);

} } catch (IOException ex) {

Logger.getLogger(HalamanDekripsi.class.getName()).log(Level.SEVERE, null, ex);

} }

} }

private void KeyButtonActionPerformed(java.awt.event.ActionEvent evt) { JFileChooser fileChooser = new JFileChooser();

FileNameExtensionFilter filter = new FileNameExtensionFilter("key file", "key"); fileChooser.addChoosableFileFilter(filter);

fileChooser.setFileFilter(filter); fileChooser.setVisible(true);

int returnValue = fileChooser.showOpenDialog(null); if (returnValue == JFileChooser.APPROVE_OPTION) {

File key = fileChooser.getSelectedFile(); try {

BufferedReader br = new BufferedReader(new FileReader(key)); String line = ""; while ((line = br.readLine()) != null) {

dekripsiKey.append(line); }


br.close();

} catch (IOException ex) { Logger.getLogger(HalamanDekripsi.class.getName()).log(Level.SEVERE, null,

ex); }

}

} //

private void prosesDekripsiActionPerformed(java.awt.event.ActionEvent evt) { long t1 = System.nanoTime(); String message = cipherArea.getText();

String key = dekripsiKey.getText();

if (message.length() != key.length()) { hasilDekripsi.setText("Panjang pesan dan kunci harus sama!"); } else {

hasilDekripsi.setText(otp.encrypt(message, key)); hasilDekripsi.setText(otp.decrypt(message, key));

} long t2 = System.nanoTime(); LamaDekripsi.setText("" + (t2 - t1) * java.lang.Math.pow(10, -9));

}

private void simpanDekripsiActionPerformed(java.awt.event.ActionEvent evt) { JFileChooser fileChooser = new JFileChooser(new File("E:/"));

fileChooser.setFileFilter(new FileNameExtensionFilter("Microsoft Word (*.doc)", "doc"));

fileChooser.setFileFilter(new FileNameExtensionFilter("Text Documents (*.txt)", "txt")); FileOutputStream file_output_stream;

int returnValue = fileChooser.showSaveDialog(this);

if (returnValue == JFileChooser.APPROVE_OPTION) { String filename = fileChooser.getSelectedFile().getPath(); String extension = fileChooser.getFileFilter().getDescription();

if (extension.equals("Microsoft Word (*.doc)")) { File f = new File(filename + ".doc");

try { file_output_stream = new FileOutputStream(f); } catch (FileNotFoundException e) {

e.printStackTrace(); return;


}

try { BufferedWriter bfw = new BufferedWriter(new FileWriter(f)); String outputEnkripsi = hasilDekripsi.getText();

String[] cut_namaFile = outputEnkripsi.split("\\n"); FileWriter outFile = new FileWriter(f);

PrintWriter out = new PrintWriter(outFile, true); for (int i = 0; i < cut_namaFile.length; i++) { out.println("" + cut_namaFile[i].toString());

} file_output_stream.close();

} catch (IOException ie) { JOptionPane.showMessageDialog(this, "Penyimpanan Hasil Dekripsi Gagal Disimpan!!");

} JOptionPane.showMessageDialog(this, "Penyimpanan Hasil Dekripsi

Telah Berhasil Disimpan!! di " + filename); } else if (extension.equals("Text Documents (*.txt)")) { File f = new File(filename + ".txt");

try { file_output_stream = new FileOutputStream(f);

} catch (FileNotFoundException e) { e.printStackTrace(); return;

} try {

String outputDekripsi = hasilDekripsi.getText(); String[] cut_namafile = outputDekripsi.split("\\n");

FileWriter outFile = new FileWriter(f); PrintWriter out = new PrintWriter(outFile, true);

for (int i = 0; i < cut_namafile.length; i++) { out.println("" + cut_namafile[i].toString()); }

file_output_stream.close(); } catch (IOException ie) {

JOptionPane.showMessageDialog(this, "Penyimpanan Hasil Dekripsi Gagal Disimpan!!"); }

JOptionPane.showMessageDialog(this, "Penyimpanan Hasil Dekripsi Telah Berhasil Disimpan!! di " + filename);

} simpanDekripsi.setEnabled(true); }

}


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

HalamanAwal awal = new HalamanAwal(); awal.setVisible(true); this.dispose();

}

public static void main(String args[]) { java.awt.EventQueue.invokeLater(new Runnable() { public void run() {

new HalamanDekripsi().setVisible(true); }

}); }

private javax.swing.JButton CipherButton; private javax.swing.JButton KeyButton;

private javax.swing.JTextField LamaDekripsi; private javax.swing.JTextArea cipherArea; private javax.swing.JTextArea dekripsiKey;

private javax.swing.JTextArea hasilDekripsi; private javax.swing.JButton jButton1;

private javax.swing.JLabel jLabel1; private javax.swing.JLabel jLabel2; private javax.swing.JLabel jLabel3;


private javax.swing.JLabel jLabel6; private javax.swing.JPanel jPanel1; private javax.swing.JScrollPane jScrollPane1;

private javax.swing.JScrollPane jScrollPane2; private javax.swing.JScrollPane jScrollPane3;

private javax.swing.JButton prosesDekripsi; private javax.swing.JButton simpanDekripsi;

}

4. Implementasi Kelas OneTimePad.java

package skripsiotp;

public class OneTimePad { public static String encrypt(String message, String key) {

if (message.length() != key.length()) { error("Lengths must be equal");

} int[] im = charArrayToInt(message.toCharArray()); int[] ik = charArrayToInt(key.toCharArray());


int[] data = new int[message.length()];

for (int i = 0; i < message.length(); i++) { data[i] = (im[i] + ik[i])%256;

}


public static String decrypt(String message, String key) { if (message.length() != key.length()) {

error("Lengths must be equal"); } int[] im = charArrayToInt(message.toCharArray());

int[] ik = charArrayToInt(key.toCharArray()); int[] data = new int[message.length()];

for (int i = 0; i < message.length(); i++) { data[i] = (im[i] - ik[i])%256;

}


public static String genKey(int length) { MersenneTwisterFast rand = new MersenneTwisterFast();

char[] key = new char[length]; for (int i = 0; i < length; i++) { key[i] = (char) rand.nextInt(132);

if ((int) key[i] < 97) { key[i] = (char) (key[i] + 72);

} if ((int) key[i] > 122) { key[i] = (char) (key[i] - 72);

} }

return new String(key); }

public static void main(String[] args) { }

private static int chartoInt(char c) { return (int) c;

}


private static char intToChar(int i) {

return (char) i; }

private static int[] charArrayToInt(char[] cc) { int[] ii = new int[cc.length];

for (int i = 0; i < cc.length; i++) { ii[i] = chartoInt(cc[i]); }

return ii; }

private static char[] intArrayToChar(int[] ii) { char[] cc = new char[ii.length];

for (int i = 0; i < ii.length; i++) { cc[i] = intToChar(ii[i]);

} return cc; }

private static void error(String msg) {

System.out.println(msg); System.exit(-1); }

}

5. Implementasi Kelas MersenneTwisterFast.java

package skripsiotp;

import java.math.BigInteger; import java.security.SecureRandom;

import java.util.Random;

import java.io.*; import java.util.*;

public strictfp class MersenneTwisterFast implements Serializable, Cloneable { // Serialization

private static final long serialVersionUID = -8219700664442619525L; // locked as of Version 15

// Period parameters private static final int N = 624;

private static final int M = 397; private static final int MATRIX_A = 0x9908b0df; // private static final * constant vector a


private static final int UPPER_MASK = 0x80000000; // most significant w-r

bits private static final int LOWER_MASK = 0x7fffffff; // least significant r bits // Tempering parameters

private static final int TEMPERING_MASK_B = 0x9d2c5680; private static final int TEMPERING_MASK_C = 0xefc60000;

private int mt[]; // the array for the state vector private int mti; // mti==N+1 means mt[N] is not initialized private int mag01[];

// a good initial seed (of int size, though stored in a long) //private static final long GOOD_SEED = 4357;

private double __nextNextGaussian; private boolean __haveNextNextGaussian;

/* We're overriding all internal data, to my knowledge, so this should be okay */

public Object clone() { try { MersenneTwisterFast f = (MersenneTwisterFast) (super.clone());

f.mt = (int[]) (mt.clone()); f.mag01 = (int[]) (mag01.clone());

return f; } catch (CloneNotSupportedException e) { throw new InternalError();

} // should never happen }

public boolean stateEquals(Object o) { if (o == this) {

return true; }

if (o == null || !(o instanceof MersenneTwisterFast)) { return false; }

MersenneTwisterFast other = (MersenneTwisterFast) o; if (mti != other.mti) {

return false; } for (int x = 0; x < mag01.length; x++) {

if (mag01[x] != other.mag01[x]) { return false;

} } for (int x = 0; x < mt.length; x++) {

if (mt[x] != other.mt[x]) { return false;


}

} return true; }

/** Reads the entire state of the MersenneTwister RNG from the stream */

public void readState(DataInputStream stream) throws IOException { int len = mt.length; for (int x = 0; x < len; x++) {

mt[x] = stream.readInt(); }

len = mag01.length; for (int x = 0; x < len; x++) {

mag01[x] = stream.readInt(); }

mti = stream.readInt(); __nextNextGaussian = stream.readDouble();

__haveNextNextGaussian = stream.readBoolean(); }

/** Writes the entire state of the MersenneTwister RNG to the stream */ public void writeState(DataOutputStream stream) throws IOException {

int len = mt.length; for (int x = 0; x < len; x++) {

stream.writeInt(mt[x]); }

len = mag01.length; for (int x = 0; x < len; x++) {

stream.writeInt(mag01[x]); }

stream.writeInt(mti); stream.writeDouble(__nextNextGaussian);

stream.writeBoolean(__haveNextNextGaussian); }

/** * Constructor using the default seed.

*/ public MersenneTwisterFast() { this(System.currentTimeMillis());

}


/**

* Constructor using a given seed. Though you pass this seed in * as a long, it's best to make sure it's actually an integer. *

*/ public MersenneTwisterFast(long seed) {

setSeed(seed); }

/** * Constructor using an array of integers as seed.

* Your array must have a non-zero length. Only the first 624 integers * in the array are used; if the array is shorter than this then * integers are repeatedly used in a wrap-around fashion.

*/ public MersenneTwisterFast(int[] array) {

setSeed(array); }

/** * Initalize the pseudo random number generator. Don't

* pass in a long that's bigger than an int (Mersenne Twister * only uses the first 32 bits for its seed). */

synchronized public void setSeed(long seed) { // Due to a bug in java.util.Random clear up to 1.2, we're

// doing our own Gaussian variable. __haveNextNextGaussian = false;

mt = new int[N];

mag01 = new int[2]; mag01[0] = 0x0; mag01[1] = MATRIX_A;

mt[0] = (int) (seed & 0xffffffff);

for (mti = 1; mti < N; mti++) { mt[mti] = (1812433253 * (mt[mti - 1] ^ (mt[mti - 1] >>> 30)) + mti);

/* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */ /* In the previous versions, MSBs of the seed affect */

/* only MSBs of the array mt[]. */ /* 2002/01/09 modified by Makoto Matsumoto */ // mt[mti] &= 0xffffffff;

/* for >32 bit machines */ }


}

/** * Sets the seed of the MersenneTwister using an array of integers.

* Your array must have a non-zero length. Only the first 624 integers * in the array are used; if the array is shorter than this then

* integers are repeatedly used in a wrap-around fashion. */ synchronized public void setSeed(int[] array) {

if (array.length == 0) { throw new IllegalArgumentException("Array length must be greater than

zero"); } int i, j, k;

setSeed(19650218); i = 1;

j = 0; k = (N > array.length ? N : array.length); for (; k != 0; k--) {

mt[i] = (mt[i] ^ ((mt[i - 1] ^ (mt[i - 1] >>> 30)) * 1664525)) + array[j] + j; /* non linear */

// mt[i] &= 0xffffffff; /* for WORDSIZE > 32 machines */ i++; j++;

if (i >= N) { mt[0] = mt[N - 1];

i = 1; } if (j >= array.length) {

j = 0; }

} for (k = N - 1; k != 0; k--) { mt[i] = (mt[i] ^ ((mt[i - 1] ^ (mt[i - 1] >>> 30)) * 1566083941)) - i; /* non

linear */ // mt[i] &= 0xffffffff; /* for WORDSIZE > 32 machines */

i++; if (i >= N) { mt[0] = mt[N - 1];

i = 1; }

} mt[0] = 0x80000000; /* MSB is 1; assuring non-zero initial array */ }

public int nextInt() {


int y;

if (mti >= N) // generate N words at one time {

int kk; final int[] mt = this.mt; // locals are slightly faster

final int[] mag01 = this.mag01; // locals are slightly faster for (kk = 0; kk < N - M; kk++) {

y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); mt[kk] = mt[kk + M] ^ (y >>> 1) ^ mag01[y & 0x1];

} for (; kk < N - 1; kk++) { y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK);

mt[kk] = mt[kk + (M - N)] ^ (y >>> 1) ^ mag01[y & 0x1]; }

y = (mt[N - 1] & UPPER_MASK) | (mt[0] & LOWER_MASK); mt[N - 1] = mt[M - 1] ^ (y >>> 1) ^ mag01[y & 0x1];

mti = 0; }

y = mt[mti++]; y ^= y >>> 11; // TEMPERING_SHIFT_U(y)

y ^= (y << 7) & TEMPERING_MASK_B; // TEMPERING_SHIFT_S(y) y ^= (y << 15) & TEMPERING_MASK_C; //

TEMPERING_SHIFT_T(y) y ^= (y >>> 18); // TEMPERING_SHIFT_L(y)

return y; }

public short nextShort() { int y;

if (mti >= N) // generate N words at one time

{ int kk; final int[] mt = this.mt; // locals are slightly faster

final int[] mag01 = this.mag01; // locals are slightly faster

for (kk = 0; kk < N - M; kk++) { y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); mt[kk] = mt[kk + M] ^ (y >>> 1) ^ mag01[y & 0x1];

} for (; kk < N - 1; kk++) {


y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK);

mt[kk] = mt[kk + (M - N)] ^ (y >>> 1) ^ mag01[y & 0x1]; } y = (mt[N - 1] & UPPER_MASK) | (mt[0] & LOWER_MASK);

mt[N - 1] = mt[M - 1] ^ (y >>> 1) ^ mag01[y & 0x1];

mti = 0; }


y ^= (y << 7) & TEMPERING_MASK_B; // TEMPERING_SHIFT_S(y) y ^= (y << 15) & TEMPERING_MASK_C; // TEMPERING_SHIFT_T(y)

y ^= (y >>> 18); // TEMPERING_SHIFT_L(y)

return (short) (y >>> 16); }

public char nextChar() { int y;








mti = 0; }


y ^= (y << 7) & TEMPERING_MASK_B; // TEMPERING_SHIFT_S(y)


y ^= (y << 15) & TEMPERING_MASK_C; //


return (char) (y >>> 16); }

public boolean nextBoolean() { int y;





} for (; kk < N - 1; kk++) {

y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); mt[kk] = mt[kk + (M - N)] ^ (y >>> 1) ^ mag01[y & 0x1]; }


mti = 0; }

y = mt[mti++];

y ^= y >>> 11; // TEMPERING_SHIFT_U(y) y ^= (y << 7) & TEMPERING_MASK_B; // TEMPERING_SHIFT_S(y) y ^= (y << 15) & TEMPERING_MASK_C; //


return (boolean) ((y >>> 31) != 0); }

/** This generates a coin flip with a probability <tt>probability</tt>

of returning true, else returning false. <tt>probability</tt> must be between 0.0 and 1.0, inclusive. Not as precise a random real event as nextBoolean(double), but twice as fast. To explicitly

use this, remember you may need to cast to float first. */ public boolean nextBoolean(float probability) {


int y;

if (probability < 0.0f || probability > 1.0f) { throw new IllegalArgumentException("probability must be between 0.0

and 1.0 inclusive."); }

if (probability == 0.0f) { return false; // fix half-open issues } else if (probability == 1.0f) {

return true; // fix half-open issues }

if (mti >= N) // generate N words at one time { int kk;

final int[] mt = this.mt; // locals are slightly faster final int[] mag01 = this.mag01; // locals are slightly faster

for (kk = 0; kk < N - M; kk++) { y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK);

mt[kk] = mt[kk + M] ^ (y >>> 1) ^ mag01[y & 0x1]; }

for (; kk < N - 1; kk++) { y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); mt[kk] = mt[kk + (M - N)] ^ (y >>> 1) ^ mag01[y & 0x1];

} y = (mt[N - 1] & UPPER_MASK) | (mt[0] & LOWER_MASK);

mt[N - 1] = mt[M - 1] ^ (y >>> 1) ^ mag01[y & 0x1]; mti = 0;

}

y = mt[mti++]; y ^= y >>> 11; // TEMPERING_SHIFT_U(y) y ^= (y << 7) & TEMPERING_MASK_B; // TEMPERING_SHIFT_S(y)

y ^= (y << 15) & TEMPERING_MASK_C; // TEMPERING_SHIFT_T(y)

y ^= (y >>> 18); // TEMPERING_SHIFT_L(y) return (y >>> 8) / ((float) (1 << 24)) < probability;

}

/** This generates a coin flip with a probability <tt>probability</tt> of returning true, else returning false. <tt>probability</tt> must be between 0.0 and 1.0, inclusive. */

public boolean nextBoolean(double probability) { int y;


int z;

if (probability < 0.0 || probability > 1.0) { throw new IllegalArgumentException("probability must be between 0.0

and 1.0 inclusive."); }

if (probability == 0.0) { return false; // fix half-open issues } else if (probability == 1.0) {

return true; // fix half-open issues }








}



y ^= (y >>> 18); // TEMPERING_SHIFT_L(y) if (mti >= N) // generate N words at one time

{ int kk;


for (kk = 0; kk < N - M; kk++) { z = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK);


mt[kk] = mt[kk + M] ^ (z >>> 1) ^ mag01[z & 0x1];

} for (; kk < N - 1; kk++) { z = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK);

mt[kk] = mt[kk + (M - N)] ^ (z >>> 1) ^ mag01[z & 0x1]; }

z = (mt[N - 1] & UPPER_MASK) | (mt[0] & LOWER_MASK); mt[N - 1] = mt[M - 1] ^ (z >>> 1) ^ mag01[z & 0x1];

mti = 0; }

z = mt[mti++]; z ^= z >>> 11; // TEMPERING_SHIFT_U(z)

z ^= (z << 7) & TEMPERING_MASK_B; // TEMPERING_SHIFT_S(z) z ^= (z << 15) & TEMPERING_MASK_C; //

TEMPERING_SHIFT_T(z) z ^= (z >>> 18); // TEMPERING_SHIFT_L(z)

/* derived from nextDouble documentation in jdk 1.2 docs, see top */ return ((((long) (y >>> 6)) << 27) + (z >>> 5)) / (double) (1L << 53) <

probability; }

public byte nextByte() { int y;








mti = 0; }




y ^= (y >>> 18); // TEMPERING_SHIFT_L(y) return (byte) (y >>> 24);

}

public void nextBytes(byte[] bytes) { int y;

for (int x = 0; x < bytes.length; x++) { if (mti >= N) // generate N words at one time




} for (; kk < N - 1; kk++) {



mti = 0; }

y = mt[mti++];

y ^= y >>> 11; // TEMPERING_SHIFT_U(y) y ^= (y << 7) & TEMPERING_MASK_B; // TEMPERING_SHIFT_S(y)


y ^= (y >>> 18); // TEMPERING_SHIFT_L(y) bytes[x] = (byte) (y >>> 24);

} }


public long nextLong() { int y; int z;





} for (; kk < N - 1; kk++) {



mti = 0; }

y = mt[mti++];






z = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); mt[kk] = mt[kk + M] ^ (z >>> 1) ^ mag01[z & 0x1];




z = (mt[N - 1] & UPPER_MASK) | (mt[0] & LOWER_MASK);

mt[N - 1] = mt[M - 1] ^ (z >>> 1) ^ mag01[z & 0x1]; mti = 0;

}

z = mt[mti++]; z ^= z >>> 11; // TEMPERING_SHIFT_U(z) z ^= (z << 7) & TEMPERING_MASK_B; // TEMPERING_SHIFT_S(z)

z ^= (z << 15) & TEMPERING_MASK_C; // TEMPERING_SHIFT_T(z)

z ^= (z >>> 18); // TEMPERING_SHIFT_L(z) return (((long) y) << 32) + (long) z;

}

/** Returns a long drawn uniformly from 0 to n-1. Suffice it to say, n must be > 0, or an IllegalArgumentException is raised. */ public long nextLong(long n) {

if (n <= 0) { throw new IllegalArgumentException("n must be positive, got: " + n);

} long bits, val;

do { int y;

int z; if (mti >= N) // generate N words at one time

{ int kk;



mt[kk] = mt[kk + M] ^ (y >>> 1) ^ mag01[y & 0x1]; } for (; kk < N - 1; kk++) {

y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); mt[kk] = mt[kk + (M - N)] ^ (y >>> 1) ^ mag01[y & 0x1];

} y = (mt[N - 1] & UPPER_MASK) | (mt[0] & LOWER_MASK); mt[N - 1] = mt[M - 1] ^ (y >>> 1) ^ mag01[y & 0x1];

mti = 0;


}



y ^= (y << 15) & TEMPERING_MASK_C; // TEMPERING_SHIFT_T(y) y ^= (y >>> 18); // TEMPERING_SHIFT_L(y)




for (kk = 0; kk < N - M; kk++) { z = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); mt[kk] = mt[kk + M] ^ (z >>> 1) ^ mag01[z & 0x1];

} for (; kk < N - 1; kk++) {

z = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); mt[kk] = mt[kk + (M - N)] ^ (z >>> 1) ^ mag01[z & 0x1]; }


mti = 0; }

z = mt[mti++];

z ^= z >>> 11; // TEMPERING_SHIFT_U(z) z ^= (z << 7) & TEMPERING_MASK_B; // TEMPERING_SHIFT_S(z)


z ^= (z >>> 18); // TEMPERING_SHIFT_L(z) bits = (((((long) y) << 32) + (long) z) >>> 1);

val = bits % n; } while (bits - val + (n - 1) < 0);

return val; }

/** Returns a random double in the half-open range from [0.0,1.0). Thus 0.0 is a valid


result but 1.0 is not. */

public double nextDouble() { int y; int z;





} for (; kk < N - 1; kk++) {



mti = 0; }

y = mt[mti++];






z = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); mt[kk] = mt[kk + M] ^ (z >>> 1) ^ mag01[z & 0x1];




z = (mt[N - 1] & UPPER_MASK) | (mt[0] & LOWER_MASK);

mt[N - 1] = mt[M - 1] ^ (z >>> 1) ^ mag01[z & 0x1]; mti = 0;

}

z = mt[mti++]; z ^= z >>> 11; // TEMPERING_SHIFT_U(z) z ^= (z << 7) & TEMPERING_MASK_B; // TEMPERING_SHIFT_S(z)


z ^= (z >>> 18); // TEMPERING_SHIFT_L(z) /* derived from nextDouble documentation in jdk 1.2 docs, see top */

return ((((long) (y >>> 6)) << 27) + (z >>> 5)) / (double) (1L << 53); }

/** Returns a double in the range from 0.0 to 1.0, possibly inclusive of 0.0 and 1.0 themselves. Thus:

<p><table border=0>

<th><td>Expression<td>Interval <tr><td>nextDouble(false, false)<td>(0.0, 1.0) <tr><td>nextDouble(true, false)<td>[0.0, 1.0)

<tr><td>nextDouble(false, true)<td>(0.0, 1.0] <tr><td>nextDouble(true, true)<td>[0.0, 1.0]

</table> <p>This version preserves all possible random values in the double range.

*/ public double nextDouble(boolean includeZero, boolean includeOne) {

double d = 0.0; do { d = nextDouble(); // grab a value, initially from half-open

[0.0, 1.0) if (includeOne && nextBoolean()) {

d += 1.0; // if includeOne, with 1/2 probability, push to [1.0, 2.0) } } while ((d > 1.0) || // everything above 1.0 is always invalid

(!includeZero && d == 0.0)); // if we're not including zero, 0.0 is invalid

return d; }

public double nextGaussian() { if (__haveNextNextGaussian) {


__haveNextNextGaussian = false;

return __nextNextGaussian; } else { double v1, v2, s;

do { int y;

int z; int a; int b;





} for (; kk < N - 1; kk++) {



mti = 0; }

y = mt[mti++];

y ^= y >>> 11; // TEMPERING_SHIFT_U(y) y ^= (y << 7) & TEMPERING_MASK_B; // TEMPERING_SHIFT_S(y)


y ^= (y >>> 18); // TEMPERING_SHIFT_L(y) if (mti >= N) // generate N words at one time

{ int kk;


for (kk = 0; kk < N - M; kk++) { z = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK);


mt[kk] = mt[kk + M] ^ (z >>> 1) ^ mag01[z & 0x1];




mti = 0; }

z = mt[mti++]; z ^= z >>> 11; // TEMPERING_SHIFT_U(z)

z ^= (z << 7) & TEMPERING_MASK_B; // TEMPERING_SHIFT_S(z)

z ^= (z << 15) & TEMPERING_MASK_C; // TEMPERING_SHIFT_T(z) z ^= (z >>> 18); // TEMPERING_SHIFT_L(z)




for (kk = 0; kk < N - M; kk++) { a = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); mt[kk] = mt[kk + M] ^ (a >>> 1) ^ mag01[a & 0x1];

} for (; kk < N - 1; kk++) {

a = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); mt[kk] = mt[kk + (M - N)] ^ (a >>> 1) ^ mag01[a & 0x1]; }

a = (mt[N - 1] & UPPER_MASK) | (mt[0] & LOWER_MASK); mt[N - 1] = mt[M - 1] ^ (a >>> 1) ^ mag01[a & 0x1];

mti = 0; }

a = mt[mti++];

a ^= a >>> 11; // TEMPERING_SHIFT_U(a) a ^= (a << 7) & TEMPERING_MASK_B; // TEMPERING_SHIFT_S(a)

a ^= (a << 15) & TEMPERING_MASK_C; // TEMPERING_SHIFT_T(a)


a ^= (a >>> 18); // TEMPERING_SHIFT_L(a)




b = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); mt[kk] = mt[kk + M] ^ (b >>> 1) ^ mag01[b & 0x1];

} for (; kk < N - 1; kk++) { b = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK);

mt[kk] = mt[kk + (M - N)] ^ (b >>> 1) ^ mag01[b & 0x1]; }

b = (mt[N - 1] & UPPER_MASK) | (mt[0] & LOWER_MASK); mt[N - 1] = mt[M - 1] ^ (b >>> 1) ^ mag01[b & 0x1];

mti = 0; }

b = mt[mti++]; b ^= b >>> 11; // TEMPERING_SHIFT_U(b)

b ^= (b << 7) & TEMPERING_MASK_B; // TEMPERING_SHIFT_S(b)

b ^= (b << 15) & TEMPERING_MASK_C; // TEMPERING_SHIFT_T(b) b ^= (b >>> 18); // TEMPERING_SHIFT_L(b)

/* derived from nextDouble documentation in jdk 1.2 docs, see top */

v1 = 2 * (((((long) (y >>> 6)) << 27) + (z >>> 5)) / (double) (1L << 53)) - 1;

v2 = 2 * (((((long) (a >>> 6)) << 27) + (b >>> 5)) / (double) (1L << 53))

- 1; s = v1 * v1 + v2 * v2; } while (s >= 1 || s == 0);

double multiplier = StrictMath.sqrt(-2 * StrictMath.log(s) / s); __nextNextGaussian = v2 * multiplier;

__haveNextNextGaussian = true; return v1 * multiplier; }

}


/** Returns a random float in the half-open range from [0.0f,1.0f). Thus 0.0f is

a valid result but 1.0f is not. */ public float nextFloat() {

int y;








}



y ^= (y >>> 18); // TEMPERING_SHIFT_L(y) return (y >>> 8) / ((float) (1 << 24));

}

/** Returns a float in the range from 0.0f to 1.0f, possibly inclusive of 0.0f and 1.0f themselves. Thus:

<p><table border=0> <th><td>Expression<td>Interval

<tr><td>nextFloat(false, false)<td>(0.0f, 1.0f) <tr><td>nextFloat(true, false)<td>[0.0f, 1.0f) <tr><td>nextFloat(false, true)<td>(0.0f, 1.0f]

<tr><td>nextFloat(true, true)<td>[0.0f, 1.0f] </table>


<p>This version preserves all possible random values in the float range. */ public float nextFloat(boolean includeZero, boolean includeOne) {

float d = 0.0f; do {

d = nextFloat(); // grab a value, initially from half-open [0.0f, 1.0f) if (includeOne && nextBoolean()) {

d += 1.0f; // if includeOne, with 1/2 probability, push to [1.0f, 2.0f) }

} while ((d > 1.0f) || // everything above 1.0f is always invalid (!includeZero && d == 0.0f)); // if we're not including zero, 0.0f is invalid

return d; }

/** Returns an integer drawn uniformly from 0 to n-1. Suffice it to say, n must be > 0, or an IllegalArgumentException is raised. */

public int nextInt(int n) { if (n <= 0) {

throw new IllegalArgumentException("n must be positive, got: " + n); }

if ((n & -n) == n) // i.e., n is a power of 2 {

int y; if (mti >= N) // generate N words at one time

{ int kk;



mt[kk] = mt[kk + M] ^ (y >>> 1) ^ mag01[y & 0x1]; } for (; kk < N - 1; kk++) {

y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); mt[kk] = mt[kk + (M - N)] ^ (y >>> 1) ^ mag01[y & 0x1];

} y = (mt[N - 1] & UPPER_MASK) | (mt[0] & LOWER_MASK); mt[N - 1] = mt[M - 1] ^ (y >>> 1) ^ mag01[y & 0x1];

mti = 0;


}




return (int) ((n * (long) (y >>> 1)) >> 31);

} int bits, val;

do { int y;








mti = 0; }




bits = (y >>> 1);


val = bits % n;

} while (bits - val + (n - 1) < 0); return val; }

/**

* Tests the code. */ public static void main(String args[]) {

int j;

MersenneTwisterFast r; // CORRECTNESS TEST

// COMPARE WITH http://www.math.keio.ac.jp/matumoto/CODES/MT2002/mt19937ar.out

r = new MersenneTwisterFast(new int[]{0x123, 0x234, 0x345, 0x456}); System.out.println("Output of MersenneTwisterFast with new (2002/1/26)

seeding mechanism"); for (j = 0; j < 1000; j++) {

// first, convert the int from signed to "unsigned" long l = (long) r.nextInt(); if (l < 0) {

l += 4294967296L; // max int value }

String s = String.valueOf(l); while (s.length() < 10) { s = " " + s; // buffer

} System.out.print(s + " ");

if (j % 5 == 4) { System.out.println(); }

}

// SPEED TEST final long SEED = 4357;

int xx;

long ms; System.out.println("\nTime to test grabbing 100000000 ints");

Random rr = new Random(SEED); xx = 0;


ms = System.currentTimeMillis();

for (j = 0; j < 100000000; j++) { xx += rr.nextInt(); }

System.out.println("java.util.Random: " + (System.currentTimeMillis() - ms) + " Ignore this: " + xx);

r = new MersenneTwisterFast(SEED); ms = System.currentTimeMillis();

xx = 0; for (j = 0; j < 100000000; j++) {

xx += r.nextInt(); } System.out.println("Mersenne Twister Fast: " + (System.currentTimeMillis()

- ms) + " Ignore this: " + xx);

// TEST TO COMPARE TYPE CONVERSION BETWEEN // MersenneTwisterFast.java AND MersenneTwister.java

System.out.println("\nGrab the first 1000 booleans"); r = new MersenneTwisterFast(SEED);

for (j = 0; j < 1000; j++) { System.out.print(r.nextBoolean() + " "); if (j % 8 == 7) {

System.out.println(); }

} if (!(j % 8 == 7)) { System.out.println();

}

System.out.println("\nGrab 1000 booleans of increasing probability using nextBoolean(double)"); r = new MersenneTwisterFast(SEED);

for (j = 0; j < 1000; j++) { System.out.print(r.nextBoolean((double) (j / 999.0)) + " ");


} if (!(j % 8 == 7)) {


System.out.println("\nGrab 1000 booleans of increasing probability using nextBoolean(float)");


r = new MersenneTwisterFast(SEED);

for (j = 0; j < 1000; j++) { System.out.print(r.nextBoolean((float) (j / 999.0f)) + " "); if (j % 8 == 7) {


} if (!(j % 8 == 7)) { System.out.println();

}

byte[] bytes = new byte[1000]; System.out.println("\nGrab the first 1000 bytes using nextBytes"); r = new MersenneTwisterFast(SEED);

r.nextBytes(bytes); for (j = 0; j < 1000; j++) {

System.out.print(bytes[j] + " "); if (j % 16 == 15) { System.out.println();

} }

if (!(j % 16 == 15)) { System.out.println(); }

byte b;

System.out.println("\nGrab the first 1000 bytes -- must be same as nextBytes"); r = new MersenneTwisterFast(SEED);

for (j = 0; j < 1000; j++) { System.out.print((b = r.nextByte()) + " ");

if (b != bytes[j]) { System.out.print("BAD "); }

if (j % 16 == 15) { System.out.println();

} } if (!(j % 16 == 15)) {


System.out.println("\nGrab the first 1000 shorts"); r = new MersenneTwisterFast(SEED);

for (j = 0; j < 1000; j++) { System.out.print(r.nextShort() + " ");


if (j % 8 == 7) {

System.out.println(); } }

if (!(j % 8 == 7)) { System.out.println();

} System.out.println("\nGrab the first 1000 ints");

r = new MersenneTwisterFast(SEED); for (j = 0; j < 1000; j++) {

System.out.print(r.nextInt() + " "); if (j % 4 == 3) { System.out.println();

} }


System.out.println("\nGrab the first 1000 ints of different sizes");

r = new MersenneTwisterFast(SEED); int max = 1; for (j = 0; j < 1000; j++) {

System.out.print(r.nextInt(max) + " "); max *= 2;

if (max <= 0) { max = 1; }


} } if (!(j % 4 == 3)) {


System.out.println("\nGrab the first 1000 longs"); r = new MersenneTwisterFast(SEED);

for (j = 0; j < 1000; j++) { System.out.print(r.nextLong() + " ");


} if (!(j % 3 == 2)) {


System.out.println();

} System.out.println("\nGrab the first 1000 longs of different sizes");

r = new MersenneTwisterFast(SEED); long max2 = 1;

for (j = 0; j < 1000; j++) { System.out.print(r.nextLong(max2) + " "); max2 *= 2;

if (max2 <= 0) { max2 = 1;

} if (j % 4 == 3) { System.out.println();

} }


System.out.println("\nGrab the first 1000 floats");

r = new MersenneTwisterFast(SEED); for (j = 0; j < 1000; j++) { System.out.print(r.nextFloat() + " ");


} } if (!(j % 4 == 3)) {


System.out.println("\nGrab the first 1000 doubles"); r = new MersenneTwisterFast(SEED);

for (j = 0; j < 1000; j++) { System.out.print(r.nextDouble() + " ");


} if (!(j % 3 == 2)) {


System.out.println("\nGrab the first 1000 gaussian doubles"); r = new MersenneTwisterFast(SEED);


for (j = 0; j < 1000; j++) {

System.out.print(r.nextGaussian() + " "); if (j % 3 == 2) { System.out.println();

} }


}

}


LAMPIRAN 3

Kode ASCII – Tabel ASCII

DEC OCT HEX BIN Symbol HTML

Number HTML Name

Description

0 000 00 00000000 NUL Null char

1 001 01 00000001 SOH Start of Heading

2 002 02 00000010 STX Start of Text

3 003 03 00000011 ETX End of Text

4 004 04 00000100 EOT End of Transmission

5 005 05 00000101 ENQ Enquiry

6 006 06 00000110 ACK Acknowledgment

7 007 07 00000111 BEL Bell

8 010 08 00001000 BS Back Space

9 011 09 00001001 HT Horizontal Tab

10 012 0A 00001010 LF
Line Feed

11 013 0B 00001011 VT Vertical Tab

12 014 0C 00001100 FF Form Feed

13 015 0D 00001101 CR Carriage Return

14 016 0E 00001110 SO Shift Out / X-On

15 017 0F 00001111 SI Shift In / X-Off

16 020 10 00010000 DLE Data Line Escape

17 021 11 00010001 DC1 Device Control 1 (oft. XON)

18 022 12 00010010 DC2 Device Control 2

19 023 13 00010011 DC3 Device Control 3 (oft.

XOFF)

20 024 14 00010100 DC4 Device Control 4

21 025 15 00010101 NAK Negative Acknowledgement

22 026 16 00010110 SYN Synchronous Idle

23 027 17 00010111 ETB End of Transmit Block

24 030 18 00011000 CAN Cancel

25 031 19 00011001 EM End of Medium

26 032 1A 00011010 SUB Substitute

27 033 1B 00011011 ESC Escape

28 034 1C 00011100 FS File Separator

29 035 1D 00011101 GS Group Separator

30 036 1E 00011110 RS Record Separator

31 037 1F 00011111 US Unit Separator


32 040 20 00100000 Space

33 041 21 00100001 ! ! Exclamation mark

34 042 22 00100010 " " " Double quotes (or speech marks)

35 043 23 00100011 # # Number

36 044 24 00100100 $ $ Dollar

37 045 25 00100101 % % Procenttecken

38 046 26 00100110 & & & Ampersand

39 047 27 00100111 ' ' Single quote

40 050 28 00101000 ( ( Open parenthesis (or

open bracket)

41 051 29 00101001 ) ) Close parenthesis (or

close bracket)

42 052 2A 00101010 * * Asterisk

43 053 2B 00101011 + + Plus

44 054 2C 00101100 , , Comma

45 055 2D 00101101 - - Hyphen

46 056 2E 00101110 . . Period, dot or full stop

47 057 2F 00101111 / / Slash or divide

48 060 30 00110000 0 0 Zero

49 061 31 00110001 1 1 One

50 062 32 00110010 2 2 Two

51 063 33 00110011 3 3 Three

52 064 34 00110100 4 4 Four

53 065 35 00110101 5 5 Five

54 066 36 00110110 6 6 Six

55 067 37 00110111 7 7 Seven

56 070 38 00111000 8 8 Eight

57 071 39 00111001 9 9 Nine

58 072 3A 00111010 : : Colon

59 073 3B 00111011 ; ; Semicolon

60 074 3C 00111100 < < < Less than (or open

angled bracket)

61 075 3D 00111101 = = Equals

62 076 3E 00111110 > > > Greater than (or

close angled bracket)

63 077 3F 00111111 ? ? Question mark

64 100 40 01000000 @ @ At symbol

65 101 41 01000001 A A Uppercase A

66 102 42 01000010 B B Uppercase B


67 103 43 01000011 C C Uppercase C

68 104 44 01000100 D D Uppercase D

69 105 45 01000101 E E Uppercase E

70 106 46 01000110 F F Uppercase F

71 107 47 01000111 G G Uppercase G

72 110 48 01001000 H H Uppercase H

73 111 49 01001001 I I Uppercase I

74 112 4A 01001010 J J Uppercase J

75 113 4B 01001011 K K Uppercase K

76 114 4C 01001100 L L Uppercase L

77 115 4D 01001101 M M Uppercase M

78 116 4E 01001110 N N Uppercase N

79 117 4F 01001111 O O Uppercase O

80 120 50 01010000 P P Uppercase P

81 121 51 01010001 Q Q Uppercase Q

82 122 52 01010010 R R Uppercase R

83 123 53 01010011 S S Uppercase S

84 124 54 01010100 T T Uppercase T

85 125 55 01010101 U U Uppercase U

86 126 56 01010110 V V Uppercase V

87 127 57 01010111 W W Uppercase W

88 130 58 01011000 X X Uppercase X

89 131 59 01011001 Y Y Uppercase Y

90 132 5A 01011010 Z Z Uppercase Z

91 133 5B 01011011 [ [ Opening bracket

92 134 5C 01011100 \ \ Backslash

93 135 5D 01011101 ] ] Closing bracket

94 136 5E 01011110 ^ ^ Caret - circumflex

95 137 5F 01011111 _ _ Underscore

96 140 60 01100000 ` ` Grave accent

97 141 61 01100001 a a Lowercase a

98 142 62 01100010 b b Lowercase b

99 143 63 01100011 c c Lowercase c

100 144 64 01100100 d d Lowercase d

101 145 65 01100101 e e Lowercase e

102 146 66 01100110 f f Lowercase f

103 147 67 01100111 g g Lowercase g

104 150 68 01101000 h h Lowercase h

105 151 69 01101001 i i Lowercase i


106 152 6A 01101010 j j Lowercase j

107 153 6B 01101011 k k Lowercase k

108 154 6C 01101100 l l Lowercase l

109 155 6D 01101101 m m Lowercase m

110 156 6E 01101110 n n Lowercase n

111 157 6F 01101111 o o Lowercase o

112 160 70 01110000 p p Lowercase p

113 161 71 01110001 q q Lowercase q

114 162 72 01110010 r r Lowercase r

115 163 73 01110011 s s Lowercase s

116 164 74 01110100 t t Lowercase t

117 165 75 01110101 u u Lowercase u

118 166 76 01110110 v v Lowercase v

119 167 77 01110111 w w Lowercase w

120 170 78 01111000 x x Lowercase x

121 171 79 01111001 y y Lowercase y

122 172 7A 01111010 z z Lowercase z

123 173 7B 01111011 { { Opening brace

124 174 7C 01111100 | | Vertical bar

125 175 7D 01111101 } } Closing brace

126 176 7E 01111110 ~ ~ Equivalency sign -

tilde

127 177 7F 01111111 Delete

128 200 80 10000000 € € Euro sign

129 201 81 10000001

130 202 82 10000010 ‚ &sbquo; Single low-9

quotation mark

131 203 83 10000011 ƒ &fnof; Latin small letter f

with hook

132 204 84 10000100 „ &bdquo; Double low-9

quotation mark

133 205 85 10000101 … … Horizontal ellipsis

134 206 86 10000110 † &dagger; Dagger

135 207 87 10000111 ‡ &Dagger; Double dagger

136 210 88 10001000 ˆ &circ; Modifier letter

circumflex accent

137 211 89 10001001 ‰ &permil; Per mille sign

138 212 8A 10001010 Š &Scaron; Latin capital letter S with caron

139 213 8B 10001011 ‹ &lsaquo; Single left-pointing angle quotation


140 214 8C 10001100 Œ &OElig; Latin capital ligature OE

141 215 8D 10001101

142 216 8E 10001110 Ž Latin captial letter Z

with caron

143 217 8F 10001111

144 220 90 10010000

145 221 91 10010001 ‘ ‘ Left single quotation

mark

146 222 92 10010010 ’ ’ Right single quotation mark

147 223 93 10010011 “ “ Left double quotation mark

148 224 94 10010100 ” ” Right double quotation mark

149 225 95 10010101 • • Bullet

150 226 96 10010110 – – En dash

151 227 97 10010111 — — Em dash

152 230 98 10011000 ˜ &tilde; Small tilde

153 231 99 10011001 ™ ™ Trade mark sign

154 232 9A 10011010 š &scaron; Latin small letter S

with caron

155 233 9B 10011011 › &rsaquo; Single right-pointing angle quotation mark

156 234 9C 10011100 œ &oelig; Latin small ligature oe

157 235 9D 10011101

158 236 9E 10011110 ž Latin small letter z

with caron

159 237 9F 10011111 Ÿ ÿ Latin capital letter Y

with diaeresis

160 240 A0 10100000 Non-breaking space

161 241 A1 10100001 ¡ ¡ ¡ Inverted exclamation

mark

162 242 A2 10100010 ¢ ¢ ¢ Cent sign

163 243 A3 10100011 £ £ £ Pound sign

164 244 A4 10100100 ¤ ¤ ¤ Currency sign

165 245 A5 10100101 ¥ ¥ ¥ Yen sign

166 246 A6 10100110 ¦ ¦ ¦ Pipe, Broken vertical

bar

167 247 A7 10100111 § § § Section sign

168 250 A8 10101000 ¨ ¨ ¨ Spacing diaeresis - umlaut

169 251 A9 10101001 © © © Copyright sign


170 252 AA 10101010 ª ª ª Feminine ordinal indicator

171 253 AB 10101011 « « « Left double angle quotes

172 254 AC 10101100 ¬ ¬ ¬ Not sign

173 255 AD 10101101 Soft hyphen

174 256 AE 10101110 ® ® ® Registered trade mark sign

175 257 AF 10101111 ¯ ¯ ¯ Spacing macron -

overline

176 260 B0 10110000 ° ° ° Degree sign

177 261 B1 10110001 ± ± ± Plus-or-minus sign

178 262 B2 10110010 ² ² ² Superscript two -

squared

179 263 B3 10110011 ³ ³ ³ Superscript three -

cubed

180 264 B4 10110100 ´ ´ ´ Acute accent -

spacing acute

181 265 B5 10110101 µ µ µ Micro sign

182 266 B6 10110110 ¶ ¶ ¶ Pilcrow sign -

paragraph sign

183 267 B7 10110111 · · · Middle dot - Georgian

comma

184 270 B8 10111000 ¸ ¸ ¸ Spacing cedilla

185 271 B9 10111001 ¹ ¹ ¹ Superscript one

186 272 BA 10111010 º º º Masculine ordinal

indicator

187 273 BB 10111011 » » » Right double angle

quotes

188 274 BC 10111100 ¼ ¼ ¼ Fraction one quarter

189 275 BD 10111101 ½ ½ ½ Fraction one half

190 276 BE 10111110 ¾ ¾ ¾ Fraction three

quarters

191 277 BF 10111111 ¿ ¿ ¿ Inverted question mark

192 300 C0 11000000 À À À Latin capital letter A with grave

193 301 C1 11000001 Á Á Á Latin capital letter A with acute

194 302 C2 11000010 Â Â Â Latin capital letter A with circumflex

195 303 C3 11000011 Ã Ã Ã Latin capital letter A

with tilde

196 304 C4 11000100 Ä Ä Ä Latin capital letter A

with diaeresis


197 305 C5 11000101 Å Å Å Latin capital letter A with ring above

198 306 C6 11000110 Æ Æ Æ Latin capital letter AE

199 307 C7 11000111 Ç Ç Ç Latin capital letter C

with cedilla

200 310 C8 11001000 È È È Latin capital letter E

with grave

201 311 C9 11001001 É É É Latin capital letter E

with acute

202 312 CA 11001010 Ê Ê Ê Latin capital letter E with circumflex

203 313 CB 11001011 Ë Ë Ë Latin capital letter E with diaeresis

204 314 CC 11001100 Ì Ì Ì Latin capital letter I with grave

205 315 CD 11001101 Í Í Í Latin capital letter I with acute

206 316 CE 11001110 Î Î Î Latin capital letter I

with circumflex

207 317 CF 11001111 Ï Ï Ï Latin capital letter I

with diaeresis

208 320 D0 11010000 Ð Ð Ð Latin capital letter

ETH

209 321 D1 11010001 Ñ Ñ Ñ Latin capital letter N

with tilde

210 322 D2 11010010 Ò Ò Ò Latin capital letter O

with grave

211 323 D3 11010011 Ó Ó Ó Latin capital letter O with acute

212 324 D4 11010100 Ô Ô Ô Latin capital letter O with circumflex

213 325 D5 11010101 Õ Õ Õ Latin capital letter O with tilde

214 326 D6 11010110 Ö Ö Ö Latin capital letter O with diaeresis

215 327 D7 11010111 × × × Multiplication sign

216 330 D8 11011000 Ø Ø Ø Latin capital letter O

with slash

217 331 D9 11011001 Ù Ù Ù Latin capital letter U with grave

218 332 DA 11011010 Ú Ú Ú Latin capital letter U with acute

219 333 DB 11011011 Û Û Û Latin capital letter U with circumflex

220 334 DC 11011100 Ü Ü Ü Latin capital letter U with diaeresis


221 335 DD 11011101 Ý Ý Ý Latin capital letter Y with acute

222 336 DE 11011110 Þ Þ Þ Latin capital letter THORN

223 337 DF 11011111 ß ß ß Latin small letter sharp s - ess-zed

224 340 E0 11100000 à à à Latin small letter a

with grave

225 341 E1 11100001 á á á Latin small letter a

with acute

226 342 E2 11100010 â â â Latin small letter a

with circumflex

227 343 E3 11100011 ã ã ã Latin small letter a

with tilde

228 344 E4 11100100 ä ä ä Latin small letter a

with diaeresis

229 345 E5 11100101 å å å Latin small letter a

with ring above

230 346 E6 11100110 æ æ æ Latin small letter ae

231 347 E7 11100111 ç ç ç Latin small letter c

with cedilla

232 350 E8 11101000 è è è Latin small letter e

with grave

233 351 E9 11101001 é é é Latin small letter e

with acute

234 352 EA 11101010 ê ê ê Latin small letter e

with circumflex

235 353 EB 11101011 ë ë ë Latin small letter e with diaeresis

236 354 EC 11101100 ì ì ì Latin small letter i with grave

237 355 ED 11101101 í í í Latin small letter i with acute

238 356 EE 11101110 î î î Latin small letter i with circumflex

239 357 EF 11101111 ï ï ï Latin small letter i with diaeresis

240 360 F0 11110000 ð ð ð Latin small letter eth

241 361 F1 11110001 ñ ñ ñ Latin small letter n with tilde

242 362 F2 11110010 ò ò ò Latin small letter o with grave

243 363 F3 11110011 ó ó ó Latin small letter o with acute

244 364 F4 11110100 ô ô ô Latin small letter o with circumflex


245 365 F5 11110101 õ õ õ Latin small letter o with tilde

246 366 F6 11110110 ö ö ö Latin small letter o with diaeresis

247 367 F7 11110111 ÷ ÷ ÷ Division sign

248 370 F8 11111000 ø ø ø Latin small letter o

with slash

249 371 F9 11111001 ù ù ù Latin small letter u

with grave

250 372 FA 11111010 ú ú ú Latin small letter u with acute

251 373 FB 11111011 û û û Latin small letter u with circumflex

252 374 FC 11111100 ü ü ü Latin small letter u with diaeresis

253 375 FD 11111101 ý ý ý Latin small letter y with acute

254 376 FE 11111110 Ϸ þ þ Latin small letter

thorn

255 377 FF 11111111 ÿ ÿ ÿ Latin small letter y

with diaeresis
