Verschlüsselungsprogramm

[__blackjack__]

@Fire Spike: Das *tatsächlich* Byte für Byte zu machen ist ziemlich bekloppt.

[Fire Spike]

was ist denn nicht "bekloppt"?

[Sirius3]

Als kleine Hausaufgabe, schreibe man alle Dir bekannten Filemodi heraus und was sie bedeuten.

Typische Blockgrößen sind wohl einige tausend Bytes.
Es fehlt noch ›finalize‹.

[Fire Spike]

a = anhängen, wenn noch nicht vorhanden erstellen
w = schreiben, wenn noch nicht vorhanden erstellen
w+ = schreiben und lesen, wenn noch nicht vorhanden erstellen
wb = bytes schreiben, wenn noch nicht vorhanden erstellen
wb+ = bytes schreiben und lesen, wenn noch nicht vorhanden erstellen
r = lesen
r+ = lesen und schreiben
rb = bytes lesen
rb+ = bytes lesen und schreiben

______________________________________________________________________
für was braucht es finalize?
eine blockgrösse währe 4096 bytes

[Sirius3]

Und was wäre jetzt ein Filemode für Dateien die Du lesen willst, und welchen benutzt man für Dateien wo man hineinschreiben will?

Für was braucht man wohl finalize: schlags im Englischwörterbuch nach.

[Fire Spike]

also hinter dem letzten block.

Code: Alles auswählen

def verschlüsseln(passwort, dateipfad):
    with open(dateipfad, "rb") as datei:
        with open(dateipfad + ".verschluesselt", "ab") as datei_verschlüsselt:
            schlüssel, salt = generiere_Schlüssel(passwort)
            f = Fernet.FernetStream(schlüssel)
            encryptor = f.encryptor()
            datei_verschlüsselt.write(salt)
            anzahl_blöcke, rest = divmod(os.path.getsize(dateipfad), __BLOCK_GRÖSSE)
            for i in range(anzahl_blöcke):
                block = datei.read(__BLOCK_GRÖSSE)
                datei_verschlüsselt.write(encryptor.update(block))
                
            datei_verschlüsselt.write(encryptor.update(datei.read(rest)) + encryptor.finalize())

wenn ich das jetzt entschlüsseln will, wie weiss das programm welcher block oder rest was ist?

[__blackjack__]

@Fire Spike: Das ist unnötig kompliziert mit der Anzahl der Blöcke und dem Rest. Lies einfach solange bis `read()` nichts mehr liefert. Dazu muss man nicht wissen wie gross die Datei ist.

[Fire Spike]

JUHU das währe mal geschafft. soll ich noch den hash vom key mit in die datei speichern? weil jetzt entschlüssel er einfach falsch. mit hash könnte ich den key überprüfen.

[Sirius3]

Bei Fernet werden Daten nicht nur verschlüsselt, sondern auch signiert. Bei falschem Passwort geht zweiteres schief. Hättest Du das tatsächlich mal ausprobiert, wäre es Dir aufgefallen.

Code: Alles auswählen

def verschlüsseln(passwort, dateipfad):
    schlüssel, salt = generiere_Schlüssel(passwort)
    fernet = Fernet.FernetStream(schlüssel)
    encryptor = fernet.encryptor()
    with open(dateipfad, "rb") as datei:
        with open(dateipfad + ".verschluesselt", "wb") as datei_verschlüsselt:
            datei_verschlüsselt.write(salt)
            while True:
                block = datei.read(BLOCK_GRÖSSE)
                if not block:
                    break
                datei_verschlüsselt.write(encryptor.update(block))
            datei_verschlüsselt.write(encryptor.finalize())

[Fire Spike]

danke für dein beispiel. entschlüsseln habe ich auch angepasst. könntest du mir noch ein minimales beispiel posten wie ich tk mit threads verwenden kann? OHNE KLASSE WENN MÖGLICH!

[Sirius3]

Mt ein bißchen Suchen findest Du hier genug Beispiele.

[Fire Spike]

ich habe gesucht aber nichts was mir wirklich geholfen hätte. die meisten verwenden klassen.

[__deets__]

Klassen sind halt fuer sowas die richtige Wahl. Und wenn es nur die *meisten* sind, dann gibt's doch auch welche ohne?

[Fire Spike]

keine wirklich schlauen. Kann ich das auch mit prozessen machen?(ohne klassen)

[__deets__]

Ich verstehe die Frage nicht. Was sollen Prozesse damit zu tun haben? Und was genau ist dein Problem mit Klassen? Wenn man GUI-Programmierung betreibt, muss man die nunmal benutzen. Mach dein Programm einfach ohne GUI, dann brauchst du auch keine Klassen.

[Fire Spike]

meine frage ist: kann ich anstatt threads auch prozesse nehmen.
Ich werde das jetzt in eine klasse umschreiben da es anders nicht geht.

[__deets__]

Was genau erhoffst du dir von einem Prozess? Auch dessen zustand musst du irgendwie in deine Programm bekommen. Das ist nicht einfacher als es in einem thread zu machen.

[Fire Spike]

ich würde das mit einer queue machen. Ich finde prozesse einfacher zu programmieren. Die Wahrscheinlichkeit ist grösser das der prozess einen eigenen kern bekommt

[__deets__]

Dann mach’s mit nem Prozess. An der Notwendigkeit die GUI mit Klassen zu schreiben ändert das nichts. Weswegen ich die Frage verwirrend fand.

[Fire Spike]

Sehr dumme Frage, aber könnte mir jemand meinen aktuellen Code in eine Klasse schreiben?
Wenn ich diese Klasse hätte könnte ich nämlich weiter machen mit den Prozessen.
Ich hatte schon ein Paar mal versucht, aber irgendwie macht es nie sinn.
Ich hatte noch nie eine GUI mit Klassen geschrieben.
Ich währe euch sehr dankbar.

