# Python : Verschlüsselungsalgorithmus



## LastChaosTyp (8. Juni 2014)

*Python : Verschlüsselungsalgorithmus*

Hallo liebe PCGHler,

In der Schule lerne ich grade Python. Nun ist mir die Idee gekommen, mal ein eigenes Verschlüsselungsprogramm zu bauen. Das ganze soll eine grafische Oberfläche haben. Man gibt dem Programm einen Dateipfad zu einer beliebigen .txt Datei. Nun drückt der Benutzer auf den entsprechenden Button für zB. "Verschlüsseln" und der Inhalt der Datei wird mit einem Passwort! verschlüsselt. Wenn man eine Datei entschlüsseln will, muss man nur das Passwort und den Dateipfad angeben und die Datei wird wieder in den Ursprungszusatnd versetzt. Ich kann soweit mit Python umgehen, dass ich die Dateien lesen/schreiben kann und ein GUI bekomme ich auch ohne Weiteres hin. Fehlt mir "nur noch" der Verschlüsselungsalgorithmus mit einer Passwort-Funktion!. Ich habe hier einen VisualBasic-Code gefunden, der genau das kann. Kann das einer von euch in Python übersetzen?

```
Public Class Form1

    Public Function VernamCode(ByVal sOriginal As String, ByVal sPassword As String) As String
        Dim i As Long
        Dim aktpos As Long
        Dim bAkt As Byte
        Dim bCode As Byte

        VernamCode = ""

        aktpos = 1
        For i = Len(sPassword) + 1 To Len(sOriginal)
            sPassword = sPassword & Mid(sPassword, aktpos, 1)
            aktpos += 1
            If aktpos > Len(sPassword) Then aktpos = 1
        Next i
        For i = 1 To Len(sOriginal)
            bAkt = Asc(Mid(sOriginal, i, 1))
            bCode = Asc(Mid(sPassword, i, 1))
            VernamCode = VernamCode & Chr(bAkt Xor bCode)
        Next i
    End Function

    Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
        Dim sOriginal As String
        Dim sPassword As String
        Dim sCode As String
        sOriginal = TextBox1.Text
        sPassword = TextBox4.Text
        sCode = VernamCode(sOriginal, sPassword)
        TextBox3.Text = sCode
    End Sub

    Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click
        Dim sOriginal As String
        Dim sPassword As String
        Dim sCode As String
        sCode = TextBox1.Text
        sPassword = TextBox4.Text
        sOriginal = VernamCode(sCode, sPassword)
        TextBox3.Text = sOriginal
    End Sub
End Class
```
Das ganze basiert auf der VernamCodierung. Ich bedanke mich schonmal für alle hilfreichen Antworten 

Liebe Grüße
Henri K.


----------



## DarkMo (8. Juni 2014)

*AW: Python : Verschlüsselungsalgorithmus*

hehehe, "nur" noch. mit sowas füllen professoren ganze vorlesungen  und auch die sind dann nicht vollständig. kommt halt auch drauf an, in welcher art und weise du verschlüsseln magst. geht ganz simpel von ner cesar? verschlüsselung wo man einfach jeden buchstaben um x stellen verschiebt (im alphabet) bis hin zu sonstwas für kompliziertem zeugs.


----------



## LastChaosTyp (8. Juni 2014)

*AW: Python : Verschlüsselungsalgorithmus*

Die CesarVerschlüsselung ist mir zu einfach. Es soll schon eine mit Passwort sein. Ich habe ja bereits nen VB Code oben eingefügt, jetzt müsste das "nur noch" einer übersetzen  Habe leider keinen Algorithmus mit Passwort auf Google für Python gefunden  Die Sprache ist ja auch eigentlich nicht für sowas gemacht, aber das ist halt die, in der ich mich halbwegs gut auskenne 

Edit: Bei dem Code oben verstehe ich nur die Verschlüsselung nicht, den Aufruf durch die Button schon. Die Variablen werden da ja auch deklariert, aber ich weiß halt nicht genau, wie man die For-Schleife übersetzen kann


----------



## Blubbertzz (8. Juni 2014)

*AW: Python : Verschlüsselungsalgorithmus*

Hallo,
wir haben in der Schule in Info mal sowas ähnliches gemacht. Da musst du dann allerdings pro Buchstaben den entsprechenden Anderen (sprich: zu welchem Buchstaben verschlüsselt werden soll) eingeben und dir dann am besten die Reihenfolge merken oder aufschreiben. Das Programm was wir hatten konnte auch Dateien in die GUI laden und anschließend wieder abspeichern.
Wir haben das mit Delphi gemacht, das wäre doch dann Phyton oder liege ich falsch?

