hi leute,
ich hab mal einen kleinen passwort saver programmiert. Heisst, wer probleme hat sich seine passwörter+nick und webseite zu merken gibt die daten in drei editfelder ein, diese felder werden dann in ein memo geladen. mithilfe von opendialog und savedialog kann ich diese dann speichern bzw abrufen...

Soweit so gut! Nun meine Frage:

Wie verschlüssle ich diese Passwörter, die jetzt in dem Memofeld sind. Bzw in welche .Dateiendung sollen diese passwörter geschrieben werden, sodass es nicht möglich ist diese mit öffnen z.b. des editors abzufangen?

ich danke euch,

Gruß Nohh

Hehehe, <Jean_Puetz_Stimme> "Ich hab da mal was vorbereitet" </Jean_Puetz_Stimme>.

Wie verschlüssle ich diese Passwörter, die jetzt in dem Memofeld sind.

Einfache Frage, hochkomplexe Antworten sind möglich.
Als erste Anlaufstellen hier mal zwei Links:
Wikibook "Cäsar-Verschlüsselung"
Wikipedia: Krytographie

Bzw in welche .Dateiendung sollen diese passwörter geschrieben werden, sodass es nicht möglich ist diese mit öffnen z.b. des editors abzufangen?

Also grundsätzlich würde ich persönlich niemals mit einem simplen Notepad mit automatischer Dateiendungszuordnung versuchen, irgendwelche Passwörter zu knacken sondern schon mal grundsätzlich mit einem Hex-Editor ran gehen. Was bedeutet: Die Dateiendung ist mir vollkommen egal. Ob das eine .txt, .wwi, .bat oder .dat-Datei ist, spielt für mich keine Musik. Wenn da ein Passwort drin steht, dann sehe ich das.
Wirklich wichtig ist, dass der Inhalt verschlüsselt ist. Und da scheiden sich bereits die Geister und viele Stimmen rufen von 1024- oder 2048-Bit-Verschlüsselungen etc. pp.

Ich persönlich habe im privaten Bereich folgende Erfahrungen gemacht:
1. Die üblichste Methode, um an Passwörter zu gelangen ist "brute force". Das ist kein Algorithmus oder eine Verschlüsselungstechnik, sondern einfach eine Methode, die darin besteht, alle möglichen Kombinationen einfach auszuprobieren, bis man eine vernünftige Lösung hat. Das Vergleichen der einzelnen Entschlüsselungsversuche kann auch automatisiert werden (semantische Scanner mit angeschlossenem Wörterbuch) und irgendwann hat man eine Liste mit möglichen Lösungen, die man ausprobieren kann.
2. Voraussetzung für "brute force" ist jedoch, dass die Passwortverschlüsselung einfach erfolgte. D.h. das Passwort wurde genommen, einmal verschlüsselt (wie auch immer) und fertig. Deswegen benutze ich sehr gerne kombinierte Verschlüsselungen, also mehrere Schritte. Da braucht es dann auch gar keine supermegaausgefeilten Verschlüsselungen.
3. Wenn mit "brute force" in einem bestimmten Zeitrahmen nichts zu erreichen ist, besteht der nächste Schritt normal aus einer Sichtung der einzelnen Bytes und deren Abstand zueinander. Bei einfachen Cäsar- oder Vigenère-Verschlüsselungen geht das auch recht gut, da sich dann Byteblöcke in einem Rahmen von 26 bis 52 Differenz bewegen (siehe auch die geposteten Links). Wenn ich dann mit dem Hexeditor auf einen solchen Datenblock stosse, dann nehme ich mir den natürlich intensiv vor.
4. Wenn das alles nichts fruchtet (ich komme einfach nicht so schnell an die verschlüsselten Passwörter), dann gehe ich mit dem Hexeditor auf die .exe-Datei des Verschlüsselungsprogramms los und suche da nach den Schlüsseln der Verschlüsselung. Insbesondere im Hobbybereich wird das nämlich gerne vergessen. Da werden die Schlüssel als einfach Strings oder Charakter-Arrays im Programm definiert und stehen dann auch so hinterher im Kompilat drin. Wenn ich den oder die Schlüssel gefunden habe, erleichtert mir das die Arbeit natürlich erheblich, da ich nur noch rumknobeln muss, wie und in welcher Reihenfolge ich die Dinger auf die verschlüsselten Passwörter anzuwenden habe.

