IMPLEMENTASI ENKRIPSI DAN DEKRIPSI DOKUMEN MENGGUNAKAN ALGORITMA ONE TIME PAD DENGAN PEMBANGKIT BILANGAN ACAK MERSENNE TWISTER

PLAGIAT PLAGIATMERUPAKAN MERUPAKANTINDAKAN TINDAKANTIDAK TIDAKTERPUJI TERPUJI

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

i


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

ii




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


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 1


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).

2


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)

3


1.6 Sistematika Penulisan BAB I PENDAHULUAN Berisi

latar

penulisan,

belakang batasan

masalah,

masalah,

rumusan

masalah,

metodologi

penulisan,

tujuan 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.

4


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: Kunci

Plaintext

Enkripsi

Ciphertext

Dekripsi

Plaintext

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) 5


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 mekanisme

(Cryptanalysist), kriptografi

dengan 6

merupakan cara

aksi

memecahkan

menganalisisnya

untuk


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) 7

hanya


diketahui oleh pihak yang sah (Raharjo, 2002). Contohnya RSA, Elgamal, Diffie-Hellman. Kunci Publik

Plaintext

Kunci Privat

Enkripsi

Ciphertext

Dekripsi

Plaintext

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 8

mendekripsikan karakter-


dkarakter

ciphertext

menjadi karakter-karakter

plaintext

dengan

persamaan: pi = (ci – ki) mod 256

2.5

(2.2)

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 : 9


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.

10


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). Bilangan acak semu

PRNG

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 : 11


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).

12


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. 13


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.

14


Mulai

Cari plaintext

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.

15


Mulai

Cari ciphertext

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 16


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

Insialisasi data

i=0

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

Ya

i < message.length

Tidak

Return

End

Gambar 3.3 Algoritma Enkripsi 17


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.

18


Start

Insialisasi im

Insialisasi ik

Inisialisasi data

i=0

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

Ya

i < message.length

Tidak

Return

End

Gambar 3.4 Algoritma Dekripsi 19


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

20


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 “Simpan”

hasil enkripsi serta lamanya proses enkripsi.

yang

digunakan

untuk

menyimpan

hasil

enkripsi.

“Kembali” yang digunakan untuk kembali ke halaman awal.

21

Button Button


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”

Button

yang

digunakan

untuk

menyimpan

hasil

dekripsi.

“Kembali” yang digunakan untuk kembali ke halaman awal.

22


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; 23


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

TEKNOLOGI

24

FAKULTAS

SAINS

DAN


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 25


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.

26


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 27


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 28


“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.

29


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 30


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

31


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 : 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); } 2. Proses Enkripsi Berikut baris – baris perintah untuk proses enkripsi : 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; } 3. Proses Enkripsi return new String(intArrayToChar(data)); Berikut baris – baris perintah untuk proses dekripsi : }

32


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; } return new String(intArrayToChar(data)); } 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

8

Tujuan penelitian ini adalah untuk mengimplementasikan algoritma One Time Pad untuk mengenkripsi dan mendekripsi berkas dokumen (.txt,.doc) dan Mersenne Twister sebagai pembangkit kunci. MersenneTwisterFast other = (MersenneTwisterFast) o;

9

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

10

Batasan masalah dalam penelitian ini adalah:

33


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[PSyMHeKgUfEi@\6l

2

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

]_IU8Ug6VnX7d7W

4

5i85KP=z;SprP]ETktbFm8<SMqhecZOOIW_9
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); Allah Bapa sungguh besar kasih Mu,, Engkau selalu hadir dalam setiap

3

langkah ku,, 4

Universitas Sanata Dharma

34


5

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

6

Algoritma penyandian

7

Algoritma

8 9

FileWriter outFile = new FileWriter(f); PrintWriter out = new PrintWriter(outFile, true); 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>
3

ZyHIoUlQc4rVIIE3Z`ruP7Huo\LgURJ_KH]gV6i6mPN\7`[OhJgLbW7A vWCV
4

NlF>WeBv6P]b4O6dMH3Y\x_TYWgU@

5

5TQEk]hNLM^5kGrAv]UiôOa@

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

35


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