Hier ist der komplette Code:


```
unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  StdCtrls, ExtCtrls, Spin;

type
  tKodierung = array ['A'..'Z'] of char;

type
  TForm1 = class(TForm)
    PTitel: TPanel;
    GBQuelltext: TGroupBox;
    GBChiffre: TGroupBox;
    MQuelltext: TMemo;
    BLadenQ: TButton;
    BSpeichernQ: TButton;
    OpenDialog1: TOpenDialog;
    SaveDialog1: TSaveDialog;
    GBGeheimtext: TGroupBox;
    MGeheimtext: TMemo;
    BLadenG: TButton;
    BSpeichernG: TButton;
    OpenDialog2: TOpenDialog;
    SaveDialog2: TSaveDialog;
    BVorbereiten: TButton;
    BLoeschen1: TButton;
    BLoeschen2: TButton;
    BVerschluesseln: TButton;
    BEntschluesseln: TButton;
    EQuellalphabet: TEdit;
    EGeheimalphabet: TEdit;
    BUebernehmen: TButton;
    procedure BVerschluesselnClick(Sender: TObject);
    procedure BEntschluesselnClick(Sender: TObject);
    procedure BLadenQClick(Sender: TObject);
    procedure BSpeichernQClick(Sender: TObject);
    procedure BLadenGClick(Sender: TObject);
    procedure BSpeichernGClick(Sender: TObject);
    procedure BVorbereitenClick(Sender: TObject);
    procedure BLoeschen1Click(Sender: TObject);
    procedure BLoeschen2Click(Sender: TObject);
    procedure BUebernehmenClick(Sender: TObject);
    procedure FormCreate(Sender: TObject);
  private
    { Private-Deklarationen }
    quelltext: string;
    geheimtext: string;
    kodierung: tKodierung;
    procedure verschluesseln;
    procedure entschluesseln;
    procedure vorbereiten;
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.DFM}

procedure TForm1.verschluesseln;
  var
    i: integer;
    quelle, geheim: char;
begin
geheimtext := '';
for i := 1 to length(quelltext) do
  begin
  quelle := quelltext[i];
  geheim := kodierung[quelle];
  geheimtext := geheimtext + geheim;
  end;
end;

procedure TForm1.entschluesseln;
  var
    i: integer;
    quelle, geheim: char;
    c: char;
begin
quelltext := '';
for i := 1 to length(geheimtext) do
  begin
  geheim := geheimtext[i];
  for c := 'A' to 'Z' do
    if kodierung[c] = geheim then
      quelle := c;
  quelltext := quelltext + quelle;
  end;
end;

procedure TForm1.vorbereiten;
  var c: char;
      i: integer;
      hilfstext: string;
begin
Hilfstext := '';
for i := 1 to length(quelltext) do
  begin
  c := quelltext[i];
  case c of
    'A'..'Z': hilfstext := hilfstext + c;
    'a'..'z': hilfstext := hilfstext + chr(ord(c)-32);
    'ß': hilfstext := hilfstext + 'SS';
    'ä': hilfstext := hilfstext + 'AE';
    'ö': hilfstext := hilfstext + 'OE';
    'ü': hilfstext := hilfstext + 'UE';
    'Ä': hilfstext := hilfstext + 'AE';
    'Ö': hilfstext := hilfstext + 'OE';
    'Ü': hilfstext := hilfstext + 'UE';
  end;
  end;
quelltext := hilfstext;
end;

procedure TForm1.BVerschluesselnClick(Sender: TObject);
begin
// Eingabe
quelltext := MQuelltext.Text;
// Verarbeitung
verschluesseln;
// Ausgabe
MGeheimtext.Text := geheimtext;
end;

procedure TForm1.BEntschluesselnClick(Sender: TObject);
begin
// Eingabe
geheimtext := MGeheimtext.Text;
// Verarbeitung
entschluesseln;
// Ausgabe
MQuelltext.Text := quelltext;
end;

procedure TForm1.BVorbereitenClick(Sender: TObject);
begin
// Eingabe
quelltext := MQuelltext.Text;
// Verarbeitung
vorbereiten;
// Ausgabe
MQuelltext.Text := quelltext;
end;

procedure TForm1.BLadenQClick(Sender: TObject);
begin
if OpenDialog1.Execute then
  MQuelltext.Lines.LoadFromFile(OpenDialog1.Filename);
end;

procedure TForm1.BSpeichernQClick(Sender: TObject);
begin
if SaveDialog1.Execute then
  MQuelltext.Lines.SaveToFile(SaveDialog1.Filename);
end;

procedure TForm1.BLadenGClick(Sender: TObject);
begin
if OpenDialog2.Execute then
  MGeheimtext.Lines.LoadFromFile(OpenDialog2.Filename);
end;

procedure TForm1.BSpeichernGClick(Sender: TObject);
begin
if SaveDialog2.Execute then
  MGeheimtext.Lines.SaveToFile(SaveDialog2.Filename);
end;

procedure TForm1.BLoeschen1Click(Sender: TObject);
begin
MQuelltext.Lines.Clear;
end;

procedure TForm1.BLoeschen2Click(Sender: TObject);
begin
MGeheimtext.Lines.Clear;
end;

procedure TForm1.BUebernehmenClick(Sender: TObject);
  var
    i: integer;
begin
// Aktualisierung des Datenmodells
for i := 1 to 26 do
  kodierung[chr(i+64)] := EGeheimalphabet.Text[i];

end;

procedure TForm1.FormCreate(Sender: TObject);
  var
    c: char;
    i:integer;
begin
// Initialisierung des Datenmodells
for i := 1 to 26 do
  kodierung[chr(i+64)] := EGeheimalphabet.Text[i];
end;

end.
```