Womit ich bisher recht gute Erfahrungen gemacht habe, ist eine mehrstufige Vigenère-Verschlüsselung mit einer Abwandlung eines eingestreuten Rot13.
Nicht nur werden die Passwörter verschlüsselt sondern auch (bei passender Schlüsselwahl) "demaskiert", d.h. sie sind auch hinterher mittels Hexeditor nicht mehr ohne weiteres als verschlüsselte Passwörter zu erkennen und unterscheiden sich auch vom Aussehen her nicht mehr wirklich von Binärcode. Wenn man dann noch freundliche 5-16kb zufälligen Datenmüll dazu packt und die codierten Passwörter da drin speichert - gute Nacht, Marie, da darf dann jemand aber richtig lange knobeln.

Ähnlich gehe ich in meinem Programm vor.
Angenommen, ich verwende als 1. Schlüssel (von mehreren) das Wort "Schluessel". Du wirst dann niemals so etwas in meinem Sourecode finden:

Code delphi:

1 2 3 4

var   Key1: String; ... Key1 := 'Schluessel';

Denn das lässt sich hinterher mit dem Hexeditor finden.

Viel mehr wird das Ding wohl eher so drin stehen:

Code delphi:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

var   Key1Part1: String;   Key1Part2: String;   Key1Part3: String;   KeyCoded: String;   KeyUncoded: String;   DummyInt1: Integer;   DummyInt2: Integer;   DummyInt3: Integer;   i: Integer; ... Key1Part1 := 'Vfk'; DummyInt1 := 4354223; Key1Part2 := 'oxv'; DummyInt2 := '12234'; Key1Part3 := 'vho'; DummyInt3 := '443254'; KeyCoded := Key1Part1 + Key1Part2 + Key1Part3; KeyUncoded := ''; for i := 1 to Length(KeyCoded) do   KeyUncoded := KeyUncoded + Chr(Ord(KeyCoded[i]) - 3);

Das ist mit einem Hexeditor schon deutlich schwerer aufzuspüren (insbesondere bei der Grösse eines Kompilats) und natürlich kann man das auch noch weitertreiben und beispielsweise "red herrings" in den Source einstreuen.

(to be continued)

(continued)

Ok, genug mit dem ewigen Geschwafel, ich nehme mal an, du bist auch an ein bisschen Sourcecode interessiert, der ein wenig die Funktionsweise des von mir Gesagten beleuchten.

Ich habe in einem neuen Projekt mal ein Formular erstellt und darauf folgende visuelle Komponenten gelegt:
- Memofeld memPasswords für die Passwörter
- Editfeld edKey1 für den ersten Schlüssel
- Editfeld edKey2 für den zweiten Schlüssel
- Editfeld edKey3 für den dritten Schlüssel
- Editfeld edUncoded für die Byteanzeige des unverschlüsselten Passworts
- Editfeld edCoded1 für die Byteanzeige nach der ersten Verschlüsselung
- Editfeld edCoded2 für die Byteanzeige nach der zweiten Verschlüsselung
- Editfeld edCodedRot13 für die Byteanzeige nach der Rot13-Verschlüsselung
- Editfeld edCoded3 für die Byteanzeige nach der dritten (letzten) Verschlüsselung
- Button btCode, Beschriftung "Mach ma".

Es ist nur eine einzige Ereignismethode angelegt und zwar für den Button.
Die Bedienung ist sehr einfach:
Im Memofeld steht das zu verschlüsselnde Passwort.
Für die drei Schlüssel werden Werte (Strings) eingetragen und dann auf den Button "Mach ma" geklickt.
In edCoded3 steht am Schluss die Bytefolge des codierten Passworts drin, datentechnisch liegt dir das Teil dann als strPassword vor, das du dann beliebig weiterverwenden kannst.

Hier der voll kommentierte Source. Ich hoffe du hast deinen Spaß dran.

Code delphi:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184