ÉÃÎÎ-ª»´ÃÜã¬°-Ö×ëÑÇÐ ÎÓßàÉ¶¤ç|âÓÅÁÄ¶¡¼ï¨ÂáÇ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^ 36


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

Hasil

Huruf /

(pi + ki) mod 256

Penjumlahan

Simbol

(85 + 56) mod 256

141

(no symbol)

37


(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±ÃÎ˜ÏÙ‰|Ç·ãÜ¶

38


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

Hasil

Huruf /

(ci - ki) mod 256

Pengurangan

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

39


(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

40


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

41


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 Lama proses berformat

No

Nama File

1 2 3

file1 file2 file3

0,01072 0,00244338 0,00281067

0,00322326 0,00358603 0,00488268

4 5 6 7

file4 file5 file6 file7

0,00488268 0,00374817 0,00401131

0,00282336 0,00223776 0,00228939

0,00130253

0,00040896

.txt

.doc

42


8 9

file8 file9

10

file10 Rata - rata

0,00162997 0,00041847 0,00024954 0,00322

0,00191756 0,00037001 0,0003211 0,002206011

Tabel 4.12 Lama Proses Dekripsi No

Nama File

1 2 3

file1 file2 file3

4 5 6 7 8 9 10

file4 file5 file6 file7 file8 file9 file10 Rata - rata

Lama proses berformat .txt

.doc

0,004684768 0,002670282 0,002136769 0,000336955

0,002998179 0,001715574 0,001937946 0,001612767

0,000454256 0,005159856 0,003030788

0,002295283 0,001222822 0,000376358

0,002007693 0,003011313 0,002533507

0,002003617 0,000502716 0,001274905

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. 43


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 44


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

45


LAMPIRAN

46


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





Key





Key





Key





Key





Key





Key





Key





Key




B. Uji Coba Berkas Dokumen Berformat .doc 1. Pengujian 01 : Berkas asli

Key





Key





Key





Key





Key





Key





Key





Key





Key





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.LEADI NG) .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(); }//


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 private private private private private private

javax.swing.JButton jButton1; javax.swing.JButton jButton2; javax.swing.JLabel jLabel1; javax.swing.JLabel jLabel2; javax.swing.JLabel jLabel3; javax.swing.JLabel jLabel4; javax.swing.JPanel jPanel1;

}

2. Implementasi Kelas HalamanEnkripsi.java package skripsiotp; import import import import import import import import import import import

java.io.BufferedReader; java.io.BufferedWriter; java.io.File; java.io.FileInputStream; java.io.FileNotFoundException; java.io.FileOutputStream; java.io.FileReader; java.io.FileWriter; java.io.IOException; java.io.PrintWriter; java.util.logging.Level;


import import import import import

java.util.logging.Logger; javax.swing.JFileChooser; javax.swing.JOptionPane; javax.swing.filechooser.FileNameExtensionFilter; 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();

setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE); 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()) .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(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) .addGap(9, 9, 9) .addComponent(jLabel3) .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) .addComponent(jScrollPane1, javax.swing.GroupLayout.PREFERRED_SIZE, 65, javax.swing.GroupLayout.PREFERRED_SIZE) .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.Alignm ent.BASELINE) .addComponent(jLabel5) .addComponent(LamaEnkrip, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE) .addComponent(jLabel6)) .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, 18, Short.MAX_VALUE) .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignm ent.BASELINE) .addComponent(simpanEnkripsi) .addComponent(jButton1)) .addContainerGap())


.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignm ent.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(); }// 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 private private private private private private private private private private private private private private private private private private

javax.swing.JButton GenerateKey; javax.swing.JTextField LamaEnkrip; javax.swing.JButton PlainButton; javax.swing.JTextArea enkripsiKey; javax.swing.JTextArea hasilEnkripsi; javax.swing.JButton jButton1; javax.swing.JLabel jLabel1; javax.swing.JLabel jLabel2; javax.swing.JLabel jLabel3; javax.swing.JLabel jLabel4; javax.swing.JLabel jLabel5; javax.swing.JLabel jLabel6; javax.swing.JPanel jPanel1; javax.swing.JScrollPane jScrollPane1; javax.swing.JScrollPane jScrollPane2; javax.swing.JScrollPane jScrollPane3; javax.swing.JTextArea plainArea; javax.swing.JButton prosesEnkripsi; javax.swing.JButton simpanEnkripsi;

} 3. Implementasi Kelas HalamanDekripsi.java package skripsiotp; import import import import import import import import import import import import import import import