@edit: Danke für den Hinweis, LastChaosTyp


----------



## LastChaosTyp (8. Juni 2014)

*AW: Python : Verschlüsselungsalgorithmus*

Danke für deinen Tipp  Leider sind Python und Delphi nicht identisch, haben aber die selben Absichten 
Tipp: Packe um deinen Code mal bitte [CODE...] und am Ende [/CODE...], dann wird der Beitrag übersichtlicher. Lass dann ... jeweils weg


----------



## hodenbussard (8. Juni 2014)

*AW: Python : Verschlüsselungsalgorithmus*

Python Tools for Visual Studio - Home
schaut da mal rein

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


----------



## LastChaosTyp (8. Juni 2014)

*AW: Python : Verschlüsselungsalgorithmus*

Danke für das Video, danke für das Einfügen von [CODE...] 
Mittlerweile habe ich mich mal an so ne CesarLösung gemacht und werde dann hier mal meinen Code für Verbesserungsvorschläge zeigen


----------



## Rho (8. Juni 2014)

*AW: Python : Verschlüsselungsalgorithmus*



LastChaosTyp schrieb:


> Ich habe hier einen VisualBasic-Code gefunden, der genau das kann. Kann das einer von euch in Python übersetzen?


Erst mal solltest du dich fragen, ob du den Code wirklich verwenden willst. Mal abgesehen davon, dass der dadurch erzeugte Schlüssel alles andere als sicher ist, wird *Chr(bAkt Xor bCode)* in den meisten Fällen nicht wie gewollt funktionieren, da dabei kein darstellbares Zeichen erzeugt wird. Das _Chr()_ kann man sich also schenken.

Für den Fall, dass dich das nicht weiter interessiert:


```
def vernam_cipher(message, password):
    key = gen_key(password, len(message))
    ciphertext = xor_strings(message, key)
    return ciphertext

def gen_key(password, length):
    key = password
    while len(key) < length:
        key += password
    return key[:length]

def xor_strings(firstString, secondString):
    output = []
    for (c1, c2) in zip(firstString, secondString):
        result = chr(ord(c1) ^ ord(c2))
        output.append(result)
    return "".join(output)

message = "Hello, World!"
password = "secret"

ciphertext = vernam_cipher(message, password)
print(ciphertext)

cleartext = vernam_cipher(ciphertext, password)
print(cleartext)
```



hodenbussard schrieb:


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


War das jetzt Ironie?


----------



## LastChaosTyp (8. Juni 2014)

*AW: Python : Verschlüsselungsalgorithmus*

Mir geht es bei dieser Aktion nicht um sicher oder nicht, sondern um ein wenig ausprobieren und das erste, eigene sinnvolle Programm.
Vielen vielen vielen vielen vielen Dank für das Umschreiben des Codes. Ich werde nun eine CesarVariante und eine mit deinem Code schreiben. Könntest du dann nochmal einen Blick drüber werfen, ob das so passt und was man verbessern könnte?

