1 Python-Module (Ernst Erich Schnoor) Im Folgenden sind einige Python-Module aufgeführt, die mit Python 3.6.2 unter IDLE / Run / Run Module aufgerufen und ausgeführt werden können ( CMLizenz.pdf ): Analyse.py (Zeichen analysieren) 1 Buchstaben.py (eigener Zeichen-Satz) 2 telecypher.py (Dateien verschlüsseln) 3 Pykurier.py (Kommunikation verschlüsseln) 13 Pychange.py (sicherer Schlüsselaustausch) 23 Hashwert.py (Hashwerte berechnen) 38 Userpass.py (sicheres Passwortverfahren) 44 CGenerator.py (Random-Sequenzen) 52 Alle Programme basieren auf dem vom Verfasser entwickelten CypherMatrix Verfahren. Einzelheiten sind unter telecypher.net erläutert. Da Microsoft die Unterstützung von WindowsXP aufgegeben hat, können die bereits bestehenden Programme nicht weiter benutzt werden. Sie werden nach Python umgeschrieben. Analyse.py Das Programm analysiert Dateien und zählt jedes einzelne Zeichen. # Analyse.py (3.6.2) import sys # -*- coding: utf8 -*- #-------------------------------------------------------- Hauptprogramm -------------------------------- datei = input(" Datei: ") try: lesen = open(datei,"rb") zeile = lesen.read() zeile = zeile.decode("utf8") except: print(" Nicht lesbare Zeichen oder Datei ist nicht vorhanden! ") print(zeile) lang = len(zeile) anzahl = 0 inhalt = "" for a in zeile[0:lang]:
2 if a not in inhalt: inhalt = inhalt + a print(a,zeile.count(a)) anzahl += 1 print(" ",inhalt) print(" Anzahl Zeichen: ",anzahl) lesen.close() # Ende Quellcode Buchstaben.py Das Modul enthält einen eigenen Zeichensatz mit erweiterten Unicode-Elementen. Der Zeichen-Satz wird in den folgenden Programmen verwendet. @ABCDEFGHIJKLMNOPQRSTUVWXYZƂƃƄƅƆƇƈƉƊƋƌƍƎƏƐƑƒƓƔƕƖƗƘƜƝƞƟƠơƢƣƤ ƥʀƨƨʃƪƫƭƭʈưưʊʋƴƴƶƶʒƹ#!"#&'()*+,-./0123456789:;<=>ǹǹǻǻǽǽǿǿȁȁȃȃȅȅȇȇȉȉȋȋȍȍȏȏ Ȑabcdefghijklmnopqrstuvwxyz{ljNJNjnjǍǎǏǐǑǒǓǔǕǖǗǘǙǚǛǜǝǞǟǠǡǢǣǤǥǦǧǨǩǪǫǬǭǮǯǰ DZDzdzǴ½¾ ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ ØÙÚÛÜÝÞßàáâãäåæçöü Umfang: 256 # Buchstaben.py (3.6.2) # -*- coding: cp1252 -*- # Definition Buchstaben Cypher: Zeichen-Code t1 = "" t2 = "" t3 = "" t4 = "" t5 = "" t6 = "" t7 = "" t8 = "" t9 = "" buchst = "" umfang = int for i in range(64,91): t1 += chr(i) for i in range(386,409): t2 += chr(i) for i in range(412,441): t3 += chr(i) for i in range(33,64): # Latin Capital Letter # Greek Capital Letter # Greek Small Letter # Latin Ziffern
3 t4 += chr(i) for i in range(504,529): # Cyrillic Small Letter t5 += chr(i) for i in range(97,125): # Latin Small Letter t6 += chr(i) for i in range(457,501): # Cyrillic Capital Letter t7 += chr(i) for i in range(189,233): # versch. Zeichen (Rest) t8 += chr(i) t9 = chr(246)+chr(252)+chr(8364)+chr(8998)+chr(32) # ö,ü,, Sonderzeichen buchst = t1+t2+t3+t4+t5+t6+t7+t8+t9 print(buchst) umfang = len(buchst) print(umfang) # Ende Quellcode telecypher.py Das Programm telecypher.py verschlüsselt Dateien. Das Verfahren arbeitet in zwei Bereichen: Generator zur Erzeugung der notwendigen Bestimmungsfaktoren und Codierbereich zur Durchführung der Verschlüsselung (ver- und entschlüsseln). Beide Bereiche werden kombiniert, können aber auch getrennt und eigenständig
4 verwendet werden. Einzelheiten unter Telecypher.pdf. Der Generator erzeugt laufend Schlüssel in Blocklänge, die jeweils mit gleich langen Klartextblöcken XOR-verknüpft werden. Jeder Schlüssel ist anders und wird auch nur einmal eingesetzt. Er wird auch nicht gespeichert und bleibt geheim. So entsteht in jeder Runde ein partielles one-time.pad. Das ergibt für den gesamten Verschlüsselungsvorgang eine Kette zusammenhängender one-time-pad Funktionen, gewissermaßen als eine one-time-chain. Nach derzeitigem Stand der Technik wird so absolute Sicherheit erreicht. Zur Initialisierung wird eine persönliche Startsequenz eingegeben (mind. 36 bis max. 92 Zeichen). Einige Beispiele: Im Steinhuder Meer schwimmen 267 Steinbeisser (45 Bytes) 7 kangaroos jumping along the Times Square (42 Bytes) Jeden Morgen um 7 Uhr 30 fährt ein Zug von StMichaelisdonn nach Höllriegelskreuth (80 Bytes) Zur Unterscheidung werden verschlüsselte Dateien mit Präfix: Cy- (Cyphertextdatei) und entschlüsselte Dateien mit Präfix: Kt- (Klartextdatei) gekennzeichnet. # telecypher.py (3.6.2) Schleife: (63 --72) import sys, os # -*- coding: cp1252 -*- # Definition Buchstaben Cypher: Zeichen-Code t1 = "" t2 = "" t3 = "" t4 = "" t5 = "" t6 = "" t7 = "" t8 = "" t9 = "" buchst = "" umfang = int for i in range(64,91): t1 += chr(i) for i in range(386,409): t2 += chr(i) for i in range(412,441): t3 += chr(i) for i in range(33,64): t4 += chr(i) # Latin Capital Letter # Greek Capital Letter # Greek Small Letter # Latin Ziffern
5 for i in range(504,529): # Cyrillic Small Letter t5 += chr(i) for i in range(97,125): # Latin Small Letter t6 += chr(i) for i in range(457,501): # Cyrillic Capital Letter t7 += chr(i) for i in range(189,233): # versch. Zeichen (Rest) t8 += chr(i) t9 = chr(246)+chr(252)+chr(8364)+chr(8998)+chr(32) # ö,ü,, Sonderzeichen buchst = t1+t2+t3+t4+t5+t6+t7+t8+t9 # Zahlensystem Cypher: Zahlen-Code zahlen = "" digits = "" t2 = "" t3 = "" t4 = "" t5 = "" t6 = "" t7 = "" t8 = "" t9 = "" t10 = "" t11 = "" t12 = "" for i in range(49,58): zahlen += chr(i) for i in range(97,123): t2 += chr(i) for i in range(65,91): t3 += chr(i) t4 = chr(196)+chr(214)+chr(220)+chr(223)+chr(228)+chr(246)+chr(252)+chr(8369) for i in range(915,917): t5 += chr(i) t6 = chr(920)+chr(923)+chr(926)+chr(928)+chr(931)+chr(934)+chr(936)+chr(937) for i in range(945,959): t7 += chr(i) for i in range(960,970): t8 += chr(i) t9 = chr(1024)+chr(1025)+chr(1028) for i in range(1033,1041): t10 += chr(i) for i in range(1046,1051): t11 += chr(i) for i in range(1073,1082): t12 += chr(i)
6 digits = zahlen+t2+t3+t4+t5+t6+t7+t8+t9+t10+t11+t12 def nachsys(basis,q): # Dezimal nach System digitset = digits ergebnis = "" umfang = "" z="" zd="" if basis>10: umfang=digitset[:basis-10] while q > 0: z=int(q % basis) if z>9: zd=umfang[z-10:z-9] else: zd=str(z) q = (q-z)/basis ergebnis=zd+ergebnis return ergebnis def nachdez(basis,syszahl): # System nach Dezimal digitset = digits umfang = digitset[:basis-1] zahl=0 ziffer = "" dezzahl = 0 laenge = len(syszahl) hoch = laenge n = 0 for n in range(laenge): hoch -= 1 n += 1 ziffer = syszahl[n-1] if ziffer: zahl = umfang.find(ziffer)+1 else: zahl = int(ziffer)+1
7 dezzahl = dezzahl + zahl*basis**hoch return dezzahl def generator(matrkey,cd): rundkey = "" breite = 63 l = len(matrkey) ck = (l * (l-2)) + cd # Generator Prozess # Breite der Eingaben n = 0 hp = 0 hs = 0 hk = 0 for z in matrkey[0:(l+1)]: n += 1 s = (ord(z)+1) * (ck +n) hp = hp + s hashfolge = "" folgehash = "" ergebnis = "" n = 0 for z in matrkey[0:(l+1)]: n += 1 ss = ((ord(z)+1) * n * hp) +n+cd+1 ergebnis = nachsys(77,ss) hashfolge = hashfolge + ergebnis hk = hk + ss hs = hp + hk folgehash = hashfolge[::-1] cyphfolge = hashfolge+folgehash lange = len(cyphfolge) alpha = ((hk + hp) % 127) + 1 beta = (hk % 169) + 1 gamma = ((hp +cd) % 196) + 1 theta = (hk % 32) + 1 slip = "" digit = "" zahl = 0 element = ""
8 umfang = 0 i = theta matrix = "" for z in cyphfolge[:lange]: i += 1 slip = cyphfolge[i:i+3] digit = nachdez(78,slip) digit = int(digit) zahl = digit % 256 element = buchst[zahl] if element in matrix: element = "" else: matrix = matrix + element umfang = len(matrix) rest = 0 zusatz = "" if umfang < 256: rest = 256 - umfang zusatz = digits[36:36 + rest] matrix = matrix + zusatz alphabet = matrix[alpha:alpha+128] if beta > (256 - breite): beta == (256 - breite) rundkey = matrix[beta:beta+breite] if gamma > (256 - breite): gamma == (256 - breite) matrkey = matrix[gamma:gamma+breite] return rundkey, matrkey, alphabet def XORgen(original,rundkey): # XOR-Verknüpfung (one-time-chain) resultat = "" digit = 0 element = "" cypher = [] lang = len(original) umfg = len(rundkey) for x in original[:lang]:
9 digit = buchst.find(x) element = str(digit) cypher.append(element) digit = 0 element = "" parbeta = [] for z in rundkey[:umfg]: digit = buchst.find(z) element = str(digit) parbeta.append(element) n = 0 m = 0 cx = int xo = int ergxor = [] for n in cypher[:umfg]: cx = parbeta[m] cx = int(cx) n = int(n) xo = n ^ cx ergxor.append(xo) m += 1 element = [] ergebnis = "" for x in ergxor: element = buchst[x] resultat = resultat + element return resultat def bitconvenc(original,alphabet): # Konversion (8-bit > 7-bit / encode) i = 0 digit = 0 xduo = "" folge1 = "" lang = len(original) zusatz = "00000000" for x in original[:lang+1]: digit = buchst.find(x) i += 1 xduo = nachsys(2,digit) xduo = str(xduo)
10 xduo = zusatz + xduo l = len(xduo) xduo = xduo[l-8:] folge1 = folge1 + xduo umfang = len(folge1) slip = "" digit = "" cypher = "" i = 0 element = "" for z in folge1[:umfang+1]: slip = folge1[i:i+7] i += 7 if i > umfang: break digit = nachdez(2,slip) digit = int(digit) element = alphabet[digit] cypher = cypher + element return cypher def bitconvdec(original,alphabet): # Bit-Konversion (7-bit > 8-bit / decode) i = 0 digit = 0 xduo = "" folge1 = "" lang = len(original) zusatz = "00000000" for x in original[:lang+1]: digit = alphabet.find(x) xduo = nachsys(2,digit) xduo = str(xduo) xduo = zusatz + xduo l = len(xduo) xduo = xduo[l-7:l] folge1 = folge1 + xduo umfang = len(folge1) slip = "" digit = "" element = "" ergebnis = "" i = 0
11 for z in folge1[i:umfang]: slip = folge1[i:i+8] i += 8 if i > umfang: break digit = nachdez(2,slip) element = buchst[digit] ergebnis = ergebnis + element return ergebnis #... Hauptprogramm print(" Passphrase als Startsequenz mit mind.36 und max.92 Zeichen eingeben") startsequenz = input( " Startsequenz: ") lang = len(startsequenz) print(" Länge: ",lang) # Eingabe Startsequenz cd = input( " Sicherheits-Code: ") if cd == "": cd = 1 print(" Code = 1") cd = int(cd) xbt = buchst.rfind(startsequenz[27]) # 27 = Steuerung: Rundkey beim Start rundkey = buchst[xbt:xbt+lang] matrkey = startsequenz rundkey,matrkey,alphabet = generator(matrkey,cd) # Generator aufrufen datei = input(" Datei: ") ln = len(datei) # Eingabe der Datei # Auswahl wahl = input(" Auswahl: encode =..e.. / decode =..d.. / beenden..q.. > ") if wahl == "e": # Aufruf der Verschlüsselung try: lesen = open(datei,"rb") zeile = lesen.read() zeile = zeile.decode("utf8") except: print(" Datei ist nicht vorhanden oder unbekannte Zeichen! ")
cydatei = "Cy-"+datei # Name der verschlüsselten Datei schreiben = open(cydatei,"wb") breite = 63 print(" Cipher-Datei: ",cydatei) print(" Der verschlüsselte Text lautet wie folgt:") elif wahl == "d": try: lesen = open(datei,"rb") zeile = lesen.read() zeile = zeile.decode("utf8") except: print(" Datei ist nicht vorhanden! ") 12 kldatei = "Kt-"+ datei[3:ln] schreiben = open(kldatei,"wb") breite = 72 print(" Klartext-Datei: ",kldatei) print(" Der Klartext lautet wie folgt:") else: # Name der entschlüsselten Datei # Prozess beenden i = 0 abschn = "" while zeile!= "": rundkey,matrkey,alphabet = generator(matrkey,cd) # Arbeitsschleife # Generator abschn = zeile[i:i+breite] i += breite if wahl == "e": resultat = XORgen(abschn,rundkey) cypher = bitconvenc(resultat,alphabet) print(cypher) zchn = bytes(cypher.encode("utf8")) schreiben.write(zchn) # Aufruf der Verschlüsselung # Aufruf der one-time-chain # Aufruf Bit-Konversion # Schreiben der verschlüsselten Datei if abschn == "": break if wahl == "d": # Aufruf der Entschlüsselung
13 ergebnis = bitconvdec(abschn,alphabet) resultat = XORgen(ergebnis,rundkey) # Aufruf Bit-Konversion # Aufruf der one-time-chain print(resultat) zchn = bytes(resultat.encode("utf8")) schreiben.write(zchn) # Schreiben der entschlüsselten Datei if abschn == "": break if wahl == "q": # Prozess beenden lesen.close() schreiben.close() # Ende Quellcode Pykurier.py Das folgende Programm Pykurier.py verschlüsselt individuell geschriebene Nachrichten. Es bietet eine persönliche Kommunikation univalent vom Sender bis zum Empfänger ohne Zwischenstationen. Niemand, auch nicht der Diensteanbieter, kann mitlesen. Verschlüsselt wird mit dem CypherMatrix Verfahren und der one-time-chain. Es gelten im Übrigen dieselben Vorbemerkungen wie zum vorhergehenden Programm: telecypher.py. # Pykurier.py (3.6.2: CypherCode) Schleife: 63-72 import sys, os # -*- coding: cp1252 -*- # Definition Buchstaben Cypher: Zeichen-Code t1 = "" t2 = "" t3 = "" t4 = "" t5 = "" t6 = "" t7 = "" t8 = "" t9 = "" buchst = "" umfang = int for i in range(64,91): # Latin Capital Letter
14 t1 += chr(i) for i in range(386,409): # Greek Capital Letter t2 += chr(i) for i in range(412,441): # Greek Small Letter t3 += chr(i) for i in range(33,64): # Latin Ziffern t4 += chr(i) for i in range(504,529): # Cyrillic Small Letter t5 += chr(i) for i in range(97,125): # Latin Small Letter t6 += chr(i) for i in range(457,501): # Cyrillic Capital Letter t7 += chr(i) for i in range(189,233): # versch. Zeichen (Rest) t8 += chr(i) t9 = chr(246)+chr(252)+chr(8364)+chr(32) # ö,ü,, Sonderzeichen buchst = t1+t2+t3+t4+t5+t6+t7+t8+t9 # Zahlensystem Cypher: Zahlen-Code zahlen = "" digits = "" t2 = "" t3 = "" t4 = "" t5 = "" t6 = "" t7 = "" t8 = "" t9 = "" t10 = "" t11 = "" t12 = "" for i in range(49,58): zahlen += chr(i) for i in range(97,123): t2 += chr(i) for i in range(65,91): t3 += chr(i) t4 = chr(196)+chr(214)+chr(220)+chr(223)+chr(228)+chr(246)+chr(252)+chr(8369) for i in range(915,917): t5 += chr(i) t6 = chr(920)+chr(923)+chr(926)+chr(928)+chr(931)+chr(934)+chr(936)+chr(937) for i in range(945,959): t7 += chr(i) for i in range(960,970): t8 += chr(i) t9 = chr(1024)+chr(1025)+chr(1028)
15 for i in range(1033,1041): t10 += chr(i) for i in range(1046,1051): t11 += chr(i) for i in range(1073,1084): t12 += chr(i) for i in range(1094,1108) t13 += chr(i) digits = zahlen+t2+t3+t4+t5+t6+t7+t8+t9+t10+t11+t12 def nachsys(basis,q): # Dezimal nach System digitset = digits ergebnis = "" umfang = "" z = "" zd = "" if basis>10: umfang=digitset[:basis-10] while q > 0: z=int(q % basis) if z>9: zd=umfang[z-10:z-9] else: zd=str(z) q = (q-z)/basis ergebnis=zd+ergebnis return ergebnis def nachdez(basis,syszahl): # System nach Dezimal digitset = digits umfang = digitset[:basis-1] zahl=0 ziffer = "" dezzahl = 0 laenge = len(syszahl) hoch = laenge n = 0 for n in range(laenge):
16 hoch -= 1 n += 1 ziffer = syszahl[n-1] if ziffer: zahl = umfang.find(ziffer)+1 else: zahl = int(ziffer)+1 dezzahl = dezzahl + zahl*basis**hoch return dezzahl def generator(matrkey,cd): rundkey = "" breite = 63 l = len(matrkey) ck = (l * (l-2)) + cd # Generator Prozess # Breite der Eingaben n = 0 hp = 0 hs = 0 hk = 0 for z in matrkey[0:(l+1)]: n += 1 s = (ord(z)+1) * (ck +n) hp = hp + s hashfolge = "" folgehash = "" ergebnis = "" n = 0 for z in matrkey[0:(l+1)]: n += 1 ss = ((ord(z)+1) * n * hp) +n+cd+1 ergebnis = nachsys(77,ss) hashfolge = hashfolge + ergebnis hk = hk + ss hs = hp + hk folgehash = hashfolge[::-1] cyphfolge = hashfolge+folgehash lange = len(cyphfolge)
17 alpha = ((hk + hp) % 127) + 1 beta = (hk % 169) + 1 gamma = ((hp +cd) % 196) + 1 theta = (hk % 32) + 1 slip = "" digit = "" zahl = 0 element = "" umfang = 0 i = theta matrix = "" for z in cyphfolge[:lange]: i += 1 slip = cyphfolge[i:i+3] digit = nachdez(78,slip) digit = int(digit) zahl = digit % 256 element = buchst[zahl] if element in matrix: element = "" else: matrix = matrix + element umfang = len(matrix) rest = 0 zusatz = "" if umfang < 256: rest = 256 - umfang zusatz = digits[36:36 + rest] matrix = matrix + zusatz alphabet = matrix[alpha:alpha+128] if beta > (256 - breite): beta = (256 - breite) rundkey = matrix[beta:beta+breite] if gamma > (256 - breite): gamma == (256 - breite) matrkey = matrix[gamma:gamma+breite] return rundkey, matrkey, alphabet def XORgen(original,rundkey): # XOR-Verknüpfung (one-time-chain)
18 resultat = "" digit = 0 element = "" cypher = [] lang = len(original) umfg = len(rundkey) for x in original[:lang]: digit = buchst.find(x) element = str(digit) cypher.append(element) digit = 0 element = "" parbeta = [] for z in rundkey[:umfg]: digit = buchst.find(z) element = str(digit) parbeta.append(element) n = 0 m = 0 cx = int xo = int ergxor = [] for n in cypher[:umfg]: cx = parbeta[m] cx = int(cx) n = int(n) xo = n ^ cx ergxor.append(xo) m += 1 # XOR-Verknüpfung element = [] ergebnis = "" for x in ergxor: element = buchst[x] resultat = resultat + element return resultat def bitconvenc(original,alphabet): # Konversion (8-bit > 7-bit / encode) i = 0 digit = 0 xduo = ""
19 folge1 = "" lang = len(original) zusatz = "00000000" for x in original[:lang+1]: digit = buchst.find(x) i += 1 xduo = nachsys(2,digit) xduo = str(xduo) xduo = zusatz + xduo l = len(xduo) xduo = xduo[l-8:] folge1 = folge1 + xduo umfang = len(folge1) slip = "" digit = "" cypher = "" i = 0 element = "" for z in folge1[:umfang+1]: slip = folge1[i:i+7] i += 7 if i > umfang: break digit = nachdez(2,slip) digit = int(digit) element = alphabet[digit] cypher = cypher + element return cypher def bitconvdec(original,alphabet): # Bit-Konversion (7-bit > 8-bit / decode) i = 0 digit = 0 xduo = "" folge1 = "" lang = len(original) zusatz = "00000000" for x in original[:lang+1]: digit = alphabet.find(x) xduo = nachsys(2,digit) xduo = str(xduo) xduo = zusatz + xduo l = len(xduo) xduo = xduo[l-7:l]
20 folge1 = folge1 + xduo umfang = len(folge1) slip = "" digit = "" element = "" ergebnis = "" i = 0 for z in folge1[i:umfang]: slip = folge1[i:i+8] i += 8 if i > umfang: break digit = nachdez(2,slip) element = buchst[digit] ergebnis = ergebnis + element return ergebnis #-------------------------------------------------------------------------------------- Hauptprogramm print(" Passphrase als Startsequenz mit mind. 20 und max. 80 Zeichen eingeben") startsequenz = input( " Startsequenz: ") # Eingabe Startsequenz lang = len(startsequenz) print(" Länge: ",lang) weit = 0 if lang < 20: if lang < 10: print(" Eingabe ist zu kurz! Das Programm endet!") else: startsequenz = buchst[lang:lang+36] + startsequenz weit = len(startsequenz) cd = 1 rundkey = buchst[weit:weit+36] + "Höllriegelskreuth" # Rundkey beim Start # Wahl der Bereiche wahl = input(" Auswahl: schreiben =..w.. / lesen =..r.. / beenden..q.. > ") print(" Bereich: ",wahl) print(" Start: ",startsequenz) matrkey = startsequenz rundkey,matrkey,alphabet = generator(matrkey,cd) # Generator aufrufen
21 if wahl == "w": # Nachricht schreiben datei = "Nachricht.txt" print(" Name der Datei: Nachricht.txt") print(" Bitte die Nachricht schreiben und mit <Enter> abschließen!") zeile = "" text = ":" while text: text = input() zeile = zeile + text if text == "": break cydatei = datei schreiben = open(cydatei,"wb") # Nachricht eingeben # Name der verschlüsselten Datei print(" Cipher-Datei: ",cydatei) print(" Der verschlüsselte Text lautet wie folgt:") i = 0 breite = 63 abschn1 = ":" zeile = zeile + " " # Erfassung des letzten Zeichens while zeile: rundkey,matrkey,alphabet = generator(matrkey,cd) # Generator abschn1 = zeile[i:i+breite] # Abschnitt: Breite = 63 i += breite resultat = XORgen(abschn1,rundkey) # Aufruf XOR-Verknüpf. (one-time-chain) cypher = bitconvenc(resultat,alphabet) # Aufruf Bit-Konversion print(cypher) zeichen = bytes(cypher.encode("utf8")) schreiben.write(zeichen) # Schreiben der verschlüsselten Datei if abschn1 == "": break print(" Die Datei: ",datei," mit e-mail an den Empfänger senden") elif wahl == "r": # erhaltenen Chiffre-text lesen datei = input(" Chiffre-Datei: ")
22 if datei == "": datei = "Nachricht.txt" ln = len(datei) print(" Datei lesen: ",datei) try: lesen = open(datei,"rb") zeile = lesen.read() zeile = zeile.decode("utf8") except: print(" Datei ist nicht vorhanden! ") kldatei = datei schreiben = open(kldatei,"wb") print(" Klartext-Datei: ",kldatei) print(" Der Klartext lautet wie folgt:") i = 0 breite = 72 abschn2 = ":" # Chiffrat lesen # Name der entschlüsselten Datei # Breite verschlüsselte Abschnitte while abschn2: rundkey,matrkey,alphabet = generator(matrkey,cd) # Generator aufrufen abschn2 = zeile[i:i+breite] # Breite = 72 i += breite ergebnis = bitconvdec(abschn2,alphabet) # Aufruf Bit-Konversion resultat = XORgen(ergebnis,rundkey) # Aufruf: XOR-Verschl. (one-time.chain) print(resultat) zeichen = bytes(resultat.encode("1252")) schreiben.write(zeichen) # Schreiben der entschlüsselten Datei else: # Prozess beenden print(" Das Programm ist beendet") schreiben.close() # Ende Quellcode
23 Pychange.py Mit dem Programm wird ein sicherer Schlüsselaustausch mit einem neuen Partner eingeleitet. Einzelheiten sind unter Python-Exchange erläutert. Die ausgetauschen Informationen werden mit CypherMatrix und one-time-chain von End to End verschlüsselt. Nach derzeitigem Stand der Technik wird so eine absolute Sicherheit erreicht. # pychange.py (3.6.2) Schleife: (56 --> 64) import sys, os, time # -*- coding: cp1252 -*- # Definition Buchstaben Cypher: Zeichen-Code t1 = "" t2 = "" t3 = "" t4 = "" t5 = "" t6 = "" t7 = "" t8 = "" t9 = "" buchst = "" umfang = int for i in range(64,91): # Latin Capital Letter t1 += chr(i) for i in range(386,409): # Greek Capital Letter t2 += chr(i) for i in range(412,441): # Greek Small Letter t3 += chr(i) for i in range(33,64): # Latin Ziffern t4 += chr(i) for i in range(504,529): # Cyrillic Small Letter t5 += chr(i) for i in range(97,125): # Latin Small Letter t6 += chr(i) for i in range(457,501): # Cyrillic Capital Letter t7 += chr(i) for i in range(189,233): # versch. Zeichen (Rest) t8 += chr(i) t9 = chr(246)+chr(252)+chr(8364)+chr(8998)+chr(32) # ö,ü,, Sonderzeichen buchst = t1+t2+t3+t4+t5+t6+t7+t8+t9 # Zahlensystem Cypher: Zahlen-Code zahlen = ""
24 digits = "" t2 = "" t3 = "" t4 = "" t5 = "" t6 = "" t7 = "" t8 = "" t9 = "" t10 = "" t11 = "" t12 = "" for i in range(49,58): zahlen += chr(i) for i in range(97,123): t2 += chr(i) for i in range(65,91): t3 += chr(i) t4 = chr(196)+chr(214)+chr(220)+chr(223)+chr(228)+chr(246)+chr(252)+chr(8369) for i in range(915,917): t5 += chr(i) t6 = chr(920)+chr(923)+chr(926)+chr(928)+chr(931)+chr(934)+chr(936)+chr(937) for i in range(945,959): t7 += chr(i) for i in range(960,970): t8 += chr(i) t9 = chr(1024)+chr(1025)+chr(1028) for i in range(1033,1041): t10 += chr(i) for i in range(1046,1051): t11 += chr(i) for i in range(1073,1082): t12 += chr(i) digits = zahlen+t2+t3+t4+t5+t6+t7+t8+t9+t10+t11+t12 def nachsys(basis,q): # Dezimal nach System digitset = digits ergebnis = "" umfang = "" z="" zd="" if basis>10: umfang=digitset[:basis-10] while q > 0:
25 z=int(q % basis) if z>9: zd=umfang[z-10:z-9] else: zd=str(z) q = (q-z)/basis ergebnis=zd+ergebnis return ergebnis def nachdez(basis,syszahl): # System nach Dezimal digitset = digits umfang = digitset[:basis-1] zahl=0 ziffer = "" dezzahl = 0 laenge = len(syszahl) hoch = laenge n = 0 for n in range(laenge): hoch -= 1 n += 1 ziffer = syszahl[n-1] if ziffer: zahl = umfang.find(ziffer)+1 else: zahl = int(ziffer)+1 dezzahl = dezzahl + zahl*basis**hoch return dezzahl def generator(matrkey,cd): rundkey = "" breite = 56 l = len(matrkey) ck = (l * (l-2)) + cd # Generator Prozess # Breite der Eingaben n = 0 hp = 0 hs = 0
26 hk = 0 for z in matrkey[0:(l+1)]: n += 1 s = (ord(z)+1) * (ck +n) hp = hp + s hashfolge = "" folgehash = "" ergebnis = "" n = 0 for z in matrkey[0:(l+1)]: n += 1 ss = ((ord(z)+1) * n * hp) +n+cd+1 ergebnis = nachsys(77,ss) hashfolge = hashfolge + ergebnis hk = hk + ss hs = hp + hk folgehash = hashfolge[::-1] cyphfolge = hashfolge+folgehash lange = len(cyphfolge) alpha = ((hk + hp) % 127) + 1 beta = (hk % 169) + 1 gamma = ((hp +cd) % 196) + 1 theta = (hk % 32) + 1 slip = "" digit = "" zahl = 0 element = "" umfang = 0 i = theta matrix = "" for z in cyphfolge[:lange]: i += 1 slip = cyphfolge[i:i+3] digit = nachdez(78,slip) digit = int(digit) zahl = digit % 256 element = buchst[zahl] if element in matrix: element = "" else:
27 matrix = matrix + element umfang = len(matrix) rest = 0 zusatz = "" if umfang < 256: rest = 256 - umfang zusatz = digits[36:36 + rest] matrix = matrix + zusatz alphabet = matrix[alpha:alpha+128] if beta > (256 - breite): beta == (256 - breite) rundkey = matrix[beta:beta+breite] if gamma > (256 - breite): gamma == (256 - breite) matrkey = matrix[gamma:gamma+breite] return rundkey, matrkey, matrix, hs def XORgen(original,rundkey): # XOR-Verknüpfung (one-time-pad) resultat = "" digit = 0 element = "" cypher = [] lang = len(original) umfg = len(rundkey) for x in original[:lang]: digit = buchst.find(x) element = str(digit) cypher.append(element) digit = 0 element = "" parbeta = [] for z in rundkey[:umfg]: digit = buchst.find(z) element = str(digit) parbeta.append(element) n = 0 m = 0
28 cx = int xo = int ergxor = [] for n in cypher[:umfg]: cx = parbeta[m] cx = int(cx) n = int(n) xo = n ^ cx ergxor.append(xo) m += 1 element = [] ergebnis = "" for x in ergxor: element = buchst[x] resultat = resultat + element return resultat def bitconvenc(original,alphabet): # Konversion (8-bit > 7-bit / encode) i = 0 digit = 0 xduo = "" folge1 = "" lang = len(original) zusatz = "00000000" for x in original[:lang+1]: digit = buchst.find(x) i += 1 xduo = nachsys(2,digit) xduo = str(xduo) xduo = zusatz + xduo l = len(xduo) xduo = xduo[l-8:] folge1 = folge1 + xduo umfang = len(folge1) slip = "" digit = "" cypher = "" i = 0 element = "" for z in folge1[:umfang+1]: slip = folge1[i:i+7] i += 7
29 if i > umfang: break digit = nachdez(2,slip) digit = int(digit) element = alphabet[digit] cypher = cypher + element return cypher def bitconvdec(original,alphabet): # Bit-Konversion (7-bit > 8-bit / decode) i = 0 digit = 0 xduo = "" folge1 = "" lang = len(original) zusatz = "00000000" for x in original[:lang+1]: digit = alphabet.find(x) xduo = nachsys(2,digit) xduo = str(xduo) xduo = zusatz + xduo l = len(xduo) xduo = xduo[l-7:l] folge1 = folge1 + xduo umfang = len(folge1) slip = "" digit = "" element = "" ergebnis = "" i = 0 for z in folge1[i:umfang]: slip = folge1[i:i+8] i += 8 if i > umfang: break digit = nachdez(2,slip) element = buchst[digit] ergebnis = ergebnis + element return ergebnis #... Hauptprogramm # Haupt-Auswahl
30 print(" Bereich: Verschlüsselung = vs / Datentransfer = dt / beenden = qt >") auswahl = input(" Bereich: ") cd = 1 # --------------------------------------- Verschlüssselung ----------------------------------------- if auswahl == "vs": print(" Passphrase als Startsequenz mit mind.36 und max.92 Zeichen eingeben") startsequenz = input( " Startsequenz: ") lang = len(startsequenz) print(" Länge: ",lang) # Eingabe Startsequenz cd = "" cd = input( " Sicherheits-Code: ") if cd == "": cd = 1 print(" Code = 1") cd = int(cd) keyteil = "" teilkey = buchst[lang:lang+36] keyteil = "Höllriegelskreuth" rundkey = teilkey+keyteil # Steuerung: Rundkey beim Start wahl = input(" Auswahl: schreiben =..w.. / lesen =..r.. / beenden..q.. > ") print(" Bereich: ",wahl) matrkey = startsequenz rundkey,matrkey,alphabet,leer = generator(matrkey,cd) if wahl == "w": # Generator aufrufen # Nachricht schreiben datei = "Nachricht.txt" print(" Name der Datei: Cy-Nachricht.txt") print(" Bitte die Nachricht schreiben!") print(" dann weiter mit <Enter> ") zeile = "" text = ":" while text: text = input() zeile = zeile + text # Nachricht schreiben
31 if text == "": break cydatei = "Cy-"+datei schreiben = open(cydatei,"wb") # Name der verschlüsselten Datei print(" Cipher-Datei: ",cydatei) print(" Der verschlüsselte Text lautet wie folgt:") i = 0 breite = 63 abschn1 = ":" zeile = zeile + " " # Erfassung des letzten Zeichens while zeile: rundkey,matrkey,alphabet,leer = generator(matrkey,cd) # Generator abschn1 = zeile[i:i+breite] # Abschnitt: Breite = 63 i += breite resultat = XORgen(abschn1,rundkey) cypher = bitconvenc(resultat,alphabet) print(cypher) # Aufruf der one-time.chain # Aufruf Bit-Konversion zeichen = bytes(cypher.encode("utf8")) schreiben.write(zeichen) # Schreiben der verschlüsselten Datei if abschn1 == "": break elif wahl == "r": # erhaltenen Chiffre-text lesen datei = input(" Chiffre-Datei: ") if datei == "": datei = "Cy-Nachricht.txt" ln = len(datei) print(" Datei lesen: ",datei) try: lesen = open(datei,"rb") zeile = lesen.read() zeile = zeile.decode("utf8") except: print(" Datei ist nicht vorhanden! ") kldatei = "Kt-"+ datei[3:ln] # Chiffrat lesen # Name der entschlüsselten Datei
32 schreiben = open(kldatei,"wb") print(" Klartext-Datei: ",kldatei) print(" Der Klartext lautet wie folgt:") i = 0 breite = 72 abschn2 = ":" # Breite verschlüsselte Abschnitte while abschn2: rundkey,matrkey,alphabet,leer = generator(matrkey,cd) # Generator abschn2 = zeile[i:i+breite] # Breite = 72 i += breite ergebnis = bitconvdec(abschn2,alphabet) # Aufruf Bit-Konversion resultat = XORgen(ergebnis,rundkey) # Aufruf one-time-chain print(resultat) zeichen = bytes(resultat.encode("1252")) schreiben.write(zeichen) # Schreiben der entschlüsselten Datei elif wahl == "q": # Prozess beenden schreiben.close() # --------------------------------------------- Datentransfer ---------------------------------------- elif auswahl == "dt": auswahl = input(" Abschnitt: Sender = s / Empfänger = e / Rücksendung = r / Beenden = qt >") print(" Auswahl: ",auswahl) parole = "" lang = 0 if auswahl == "qt": if auswahl == "s": lt = str(time.time()) matrkey,rundkey,matrix,hs = generator(lt,cd) workcode = nachsys(62,hs) print(" Workcode: ",workcode," Bitte geheim notieren!"), sender = input(" Name des Senders: ") # Eingabe Sender
33 umfang = len(sender) matrkey = parole+buchst[lang:lang+56] matrkey = matrkey[:42] matrkey,rundkey,matrix,hs = generator(matrkey,cd) matrkey = matrkey.replace(chr(8998),"?") rundkey = rundkey.replace(chr(8998),"?") matrix = matrix.replace(chr(8998),"?") trustvalue = nachsys(62,hs) # TrustCode # ---------------------------------- Vorbereitungen beim Sender -------------------------------- if auswahl == "s": print(" TrustCode: ",trustvalue) initialkey = matrkey transferkey = rundkey # Initialkey # Transferkey frage = input(" Soll ein Angebot gesendet werden? [y] ") if frage == "y": # Schlüssel in BACKDATA.TXT speichern parole = input(" Eingabe >PAROLE< [mind. 6 Zeichen] ") lang = len(parole) # Eingabe # PAROLE inhalt = initialkey+chr(8998)+transferkey+chr(8998)+workcode # chr(8998) = ' ' breite = len(inhalt) rundkey = rundkey[:breite] bkinhalt = XORgen(inhalt,matrix[:breite]) # XOR-Verschlüss. (one-time-chain) try: backdata = open("backdata.txt","wb") except: print(" Aktion fehlgeschlagen") schreiben = bytes(bkinhalt.encode("utf8")) backdata.write(schreiben) backdata.close() print(" Datei BACKDATA.TXT im Verzeichnis DOKUMENTE gespeichert") # Angebot an Empfänger: TRANSKEY.TXT
34 nextinhalt = transferkey+chr(8998)+trustvalue+chr(8998)+sender # chr(8998) = ' ' breite = len(nextinhalt) cyinhalt = XORgen(nextinhalt,matrix[:breite]) # XOR-Verschlüss. (one-time-chain) try: transkey = open("transkey.txt","wb") except: print(" Speichern fehlgeschlagen") schreiben = bytes(cyinhalt.encode("utf8")) transkey.write(schreiben) print(" Datei TRANSKEY.TXT im Verzeichnis DOKUMENTE gespeichert") print(" Datei TRANSKEY.TXT per e-mail an den Empfänger schicken") transkey.close() # ---------------------------------- Arbeitsschritte beim Empfänger ------------------------------ elif auswahl == "e": frage = input(" Soll die Nachricht angenommen werden? [y] ") if frage == "y": parole = input(" Eingabe >PAROLE< [mind. 6 Zeichen] ") lang = len(parole) # Eingabe # PAROLE datei = "transkey.txt" ln = len(datei) try: lesen = open(datei,"rb") zeile = lesen.read() zeile = zeile.decode("utf8") except: print(" Datei TRANSKEY.TXT ist nicht vorhanden") i = 0 abschn = ":" breite = len(zeile) while abschn:
35 abschn = zeile[i:i+breite] # Breite = 56 i += breite zeichen = XORgen(abschn,matrix[:breite]) anf = zeichen.find(chr(8998)) nextanf = zeichen.find(chr(8998),anf+1) trustcode = zeichen[anf+1:nextanf] # chr(8998) = ' ' if trustcode == trustvalue: print(" Trustcode "+trustcode+" = Trustvalue "+trustvalue) else: print(" Trustcode wird nicht bestätigt!") os.remove("transkey.txt") print(" Die Datei TRANSKEY.TXT wurde gelöscht") sender = zeichen[nextanf+1:] transferkey = zeichen[:anf] print("",sender," bietet einen Schlüsselaustausch an!") break lesen.close() # Den Schlüssel als Nachricht erzeugen frage = input(" Soll ein Schlüssel erzeugt und gesendet werden? [y] ") if frage == "y": lt = str(time.time()) leer1,leer2,leer3,hs = generator(lt,cd) sendcode = nachsys(62,hs) # Hashwert des Zeitstempels cd = 1 matrkey,rundkey,matrix,hs = generator(transferkey,cd) matrkey = matrkey[:42] trustcode = nachsys(62,hs) # TrustCode datei = "Datasend.txt" print(" Bitte Schlüssel und ggf. weitere Informationen schreiben!") print(" dann weiter mit <Enter>") zeile = "" text = ":" while text: text = input() zeile = zeile + text # Nachricht schreiben
36 if zeile == "": print(" Keine Information geschrieben!") if text == "": break zeile = zeile +" " schreiben = open(datei,"wb") # Den eingegebenen Text verschlüsseln i = 0 breite = 56 abschn = ":" zeile = zeile + chr(8998)+sendcode+" " while zeile: cd = 1 rundkey,matrkey,alphabet,hs = generator(transferkey,cd) # Generator für gespeicherte Nachricht abschn = zeile[i:i+breite] # Abschnitt: Breite = 56 i += breite resultat = XORgen(abschn,rundkey) # XOR-Aufruf (one-time-chain) cypher = bitconvenc(resultat,alphabet) # Aufruf Bit-Konversion zeichen = bytes(cypher.encode("utf8")) schreiben.write(zeichen) # Schreiben der verschlüsselten Datei if abschn == "": schreiben.close() break print(" Sendcode: ",sendcode," Bitte zur Abstimmung merken!") print(" DATASEND.TXT an "+sender+" zurückschicken") # --------------------------------------- Rückkehr zum Sender -------------------------------- elif auswahl == "r": workcode = "" workcode = input(" Bitte den Workcode eingeben! ") parole = input(" Eingabe >PAROLE< [mind. 6 Zeichen] ") lang = len(parole) # Eingabe PAROLE try:
37 lesen = open("backdata.txt","rb") newinhalt = lesen.read() newinhalt = newinhalt.decode("utf8") breite = len(newinhalt) except: print(" Datei BACKDATA.TXT ist nicht vorhanden") exinhalt = XORgen(newinhalt,matrix[:breite]) umfang = len(exinhalt) anf = exinhalt.find(chr(8998)) nextanf = exinhalt.find(chr(8998),anf+1) # XOR-Verschlüss. (one-time-chain) # chr(8998) = ' ' initialkey = exinhalt[:anf] transferkey = exinhalt[anf+1:nextanf] zeitcode =exinhalt[nextanf+1:umfang] if workcode == zeitcode: print(" Workcode: "+workcode+" = Codetest: "+zeitcode) else: print(" Keine Berechtigung für das Programm!") os.remove("datasend.txt") print(" Die Datei DATASEND.TXT wurde gelöscht") datei = input(" Chiffre-Datei: ") if datei == "": datei = "Datasend.txt" print("",datei) try: lesen = open(datei,"rb") zeile = lesen.read() zeile = zeile.decode("utf8") except: print(" Datei "+datei+" ist nicht vorhanden! ") # Chiffrat lesen print(" Die Nachricht lautet wie folgt:") i = 0 breite = 64 abschn = ":" nachricht = "" # Breite der verschlüsselten Abschnitte while abschn:
38 cd = 1 rundkey,matrkey,alphabet,hs = generator(transferkey,cd) # Generator abschn = zeile[i:i+breite] # Breite = 64 i += breite ergebnis = bitconvdec(abschn,alphabet) resultat = XORgen(ergebnis,rundkey) nachricht = nachricht + resultat # Aufruf Bit-Konversion # XOR Verknüpf. (one-time-chain) if abschn == "": break umfg = len(nachricht) anf = nachricht.find(chr(8998)) sendung = nachricht[:anf] codetest = nachricht[anf+1:umfg] if codetest == "": print(" Nachricht wurde nicht korrekt übermittelt! ") else: sendung = nachricht[:anf] print("",sendung) print(" Trustcode: "+codetest+" Mit dem Partner abstimmen!") print(" Das Programm ist beendet ") lesen.close() else: # Prozess beenden # Ende Quellcode Hashwert.py Das Programm ermittelt den Hashwert in 3 Größen: Dezimalwert, Hexadezimal und im System zur Basis 62. Das letztere ist maßgebend. # Hashwert.py (Python 3.6.2) import sys # -*- coding: utf8 -*- # Definition Buchstaben Cypher: Zeichen-Code t1 = ""
39 t2 = "" t3 = "" t4 = "" t5 = "" t6 = "" t7 = "" t8 = "" t9 = "" buchst = "" umfang = int for i in range(64,91): t1 += chr(i) for i in range(386,409): t2 += chr(i) for i in range(412,441): t3 += chr(i) for i in range(33,63): t4 += chr(i) for i in range(504,529): t5 += chr(i) for i in range(97,125): t6 += chr(i) for i in range(457,501): t7 += chr(i) for i in range(189,260): t8 += chr(i) t9 = chr(32) # Latin Capital Letter # Greek Capital Letter # Greek Small Letter # Latin Ziffern # Cyrillic Small Letter # Latin Small Letter # Cyrillic Capital Letter # versch. Zeichen (Rest) # Leerzeichen buchst = t1+t2+t3+t4+t5+t6+t7+t8+t9 # Definition Zahlen Cypher: Zahlen-Code zahlen = "" t1 = "" t2 = "" t3 = "" t4 = "" t5 = "" t6 = "" t7 = "" t8 = "" t9 = "" t10 = "" t11 = "" t12 = "" for i in range(49,58): zahlen += chr(i) for i in range(97,123):
t2 += chr(i) for i in range(65,91): t3 += chr(i) t4 = chr(196)+chr(214)+chr(220)+chr(223)+chr(228)+chr(246)+chr(252)+chr(8369) for i in range(915,917): t5 += chr(i) t6 = chr(920)+chr(923)+chr(926)+chr(928)+chr(931)+chr(934)+chr(936)+chr(937) for i in range(945,959): t7 += chr(i) for i in range(960,970): t8 += chr(i) t9 = chr(1024)+chr(1025)+chr(1028) for i in range(1033,1041): t10 += chr(i) for i in range(1046,1051): t11 += chr(i) for i in range(1073,1082): t12 += chr(i) zahlen = t1+t2+t3+t4+t5+t6+t7+t8+t9+t10+t11+t12 40 def nachsys(basis,q): # Zahlenwandeln: dez / sys digitset = "0"+zahlen ergebnis = "" umfang = "" z = "" zd = "" if basis>10: umfang=digitset[10:basis] while q > 0: z=int(q % basis) if z>9: zd=umfang[z-10:z-9] else: zd=str(z) q = (q-z)/basis ergebnis=zd+ergebnis return ergebnis def nachdez(basis,syszahl): # Zahlenwandeln: sys / dez digitset = zahlen
41 umfang = digitset[:basis-1] zahl = 0 ziffer = "" dezzahl = 0 laenge = len(syszahl) hoch = laenge for n in range(laenge): hoch -= 1 n += 1 ziffer = syszahl[n-1] if ziffer: zahl = umfang.find(ziffer)+1 else: zahl = int(ziffer)+1 dezzahl = dezzahl + zahl*basis**hoch return dezzahl def generator(abschn,cd): # Generator Prozess breite = 62 l = len(abschn) ck = (l * (l-2)) + cd n = 0 s = 0 ss= 0 hp = 0 hs = 0 hk = 0 hw = 0 www = int for z in abschn[0:(l+1)]: n += 1 s = (ord(z)+1) * (ck +n) hp = hp + s hashfolge = "" folgehash = "" ergebnis = "" n = 0 for z in abschn[0:(l+1)]: # Schleife auf 0 stellen
42 n += 1 ss = ((ord(z)+1) * n * hp) +n+cd+1 ergebnis = nachsys(77,ss) hashfolge = hashfolge + ergebnis hk = hk + ss hs = hp + hk folgehash = hashfolge[::-1] cyphfolge = hashfolge+folgehash lange = len(cyphfolge) alpha = ((hk + hp) % 127) + 1 theta = (hk % 32) + 1 slip = "" digit = "" zahl = 0 element = "" umfang = 0 i = theta matrix = "" for z in cyphfolge[:lange]: i += 1 slip = cyphfolge[i:i+3] digit = nachdez(78,slip) digit = int(digit) hw = hw + digit zahl = digit % 256 element = buchst[zahl] if element in matrix: element = "" else: matrix = matrix + element umfang = len(matrix) rest = 0 zusatz = "" hc = 0 lc = 0 if umfang < 256: rest = 256 - umfang zusatz = zahlen[80:80 + rest] matrix = matrix + zusatz alphabet = matrix[alpha:alpha+128]
43 for a in alphabet: lc = buchst.find(a) hc = hc +lc hs = hs + hw + hc r return hs # ----------------------------------------------------------------------- Hauptprogramm ------- # Auswahl wahl = input(" Auswahl: Datei =..d.. / Textsequenz =..t.. / beenden..q.. > ") if wahl == "d": datei = input(" Datei: ") try: lesen = open(datei,"rb") zeile = lesen.read() zeile = zeile.decode("utf8") except: print(" Datei ist nicht vorhanden oder unbekannte Zeichen! ") elif wahl == "t": lesen = input(" Eingabe Textsequenz: ") breite = len(lesen) zeile = lesen[0:breite] else: # Textsequenz # Prozess beenden cd = 1 hs = generator(zeile,cd) print(" Hashwert 10: ",hs) wert16 = nachsys(16,hs) print(" Hashwert 16: ",wert16) hashwert = nachsys(62,hs) anzahl = len(hashwert) print(" Hashwert 62: ",hashwert) print(" Zeichen: ",anzahl)
44 lesen.close() # Ende Quellcode Userpass.py Um das Problem mit vielen Passwörtern zu vermeiden, verwendet das Programm nur ein einziges Passwort für alle Fälle, allerdings mit größerer Länge (ab 26 Zeichen). Dafür ist die Passphrase mit CypherMatrix und one-time-chain so gut gesichert, dass sie nicht gebrochen werden kann. Detailierte Erläuterungen finden sich unter Python-Passwortlösung Beispiele für Passphrasen: Im Steinhuder Meer schwimmen 267 Steinbeisser (45 Bytes) Leonardo eroberte Florenz mit Schneekanonen (43 Bytes) Sven Hedin is sailing around the Northpole (42 Bytes) Jeden Morgen um 7 Uhr 30 fährt ein Zug von StMichaelisdonn nach Höllriegelskreuth (80 Bytes) # userpass.py (3.6.2) Umfang: Breite der Eingabe import sys, os # -*- coding: cp1252 -*- # Definition Buchstaben Cypher: Zeichen-Code t1 = "" t2 = "" t3 = "" t4 = "" t5 = "" t6 = "" t7 = "" t8 = "" t9 = "" buchst = "" umfang = int for i in range(64,91): t1 += chr(i) for i in range(386,409): t2 += chr(i) for i in range(412,441): t3 += chr(i) for i in range(33,64): t4 += chr(i) for i in range(504,529): t5 += chr(i) # Latin Capital Letter # Greek Capital Letter # Greek Small Letter # Latin Ziffern # Cyrillic Small Letter
45 for i in range(97,125): t6 += chr(i) for i in range(457,501): t7 += chr(i) for i in range(189,237): t8 += chr(i) t9 = chr(32) # Latin Small Letter # Cyrillic Capital Letter # versch. Zeichen (Rest) # Leerzeichen buchst = t1+t2+t3+t4+t5+t6+t7+t8+t9 # Zahlensystem Cypher: Zahlen-Code t2 = "" t3 = "" t4 = "" t5 = "" t6 = "" t7 = "" t8 = "" t9 = "" t10 = "" t11 = "" t12 = "" t13 = "" zahlen = "" digits = "" for i in range(49,58): zahlen += chr(i) for i in range(97,123): t2 += chr(i) for i in range(65,91): t3 += chr(i) t4 = chr(196)+chr(214)+chr(220)+chr(223)+chr(228)+chr(246)+chr(252)+chr(8369) for i in range(915,917): t5 += chr(i) t6 = chr(920)+chr(923)+chr(926)+chr(928)+chr(931)+chr(934)+chr(936)+chr(937) for i in range(945,959): t7 += chr(i) for i in range(960,970): t8 += chr(i) t9 = chr(1024)+chr(1025)+chr(1028) for i in range(1033,1041): t10 += chr(i) for i in range(1046,1051): t11 += chr(i) for i in range(1073,1082): t12 += chr(i) for i in range(1094,1108):
46 t13 += chr(i) digits = zahlen+t2+t3+t4+t5+t6+t7+t8+t9+t10+t11+t12+t13 def nachsys(basis,q): Zahlenwandel: Dezimal nach System digitset = digits ergebnis = "" umfang = "" z = "" zd = "" if basis>10: umfang=digitset[:basis-10] while q > 0: z=int(q % basis) if z>9: zd=umfang[z-10:z-9] else: zd=str(z) q = (q-z)/basis ergebnis=zd+ergebnis return ergebnis def nachdez(basis,syszahl) : # Zahlenwandel: System nach Dezimal digitset = digits umfang = digitset[:basis-1] zahl=0 ziffer = "" dezzahl = 0 laenge = len(syszahl) hoch = laenge for n in range(laenge): hoch -= 1 n += 1 ziffer = syszahl[n-1] if ziffer: zahl = umfang.find(ziffer)+1 else:
47 zahl = int(ziffer)+1 dezzahl = dezzahl + zahl*basis**hoch return dezzahl def generator(matrkey,cd): # Generator: Steuerung Variable l = len(matrkey) breite = l ck = (l * (l-2)) + cd rundkey = "" n = 0 hp = 0 hs = 0 hk = 0 for z in matrkey[0:(l+1)]: n += 1 s = (ord(z)+1) * (ck +n) hp = hp + s hashfolge = "" folgehash = "" ergebnis = "" n = 0 for z in matrkey[0:(l+1)]: n += 1 ss = ((ord(z)+1) * n * hp) +n+cd+1 ergebnis = nachsys(77,ss) hashfolge = hashfolge + ergebnis hk = hk + ss hs = hp + hk folgehash = hashfolge[::-1] cyphfolge = hashfolge+folgehash lange = len(cyphfolge) alpha = ((hk + hp) % 127) + 1 beta = (hk % 169) + 1 gamma = ((hp +cd) % 196) + 1 theta = (hk % 32) + 1 slip = "" digit = "" zahl = 0
48 element = "" umfang = 0 i = theta matrix = "" for z in cyphfolge[:lange]: i += 1 slip = cyphfolge[i:i+3] digit = nachdez(78,slip) digit = int(digit) zahl = digit % 256 element = buchst[zahl] if element in matrix: element = "" else: matrix = matrix + element umfang = len(matrix) rest = 0 zusatz = "" if umfang < 256: rest = 256 - umfang zusatz = digits[36:36 + rest] matrix = matrix + zusatz alphabet = matrix[alpha:alpha+128] # Runden-Alphabet if beta > (256 - breite): beta == (256 - breite) rundkey = matrix[beta:beta+breite] # Rundenschlüssel if gamma > (256 - breite): gamma == (256 - breite) matrkey = matrix[gamma:gamma+breite] # Matrixschlüssel return rundkey, matrkey, alphabet def XORgen(original,rundkey): # XOR-Verknüpfung (one-time-chain) resultat = "" digit = 0 element = "" cypher = [] lang = len(original) umfg = len(rundkey)
49 for x in original[:lang]: x = str(x) digit = buchst.find(x) element = str(digit) cypher.append(element) digit = 0 element = "" parbeta = [] for z in rundkey[:lang]: z = str(z) digit = buchst.find(z) element = str(digit) parbeta.append(element) n = 0 m = 0 cx = int xo = int ergxor = [] for n in cypher[:umfg]: cx = parbeta[m] cx = int(cx) n = int(n) xo = n ^ cx ergxor.append(xo) m += 1 # Blockzeile XOR Rundenschlüssel element = [] ergebnis = "" for x in ergxor: element = buchst[x] resultat = resultat + element return resultat def bitconverten(original,alphabet): # Konversion (8-bit > 7-bit / encode) i = 0 digit = 0 xduo = "" folge1 = "" lang = len(original) zusatz = "00000000" for x in original[:lang+1]: digit = buchst.find(x)
50 i += 1 xduo = nachsys(2,digit) xduo = str(xduo) xduo = zusatz + xduo l = len(xduo) xduo = xduo[l-8:] folge1 = folge1 + xduo umfang = len(folge1) slip = "" digit = "" cypher = "" i = 0 element = "" for z in folge1[:umfang+1]: slip = folge1[i:i+7] i += 7 if i > umfang: break digit = nachdez(2,slip) digit = int(digit) element = alphabet[digit] cypher = cypher + element # Chiffretext return cypher #................................................... Hauptprogramm print(" >>>>> PassPhrase eingeben mit mind.26 Zeichen <<<<<" ) kennung = input( " Eingabe PassPhrase: ") # Eingabe Startsequenz sequ = len(kennung) print(" Länge: ",sequ," Zeichen") if sequ < 26: print(" PassPhrase ist zu kurz, mind.26 Zeichen! Bitte neu starten") sys.exit() cd = 1 # Auswahl wahl = input(" Auswahl: testen =..t.. / schreiben =..s.. / beenden..q.. > ") print(" gewählt: ",wahl) zeile = kennung breite = len(zeile)
51 rundkey,nix,alphabet = generator(zeile,cd) # Generator: Steuerungsdaten resultat = XORgen(zeile,rundkey) cypher = bitconverten(resultat,alphabet) if wahl == "s": # Aufruf XOR-Verknüpfung (one-time-chain) # Aufruf Bit-Konversion # PassPhrase codieren print(" PassPhrase: ",cypher) umfang = len(cypher) print(" Umfang: ",umfang," Zeichen") datei = "userpass.txt" schreiben = open(datei,"wb") zeichen = cypher.encode("utf8") zeichen = bytes(zeichen) schreiben.write(zeichen) # Schreiben der verschlüsselten Datei print(" Gespeichert in: ",datei) schreiben.close() elif wahl == "t": hashwert = cypher datei = "userpass.txt" inhalt = open(datei,"rb") reihe = inhalt.read() vergleich = reihe.decode() umfang = len(vergleich) print(" Eingabe: ",kennung) print(" PassTest: ",vergleich) print("",umfang," Zeichen") if hashwert == vergleich: print(" Übereinstimmung!") else: print(" Keine Übereinstimmung") CypherMatrix Generator inhalt.close() else: sys.exit()
52 # Ende Quellcode CGenerator.py Der im CypherMatrix -Verfahren verwendete Generator verwendet in fast allen Fällen auch die one-time-chain, die aus lückenlosen alternativen one-time-pads besteht. Einzelheiten unter CypherMatrix Generator # CGenerator.py (3.6.2) Schleife: (63 ) import sys, os, random # -*- coding: cp1252 -*- # Definition Buchstaben Cypher: Zeichen-Code t1 = "" t2 = "" t3 = "" t4 = "" t5 = "" t6 = "" t7 = "" t8 = "" t9 = "" buchst = "" umfang = int for i in range(64,91): # Latin Capital Letter t1 += chr(i) for i in range(386,409): # Greek Capital Letter t2 += chr(i) for i in range(412,441): # Greek Small Letter t3 += chr(i) for i in range(33,64): # Latin Ziffern t4 += chr(i) for i in range(504,529): # Cyrillic Small Letter t5 += chr(i) for i in range(97,125): # Latin Small Letter t6 += chr(i) for i in range(457,501): # Cyrillic Capital Letter t7 += chr(i) for i in range(189,234): # versch. Zeichen (Rest) t8 += chr(i) t9 = chr(246)+chr(252)+chr(8364)+chr(8998)+chr(32) # ö,ü,, Sonderzeichen buchst = t1+t2+t3+t4+t5+t6+t7+t8+t9 # Zahlensystem Cypher: Zahlen-Code
53 zahlen = "" digits = "" t2 = "" t3 = "" t4 = "" t5 = "" t6 = "" t7 = "" t8 = "" t9 = "" t10 = "" t11 = "" t12 = "" for i in range(49,58): zahlen += chr(i) for i in range(97,123): t2 += chr(i) for i in range(65,91): t3 += chr(i) t4 = chr(196)+chr(214)+chr(220)+chr(223)+chr(228)+chr(246)+chr(252)+chr(8369) for i in range(915,917): t5 += chr(i) t6 = chr(920)+chr(923)+chr(926)+chr(928)+chr(931)+chr(934)+chr(936)+chr(937) for i in range(945,959): t7 += chr(i) for i in range(960,970): t8 += chr(i) t9 = chr(1024)+chr(1025)+chr(1028) for i in range(1033,1041): t10 += chr(i) for i in range(1046,1051): t11 += chr(i) for i in range(1073,1082): t12 += chr(i) digits = zahlen+t2+t3+t4+t5+t6+t7+t8+t9+t10+t11+t12 def nachsys(basis,q): # Dezimal nach System digitset = digits ergebnis = "" umfang = "" z = "" zd = "" if basis>10: umfang=digitset[:basis-10]
54 while q > 0: z=int(q % basis) if z>9: zd=umfang[z-10:z-9] else: zd=str(z) q = (q-z)/basis ergebnis=zd+ergebnis return ergebnis def nachdez(basis,syszahl): # System nach Dezimal digitset = digits umfang = digitset[:basis-1] zahl=0 ziffer = "" dezzahl = 0 laenge = len(syszahl) hoch = laenge n = 0 for n in range(laenge): hoch -= 1 n += 1 ziffer = syszahl[n-1] if ziffer: zahl = umfang.find(ziffer)+1 else: zahl = int(ziffer)+1 dezzahl = dezzahl + zahl*basis**hoch return dezzahl def generator(matrkey): breite = 63 l = len(matrkey) ck = (l * (l-2)) # Generator Prozess # Breite der Eingaben n = 0 hp = 0 hs = 0
55 hk = 0 for z in matrkey[0:(l+1)]: n += 1 s = (ord(z)+1) * (ck +n) hp = hp + s hashfolge = "" folgehash = "" ergebnis = "" n = 0 for z in matrkey[0:(l+1)]: n += 1 ss = ((ord(z)+1) * n * hp) +n+1 ergebnis = nachsys(77,ss) hashfolge = hashfolge + ergebnis hk = hk + ss hs = hp + hk folgehash = hashfolge[::-1] cyphfolge = hashfolge+folgehash lange = len(cyphfolge) alpha = ((hk + hp) % 127) + 1 beta = (hk % 169) + 1 gamma = (hp % 196) + 1 theta = (hk % 32) + 1 slip = "" digit = "" zahl = 0 element = "" umfang = 0 i = theta matrix = "" for z in cyphfolge[:lange]: i += 1 slip = cyphfolge[i:i+3] digit = nachdez(78,slip) digit = int(digit) zahl = digit % 256 element = buchst[zahl] if element in matrix: element = "" else:
56 matrix = matrix + element umfang = len(matrix) rest = 0 zusatz = "" if umfang < 256: rest = 256 - umfang zusatz = digits[36:36 + rest] matrix = matrix + zusatz alphabet = matrix[alpha:alpha+128] if beta > (256 - breite): beta == (256 - breite) rundkey = matrix[beta:beta+breite] if gamma > (256 - breite): gamma == (256 - breite) matrkey = matrix[gamma:gamma+breite] return rundkey, matrkey, alphabet def XORgen(original,rundkey): # XOR-Verknüpfung (one-time-chain) resultat = "" digit = 0 element = "" cypher = [] lang = len(original) umfg = len(rundkey) for x in original[:lang]: digit = buchst.find(x) element = str(digit) cypher.append(element) digit = 0 element = "" parbeta = [] for z in rundkey[:umfg]: digit = buchst.find(z) element = str(digit) parbeta.append(element) n = 0 m = 0