From 8dc56b70b2269fb37edf2a20c82f9ba14ebe2ebb Mon Sep 17 00:00:00 2001 From: tebarius Date: Sat, 26 Jul 2025 22:39:36 +0200 Subject: [PATCH] =?UTF-8?q?chronogramm,=20r=C3=B6m-zahlen,=20urls-decode,?= =?UTF-8?q?=20reverse-wig,=20bas64,=20j=C3=A4gerzaun?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- app/app.py | 33 +++++ app/helper.py | 69 ++++++++-- app/tools.py | 322 ++++++++++++++++------------------------------- requirements.txt | Bin 44 -> 74 bytes 4 files changed, 201 insertions(+), 223 deletions(-) diff --git a/app/app.py b/app/app.py index 8df8225..f2017d1 100644 --- a/app/app.py +++ b/app/app.py @@ -221,6 +221,27 @@ def auswahl_verarbeiten(): output, mapd = tools.quadtree_koordinaten(text) st.session_state.output_text = output st.session_state.map_data = mapd + elif auswahl == "Chronogramm": + st.session_state.output_text = tools.chronogramm(text) + st.session_state.map_data = None + elif auswahl == "Zahl röm.<->arabisch": + st.session_state.output_text = tools.zahlen_roemisch_arabisch_umwandeln(text) + st.session_state.map_data = None + elif auswahl == "URL decode": + st.session_state.output_text = tools.url_decode(text) + st.session_state.map_data = None + elif auswahl == "Reverse-Wherigo": + st.session_state.output_text = tools.reversewig(text) + st.session_state.map_data = None + elif auswahl == "Base64<->ASCII": + st.session_state.output_text = tools.base64_ascii(text) + st.session_state.map_data = None + elif auswahl == "Jägerzaun kodieren": + st.session_state.output_text = tools.jaegerzaun_encrypt(text, additional_parameter) + st.session_state.map_data = None + elif auswahl == "Jägerzaun dekodieren": + st.session_state.output_text = tools.jaegerzaun_decrypt(text, additional_parameter) + st.session_state.map_data = None elif auswahl == "REPLACE": st.session_state.output_text = tools.REPLACE(text) st.session_state.map_data = None @@ -311,6 +332,13 @@ option = st.sidebar.radio("hidden_label", "Klopfcode dekodieren", "Maptiles/Kachelkoord.", "Quadtree/Quadkey", + "Chronogramm", + "Zahl röm.<->arabisch", + "URL decode", + "Reverse-Wherigo", + "Base64<->ASCII", + "Jägerzaun kodieren", + "Jägerzaun dekodieren", "Dummy mit Karte", ), key='option', @@ -335,6 +363,11 @@ elif option in ["Mono.-Substitution"]: "Schlüsselwort/Schlüsselalphabet:", placeholder="Schlüsselwort/Schlüsselalphabet hier eingeben" ) +elif option in ["Jägerzaun kodieren", "Jägerzaun dekodieren"]: + additional_parameter = st.text_input( + "Schlüsselfeld:", + placeholder="Schlüsselzahl hier eingeben" + ) # Button zum manuellen Ausführen der Verarbeitungsfunktion if st.button(f"{st.session_state.option}"): auswahl_verarbeiten() diff --git a/app/helper.py b/app/helper.py index 9bd8495..1ac6e17 100644 --- a/app/helper.py +++ b/app/helper.py @@ -12,7 +12,6 @@ def q_sum(n): n = q_sum(n // 10) + n % 10 return n - # ***recursive iterierte quersummenfunktion*** def iq_sum(n): if n < 10: @@ -21,7 +20,6 @@ def iq_sum(n): n = iq_sum(q_sum(n)) return n - # ***produziert eine Liste mit Primzahlen kleiner als grenze*** # ***nach dem Prinzip des "Sieb des Eratosthenes"*** @st.cache_resource @@ -39,7 +37,6 @@ def primzahlliste(grenze): primes.append(i) return primes - # ***alle permutationen generieren*** def all_perms(liste): if len(liste) <= 1: @@ -49,7 +46,6 @@ def all_perms(liste): for i in range(len(perm) + 1): yield perm[:i] + liste[0:1] + perm[i:] - # ***zählfunktionen für anagramm suche def buchstabenzaehl(buchstabe, anzahl): if buchstabe in anzahl: @@ -57,14 +53,12 @@ def buchstabenzaehl(buchstabe, anzahl): else: anzahl[buchstabe] = 1 - def wortzaehl(wort): anzahl = {} for buchstabe in wort: buchstabenzaehl(buchstabe.upper(), anzahl) return anzahl - # ***Funktionen für Kachelkoordinaten/Maptiles-Funktion def dec_to_maptiles(lat_deg, lon_deg, zoom): lat_rad = math.radians(lat_deg) @@ -73,7 +67,6 @@ def dec_to_maptiles(lat_deg, lon_deg, zoom): ytile = int((1.0 - math.log(math.tan(lat_rad) + (1 / math.cos(lat_rad))) / math.pi) / 2.0 * n) return xtile, ytile - def maptiles_to_dec(xtile, ytile, zoom): n = 2.0 ** zoom lon_dec = xtile / n * 360.0 - 180.0 @@ -81,7 +74,6 @@ def maptiles_to_dec(xtile, ytile, zoom): lat_dec = math.degrees(lat_rad) return lat_dec, lon_dec - # ***Dezimalgrad in Dezimalminuten (Ausgabe als String) def dec_to_deg(lat_dec, lon_dec): if lat_dec < 0: @@ -101,7 +93,6 @@ def dec_to_deg(lat_dec, lon_dec): return ("{}{} {:.3f} {}{} {:.3f}".format(lat_pre, lat_degree, round(lat_minutes, 3), lon_pre, lon_degree, round(lon_minutes, 3))) - # ***ReverseWherIGo zu Dezimalgrad def rwig_to_coords(a, b, c): lat, lon = 0, 0 @@ -286,3 +277,63 @@ def t9_germandic(eingabetext): ausgabetext += zeile + " \n" wbfile.close() return ausgabetext + +def rail_encrypt(plain_text: str, rails: int): + arr = [["" for _ in range(len(plain_text))] for _ in range(rails)] + r = 0 + z = 0 + plus = True + for b in plain_text: + arr[r][z] = b + z += 1 + if r + 1 == rails and plus: + plus = False + r -= 1 + elif r - 1 < 0 and not plus: + plus = True + r += 1 + elif plus: + r += 1 + else: + r -= 1 + out = "" + for i in range(rails): + for j in range(len(plain_text)): + out += arr[i][j] + return out + +def rail_decrypt(cipher: str, rails: int): + arr = [["_" for _ in range(len(cipher))] for _ in range(rails)] + # cipher ins array reinbasteln + x, y = 0, 0 + first_x = True + for b in cipher: + if x >= len(cipher) and y < rails: + y += 1 + x = y + first_x = True + arr[y][x] = b + if y == 0 or (first_x and y != rails - 1): + x = x + (rails - y - 1) * 2 + first_x = False + elif y == rails - 1 or first_x is False: + x = x + (y * 2) + first_x = True + # dekodierten Text aus array holen + out = "" + x, y = 0, 0 + down = True + for _ in range(len(cipher)): + out += arr[y][x] + x += 1 + if down and y + 1 == rails: + down = False + y -= 1 + elif down: + y += 1 + elif down is False and y == 0: + down = True + y += 1 + elif down is False: + y -= 1 + return out diff --git a/app/tools.py b/app/tools.py index 27627b3..1b67807 100644 --- a/app/tools.py +++ b/app/tools.py @@ -4,6 +4,7 @@ from itertools import chain # für primfaktoren zerlegung import helper import pandas as pd from urllib.parse import unquote as urllib_parse_unquote # für nak-nak +import binascii # für base64_ascii def funktion_mit_karte(text,param): """Verarbeitet Text und liefert Daten für eine Karte (z.B. Potsdam Zentrum).""" @@ -2553,21 +2554,17 @@ def chronogramm(eingabetext): 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 -arbeitet dabei bei der Umwandlung von arabisch zu römisch mit Werten bis -maximal 500000. Es werden folgende Zeichen verwendet: I=1, V=5, X=10, L=50, -C=100, D=500, M=1000, \u2181=5000, \u2182=10000, \u2187=50000, \u2188=100000 -Etwas Vorsicht sollte bei einer Umwandlung von römischen in arabische Zahlen -geboten sein, wenn mit untypischen Schreibweisen gearbeitet wird bei welchen -mehr als ein Zeichen von dem nachfolgenden Zeichen abgezogen werden soll. -Die eigentlich inkorrekte Schreibweise IIX für die Zahl 8 wird hier die Zahl -10 als Ergebnis haben (+1-1+10), dafür wird aber allerdings die ebenfalls -falsche Schreibweise IM genauso als 999 wie die korrekte Schreibweise CMXCIX -erkannt. -""" + +def zahlen_roemisch_arabisch_umwandeln(eingabetext): + hilfetext = ("### Römische in Arabische Zahlen umwandeln und umgekehrt\n" + "Es werden römische Zahlen in arabische umgewandelt und umgekehrt, die Funktion arbeitet dabei bei " + "der Umwandlung von arabisch zu römisch mit Werten bis maximal 500000. Es werden folgende Zeichen " + "verwendet: I=1, V=5, X=10, L=50, C=100, D=500, M=1000, \u2181=5000, \u2182=10000, \u2187=50000, " + "\u2188=100000 \nEtwas Vorsicht sollte bei einer Umwandlung von römischen in arabische Zahlen " + "geboten sein, wenn mit untypischen Schreibweisen gearbeitet wird bei welchen mehr als ein Zeichen " + "von dem nachfolgenden Zeichen abgezogen werden soll. Die eigentlich inkorrekte Schreibweise IIX " + "für die Zahl 8 wird hier die Zahl 10 als Ergebnis haben (+1-1+10), dafür wird aber allerdings die " + "ebenfalls falsche Schreibweise IM genauso als 999 wie die korrekte Schreibweise CMXCIX erkannt.") rza = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000, '\u2181': 5000, '\u2182': 10000, '\u2187': 50000, '\u2188': 100000} azr = [(100000, '\u2188'), (90000, '\u2182\u2188'), (50000, '\u2187'), (40000, '\u2182\u2187'), @@ -2575,11 +2572,9 @@ erkannt. (500, 'D'), (400, 'CD'), (100, 'C'), (90, 'XC'), (50, 'L'), (40, 'XL'), (10, 'X'), (9, 'IX'), (5, 'V'), (4, 'IV'), (1, 'I')] - - eingabetext = Eingabe.get(1.0, END) rz = eingabetext.rstrip() if rz == "": - Ausgabe.insert(1.0, hilfetext + "\n") + return hilfetext else: rz = rz.upper() try: @@ -2587,7 +2582,7 @@ erkannt. for i in range(len(rz)): if i == len(rz) - 1: az += rza[rz[i]] - Ausgabe.insert(1.0, "{} = {}\n".format(rz, az)) + return f"{rz} = {az}" else: if rza[rz[i]] < rza[rz[i + 1]]: az -= rza[rz[i]] @@ -2597,66 +2592,47 @@ erkannt. try: zahl = int(rz) if zahl > 500000: - Ausgabe.insert(1.0, "arabische Zahlen größer als 500000 mag ich nicht in römische Zahlen!\n", "re") - return + return "arabische Zahlen größer als 500000 mag ich nicht in römische Zahlen!" rom = "" for az, romz in azr: count = zahl // az zahl -= az * count rom += romz * count - Ausgabe.insert(1.0, "{} = {}\n".format(rz, rom)) + return f"{rz} = {rom}" except ValueError: - Ausgabe.insert(1.0, "Es konnte keine römische oder arabische Zahl erkannt werden!\n", "re") + return "Es konnte keine römische oder arabische Zahl erkannt werden!" + return "" - - -def url_decode(): - - eingabetext = Eingabe.get(1.0, END) +def url_decode(eingabetext): eingabetext = eingabetext.rstrip() if eingabetext == "": - Ausgabe.insert(1.0, """HILFE: [URL-decode] -Nachdem Groundspeak nun inzwischen sämtliche Bilddateien -über einen Proxy umleitet bevor sie im Listing erscheinen -wird es manchmal schwer die ursprüngliche URL und/oder -den Dateinamen des Bildes noch lesen zu können. -Die URL hat dort nun jeweils folgendes Muster: -https://imgproxy.geocaching.com/......?url=..... -wobei nach dem ?url= dann die ursprüngliche Bild-URL -folgt, allerdings wird dabei dann aus -http:// folgendes http%3A%2F%2F und um genau dieses -wieder normal lesbar zu machen dient diese Funktion\n\n""") + return ("### URL-decode\n" + "Nachdem Groundspeak nun inzwischen sämtliche Bilddateien über einen Proxy umleitet bevor sie im " + "Listing erscheinen wird es manchmal schwer die ursprüngliche URL und/oder den Dateinamen des " + "Bildes noch lesen zu können. Die URL hat dort nun jeweils folgendes Muster: " + "`https://imgproxy.geocaching.com/......?url=.....` wobei nach dem `?url=` dann die ursprüngliche " + "Bild-URL folgt, allerdings wird dabei dann aus `http://` folgendes `http%3A%2F%2F` und um genau " + "dieses wieder normal lesbar zu machen dient diese Funktion") else: atxt = urllib_parse_unquote(eingabetext) - Ausgabe.insert(1.0, atxt + "\n") - Ausgabe.insert(1.0, "dekodierte URL:\n", "bu") + return f"dekodierte URL: `{atxt}`" - -def reversewig(): +def reversewig(eingabetext): seperator = ("|,", "_", "/", ";", ",") - - eingabetext = Eingabe.get(1.0, END) eingabetext = eingabetext.rstrip() if eingabetext == "": - Ausgabe.insert(1.0, """HILFE: [Reverse Wherigo zu Koordinaten] -Mit dem Reverse Wherigo hat -Waldmeister- eigentlich eine coole Sache -erfunden. Man hat anfangs keine Koordinaten sondern nur 3 Zahlen, welche -man nach Start des Wherigo-Cartridges eingibt und dann erfährt man wie weit -der Cache entfernt ist. Nun kann man immer wieder von unterschiedlichen -Positionen aus diese Entfernungsfragen durchführen und sich damit dem -Cache nähern. Je weniger Abfragen man braucht umso besser. -Leider gibt es inzwischen genügend Tools die genau wie diese Funktion -hier aus den 3 Zahlen direkt die Finalkoordinaten ermitteln können. -Leider??? Ja leider denn das führt auch dazu, das es inzwischen so extrem -viele dieser Reverse-Wherigos gibt wo sich die Owner anscheinend auch -denken "Die spielt doch sowieso keiner mehr normal..." anders kann ich -mir ganze Trails mit Reverse-Wherigos nicht erklären. - -Um die Funktion zu nutzen braucht man nur die 3 Zahlen durch ein entsprechendes -Trennzeichen: | , _ / ; , oder Leerzeichen eingeben und auf den Knopp klicken -und bekommt Koordinaten. - -""" + "\n\n") + return ('### Reverse Wherigo zu Koordinaten\n' + 'Mit dem Reverse Wherigo hat -Waldmeister- eigentlich eine coole Sache erfunden. Man hat anfangs ' + 'keine Koordinaten sondern nur 3 Zahlen, welche man nach Start des Wherigo-Cartridges eingibt und ' + 'dann erfährt man wie weit der Cache entfernt ist. Nun kann man immer wieder von unterschiedlichen ' + 'Positionen aus diese Entfernungsfragen durchführen und sich damit dem Cache nähern. Je weniger ' + 'Abfragen man braucht umso besser. Leider gibt es inzwischen genügend Tools die genau wie diese ' + 'Funktion hier aus den 3 Zahlen direkt die Finalkoordinaten ermitteln können. \n' + ' Leider??? Ja leider denn das führt auch dazu, das es inzwischen so extrem viele dieser ' + 'Reverse-Wherigos gibt wo sich die Owner anscheinend auch denken "Die spielt doch sowieso keiner ' + 'mehr normal..." anders kann ich mir ganze Trails mit Reverse-Wherigos nicht erklären. Um die ' + 'Funktion zu nutzen braucht man nur die 3 Zahlen durch ein entsprechendes Trennzeichen: ' + '| , _ / ; , oder Leerzeichen eingeben und auf den Knopp klicken und bekommt Koordinaten.') else: se = "" for s in seperator: @@ -2665,198 +2641,116 @@ und bekommt Koordinaten. if se == "" and " " in eingabetext: se = " " if se == "": - Ausgabe.insert(1.0, "Keine gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!\n", "re") + return "Keine gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!" else: txt = eingabetext.split(se) if len(txt) == 3: + ausgabetext = "" error = 0 for z in txt: try: int(z) except ValueError: - Ausgabe.insert(1.0, "Bitte die Eingabezahlen überprüfen\n", "re") + ausgabetext += "Bitte die Eingabezahlen überprüfen \n" error += 1 if error == 0: - final = rwig_to_coords(txt[0], txt[1], txt[2]) - Ausgabe.insert(1.0, "DEG: " + dec_to_deg(final[0], final[1]) + "\n") - Ausgabe.insert(1.0, "DEC: " + str(final[0]) + " " + str(final[1]) + "\n") - Ausgabe.insert(1.0, "WIG: " + txt[0] + ", " + txt[1] + ", " + txt[2] + "\n") - + final = helper.rwig_to_coords(txt[0], txt[1], txt[2]) + ausgabetext += "WIG: " + txt[0] + ", " + txt[1] + ", " + txt[2] + " \n" + ausgabetext += "DEC: " + str(final[0]) + " " + str(final[1]) + " \n" + ausgabetext += "DEG: " + helper.dec_to_deg(final[0], final[1]) + " \n" + return ausgabetext else: - Ausgabe.insert(1.0, "Es wurden nicht 3 Zahlen erkannt.\n", "re") + return "Es wurden nicht 3 Zahlen erkannt. \n" - -def base64_ascii(): - - eingabetext = Eingabe.get(1.0, END) +def base64_ascii(eingabetext): eingabetext = eingabetext.rstrip() if eingabetext == "": - Ausgabe.insert(1.0, """HILFE: [Base64 <-> ASCII] -Base64 ist ein Kodierungsverfahren, welches dazu verwendet wird -um beliebige Binärdaten nur Hilfe einer Zeichenkette aus A-Z, -a-z, 0-9, +, / sowie am Ende = übertragen zu können. Ein Einsatzzweck -dafür ist z.B. wenn bei EMails Dateianhänge verwendet werden, dort -werden nahezu alle Dateiformate base64-kodiert übertragen. -Auch bei dem einem oder anderen Mystery sind mir solche kodierten -Zeichenketten schon begegnet. Wenn am Ende einer Zeichenkette ein -oder zwei "="-Zeichen stehen ist die Wahrscheinlichkeit recht groß, -das hier base64 verwendet wurde. Das "="-Zeichen dient hier nämlich -als "Lückenfüller" am Ende. -Die Funktion hier versucht zunächst eine Dekodierung Base64->ASCII -gelingt dies nicht, erscheint ein Hinweis und der eingegeben Text -wird dann Base64-kodiert ausgegeben. -""" + "\n\n") + return ('### Base64 <-> ASCII\n' + 'Base64 ist ein Kodierungsverfahren, welches dazu verwendet wird um beliebige Binärdaten nur Hilfe ' + 'einer Zeichenkette aus A-Z, a-z, 0-9, +, / sowie am Ende = übertragen zu können. Ein Einsatzzweck ' + 'dafür ist z.B. wenn bei EMails Dateianhänge verwendet werden, dort werden nahezu alle Dateiformate ' + 'base64-kodiert übertragen. Auch bei dem einem oder anderen Mystery sind mir solche kodierten ' + 'Zeichenketten schon begegnet. Wenn am Ende einer Zeichenkette ein oder zwei "="-Zeichen stehen ist ' + 'die Wahrscheinlichkeit recht groß, das hier base64 verwendet wurde. Das "="-Zeichen dient hier ' + 'nämlich als "Lückenfüller" am Ende. Die Funktion hier versucht zunächst eine Dekodierung ' + 'Base64->ASCII gelingt dies nicht, erscheint ein Hinweis und der eingegeben Text wird dann ' + 'Base64-kodiert ausgegeben.') else: try: ascii_string = binascii.a2b_base64(eingabetext).decode() - Ausgabe.insert(1.0, ascii_string + "\n") - Ausgabe.insert(1.0, "Base64 -> ASCII:\n", "bu") + return f"Base64 -> ASCII: \n{ascii_string} \n" except ValueError: base64_string = binascii.b2a_base64(eingabetext.encode()) - Ausgabe.insert(1.0, base64_string.decode() + "\n") - Ausgabe.insert(1.0, "ASCII -> Base64:\n", "bu") - Ausgabe.insert(1.0, "Umwandlung Base64 -> ASCII war nicht möglich.\n", "re") + return f"Umwandlung Base64 -> ASCII war nicht möglich. \nASCII -> Base64: \n{base64_string.decode()}" - -def rail_encrypt(plain_text: str, rails: int): - arr = [["" for _ in range(len(plain_text))] for _ in range(rails)] - r = 0 - z = 0 - plus = True - for b in plain_text: - arr[r][z] = b - z += 1 - if r + 1 == rails and plus: - plus = False - r -= 1 - elif r - 1 < 0 and not plus: - plus = True - r += 1 - elif plus: - r += 1 - else: - r -= 1 - out = "" - for i in range(rails): - for j in range(len(plain_text)): - out += arr[i][j] - return out - - -def jaegerzaun_encrypt(): - - eingabetext = Eingabe.get(1.0, END) +def jaegerzaun_encrypt(eingabetext, pw): + hilfetext = ("### encrypt Jägerzaun\n" + "Jägerzaun (auch Railfence oder ZigZag-Chiffre genannt) Bei dieser Chiffre wird kodiert, indem man " + "einen Text im Zickzackmuster in ein Feld aus z.B. 3 Zeilen und so vielen Spalten wie der Text lang " + "ist schreibt. Man beginnt in Spalte 1 - Zeile 1, dann geht es in Spalte 2 - Zeile 1 weiter danach " + "Spalte 3 - Zeile 3, dann Spalte 4 - Zeile 2, Spalte 5 - Zeile 1 usw. Danach werden die Buchstaben " + "einfach Zeile für Zeile hintereinander geschrieben. Unterschiedliche Varianten entstehen einfach " + "dadurch, dass man mit unterschiedlich vielen Zeilen arbeitet welche im Schlüsselfeld anzugeben " + "ist. \n" + "Die Funktion erzeugt hierbei einmal eine Ausgabe bei welcher auch Leerzeichen mitgeschrieben werden " + "und eine Ausgabe wo zuvor die Leerzeichen entfernt werden.") + if pw is None: + return hilfetext eingabetext = eingabetext.strip().replace("\n", " ") - pw = PW_Eingabe.get() pw = pw.strip() if eingabetext == "": - Ausgabe.insert(1.0, """HILFE: [encrypt Jägerzaun] -Jägerzaun (auch Railfence oder ZigZag-Chiffre genannt) -Bei dieser Chiffre wird kodiert, indem man einen Text im Zickzackmuster -in ein Feld aus z.B. 3 Zeilen und so vielen Spalten wie der Text lang ist -schreibt. Man beginnt in Spalte 1 - Zeile 1, dann geht es in Spalte 2 - Zeile 1 -weiter danach Spalte 3 - Zeile 3, dann Spalte 4 - Zeile 2, Spalte 5 - Zeile 1 usw. -Danach werden die Buchstaben einfach Zeile für Zeile hintereinander geschrieben. -Unterschiedliche Varianten entstehen einfach dadurch, dass man mit unterschiedlich -vielen Zeilen arbeitet welche im Schlüsselfeld anzugeben ist. - -Die Funktion erzeugt hierbei einmal eine Ausgabe bei welcher auch Leerzeichen -mitgeschrieben werden und eine Ausgabe wo zuvor die Leerzeichen entfernt werden. - """ + "\n\n") + return hilfetext elif pw == "" or not pw.isdigit(): - Ausgabe.insert(1.0, "Bitte eine Zahl im Schlüsselfeld eingeben!!\n", "re") + return "Bitte eine Zahl im Schlüsselfeld eingeben!!" else: try: if int(pw) < 2: raise ValueError("Zahl zu klein") - Ausgabe.insert(1.0, rail_encrypt(eingabetext.replace(" ", ""), int(pw)) + "\n") - Ausgabe.insert(1.0, "ohne Leerzeichen\n", "bu") - Ausgabe.insert(1.0, rail_encrypt(eingabetext, int(pw)) + "\n") - Ausgabe.insert(1.0, "inkl. Leerzeichen\n", "bu") + return (f"_inkl. Leerzeichen_ \n{helper.rail_encrypt(eingabetext, int(pw))} \n \n" + f"_ohne Leerzeichen_ \n{helper.rail_encrypt(eingabetext.replace(" ", ""), int(pw))}") except ValueError: - Ausgabe.insert(1.0, "Schlüsselzahl fehlerhaft oder kleiner als 2.\n", "re") + return "Schlüsselzahl fehlerhaft oder kleiner als 2." - -def rail_decrypt(cipher: str, rails: int): - arr = [["_" for _ in range(len(cipher))] for _ in range(rails)] - # cipher ins array reinbasteln - x, y = 0, 0 - first_x = True - for b in cipher: - if x >= len(cipher) and y < rails: - y += 1 - x = y - first_x = True - arr[y][x] = b - if y == 0 or (first_x and y != rails - 1): - x = x + (rails - y - 1) * 2 - first_x = False - elif y == rails - 1 or first_x is False: - x = x + (y * 2) - first_x = True - # dekodierten Text aus array holen - out = "" - x, y = 0, 0 - down = True - for _ in range(len(cipher)): - out += arr[y][x] - x += 1 - if down and y + 1 == rails: - down = False - y -= 1 - elif down: - y += 1 - elif down is False and y == 0: - down = True - y += 1 - elif down is False: - y -= 1 - return out - - -def jaegerzaun_decrypt(): - - eingabetext = Eingabe.get(1.0, END) +def jaegerzaun_decrypt(eingabetext, pw): + hilfetext = ("### decrypt Jägerzaun\n" + "Jägerzaun (auch Railfence oder ZigZag-Chiffre genannt) Bei dieser Chiffre wird kodiert, indem man " + "einen Text im Zickzackmuster in ein Feld aus z.B. 3 Zeilen und so vielen Spalten wie der Text " + "lang ist schreibt. Man beginnt in Spalte 1 - Zeile 1, dann geht es in Spalte 2 - Zeile 1 weiter " + "danach Spalte 3 - Zeile 3, dann Spalte 4 - Zeile 2, Spalte 5 - Zeile 1 usw. Danach werden die " + "Buchstaben einfach Zeile für Zeile hintereinander geschrieben. Unterschiedliche Varianten " + "entstehen einfach dadurch, dass man mit unterschiedlich vielen Zeilen arbeitet welche im " + "Schlüsselfeld angegeben werden kann. \n" + "Die Funktion erzeugt hierbei einmal eine Ausgabe bei welcher auch Leerzeichen mitgeschrieben " + "werden und eine Ausgabe wo zuvor die Leerzeichen entfernt werden. \n" + "Wird im Schlüsselfeld keine Zahl angegeben erfolgt automatisch die Dekodierung für alle " + "Zeilenanzahlen von 2-12.") + if pw is None: + return hilfetext eingabetext = eingabetext.strip().replace("\n", " ") - pw = PW_Eingabe.get() pw = pw.strip() if eingabetext == "": - Ausgabe.insert(1.0, """HILFE: [decrypt Jägerzaun] -Jägerzaun (auch Railfence oder ZigZag-Chiffre genannt) -Bei dieser Chiffre wird kodiert, indem man einen Text im Zickzackmuster -in ein Feld aus z.B. 3 Zeilen und so vielen Spalten wie der Text lang ist -schreibt. Man beginnt in Spalte 1 - Zeile 1, dann geht es in Spalte 2 - Zeile 1 -weiter danach Spalte 3 - Zeile 3, dann Spalte 4 - Zeile 2, Spalte 5 - Zeile 1 usw. -Danach werden die Buchstaben einfach Zeile für Zeile hintereinander geschrieben. -Unterschiedliche Varianten entstehen einfach dadurch, dass man mit unterschiedlich -vielen Zeilen arbeitet welche im Schlüsselfeld angegeben werden kann. - -Die Funktion erzeugt hierbei einmal eine Ausgabe bei welcher auch Leerzeichen -mitgeschrieben werden und eine Ausgabe wo zuvor die Leerzeichen entfernt werden. - -Wird im Schlüsselfeld keine Zahl angegeben erfolgt automatisch die Dekodierung -für alle Zeilenanzahlen von 2-12.""" + "\n\n") + return hilfetext elif pw == "": + ausgabtext = "" + ausgabtext += "_inkl. Leerzeichen_ \n" for i in range(12, 1, -1): - Ausgabe.insert(1.0, f'{i:02} - {rail_decrypt(eingabetext.replace(" ", ""), i)}\n') - Ausgabe.insert(1.0, "ohne Leerzeichen\n", "bu") + ausgabtext += f'{i:02} - {helper.rail_decrypt(eingabetext, i)} \n' + ausgabtext += " \n_ohne Leerzeichen_ \n" for i in range(12, 1, -1): - Ausgabe.insert(1.0, f'{i:02} - {rail_decrypt(eingabetext, i)}\n') - Ausgabe.insert(1.0, "inkl. Leerzeichen\n", "bu") + ausgabtext += f'{i:02} - {helper.rail_decrypt(eingabetext.replace(" ", ""), i)} \n' + return ausgabtext elif not pw.isdigit(): - Ausgabe.insert(1.0, "Bitte eine Zahl im Schlüsselfeld eingeben!!\n", "re") + return "Bitte eine Zahl im Schlüsselfeld eingeben!!" else: try: if int(pw) < 2: raise ValueError("Zahl zu klein") - Ausgabe.insert(1.0, rail_decrypt(eingabetext.replace(" ", ""), int(pw)) + "\n") - Ausgabe.insert(1.0, "ohne Leerzeichen\n", "bu") - Ausgabe.insert(1.0, rail_decrypt(eingabetext, int(pw)) + "\n") - Ausgabe.insert(1.0, "inkl. Leerzeichen\n", "bu") + ausgabetext = (f"_inkl. Leerzeichen_ \n{helper.rail_decrypt(eingabetext, int(pw))} \n \n" + f"_ohne Leerzeichen_ \n{helper.rail_decrypt(eingabetext.replace(" ", ""), int(pw))}") + return ausgabetext except ValueError: - Ausgabe.insert(1.0, "Schlüsselzahl fehlerhaft oder kleiner als 2.\n", "re") - - + return "Schlüsselzahl fehlerhaft oder kleiner als 2.\n" +''' def adfgx_kodieren(): hilfetext = """HILFE: [ADFGX kodieren] Die ADFGX-Chiffre arbeitet mit zwei Passwörtern, wobei jedes für je einen diff --git a/requirements.txt b/requirements.txt index 1daf9740478e6623bfc896274a7ef820da8a6e7f..3f4e58d46384e48c20b7bf4e90c8802b52633d78 100644 GIT binary patch delta 39 mcmdP#nxLUnz>vt0$B+Ufiy3Tz(1<~g!5D}Q8F(4Ez!(6Kkp*G^ delta 9 Qcmea$nV`YK%fQ6|00}<