Python-Module. (Ernst Erich Schnoor)
|
|
- Catharina Raske
- vor 6 Jahren
- Abrufe
Transkript
1 1 Python-Module (Ernst Erich Schnoor) Im Folgenden sind einige Python-Module aufgeführt, die mit Python 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 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 ƥʀƨƨʃƪƫƭƭʈưưʊʋƴƴƶƶʒƹ#!"#&'()*+,-./ :;<=>ǹǹǻǻǽǽǿǿȁȁȃȃȅȅȇȇȉȉȋȋȍȍȏȏ Ȑ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 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 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: ( ) 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 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 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 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 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 = 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 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 = " " for x in original[:lang+1]: digit = buchst.find(x) i += 1 xduo = nachsys(2,digit) xduo = str(xduo)
10 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 = " " 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 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! ")
12 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 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: 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 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 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 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 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 = 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 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 19 folge1 = "" lang = len(original) zusatz = " " 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 = " " 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 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 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 an den Empfänger senden") elif wahl == "r": # erhaltenen Chiffre-text lesen datei = input(" Chiffre-Datei: ")
22 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 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 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 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 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 27 matrix = matrix + element umfang = len(matrix) rest = 0 zusatz = "" if umfang < 256: rest = 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 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 = " " 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 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 = " " 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 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 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 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 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 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 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 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 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 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 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 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):
40 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 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 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 = umfang zusatz = zahlen[80:80 + rest] matrix = matrix + zusatz alphabet = matrix[alpha:alpha+128]
43 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 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 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 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 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 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 = 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 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 = " " for x in original[:lang+1]: digit = buchst.find(x)
50 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 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 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 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 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 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 56 matrix = matrix + element umfang = len(matrix) rest = 0 zusatz = "" if umfang < 256: rest = 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
Gesicherter Schlüsselaustausch >CypherMatrix Key-Exchange< (Ernst Erich Schnoor)
Gesicherter Schlüsselaustausch >CypherMatrix Key-Exchange< (Ernst Erich Schnoor) Die Verschlüsselung das Schreiben und Lesen von geheimen Informationen wird im CypherMatrix Verfahren im Gegensatz zu den
MehrSteht in der ersten Zeile #!/usr/bin/python und hat man die Ausführungsrechte gesetzt kann man es direkt ausführen.
Python Unter Windows empfiehlt sich der Download von Python unter folgender URL, http:// www.python.org/download/. Linux Distributionen wie z.b. Ubuntu liefern Python direkt in Ihrer Paketverwaltung mit:
MehrSicherheit von PDF-Dateien
Sicherheit von PDF-Dateien 1 Berechtigungen/Nutzungsbeschränkungen zum Drucken Kopieren und Ändern von Inhalt bzw. des Dokumentes Auswählen von Text/Grafik Hinzufügen/Ändern von Anmerkungen und Formularfeldern
MehrBeispiel 19. December 4, 2009
Beispiel 9 December 4, 2009 Computermathematik (für Informatik) 4. Übungsblatt (Musterlösung) 2. 2. 2009 Die heutigen Übungen sollen mit dem Computeralgebrasystem Sage gelöst werden. Die Lösung der Beispiele
MehrEinführung in Python Teil I Grundlagen
Einführung in Python Teil I Grundlagen Valentin Flunkert Institut für Theoretische Physik Technische Universität Berlin Do. 27.5.2010 Nichtlineare Dynamik und Kontrolle SS2010 1 of 22 Diese Einführung
MehrNetzwerktechnologien 3 VO
Netzwerktechnologien 3 VO Univ.-Prof. Dr. Helmut Hlavacs helmut.hlavacs@univie.ac.at Dr. Ivan Gojmerac gojmerac@ftw.at Bachelorstudium Medieninformatik SS 2012 Kapitel 8 - Netzwerksicherheit 8.1 Was ist
MehrGrundlagen der Kryptographie
Grundlagen der Kryptographie Seminar zur Diskreten Mathematik SS2005 André Latour a.latour@fz-juelich.de 1 Inhalt Kryptographische Begriffe Primzahlen Sätze von Euler und Fermat RSA 2 Was ist Kryptographie?
MehrGnuPG für Mail Mac OS X 10.4 und 10.5
GnuPG für Mail Mac OS X 10.4 und 10.5 6. Nachrichten verschlüsseln und entschlüsseln mit Mail http://verbraucher-sicher-online.de/ 22.10.2009 Sie haben GPG installiert. Sie haben ein Schlüsselpaar und
MehrInstitut für Kryptographie und Sicherheit Jun.-Prof. Dr. D. Hofheinz. Stammvorlesung Sicherheit im Sommersemester 2013.
Institut für Kryptographie und Sicherheit Jun.-Prof. Dr. D. Hofheinz IKS Institut für Kryptographie und Sicherheit Stammvorlesung Sicherheit im Sommersemester 2013 Übungsblatt 2 Aufgabe 1. Wir wissen,
MehrMit Python von Caesar zur Public-Key Kryptographie
Mit Python von Caesar zur Public-Key Kryptographie Thomas Grischott KSS 30. Juni 2008 1 Die Caesarverschiebung Caesar hat Nachrichten an seine Feldherren verschlüsselt, indem er jeden Buchstaben um drei
Mehrmonoalphabetisch: Verschiebechiffren (Caesar), multiplikative Chiffren polyalphabetisch: Vigenère-Chiffre
Was bisher geschah Kryptographische Systeme (M, C, K, E, D) Symmetrische Verfahren (gleicher Schlüssel zum Verschlüsseln und Entschlüsseln): Substitutions-Chiffren (Permutationschiffren): Ersetzung jedes
MehrHans-Georg Eßer Betriebssysteme, WS 2006/07. Fachbereich Informatik/Mathematik Übungsblatt 1, Seite 1/5 Fachhochschule München 08.11.
Fachbereich Informatik/Mathematik Übungsblatt 1, Seite 1/5 Vorbereitung Booten Sie den Rechner unter Linux. Melden Sie sich mit Ihrem ifw... - oder ibw... -Account an (Passwort ist evtl. die Matrikelnummer).
MehrThunderbird Portable + GPG/Enigmail
Thunderbird Portable + GPG/Enigmail Bedienungsanleitung für die Programmversion 17.0.2 Kann heruntergeladen werden unter https://we.riseup.net/assets/125110/versions/1/thunderbirdportablegpg17.0.2.zip
MehrInformationssicherheit - Lösung Blatt 2
Informationssicherheit - Lösung Blatt 2 Adam Glodek adam.glodek@gmail.com 13.04.2010 1 1 Aufgabe 1: One Time Pad 1.1 Aufgabenstellung Gegeben ist der folgende Klartext 12Uhr (ASCII). Verschlüsseln Sie
MehrKapitel 3. Codierung von Text (ASCII-Code, Unicode)
Kapitel 3 Codierung von Text (ASCII-Code, Unicode) 1 Kapitel 3 Codierung von Text 1. Einleitung 2. ASCII-Code 3. Unicode 2 1. Einleitung Ein digitaler Rechner muss jede Information als eine Folge von 0
Mehr10. Kryptographie. Was ist Kryptographie?
Chr.Nelius: Zahlentheorie (SoSe 2015) 39 10. Kryptographie Was ist Kryptographie? Die Kryptographie handelt von der Verschlüsselung (Chiffrierung) von Nachrichten zum Zwecke der Geheimhaltung und von dem
MehrPeDaS Personal Data Safe. - Bedienungsanleitung -
PeDaS Personal Data Safe - Bedienungsanleitung - PeDaS Bedienungsanleitung v1.0 1/12 OWITA GmbH 2008 1 Initialisierung einer neuen SmartCard Starten Sie die PeDaS-Anwendung, nachdem Sie eine neue noch
MehrPython Einführung in die prozedurale Programmierung. Monty Python's Flying Circus
Python Einführung in die prozedurale Programmierung Monty Python's Flying Circus Literatur Buchtitel Autor ISBN-Nummer Python Python3 Objektorientierte Programmierung mit Python 3 Handbuch des RRZN Johannes
MehrPython Programmierung. Dipl.-Ing.(FH) Volker Schepper
Python Programmierung Kontaktdaten Homepage: http://wwwlehre.dhbw-stuttgart.de/~schepper/ Email: Volker. Schepper [A@T] yahoo.de Vorlesung Skriptsprachen Vorlesung: 06.03.2013 13.03.2013 20.03.2013 27.03.2013
MehrProgrammieren mit Python
Programmieren mit Python Programmieren heisst: Dem Computer sagen, was er tun soll. Die Befehle muss man übrigens in einer Sprache geben, die der Computer versteht. Darum sind verschiedene Programmiersprachen
MehrE-Mail-Verschlüsselung mit S/MIME
E-Mail-Verschlüsselung mit S/MIME 17. November 2015 Inhaltsverzeichnis 1 Zertifikat erstellen 1 2 Zertifikat speichern 4 3 Zertifikat in Thunderbird importieren 6 4 Verschlüsselte Mail senden 8 5 Verschlüsselte
Mehr12 Kryptologie. ... immer wichtiger. Militär (Geheimhaltung) Telebanking, Elektronisches Geld E-Commerce WWW...
12 Kryptologie... immer wichtiger Militär (Geheimhaltung) Telebanking, Elektronisches Geld E-Commerce WWW... Kryptologie = Kryptographie + Kryptoanalyse 12.1 Grundlagen 12-2 es gibt keine einfachen Verfahren,
MehrPython SVN-Revision 12
Python SVN-Revision 12 Uwe Ziegenhagen 7. Januar 2012 Vorwort Dieses Skript erhebt keinen Anspruch auf Vollständigkeit oder Richtigkeit. Es wird geschrieben, um mir als Gedächtnisstütze für den Umgang
MehrModul Entscheidungsunterstützung in der Logistik. Einführung in die Programmierung mit C++ Übung 2
Fakultät Verkehrswissenschaften Friedrich List, Professur für Verkehrsbetriebslehre und Logistik Modul Entscheidungsunterstützung in der Logistik Einführung in die Programmierung mit C++ Übung 2 SS 2016
MehrDas RSA-Verschlüsselungsverfahren 1 Christian Vollmer
Das RSA-Verschlüsselungsverfahren 1 Christian Vollmer Allgemein: Das RSA-Verschlüsselungsverfahren ist ein häufig benutztes Verschlüsselungsverfahren, weil es sehr sicher ist. Es gehört zu der Klasse der
MehrRegistrierung am Elterninformationssysytem: ClaXss Infoline
elektronisches ElternInformationsSystem (EIS) Klicken Sie auf das Logo oder geben Sie in Ihrem Browser folgende Adresse ein: https://kommunalersprien.schule-eltern.info/infoline/claxss Diese Anleitung
MehrVerschlüsselung. Kirchstraße 18 Steinfelderstraße 53 76831 Birkweiler 76887 Bad Bergzabern. 12.10.2011 Fabian Simon Bfit09
Verschlüsselung Fabian Simon BBS Südliche Weinstraße Kirchstraße 18 Steinfelderstraße 53 76831 Birkweiler 76887 Bad Bergzabern 12.10.2011 Fabian Simon Bfit09 Inhaltsverzeichnis 1 Warum verschlüsselt man?...3
Mehr4 Codierung nach Viginere (Lösung)
Kapitel 4 Codierung nach Viginere (Lösung) Seite 1/14 4 Codierung nach Viginere (Lösung) 4.1 Einführung Blaise de Vigenère lebte von 1523 bis 1596 in Frankreich und war nach dem Studium bei verschiedenen
MehrKryptographische Systeme (M, C, K, e, d) Symmetrische Verfahren (gleicher Schlüssel zum Verschlüsseln und Entschlüsseln):
Was bisher geschah Kryptographische Systeme (M, C, K, e, d) Symmetrische Verfahren (gleicher Schlüssel zum Verschlüsseln und Entschlüsseln): Substitutions-Chiffren (Permutationschiffren): Ersetzung jedes
MehrBetriebsarten für Blockchiffren
Betriebsarten für Blockchiffren Prof. Dr. Rüdiger Weis TFH Berlin Sommersemester 2008 Betriebsarten für Blockchiffren Was ist eine Betriebsart (engl. Mode of Operation )? Blockchiffre wird genutzt, um
MehrPraktikum IT-Sicherheit
IT-Sicherheit Praktikum IT-Sicherheit - Versuchshandbuch - Aufgaben Kryptografie II In diesem zweiten Versuch zur Kryptografie gehen wir etwas genauer auf die Art und Weise der Verschlüsselung mit der
MehrKurzanleitung GPG Verschlüsselung Stand vom 13.11.2006
Inhaltsverzeichnis 1. Versenden des eigenen öffentlichen Schlüssels... 2 2. Empfangen eines öffentlichen Schlüssels... 3 3. Versenden einer verschlüsselten Nachricht... 6 4. Empfangen und Entschlüsseln
MehrKodierung. Kodierung von Zeichen mit dem ASCII-Code
Kodierung Kodierung von Zeichen mit dem ASCII-Code Weiterführende Aspekte zur Kodierung: Speicherplatzsparende Codes Fehlererkennende und -korrigierende Codes Verschlüsselnde Codes Spezielle Codes, Beispiel
MehrHinweise für die verschlüsselte E-Mail Kommunikation bei der VHV Verwendung des Z1-Messengers
Hinweise für die verschlüsselte E-Mail Kommunikation bei der VHV Verwendung des Z1-Messengers So können Sie eine verschlüsselte E-Mail der VHV erkennen und entschlüsseln. 1. Ankündigung, das eine E-Mail
MehrSICHERE DATENHALTUNG IN DER CLOUD VIA HANDY. Tuba Yapinti Abschlussvortrag der Bachelorarbeit Betreuer: Prof. Reinhardt, Dr.
SICHERE DATENHALTUNG IN DER CLOUD VIA HANDY 1 Tuba Yapinti Abschlussvortrag der Bachelorarbeit Betreuer: Prof. Reinhardt, Dr. Bernd Borchert GLIEDERUNG 1. Motivation Gründe für die Entwicklung Ideen für
MehrKundenleitfaden Secure E-Mail
Vorwort Wir leben in einem elektronischen Zeitalter. Der Austausch von Informationen erfolgt zunehmend über elektronische Medien wie das Versenden von E-Mails. Neben den großen Vorteilen, die uns elektronische
MehrSichere E-Mail-Kommunikation zur datenschutz nord GmbH Merkblatt
April 2011 Sichere E-Mail-Kommunikation zur datenschutz nord GmbH Merkblatt 1. Einleitung E-Mails lassen sich mit geringen Kenntnissen auf dem Weg durch die elektronischen Netze leicht mitlesen oder verändern.
MehrE-Mails versenden aber sicher! Secure E-Mail. Kundenleitfaden. Sparkasse Landshut
E-Mails versenden aber sicher! Secure E-Mail Kundenleitfaden S Vorwort Wir alle leben in einem elektronischen Zeitalter. Der Austausch von Informationen erfolgt zunehmend über elektronische Medien wie
MehrAnleitung zum Erstellen und Auspacken eines verschlüsselten Archivs zur Übermittlung personenbezogener Daten per E-Mail 1
personenbezogener Daten per E-Mail 1 Entsprechend der gültigen Verschlüsselungsverordnung http://www.kirchenrechtwuerttemberg.de/showdocument/id/17403 gilt u.a. 1 (1) Personenbezogene Daten und andere
MehrC-Probeklausur (Informatik 1; Umfang: C, Teil 1; SS07)
C-Probeklausur (Informatik 1; Umfang: C, Teil 1; SS07) 1. Aufgabe 6 Punkte Geben Sie Definitionen an für: float var; 1 a) eine float-variable var: b) einen Zeiger pvar, der float *pvar = &var; 1 auf die
MehrBefundempfang mit GPG4Win
Befundempfang mit GPG4Win Entschlüsseln von PGP Dateien mittels GPG4Win... 1 Tipps... 9 Automatisiertes Speichern von Anhängen mit Outlook und SmartTools AutoSave... 10 Automatisiertes Speichern von Anhängen
MehrDatenaustausch. Energiewirtschaft 3. Semester. Tillman Swinke
Datenaustausch Energiewirtschaft 3. Semester Tillman Swinke Frohes neues Jahr Organisatorisches Ab nächster Vorlesung: 30 min Fragestunde (Bitte Vorbereiten) Übungsklausur in der nächsten Vorlesung Agenda
MehrMerkblatt: Sichere E-Mail-Kommunikation zur datenschutz cert GmbH
Version 1.3 März 2014 Merkblatt: Sichere E-Mail-Kommunikation zur datenschutz cert GmbH 1. Relevanz der Verschlüsselung E-Mails lassen sich mit geringen Kenntnissen auf dem Weg durch die elektronischen
MehrÜbung zur Wirtschaftsinformatik I. Zahlensysteme / Codierung
WS 06/07 Thema 4: Zahlensysteme / Codierung 1 Übung zur Winfo I - Themenplan - Informationsverarbeitung in Unternehmen Tabellenkalkulation Anwendungen PC-Komponenten Zahlensysteme / Codierung Boole sche
MehrAcer edatasecurity Management
1 Acer edatasecurity Management Mittels erweiterter Kryptographie-Technologien bietet Acer edatasecurity Management eine bessere Sicherheit für Ihre persönlichen Daten und Verschlüsselung von Dateien und
MehrEs ist für die Lösung der Programmieraufgabe nicht nötig, den mathematischen Hintergrund zu verstehen, es kann aber beim Verständnis helfen.
Ziele sind das Arbeiten mit Funktionen und dem Aufzählungstyp (enum), sowie - einfache Verzweigung (if else) - Alternativen switch case - einfache Schleifen (while oder do while) Aufgabe 3: Diese Aufgabe
MehrDaten verschlüsseln: warum? wie? Das Programm herunterladen und auf dem USB-Stick installieren Dateien mit Challenger verschlüsseln - entschlüsseln
Verschlüsseln und Entschlüsseln von Dateien-Ordnern-Laufwerken Die Themen Daten verschlüsseln: warum? wie? Das Programm herunterladen und auf dem USB-Stick installieren Dateien mit Challenger verschlüsseln
Mehr1. Praktikum zur IT-Sicherheit 1
Prof. Dr. Heiko Knospe WS 2004/05 Vigenère Chiffre 1. Praktikum zur IT-Sicherheit 1 Bei der Vigenère Chiffre der Länge n werden Klartext- und Chiffretexte durch Worte über dem Alphabet Σ = {A, B,..., Z}
MehrDie Programmiersprache C
Die Programmiersprache C höhere Programmiersprache (mit einigen Assembler-ähnlichen Konstrukten) gut verständliche Kommandos muss von Compiler in maschinenlesbaren Code (Binärdatei) übersetzt werden universell,
MehrEin Scan basierter Seitenangriff auf DES
Ein Scan basierter Seitenangriff auf DES Seminar Codes & Kryptographie SS04 Tobias Witteler 29.06.2004 Struktur des Vortrags 1. Einführung / Motivation 2. Struktur von DES 3. Die Attacke Begriffsklärung:
MehrHochschule München, FK 03 FA SS 2012. Ingenieurinformatik
Hochschule München, FK 03 FA SS 2012 Ingenieurinformatik Zulassung geprüft vom Aufgabensteller: Teil 1/Aufgabe 1: 30 Minuten ohne Unterlagen, Teil 2/Aufgaben 2-4: 60 Minuten, beliebige eigene Unterlagen
MehrIngenieurinformatik Diplom-FA (Teil 2, C-Programmierung)
Hochschule München, FK 03 SS 2014 Ingenieurinformatik Diplom-FA (Teil 2, C-Programmierung) Zulassung geprüft: (Grundlagenteil) Die Prüfung ist nur dann gültig, wenn Sie die erforderliche Zulassungsvoraussetzung
MehrHUNDERBIRD FÜR VERSCHLÜSSELTEN EMAIL-AUSTAUSCH VORBEREITEN
THUNDERBIRD FÜR VERSCHLÜSSELTEN EMAIL-AUSTAUSCH VORBEREITEN Um Emails mit Thunderbird ver- und entschlüsseln zu können, muss zusätzlich die freie Softwa re OpenPGP (PGP Pretty Good Privacy) und ein Add-On
MehrGliederung. Tutorium zur Vorlesung. Gliederung. Gliederung. 1. Gliederung der Informatik. 1. Gliederung der Informatik. 1. Gliederung der Informatik
Informatik I WS 2012/13 Tutorium zur Vorlesung 1. Alexander Zietlow zietlow@informatik.uni-tuebingen.de Wilhelm-Schickard-Institut für Informatik Eberhard Karls Universität Tübingen 11.02.2013 1. 2. 1.
MehrDas beantragte persönliche Zertifikat wird standardmäßig in den Zertifikatspeicher des Browsers abgelegt, mit dem es beantragt wurde.
1. Zertifikatsinstallation und Anbindung an das Mailkonto Das beantragte persönliche Zertifikat wird standardmäßig in den Zertifikatspeicher des Browsers abgelegt, mit dem es beantragt wurde. Hinweis:
MehrKapitel 3: Etwas Informationstheorie
Stefan Lucks 3: Informationstheorie 28 orlesung Kryptographie (SS06) Kapitel 3: Etwas Informationstheorie Komplexitätstheoretische Sicherheit: Der schnellste Algorithmus, K zu knacken erfordert mindestens
MehrVorwort. Sichere E-Mail bietet. Kundenleitfaden Sichere E-Mail
Vorwort Wir alle leben in einem elektronischen Zeitalter. Der Austausch von Informationen erfolgt zunehmend über elektronische Medien wie das Versenden von E-Mails. Neben den großen Vorteilen, die uns
MehrGrundpraktikum zur IT-Sicherheit SS 2005. Bericht zum 1. Versuch
Grundpraktikum zur IT-Sicherheit SS 2005 Bericht zum 1. Versuch Benutzung der Software PGP /GnuPG zur Verschlüsselung und zum Signieren digitaler Daten durchgeführt von: Steffen Schulz, Lars Wolleschensky
MehrBeschreibung und Bedienungsanleitung. Inhaltsverzeichnis: Abbildungsverzeichnis: Werkzeug für verschlüsselte bpks. Dipl.-Ing.
www.egiz.gv.at E-Mail: post@egiz.gv.at Telefon: ++43 (316) 873 5514 Fax: ++43 (316) 873 5520 Inffeldgasse 16a / 8010 Graz / Austria Beschreibung und Bedienungsanleitung Werkzeug für verschlüsselte bpks
MehrInformation über die Secure E-Mail
Information über die Secure E-Mail Ihre Möglichkeiten Der Austausch von verschlüsselten E-Mails kann auf 3 Arten erfolgen 1. über das Webmail-Portal: Direkt empfangen und senden Sie vertrauliche Informationen
MehrBenutzer- und Datensicherheit. Ralf Abramowitsch Vector Informatik GmbH abramowitsch@lehre.dhbw-stuttgart.de
Benutzer- und Datensicherheit Ralf Abramowitsch Vector Informatik GmbH abramowitsch@lehre.dhbw-stuttgart.de Authentifizierung vs. Autorisierung IIdentity vs. IPrincipal Verschlüsseln und Entschlüsseln
MehrInhaltsverzeichnis. Seite
UEmail und GMX Inhaltsverzeichnis I. Email/ Allgemeines 1 II. Emailprogramm GMX 1 1. Zugangsdaten bei GMX 1 2. Anmelden bei GMX/ Zugang zu Ihrem Email-Postfach 1 3. Lesen neuer Emails 4 4. Neue Email schreiben
MehrSchwächen in der Kryptographie
Schwächen in der Kryptographie (Ernst Erich Schnoor) In der aktuellen Kryptographie bestehen offensichtlich systemimmanente Schwächen. Sie entspringen der Tatsache, dass die Eingaben des Klartextes nur
MehrDokument Information. Hilfe für. ArmorToken. Hilfe für ArmorToken Seite 1 von 8
Dokument Information Hilfe für ArmorToken Hilfe für ArmorToken Seite 1 von 8 Inhalt Inhalt 1 Hilfe für ArmorToken... 3 1.1.1 Willkommen bei ArmorToken... 3 1.1.2 ArmorToken installieren... 3 1.1.3 Verschlüsseln
MehrInhaltsverzeichnis. Grundbegriffe der C-Programmierung Für den HI-TECH C-Compiler
Inhaltsverzeichnis Grundbegriffe der C-Programmierung 1. Grundsätzliches... 2 1.1 Darstellung von Werten... 2 1.1.1 Dezimale Zahlendarstellung... 2 1.1.2 Binäre Zahlendarstellung... 3 1.1.3 Hexadezimale
MehrKryptographische Zufallszahlen. Schieberegister, Output-Feedback
Kryptographische Zufallszahlen Schieberegister, Output-Feedback Stromchiffren Bei Stromchiffren wird die Eingabe zeichenweise bzw. blockweise mit einer parallel dazu erzeugten Schlüsselfolge meist mit
MehrEinstieg in die Informatik mit Java
Vorlesung vom 18.4.07, Grundlagen Übersicht 1 Kommentare 2 Bezeichner für Klassen, Methoden, Variablen 3 White Space Zeichen 4 Wortsymbole 5 Interpunktionszeichen 6 Operatoren 7 import Anweisungen 8 Form
MehrSicherer Datenaustausch mit EurOwiG AG
Sicherer Datenaustausch mit EurOwiG AG Inhalt AxCrypt... 2 Verschlüsselung mit Passwort... 2 Verschlüsseln mit Schlüsseldatei... 2 Entschlüsselung mit Passwort... 4 Entschlüsseln mit Schlüsseldatei...
Mehrvorab noch ein paar allgemeine informationen zur de-mail verschlüsselung:
Kurzanleitung De-Mail Verschlüsselung so nutzen sie die verschlüsselung von de-mail in vier schritten Schritt 1: Browser-Erweiterung installieren Schritt 2: Schlüsselpaar erstellen Schritt 3: Schlüsselaustausch
MehrÜbungsblatt 2. Abgabe: Freitag, 7. November 2014, 18:00 Uhr
Informatik I: Einführung in die Programmierung Prof. Dr. Bernhard Nebel Dr. Christian Becker-Asano, Dr. Stefan Wölfl Wintersemester 2014/2015 Universität Freiburg Institut für Informatik Übungsblatt 2
MehrAK-Automatisierungs und Kommunikationstechnik TI Technische Informatik. NWT Netzwerktechnik
Netzwerk Programmierung Ein großer Teil von dem, was Netzwerkprogramme tun ist ganz simpler input und output: also bytes verschieben von einem System zu einem anderen. Bytes bleiben Bytes. Die Daten zu
MehrSocket-Programmierung (3)
Socket-Programmierung (3) E-Mails versenden Aufgabe: ein Programm schreiben, das E-Mails versenden kann Lernziele: - SMTP Kommandos - Authentifizierung - Passworteingabe (wxwidgets) - SMTP Ergebniscodes
MehrEinführung in die Computerlinguistik Einführung in Python (1)
Einführung in die Computerlinguistik Einführung in Python (1) Dozentin: Wiebke Petersen 10. Foliensatz Wiebke Petersen Einführung CL 1 Compiler Ein Compiler (auch Übersetzer oder Kompilierer genannt) ist
MehrSelbstdatenschutz. E-Mail-Inhalte schützen. Verschlüsselung mit GPGTools for Mac. Was ist GPGTools? Woher bekomme ich GPGTools?
Selbstdatenschutz E-Mail-Inhalte schützen Verschlüsselung mit GPGTools for Mac Was ist GPGTools? GPGTools (GNU Privacy Guard) ist ein Kryptografie-Werkzeugpaket zum Verschlüsseln und Signieren unter dem
MehrEinführung in Python Übung 1
Einführung in Python Übung 1 Rebecca Breu, Bastian Tweddell Oktober 2007 Login: XXXloginXXX Passwort: XXXpasswortXXX Bitte das Passwort ändern (passwd)! Datentypen I Aufgabe 1 (Erste Schritte, Zahlen)
MehrAsymmetrische Kryptologie am Beispiel RSA entdecken
Asymmetrische Kryptologie am Beispiel RSA entdecken Screenshots mit CrypTool 1.4.30 www.cryptool.com www.cryptool.de www.cryptool.pl Das CrypTool-Team, Januar 2010 Version 1.1 Übersicht Aufbau der Folien
MehrESP Tutorium. Studienassistent: Ewald Moitzi. E-Mail: prog-tutor-ewald@iicm.edu. Gruppe 9
ESP Tutorium Studienassistent: Ewald Moitzi E-Mail: prog-tutor-ewald@iicm.edu Gruppe 9 Plan für Heute Zip am pluto Datentypen? If, Schleifen Debugging Fehlerquellen Compiler-Fehlermeldungen Fehlersuche
Mehr12 == 12 true 12 == 21 false 4 === 7 true 4 === "vier" false 4 === 4.0 false 12!= 13 true 12!== 12 false 12!== 12.0 true. 1 < 3 true 3 < 1 false
Die if-anweisung if (Bedingung 1) { Code 1 else { Code 2 ; Anm.1: Das ; kann entfallen, da innerhalb { ein sog. Codeblock geschrieben wird. Anm.2: Es gibt noch andere Schreibweisen, aber wir wollen uns
MehrInformatik I. Informatik I. 6.1 Programme. 6.2 Programme schreiben. 6.3 Programme starten. 6.4 Programme entwickeln. 6.1 Programme.
Informatik I 05. November 2013 6. Python-, kommentieren, starten und entwickeln Informatik I 6. Python-, kommentieren, starten und entwickeln Bernhard Nebel Albert-Ludwigs-Universität Freiburg 05. November
MehrÜbungen zu. Grundlagen der Kryptologie SS 2008. Hochschule Konstanz. Dr.-Ing. Harald Vater. Giesecke & Devrient GmbH Prinzregentenstraße 159
Übungen zu Grundlagen der Kryptologie SS 2008 Hochschule Konstanz Dr.-Ing. Harald Vater Giesecke & Devrient GmbH Prinzregentenstraße 159 D-81677 München Tel.: +49 89 4119-1989 E-Mail: hvater@htwg-konstanz.de
MehrWir übertragen Daten mit Licht
Wir übertragen Daten mit Licht Durch das Internet werden täglich Unmengen von Daten von einem Ort an den anderen transportiert. Häufig geschieht dies über Glasfasern (Abb. 1). An dem einen Ende werden
MehrName: Matr.-Nr.: Seite: Geben Sie drei Klassifizierungsmerkmale aus dem Kurstext für den Begriff
Name: Matr.-Nr.: Seite: 1 Aufgabe 1 (20 Punkte) 1.1 Geben Sie drei Klassifizierungsmerkmale aus dem Kurstext für den Begriff Bedrohung an. (3 Punkte) 1.2 Was ist Steganographie? (1 Punkt) 1.3 Wozu benötigt
MehrBitsysteme als Dritte Dimension
1 Bitsysteme als Dritte Dimension (Ernst Erich Schnoor) 1 CypherMatrix Verfahren 2 2 Systematisierung der Bitfolgen 3 2.1 Bitsystem zur Basis 1 5 2.2 Bitsystem zur Basis 2 7 2.3 Bitsystem zur Basis 3 9
Mehr1. Asymmetrische Verschlüsselung einfach erklärt
1. Asymmetrische Verschlüsselung einfach erklärt Das Prinzip der asymmetrischen Verschlüsselung beruht im Wesentlichen darauf, dass sich jeder Kommunikationspartner jeweils ein Schlüsselpaar (bestehend
MehrÜbungen zu C++ Kapitel 1
Übungen zu C++ Kapitel 1 Aufgabe 1 Ergänze den Text. a) Die sechs logischen Einheiten eines Computers sind Eingabe-Einheit, Ausgabe-Einheit, RAM, ALU, CPU, Plattenspeicher. b) Die Programme, welche Hochsprachenprogramme
MehrEinfache kryptographische Verfahren
Einfache kryptographische Verfahren Prof. Dr. Hagen Knaf Studiengang Angewandte Mathematik 26. April 2015 c = a b + a b + + a b 1 11 1 12 2 1n c = a b + a b + + a b 2 21 1 22 2 2n c = a b + a b + + a b
MehrEine Liste der offiziellen Versionen für verschiedene Betriebssysteme findet sich unter http://www.7-zip.org /download.html.
Selbstdatenschutz E-Mail-Inhalte schützen Nutzung von 7-Zip zur Verschlüsselung Bei dem Programm 7-Zip (http://www.7-zip.org ) handelt es sich um ein frei nutzbares Komprimierungsprogramm für Windows Betriebssysteme
MehrWiederholung und Vertiefung. Programmieren in C. Pointer und so... thoto. /dev/tal e.v. 6. April 2013 (Version vom 11. April 2013) Programmieren in C
Pointer und so... 6. April 2013 (Version vom 11. April 2013) Agenda für Heute 1 Wiederholung und Vertiefung Wiederholung 2 Was sind? Felder und Vektoren? Zeichenketten Wiederholung Wiederholung Funktion
MehrS Stadtsparkasse. Sichere E-Mail. Remscheid. Produktinformation
Sichere E-Mail Produktinformation Produktinformation Sichere E-Mail 2 Allgemeines Mit E-Mail nutzen Sie eines der am häufigsten verwendeten technischen Kommunikationsmittel. Beim täglichen Gebrauch der
Mehr5 Codierung nach RSA (Lösung)
Kapitel 5 Codierung nach RSA (Lösung) Seite 1/17 5 Codierung nach RSA (Lösung) 5.1 Einführung Die drei Mathematiker Rivest, Shamir und Adleman entwickelten 1977 das nach ihnen benannte RSA-Verfahren. Es
MehrLinux Tutorium. 12. Shellprogrammierung. Version vom 02.07.2008 13:38:56
Linux Tutorium 12. Shellprogrammierung Version vom 02.07.2008 13:38:56 im Grunde ist ein Shell-Skript nichts anderes als eine Textdatei, welche Befehlsfolgen enthält Shell-Skripte werden im Wesentlichen
MehrMEMO Paradigmenwechsel in der Kryptographie
MEMO Paradigmenwechsel in der Kryptographie Ernst Erich Schnoor Kryptographie ist schreiben und lesen von geheimen Botschaften mit arteigenen Methoden (Verschlüsselung). Seit sich die Computer der Kryptographie
MehrKURZANLEITUNG DUPLICITY MIT CLOUD OBJECT STORAGE
KURZANLEITUNG DUPLICITY MIT CLOUD OBJECT STORAGE Version 1.12 01.07.2014 SEITE _ 2 INHALTSVERZEICHNIS 1. Einleitung...Seite 03 2. Einrichtung des Systems...Seite 04 3. Erzeugen eines Backup-Skripts...Seite
MehrBedienungsanleitung für den SecureCourier
Bedienungsanleitung für den SecureCourier Wo kann ich den SecureCourier nach der Installation auf meinem Computer finden? Den SecureCourier finden Sie dort, wo Sie mit Dateien umgehen und arbeiten. Bei
MehrFAQs zur Nutzung des E-Mail Zertifikats zur sicheren E-Mail-Kommunikation. Das E-Mail Zertifikat von S-TRUST
FAQs zur Nutzung des E-Mail Zertifikats zur sicheren E-Mail-Kommunikation. Das E-Mail Zertifikat von S-TRUST S - t r u s t Z e r t i f i z i e r u n g s d i e n s t l e i s t u n g e n d e s D e u t s
MehrDie Programmiersprache C99: Zusammenfassung
Die Programmiersprache C99: Zusammenfassung Jörn Loviscach Versionsstand: 7. Dezember 2010, 19:30 Die nummerierten Felder sind absichtlich leer, zum Ausfüllen in der Vorlesung. Videos dazu: http://www.youtube.com/joernloviscach
MehrSchritt 1. Schritt 1. Schritt 3. - Analysieren des Problems und Spezifizierung einer Lösung.
I. Programmierung ================================================================== Programmierung ist die Planung einer Abfolge von Schritten (Instruktionen), nach denen ein Computer handeln soll. Schritt
MehrPython Programmieren. Variablen, Ausdrücke und Anweisungen
Python Programmieren Funktionen Module und Namensräume Datentypen in Python Was noch zu sagen bleibt... richard rascher-friesenhausen Programmierung SS 12 Daten: Wert und Typ Variablen Variablennamen und
MehrKryptologie. Verschlüsselungstechniken von Cäsar bis heute. Arnulf May
Kryptologie Verschlüsselungstechniken von Cäsar bis heute Inhalt Was ist Kryptologie Caesar Verschlüsselung Entschlüsselungsverfahren Die Chiffrierscheibe Bestimmung der Sprache Vigenére Verschlüsselung
MehrImport des persönlichen Zertifikats in Outlook 2003
Import des persönlichen Zertifikats in Outlook 2003 1. Installation des persönlichen Zertifikats 1.1 Voraussetzungen Damit Sie das persönliche Zertifikat auf Ihren PC installieren können, benötigen Sie:
Mehr