java.io.BufferedReader; java.io.BufferedWriter; java.io.File; java.io.FileFilter; java.io.FileNotFoundException; java.io.FileOutputStream; java.io.FileReader; java.io.FileWriter; java.io.IOException; java.io.PrintWriter; java.util.logging.Level; java.util.logging.Logger; javax.swing.JFileChooser; javax.swing.JOptionPane; 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();

setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE); 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.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(prosesDekripsi) .addPreferredGap(javax.swing.LayoutStyle.ComponentPlace ment.RELATED, 330, Short.MAX_VALUE) .addComponent(KeyButton) .addContainerGap()) .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, jPanel1Layout.createSequentialGroup() .addComponent(CipherButton) .addContainerGap()) .addGroup(jPanel1Layout.createSequentialGroup() .addComponent(jLabel5) .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) .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()) .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(CipherButton) .addGap(9, 9, 9) .addComponent(jLabel3) .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) .addComponent(jScrollPane1, javax.swing.GroupLayout.PREFERRED_SIZE, 65, javax.swing.GroupLayout.PREFERRED_SIZE)


.addGap(18, 18, 18) .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignm ent.BASELINE) .addComponent(prosesDekripsi) .addComponent(KeyButton)) .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.Alignm ent.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.Alignm ent.LEADING) .addGroup(jPanel1Layout.createSequentialGroup() .addGap(41, 41, 41) .addComponent(jScrollPane2, javax.swing.GroupLayout.PREFERRED_SIZE, 65, javax.swing.GroupLayout.PREFERRED_SIZE) .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.LEA DING) .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(); }// 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(Le vel.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 private private private private private private private private private private private private private private private private private private