// Hier findet die Verschlüsselung des Passworts statt. // Diese erfolgt in mehreren Schritten: // - Vigenère-Verschlüsselung mit dem Inhalt von edKey1 // - Vigenère-Verschlüsselung mit dem Inhalt von edKey2 // - Direkte Rot13-Verschlüsselung // - Abschließende Vigenère-Verschlüsselung mit dem Inhalt von edKey3 // Als Codierungsraum wird der ASCII-Zeichensatz genommen, d.h. alle // Zeichen des verschlüsselten Passworts liegen hinterher im Bereich von // 0 bis 255. procedure TForm1.btCodeClick(Sender: TObject); var   strPassword: String;   strCodedPassword: String; begin   // Einlesen des Passworts aus dem Memo in einen lokalen String   strPassword := memPasswords.Lines.Strings[0].Trim;     // Anzeige der Bytefolge des unverschlüsselten Passworts.   // Mit anderen Worten: edUncoded zeigt die ASCII-Werte des Passworts an   edUncoded.Text := ShowBytes(strPassword);     // Durchführung der 1. Vigenère-Verschlüsselung, Übertragung des   // codierten Passworts zur weiteren Verarbeitung und Anzeige der   // ASCII-Werte.   strCodedPassword := Vigenere(strPassword, edKey1.Text);   strPassword := strCodedPassword;   edCoded1.Text := ShowBytes(strPassword);     // Wie zuvor. Wieder eine Vigenère-Verschlüsselung, diesmal mit Key2   strCodedPassword := Vigenere(strPassword, edKey2.Text);   strPassword := strCodedPassword;   edCoded2.Text := ShowBytes(strPassword);     // Immer nur Vigenère ist langweilig, ein Rot13 passt auch dazwischen. :)   strCodedPassword := Rot13(strPassword);   strPassword := strCodedPassword;   edCodedRot13.Text := ShowBytes(strPassword);     // Letzte Vigenère. Am Schluss liegt in strPassword das verschlüsselte   // Passwort vor.   strCodedPassword := Vigenere(strPassword, edKey3.Text);   strPassword := strCodedPassword;   edCoded3.Text := ShowBytes(strPassword); end;     // Durchführung der Vigenère-Verschlüsselung. // Jedes ASCII-Zeichen des Passworts (von Buchstaben kann man da // nicht notwendigerweise sprechen) wird um die Distanz zum // korrespondierenden Schlüsselzeichen verschoben. // Zur exakten und detaillierten Funktionsweise der // Vigenère-Verschlüsselung finden sich zahlreiche Quellen im // Internet. function TForm1.Vigenere(pPassword: String; pKey: String): String; var   nPasswordCounter: Integer;   nKeyCounter: Integer;   cPasswordZeichen: Char;   nPasswordZeichen: Integer;   cKeyZeichen: Char;   nKeyZeichen: Integer;   nNeuesZeichen: Integer; begin   // Result enthält hinterher das verschlüsselte Passwort.   Result := '';     // Zwei Zeiger. Diese beziehen sich auch die jeweiligen   // Codierungspositionen in Passwort und Schlüssel. Da der   // Schlüssel durchaus kürzer sein kann als das Passwort,   // muss er dann entsprechend oft durchlaufen werden, weswegen   // es zwei unabhängige Zeiger geben muss.   // (siehe auch Vigenère-Verschlüsselung im Internet)   nPasswordCounter := 1;   nKeyCounter := 1;     // Das Passwort muss verschlüsselt werden, wobei es überhaupt   // keine Rolle spielt, wie oft der Schlüssel dafür angewendet   // wird. Daher läuft die Schleife über die gesamte Länge des   // Passworts.     while nPasswordCounter <= Length(pPassword) do   begin     // Um es nicht unübersichtlich zu machen, ist der folgende     // Schritt in zwei Einzelschritte aufgeteilt:     // Es wird das Zeichen des Passworts genommen, auf das     // der Passwortzeiger aktuell weist und in einen reinen     // Zahlenwert verwandelt.     cPasswordZeichen := pPassword[nPasswordCounter];     nPasswordZeichen := Ord(cPasswordZeichen);       // Des gleiche passiert mit dem Zeichen des Schlüssels, auf     // das der Schlüsselzeiger aktuell weist.     cKeyZeichen := pKey[nKeyCounter];     nKeyZeichen := Ord(cKeyZeichen);       // Die beiden Zeichenwerte werden addiert. Sollte dabei ein     // "ASCII-Überlauf" stattfinden, so wird er korrigiert.     nNeuesZeichen := nPasswordZeichen + nKeyZeichen;     if nNeuesZeichen > 255 then       nNeuesZeichen := nNeuesZeichen - 256;       // Der neue Zahlenwert stellt den ASCII-Wert des verschlüsselten     // Zeichens dar und entsprechend wird dieses verschlüsselte     // Zeichen dem verschlüsselten Passwort (dem Endergebnis)     // hinzugefügt.     Result := Result + Chr(nNeuesZeichen);       // Die Zeiger für das Passwort und den Schlüssel werden erhöht,     // damit auch wirklich alle Zeichen gelesen werden.     Inc(nPasswordCounter);     Inc(nKeyCounter);         // Sollte der Schlüssel kürzer sein als das zu verschlüsselnde     // Passwort, dann ist irgendwann mitten während der Codierung     // des Passworts das Ende des Schlüssels erreicht. In diesem     // Falle fängt der Schlüssel einfach wieder von vorne an.     // (siehe auch Vigenère-Verschlüsselung im Internet)     if nKeyCounter > Length(pKey) then       nKeyCounter := 1;   end; end;     // Durchführung der Rot13-Verschlüsselung. // Naja, gut, eine echte Rot13-Verschlüsselung ist es nicht // wirklich, da sich ja das Rot13 auf "Rotate 13" bezieht // und damit auf eine einfache Cäsar-Verschlüsselung. Aber // das generelle Prinzip bleibt das Gleiche. // Im Endeffekt wird vom zu verschlüsselnden Passwort // jedes einzelne Zeichen genommen. Von jedem dieser Zeichen // wird die 8-Bit (Größe des ASCII-Raums)-Darstellung // verwendet und jedes Bit invertiert. // Aus einem A (ASCII 65, Binär 01000001) wird somit ein // ASCII 190, Binär 10111110, als darstellbares Zeichen ist // das eine Art Grafiksymbol. function TForm1.Rot13(pPassword: String): String; var   i: Integer;   cZeichen: Char;   nZeichen: Integer; begin   // Result beinhaltet hinterher das verschlüsselte Passwort   Result := '';     // Durchlaufen des Passworts auf seiner gesamten Länge   for i := 1 to Length(pPassword) do   begin     // Selbes Spiel wie bei der Vigenère-Methode: Es wird vom     // Aktuellen Zeichen der ASCII-Wert benötigt.     cZeichen := pPassword[i];     nZeichen := Ord(cZeichen);     // Die Bitinvertierung funktioniert wunderbar mit einem     // XOR 255. Natürlich sind auch andere Zahlen möglich.     // Ein XOR n (n beliebige Zahl, bei ASCII von 1 - 255)     // invertiert eine Reihe von Bits, ein zweiter XOR n     // (wobei n der gleiche Zahlenwert sein muss) macht die     // Bitinvertierung wieder rückgängig.     // Sollte die genaue Arbeitsweise des XOR nicht bekannt     // sein: RTFM oder im Internet nachschlagen.     nZeichen := nZeichen xor 255;       // Aufbau des verschlüsselten Passworts mit den     // verschlüsselten Zeichen.     Result := Result + Chr(nZeichen);   end; end;     // Anzeige der verschlüsselten Passwörter // Da durch die Verschlüsselungen über den gesamten ASCII-Raum // auch leicht Sonderzeichen und nicht anzeigbare Zeichen erzeugt // werden können (was mir nicht nur bewusst sondern auch absolut gewollt // ist), lassen sich die verschlüsselten Passwörter nicht einfach so // darstellen. Daher sorgt diese Routine dafür, dass bequem zu einem // verschlüsselten Passwort die ASCII-Werte der einzelnen Zeichen // angezeigt werden. // Die entsprechende Zeile nachzuvollziehen ist Fleißaufgabe. :) function TForm1.ShowBytes(pText: String): String; var   i: Integer; begin   Result := '';   for i := 1 to Length(pText) do     Result := Result + IntToStr(Ord(pText[i])) + ' '; end;