Edit: Kommen bei deiner Version auch die nicht lesbaren Zeichen raus?


----------



## Rho (8. Juni 2014)

*AW: Python : Verschlüsselungsalgorithmus*

Trotz allem sollte man sich im Klarem darüber sein. Ich bin auch nicht davon ausgegangen, dass du das Programm produktiv einsetzen willst.
Das Resultat der XOR-Operation in einen Char und dann in einen String umzuwandeln ist aber in dem Fall unsinnig. Normalerweise arbeitet man hier einfach mit Bytes bzw. Byte-Arrays.



> Edit: Kommen bei deiner Version auch die nicht lesbaren Zeichen raus?


Ja, das ist von der Funktionsweise mit dem von dir geposteten Beispiel identisch.


----------



## LastChaosTyp (8. Juni 2014)

*AW: Python : Verschlüsselungsalgorithmus*

Ok, Ich habs nun endlich geschafft  Hier ist mein Code:


```
# ------------------------------------------ Bibliotheken ------------------------------------------

from tkinter import *

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

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

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

        # Label:
        self.labelUeberschrift = Label(self.hauptfenster, text = "Ver-/Entschlüsselung", fg = "black", font = "Arial 30 underline")
        self.labelPasswort = Label(self.frame1, text = "Passwort", fg ="black", font = "Arial 15 bold")
        self.labelDateipfad = 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.buttonCodieren = Button(self.hauptfenster, text = "Codieren", font = "Arial 15 bold", width = "20", command = self.codierenAufruf)

        # Eingabe:
        self.entryPasswort = Entry(self.frame1, width = "50")
        self.entryDateipfad = Entry(self.frame2, width = "50")

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

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

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

        self.labelPlatzhalter2.pack()

        self.buttonCodieren.pack(padx = "5")

        self.labelAusgabe.pack()

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

    def codierenAufruf(self):
        pfad = self.entryDateipfad.get()
        self.codieren(pfad)

    def vernam_cipher(self, message, password):
        key = self.gen_key(password, len(message))
        ciphertext = self.xor_strings(message, key)
        return ciphertext

    def gen_key(self, password, length):
        key = password
        while len(key) < length:
            key += password
        return key[:length]

    def xor_strings(self, firstString, secondString):
        output = []
        for (c1, c2) in zip(firstString, secondString):
            result = chr(ord(c1) ^ ord(c2))
            output.append(result)
        return "".join(output)
    
    def codieren(self, dateipfad):
        # In dieser Variable wird der Orginaltext gespeichert:
        orginaltext = ""

        # Passwort wird erfragt:
        passwort = self.entryPasswort.get()

        # Festlegung des neuen Dateipfads:
        neuerDateipfad = dateipfad[:-3]
        neuerDateipfad += "Codiert.txt"
        
        # Lesen der Zeilen, solange Inhalt vorhanden ist:
        dateizeiger = open(dateipfad, "r")
        zeile = dateizeiger.readline()
        while zeile != "":    
            orginaltext += zeile
            zeile = dateizeiger.readline()
        dateizeiger.close()
            
        # Codierung des Textes:
        ciphertext = self.vernam_cipher(orginaltext, passwort)

        # Schreiben des Textes in neue Datei:
        dateizeiger = open(neuerDateipfad, "at")
        dateizeiger.write(ciphertext)
        dateizeiger.close()
                
        # Ausgabe zur Bestätigung des erfolgreichen Ablaufs
        self.labelAusgabe["text"] = "Die Datei wurde erfolgreich codiert und unter " + str(neuerDateipfad) + " gespeichert!"

# ------------------------------------------ Programm ----------------------------------------------

hauptfenster = FensterMitCode()
```

Nochmal ne Frage an Rho:
Diese Verschlüsselung hat den Nachteil, dass Windows nicht alle Zeichen richtig abspeichern/lesen kann! Ist dir ein Verschlüsselungsalgorithmus für Python bekannt, der in für Windows lesbaren Zeichen speichert (ANSI, ...)? Dieser sollte aber trotzdem mit Passwort arbeiten 
Ich bedanke mich nochmal bei dir für das Umschreiben und die Hilfe


----------



## Rho (8. Juni 2014)

*AW: Python : Verschlüsselungsalgorithmus*

