chronogramm, röm-zahlen, urls-decode, reverse-wig,

bas64, jägerzaun

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()

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

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():
+def zahlen_roemisch_arabisch_umwandeln(eingabetext):
-    hilfetext = """HILFE: [Römische in Arabische Zahlen umwandeln und umgekehrt]
+    hilfetext = ("### Römische in Arabische Zahlen umwandeln und umgekehrt\n"
-Es werden römische Zahlen in arabische umgewandelt und umgekehrt, die Funktion
+                 "Es werden römische Zahlen in arabische umgewandelt und umgekehrt, die Funktion arbeitet dabei bei "
-arbeitet dabei bei der Umwandlung von arabisch zu römisch mit Werten bis
+                 "der Umwandlung von arabisch zu römisch mit Werten bis maximal 500000. Es werden folgende Zeichen "
-maximal 500000. Es werden folgende Zeichen verwendet: I=1, V=5, X=10, L=50,
+                 "verwendet: I=1, V=5, X=10, L=50, C=100, D=500, M=1000, \u2181=5000, \u2182=10000, \u2187=50000, "
-C=100, D=500, M=1000, \u2181=5000, \u2182=10000, \u2187=50000, \u2188=100000
+                 "\u2188=100000  \nEtwas Vorsicht sollte bei einer Umwandlung von römischen in arabische Zahlen "
-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 "
-geboten sein, wenn mit untypischen Schreibweisen gearbeitet wird bei welchen
+                 "von dem nachfolgenden Zeichen abgezogen werden soll. Die eigentlich inkorrekte Schreibweise IIX "
-mehr als ein Zeichen von dem nachfolgenden Zeichen abgezogen werden soll.
+                 "für die Zahl 8 wird hier die Zahl 10 als Ergebnis haben (+1-1+10), dafür wird aber allerdings die "
-Die eigentlich inkorrekte Schreibweise IIX für die Zahl 8 wird hier die Zahl
+                 "ebenfalls falsche Schreibweise IM genauso als 999 wie die korrekte Schreibweise CMXCIX erkannt.")
-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 "arabische Zahlen größer als 500000 mag ich nicht in römische Zahlen!"
-                    return
                 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):
-
-def url_decode():
-    
-    eingabetext = Eingabe.get(1.0, END)
     eingabetext = eingabetext.rstrip()
     if eingabetext == "":
-        Ausgabe.insert(1.0, """HILFE: [URL-decode]
+        return ("### URL-decode\n"
-Nachdem Groundspeak nun inzwischen sämtliche Bilddateien
+                "Nachdem Groundspeak nun inzwischen sämtliche Bilddateien über einen Proxy umleitet bevor sie im "
-über einen Proxy umleitet bevor sie im Listing erscheinen
+                "Listing erscheinen wird es manchmal schwer die ursprüngliche URL und/oder den Dateinamen des "
-wird es manchmal schwer die ursprüngliche URL und/oder
+                "Bildes noch lesen zu können. Die URL hat dort nun jeweils folgendes Muster: "
-den Dateinamen des Bildes noch lesen zu können.
+                "`https://imgproxy.geocaching.com/......?url=.....` wobei nach dem `?url=` dann die ursprüngliche "
-Die URL hat dort nun jeweils folgendes Muster:
+                "Bild-URL folgt, allerdings wird dabei dann aus `http://` folgendes `http%3A%2F%2F` und um genau "
-https://imgproxy.geocaching.com/......?url=.....
+                "dieses wieder normal lesbar zu machen dient diese Funktion")
-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""")
     else:
         atxt = urllib_parse_unquote(eingabetext)
-        Ausgabe.insert(1.0, atxt + "\n")
+        return f"dekodierte URL:  `{atxt}`"
-        Ausgabe.insert(1.0, "dekodierte URL:\n", "bu")
 
-
+def reversewig(eingabetext):
-def reversewig():
     seperator = ("|,", "_", "/", ";", ",")
-    
-    eingabetext = Eingabe.get(1.0, END)
     eingabetext = eingabetext.rstrip()
     if eingabetext == "":
-        Ausgabe.insert(1.0, """HILFE: [Reverse Wherigo zu Koordinaten]
+        return ('### Reverse Wherigo zu Koordinaten\n'
-Mit dem Reverse Wherigo hat -Waldmeister- eigentlich eine coole Sache
+                'Mit dem Reverse Wherigo hat -Waldmeister- eigentlich eine coole Sache erfunden. Man hat anfangs '
-erfunden. Man hat anfangs keine Koordinaten sondern nur 3 Zahlen, welche
+                'keine Koordinaten sondern nur 3 Zahlen, welche man nach Start des Wherigo-Cartridges eingibt und '
-man nach Start des Wherigo-Cartridges eingibt und dann erfährt man wie weit
+                'dann erfährt man wie weit der Cache entfernt ist. Nun kann man immer wieder von unterschiedlichen '
-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 '
-Positionen aus diese Entfernungsfragen durchführen und sich damit dem
+                'Abfragen man braucht umso besser. Leider gibt es inzwischen genügend Tools die genau wie diese '
-Cache nähern. Je weniger Abfragen man braucht umso besser.
+                'Funktion hier aus den 3 Zahlen direkt die Finalkoordinaten ermitteln können.  \n'
-Leider gibt es inzwischen genügend Tools die genau wie diese Funktion
+                ' Leider??? Ja leider denn das führt auch dazu, das es inzwischen so extrem viele dieser '
-hier aus den 3 Zahlen direkt die Finalkoordinaten ermitteln können.
+                'Reverse-Wherigos gibt wo sich die Owner anscheinend auch denken "Die spielt doch sowieso keiner '
-Leider??? Ja leider denn das führt auch dazu, das es inzwischen so extrem
+                'mehr normal..." anders kann ich mir ganze Trails mit Reverse-Wherigos nicht erklären. Um die '
-viele dieser Reverse-Wherigos gibt wo sich die Owner anscheinend auch
+                'Funktion zu nutzen braucht man nur die 3 Zahlen durch ein entsprechendes Trennzeichen: '
-denken "Die spielt doch sowieso keiner mehr normal..." anders kann ich
+                '| , _ / ; , oder Leerzeichen eingeben und auf den Knopp klicken und bekommt Koordinaten.')
-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")
     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])