javax.swing.JButton CipherButton; javax.swing.JButton KeyButton; javax.swing.JTextField LamaDekripsi; javax.swing.JTextArea cipherArea; javax.swing.JTextArea dekripsiKey; javax.swing.JTextArea hasilDekripsi; javax.swing.JButton jButton1; javax.swing.JLabel jLabel1; javax.swing.JLabel jLabel2; javax.swing.JLabel jLabel3; javax.swing.JLabel jLabel4; javax.swing.JLabel jLabel5; javax.swing.JLabel jLabel6; javax.swing.JPanel jPanel1; javax.swing.JScrollPane jScrollPane1; javax.swing.JScrollPane jScrollPane2; javax.swing.JScrollPane jScrollPane3; javax.swing.JButton prosesDekripsi; 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; } return new String(intArrayToChar(data)); } 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; } return new String(intArrayToChar(data)); } 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 = 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 (short) (y >>> 16); } public char nextChar() { 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 (char) (y >>> 16); } public boolean nextBoolean() { 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 (boolean) ((y >>> 31) != 0); } /** This generates a coin flip with a probability probability of returning true, else returning false. probability 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 probability of returning true, else returning false. probability 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 } 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) 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++) { 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; 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 (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 { 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) bytes[x] = (byte) (y >>> 24); } }


public long nextLong() { int y; int z; 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) 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++) { 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) 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; 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) 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++) { 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) 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; 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) 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++) { 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); } /** Returns a double in the range from 0.0 to 1.0, possibly inclusive of 0.0 and 1.0 themselves. Thus:

Expression Interval
nextDouble(false, false) (0.0, 1.0)
nextDouble(true, false) [0.0, 1.0)
nextDouble(false, true) (0.0, 1.0]
nextDouble(true, true) [0.0, 1.0]

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; 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) 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++) { 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) 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++) { 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)

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++) { 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; 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)); } /** Returns a float in the range from 0.0f to 1.0f, possibly inclusive of 0.0f and 1.0f themselves. Thus:

Expression Interval
nextFloat(false, false) (0.0f, 1.0f)
nextFloat(true, false) [0.0f, 1.0f)
nextFloat(false, true) (0.0f, 1.0f]
nextFloat(true, true) [0.0f, 1.0f]


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; 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 (int) ((n * (long) (y >>> 1)) >> 31); } int bits, val; do { 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) 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(); } } if (!(j % 8 == 7)) { System.out.println(); } 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) { System.out.println(); } } 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(); } 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(); } } 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(); } } if (!(j % 4 == 3)) { System.out.println(); } 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(); } } 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(); } } 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(); } } if (!(j % 4 == 3)) { System.out.println(); } 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(); } } if (!(j % 3 == 2)) { System.out.println(); } 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(); } } if (!(j % 3 == 2)) { System.out.println(); } } }


LAMPIRAN 3 Kode ASCII – Tabel ASCII DEC

OCT

HEX

BIN

Symbol

HTML Number

HTML Name

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

Description


32

040

20

00100000

Space

33

041

21

00100001

!

!

Exclamation mark

34

042

22

00100010

"

"

35

043

23

00100011

#

#

Number

36

044

24

00100100

$

$

Dollar

37

045

25

00100101

%

%

Procenttecken

38

046

26

00100110

&

&

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

<

<

61

075

3D

00111101

=

=

62

076

3E

00111110

>

>

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

"

&

<

Double quotes (or speech marks)

Ampersand

Less than (or open angled bracket) Equals

>

Greater than (or close angled bracket)


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

129

201

81

10000001

130

202

82

131

203

132

€

€

€

10000010

‚

‚

‚

83

10000011

ƒ

ƒ

ƒ

204

84

10000100

„

„

„

Double low -9 quotation mark

133

205

85

10000101

…

…

…

Horizontal ellipsis

134

206

86

10000110

†

†

† Dagger

135

207

87

10000111

‡

‡

‡ Double dagger

136

210

88

10001000

ˆ

ˆ

137

211

89

10001001

‰

‰

‰ Per mille sign

138

212

8A

10001010

Š

Š

Š

Latin capital letter S with caron

139

213

8B

10001011

‹

‹

‹

Single left-pointing angle quotation

ˆ

Euro sign Single low -9 quotation mark Latin small letter f with hook

Modifier letter circumflex accent


140

214

8C

10001100

141

215

8D

10001101

142

216

8E

10001110

143

217

8F

10001111

144

220

90

10010000

145

221

91

146

222

147

Œ

Latin capital ligature OE

Œ

Œ

Ž

Ž

10010001

‘

‘

‘

Left single quotation mark

92

10010010

’

’

’

Right single quotation mark

223

93

10010011

“

“

“

Left double quotation mark

148

224

94

10010100

”

”

”

Right double quotation mark

149

225

95

10010101

•

•

•

150

226

96

10010110

–

–

– En dash

151

227

97

10010111

—

—

— Em dash

152

230

98

10011000

˜

˜

˜

153

231

99

10011001

™

™

™ Trade mark sign

154

232

9A

10011010

š

š

š

Latin small letter S with caron

155

233

9B

10011011

›

›

›

Single right-pointing angle quotation mark

156

234

9C

10011100

œ

œ

œ

157

235

9D

10011101

158

236

9E

10011110

ž

ž

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

¥

¥

¥

166

246

A6

10100110

¦

¦

¦

167

247

A7

10100111

§

§

§

Section sign

168

250

A8

10101000

¨

¨

¨

Spacing diaeresis umlaut

169

251

A9

10101001

©

©

©

Latin captial letter Z with caron

Bullet

Small tilde

Latin small ligature oe Latin small letter z with caron

Yen sign Pipe, Broken vertical bar

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

±

±

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

·

·

·

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

± Plus-or-minus sign

Middle dot - Georgian comma


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

	Expression	Interval
nextDouble(false, false)	(0.0, 1.0)
nextDouble(true, false)	[0.0, 1.0)
nextDouble(false, true)	(0.0, 1.0]
nextDouble(true, true)	[0.0, 1.0]

	Expression	Interval
nextFloat(false, false)	(0.0f, 1.0f)
nextFloat(true, false)	[0.0f, 1.0f)
nextFloat(false, true)	(0.0f, 1.0f]
nextFloat(true, true)	[0.0f, 1.0f]

IMPLEMENTASI ENKRIPSI DAN DEKRIPSI DOKUMEN MENGGUNAKAN ALGORITMA ONE TIME PAD DENGAN PEMBANGKIT BILANGAN ACAK MERSENNE TWISTER

Recommend Documents