1. libelgamal.py - Simulasi Pencarian Kunci Privat dengan Algoritma Silver-Pohlig-Hellaman pada Algoritma Kriptografi Elgamal

(1)

LISTING PROGRAM

1. lib/elgamal.py

import random import base64

from .myprime import MyPrime from .dlpModule import DLP

class ElGamal: delimeter = 100

def bangkitkanKunci(self, panjang): my = MyPrime()

a = 0 b = 0 p = 0 d = 0

#1. tentukan bilangan prima p dengan batas min dan max p = my.primeGenerateLen(panjang)

print('prime: ', p)

#2. Temukan primitive root a = self.findPrimitiveRoot(p)

#3. ambil d dengan syarat 1 <= d <= p - 2 d = random.randint(2, p-2)

#4. Hitung b = a pangkat d mod p. b = my.modExp(a, d, p)

key = ElGamalKey(a, b, p, d) return key

def enkripsi(self, message, pubKeyA, pubKeyB, pubKeyP): delimeter = chr(self.delimeter)

my = MyPrime() #z dipilih acak

# z = random.randint(2, pubKeyP-1) z = 143

C1 = my.modExp(pubKeyA, z, pubKeyP) C2 = ''

#ubah ke kode ascii for item in message: print(item)

message = message.encode('ascii') for item in message:

print(item) for c in message:

print('plainchar: ', c) # enkripsi

cipchar = my.modExp(c * my.modExp(pubKeyB, z, pubKeyP), 1, pubKeyP)

print('cipchar: ', cipchar) #print('cipchar: ', cipchar) # jadikan list

(2)

def dekripsi(self, C1, C2, pubKeyP, privKeyD): delimeter = chr(self.delimeter)

my = MyPrime() plainText = ''

myCiphList = C2.split(delimeter) for cipChar in myCiphList:

if(cipChar == ''): continue

myint = int(cipChar)

#print('cipchar code: ', myint)

plainchar = my.modExp(myint * my.modExp(C1, (pubKeyP - 1 - privKeyD), pubKeyP), 1, pubKeyP)

#print('plainchar code: ', plainchar) plainchar = chr(plainchar)

plainText = plainText + plainchar return plainText

def findPrimitiveRoot(self, prime): myp = MyPrime()

dlp = DLP() s = prime - 1

distinctPrimes = dlp.findDistinctPrimes(s)

# Hasil distinct primes dimasukkan ke dalam Array p = getattr(distinctPrimes, "pj")

power = getattr(distinctPrimes, "aj")

print('berikut ini adalah faktor bilangan prima berbeda dari p-1')

for item in p:

print(item, '^', power[item])

testlist = []

for item in p:

