From 07dc37902b57bbe3b0cd942863360c3429befda8 Mon Sep 17 00:00:00 2001 From: tebarius Date: Sat, 26 Jul 2025 18:41:41 +0200 Subject: [PATCH] chronogramm --- app/app.py | 2 +- app/tools.py | 851 +++++++++++++++++++++++++-------------------------- 2 files changed, 423 insertions(+), 430 deletions(-) diff --git a/app/app.py b/app/app.py index f217fb9..8df8225 100644 --- a/app/app.py +++ b/app/app.py @@ -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": diff --git a/app/tools.py b/app/tools.py index a2275f8..27627b3 100644 --- a/app/tools.py +++ b/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()