def output(self, value):
eingabe = value.getString()
if eingabe == "Lexikon":
# Falls "Lexikon" an den Clienten übergeben wird, wird die GUI geöffnet,
# in der man deutsche Wörter eingeben kann, die einem dann auf Englisch
# vorgelesen werden.
def change_text(event):
text = feld.getText()
x = suche(text)
self.send(x)
frame.visible = False
frame = JFrame(
'Woerterbuch',
defaultCloseOperation=JFrame.EXIT_ON_CLOSE,
size=(380, 350),
)
frame.setLayout(None)
frame.visible = True
hintergrund = ImageIcon("Hintergrund.jpg")
hintergrundlabel = JLabel(hintergrund)
frame.setContentPane(hintergrundlabel)
uebersetzerlabel = JLabel()
uebersetzerlabel.setForeground(Color(025, 025, 112))
uebersetzerlabel.setText(
"<html><font size=+1>Welches Wort soll ich uebersetzen?</font></html>"
)
uebersetzerlabel.setBounds(10, 20, 500, 50)
frame.add(uebersetzerlabel)
feld = JTextField()
feld.setText("")
feld.setBounds(20, 80, 300, 25)
frame.add(feld)
button = JButton('Uebersetzen',
actionPerformed=change_text,
size=(10, 20))
button.setBounds(20, 110, 300, 30)
frame.add(button)
if eingabe == "neue Lektion":
# Falls dem Clienten "neue Lektion" übergeben wird, öffnet er er die
# GUI für das Verwalten der Lektionen
frame = JFrame('Lektion erstellen',
defaultCloseOperation=JFrame.EXIT_ON_CLOSE,
size=(1000, 1000))
frame.setLayout(None)
def auflisten_in(ort):
font = Font("Verdana", Font.BOLD, 15)
liste_mit_Lektionen = []
with open(pfad, "r") as f:
for line in f:
liste_mit_Lektionen.append(line.strip())
liste_mit_Lektionen.sort()
text = ""
for lektion in liste_mit_Lektionen:
text += lektion
text += "\n"
ort.setText(text)
ort.setFont(font)
frame.setLayout(None)
uebersichtLabel = JLabel()
def uebersetzen(event):
frage = feld_frage.getText()
x = suche(frage)
feld_frage.setText(x)
liste = []
with open(pfad, "r") as lektionen:
for lektion in lektionen:
if "nachgeschlagen" in lektion:
liste.append(lektion)
if liste:
name = liste[-1]
words = []
sql = "SELECT deutsch, englisch, symbol FROM " + name
zeile = stmt.executeQuery(sql)
while zeile.next():
d = zeile.getString("deutsch")
e = zeile.getString("englisch")
symb = zeile.getString("symbol")
words.append((d, e, symb))
if len(words) < 50:
sql = "INSERT INTO " + name + " (deutsch, englisch, symbol) VALUES(?,?,?);"
pstmt = conn.prepareStatement(sql)
pstmt.setString(1, frage)
pstmt.setString(2, x)
pstmt.setString(3, "X")
pstmt.executeUpdate()
else:
namensteile = name.split("_")
nummer = int(namensteile[1].strip()) + 1
name = "nachgeschlagen_" + str(nummer)
test = ""
with open(pfad, "r") as f:
for line in f:
test += line
if not name in test:
with open(pfad, "a") as f:
f.write(name + "\n")
sql = "CREATE TABLE " + name + " (deutsch text, englisch text, symbol text);"
stmt.execute(sql)
sql = "INSERT INTO " + name + " (deutsch, englisch, symbol) VALUES(?,?,?);"
pstmt = conn.prepareStatement(sql)
pstmt.setString(1, frage)
pstmt.setString(2, x)
pstmt.setString(3, "X")
pstmt.executeUpdate()
else:
name = "nachgeschlagen_1"
test = ""
with open(pfad, "r") as f:
for line in f:
test += line
if not name in test:
with open(pfad, "a") as f:
f.write(name + "\n")
sql = "CREATE TABLE " + name + " (deutsch text, englisch text, symbol text);"
stmt.execute(sql)
sql = "INSERT INTO " + name + " (deutsch, englisch, symbol) VALUES(?,?,?);"
pstmt = conn.prepareStatement(sql)
pstmt.setString(1, frage)
pstmt.setString(2, x)
pstmt.setString(3, "X")
pstmt.executeUpdate()
auflisten_in(uebersicht)
def delete(event):
name = feld.getText()
print name
print self.geladen
if name == self.geladen:
count = 0
while tabelle.getValueAt(count, 0) != None:
tabelle.setValueAt(None, count, 0)
tabelle.setValueAt(None, count, 1)
count += 1
stmt.execute("DROP TABLE " + name + ";")
lektionen = []
with open(pfad, "r") as f:
for line in f:
lektion = line.strip()
if not name == lektion:
lektionen.append(lektion)
with open(pfad, "w") as f:
for lektion in lektionen:
f.write(lektion + "\n")
auflisten_in(uebersicht)
def laden(event):
name = feld.getText()
self.geladen = name
sql = "SELECT deutsch, englisch FROM " + name
results = stmt.executeQuery(sql)
count = 0
while results.next():
d = results.getString("deutsch")
e = results.getString("englisch")
tabelle.setValueAt(d, count, 0)
tabelle.setValueAt(e, count, 1)
count += 1
while tabelle.getValueAt(count, 0) != None:
tabelle.setValueAt(None, count, 0)
tabelle.setValueAt(None, count, 1)
count += 1
def erstelle_Lektionstabelle(event):
reihen = []
for i in range(0, 50):
deutsch = tabelle.getValueAt(i, 0)
englisch = tabelle.getValueAt(i, 1)
if deutsch != None:
symbol = "X"
reihen.append([deutsch, englisch, symbol])
else:
break
z = 0
name = feld.getText()
sql = "CREATE TABLE " + name + " (deutsch text, englisch text, symbol text);"
try:
stmt.execute(sql)
except SQLError:
stmt.execute("DROP TABLE " + name + ";")
stmt.execute(sql)
for reihe in reihen:
print(reihe)
deutsch = reihe[0]
englisch = reihe[1]
symbol = reihe[2]
sql = "INSERT INTO " + name + " (deutsch, englisch, symbol) VALUES(?,?,?);"
pstmt = conn.prepareStatement(sql)
pstmt.setString(1, deutsch)
pstmt.setString(2, englisch)
pstmt.setString(3, symbol)
pstmt.executeUpdate()
test = ""
with open(pfad, "r") as f:
for line in f:
test += line
if not name in test:
with open(pfad, "a") as f:
f.write(name + "\n")
self.send(name)
frame.setVisible(False)
frame = JFrame('Vokabel Listen',
defaultCloseOperation=JFrame.EXIT_ON_CLOSE,
size=(1000, 1000))
frame.setLayout(None)
label_enter = JLabel()
label_enter.setText(
"<html><font size=+0.5 color = 000000>Bitte vor dem Speichern<br>die Entertaste bedienen</font></html>"
)
label_enter.setBounds(20, 720, 250, 50)
uebersichtLabel = JLabel()
uebersichtLabel.setText(
"<html><font size=+1 color=#191970>Bereits vorhandene Lektionen:</font></html>"
)
uebersichtLabel.setBounds(450, 230, 250, 50)
uebersicht = JTextArea()
uebersicht.editable = False
uebersicht_scroll = JScrollPane(uebersicht)
uebersicht_scroll.viewport.view = uebersicht
uebersicht_scroll.setBounds(450, 300, 250, 380)
auflisten_in(uebersicht)
button = JButton('Lektion speichern/Lektion reseten',
actionPerformed=erstelle_Lektionstabelle,
size=(10, 20))
button.setBounds(20, 700, 300, 30)
button_laden = JButton('vorhandene Lektion laden',
actionPerformed=laden,
size=(10, 20))
button_laden.setBounds(20, 110, 210, 30)
button_delete = JButton("Lektion entfernen",
actionPerformed=delete)
button_delete.setBounds(20, 140, 210, 30)
hintergrund = ImageIcon("Hintergrund.jpg")
pnl = JPanel()
hintergrundlabel = JLabel(hintergrund)
frame.setContentPane(hintergrundlabel)
lektionsnamensLabel = JLabel()
lektionsnamensLabel.setForeground(Color(025, 025, 112))
lektionsnamensLabel.setText(
"<html><font size=+1>Hier bitte Namen der Lektion eingeben<br>(Nur ein Wort lang)</font></html>"
)
lektionsnamensLabel.setBounds(10, 20, 500, 50)
frame.add(lektionsnamensLabel)
feld = JTextField()
feld.setText("")
feld.setBounds(20, 80, 210, 25)
frame.add(feld)
column_names = [
"<html><font size=+1 color=#191970><b>Deutsch</b></font></html>",
"<html><font size=+1 color=#191970><b>Englisch</b></font></html>"
]
table_model = DefaultTableModel(column_names, 50)
tabelle = JTable(table_model)
lektionsnamensLabel.setForeground(Color(025, 025, 112))
scrollbar = JScrollPane(tabelle)
scrollbar.viewport.view = tabelle
scrollbar.setVerticalScrollBarPolicy(
scrollbar.VERTICAL_SCROLLBAR_ALWAYS)
scrollbar.setVisible(True)
tabelle.setVisible(True)
scrollbar.setBounds(20, 190, 300, 490)
feld_frage = JTextField()
feld_frage.setText("")
feld_frage.setBounds(450, 30, 300, 50)
uebersetzerlabel = JLabel()
uebersetzerlabel.setForeground(Color(025, 025, 112))
uebersetzerlabel.setText(
"<html><font size=+1>Hier kannst Du ein deutsches Wort eintragen,<br>dass ich fuer Dich nachschlage</font></html>"
)
uebersetzerlabel.setBounds(450, 80, 500, 50)
button_uebersetzen = JButton('Uebersetzen',
actionPerformed=uebersetzen,
size=(10, 20))
button_uebersetzen.setBounds(450, 130, 300, 30)
frame.add(button_uebersetzen)
frame.add(uebersetzerlabel)
frame.add(feld_frage)
frame.add(feld)
frame.add(scrollbar)
frame.add(button)
frame.add(button_laden)
frame.setVisible(True)
frame.add(uebersicht_scroll)
frame.add(uebersichtLabel)
frame.add(button_delete)
frame.add(label_enter)
elif eingabe == "alle Lektionen auflisten":
# Hier erstellt der Client eine dynamische Grammatik
# mit den vorhandenen Lektionen, die man sich abfragen lassen kann
# und gibt diese wieder an DialogOS zurück.
# Außerdem wird der Feedback Frame geöffnet.
def auflisten_in2(ort):
font = Font("Verdana", Font.BOLD, 15)
liste_mit_Lektionen = []
with open(pfad, "r") as f:
for line in f:
liste_mit_Lektionen.append(line.strip())
liste_mit_Lektionen.sort()
text = ""
for lektion in liste_mit_Lektionen:
text += lektion
text += "\n"
ort.setText(text)
ort.setFont(font)
frame_feedback.setVisible(True)
auflisten_in2(uebersicht2)
grammatik = ""
grammatik = "root $NamevonLektion;\n"
grammatik += "$NamevonLektion = "
with open(pfad, "r") as f:
z = 0
for line in f:
if z == 0:
if not "_" in line:
grammatik += line
else:
zeile = line.split("_")
grammatik += zeile[0] + " "
grammatik += zeile[1].strip()
else:
if not "_" in line:
grammatik += "|" + line
else:
zeile = line.split("_")
grammatik += "|" + zeile[0] + " "
grammatik += zeile[1].strip()
if line != "\n":
z += 1
grammatik += ";"
self.send(grammatik)
elif "sende" in eingabe:
# DialogOS sagt dem Clienten, welche Lektion der User abgefragt
# werden möchte. Der Client ließt dann die entsprechende Lektion
# aus der Datenbank aus und gibt eine Liste mit 2 Listen zurück.
# In der ersten Liste befinden sich die deutschen Bedeutungen, der
# noch nicht gewussten Wörter, in der 2. Liste die englsichen Bedeutungen.
# Falls alle Wörter bereits gekonnt wurden, wird stattdessen eine entsprechende
# Anmerkung an DialogOS geschickt und DialogOS informiert den User darüber.
z = 0
if "nachgeschlagen" in eingabe:
bestandteile = eingabe.split()
name = bestandteile[1] + "_" + bestandteile[2]
else:
name = eingabe.split()[1]
sql = "SELECT deutsch, englisch, symbol FROM " + name
vokabelliste = stmt.executeQuery(sql)
deutsch = []
englisch = []
symbol = []
while (vokabelliste.next()):
deutsch.append(vokabelliste.getString("deutsch"))
englisch.append(vokabelliste.getString("englisch"))
symbol.append(vokabelliste.getString("symbol"))
indices = range(0, len(deutsch))
random.shuffle(indices)
vokabeln = [[], []]
for index in indices:
d = deutsch[index]
e = englisch[index]
s = symbol[index]
if s == "X":
vokabeln[0].append(d)
vokabeln[1].append(e)
if vokabeln[0]:
self.send(vokabeln)
else:
self.send([
"Du kannst diese Lektion schon komplett. Wenn Du sie wieder abgefragt werden willst, resete sie bitte unter Wokabeln verwalten."
])
else:
# Dieser Teil des Codes wird während der Abfrage ausgeführt.
# Nach jeder neuen Vokabel wird dann in ein Feld im Feedback
# Frame die deutsche, die englische Vokabel und ein Symbol angezeigt,
# welches einen darüber informiert, ob man die Vokabel wusste, oder nicht.
# (O für gewusst und X für nicht gewusst)
nametext = eingabe.split(":")
name = nametext[0]
text = nametext[1]
feld_feedback.setText(text)
zeilen = text.split("\n")
symb = zeilen[-2].split("\t")[-1]
d = zeilen[-2].split("\t")[-3]
print d
sql = "UPDATE " + name + " SET symbol = ? WHERE deutsch = ?"
pstmt = conn.prepareStatement(sql)
pstmt.setString(1, symb)
pstmt.setString(2, d)
pstmt.executeUpdate()
class tab():
def __init__(self, callbacks):
""" Method automatically called when memory is
allocated for a new object, initiates tab object """
print("Created a tab")
self.callbacks = callbacks
self.curRequest = None
self.createTabGUI()
def getFirstTab(self):
""" Get the JPanel that represents the object's
Timing Attack tab """
self.scrollPane = JScrollPane(
self.firstTab, JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,
JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED)
return self.scrollPane
###########################
# SECTION 1: CREATING GUI #
###########################
def createTabGUI(self):
""" Create GUI for this tabbed pane """
# panel for the whole tab
self.firstTab = JPanel()
# name of the extention
self.titleTop = JLabel("Timing Attack")
self.titleTop.setFont(Font("Tahoma", 1, 14))
self.titleTop.setForeground(Color(255, 102, 51))
# info about the extention
self.infoTop = JLabel(
"Timing Attack is a open source extention to inform how long the system takes to respond for a valid and an invalid authentication."
)
self.infoTop.setFont(Font("Tahoma", 0, 11))
# labels and inputs on top half
self.addTitle = JLabel("Enter a Valid and an Invalid Username")
self.addTitle.setFont(Font("Tahoma", 1, 13))
self.addTitle.setForeground(Color(255, 102, 51))
self.validUsername = JLabel("Valid Username")
self.validUsername.setFont(Font("Tahoma", 0, 12))
self.invalidUsername = JLabel("Invalid Username")
self.invalidUsername.setFont(Font("Tahoma", 0, 12))
self.parameter = JLabel("Parameter")
self.parameter.setFont(Font("Tahoma", 0, 12))
self.average = JLabel("Sample Size")
self.average.setFont(Font("Tahoma", 0, 12))
self.addValid = JTextField("")
self.addInvalid = JTextField("")
self.addParameter = JTextField("")
self.addAverage = JTextField("")
self.submitButton1 = JButton("Submit",
actionPerformed=self.timeTwoUsers)
# result on top left
self.resultTitle = JLabel("Result")
self.resultTitle.setFont(Font("Tahoma", 1, 13))
self.resultTitle.setForeground(Color(255, 102, 51))
self.showResults = JTextArea("")
self.showResults.setEditable(False)
self.showResultsScroll = JScrollPane(self.showResults)
self.twoUserViewResult = JButton("View Results",
actionPerformed=self.showResultsTop)
self.twoUserViewReq = JButton("View Request",
actionPerformed=self.showRequestTop)
self.twoUserViewValidResponse = JButton(
"View Valid Response", actionPerformed=self.showValidResponseTop)
self.twoUserViewInvalidResponse = JButton(
"View Invalid Response",
actionPerformed=self.showInvalidResponseTop)
# Set top buttons to invisible until a request is submitted
self.twoUserViewResult.setVisible(False)
self.twoUserViewReq.setVisible(False)
self.twoUserViewValidResponse.setVisible(False)
self.twoUserViewInvalidResponse.setVisible(False)
# labels, inputs and file on bottom half
self.addTitleFile = JLabel("Input Username File")
self.addTitleFile.setFont(Font("Tahoma", 1, 13))
self.addTitleFile.setForeground(Color(255, 102, 51))
self.inputFileButton = JButton("Choose File...",
actionPerformed=self.chooseFile)
self.separatorList = JLabel("Separator")
self.separatorList.setFont(Font("Tahoma", 0, 12))
self.parameterList = JLabel("Parameter")
self.parameterList.setFont(Font("Tahoma", 0, 12))
self.averageList = JLabel("Sample Size")
self.averageList.setFont(Font("Tahoma", 0, 12))
self.addSeparatorList = JTextField("")
self.addParameterList = JTextField("")
self.addAverageList = JTextField("")
self.submitButton2 = JButton("Submit",
actionPerformed=self.timeUserList)
# result on bottom left
self.resultTitleList = JLabel("Result")
self.resultTitleList.setFont(Font("Tahoma", 1, 13))
self.resultTitleList.setForeground(Color(255, 102, 51))
self.showResultsList = JTextArea("")
self.showResultsList.setEditable(False)
self.showResultsListScroll = JScrollPane(self.showResultsList)
self.downloadResultList = JButton("Download Display",
actionPerformed=self.downloadResults)
self.listViewResults = JButton("View Results",
actionPerformed=self.showListResults)
self.listViewReq = JButton("View Request",
actionPerformed=self.showListRequest)
self.listViewResponses = JButton(
"View Responses", actionPerformed=self.showListResponses)
# Set list buttons to invisible until a request is submitted
self.downloadResultList.setVisible(False)
self.listViewResults.setVisible(False)
self.listViewReq.setVisible(False)
self.listViewResponses.setVisible(False)
# something wrong?
self.somethingWrong = JLabel("Something Wrong?")
self.debugOn = False
self.viewDebug = JButton("View debug output",
actionPerformed=self.showDebug)
self.debugText = JTextArea("")
self.debugTextScroll = JScrollPane(self.debugText)
self.debugTextScroll.setVisible(False)
# layout
layout = GroupLayout(self.firstTab)
self.firstTab.setLayout(layout)
layout.setHorizontalGroup(
layout.createParallelGroup(GroupLayout.Alignment.LEADING)
# whole layout
.addGroup(
layout.createSequentialGroup().addGap(15)
# title + description
.addGroup(
layout.createParallelGroup(
GroupLayout.Alignment.LEADING).addComponent(
self.titleTop).addComponent(self.infoTop)
# titles
.addGroup(
layout.createSequentialGroup()
# title left
.addGroup(
layout.createParallelGroup(
GroupLayout.Alignment.LEADING).addComponent(
self.addTitle)).addGap(168)
# title right
.addGroup(
layout.createParallelGroup(
GroupLayout.Alignment.LEADING).addComponent(
self.resultTitle))).
addGroup(
layout.createSequentialGroup()
# left
.addGroup(
layout.createParallelGroup(
GroupLayout.Alignment.LEADING).addComponent(
self.validUsername).addComponent(
self.invalidUsername).addComponent(
self.parameter).addComponent(
self.average).addComponent(
self.addTitleFile).
addComponent(self.inputFileButton).addComponent(
self.separatorList).addComponent(
self.parameterList).addComponent(
self.averageList).addComponent(
self.somethingWrong)).addGap(12).
addGroup(
layout.createParallelGroup(
GroupLayout.Alignment.LEADING).addComponent(
self.addValid, GroupLayout.PREFERRED_SIZE,
200,
GroupLayout.PREFERRED_SIZE).addComponent(
self.addInvalid,
GroupLayout.PREFERRED_SIZE, 200,
GroupLayout.PREFERRED_SIZE).
addComponent(
self.addParameter,
GroupLayout.PREFERRED_SIZE, 200,
GroupLayout.PREFERRED_SIZE).addComponent(
self.addAverage,
GroupLayout.PREFERRED_SIZE, 80,
GroupLayout.PREFERRED_SIZE).addComponent(
self.submitButton1).addComponent(
self.addSeparatorList,
GroupLayout.PREFERRED_SIZE, 200,
GroupLayout.PREFERRED_SIZE).
addComponent(
self.addParameterList,
GroupLayout.PREFERRED_SIZE, 200,
GroupLayout.PREFERRED_SIZE).addComponent(
self.addAverageList,
GroupLayout.PREFERRED_SIZE, 80,
GroupLayout.PREFERRED_SIZE).addComponent(
self.submitButton2).addComponent(
self.viewDebug)).addGap(50)
# right
.addGroup(
layout.createParallelGroup(
GroupLayout.Alignment.LEADING).addComponent(
self.showResultsScroll,
GroupLayout.PREFERRED_SIZE, 600,
GroupLayout.PREFERRED_SIZE).
addGroup(layout.createSequentialGroup().addGroup(
layout.createParallelGroup(
GroupLayout.Alignment.LEADING).
addComponent(self.twoUserViewResult)
).addGap(15).addGroup(
layout.createParallelGroup(
GroupLayout.Alignment.LEADING).
addComponent(
self.twoUserViewReq)).addGap(15).addGroup(
layout.createParallelGroup(
GroupLayout.Alignment.LEADING).
addComponent(
self.twoUserViewValidResponse)
).addGap(15).addGroup(
layout.createParallelGroup(
GroupLayout.Alignment.LEADING).
addComponent(
self.twoUserViewInvalidResponse))).
addComponent(self.resultTitleList).addComponent(
self.showResultsListScroll,
GroupLayout.PREFERRED_SIZE, 600,
GroupLayout.PREFERRED_SIZE).addGroup(
layout.createSequentialGroup().addGroup(
layout.createParallelGroup(
GroupLayout.Alignment.LEADING).
addComponent(self.downloadResultList)).
addGap(15).addGroup(
layout.createParallelGroup(
GroupLayout.Alignment.LEADING).
addComponent(self.listViewResults)
).addGap(15).addGroup(
layout.createParallelGroup(
GroupLayout.Alignment.LEADING).
addComponent(self.listViewReq)
).addGap(15).addGroup(
layout.createParallelGroup(
GroupLayout.Alignment.LEADING).
addComponent(self.listViewResponses)
)).addGap(10).addComponent(
self.debugTextScroll,
GroupLayout.PREFERRED_SIZE, 300,
GroupLayout.PREFERRED_SIZE))))))
layout.setVerticalGroup(
layout.createParallelGroup(GroupLayout.Alignment.LEADING)
# whole layout
.addGroup(
layout.createSequentialGroup().addGap(15).addComponent(
self.titleTop).addGap(10).addComponent(
self.infoTop).addGap(10)
# titles
.addGroup(
layout.createSequentialGroup()
# left
.addGroup(
layout.createParallelGroup(
GroupLayout.Alignment.LEADING).addComponent(
self.addTitle).addGap(25)
# right
.addGroup(
layout.createParallelGroup(
GroupLayout.Alignment.LEADING).addComponent(
self.resultTitle))))
# top half
.addGroup(
layout.createSequentialGroup()
# left top half
.addGroup(
layout.createParallelGroup(
GroupLayout.Alignment.BASELINE).
addGroup(layout.createSequentialGroup().addGroup(
layout.createParallelGroup(
GroupLayout.Alignment.BASELINE).addComponent(
self.validUsername).addGap(5).addComponent(
self.addValid,
GroupLayout.PREFERRED_SIZE,
GroupLayout.DEFAULT_SIZE,
GroupLayout.PREFERRED_SIZE)
).addGap(5).addGroup(
layout.createParallelGroup(
GroupLayout.Alignment.BASELINE).addComponent(
self.invalidUsername).addGap(
5).addComponent(
self.addInvalid,
GroupLayout.PREFERRED_SIZE,
GroupLayout.DEFAULT_SIZE,
GroupLayout.PREFERRED_SIZE)
).addGap(5).addGroup(
layout.createParallelGroup(
GroupLayout.Alignment.BASELINE).addComponent(
self.parameter).addGap(5).addComponent(
self.addParameter,
GroupLayout.PREFERRED_SIZE,
GroupLayout.DEFAULT_SIZE,
GroupLayout.PREFERRED_SIZE)
).addGap(5).addGroup(
layout.createParallelGroup(
GroupLayout.Alignment.BASELINE).addComponent(
self.average).addGap(5).addComponent(
self.addAverage,
GroupLayout.PREFERRED_SIZE,
GroupLayout.DEFAULT_SIZE,
GroupLayout.PREFERRED_SIZE)
).addGap(5).addGroup(
layout.createParallelGroup(
GroupLayout.Alignment.BASELINE).addComponent(
self.submitButton1))).addGap(5)
# right top half
.addGroup(
layout.createParallelGroup(
GroupLayout.Alignment.BASELINE).addComponent(
self.showResultsScroll,
GroupLayout.PREFERRED_SIZE, 200,
GroupLayout.PREFERRED_SIZE)))).addGap(5)
# buttons + titles
.addGroup(layout.createSequentialGroup().addGroup(
layout.createParallelGroup(
GroupLayout.Alignment.BASELINE).addComponent(
self.twoUserViewResult).addGap(20).addComponent(
self.twoUserViewReq).addGap(20).addComponent(
self.twoUserViewValidResponse).addGap(20).
addComponent(
self.twoUserViewInvalidResponse)).addGap(10).addGroup(
layout.createParallelGroup(
GroupLayout.Alignment.BASELINE).addComponent(
self.addTitleFile).addGap(25).addComponent(
self.resultTitleList))).addGap(3)
# bottom half
.addGroup(
layout.createSequentialGroup()
# left bottom half
.addGroup(
layout.createParallelGroup(
GroupLayout.Alignment.BASELINE).
addGroup(layout.createSequentialGroup().addGroup(
layout.createParallelGroup(
GroupLayout.Alignment.BASELINE).addComponent(
self.inputFileButton)
).addGap(10).addGroup(
layout.createParallelGroup(
GroupLayout.Alignment.BASELINE).addComponent(
self.separatorList).addGap(5).addComponent(
self.addSeparatorList,
GroupLayout.PREFERRED_SIZE,
GroupLayout.DEFAULT_SIZE,
GroupLayout.PREFERRED_SIZE)
).addGap(5).addGroup(
layout.createParallelGroup(
GroupLayout.Alignment.BASELINE).addComponent(
self.parameterList).addGap(5).addComponent(
self.addParameterList,
GroupLayout.PREFERRED_SIZE,
GroupLayout.DEFAULT_SIZE,
GroupLayout.PREFERRED_SIZE)
).addGap(5).addGroup(
layout.createParallelGroup(
GroupLayout.Alignment.BASELINE).addComponent(
self.averageList).addGap(5).addComponent(
self.addAverageList,
GroupLayout.PREFERRED_SIZE,
GroupLayout.DEFAULT_SIZE,
GroupLayout.PREFERRED_SIZE)
).addGap(5).addGroup(
layout.createParallelGroup(
GroupLayout.Alignment.BASELINE).addComponent(
self.submitButton2)
)).addGap(5).addGroup(
layout.createParallelGroup(
GroupLayout.Alignment.BASELINE).addComponent(
self.showResultsListScroll,
GroupLayout.PREFERRED_SIZE, 200,
GroupLayout.PREFERRED_SIZE)))).addGap(5)
# right bottom half
.addGroup(layout.createSequentialGroup().addGroup(
layout.createParallelGroup(
GroupLayout.Alignment.BASELINE).addComponent(
self.downloadResultList).addGap(10).addComponent(
self.listViewResults).addGap(10).addComponent(
self.listViewReq).addGap(10).addComponent(
self.listViewResponses))).addGap(30)
# something wrong section
.addGroup(layout.createSequentialGroup().addGroup(
layout.createParallelGroup(
GroupLayout.Alignment.BASELINE).addComponent(
self.somethingWrong).addGap(10).addComponent(
self.viewDebug).addGap(10).addComponent(
self.debugTextScroll,
GroupLayout.PREFERRED_SIZE, 150,
GroupLayout.PREFERRED_SIZE)))))
return
def chooseFile(self, event):
""" Method that allows the user to choose a file of
usernames, and it tries to load the last used directory """
try:
# load the directory for future imports/exports
fileChooserDirectory = self._callbacks.loadExtensionSetting(
"fileChooserDirectory")
# there is not a last used directory
except:
# set the last used directory to blank
fileChooserDirectory = ""
self.chooser = JFileChooser(fileChooserDirectory)
fileextensions = ["txt"]
filter = FileNameExtensionFilter("TXT FILES", fileextensions)
self.chooser.setFileFilter(filter)
returnVal = self.chooser.showOpenDialog(self.chooser)
if (returnVal == JFileChooser.APPROVE_OPTION):
self.inputFileButton.text = self.chooser.getSelectedFile().getName(
)
##################################
# SECTION 2: SEND TIMING REQUEST #
##################################
def timeTwoUsers(self, event):
""" Method that sends the current request to getTwoUserTimes """
if (self.curRequest == None):
self.debugOutput("Timing Attack does not have a request")
return
# change button to say show request
self.twoUserViewResult.setVisible(True)
self.twoUserViewReq.setVisible(True)
self.twoUserViewValidResponse.setVisible(True)
self.twoUserViewInvalidResponse.setVisible(True)
threading.Thread(target=self.getTwoUserTimes).start()
return
def getTwoUserTimes(self):
""" Method that prints the time taken to return responses
from one valid username and from one invalid username
(called by timeTwoUsers) """
self.twoUserViewReq.setVisible(True)
validTime, self.validRequest, self.validResponse = self.getTime(
self.addParameter.text, self.addValid.text, self.addAverage.text)
invalidTime, self.invalidRequest, self.invalidResponse = self.getTime(
self.addParameter.text, self.addInvalid.text, self.addAverage.text)
self.showResults.text = "Valid username: "******"\t Time: "
self.showResults.text += str(validTime) + "\n"
self.showResults.text += "Invalid username: "******"\t Time: "
self.showResults.text += str(invalidTime)
self.twoUserResult = self.showResults.text
def timeUserList(self, event):
""" Method that reads the usernames from file and sends
them to getUserListTimes, and if there is no file so the
program is going to return anything """
if (self.curRequest == None):
self.debugOutput("Timing Attack does not have a request")
return
try:
# stores the file
file = self.chooser.getSelectedFile()
# reads it
scan = Scanner(file)
readFile = ""
while scan.hasNext():
readFile += scan.nextLine()
# divides the file to a list of usernames
self.userList = readFile.split(self.addSeparatorList.text)
# set all the list buttons to visible
self.downloadResultList.setVisible(True)
self.listViewResults.setVisible(True)
self.listViewReq.setVisible(True)
self.listViewResponses.setVisible(True)
# gets the time for each username
threading.Thread(target=self.getUserListTimes).start()
# it will handle the error and send a message about it
except:
self.debugOutput("No File Submitted")
return
def getUserListTimes(self):
""" Method that prints the time taken to return responses
for each username from file (called by timeUserList) """
self.listViewReq.setVisible(True)
self.showResultsList.text = ""
self.listResponses = ""
self.listRequests = ""
helpers = self.callbacks.getHelpers()
for index, username in enumerate(self.userList):
self.showResultsList.text += "Username: "******"\t Time: "
time, request, response = self.getTime(self.addParameterList.text,
username,
self.addAverageList.text)
self.showResultsList.text += str(time) + "\n"
self.listResponses += ":: Response " + str(
index) + " ::\n" + "Username: "******"\n\n"
self.listResponses += helpers.bytesToString(
response) + "\n\n\n\n\n"
self.listRequests += ":: Request " + str(
index) + " ::\n" + "Username: "******"\n\n"
self.listRequests += helpers.bytesToString(request) + "\n\n\n\n\n"
self.listResults = self.showResultsList.text
return
def getTime(self, paramName, paramInput, numTriesText):
""" Method that takes in a username and returns the time taken to get
its response (called by getTwoUserTimes and getUserListTimes) """
try:
numTries = int(numTriesText)
except:
self.debugOutput("Sample size must be an integer")
# keeps a reference to helpers
helpers = self.callbacks.getHelpers()
# Get the request
request = self.curRequest.getRequest()
# Get request information
requestInfo = helpers.analyzeRequest(request)
# loop through parameters
for i in requestInfo.getParameters():
# find username parameter and change its value
if (i.getName() == paramName):
# it creates the request
buildParam = helpers.buildParameter(paramName, paramInput,
i.getType())
newRequest = helpers.updateParameter(request, buildParam)
if 'newRequest' not in locals():
self.debugOutput("Parameter " + paramName +
" cannot be found in request")
# it builds an http service to send a request to the website
httpService = self.curRequest.getHttpService()
useHttps = True if httpService.getProtocol() == "https" else False
httpService = helpers.buildHttpService(httpService.getHost(),
httpService.getPort(), useHttps)
getTime = 0
for i in range(numTries):
# starts the time and it sends the changed request with valid parameter
start = time.clock()
makeRequest = self.callbacks.makeHttpRequest(
httpService, newRequest)
makeRequest.getResponse()
getTime += time.clock() - start
makeRequest = self.callbacks.makeHttpRequest(httpService, newRequest)
request = makeRequest.getRequest()
response = makeRequest.getResponse()
# return the response
return getTime / numTries, request, response
####################################################
# SECTION 3: VIEW REQUEST/RESPONSE/RESULTS BUTTONS #
####################################################
def showListRequest(self, event):
""" Method that shows the request from a file of usernames """
helpers = self.callbacks.getHelpers()
self.showResultsList.text = self.listRequests
def showListResults(self, event):
""" Show results for list """
self.showResultsList.text = self.listResults
def showListResponses(self, event):
""" Show responses for list """
self.showResultsList.text = self.listResponses
def showResultsTop(self, event):
""" Show results on top """
self.showResults.text = self.twoUserResult
def showRequestTop(self, event):
""" Show request on top """
helpers = self.callbacks.getHelpers()
self.showResults.text = ":: Valid Request :: \n"
self.showResults.text += helpers.bytesToString(self.validRequest)
self.showResults.text += "\n\n\n:: Invalid Request :: \n"
self.showResults.text += helpers.bytesToString(self.invalidRequest)
def showValidResponseTop(self, event):
""" Show valid response on top """
helpers = self.callbacks.getHelpers()
self.showResults.text = helpers.bytesToString(self.validResponse)
def showInvalidResponseTop(self, event):
""" Show invalid response on top """
helpers = self.callbacks.getHelpers()
self.showResults.text = helpers.bytesToString(self.invalidResponse)
##############################
# SECTION 4: DOWNLOAD BUTTON #
##############################
def downloadResults(self, event):
""" Method that allows user to download file to get the response's time """
try:
if (self.showResultsList.text == ""):
return
file = open(self.get_download_path() + "/downloadresults.txt", "w")
file.write(self.showResultsList.text)
file.close()
self.debugOutput(
"Download successful! \nCheck your downloads folder for the file."
)
except:
self.debugOutput("Download failed.")
def get_download_path(self):
""" Method to find path of download folder (called by downloadResults),
and it returns the default downloads path for linux or windows """
if os.name == 'nt':
import winreg
sub_key = r'SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders'
downloads_guid = '{374DE290-123F-4565-9164-39C4925E467B}'
with winreg.OpenKey(winreg.HKEY_CURRENT_USER, sub_key) as key:
location = winreg.QueryValueEx(key, downloads_guid)[0]
return location
else:
return os.path.join(os.path.expanduser('~'), 'downloads')
###########################
# SECTION 5: DEBUG BUTTON #
###########################
def debugOutput(self, message):
""" Write a debug message in the debug box """
self.debugText.text = message
self.debugTextScroll.setVisible(True)
self.viewDebug.setText("Close Debug Output")
self.debugOn = True
def showDebug(self, event):
""" Open or close debug box """
if self.debugOn:
self.debugTextScroll.setVisible(False)
self.viewDebug.setText("View Debug Output")
self.debugOn = False
self.debugText.text = ""
else:
self.debugTextScroll.setVisible(True)
self.viewDebug.setText("Close Debug Output")
self.debugOn = True
###################################
# SECTION 6: TAB RECIEVES REQUEST #
###################################
def getRequest(self, messageList):
""" Method that stores the request sent from proxy """
self.curRequest = messageList[0]
# Show request in top box
helpers = self.callbacks.getHelpers()
self.showResults.text = helpers.bytesToString(
self.curRequest.getRequest())
# Show request in bottom box
helpers = self.callbacks.getHelpers()
self.showResultsList.text = helpers.bytesToString(
self.curRequest.getRequest())