Oha, das überschreitet wohl meinen horizont...

Code :

1 2 3 4 5 6 7 8 9 10

- Memofeld memPasswords für die Passwörter - Editfeld edKey1 für den ersten Schlüssel - Editfeld edKey2 für den zweiten Schlüssel - Editfeld edKey3 für den dritten Schlüssel - Editfeld edUncoded für die Byteanzeige des unverschlüsselten Passworts - Editfeld edCoded1 für die Byteanzeige nach der ersten Verschlüsselung - Editfeld edCoded2 für die Byteanzeige nach der zweiten Verschlüsselung - Editfeld edCodedRot13 für die Byteanzeige nach der Rot13-Verschlüsselung - Editfeld edCoded3 für die Byteanzeige nach der dritten (letzten) Verschlüsselung - Button btCode, Beschriftung "Mach ma".

sind das alles spezielle Edits? oder normale im Eventfenster?

Code :

1 2 3 4 5

// - Vigenère-Verschlüsselung mit dem Inhalt von edKey1 // - Vigenère-Verschlüsselung mit dem Inhalt von edKey2 // - Direkte Rot13-Verschlüsselung // - Abschließende Vigenère-Verschlüsselung mit dem Inhalt von edKey3 // Als Codierungsraum wird der ASCII-Zeichensatz genommen, d.h. alle...