+                    final = helper.rwig_to_coords(txt[0], txt[1], txt[2])
-                    Ausgabe.insert(1.0, "DEG: " + dec_to_deg(final[0], final[1]) + "\n")
+                    ausgabetext += "WIG: " + txt[0] + ", " + txt[1] + ", " + txt[2] + "  \n"
-                    Ausgabe.insert(1.0, "DEC: " + str(final[0]) + " " + str(final[1]) + "\n")
+                    ausgabetext += "DEC: " + str(final[0]) + " " + str(final[1]) + "  \n"
-                    Ausgabe.insert(1.0, "WIG: " + txt[0] + ", " + txt[1] + ", " + txt[2] + "\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):
-def base64_ascii():
-    
-    eingabetext = Eingabe.get(1.0, END)
     eingabetext = eingabetext.rstrip()
     if eingabetext == "":
-        Ausgabe.insert(1.0, """HILFE: [Base64 <-> ASCII]
+        return ('### Base64 <-> ASCII\n'
-Base64 ist ein Kodierungsverfahren, welches dazu verwendet wird
+                'Base64 ist ein Kodierungsverfahren, welches dazu verwendet wird um beliebige Binärdaten nur Hilfe '
-um beliebige Binärdaten nur Hilfe einer Zeichenkette aus A-Z,
+                'einer Zeichenkette aus A-Z, a-z, 0-9, +, / sowie am Ende = übertragen zu können. Ein Einsatzzweck '
-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 '
-dafür ist z.B. wenn bei EMails Dateianhänge verwendet werden, dort
+                'base64-kodiert übertragen. Auch bei dem einem oder anderen Mystery sind mir solche kodierten '
-werden nahezu alle Dateiformate base64-kodiert übertragen.
+                'Zeichenketten schon begegnet. Wenn am Ende einer Zeichenkette ein oder zwei "="-Zeichen stehen ist '
-Auch bei dem einem oder anderen Mystery sind mir solche kodierten
+                'die Wahrscheinlichkeit recht groß, das hier base64 verwendet wurde. Das "="-Zeichen dient hier '
-Zeichenketten schon begegnet. Wenn am Ende einer Zeichenkette ein
+                'nämlich als "Lückenfüller" am Ende. Die Funktion hier versucht zunächst eine Dekodierung '
-oder zwei "="-Zeichen stehen ist die Wahrscheinlichkeit recht groß,
+                'Base64->ASCII gelingt dies nicht, erscheint ein Hinweis und der eingegeben Text wird dann '
-das hier base64 verwendet wurde. Das "="-Zeichen dient hier nämlich
+                'Base64-kodiert ausgegeben.')
-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")
     else:
         try:
             ascii_string = binascii.a2b_base64(eingabetext).decode()
-            Ausgabe.insert(1.0, ascii_string + "\n")
+            return f"Base64 -> ASCII:  \n{ascii_string}  \n"
-            Ausgabe.insert(1.0, "Base64 -> ASCII:\n", "bu")
         except ValueError:
             base64_string = binascii.b2a_base64(eingabetext.encode())
-            Ausgabe.insert(1.0, base64_string.decode() + "\n")
+            return f"Umwandlung Base64 -> ASCII war nicht möglich.  \nASCII -> Base64:  \n{base64_string.decode()}"
-            Ausgabe.insert(1.0, "ASCII -> Base64:\n", "bu")
-            Ausgabe.insert(1.0, "Umwandlung Base64 -> ASCII war nicht möglich.\n", "re")
 
-
+def jaegerzaun_encrypt(eingabetext, pw):
-def rail_encrypt(plain_text: str, rails: int):
+    hilfetext = ("### encrypt Jägerzaun\n"
-    arr = [["" for _ in range(len(plain_text))] for _ in range(rails)]
+                "Jägerzaun (auch Railfence oder ZigZag-Chiffre genannt) Bei dieser Chiffre wird kodiert, indem man "
-    r = 0
+                "einen Text im Zickzackmuster in ein Feld aus z.B. 3 Zeilen und so vielen Spalten wie der Text lang "
-    z = 0
+                "ist schreibt. Man beginnt in Spalte 1 - Zeile 1, dann geht es in Spalte 2 - Zeile 1 weiter danach "
-    plus = True
+                "Spalte 3 - Zeile 3, dann Spalte 4 - Zeile 2, Spalte 5 - Zeile 1 usw. Danach werden die Buchstaben "
-    for b in plain_text:
+                "einfach Zeile für Zeile hintereinander geschrieben. Unterschiedliche Varianten entstehen einfach "
-        arr[r][z] = b
+                "dadurch, dass man mit unterschiedlich vielen Zeilen arbeitet welche im Schlüsselfeld anzugeben "
-        z += 1
+                 "ist.  \n"
-        if r + 1 == rails and plus:
+                "Die Funktion erzeugt hierbei einmal eine Ausgabe bei welcher auch Leerzeichen mitgeschrieben werden "
-            plus = False
+                "und eine Ausgabe wo zuvor die Leerzeichen entfernt werden.")
-            r -= 1
+    if pw is None:
-        elif r - 1 < 0 and not plus:
+        return hilfetext
-            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)
     eingabetext = eingabetext.strip().replace("\n", " ")
-    pw = PW_Eingabe.get()
     pw = pw.strip()
     if eingabetext == "":
-        Ausgabe.insert(1.0, """HILFE: [encrypt Jägerzaun]
+        return hilfetext
-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")
     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")
+            return (f"_inkl. Leerzeichen_  \n{helper.rail_encrypt(eingabetext, int(pw))}  \n  \n"
-            Ausgabe.insert(1.0, "ohne Leerzeichen\n", "bu")
+                    f"_ohne Leerzeichen_  \n{helper.rail_encrypt(eingabetext.replace(" ", ""), int(pw))}")
-            Ausgabe.insert(1.0, rail_encrypt(eingabetext, int(pw)) + "\n")
-            Ausgabe.insert(1.0, "inkl. Leerzeichen\n", "bu")
         except ValueError:
-            Ausgabe.insert(1.0, "Schlüsselzahl fehlerhaft oder kleiner als 2.\n", "re")
+            return "Schlüsselzahl fehlerhaft oder kleiner als 2."
 
-
+def jaegerzaun_decrypt(eingabetext, pw):
-def rail_decrypt(cipher: str, rails: int):
+    hilfetext = ("### decrypt Jägerzaun\n"
-    arr = [["_" for _ in range(len(cipher))] for _ in range(rails)]
+                 "Jägerzaun (auch Railfence oder ZigZag-Chiffre genannt) Bei dieser Chiffre wird kodiert, indem man "
-    # cipher ins array reinbasteln
+                 "einen Text im Zickzackmuster in ein Feld aus z.B. 3 Zeilen und so vielen Spalten wie der Text "
-    x, y = 0, 0
+                 "lang ist schreibt. Man beginnt in Spalte 1 - Zeile 1, dann geht es in Spalte 2 - Zeile 1 weiter "
-    first_x = True
+                 "danach Spalte 3 - Zeile 3, dann Spalte 4 - Zeile 2, Spalte 5 - Zeile 1 usw. Danach werden die "
-    for b in cipher:
+                 "Buchstaben einfach Zeile für Zeile hintereinander geschrieben. Unterschiedliche Varianten "
-        if x >= len(cipher) and y < rails:
+                 "entstehen einfach dadurch, dass man mit unterschiedlich vielen Zeilen arbeitet welche im "
-            y += 1
+                 "Schlüsselfeld angegeben werden kann.  \n"
-            x = y
+                 "Die Funktion erzeugt hierbei einmal eine Ausgabe bei welcher auch Leerzeichen mitgeschrieben "
-            first_x = True
+                 "werden und eine Ausgabe wo zuvor die Leerzeichen entfernt werden.  \n"
-        arr[y][x] = b
+                 "Wird im Schlüsselfeld keine Zahl angegeben erfolgt automatisch die Dekodierung für alle "
-        if y == 0 or (first_x and y != rails - 1):
+                 "Zeilenanzahlen von 2-12.")
-            x = x + (rails - y - 1) * 2
+    if pw is None:
-            first_x = False
+        return hilfetext
-        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)
     eingabetext = eingabetext.strip().replace("\n", " ")
-    pw = PW_Eingabe.get()
     pw = pw.strip()
     if eingabetext == "":
-        Ausgabe.insert(1.0, """HILFE: [decrypt Jägerzaun]
+        return hilfetext
-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")
     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')
+            ausgabtext += f'{i:02} - {helper.rail_decrypt(eingabetext, i)}  \n'
-        Ausgabe.insert(1.0, "ohne Leerzeichen\n", "bu")
+        ausgabtext += "  \n_ohne Leerzeichen_  \n"
         for i in range(12, 1, -1):
-            Ausgabe.insert(1.0, f'{i:02} - {rail_decrypt(eingabetext, i)}\n')
+            ausgabtext += f'{i:02} - {helper.rail_decrypt(eingabetext.replace(" ", ""), i)}  \n'
-        Ausgabe.insert(1.0, "inkl. Leerzeichen\n", "bu")
+        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")
+            ausgabetext = (f"_inkl. Leerzeichen_  \n{helper.rail_decrypt(eingabetext, int(pw))}  \n  \n"
-            Ausgabe.insert(1.0, "ohne Leerzeichen\n", "bu")
+                           f"_ohne Leerzeichen_  \n{helper.rail_decrypt(eingabetext.replace(" ", ""), int(pw))}")
-            Ausgabe.insert(1.0, rail_decrypt(eingabetext, int(pw)) + "\n")
+            return ausgabetext
-            Ausgabe.insert(1.0, "inkl. Leerzeichen\n", "bu")
         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