Python : Verschlüsselungsalgorithmus

[DarkMo]

AW: Python : Verschlüsselungsalgorithmus

wegen dem "passwort drauf addieren":
du hast zum bsp den klartext "hallo welt" und das pw "abc". dann addierst du folgendermaßen:

[FONT=Courier New]  hallo welt
+ abcabcabca[/FONT]

dann haste für das h + a zum bsp mit ascii-werten 104+97=201. oooder du zählst beginend von a an mit 1 und machst keinen unterschied zw groß- und kleinbuchstaben (lowercase zum bsp). dann würde man bei den ascii werten irgendwo den "startwert" (a hat ascii 97, also wäre der startwert 96 zum bsp) abziehen: 104+97-96=105 -> als zeichen i. das käme der eigentlichen auffassung dieser verschlüsselung sehr viel näher, als die asciies pur zu addieren.

 

[Rho]

AW: Python : Verschlüsselungsalgorithmus

Was genau ist ein ModuloOperator?

Gibt dir den Rest einer Division.

Beispiele:

1 % 2 = 1
2 % 2 = 0
3 % 2 = 1
7 % 4 = 3

 

[LastChaosTyp]

Ah, danke für die Antworten Der ModuloOperator war mir unter anderem Namen bekannt

 

[LastChaosTyp]

AW: Python : Verschlüsselungsalgorithmus

Nochmal ne Frage zu deinen Quelltext. Dort ist ein Fehler:

def vernam_cipher(messageData, password):
keyData = gen_key(password, len(message))
cipherData = xor_bytes(messageData, keyData)
return cipherData

In Zeile 2 ist ja len(message), aber message wird garnicht mit in die Methode gegeben. Ist das die Variable als Globale Variable aus dem Hauptprogramm? Oder muss message = messageData heißen?

 

[LastChaosTyp]

AW: Python : Verschlüsselungsalgorithmus

Ok, dieses Problem hat sich gelöst. Hatte vergessen, bei dem einlesen der .txt den Inhalt an den Aufrufer zurückzugeben Halbe Stunde für so nen behinderten Fehler...

Bis jetzt scheint es, als gäbe es keine neuen Bugs. Damit ihr auch was von meinem kleinen Projekt habt, hier mein bisheriger Code mit allen Verbesserungen

# ------------------------------------------ Bibliotheken ------------------------------------------

from tkinter import *
import os

# ------------------------------------------ Klassen -----------------------------------------------

