tebarius/Mysteryhelfer-web
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
bas64, jägerzaun
This commit is contained in:
Martin Kayser
2025-07-26 22:39:36 +02:00
parent 07dc37902b
commit 8dc56b70b2
4 changed files with 201 additions and 223 deletions
Download Patch File Download Diff File Expand all files Collapse all files

33
app/app.py
View File

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

69
app/helper.py
View File

@@ -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

322
app/tools.py
View File

@@ -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

BIN
requirements.txt
View File

Binary file not shown.