Code: Alles auswählen

import base64
import os
import tkinter as tk
import Fernet
import pygame.mixer
from tkinter import ttk
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC

BLOCK_GRÖSSE = 4096

def generiere_Schlüssel(passwort, salt=False):
    passwort = passwort.encode()
    return_tuple = False
    if not salt:
        salt = os.urandom(16)
        return_tuple = True
        
    kdf = PBKDF2HMAC(algorithm=hashes.SHA256(),
                     length=32,
                     salt=salt,
                     iterations=1000000,
                     backend=default_backend()
                     )
    
    schlüssel = base64.urlsafe_b64encode(kdf.derive(passwort))
    if return_tuple:
        return schlüssel, salt
    else:
        return schlüssel

def verschlüsseln(passwort, dateipfad):
    schlüssel, salt = generiere_Schlüssel(passwort)
    fernet = Fernet.FernetStream(schlüssel)
    encryptor = fernet.encryptor()
    with open(dateipfad, "rb") as datei:
        with open(dateipfad + ".verschluesselt", "wb") as datei_verschlüsselt:
            datei_verschlüsselt.write(salt)
            while True:
                block = datei.read(BLOCK_GRÖSSE)
                if not block:
                    break
                datei_verschlüsselt.write(encryptor.update(block))
            datei_verschlüsselt.write(encryptor.finalize())
    
    pygame.mixer.music.play()
def entschlüsseln(passwort, dateipfad):
    dateiname, _ = os.path.splitext(os.path.basename(dateipfad))
    with open(dateipfad, "rb") as datei:
        with open(os.path.join(os.path.dirname(dateipfad), dateiname + ".entschluesselt"), "wb") as datei_entschlüsselt:                
            salt = datei.read(16)
            schlüssel = generiere_Schlüssel(passwort, salt)
            f = Fernet.FernetStream(schlüssel)
            decryptor = f.decryptor()
            while True:
                block = datei.read(BLOCK_GRÖSSE)
                if not block:
                    break
                datei_entschlüsselt.write(decryptor.update(block))
            datei_entschlüsselt.write(decryptor.finalize())
    pygame.mixer.music.play()
            

def GUI():
    root = tk.Tk()
    root.title("Dateien ent/verschlüsseln")
    root.config(bg="white")
    
    style = ttk.Style()
    settings = {"TNotebook.Tab": {"configure": {"padding": [5, 1],
                                                "background": "white"
                                               },
                                  "map": {"background": [("selected", "white"), 
                                                         ("active", "#bdbdbd")],

                                         }
                                  }
               }  
    style.theme_create("alles_weiss", parent="alt", settings=settings)
    style.theme_use("alles_weiss")
    style.configure("TNotebook", background="white")
    style.configure("TFrame", background="white")
    
    root_tab = ttk.Notebook(root)
    tab1 = ttk.Frame(root_tab) 
    tab2 = ttk.Frame(root_tab)
    
    root_tab.add (tab1, text="Entschlüsseln")
    root_tab.add (tab2, text="Verschlüsseln")
    root_tab.pack(expand=1, fill='both')
       
    info1 = tk.Label(tab1, text="Wichtig: Die Datei wird mit einer zusätzlichen\n Dateiendung gespeichert. Nicht überschrieben!\n", bg="white")
    dateipfad_text1 = tk.Label(tab1, text="Bitte Dateipfad angeben", bg="white")
    dateipfad_eingabe1 = tk.Entry(tab1, bg="white")
    passwort_text1 = tk.Label(tab1, text="Bitte Passwort eingeben", bg="white")
    passwort_eingabe1 = tk.Entry(tab1, bg="white")
    entschlüsseln_button = tk.Button(tab1, text="entschlüsseln", command=lambda: entschlüsseln(passwort_eingabe1.get(), dateipfad_eingabe1.get()), bg="white")
    verschlüsseln_button = tk.Button(tab2, text="verschlüsseln", command=lambda: verschlüsseln(passwort_eingabe2.get(), dateipfad_eingabe2.get()), bg="white")
    info2 = tk.Label(tab2, text="Wichtig: Die Datei wird mit einer zusätzlichen\n Dateiendung gespeichert. Nicht überschrieben!\n", bg="white")
    dateipfad_text2 = tk.Label(tab2, text="Bitte Dateipfad angeben", bg="white")
    dateipfad_eingabe2 = tk.Entry(tab2, bg="white")
    passwort_text2 = tk.Label(tab2, text="Bitte Passwort eingeben", bg="white")
    passwort_eingabe2 = tk.Entry(tab2, bg="white")

    info1.grid(row=0, columnspan=1, sticky=tk.W)
    dateipfad_text1.grid(row=1, column=0, sticky=tk.W)
    dateipfad_eingabe1.grid(row=1, column=1, sticky=tk.W)
    passwort_text1.grid(row=2, column=0, sticky=tk.W)
    passwort_eingabe1.grid(row=2, column=1, sticky=tk.W)
    info2.grid(row=0, columnspan=1, sticky=tk.W)
    dateipfad_text2.grid(row=1, column=0, sticky=tk.W)
    dateipfad_eingabe2.grid(row=1, column=1, sticky=tk.W)
    passwort_text2.grid(row=2, column=0, sticky=tk.W)
    passwort_eingabe2.grid(row=2, column=1, sticky=tk.W)
    entschlüsseln_button.grid(row=4, columnspan=1, sticky=tk.W)
    verschlüsseln_button.grid(row=4, columnspan=1, sticky=tk.W)
    root.mainloop()

if __name__ == "__main__":
    pygame.mixer.init()
    pygame.mixer.music.load("audio.mp3")
    GUI()