testlist.append(s // item)

print('elemen di dalam testlist: ') for item in testlist:

print(item)

pr = 2

passed = False while(not passed): passed = True

for item in testlist:

temp = myp.modExp(pr, item, prime) if(temp == 1):

pr = pr + 1 passed = False break

return pr

class ElGamalKey: pubKeyA = 0 pubKeyB = 0 pubKeyP = 0 privKeyD = 0

(3)

self.pubKeyA = a self.pubKeyB = b self.pubKeyP = p self.privKeyD = d

class ElGamalConverter:

def stringToPubKey(self, mystring): keyList = mystring.split(';') keyDict = {}

for key in keyList: if key[0] == 'p':

keyDict['p'] = key[1:] if key[0] == 'a':

keyDict['a'] = key[1:] if key[0] == 'b':

keyDict['b'] = key[1:] return keyDict

def stringToPrivKey(self, mystring): keyList = mystring.split(';') keyDict = {}

for key in keyList: if key[0] == 'p':

keyDict['p'] = key[1:] if key[0] == 'd':

keyDict['d'] = key[1:] return keyDict

def stringToMessage(self, mystring): messageList = mystring.split(chr(95)) return messageList

class ElGamalCipherText: cipherText1 = '' cipherText2 = 0

def __init__(self, c1, c2): self.cipherText1 = c1 self.cipherText2 = c2

2. lib/myprime.py

import random

class MyPrime:

# men-generate bilangan prima antara batasmin dan batasmax def primeGenerate(self, batasMin, batasMax):

x = random.randint(batasMin, batasMax) #Belum selesai

while(not self.rabinMillerPrimeTest(x)): x = random.randint(batasMin, batasMax) return x

# men-generate bilangan prima dengan panjang tertentu def primeGenerateLen(self, length):

x = self.getRandomByLen(length) #Belum selesai

(4)

# print('x: ', x) return x

# pengetesan bilangan prima menggunakan # algoritma miller rabin

def rabinMillerPrimeTest(self, n): nmin1 = n-1

s = self.getSForEksponen(nmin1) d = nmin1 / (2 ** s)

d = int(d)

certainty = int(len(str(n))) for i in range (0, certainty): nmin2 = n - 2

if(nmin2 < 2): nmin2 = 2

a = random.randint(2, nmin2) x = self.modExp(a, d, n) if((x == 1) or (x == n-1)): continue

for j in range (0, s - 1): x = (x ** 2) % n

if(x == 1): return False if(x == n-1): continue return False return True

# mencari gcd dua buah bilangan # menggunakan euclidean algorithm def gcdEuclidean(self, a, b): x = 0

while(b != 0): x = a % b a = b b = x return a

# Mencari inversi modulo # m adalah pemodulo

def inversMod(self, x, m): i = 1

while(((x * i) % m) != 1): i = i + 1

return i

# Fast Modular Exponentiation -vyn

# dihitung dengan cara memecah pangkat menjadi basis 2 # kemudian menjumlahkan hasil perkaliannya.

def modExp(self, x, e, p): binb = bin(e)[2:] bin1 = []

index = 0

# dapatkan index yang bernilai 1 dari binary for item in binb:

if (int(item) == 1):

(5)

index = index + 1

# mendapatkan list a^x mod p dengan x mulai dari 1 sampai panjang binary

modpowbin = []

modpowbin.append(x % p)

for i in range(1, len(binb) + 1):

temp = (modpowbin[i - 1] * modpowbin[i - 1]) % p modpowbin.append(temp)

# Menghitung hasil akhir. result = 1

for item in bin1:

result = result * modpowbin[item] result = result % p

return result

#langkah pertama dalam algoritma miller rabin #adalah mencari nilai d * 2^s untuk n-1

#method ini untuk mencari nilai s. def getSForEksponen(self, xmin1): x = 0

while(((xmin1 % 2) == 0) and (xmin1 > 0)): xmin1 = xmin1 / 2

x = x + 1 return x

# Men-generate bilangan random dengan panjang digit # yang ditetapkan

# Parameter: length = panjang digit def getRandomByLen(self, length): length = int(length)

x = ''

for i in range(0, length):

randnum = random.randint(0, 9) if(i == 0):

# bilangan paling kiri tidak boleh 0 while(randnum == 0):

randnum = random.randint(0,9) if(i == (length - 1)):

# bilangan random yang diminta tidak boleh ganjil while ((randnum%2) == 0):

randnum = random.randint(1,9) x = x + str(randnum)

return int(x)

3. lib/dlpModule.py

from .myprime import MyPrime

class DLP:

# dengan algoritma Silver-Pohlig-Hellman def shpDiscreteLog(self, base, B, prime): myPrime = MyPrime()

primeMin1 = prime - 1

#print('start to find distinct primes') # temukan faktor distinct primes

(6)

# Hasil distinct primes dimasukkan ke dalam Array pj = getattr(distinctPrimes, "pj")

aj = getattr(distinctPrimes, "aj")

'''

for item in pj:

print(item, ' : ', aj[item]) print('distinct primes found') '''

# parameter index untuk iterasi j = 0

# hitung nilai e untuk setiap pj ej = []

# indeks j sebagai acuan index = 0

j = 1

for item in pj:

#input('Menghitung nilai e, press enter..')

ejtemp = self.finde(base, item, aj[item], B, prime, j) ej.append(ejtemp)

#print('++++++++++++++++++++++++')

#print('e', j, ' ditemukan: ', ej[index]) #print('++++++++++++++++++++++++')

j = j + 1

index = index + 1 # deret e telah didapat

#print('pencarian e selesai')

# deret pemodulo dari e yang akan digunakan dalam perhitungan CRT

# pada akhir perhitungan SHP ejm = []

for i in range(0, len(pj)): ejmtemp = pj[i] ** aj[pj[i]] ejm.append(ejmtemp)

# list untuk mencari lcm ejmcrt = []

for item in ejm:

ejmcrt.append(item) e = self.chineseRT(ej, ejm)

e = e % self.lcm(ejmcrt)

reval = HasilSHP(ej, ejm, e)

return reval

def finde(self, base, pj, aj, B, prime, j):

# deret b akan digunakan dalam perhitungan mencari deret nilai e

b = []

B0 = B

# ini adalah b0

(7)

# Lakukan iterasi untuk setiap item mulai dari b[1] dst. for i in range(1, aj):

bi = self.findb(base, B, pj, aj, prime, b, i, j) b.append(bi)

# deret b telah didapat

# Cari nilai e dengan men-sum kan deret b e = 0

for i in range(0, aj):

e = e + (b[i]) * (pj ** i)

e = e % (pj ** aj) return e

def findbzero(self, base, B0, pj, prime): myPrime = MyPrime()

k = 0

pangkatBase = (prime - 1) * k // pj pangkatB0 = (prime - 1) // pj

# Pengecekan apakah pembagian pangkat berupa # bilangan bulat, jika tidak, maka cari bilangan # bulat yang setara

tempBase = (prime - 1) * k % pj tempB0 = (prime - 1) % pj

# jaga2 saja, jika tidak habis dibagi if(tempBase != 0):

# jika hasil pembagian tidak 0 maka harus menemukan bilangan x yang

# kongruen terhadap ((prime - 1) * k) % item pangkatBase = 1

m = (prime - 1) * k % prime n = pj % prime

# selama masih belum kongruen, temukan x yang memenuhi while(m != n):

pangkatBase = pangkatBase + 1 n = (item * pangkata) % prime

if(tempB0 != 0):

# kongruen terhadap ((prime - 1) * k) % item pangkatB0 = 1

m = (prime - 1) * k % prime n = pj % prime

pangkatB0 = pangkatB0 + 1

n = (pj * pangkatB0) % prime

# pada tahap ini, pangkat alpha dan B0 yang sesuai telah ditemukan

# selanjutnya lakukan iterasi sampai didapati k yang tepat m = myPrime.modExp(base, pangkatBase, prime)

(8)

# Jika masih belum sama, maka ganti pangkat dengan # menaikkan nilai k

while(m != n): k = k + 1

# pastikan terlebih dahulu bahwa pangkat masing-masing # sisi (alpha dan BO) berupa bilangan bulat

pangkatBase = (prime - 1) * k // pj tem = ((prime - 1) * k) % pj

if (tem != 0):

# jika hasil pembagian tidak 0

# maka harus menemukan bilangan x yang

# kongruen terhadap ((prime - 1) * k) % item x = 1

p = (prime-1) * k % prime q = (pj * x) % prime

#selama masih belum kongruen, temukan x yang memenuhi

while(p != q): x = x + 1

q = (pj * x) % prime

# setelah ditemukan x yang tepat, maka pangkatBase adalah x

pangkatBase = x

m = myPrime.modExp(base, pangkatBase, prime) #k adalah b0

return k

''' Parameter: deret b, pj, dan indeks i ''' def findb(self, base, B, pj, aj, prime, b, i, j): myPrime = MyPrime()

'''Temukan B[i]'''

# Tentukan pangkat dari alpha sigma = 0

for k in range(0, i):

sigma = sigma + (b[k]) * (pj ** k)

# untuk mencari invers, pangkat harus 1 tempBase = base

if(sigma != 1):

tempBase = base ** sigma sigma = -1

invTempBase = myPrime.inversMod(tempBase, prime) Bi = (B * invTempBase) % prime

'''Bi didapat'''

k = 0

'''Cari nilai k yang berarti bi''' pangkatBase = (prime - 1) * k // pj

pangkatBi = (prime - 1) // (pj ** (i + 1))

# DISINI HARUSNYA DIBERI KONDISI JIKA PEMBAGIAN PANGKAT # TIDAK HABIS

tempBase = (prime - 1) * k % pj

tempBi = (prime - 1) % (pj ** (i + 1))

if(tempBase != 0):

(9)

if(tempBi != 0):

input('PANGKAT Bi TIDAK HABIS DIBAGI')

m = myPrime.modExp(base, pangkatBase, prime) n = myPrime.modExp(Bi, pangkatBi, prime)

while(m != n): k = k + 1

pangkatBase = ((prime - 1) * k) // pj tempBase = ((prime - 1) * k) % pj if(tempBase != 0):

input('PANGKAT BASE TIDAK HABIS DIBAGI') if (tempBase != 0):

x = 1

p = ((prime-1) * k) % prime q = (item * x) % prime while(p != q):

x = x + 1

q = (item * x) % prime

pangkatBase = x m = myPrime.modExp(base, pangkatBase, prime) '''bi pangkat j didapat'''

return k

# mencari faktorisasi distinct primes def findDistinctPrimes(self, primeMin1): # pj dan aj akan diisi pada atribut reval pj = [] # list

aj = {} # dictionary

# metode trivial pembagi = 2 eksponen = 0

# coba pembagian 2, selanjutnya dimulai dari 3 # dengan increment 2

if(((primeMin1 % pembagi) == 0) and (pembagi < (primeMin1 / 2))):

pj.append(pembagi)

while((primeMin1 % pembagi) == 0): primeMin1 = primeMin1 // pembagi eksponen = eksponen + 1

aj[pembagi] = eksponen

# mulai dari sini pembagi dimulai dari 3 pembagi = pembagi + 1

lastpembagi = pembagi # reset eksponen eksponen = 0

# selama pembagi masih < primeMin1 / 2 while(pembagi < (primeMin1 / 2)): while((primeMin1 % pembagi) == 0): primeMin1 = primeMin1 // pembagi lastpembagi = pembagi

eksponen = eksponen + 1 if(eksponen > 0):

(10)

eksponen = 0

# setelah tidak bisa dibagi lagi,

# pembagi dinaikkan valuenya dengan range 2 pembagi = pembagi + 2

if(primeMin1 > 1):

pj.append(primeMin1) aj[primeMin1] = 1

reval = DistinctPrimes() # Set attribute

setattr(reval, 'pj', pj) setattr(reval, 'aj', aj) return reval

def chineseRT(self, listA, listMod): myPrime = MyPrime()

M = 1

# hitung LCM dari setiap pemodulo # BELOM DISINI

# hitung nilai M for item in listMod: M = M * item

listM = []

# hitung nilai M/m untuk setiap nilai m for item in listMod:

temp = M // item listM.append(temp)

# hitung inversi modulo listInvM = []

for i in range(0, len(listM)):

temp = myPrime.inversMod(listM[i], listMod[i]) listInvM.append(temp)

# hitung x x = 0

for i in range(0, len(listA)):

temp = listA[i] * listM[i] * listInvM[i] x = x + temp

return x

def lcm(self, listNumber): a = 1

b = 1

for item in listNumber: b = a * item

a = b // self.gcdEuclidean(a, item) return a

(11)

while(b != 0): x = a % b a = b b = x return a

def findKongruen(item, k, prime):

# kongruen terhadap ((prime - 1) * k) % item pangkatBase = 1

m = (prime - 1) * k % prime n = (item * pangkatBase) % prime

pangkatBase = pangkatBase + 1 n = (item * pangkatBase) % prime

# setelah ditemukan x yang tepat, maka pangkatBase adalah x return pangkatBase

class DistinctPrimes: pj = [] #basis

aj = {} #eksponen (pangkat), dengan tipe dictionary

def showInfo(self): for item in self.pj:

print(item, "^", self.aj[item])

def hitungProduct(self): hasil = 1

for item in self.pj:

hasil = hasil * (item * self.aj[item]) return hasil

class HasilSHP: ej = {} ejM = {} d = 0

def __init__(self, initej, initejM, initd): self.ej = initej

self.ejM = initejM self.d = initd

def showInfo(self): print("Hasil SHP") print("d:", self.d)

4. lib/splashscreen.py

import tkinter as tk

class SplashScreen(tk.Toplevel):

def __init__(self, master, image=None, timeout=1000): """

create a splash screen from a specified image file

keep splash screen up for timeout milliseconds """

(12)

self.main = master

# don't show main window self.main.withdraw() self.overrideredirect(1)

# use Tkinter's PhotoImage for .gif file_s

self.image = tk.PhotoImage(file_=image)

self.after_idle(self.centerOnScreen)

self.update()

self.after(timeout, self.destroySplash)

def centerOnScreen(self): self.update_idletasks()

self.width, self.height = self.image.width(), self.image.height()

xmax = self.winfo_screenwidth() ymax = self.winfo_screenheight()

x0 = self.x0 = xmax/2 - self.width/2 y0 = self.y0 = ymax/2 - self.height/2

self.geometry("%dx%d+%d+%d" % (self.width, self.height, x0, y0))

self.createSplash()

def createSplash(self): # show the splash image

self.canvas = tk.Canvas(self, height=self.height, width=self.width)

self.canvas.create_image(0,0, anchor='nw', image=self.image)

self.canvas.pack()

def destroySplash(self):

# bring back main window and destroy splash screen self.main.update()

self.main.deiconify() self.withdraw()

5. elgamalshp.py

from tkinter import *

from tkinter import file_dialog

import Pmw import time import os

from lib.elgamal import * from lib.dlpModule import * from lib.splashscreen import *

class ElGamalSHP(Frame):

def __init__(self, parent):

Frame.__init__(self, parent) self.parent = parent self.inisialisasi()

(13)

self.parent.title("Elgamal Cryptosistem") # Inisialisasi Python Mega Widget

Pmw.initialise()

# Buat objek notebook, dengan root sebagai rootnya notebook = Pmw.NoteBook()

self.bookgenkey(notebook) self.bookenkripsi(notebook) self.bookdekripsi(notebook) self.bookHack(notebook)

# Pengaturan posisi dengan method pack.

notebook.pack(fill = 'both', expand = 1, padx = 10, pady = 10)

# Objek elgamal

self.elGamal = ElGamal() #========================

# Method untuk mengenerate tab 'generate key' # Parameter berupa objek notebook.

def bookgenkey(self, notebook):

# Menambahkan sebuah tab

pageGenkey = notebook.add('Bangkitkan Kunci')

# BEGIN GROUP

++++++++++++++++++++++++++++++++++++++++++++++++

# Membuat grup yang berisi content halaman, parent nya berupa tab pageGenKey

group1 = Pmw.Group(pageGenkey, tag_pyclass=None)

# Frame 1 - baris 1.

frame = Frame(group1.interior())

# Membuat label di dalam frame

Label(frame, text='Panjang kunci: ').pack(padx=5, pady=5, side=LEFT)

# List panjangkey

listpanjangkey = (4,5,6,7,8,9,10,11,12,13,14,15,16) # Membat combobox dari Pmw

self.cbpjkey = Pmw.ComboBox(frame, dropdown=1,

scrolledlist_items=listpanjangkey) self.cbpjkey.pack(fill='both', padx=5, pady=5, side=LEFT) self.cbpjkey.selectitem(0)

# Membuat objek button, dari tkinter, rootnya adalah frame btngenerate = Button(frame, text="Bangkitkan!", command = self.generateKunci)

btngenerate.pack(side=LEFT, padx=5, pady=5)

# Menampilkan frame dan mengatur properti tampilan frame.pack(fill=BOTH)

# Frame baru untuk label lama pembangkitan kunci frame = Frame(group1.interior())

(14)

self.labelInfo = Label(frame, textvariable=self.labelInfoVar)

self.labelInfo.pack(padx=5, pady=5)

self.labelInfoVar.set('Lama waktu pembangkitan kunci: ') # Tampilkan frame lama waktu

frame.pack(side=LEFT)

# END GROUP

++++++++++++++++++++++++++++++++++++++++++++++++

group1.pack(fill=BOTH, padx = 5, pady = 5, ipadx = 5, ipady = 5)

# BEGIN GROUP

++++++++++++++++++++++++++++++++++++++++++++++++

# Membuat grup yang berisi content Kunci publik, parent nya page pageGenkey

group2 = Pmw.Group(pageGenkey, tag_text='Kunci Publik')

# BEGIN FRAME =========================================== # Membuat frame penampung frame lain

frameluar = Frame(group2.interior())

# Membuat frame untuk baris p frame = Frame(frameluar)

Label(frame, text='p ').pack(side=LEFT, padx=5, pady=5) self.entryGenKeypVar = StringVar()

self.entryGenKeyp = Entry(frame, textvariable = self.entryGenKeypVar)

self.entryGenKeyp.pack(side=LEFT, expand=1, fill=X, padx=10)

frame.pack(fill=X, expand=1)

# Membuat frame untuk baris a frame = Frame(frameluar)

Label(frame, text='a ').pack(side=LEFT, padx=5, pady=5) self.entryGenKeyaVar = StringVar()

self.entryGenKeya = Entry(frame, textvariable = self.entryGenKeyaVar)

self.entryGenKeya.pack(side=LEFT, expand=1, fill=X, padx=10)

# Membuat frame untuk baris b frame = Frame(frameluar)

Label(frame, text='b ').pack(side=LEFT, padx=5, pady=5) self.entryGenKeybVar = StringVar()

self.entryGenKeyb = Entry(frame, textvariable = self.entryGenKeybVar)

self.entryGenKeyb.pack(side=LEFT, expand=1, fill=X, padx=10)

# Membuat frame untuk tombol export frame = Frame(frameluar)

btnexportpubk = Button(frame, text="Eksport", command=self.exportKunciPublik)

btnexportpubk.pack(side=LEFT, padx=5, pady=5) frame.pack()

(15)

frameluar.pack(fill=X) # END GROUP

++++++++++++++++++++++++++++++++++++++++++++++++

group2.pack(side = LEFT, expand=1, fill=BOTH, padx = 5, pady = 5, ipadx = 5, ipady = 5) # packing grup.

# BEGIN GROUP

++++++++++++++++++++++++++++++++++++++++++++++++

# Membuat grup yang berisi content Kunci privat, parent nya page pageGenkey

group3 = Pmw.Group(pageGenkey, tag_text='Kunci Privat') frameluar = Frame(group3.interior())

# BEGIN FRAME =========================================== frame = Frame(frameluar)

Label(frame, text='p ').pack(padx=5, pady=5, side=LEFT) self.entryGenKeyPrivp = Entry(frame, width=25,

textvariable = self.entryGenKeypVar)

self.entryGenKeyPrivp.pack(side=LEFT, expand=1, fill=X, padx=10)

frame = Frame(frameluar)

Label(frame, text='d ').pack(padx=5, pady=5, side=LEFT) self.entryGenKeyPrivdVar = StringVar()

self.entryGenKeyPrivd = Entry(frame, width=25, textvariable = self.entryGenKeyPrivdVar)

self.entryGenKeyPrivd.pack(side=LEFT, expand=1, fill=X, padx=10)

frame = Frame(frameluar)

btnexportprivk = Button(frame, text="Eksport", command=self.exportKunciPrivat)

btnexportprivk.pack(side=LEFT, padx=5, pady=5) frame.pack()

# END FRAME =========================================== frameluar.pack(fill=X)

# END GROUP

++++++++++++++++++++++++++++++++++++++++++++++++

group3.pack(side=LEFT, expand=1, fill=BOTH, padx = 5, pady = 5, ipadx = 5, ipady = 5) # packing grup.

notebook.setnaturalsize()

def bookenkripsi(self, notebook):

pageEnkripsi = notebook.add('Enkripsi')

# Membuat grup yang berisi content page, parent nya page pageGenkey

groupKey = Pmw.Group(pageEnkripsi, tag_text='Kunci Publik')

frame = Frame(groupKey.interior())

btnexportpubk = Button(frame, text="Import", command = self.importKunciPublik)

(16)

Label(frame, text='p ').pack(padx=5, pady=5, side=LEFT) self.entryEncryptpVar = StringVar()

self.entryEncryptp = Entry(frame, width=25, textvariable = self.entryEncryptpVar)

self.entryEncryptp.pack(side=LEFT) frame.pack(side=LEFT, padx=5, pady=5)

Label(frame, text='a ').pack(padx=5, pady=5, side=LEFT) self.entryEncryptaVar = StringVar()

self.entryEncrypta = Entry(frame, width=25, textvariable = self.entryEncryptaVar)

self.entryEncrypta.pack(side=LEFT) frame.pack(side=LEFT, padx=5, pady=5)

Label(frame, text='b ').pack(padx=5, pady=5, side=LEFT) self.entryEncryptbVar = StringVar()

self.entryEncryptb = Entry(frame, width=25, textvariable = self.entryEncryptbVar)

self.entryEncryptb.pack(side=LEFT) frame.pack(side=LEFT, padx=5, pady=5)

groupKey.pack(fill=X, padx = 5, pady = 5, ipadx = 5, ipady = 5) # packing grup.

# Membuat grup yang berisi content page, parent nya page pageEnkripsi

groupPT = Pmw.Group(pageEnkripsi, tag_text='Plaintext')

frame = Frame(groupPT.interior())

btnexportpubk = Button(frame, text="Import", command = self.importPlainText)

btnexportpubk.pack(side=LEFT, padx=5, pady=5) frame.pack(fill=BOTH, padx=5, pady=5)

self.encryptPlainText = Text(frame, height=4) scrollTp = Scrollbar(frame,

command=self.encryptPlainText.yview)

self.encryptPlainText.configure(yscrollcommand=scrollTp.set)

self.encryptPlainText.pack(side=LEFT, fill=BOTH, expand=1) scrollTp.pack(side=LEFT, fill=Y)

frame.pack(fill=BOTH, expand=1, padx=5, pady=5)

btnenkripsi = Button(frame, text="Enkripsi", command = self.enkripsi)

btnenkripsi.pack(padx=5, pady=5)

groupPT.pack(fill=X, padx = 5, pady = 5, ipadx = 5, ipady = 5) # packing grup.

(17)

groupCT = Pmw.Group(pageEnkripsi, tag_text='Cipher Text')

# ============

frame = Frame(groupCT.interior())

frame1 = Frame(frame)

self.encryptCipherText1 = Text(frame1, height=4) scrollC1 = Scrollbar(frame1,

command=self.encryptCipherText1.yview)

self.encryptCipherText1.configure(yscrollcommand=scrollC1.set) self.encryptCipherText1.pack(fill=BOTH, side=LEFT, expand=1)

scrollC1.pack(side=LEFT, fill=Y)

frame1.pack(fill=X, expand=1, padx = 5, pady = 5)

frame = Frame(groupCT.interior())

btnexportciph = Button(frame, text="Eksport", command = self.eksportCipherText)

btnexportciph.pack(padx=5, pady=5)

# ---

groupCT.pack(fill=X, padx = 5, pady = 5, ipadx = 5, ipady = 5) # packing grup.

def bookdekripsi(self, notebook):

pageDekripsi = notebook.add('Dekripsi')

group1 = Pmw.Group(pageDekripsi, tag_text='Kunci Privat')

btnexportpubk = Button(frame, text="Import", command = self.importKunciPrivat)

btnexportpubk.pack(side=LEFT, padx=5, pady=5) frame.pack(side=LEFT, padx=5, pady=5)

Label(frame, text='p ').pack(padx=5, pady=5, side=LEFT) self.entryDecryptpVar = StringVar()

self.entryDecryptp = Entry(frame, width=25, textvariable =self.entryDecryptpVar)

self.entryDecryptp.pack(side=LEFT) frame.pack(side=LEFT, padx=5, pady=5)

Label(frame, text='d ').pack(padx=5, pady=5, side=LEFT) self.entryDecryptdVar = StringVar()

self.entryDecryptd = Entry(frame, width=25, textvariable = self.entryDecryptdVar)

(18)

group1.pack(fill=X, padx = 5, pady = 5, ipadx = 5, ipady = 5) # packing grup.

# Membuat grup yang berisi content page, parent nya page pageEnkripsi

group2 = Pmw.Group(pageDekripsi, tag_text='Ciphertext')

framebtn = Frame(group2.interior())

btnexportC1 = Button(framebtn, text="Import", command = self.importCipherText)

btnexportC1.pack(side=LEFT, padx=10, pady=5) framebtn.pack(fill=X)

# ============

frame1 = Frame(frame)

self.decryptCipherText1 = Text(frame1, height=4) scrollC1 = Scrollbar(frame1,

command=self.decryptCipherText1.yview)

self.decryptCipherText1.configure(yscrollcommand=scrollC1.set) self.decryptCipherText1.pack(fill=BOTH, side=LEFT, expand=1)

scrollC1.pack(side=LEFT, fill=Y)

frame1.pack(fill=X, expand=1, padx = 5, pady = 5)

# ============

btnexportpubk = Button(frame, text="Dekripsi", command = self.dekripsi)

btnexportpubk.pack(padx=5, pady=5)

group2.pack(fill=X, padx = 5, pady = 5, ipadx = 5, ipady = 5) # packing grup.

# ===========

groupPT = Pmw.Group(pageDekripsi, tag_text='Plaintext')

self.decryptPlainText = Text(frame, height=4) scrollTp = Scrollbar(frame,

command=self.decryptPlainText.yview)

self.decryptPlainText.configure(yscrollcommand=scrollTp.set)

self.decryptPlainText.pack(side=LEFT, fill=BOTH, expand=1) scrollTp.pack(side=LEFT, fill=Y)

btnexportPT = Button(frame, text="Eksport", command = self.eksportPlainText)

(19)

groupPT.pack(fill=X, padx = 5, pady = 5, ipadx = 5, ipady = 5) # packing grup.

def bookHack(self, notebook):

pageHack = notebook.add('Hack')

groupPubKey = Pmw.Group(pageHack, tag_text='Kunci Publik')

frame = Frame(groupPubKey.interior())

btnImportPubKey = Button(frame, text="Import", command = self.importKunciPublikHack)

btnImportPubKey.pack(side=LEFT, padx=5, pady=5) frame.pack(side=LEFT, padx=5, pady=5)

Label(frame, text='p ').pack(padx=5, pady=5, side=LEFT) self.entryHackpVar = StringVar()

self.entryHackp = Entry(frame, width=25,

textvariable = self.entryHackpVar) self.entryHackp.pack(side=LEFT)

frame.pack(side=LEFT, padx=5, pady=5)

Label(frame, text='a ').pack(padx=5, pady=5, side=LEFT) self.entryHackaVar = StringVar()

self.entryHacka = Entry(frame, width=25,

textvariable = self.entryHackaVar) self.entryHacka.pack(side=LEFT)

Label(frame, text='b ').pack(padx=5, pady=5, side=LEFT) self.entryHackbVar = StringVar()

self.entryHackb = Entry(frame, width=25,

textvariable = self.entryHackbVar) self.entryHackb.pack(side=LEFT)

groupPubKey.pack(fill=X, padx = 5, pady = 5, ipadx = 5, ipady = 5) # packing grup.

groupHackButton = Pmw.Group(pageHack, tag_pyclass=None) frame = Frame(groupHackButton.interior())

btnHack = Button(frame, text="Hack!",

command = self.hack) btnHack.pack(side=LEFT, padx=5, pady=5) frame.pack(side=LEFT, padx=5, pady=5)

groupHackButton.pack(fill=X, padx = 5, pady = 5, ipadx = 5, ipady = 5) # packing grup.

(20)

frame = Frame(groupPrivKey.interior())

btnexportpubk = Button(frame, text="Eksport", command =

self.eksportHackedKunciPrivat)

btnexportpubk.pack(side=LEFT, padx=5, pady=5) frame.pack(side=LEFT, padx=5, pady=5)

Label(frame, text='p ').pack(padx=5, pady=5, side=LEFT) self.entryHackPrivp = Entry(frame, width=25,

textvariable = self.entryHackpVar)

self.entryHackPrivp .pack(side=LEFT) frame.pack(side=LEFT, padx=5, pady=5)

Label(frame, text='d ').pack(padx=5, pady=5, side=LEFT) self.entryHackdVar = StringVar()

self.entryHackd = Entry(frame, width=25,

textvariable = self.entryHackdVar) self.entryHackd.pack(side=LEFT)

groupPrivKey.pack(fill=X, padx = 5, pady = 5, ipadx = 5, ipady = 5) # packing grup.

groupTime = Pmw.Group(pageHack, tag_pyclass=None)

frame = Frame(groupTime.interior()) self.lblpjkeyVar = StringVar() self.lblpjkey = Label(frame,

textvariable=self.lblpjkeyVar).pack(padx=5, pady=5, side=LEFT) frame.pack(fill = X, padx=5, pady=5)

self.lblpjkeyVar.set('Panjang Kunci: ')

frame = Frame(groupTime.interior()) self.lbltimehackVar = StringVar() self.lbltimehack = Label(frame,

textvariable=self.lbltimehackVar).pack(padx=5, pady=5, side=LEFT) frame.pack(side=LEFT, padx=5, pady=5)

self.lbltimehackVar.set('Waktu Pemecahan Kunci: ')

groupTime.pack(fill=X, padx = 5, pady = 5, ipadx = 5, ipady = 5) # packing grup.

def centerWindow(self): w = 290

h = 150

sw = root.winfo_screenwidth() sh = root.winfo_screenheight()

x = (sw - w)/2 y = (sh - h)/2

(21)

def generateKunci(self):

panjang = self.cbpjkey.get() start_time = time.time()

key = self.elGamal.bangkitkanKunci(panjang) timeelapsed = time.time() - start_time print('p: ', getattr(key, 'pubKeyP')) print('a: ', getattr(key, 'pubKeyA')) print('b: ', getattr(key, 'pubKeyB')) print('d: ', getattr(key, 'privKeyD')) print('time elapsed: ', timeelapsed)

infostring = 'Lama waktu pembangkitan kunci: ' + str("%.4f" % timeelapsed) + ' s'

self.labelInfoVar.set(infostring)

self.entryGenKeypVar.set(getattr(key, 'pubKeyP')) self.entryGenKeyaVar.set(getattr(key, 'pubKeyA')) self.entryGenKeybVar.set(getattr(key, 'pubKeyB')) self.entryGenKeyPrivdVar.set(getattr(key, 'privKeyD'))

# Hack

a = int(getattr(key, 'pubKeyA')) b = int(getattr(key, 'pubKeyB')) p = int(getattr(key, 'pubKeyP')) dlp = DLP()

start_time = time.time()

mylist = dlp.shpDiscreteLog(a, b, p) hacked = getattr(mylist, "d")

dlptimeelapsed = time.time() - start_time print('hacked key: ', hacked)

print('HACK time elapsed: ', dlptimeelapsed)

def exportKunciPublik(self):

myPubKey = 'p' + self.entryGenKeypVar.get() + ';'

myPubKey = myPubKey + 'a' + self.entryGenKeyaVar.get() + ';'

myPubKey = myPubKey + 'b' + self.entryGenKeybVar.get() myFile₌file_{dialog.asksaveas}file_(mode='w')

if myFile_{is None:}

return

myFile_{.write(myPubKey)}

def exportKunciPrivat(self):

myPrivKey = 'p' + self.entryGenKeypVar.get() + ';' myPrivKey = myPrivKey + 'd' +

self.entryGenKeyPrivdVar.get()

myFile₌file_{dialog.asksaveas}file_(mode='w')

return

myFile_{.write(myPrivKey)}

def importKunciPublik(self):

myFile₌file_{dialog.askopen}file_(mode='r')

return

myText = myFile_.read()

elGamalCon = ElGamalConverter()

(22)

self.entryEncryptpVar.set(myPubKey['p']) self.entryEncryptaVar.set(myPubKey['a']) self.entryEncryptbVar.set(myPubKey['b'])

def importKunciPrivat(self):

return

myPrivKey = elGamalCon.stringToPrivKey(myText) self.entryDecryptpVar.set(myPrivKey['p']) self.entryDecryptdVar.set(myPrivKey['d'])

def importPlainText(self):

return

self.encryptPlainText.delete(1.0, END)

self.encryptPlainText.insert(END, myFile_.read())

def importCipherText(self):

return

self.myCipherText = myFile_.read()

print(self.myCipherText)

self.decryptCipherText1.delete(1.0, END)

self.decryptCipherText1.insert(END, self.myCipherText)

def enkripsi(self):

pubKeyA = int(self.entryEncryptaVar.get()) pubKeyB = int(self.entryEncryptbVar.get()) pubKeyP = int(self.entryEncryptpVar.get()) message = self.encryptPlainText.get("1.0",END) message = message[:len(message) - 1]

for char in message: print('char: ', char)

cipherText = self.elGamal.enkripsi(message, pubKeyA, pubKeyB, pubKeyP)

self.myCiphertext = getattr(cipherText, 'cipherText1') + chr(95) + str(getattr(cipherText, 'cipherText2'))

self.encryptCipherText1.delete(1.0, END)

self.encryptCipherText1.insert(END, self.myCiphertext)

def dekripsi(self):

pubKeyP = int(self.entryDecryptpVar.get()) privKeyD = int(self.entryDecryptdVar.get())

egc = ElGamalConverter()

myct = self.decryptCipherText1.get("1.0",END) cipherText = egc.stringToMessage(myct)

C1 = cipherText[0] C2 = int(cipherText[1])

plainText = self.elGamal.dekripsi(C2, C1, pubKeyP, privKeyD)

self.decryptPlainText.delete(1.0, END)

(23)

def eksportCipherText(self):

myFile₌file_{dialog.asksaveas}file_(mode='w')

return

myFile_{.write(self.myCiphertext)}

def eksportPlainText(self):

message = self.decryptPlainText.get("1.0",END) myFile₌file_{dialog.asksaveas}file_(mode='w')

return

myFile_{.write(message)}

def importKunciPublikHack(self):

return

myPubKey = elGamalCon.stringToPubKey(myText) self.entryHackpVar.set(myPubKey['p'])

self.entryHackaVar.set(myPubKey['a']) self.entryHackbVar.set(myPubKey['b'])

def eksportHackedKunciPrivat(self):

myPrivKey = 'p' + self.entryHackpVar.get() + ';'

myPrivKey = myPrivKey + 'd' + self.entryHackdVar.get() myFile₌file_{dialog.asksaveas}file_(mode='w')

return

myFile_{.write(myPrivKey)}

def hack(self):

a = int(self.entryHackaVar.get()) b = int(self.entryHackbVar.get()) p = int(self.entryHackpVar.get()) dlp = DLP()

start_time = time.time()

mylist = dlp.shpDiscreteLog(a, b, p) timeelapsed = time.time() - start_time

self.lblpjkeyVar.set('Panjang Kunci: ' + str(len(str(p))) + ' digit')

infostring = 'Lama waktu pemecahan kunci: ' + str("%.4f" % timeelapsed) + ' s'

self.lbltimehackVar.set(infostring)

print('HACK time elapsed: ', timeelapsed) self.entryHackdVar.set(getattr(mylist, "d"))

#Code tetap, inisialisasi root = Tk()

# splash screen >;)

image_file_{= "lib/splash.gif"}

assert os.path.exists(image_file₎

s = SplashScreen(root, timeout=3000, image=image_file₎

# Membuat objek notebook dengan method inisialisasi ex = ElGamalSHP(root)

(24)

1. libelgamal.py - Simulasi Pencarian Kunci Privat dengan Algoritma Silver-Pohlig-Hellaman pada Algoritma Kriptografi Elgamal

LISTING PROGRAM

1.

lib/elgamal.py

2.

lib/myprime.py

3.

lib/dlpModule.py

4.

lib/splashscreen.py

5.

elgamalshp.py

CURRICULUM VITAE

Nama

: Arifin

Alamat

: Jl. Paku. Gg Family, no. 20, Kec. Medan Marelan, Medan.

Alamat Orang Tua

: Jl. Paku. Gg Family, no. 20, Kec. Medan Marelan, Medan.

No. Handphone

: 0878 6722 3126

Pendidikan

1997-2003

: SD N 031 Kec. Siak Hulu, Kab. Kampar, Riau.

2003-2006

: SMP N 4 Kec. Siak Hulu, Kab. Kampar, Riau.

2006-2009

: SMA S. Sinar Husni, Kec. Medan Helvetia, Medan.

2010-2015

: Universitas Sumatera Utara (S1 Ilmu Komputer Fasilkom-TI)

Riwayat Organisasi

2011-2012

: Anggota Bidang Kaderisasi UKMI Al-Khuwarizmi

2012

: Kepala Bidang Kaderisasi UKMI Al-Khuwarizmi

2012-2014

: Asisten Laboratorium Pemrograman

2012-2013

: Divisi Penjadwalan IKLC

2013-2014

: Ketua Unit IKLC

Keahlian

Web Development

Bahasa Pemrograman : HTML, Javascript, CSS, PHP.

Framework

: CodeIgniter, Wordpress, Bootstrap.