class FensterMitCode(object):
    def __init__(self):
        self.hauptfenster = Tk(className = "einfaches Crypting")
        self.message = ""

        # Frames:
        self.frame1 = Frame(self.hauptfenster)
        self.frame2 = Frame(self.hauptfenster)
        self.frame3 = Frame(self.hauptfenster)

        # Label:
        self.labelUeberschrift = Label(self.hauptfenster, text = "Ver-/Entschlüsselung", fg = "black", font = "Arial 30 underline")
        self.labelPassword = Label(self.frame1, text = "Passwort", fg ="black", font = "Arial 15 bold")
        self.labelPath = Label(self.frame2, text = "Dateipfad", fg = "black", font = "Arial 15 bold")
        self.labelAusgabe = Label(self.hauptfenster, text = "", fg = "black", font = "Arial 15 bold")
        self.labelPlatzhalter1 = Label(self.hauptfenster, text = "", fg = "black", font = "Arial 15 bold")
        self.labelPlatzhalter2 = Label(self.hauptfenster, text = "", fg = "black", font = "Arial 15 bold")

        # Button:
        self.buttonstring_to_binary = Button(self.frame3, text = "String zu Binär", font = "Arial 15 bold", width = "20", command = self.string_to_binary)
        self.buttonbinary_to_string = Button(self.frame3, text = "Binär zu String", font = "Arial 15 bold", width = "20", command = self.binary_to_string)

        # Eingabe:
        self.entryPassword = Entry(self.frame1, width = "50")
        self.entryPath = Entry(self.frame2, width = "50")

        # Implementierung:
        self.labelUeberschrift.pack()
        self.labelPlatzhalter1.pack()

        self.labelPassword.pack(side = "left", padx = "5")
        self.entryPassword.pack(side = "right", padx = "5")
        self.frame1.pack(fill = X)

        self.labelPath.pack(side = "left", padx = "5")
        self.entryPath.pack(side = "right", padx = "5")
        self.frame2.pack(fill = X)

        self.labelPlatzhalter2.pack()

        self.buttonstring_to_binary.pack(side = "left", padx = "5")
        self.buttonbinary_to_string.pack(side = "right", padx = "5")
        self.frame3.pack(fill = X)

        self.labelAusgabe.pack()

        # Fenster wird erstellt:
        self.hauptfenster.mainloop()

    def vernam_cipher(self, messageData, password):
        keyData = self.gen_key(password, len(self.message))
        cipherData = self.xor_bytes(messageData, keyData)
        return cipherData

    def gen_key(self, password, length):
        key = password
        while len(key) < length:
            key += password
        keyData = key[:length].encode("utf-8")
        return keyData

    def xor_bytes(self, firstData, secondData):
        output = bytearray()
        for (d1, d2) in zip(firstData, secondData):
            result = d1 ^ d2
            output.append(result)
        return output
    
    def save_data(self, data, path):
        f = open(path, "w+b")
        f.write(data)
        f.close()

    def save_string(self, string, path):
        f = open(path, "wt")
        f.write(string)
        f.close()
        
    def read_data(self, path):
        f = open(path, "r+b", buffering = 0)
        data = f.readall()
        f.close()
        return data

    def read_string(self, path):
        text = ""
        f = open(path, "rt")
        line = f.readline()
        while line != "":
            text += line
            line = f.readline()
        f.close()
        return text
        
    def string_to_binary(self):
        path = self.entryPath.get()
        if os.path.isfile(path):
            newPath = path[:-3] + "bin"
            self.message = str(self.read_string(path))
            password = self.entryPassword.get()
            
            messageData = self.message.encode("utf-8")      
            cipherData = self.vernam_cipher(messageData, password)

            self.save_data(cipherData, newPath)
            self.labelAusgabe["text"] = "Die Datei wurde erfolgreich codiert und unter " + str(newPath) + " gespeichert!"
        else:
            self.labelAusgabe["text"] = "Die Datei konnte nicht gefunden werden. Bitte überprüfen sie den Pfad."
        
    def binary_to_string(self):
        path = self.entryPath.get()
        if os.path.isfile(path):
            newPath = path[:-3] + "txt"
            password = self.entryPassword.get()
            
            cipherData = self.read_data(path)
            messageData = self.vernam_cipher(cipherData, password)
            self.message = messageData.decode("utf-8")

            self.save_string(self.message, newPath)
            self.labelAusgabe["text"] = "Die Datei wurde erfolgreich codiert und unter " + str(newPath) + " gespeichert!"
        else:
            self.labelAusgabe["text"] = "Die Datei konnte nicht gefunden werden. Bitte überprüfen sie den Pfad."
    
# ------------------------------------------ Programm ----------------------------------------------

hauptfenster = FensterMitCode()

 

[Rho]

AW: Python : Verschlüsselungsalgorithmus

Nochmal ne Frage zu deinen Quelltext. Dort ist ein Fehler: [...] muss message = messageData heißen?

Ja, ist ein Fehler. Habe beim Ändern übersehen, das ebenfalls anzupassen. Muss natürlich messageData heißen.

 

[LastChaosTyp]

Bei mir hat das mit message geklappt. Ich hab message einfach als Attribut hinzugefügt, um globale Variablen zu vermeiden. Werde es morgen nochmal mit messageData probieren.

 

[Icephoen1x]

AW: Python : Verschlüsselungsalgorithmus

Modulo geht natürlich auch, ist aber für nen anfänger schwerer.
Wollte das so halten dass es mit den vorhandenen kentnissen geht.

 

[fisch@namenssuche]

AW: Python : Verschlüsselungsalgorithmus

PS: es gibt keine sichere Verschlüsselung ,vor allen,wenn man den Algorismus vorher postet

Das ist zwar zwei Seiten alt, aber:

Doch.
Die Sicherheit einer Verschlüsselung muss (!!!) auf der Geheimhaltung des Passwortes und nicht auf der Geheimhaltung des Algorithmus beruhen.

Es gibt einige sehr sichere Algorithmen. Typischerweise werden jedoch beim Implementieren des Algorithmus in einer konkreten Sprache Fehler gemacht oder falsche (= erratbare) Passwörter verwendet.

Als Folge behaupte ich, dass es gut und wichtig ist, sich mit irgendeiner (einfachen) Verschlüsselung zu beschäftigen - das ist in einem modularen Programm nur ein Teil,
der später ohne Seiteneffekte ausgetauschbar sein sollte, wenn Geheimhaltung der Daten eine besondere Rolle spielt.