Hallo, zuallererst möchte ich schreiben, dass dieses Codeschnippsel sehr unsicher ist und die Verschlüsselung leicht geknackt werden kann. Ich rate also von der Verwendung ab. Benutze lieber die RC4 Funktionen, die Hagen in diesem Thread gepostet hat.
(
http://www.delphipraxis.net/internal...=206997#206997 )
Die sind nicht viel länger und sicherer.
Aber ich erkläre den Code dennoch gerne:
Das Grundprinzip basiert auf einer einfachen Vorgehensweise.
Man nehme einen Schlüsselstrom (Funktion die in einer reproduzierbarer Folge einzelne Schlüssel liefert) und verschlüssele jeden Buchstaben des Strings mit einem eigenen Schlüssel in dem der Schlüssel dem
Ascii Code des Zeichen hinzuaddiert wird.
Wenn man einen sicheren Schlüsselgenerator verwendet ist dieses Verfahren einigermasen sicher.
Ich verwende aber hier den Zufallsgenerator von Delphi als Schlüsselgenerator, der nicht sicher ist.
Zur Verwendung von Random möchte ich gerne Hagen (aus diesem Thread weiter oben) zitieren:
(Ich habe mir erlaubt einige Stellen Fett zu markieren)
[equote="negaH schrieb in
http://www.delphipraxis.net/internal...=207146#207146 "]Der in Delphi/Borland PASCAL verwendete Random Algorithmus ist seit Borland PASCAL 4.1 immer schon der selbe, also über 15 Jahre schon. Es handelt sich dabei um einen LCG = Linear Congruential Generator = Reste Generator. Diesen findet man sehr sehr häufig, eben auch in JAVA, C usw. usw.
LCG's sind sehr gut erforscht, auch in der Kryptographie und es sind die UN-sichersten Verfahren überhaupt (mal abgesehen von noch einfacheren). Wenn nun noch nicht das zweite Problem wäre, nämlich das es nur ein 32 Bit Generator ist. Dadurch ist die Länge des effektiven Passwortes immer auf 32 Bit beschränkt. Ihr solltet euch einschlägige Fachliteratur suchen und dort mehr über den LCG, LFSR, CFR usw. nachlesen. Die LCG's, fast egal in welcher Bitgröße sind heutztage sehr wohl knackbar.
Die Verwendung von Random() in der Kryptographie scheint meiner Meinung nach die meist empfohlene und die schwachsinnigste Idee unter Delphi Programmierern zu sein. An jeder Ecke im WEB stößt man auf solche Vorschläge und immer wieder muß man dazu sagen das die schlichtweg falsch sind. Im gleichem Atemzuge wird dann meistens behauptet das dies ausreichend sicher wäre, ABER NIEMAND hat dies jemals bei diesen Vorschlägen tatsächlich bewiesen. Diese Aussagen sind demzufolge alle unbewiesen, und andererseits gibt es genügend Fachliteratur in denen Matematiker bewiesen haben das LCGs kryptographisch unsicher und sogar nur bedingt in der Statistik zu gebrauchen sind.
Mal ganz davon abgesehen das die Verwendung von Random(), und dessen Seed durch Überschreibung als Passwort zu gebrauchen, den Programabfluß der Gesamtanwendung zb. für Statistische Zufallsauswertungen absolut durcheinander bringt. Man sollte Random() zur Erzeugung von Zufall applikationsweit betrachten und ihn auch nur dafür benutzen.
Das wohl schlechteste Beispiel für die Anwendung von Random() ist diesen zur Erzeugung eines OTP = One Time Password's = Einmal Passwortes zu gebrauchen. Dieses große Passwort wird dann meistens per XOR mit der Nachricht verknüpft. Diese propagierte Anwendung von Random() in einer OTP Verschlüssleung ist wohl das widersinnigste was ich gesehen habe. Eine OTP Verschlüsselung gilt als die 100% sicherste Verschlüsselung die man kennt. Aber eben NUR wenn das verwendete Passwort aus echtem puren Zufall besteht. Durch die Verwendung von Random() degradiert man die sicherere OTP Verschlüsselung auf fast 0 Sicherheit !!
Gruß Hagen[/equote]
Nun noch mal der Quelltext mit einigen Kommentaren von mir:
Delphi-Quellcode:
// written by MaBuSE, member of delphipraxis.net
function myCoder(s:
string; password: Integer; decode: Boolean):
string;
var
i, c, x: Integer;
begin
// bein Verschlüssel wird der Schlüssel zu dem Zeichen Addiert (Plus, +),
// beim Entschlüsseln wird er vom Zeichen Subtrahiert (Minus, -) in dem der Wert
// vor der Addition mit -1 Multipliziert (Mal, *) wird.
if decode
then x := -1
else x := 1;
// Mit RandSeed wird der Startwert der Random Funktion festgelegt.
// Random liefert reproduzierbar immer die selbe Reihenfolge von Zufallszahlen
// Wenn RansSeed auf einen Wert gesetzt wird.
RandSeed := password;
// Rückgabewert auf '' initialisieren
Result := '
';
// Für jedes Zeichen in dem String tue:
for i := 1
to length(s)
do
begin
// Ermittele den ASCII Wert des Zeichens an der i. Stelle im String
c := ord(s[i]);
// Nur wenn c >32 und c<122 dann verschlüsseln
// (Alles Andere bleibt unverschlüsselt)
if c
in [32..122]
then
begin
// Hier ist die Stelle an der verschlüsselt wird.
// Zu c wird der Schlüssel aus dem Schlüsselstrom addiert.
// (Beim Entschlüssel wegen dem x=-1 wird er Subtrahiert s.o.)
c := c+(x*Random(90));
// Wenn Das Ergebnis > 122 ist, dann Subtrahiere 91 um
// den Wert nochmal in den Bereich zu bekommen
if (c<32)
or (c>122)
then c := c-(x*91);
end;
// Den verschlüsselten Buchstaben zum Ergebnisstring hinzufügen.
Result := Result + chr(c);
// Den nächsten Buchstaben bearbeiten (for Schleife)
end;
// Ende der Funktion length(Result) ist nun gleich length(s)
end;
procedure TForm1.Button1Click(Sender: TObject);
begin
// von Edit2 nach Edit3 mit Passwort aus Edit1 verschlüsseln
Edit3.Text := myCoder(Edit2.Text, StrToInt(Edit1.Text), False);
// und wieder von Edit3 nach Edit4 entschlüsseln.
Edit4.Text := myCoder(Edit3.Text, StrToInt(Edit1.Text), True);
end;
Ich hoffe der Algorithmus ist nun klar.
Statt der Addition kann man natürlich auch eine Andere Operation z.B. XOR verwenden.
Wie gesagt, Random() ist unsicher, deshalb lieber RC4 verwenden.
Viel Spaß
MaBuSE