so also das sind die Verschlüsselungsarten die angewendet werden?

.........

Also ich verstehe nicht ganz, wenn man das programm denn öffnet, dass diese passwörter die mal zuvor gespeichert wurden und verschlüsselt wurden in eine datei, wie können die wieder im passwort saver programm abgerufen werden?... ich glaube es liegt am aufbau des komplexen codes, dass ich diesen nicht verstehe. Zuviel neue Dinge tauchen auf....

Ich habe dir mal meinen jetzigen Stand auf meiner Homepage abgespeichert >> Download Hier <<< ..... vielleicht kannst du dich dann besser eindenken.

Zitat von Nohh

Oha, das überschreitet wohl meinen horizont...

Wenn dann "noch". Hab ja ein paar Links und Stichworte zum Einlesen gegeben.

Zitat von Nohh

sind das alles spezielle Edits? oder normale im Eventfenster?

Ich habe TLabeledEdits genommen, aber es gehen natürlich auch ganz normale TEdits.

Zitat von Nohh

so also das sind die Verschlüsselungsarten die angewendet werden?

Genau so ist es. 2x Vigenère, dann 1x Rot13 und dann nochmal Vigenère.

Zitat von Nohh

Also ich verstehe nicht ganz, wenn man das programm denn öffnet, dass diese passwörter die mal zuvor gespeichert wurden und verschlüsselt wurden in eine datei, wie können die wieder im passwort saver programm abgerufen werden?...

Indem man einfach die entsprechenden Codierungsschritte wieder rückwärts durchführt. Im konkreten Fall also nochmal Vigenère, nur dass beim Decodieren der Schlüsselwert vom Codewert abgezogen wird (anstatt hinzuaddiert), dann wieder Rot13 mit XOR255, dann noch zweimal Vigenère, wieder mit Subtraktion statt Addition.

Zitat von Nohh

ich glaube es liegt am aufbau des komplexen codes, dass ich diesen nicht verstehe.

Nichts für ungut, aber in Punkto Kryptographie halte ich meinen Source sogar für extrem billig. Ist aber wohl Ansichtssache.

Zitat von Nohh

Zuviel neue Dinge tauchen auf....

Und ich glaube, eher das ist der Grund, weshalb dir das so tierisch kompliziert vorkommt. Aber so leid es mir tut (naja nicht wirklich):
Wenn du die Passwörter mit einer simplen Cäsarverschlüsselung codierst und dann in eine "Password.dat" speicherst, dann brauche ich keine 5 Minuten, um dir die Dinger zu knacken. Und das kann ja wohl kaum Sinn und Zweck der Verschlüsselung sein, oder?

Zitat von Nohh

Ich habe dir mal meinen jetzigen Stand auf meiner Homepage abgespeichert

Werd's mir mal bei Gelegenheit anschauen, muss mich aber jetzt erstmal um einen Kunden kümmern.

Ok, ich hab mir dein Teil mal angeschaut. Ähhhm... sehr übersichtlich.

Wie willst du es denn haben?
Willst du dir das Teil selbst erarbeiten und programmieren?
Dann kann ich gerne mit Tips und dummen Sprüchen zur Seite stehen.
Oder willst du einen fertigen Source und den dann durchkauen?
Das kann dann allerdings etwas dauern, bis ich den getippselt habe. Bin derzeit dick eingespannt.

hi,
auf der einen seite will ich es verstehen aber nicht den source klauen

aber mein problem immer, wie kommt man auf sowas verdammt?
mir is die logik klar aber irgendwie würde ich nie auf sowas kommen in dem maße!

strdcodec etc ... pp sagt mir alles nix


MfG
Nohh

So, ich habe da mal was zusammengeschrieben, aber derzeit weder Nerv noch Zeit noch Lust, das in das spezielle Format hier bei den Tutorials zu packen. Es ist ein Word-Dokument mit 55 Seiten Umfang, wovon aber mindestens ein Drittel einfach nochmal aus dem zusammengefassten kompletten Source besteht.
Das Ding kannst dir hier runterladen. Viel Spaß damit.