Das hat nichts mit Windows zu tun. chr() wandelt einen Integer in das entsprechende Unicode-Zeichen um und die sind nunmal nicht alle darstellbar (Control character - Wikipedia, the free encyclopedia).
Wandle den verschlüsselten Text einfach nicht in einen String um, sondern speichere ihn binär. Dann gibt es keine Probleme.


----------



## LastChaosTyp (8. Juni 2014)

*AW: Python : Verschlüsselungsalgorithmus*

Ok, ich kann leider nur als String speichern. Könntest du mir kurz sagen, wie man binär speichert? Oder mir nen Link zu ner Anleitung oder so schicken. Wäre super


----------



## Rho (8. Juni 2014)

*AW: Python : Verschlüsselungsalgorithmus*

Eventuell würde sich für dich mal ein Blick auf https://docs.python.org/3/ lohnen.


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

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

def xor_bytes(firstData, secondData):
    output = bytearray()
    for (d1, d2) in zip(firstData, secondData):
        result = d1 ^ d2
        output.append(result)
    return output

def save_data(data, path):
    f = open(path, 'w+b')
    f.write(cipherData)
    f.close()

def read_data(path):
    f = open(path, 'r+b', buffering=0)
    data = f.readall()
    f.close()
    return data

message = 'Hello, World!'
password = 'secret'
path = 'encoded.bin'

messageData = message.encode('utf-8')
cipherData = vernam_cipher(messageData, password)
save_data(cipherData, path)

cipherData = read_data(path)
messageData = vernam_cipher(cipherData, password)
message = messageData.decode('utf-8')
print(message)
```


----------



## LastChaosTyp (8. Juni 2014)

*AW: Python : Verschlüsselungsalgorithmus*

DANKE!!


----------



## R4Z0R1911 (8. Juni 2014)

*AW: Python : Verschlüsselungsalgorithmus*

Mal eben eine vor allem SICHERE Verschlüsselung Programmieren ist nicht.  Damit es sicher ist muss es schon sehr aufwändig sein.
Vielleicht bekommst ja irgendwo noch die Source von TrueCrypt. Ist zwar glaube ich kein Python aber wird dir vllt etwas helfen.


----------



## LastChaosTyp (8. Juni 2014)

*AW: Python : Verschlüsselungsalgorithmus*

Nochmals: Es geht mir nicht um sicher oder nicht. Ich will lediglich dazu lernen und ein kleines halbwegs sinnvolles Programm. Diese Anwendung kommt nicht zum ernsthaften Einsatz!


----------



## Icephoen1x (9. Juni 2014)

*AW: Python : Verschlüsselungsalgorithmus*

Du könntest auch mal drüber nachdenken den schlüssel einfach auf den klartext draufzuaddieren (so funktioniert vernam afaik, nicht mit xor). Dann könntest du einfach mit nem if dafür sorgen, dass der ciphertext im lesbaren bereich bleibt. Geht bei caesar genauso. Caesar ist dann ja das gleiche mit nem einstelligen passwort.


----------



## Rho (9. Juni 2014)

*AW: Python : Verschlüsselungsalgorithmus*



Icephoen1x schrieb:


> (so funktioniert vernam afaik, nicht mit xor)


Es gibt beide Varianten. Die erste Variante wäre dann im Grunde die Vigenère-Chiffre.



Icephoen1x schrieb:


> Dann könntest du einfach mit nem if dafür sorgen, dass der ciphertext im lesbaren bereich bleibt.


Oder man benutzt einfach den Modulo-Operator.


----------



## LastChaosTyp (9. Juni 2014)

Wie meinst du das mit draufaddieren? Dwn Wert des Schlüssels berechnen un dann auf jeden Buchstaben draufaddieren?

Was genau ist ein ModuloOperator?


----------



## DarkMo (9. Juni 2014)

*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 (9. Juni 2014)

*AW: Python : Verschlüsselungsalgorithmus*



LastChaosTyp schrieb:


> 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 (9. Juni 2014)

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


----------



## LastChaosTyp (9. Juni 2014)

*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 (9. Juni 2014)

*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 (10. Juni 2014)

*AW: Python : Verschlüsselungsalgorithmus*



LastChaosTyp schrieb:


> 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 (10. Juni 2014)

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 (10. Juni 2014)

*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 (11. Juni 2014)

*AW: Python : Verschlüsselungsalgorithmus*



hodenbussard schrieb:


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


----------

