chronogramm
This commit is contained in:
@@ -218,7 +218,7 @@ def auswahl_verarbeiten():
|
||||
st.session_state.output_text = output
|
||||
st.session_state.map_data = mapd
|
||||
elif auswahl == "Quadtree/Quadkey":
|
||||
output, mapd = tools.quadtreekoordinaten(text)
|
||||
output, mapd = tools.quadtree_koordinaten(text)
|
||||
st.session_state.output_text = output
|
||||
st.session_state.map_data = mapd
|
||||
elif auswahl == "REPLACE":
|
||||
|
||||
851
app/tools.py
851
app/tools.py
@@ -2438,7 +2438,7 @@ def maptiles_kachelkoordinaten(eingabetext):
|
||||
else:
|
||||
return "Zahlen konnten nicht ermittelt werden!", None
|
||||
|
||||
def quadtreekoordinaten(eingabetext):
|
||||
def quadtree_koordinaten(eingabetext):
|
||||
hilfetext = ("### Quadtree-/Quadkeykoordinaten\n"
|
||||
"Diese Koordinatenkodierung spielt in der alltäglichen Praxis eigentlich kaum noch ein Rolle, "
|
||||
"außer scheinbar bei bing-maps und beim Geocaching. Sie dient ähnlich wie das Maptiles-System dazu "
|
||||
@@ -2487,35 +2487,27 @@ def quadtreekoordinaten(eingabetext):
|
||||
return ("Es konnte keine gültige Quadtree-Koordinate erkannt werden. (eine Zahl die nur die Ziffern "
|
||||
"0,1,2,3 enthält)"), None
|
||||
|
||||
'''
|
||||
def chronogramm():
|
||||
hilfetext = """HILFE: [Chronogramm/ römische Ziffern zählen]
|
||||
Ein Chronogramm (oder Eteostichon) ist ein Satzteil, ein Satz, ein Sinnspruch
|
||||
oder eine Inschrift, meist ein Vers in lateinischer Sprache, in dem diejenigen
|
||||
Buchstaben, die auch als römische Zahlzeichen gelesen werden können
|
||||
(I, V, X, L, C, D, M), in ihrer Summe die Jahreszahl des Ereignisses angeben,
|
||||
auf das sich der Text bezieht. Entscheidend ist allein die Summe der
|
||||
Zahlenwertbuchstaben, die sonst bei römischen Zahlen übliche Subtraktion
|
||||
kleinerer Zahlenwerte von folgenden größeren erfolgt nicht.
|
||||
Die Zahlbuchstaben sind meist hervorgehoben, etwa durch Großschreibung oder
|
||||
Verdickung der Buchstaben bzw. durch farbliche Abhebung mittels Rötung oder
|
||||
Vergoldung. Eine Besonderheit bilden Krypto(chrono)gramme, bei denen die
|
||||
Zahlbuchstaben nicht gekennzeichnet sind und "verborgen" bleiben.
|
||||
|
||||
Bei der einfachen Analyse werden hier die Buchstaben I(1),V(5),X(10),L(50),
|
||||
C(100), D(500), M(1000) berücksichtigt und addiert, bei der erweiterten
|
||||
Analyse wird zunächst einmal berücksichtigt, daß im Lateinischen Alphabet
|
||||
der Buchstabe J als I und der Buchstabe U als V geschrieben wird. Außerdem
|
||||
erfolgt wird in der extremen Variante auch noch W=10(V+V) und Y=2(I+I)
|
||||
berücksichtigt. Desweiteren wird auch für jeden relevanten Buchstaben
|
||||
einzeln noch einmal die Anzahl und Summe angezeigt.
|
||||
Eine Unterscheidung zwischen Klein- und Großschreibung findet nicht statt.
|
||||
"""
|
||||
|
||||
eingabetext = Eingabe.get(1.0, END)
|
||||
def chronogramm(eingabetext):
|
||||
hilfetext = ('### Chronogramm/ römische Ziffern zählen\n'
|
||||
'Ein Chronogramm (oder Eteostichon) ist ein Satzteil, ein Satz, ein Sinnspruch oder eine Inschrift, '
|
||||
'meist ein Vers in lateinischer Sprache, in dem diejenigen Buchstaben, die auch als römische '
|
||||
'Zahlzeichen gelesen werden können (I, V, X, L, C, D, M), in ihrer Summe die Jahreszahl des '
|
||||
'Ereignisses angeben, auf das sich der Text bezieht. Entscheidend ist allein die Summe der '
|
||||
'Zahlenwertbuchstaben, die sonst bei römischen Zahlen übliche Subtraktion kleinerer Zahlenwerte von '
|
||||
'folgenden größeren erfolgt nicht. Die Zahlbuchstaben sind meist hervorgehoben, etwa durch '
|
||||
'Großschreibung oder Verdickung der Buchstaben bzw. durch farbliche Abhebung mittels Rötung oder '
|
||||
'Vergoldung. \n'
|
||||
'Eine Besonderheit bilden Krypto(chrono)gramme, bei denen die Zahlbuchstaben nicht gekennzeichnet '
|
||||
'sind und "verborgen" bleiben. Bei der einfachen Analyse werden hier die Buchstaben I(1), V(5), '
|
||||
'X(10), L(50), C(100), D(500), M(1000) berücksichtigt und addiert, bei der erweiterten Analyse wird '
|
||||
'zunächst einmal berücksichtigt, daß im Lateinischen Alphabet der Buchstabe J als I und der '
|
||||
'Buchstabe U als V geschrieben wird. Außerdem erfolgt wird in der extremen Variante auch noch '
|
||||
'W=10(V+V) und Y=2(I+I) berücksichtigt. \n'
|
||||
'Des Weiteren wird auch für jeden relevanten Buchstaben einzeln noch einmal die Anzahl und Summe'
|
||||
' angezeigt. Eine Unterscheidung zwischen Klein- und Großschreibung findet nicht statt.')
|
||||
text = eingabetext.rstrip()
|
||||
if text == "":
|
||||
Ausgabe.insert(1.0, hilfetext + "\n")
|
||||
return hilfetext
|
||||
else:
|
||||
text = text.upper()
|
||||
i, v, x, ll, c, d, m, y, w, u, j = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
|
||||
@@ -2545,407 +2537,23 @@ Eine Unterscheidung zwischen Klein- und Großschreibung findet nicht statt.
|
||||
sum_einfach = i + (v * 5) + (x * 10) + (ll * 50) + (c * 100) + (d * 500) + (m * 1000)
|
||||
sum_erweitert = sum_einfach + (u * 5) + j
|
||||
sum_extrem = sum_erweitert + (y * 2) + (w * 10)
|
||||
Ausgabe.insert(1.0, "Summe extrem(inkl.J,U,Y,W): {}\n".format(sum_extrem))
|
||||
Ausgabe.insert(1.0, "Summe erweitert(inkl. I,U): {}\n".format(sum_erweitert))
|
||||
Ausgabe.insert(1.0, "Summe einfach(I,V,X,L,C,D,M): {}\n".format(sum_einfach))
|
||||
Ausgabe.insert(1.0, "W(V+V=10):{:5}x \tSumme W: {}\n".format(w, w * 10), "gr")
|
||||
Ausgabe.insert(1.0, " Y(I+I=2):{:5}x \tSumme Y: {}\n".format(y, y * 2), "gr")
|
||||
Ausgabe.insert(1.0, " U(V=5):{:5}x \tSumme U: {}\n".format(u, u * 5), "gr")
|
||||
Ausgabe.insert(1.0, " J(I=1):{:5}x \tSumme U: {}\n".format(j, j), "gr")
|
||||
Ausgabe.insert(1.0, " M(1000):{:5}x \tSumme M: {}\n".format(m, m * 1000), "gr")
|
||||
Ausgabe.insert(1.0, " D(500):{:5}x \tSumme D: {}\n".format(d, d * 500), "gr")
|
||||
Ausgabe.insert(1.0, " C(100):{:5}x \tSumme C: {}\n".format(c, c * 100), "gr")
|
||||
Ausgabe.insert(1.0, " L(50):{:5}x \tSumme L: {}\n".format(ll, ll * 50), "gr")
|
||||
Ausgabe.insert(1.0, " X(10):{:5}x \tSumme X: {}\n".format(x, x * 10), "gr")
|
||||
Ausgabe.insert(1.0, " V(5):{:5}x \tSumme V: {}\n".format(v, v * 5), "gr")
|
||||
Ausgabe.insert(1.0, " I(1):{:5}x \tSumme I: {}\n".format(i, i), "gr")
|
||||
|
||||
|
||||
def adfgx_kodieren():
|
||||
hilfetext = """HILFE: [ADFGX kodieren]
|
||||
Die ADFGX-Chiffre arbeitet mit zwei Passwörtern, wobei jedes für je einen
|
||||
Kodierungsschritt verwendet wird. Das erste wird benutzt um eine Variation
|
||||
der Polybios-Kodierung mit einem 5x5 Quadrat und J=I durchzuführen bei
|
||||
welcher die Zahlen 1-5 durch die Buchstaben ADFGX ersetzt werden.
|
||||
Mit dem Text "Ein Beispiel",dem Passwort "PASSWORT" und einem
|
||||
mit A->Z aufgefülltem Schlüsselquadrat ergibt der erste Schritt z.B. die
|
||||
Zeichenfolge: "FA FX GG DF FA FX AF AA FX FA GD". Nun kommt das zweite Passwort
|
||||
zum Einsatz als Beispiel hier:"Tester". Zunächst einmal wird die Zeichenfolge
|
||||
5 1 4 6 2 3 in der Breite des Passwort Zeilenweise darunter geschrieben,
|
||||
T E S T E R nun werden diese Spalten dem Passwort entsprechend
|
||||
F A F X G G alphabetisch sortiert und dann von oben nach unten abgelesen.
|
||||
D F F A F X Im Beispiel fängt es also mit der Spalte 1 dem E an dann das
|
||||
A F A A F X zweite E, dann R usw. was dann als kodierten Text, welcher
|
||||
F A G D typischer Weise in 5er-Blöcken ausgegeben wird folgendes
|
||||
ergibt: AFFAG FFGXX FFAGF DAFXA AD ergibt.
|
||||
Die beiden Varianten, welche ausgegeben werden, unterscheiden sich nur
|
||||
darin, wie das Schlüsselquadrat im ersten Kodierungsschritt aufgefüllt
|
||||
wird. Entweder in alphabetischer Reihenfolge A->Z oder umgekehrt Z->A.
|
||||
"""
|
||||
|
||||
eingabetext = Eingabe.get(1.0, END)
|
||||
text = eingabetext.rstrip()
|
||||
pw = PW_Eingabe.get()
|
||||
pw = pw.strip()
|
||||
if text == "":
|
||||
Ausgabe.insert(1.0, hilfetext + "\n")
|
||||
else:
|
||||
rn = ["AA", "AD", "AF", "AG", "AX", "DA", "DD", "DF", "DG", "DX", "FA", "FD", "FF", "FG", "FX", "GA", "GD",
|
||||
"GF", "GG", "GX", "XA", "XD", "XF", "XG", "XX"]
|
||||
alpha_az = "ABCDEFGHIKLMNOPQRSTUVWXYZ" # j wird durch i ersetzt
|
||||
alpha_za = "ZYXWVUTSRQPONMLKIHGFEDCBA"
|
||||
text = text.upper()
|
||||
text = text.replace("J", "I")
|
||||
pw = pw.upper()
|
||||
pw = pw.replace("J", "I")
|
||||
pw = pw.split(",")
|
||||
if len(pw) != 2:
|
||||
Ausgabe.insert(1.0, "Es es werden genau zwei durch Komma getrennte Passwörter benötigt!\n", "re")
|
||||
return
|
||||
pw[0] = pw[0].strip()
|
||||
pw[1] = pw[1].strip()
|
||||
pw1az = ""
|
||||
for b in pw[0] + alpha_az:
|
||||
if b in alpha_az and b not in pw1az:
|
||||
pw1az += b
|
||||
pw1za = ""
|
||||
for b in pw[0] + alpha_za:
|
||||
if b in alpha_za and b not in pw1za:
|
||||
pw1za += b
|
||||
pw2 = ""
|
||||
for i in pw[1]:
|
||||
if i in alpha_az:
|
||||
pw2 += i
|
||||
klartext = ""
|
||||
for i in text:
|
||||
if i in alpha_az:
|
||||
klartext += i
|
||||
w_baz = {}
|
||||
for i in range(25):
|
||||
w_baz[pw1az[i]] = rn[i]
|
||||
w_bza = {}
|
||||
for i in range(25):
|
||||
w_bza[pw1za[i]] = rn[i]
|
||||
ctext1az = ""
|
||||
for b in klartext:
|
||||
ctext1az += w_baz[b]
|
||||
print(ctext1az)
|
||||
ctext1za = ""
|
||||
for b in klartext:
|
||||
ctext1za += w_bza[b]
|
||||
ctext2az = []
|
||||
for i in range(len(pw2)):
|
||||
ctext2az.append([pw2[i] + str(i + 10)])
|
||||
for i in range(len(ctext1az)):
|
||||
ctext2az[i % len(pw2)].append(ctext1az[i])
|
||||
ctext2az.sort()
|
||||
ausgabe_az = ""
|
||||
z = 1
|
||||
for i in ctext2az:
|
||||
for j in range(len(i) - 1):
|
||||
if z == 5:
|
||||
ausgabe_az += i[j + 1] + " "
|
||||
z = 1
|
||||
else:
|
||||
ausgabe_az += i[j + 1]
|
||||
z += 1
|
||||
ctext2za = []
|
||||
for i in range(len(pw2)):
|
||||
ctext2za.append([pw2[i] + str(i + 10)])
|
||||
for i in range(len(ctext1za)):
|
||||
ctext2za[i % len(pw2)].append(ctext1za[i])
|
||||
ctext2za.sort()
|
||||
ausgabe_za = ""
|
||||
z = 1
|
||||
for i in ctext2za:
|
||||
for j in range(len(i) - 1):
|
||||
if z == 5:
|
||||
ausgabe_za += i[j + 1] + " "
|
||||
z = 1
|
||||
else:
|
||||
ausgabe_za += i[j + 1]
|
||||
z += 1
|
||||
Ausgabe.insert(1.0, ausgabe_za + "\n")
|
||||
Ausgabe.insert(1.0, "kodiert mit Variante Z-A:\n")
|
||||
Ausgabe.insert(1.0, ausgabe_az + "\n")
|
||||
Ausgabe.insert(1.0, "kodiert mit Variante A-Z:\n")
|
||||
Ausgabe.insert(1.0, "Passwort 2: {}\n".format(pw2), "gr")
|
||||
Ausgabe.insert(1.0, "Passwort 1: {}\n".format(pw[0]), "gr")
|
||||
|
||||
|
||||
def adfgx_dekodieren():
|
||||
hilfetext = """HILFE: [ADFGX dekodieren]
|
||||
Die ADFGX-Chiffre arbeitet mit zwei Passwörtern, wobei jedes für je einen
|
||||
Kodierungsschritt verwendet wird. Das erste wird benutzt um eine Variation
|
||||
der Polybios-Kodierung mit einem 5x5 Quadrat und J=I durchzuführen bei
|
||||
welcher die Zahlen 1-5 durch die Buchstaben ADFGX ersetzt werden.
|
||||
Mit dem Text "Ein Beispiel",dem Passwort "PASSWORT" und einem
|
||||
mit A->Z aufgefülltem Schlüsselquadrat ergibt der erste Schritt z.B. die
|
||||
Zeichenfolge: "FA FX GG DF FA FX AF AA FX FA GD". Nun kommt das zweite Passwort
|
||||
zum Einsatz als Beispiel hier:"Tester". Zunächst einmal wird die Zeichenfolge
|
||||
5 1 4 6 2 3 in der Breite des Passwort Zeilenweise darunter geschrieben,
|
||||
T E S T E R nun werden diese Spalten dem Passwort entsprechend
|
||||
F A F X G G alphabetisch sortiert und dann von oben nach unten abgelesen.
|
||||
D F F A F X Im Beispiel fängt es also mit der Spalte 1 dem E an dann das
|
||||
A F A A F X zweite E, dann R usw. was dann als kodierten Text, welcher
|
||||
F A G D typischer Weise in 5er-Blöcken ausgegeben wird folgendes
|
||||
ergibt: AFFAG FFGXX FFAGF DAFXA AD ergibt.
|
||||
Die beiden Varianten, welche ausgegeben werden, unterscheiden sich nur
|
||||
darin, wie das Schlüsselquadrat im ersten Kodierungsschritt aufgefüllt
|
||||
wird. Entweder in alphabetischer Reihenfolge A->Z oder umgekehrt Z->A.
|
||||
"""
|
||||
|
||||
eingabetext = Eingabe.get(1.0, END)
|
||||
text = eingabetext.rstrip()
|
||||
pw = PW_Eingabe.get()
|
||||
pw = pw.strip()
|
||||
if text == "":
|
||||
Ausgabe.insert(1.0, hilfetext + "\n")
|
||||
else:
|
||||
rn = ["AA", "AD", "AF", "AG", "AX", "DA", "DD", "DF", "DG", "DX", "FA", "FD", "FF", "FG", "FX", "GA", "GD",
|
||||
"GF", "GG", "GX", "XA", "XD", "XF", "XG", "XX"]
|
||||
alpha_az = "ABCDEFGHIKLMNOPQRSTUVWXYZ" # j wird durch i ersetzt
|
||||
alpha_za = "ZYXWVUTSRQPONMLKIHGFEDCBA"
|
||||
text = text.upper()
|
||||
text = text.replace("J", "I")
|
||||
pw = pw.upper()
|
||||
pw = pw.replace("J", "I")
|
||||
pw = pw.split(",")
|
||||
if len(pw) != 2:
|
||||
Ausgabe.insert(1.0, "Es es werden genau zwei durch Komma getrennte Passwörter benötigt!\n", "re")
|
||||
return
|
||||
pw[0] = pw[0].strip()
|
||||
pw[1] = pw[1].strip()
|
||||
pw1az = ""
|
||||
for b in pw[0] + alpha_az:
|
||||
if b in alpha_az and b not in pw1az:
|
||||
pw1az += b
|
||||
pw1za = ""
|
||||
for b in pw[0] + alpha_za:
|
||||
if b in alpha_za and b not in pw1za:
|
||||
pw1za += b
|
||||
pw2 = ""
|
||||
for i in pw[1]:
|
||||
if i in alpha_az:
|
||||
pw2 += i
|
||||
ctext = ""
|
||||
for i in text:
|
||||
if i in alpha_az:
|
||||
ctext += i
|
||||
w_baz = {}
|
||||
for i in range(25):
|
||||
w_baz[rn[i]] = pw1az[i]
|
||||
w_bza = {}
|
||||
for i in range(25):
|
||||
w_bza[rn[i]] = pw1za[i]
|
||||
ret = ['_'] * len(ctext)
|
||||
lt, lp = len(ctext), len(pw2)
|
||||
t1 = [(pw2[i], i) for i in range(len(pw2))]
|
||||
ind = [q[1] for q in sorted(t1)]
|
||||
upto = 0
|
||||
for i in range(len(pw2)):
|
||||
tic = int(lt / lp)
|
||||
if ind[i] < lt % lp:
|
||||
tic += 1
|
||||
ret[ind[i]::lp] = ctext[upto:upto + tic]
|
||||
upto += tic
|
||||
ctext = ''.join(ret)
|
||||
klartext_az = ""
|
||||
for i in range(0, len(ctext), 2):
|
||||
bi = ctext[i:i + 2]
|
||||
if bi in w_baz:
|
||||
klartext_az += w_baz[bi]
|
||||
klartext_za = ""
|
||||
for i in range(0, len(ctext), 2):
|
||||
bi = ctext[i:i + 2]
|
||||
if bi in w_bza:
|
||||
klartext_za += w_bza[bi]
|
||||
Ausgabe.insert(1.0, klartext_za + "\n")
|
||||
Ausgabe.insert(1.0, "dekodiert mit Variante Z-A:\n")
|
||||
Ausgabe.insert(1.0, klartext_az + "\n")
|
||||
Ausgabe.insert(1.0, "dekodiert mit Variante A-Z:\n")
|
||||
Ausgabe.insert(1.0, "Passwort 2: {}\n".format(pw2), "gr")
|
||||
Ausgabe.insert(1.0, "Passwort 1: {}\n".format(pw[0]), "gr")
|
||||
|
||||
|
||||
def adfgvx_kodieren():
|
||||
hilfetext = """HILFE: [ADFGVX kodieren]
|
||||
Die ADFGVX-Chiffre erweitert das 5x5-Schlüsselquadrat der ADFGX-Chiffre
|
||||
ersten Kodierungsschritt auf 6x6 so, daß das komplette Alphabet und die
|
||||
Zahlen 0-9 verwendet werden können. Die beiden ausgegebenen Varianten
|
||||
unterscheiden sich in der Variante wie das Schlüsselquadrat aufgefüllt
|
||||
wird (A->Z + 0->9 oder 9->0 + Z->A).
|
||||
"""
|
||||
|
||||
eingabetext = Eingabe.get(1.0, END)
|
||||
text = eingabetext.rstrip()
|
||||
pw = PW_Eingabe.get()
|
||||
pw = pw.strip()
|
||||
if text == "":
|
||||
Ausgabe.insert(1.0, hilfetext + "\n")
|
||||
else:
|
||||
rn = ["AA", "AD", "AF", "AG", "AV", "AX", "DA", "DD", "DF", "DG", "DV", "DX", "FA", "FD", "FF", "FG", "FV",
|
||||
"FX", "GA", "GD", "GF", "GG", "GV", "GX", "VA", "VD", "VF", "VG", "VV", "VX", "XA", "XD", "XF", "XG",
|
||||
"XV", "XX"]
|
||||
alpha_az09 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
|
||||
alpha_90za = "9876543210ZYXWVUTSRQPONMLKJIHGFEDCBA"
|
||||
text = text.upper()
|
||||
pw = pw.upper()
|
||||
pw = pw.split(",")
|
||||
if len(pw) != 2:
|
||||
Ausgabe.insert(1.0, "Es es werden genau zwei durch Komma getrennte Passwörter benötigt!\n", "re")
|
||||
return
|
||||
pw[0] = pw[0].strip()
|
||||
pw[1] = pw[1].strip()
|
||||
pw1az09 = ""
|
||||
for b in pw[0] + alpha_az09:
|
||||
if b in alpha_az09 and b not in pw1az09:
|
||||
pw1az09 += b
|
||||
pw190za = ""
|
||||
for b in pw[0] + alpha_90za:
|
||||
if b in alpha_90za and b not in pw190za:
|
||||
pw190za += b
|
||||
pw2 = ""
|
||||
for i in pw[1]:
|
||||
if i in alpha_az09:
|
||||
pw2 += i
|
||||
klartext = ""
|
||||
for i in text:
|
||||
if i in alpha_az09:
|
||||
klartext += i
|
||||
w_baz09 = {}
|
||||
for i in range(36):
|
||||
w_baz09[pw1az09[i]] = rn[i]
|
||||
wb90za = {}
|
||||
for i in range(36):
|
||||
wb90za[pw190za[i]] = rn[i]
|
||||
ctext1az09 = ""
|
||||
for b in klartext:
|
||||
ctext1az09 += w_baz09[b]
|
||||
ctext190za = ""
|
||||
for b in klartext:
|
||||
ctext190za += wb90za[b]
|
||||
ctext2az09 = []
|
||||
for i in range(len(pw2)):
|
||||
ctext2az09.append([pw2[i] + str(i + 10)])
|
||||
for i in range(len(ctext1az09)):
|
||||
ctext2az09[i % len(pw2)].append(ctext1az09[i])
|
||||
ctext2az09.sort()
|
||||
ausgabe_az09 = ""
|
||||
z = 1
|
||||
for i in ctext2az09:
|
||||
for j in range(len(i) - 1):
|
||||
if z == 5:
|
||||
ausgabe_az09 += i[j + 1] + " "
|
||||
z = 1
|
||||
else:
|
||||
ausgabe_az09 += i[j + 1]
|
||||
z += 1
|
||||
ctext290za = []
|
||||
for i in range(len(pw2)):
|
||||
ctext290za.append([pw2[i] + str(i + 10)])
|
||||
for i in range(len(ctext190za)):
|
||||
ctext290za[i % len(pw2)].append(ctext190za[i])
|
||||
ctext290za.sort()
|
||||
ausgabe_90za = ""
|
||||
z = 1
|
||||
for i in ctext290za:
|
||||
for j in range(len(i) - 1):
|
||||
if z == 5:
|
||||
ausgabe_90za += i[j + 1] + " "
|
||||
z = 1
|
||||
else:
|
||||
ausgabe_90za += i[j + 1]
|
||||
z += 1
|
||||
Ausgabe.insert(1.0, ausgabe_90za + "\n")
|
||||
Ausgabe.insert(1.0, "kodiert mit Variante 9-0,Z-A:\n")
|
||||
Ausgabe.insert(1.0, ausgabe_az09 + "\n")
|
||||
Ausgabe.insert(1.0, "kodiert mit Variante A-Z,0-9:\n")
|
||||
Ausgabe.insert(1.0, "Passwort 2: {}\n".format(pw2), "gr")
|
||||
Ausgabe.insert(1.0, "Passwort 1: {}\n".format(pw[0]), "gr")
|
||||
|
||||
|
||||
def adfgvx_dekodieren():
|
||||
hilfetext = """HILFE: [ADFGVX dekodieren]
|
||||
Die ADFGVX-Chiffre erweitert das 5x5-Schlüsselquadrat der ADFGX-Chiffre
|
||||
ersten Kodierungsschritt auf 6x6 so, daß das komplette Alphabet und die
|
||||
Zahlen 0-9 verwendet werden können. Die beiden ausgegebenen Varianten
|
||||
unterscheiden sich in der Variante wie das Schlüsselquadrat aufgefüllt
|
||||
wird (A->Z + 0->9 oder 9->0 + Z->A).
|
||||
"""
|
||||
|
||||
eingabetext = Eingabe.get(1.0, END)
|
||||
text = eingabetext.rstrip()
|
||||
pw = PW_Eingabe.get()
|
||||
pw = pw.strip()
|
||||
if text == "":
|
||||
Ausgabe.insert(1.0, hilfetext + "\n")
|
||||
else:
|
||||
rn = ["AA", "AD", "AF", "AG", "AV", "AX", "DA", "DD", "DF", "DG", "DV", "DX", "FA", "FD", "FF", "FG", "FV",
|
||||
"FX", "GA", "GD", "GF", "GG", "GV", "GX", "VA", "VD", "VF", "VG", "VV", "VX", "XA", "XD", "XF", "XG",
|
||||
"XV", "XX"]
|
||||
alpha_az09 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
|
||||
alpha_90za = "9876543210ZYXWVUTSRQPONMLKJIHGFEDCBA"
|
||||
text = text.upper()
|
||||
pw = pw.upper()
|
||||
pw = pw.split(",")
|
||||
if len(pw) != 2:
|
||||
Ausgabe.insert(1.0, "Es es werden genau zwei durch Komma getrennte Passwörter benötigt!\n", "re")
|
||||
return
|
||||
pw[0] = pw[0].strip()
|
||||
pw[1] = pw[1].strip()
|
||||
pw1az09 = ""
|
||||
for b in pw[0] + alpha_az09:
|
||||
if b in alpha_az09 and b not in pw1az09:
|
||||
pw1az09 += b
|
||||
pw190za = ""
|
||||
for b in pw[0] + alpha_90za:
|
||||
if b in alpha_90za and b not in pw190za:
|
||||
pw190za += b
|
||||
pw2 = ""
|
||||
for i in pw[1]:
|
||||
if i in alpha_az09:
|
||||
pw2 += i
|
||||
ctext = ""
|
||||
for i in text:
|
||||
if i in alpha_az09:
|
||||
ctext += i
|
||||
w_baz09 = {}
|
||||
for i in range(36):
|
||||
w_baz09[rn[i]] = pw1az09[i]
|
||||
wb90za = {}
|
||||
for i in range(36):
|
||||
wb90za[rn[i]] = pw190za[i]
|
||||
ret = ['_'] * len(ctext)
|
||||
lt, lp = len(ctext), len(pw2)
|
||||
t1 = [(pw2[i], i) for i in range(len(pw2))]
|
||||
ind = [q[1] for q in sorted(t1)]
|
||||
upto = 0
|
||||
for i in range(len(pw2)):
|
||||
tic = int(lt / lp)
|
||||
if ind[i] < lt % lp:
|
||||
tic += 1
|
||||
ret[ind[i]::lp] = ctext[upto:upto + tic]
|
||||
upto += tic
|
||||
ctext = ''.join(ret)
|
||||
klartext_az09 = ""
|
||||
for i in range(0, len(ctext), 2):
|
||||
bi = ctext[i:i + 2]
|
||||
if bi in w_baz09:
|
||||
klartext_az09 += w_baz09[bi]
|
||||
klartext_90za = ""
|
||||
for i in range(0, len(ctext), 2):
|
||||
bi = ctext[i:i + 2]
|
||||
if bi in wb90za:
|
||||
klartext_90za += wb90za[bi]
|
||||
Ausgabe.insert(1.0, klartext_90za + "\n")
|
||||
Ausgabe.insert(1.0, "dekodiert mit Variante 0-0,Z-A:\n")
|
||||
Ausgabe.insert(1.0, klartext_az09 + "\n")
|
||||
Ausgabe.insert(1.0, "dekodiert mit Variante A-Z,0-9:\n")
|
||||
Ausgabe.insert(1.0, "Passwort 2: {}\n".format(pw2), "gr")
|
||||
Ausgabe.insert(1.0, "Passwort 1: {}\n".format(pw[0]), "gr")
|
||||
|
||||
|
||||
ausgabetext = "|Buchstabe|Wert|Anzahl|Summe\n|-|-|-|-|\n"
|
||||
ausgabetext += f"|I|1|{i}|{i}|\n"
|
||||
ausgabetext += f"|V|5|{v}|{v*5}|\n"
|
||||
ausgabetext += f"|X|10|{x}|{x*10}|\n"
|
||||
ausgabetext += f"|L|50|{ll}|{ll*50}|\n"
|
||||
ausgabetext += f"|C|100|{c}|{c*100}|\n"
|
||||
ausgabetext += f"|D|500|{d}|{d*500}|\n"
|
||||
ausgabetext += f"|M|1000|{m}|{m*1000}\n"
|
||||
ausgabetext += f"|J(=I)|1|{j}|{j}|\n"
|
||||
ausgabetext += f"|U(=V)|5|{u}|{u*5}|\n"
|
||||
ausgabetext += f"|Y(=I+I)|2|{y}|{y*2}|\n"
|
||||
ausgabetext += f"|W(=V+V)|10|{w}|{w*10}\n \n"
|
||||
ausgabetext += f"Summe einfach(I,V,X,L,C,D,M): {sum_einfach} \n"
|
||||
ausgabetext += f"Summe erweitert(inkl. I,U): {sum_erweitert} \n"
|
||||
ausgabetext += f"Summe extrem(inkl.J,U,Y,W): {sum_extrem}"
|
||||
return ausgabetext
|
||||
'''
|
||||
def zahlen_roemisch_arabisch_umwandeln():
|
||||
hilfetext = """HILFE: [Römische in Arabische Zahlen umwandeln und umgekehrt]
|
||||
Es werden römische Zahlen in arabische umgewandelt und umgekehrt, die Funktion
|
||||
@@ -3249,6 +2857,391 @@ für alle Zeilenanzahlen von 2-12.""" + "\n\n")
|
||||
Ausgabe.insert(1.0, "Schlüsselzahl fehlerhaft oder kleiner als 2.\n", "re")
|
||||
|
||||
|
||||
def adfgx_kodieren():
|
||||
hilfetext = """HILFE: [ADFGX kodieren]
|
||||
Die ADFGX-Chiffre arbeitet mit zwei Passwörtern, wobei jedes für je einen
|
||||
Kodierungsschritt verwendet wird. Das erste wird benutzt um eine Variation
|
||||
der Polybios-Kodierung mit einem 5x5 Quadrat und J=I durchzuführen bei
|
||||
welcher die Zahlen 1-5 durch die Buchstaben ADFGX ersetzt werden.
|
||||
Mit dem Text "Ein Beispiel",dem Passwort "PASSWORT" und einem
|
||||
mit A->Z aufgefülltem Schlüsselquadrat ergibt der erste Schritt z.B. die
|
||||
Zeichenfolge: "FA FX GG DF FA FX AF AA FX FA GD". Nun kommt das zweite Passwort
|
||||
zum Einsatz als Beispiel hier:"Tester". Zunächst einmal wird die Zeichenfolge
|
||||
5 1 4 6 2 3 in der Breite des Passwort Zeilenweise darunter geschrieben,
|
||||
T E S T E R nun werden diese Spalten dem Passwort entsprechend
|
||||
F A F X G G alphabetisch sortiert und dann von oben nach unten abgelesen.
|
||||
D F F A F X Im Beispiel fängt es also mit der Spalte 1 dem E an dann das
|
||||
A F A A F X zweite E, dann R usw. was dann als kodierten Text, welcher
|
||||
F A G D typischer Weise in 5er-Blöcken ausgegeben wird folgendes
|
||||
ergibt: AFFAG FFGXX FFAGF DAFXA AD ergibt.
|
||||
Die beiden Varianten, welche ausgegeben werden, unterscheiden sich nur
|
||||
darin, wie das Schlüsselquadrat im ersten Kodierungsschritt aufgefüllt
|
||||
wird. Entweder in alphabetischer Reihenfolge A->Z oder umgekehrt Z->A.
|
||||
"""
|
||||
|
||||
eingabetext = Eingabe.get(1.0, END)
|
||||
text = eingabetext.rstrip()
|
||||
pw = PW_Eingabe.get()
|
||||
pw = pw.strip()
|
||||
if text == "":
|
||||
Ausgabe.insert(1.0, hilfetext + "\n")
|
||||
else:
|
||||
rn = ["AA", "AD", "AF", "AG", "AX", "DA", "DD", "DF", "DG", "DX", "FA", "FD", "FF", "FG", "FX", "GA", "GD",
|
||||
"GF", "GG", "GX", "XA", "XD", "XF", "XG", "XX"]
|
||||
alpha_az = "ABCDEFGHIKLMNOPQRSTUVWXYZ" # j wird durch i ersetzt
|
||||
alpha_za = "ZYXWVUTSRQPONMLKIHGFEDCBA"
|
||||
text = text.upper()
|
||||
text = text.replace("J", "I")
|
||||
pw = pw.upper()
|
||||
pw = pw.replace("J", "I")
|
||||
pw = pw.split(",")
|
||||
if len(pw) != 2:
|
||||
Ausgabe.insert(1.0, "Es es werden genau zwei durch Komma getrennte Passwörter benötigt!\n", "re")
|
||||
return
|
||||
pw[0] = pw[0].strip()
|
||||
pw[1] = pw[1].strip()
|
||||
pw1az = ""
|
||||
for b in pw[0] + alpha_az:
|
||||
if b in alpha_az and b not in pw1az:
|
||||
pw1az += b
|
||||
pw1za = ""
|
||||
for b in pw[0] + alpha_za:
|
||||
if b in alpha_za and b not in pw1za:
|
||||
pw1za += b
|
||||
pw2 = ""
|
||||
for i in pw[1]:
|
||||
if i in alpha_az:
|
||||
pw2 += i
|
||||
klartext = ""
|
||||
for i in text:
|
||||
if i in alpha_az:
|
||||
klartext += i
|
||||
w_baz = {}
|
||||
for i in range(25):
|
||||
w_baz[pw1az[i]] = rn[i]
|
||||
w_bza = {}
|
||||
for i in range(25):
|
||||
w_bza[pw1za[i]] = rn[i]
|
||||
ctext1az = ""
|
||||
for b in klartext:
|
||||
ctext1az += w_baz[b]
|
||||
print(ctext1az)
|
||||
ctext1za = ""
|
||||
for b in klartext:
|
||||
ctext1za += w_bza[b]
|
||||
ctext2az = []
|
||||
for i in range(len(pw2)):
|
||||
ctext2az.append([pw2[i] + str(i + 10)])
|
||||
for i in range(len(ctext1az)):
|
||||
ctext2az[i % len(pw2)].append(ctext1az[i])
|
||||
ctext2az.sort()
|
||||
ausgabe_az = ""
|
||||
z = 1
|
||||
for i in ctext2az:
|
||||
for j in range(len(i) - 1):
|
||||
if z == 5:
|
||||
ausgabe_az += i[j + 1] + " "
|
||||
z = 1
|
||||
else:
|
||||
ausgabe_az += i[j + 1]
|
||||
z += 1
|
||||
ctext2za = []
|
||||
for i in range(len(pw2)):
|
||||
ctext2za.append([pw2[i] + str(i + 10)])
|
||||
for i in range(len(ctext1za)):
|
||||
ctext2za[i % len(pw2)].append(ctext1za[i])
|
||||
ctext2za.sort()
|
||||
ausgabe_za = ""
|
||||
z = 1
|
||||
for i in ctext2za:
|
||||
for j in range(len(i) - 1):
|
||||
if z == 5:
|
||||
ausgabe_za += i[j + 1] + " "
|
||||
z = 1
|
||||
else:
|
||||
ausgabe_za += i[j + 1]
|
||||
z += 1
|
||||
Ausgabe.insert(1.0, ausgabe_za + "\n")
|
||||
Ausgabe.insert(1.0, "kodiert mit Variante Z-A:\n")
|
||||
Ausgabe.insert(1.0, ausgabe_az + "\n")
|
||||
Ausgabe.insert(1.0, "kodiert mit Variante A-Z:\n")
|
||||
Ausgabe.insert(1.0, "Passwort 2: {}\n".format(pw2), "gr")
|
||||
Ausgabe.insert(1.0, "Passwort 1: {}\n".format(pw[0]), "gr")
|
||||
|
||||
|
||||
def adfgx_dekodieren():
|
||||
hilfetext = """HILFE: [ADFGX dekodieren]
|
||||
Die ADFGX-Chiffre arbeitet mit zwei Passwörtern, wobei jedes für je einen
|
||||
Kodierungsschritt verwendet wird. Das erste wird benutzt um eine Variation
|
||||
der Polybios-Kodierung mit einem 5x5 Quadrat und J=I durchzuführen bei
|
||||
welcher die Zahlen 1-5 durch die Buchstaben ADFGX ersetzt werden.
|
||||
Mit dem Text "Ein Beispiel",dem Passwort "PASSWORT" und einem
|
||||
mit A->Z aufgefülltem Schlüsselquadrat ergibt der erste Schritt z.B. die
|
||||
Zeichenfolge: "FA FX GG DF FA FX AF AA FX FA GD". Nun kommt das zweite Passwort
|
||||
zum Einsatz als Beispiel hier:"Tester". Zunächst einmal wird die Zeichenfolge
|
||||
5 1 4 6 2 3 in der Breite des Passwort Zeilenweise darunter geschrieben,
|
||||
T E S T E R nun werden diese Spalten dem Passwort entsprechend
|
||||
F A F X G G alphabetisch sortiert und dann von oben nach unten abgelesen.
|
||||
D F F A F X Im Beispiel fängt es also mit der Spalte 1 dem E an dann das
|
||||
A F A A F X zweite E, dann R usw. was dann als kodierten Text, welcher
|
||||
F A G D typischer Weise in 5er-Blöcken ausgegeben wird folgendes
|
||||
ergibt: AFFAG FFGXX FFAGF DAFXA AD ergibt.
|
||||
Die beiden Varianten, welche ausgegeben werden, unterscheiden sich nur
|
||||
darin, wie das Schlüsselquadrat im ersten Kodierungsschritt aufgefüllt
|
||||
wird. Entweder in alphabetischer Reihenfolge A->Z oder umgekehrt Z->A.
|
||||
"""
|
||||
|
||||
eingabetext = Eingabe.get(1.0, END)
|
||||
text = eingabetext.rstrip()
|
||||
pw = PW_Eingabe.get()
|
||||
pw = pw.strip()
|
||||
if text == "":
|
||||
Ausgabe.insert(1.0, hilfetext + "\n")
|
||||
else:
|
||||
rn = ["AA", "AD", "AF", "AG", "AX", "DA", "DD", "DF", "DG", "DX", "FA", "FD", "FF", "FG", "FX", "GA", "GD",
|
||||
"GF", "GG", "GX", "XA", "XD", "XF", "XG", "XX"]
|
||||
alpha_az = "ABCDEFGHIKLMNOPQRSTUVWXYZ" # j wird durch i ersetzt
|
||||
alpha_za = "ZYXWVUTSRQPONMLKIHGFEDCBA"
|
||||
text = text.upper()
|
||||
text = text.replace("J", "I")
|
||||
pw = pw.upper()
|
||||
pw = pw.replace("J", "I")
|
||||
pw = pw.split(",")
|
||||
if len(pw) != 2:
|
||||
Ausgabe.insert(1.0, "Es es werden genau zwei durch Komma getrennte Passwörter benötigt!\n", "re")
|
||||
return
|
||||
pw[0] = pw[0].strip()
|
||||
pw[1] = pw[1].strip()
|
||||
pw1az = ""
|
||||
for b in pw[0] + alpha_az:
|
||||
if b in alpha_az and b not in pw1az:
|
||||
pw1az += b
|
||||
pw1za = ""
|
||||
for b in pw[0] + alpha_za:
|
||||
if b in alpha_za and b not in pw1za:
|
||||
pw1za += b
|
||||
pw2 = ""
|
||||
for i in pw[1]:
|
||||
if i in alpha_az:
|
||||
pw2 += i
|
||||
ctext = ""
|
||||
for i in text:
|
||||
if i in alpha_az:
|
||||
ctext += i
|
||||
w_baz = {}
|
||||
for i in range(25):
|
||||
w_baz[rn[i]] = pw1az[i]
|
||||
w_bza = {}
|
||||
for i in range(25):
|
||||
w_bza[rn[i]] = pw1za[i]
|
||||
ret = ['_'] * len(ctext)
|
||||
lt, lp = len(ctext), len(pw2)
|
||||
t1 = [(pw2[i], i) for i in range(len(pw2))]
|
||||
ind = [q[1] for q in sorted(t1)]
|
||||
upto = 0
|
||||
for i in range(len(pw2)):
|
||||
tic = int(lt / lp)
|
||||
if ind[i] < lt % lp:
|
||||
tic += 1
|
||||
ret[ind[i]::lp] = ctext[upto:upto + tic]
|
||||
upto += tic
|
||||
ctext = ''.join(ret)
|
||||
klartext_az = ""
|
||||
for i in range(0, len(ctext), 2):
|
||||
bi = ctext[i:i + 2]
|
||||
if bi in w_baz:
|
||||
klartext_az += w_baz[bi]
|
||||
klartext_za = ""
|
||||
for i in range(0, len(ctext), 2):
|
||||
bi = ctext[i:i + 2]
|
||||
if bi in w_bza:
|
||||
klartext_za += w_bza[bi]
|
||||
Ausgabe.insert(1.0, klartext_za + "\n")
|
||||
Ausgabe.insert(1.0, "dekodiert mit Variante Z-A:\n")
|
||||
Ausgabe.insert(1.0, klartext_az + "\n")
|
||||
Ausgabe.insert(1.0, "dekodiert mit Variante A-Z:\n")
|
||||
Ausgabe.insert(1.0, "Passwort 2: {}\n".format(pw2), "gr")
|
||||
Ausgabe.insert(1.0, "Passwort 1: {}\n".format(pw[0]), "gr")
|
||||
|
||||
|
||||
def adfgvx_kodieren():
|
||||
hilfetext = """HILFE: [ADFGVX kodieren]
|
||||
Die ADFGVX-Chiffre erweitert das 5x5-Schlüsselquadrat der ADFGX-Chiffre
|
||||
ersten Kodierungsschritt auf 6x6 so, daß das komplette Alphabet und die
|
||||
Zahlen 0-9 verwendet werden können. Die beiden ausgegebenen Varianten
|
||||
unterscheiden sich in der Variante wie das Schlüsselquadrat aufgefüllt
|
||||
wird (A->Z + 0->9 oder 9->0 + Z->A).
|
||||
"""
|
||||
|
||||
eingabetext = Eingabe.get(1.0, END)
|
||||
text = eingabetext.rstrip()
|
||||
pw = PW_Eingabe.get()
|
||||
pw = pw.strip()
|
||||
if text == "":
|
||||
Ausgabe.insert(1.0, hilfetext + "\n")
|
||||
else:
|
||||
rn = ["AA", "AD", "AF", "AG", "AV", "AX", "DA", "DD", "DF", "DG", "DV", "DX", "FA", "FD", "FF", "FG", "FV",
|
||||
"FX", "GA", "GD", "GF", "GG", "GV", "GX", "VA", "VD", "VF", "VG", "VV", "VX", "XA", "XD", "XF", "XG",
|
||||
"XV", "XX"]
|
||||
alpha_az09 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
|
||||
alpha_90za = "9876543210ZYXWVUTSRQPONMLKJIHGFEDCBA"
|
||||
text = text.upper()
|
||||
pw = pw.upper()
|
||||
pw = pw.split(",")
|
||||
if len(pw) != 2:
|
||||
Ausgabe.insert(1.0, "Es es werden genau zwei durch Komma getrennte Passwörter benötigt!\n", "re")
|
||||
return
|
||||
pw[0] = pw[0].strip()
|
||||
pw[1] = pw[1].strip()
|
||||
pw1az09 = ""
|
||||
for b in pw[0] + alpha_az09:
|
||||
if b in alpha_az09 and b not in pw1az09:
|
||||
pw1az09 += b
|
||||
pw190za = ""
|
||||
for b in pw[0] + alpha_90za:
|
||||
if b in alpha_90za and b not in pw190za:
|
||||
pw190za += b
|
||||
pw2 = ""
|
||||
for i in pw[1]:
|
||||
if i in alpha_az09:
|
||||
pw2 += i
|
||||
klartext = ""
|
||||
for i in text:
|
||||
if i in alpha_az09:
|
||||
klartext += i
|
||||
w_baz09 = {}
|
||||
for i in range(36):
|
||||
w_baz09[pw1az09[i]] = rn[i]
|
||||
wb90za = {}
|
||||
for i in range(36):
|
||||
wb90za[pw190za[i]] = rn[i]
|
||||
ctext1az09 = ""
|
||||
for b in klartext:
|
||||
ctext1az09 += w_baz09[b]
|
||||
ctext190za = ""
|
||||
for b in klartext:
|
||||
ctext190za += wb90za[b]
|
||||
ctext2az09 = []
|
||||
for i in range(len(pw2)):
|
||||
ctext2az09.append([pw2[i] + str(i + 10)])
|
||||
for i in range(len(ctext1az09)):
|
||||
ctext2az09[i % len(pw2)].append(ctext1az09[i])
|
||||
ctext2az09.sort()
|
||||
ausgabe_az09 = ""
|
||||
z = 1
|
||||
for i in ctext2az09:
|
||||
for j in range(len(i) - 1):
|
||||
if z == 5:
|
||||
ausgabe_az09 += i[j + 1] + " "
|
||||
z = 1
|
||||
else:
|
||||
ausgabe_az09 += i[j + 1]
|
||||
z += 1
|
||||
ctext290za = []
|
||||
for i in range(len(pw2)):
|
||||
ctext290za.append([pw2[i] + str(i + 10)])
|
||||
for i in range(len(ctext190za)):
|
||||
ctext290za[i % len(pw2)].append(ctext190za[i])
|
||||
ctext290za.sort()
|
||||
ausgabe_90za = ""
|
||||
z = 1
|
||||
for i in ctext290za:
|
||||
for j in range(len(i) - 1):
|
||||
if z == 5:
|
||||
ausgabe_90za += i[j + 1] + " "
|
||||
z = 1
|
||||
else:
|
||||
ausgabe_90za += i[j + 1]
|
||||
z += 1
|
||||
Ausgabe.insert(1.0, ausgabe_90za + "\n")
|
||||
Ausgabe.insert(1.0, "kodiert mit Variante 9-0,Z-A:\n")
|
||||
Ausgabe.insert(1.0, ausgabe_az09 + "\n")
|
||||
Ausgabe.insert(1.0, "kodiert mit Variante A-Z,0-9:\n")
|
||||
Ausgabe.insert(1.0, "Passwort 2: {}\n".format(pw2), "gr")
|
||||
Ausgabe.insert(1.0, "Passwort 1: {}\n".format(pw[0]), "gr")
|
||||
|
||||
|
||||
def adfgvx_dekodieren():
|
||||
hilfetext = """HILFE: [ADFGVX dekodieren]
|
||||
Die ADFGVX-Chiffre erweitert das 5x5-Schlüsselquadrat der ADFGX-Chiffre
|
||||
ersten Kodierungsschritt auf 6x6 so, daß das komplette Alphabet und die
|
||||
Zahlen 0-9 verwendet werden können. Die beiden ausgegebenen Varianten
|
||||
unterscheiden sich in der Variante wie das Schlüsselquadrat aufgefüllt
|
||||
wird (A->Z + 0->9 oder 9->0 + Z->A).
|
||||
"""
|
||||
|
||||
eingabetext = Eingabe.get(1.0, END)
|
||||
text = eingabetext.rstrip()
|
||||
pw = PW_Eingabe.get()
|
||||
pw = pw.strip()
|
||||
if text == "":
|
||||
Ausgabe.insert(1.0, hilfetext + "\n")
|
||||
else:
|
||||
rn = ["AA", "AD", "AF", "AG", "AV", "AX", "DA", "DD", "DF", "DG", "DV", "DX", "FA", "FD", "FF", "FG", "FV",
|
||||
"FX", "GA", "GD", "GF", "GG", "GV", "GX", "VA", "VD", "VF", "VG", "VV", "VX", "XA", "XD", "XF", "XG",
|
||||
"XV", "XX"]
|
||||
alpha_az09 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
|
||||
alpha_90za = "9876543210ZYXWVUTSRQPONMLKJIHGFEDCBA"
|
||||
text = text.upper()
|
||||
pw = pw.upper()
|
||||
pw = pw.split(",")
|
||||
if len(pw) != 2:
|
||||
Ausgabe.insert(1.0, "Es es werden genau zwei durch Komma getrennte Passwörter benötigt!\n", "re")
|
||||
return
|
||||
pw[0] = pw[0].strip()
|
||||
pw[1] = pw[1].strip()
|
||||
pw1az09 = ""
|
||||
for b in pw[0] + alpha_az09:
|
||||
if b in alpha_az09 and b not in pw1az09:
|
||||
pw1az09 += b
|
||||
pw190za = ""
|
||||
for b in pw[0] + alpha_90za:
|
||||
if b in alpha_90za and b not in pw190za:
|
||||
pw190za += b
|
||||
pw2 = ""
|
||||
for i in pw[1]:
|
||||
if i in alpha_az09:
|
||||
pw2 += i
|
||||
ctext = ""
|
||||
for i in text:
|
||||
if i in alpha_az09:
|
||||
ctext += i
|
||||
w_baz09 = {}
|
||||
for i in range(36):
|
||||
w_baz09[rn[i]] = pw1az09[i]
|
||||
wb90za = {}
|
||||
for i in range(36):
|
||||
wb90za[rn[i]] = pw190za[i]
|
||||
ret = ['_'] * len(ctext)
|
||||
lt, lp = len(ctext), len(pw2)
|
||||
t1 = [(pw2[i], i) for i in range(len(pw2))]
|
||||
ind = [q[1] for q in sorted(t1)]
|
||||
upto = 0
|
||||
for i in range(len(pw2)):
|
||||
tic = int(lt / lp)
|
||||
if ind[i] < lt % lp:
|
||||
tic += 1
|
||||
ret[ind[i]::lp] = ctext[upto:upto + tic]
|
||||
upto += tic
|
||||
ctext = ''.join(ret)
|
||||
klartext_az09 = ""
|
||||
for i in range(0, len(ctext), 2):
|
||||
bi = ctext[i:i + 2]
|
||||
if bi in w_baz09:
|
||||
klartext_az09 += w_baz09[bi]
|
||||
klartext_90za = ""
|
||||
for i in range(0, len(ctext), 2):
|
||||
bi = ctext[i:i + 2]
|
||||
if bi in wb90za:
|
||||
klartext_90za += wb90za[bi]
|
||||
Ausgabe.insert(1.0, klartext_90za + "\n")
|
||||
Ausgabe.insert(1.0, "dekodiert mit Variante 0-0,Z-A:\n")
|
||||
Ausgabe.insert(1.0, klartext_az09 + "\n")
|
||||
Ausgabe.insert(1.0, "dekodiert mit Variante A-Z,0-9:\n")
|
||||
Ausgabe.insert(1.0, "Passwort 2: {}\n".format(pw2), "gr")
|
||||
Ausgabe.insert(1.0, "Passwort 1: {}\n".format(pw[0]), "gr")
|
||||
|
||||
|
||||
def brainfuck_interpreter():
|
||||
eingabetext = Eingabe.get(1.0, END)
|
||||
eingabetext = eingabetext.rstrip()
|
||||
|
||||
Reference in New Issue
Block a user