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
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
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
# 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):
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
# 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
# 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):
# jika hasil pembagian tidak 0 maka harus menemukan bilangan x yang
# kongruen terhadap ((prime - 1) * k) % item pangkatB0 = 1
m = (prime - 1) * k % prime n = pj % prime
# selama masih belum kongruen, temukan x yang memenuhi while(m != n):
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)
# 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):
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):
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
while(b != 0): x = a % b a = b b = x return a
def findKongruen(item, k, prime):
# 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 = (item * pangkatBase) % prime
# selama masih belum kongruen, temukan x yang memenuhi while(m != n):
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 """
self.main = master
# don't show main window self.main.withdraw() self.overrideredirect(1)
# use Tkinter's PhotoImage for .gif files
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 filedialog
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()
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())
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)
frame.pack(fill=X, expand=1)
# 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)
frame.pack(fill=X, expand=1)
# 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()
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.pack(fill=X, expand=1)
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.pack(fill=X, expand=1)
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)
frame = Frame(groupKey.interior())
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)
frame = Frame(groupKey.interior())
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)
frame = Frame(groupKey.interior())
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)
frame = Frame(groupPT.interior())
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)
frame = Frame(groupPT.interior())
btnenkripsi = Button(frame, text="Enkripsi", command = self.enkripsi)
btnenkripsi.pack(padx=5, pady=5)
frame.pack(fill=BOTH, expand=1, padx=5, pady=5)
groupPT.pack(fill=X, padx = 5, pady = 5, ipadx = 5, ipady = 5) # packing grup.
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.pack(fill=BOTH, expand=1, padx=5, pady=5)
frame = Frame(groupCT.interior())
btnexportciph = Button(frame, text="Eksport", command = self.eksportCipherText)
btnexportciph.pack(padx=5, pady=5)
frame.pack(fill=BOTH, expand=1, padx=5, pady=5)
# ---
groupCT.pack(fill=X, padx = 5, pady = 5, ipadx = 5, ipady = 5) # packing grup.
notebook.setnaturalsize()
def bookdekripsi(self, notebook):
pageDekripsi = notebook.add('Dekripsi')
# Membuat grup yang berisi content page, parent nya page pageGenkey
group1 = Pmw.Group(pageDekripsi, tag_text='Kunci Privat')
frame = Frame(group1.interior())
btnexportpubk = Button(frame, text="Import", command = self.importKunciPrivat)
btnexportpubk.pack(side=LEFT, padx=5, pady=5) frame.pack(side=LEFT, padx=5, pady=5)
frame = Frame(group1.interior())
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)
frame = Frame(group1.interior())
Label(frame, text='d ').pack(padx=5, pady=5, side=LEFT) self.entryDecryptdVar = StringVar()
self.entryDecryptd = Entry(frame, width=25, textvariable = self.entryDecryptdVar)
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)
# ============
frame = Frame(group2.interior())
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)
frame.pack(fill=BOTH, expand=1, padx=5, pady=5)
# ============
frame = Frame(group2.interior())
btnexportpubk = Button(frame, text="Dekripsi", command = self.dekripsi)
btnexportpubk.pack(padx=5, pady=5)
frame.pack(fill=BOTH, expand=1, 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')
frame = Frame(groupPT.interior())
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)
frame.pack(fill=BOTH, expand=1, padx=5, pady=5)
frame = Frame(groupPT.interior())
btnexportPT = Button(frame, text="Eksport", command = self.eksportPlainText)
frame.pack(fill=BOTH, expand=1, padx=5, pady=5)
groupPT.pack(fill=X, padx = 5, pady = 5, ipadx = 5, ipady = 5) # packing grup.
notebook.setnaturalsize()
def bookHack(self, notebook):
pageHack = notebook.add('Hack')
# Membuat grup yang berisi content page, parent nya page pageGenkey
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)
frame = Frame(groupPubKey.interior())
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)
frame = Frame(groupPubKey.interior())
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)
frame.pack(side=LEFT, padx=5, pady=5)
frame = Frame(groupPubKey.interior())
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)
frame.pack(side=LEFT, padx=5, pady=5)
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.
# Membuat grup yang berisi content page, parent nya page pageGenkey
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)
frame = Frame(groupPrivKey.interior())
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)
frame = Frame(groupPrivKey.interior())
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)
frame.pack(side=LEFT, padx=5, pady=5)
groupPrivKey.pack(fill=X, padx = 5, pady = 5, ipadx = 5, ipady = 5) # packing grup.
# Membuat grup yang berisi content page, parent nya page pageGenkey
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.
notebook.setnaturalsize()
def centerWindow(self): w = 290
h = 150
sw = root.winfo_screenwidth() sh = root.winfo_screenheight()
x = (sw - w)/2 y = (sh - h)/2
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 = filedialog.asksaveasfile(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 = filedialog.asksaveasfile(mode='w')
if myFile is None:
return
myFile.write(myPrivKey)
def importKunciPublik(self):
myFile = filedialog.askopenfile(mode='r')
if myFile is None:
return
myText = myFile.read()
elGamalCon = ElGamalConverter()
self.entryEncryptpVar.set(myPubKey['p']) self.entryEncryptaVar.set(myPubKey['a']) self.entryEncryptbVar.set(myPubKey['b'])
def importKunciPrivat(self):
myFile = filedialog.askopenfile(mode='r')
if myFile is None:
return
myText = myFile.read()
elGamalCon = ElGamalConverter()
myPrivKey = elGamalCon.stringToPrivKey(myText) self.entryDecryptpVar.set(myPrivKey['p']) self.entryDecryptdVar.set(myPrivKey['d'])
def importPlainText(self):
myFile = filedialog.askopenfile(mode='r')
if myFile is None:
return
self.encryptPlainText.delete(1.0, END)
self.encryptPlainText.insert(END, myFile.read())
def importCipherText(self):
myFile = filedialog.askopenfile(mode='r')
if myFile is None:
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)
def eksportCipherText(self):
myFile = filedialog.asksaveasfile(mode='w')
if myFile is None:
return
myFile.write(self.myCiphertext)
def eksportPlainText(self):
message = self.decryptPlainText.get("1.0",END) myFile = filedialog.asksaveasfile(mode='w')
if myFile is None:
return
myFile.write(message)
def importKunciPublikHack(self):
myFile = filedialog.askopenfile(mode='r')
if myFile is None:
return
myText = myFile.read()
elGamalCon = ElGamalConverter()
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 = filedialog.asksaveasfile(mode='w')
if myFile is None:
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)
