AGB  ·  Datenschutz  ·  Impressum  







Anmelden
Nützliche Links
Registrieren
Zurück Delphi-PRAXiS Code-Bibliothek Library: Algorithmen Delphi sehr einfache Verschlüsselung

sehr einfache Verschlüsselung

Ein Thema von MaBuSE · begonnen am 21. Jul 2004 · letzter Beitrag vom 29. Mai 2006
Antwort Antwort
Benutzerbild von MaBuSE
MaBuSE

Registriert seit: 23. Sep 2002
Ort: Frankfurt am Main (in der Nähe)
1.810 Beiträge
 
Delphi 10 Seattle Enterprise
 
#1

sehr einfache Verschlüsselung

  Alt 21. Jul 2004, 15:28
Hallo,

falls man mal nicht mit 4096bit und starkem Verschlüsselungsalgorithmus auf Spatzen schießen möchte,
hier ein kleiner Algorithmus um z.B. Log-Files zu verschlüsseln, die nur zu Debuggingzwecken verwendet werden sollen.

Dies ist keine "sichere" Verschlüsselung.

Aber vielleicht postet ja Hagen noch seinen "sicheren" RC4 Algorithmus [edit]hier in der Codelib[/edit].


Delphi-Quellcode:
// written by MaBuSE, member of delphipraxis.net
function myCoder(s: string; password: Integer; decode: Boolean):string;
var
  i, c, x: Integer;
begin
  if decode then x := -1 else x := 1;
  RandSeed := password;
  Result := '';
  for i := 1 to length(s) do
  begin
    c := ord(s[i]);
    if c in [32..122] then
    begin
      c := c+(x*Random(90));
      if (c<32) or (c>122) then c := c-(x*90);
    end;
    Result := Result + chr(c);
  end;
end;


procedure TForm1.Button3Click(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;
Hallo,

in den obigen Algorithmus hat sich leider ein kleiner Fehler eingeschlichen.

Fehlerbeschreibung:
  • Wenn man den Buchstaben 'z' verschlüsselt und danach wieder entschlüsselt bekommt man ein Leerzeichen (' ').
Erläuterung:
  • Der Zahlenraum 32..122 ist genau 90 Zahlen groß.
  • Wenn eine verschlüsselte Zahl aus diesem Rahmen fällt (sprich größer als 122 ist),
    wurde einfach 90 abgezogen, damit ist diese Zahl wieder in dem Zahlenraum.
  • Wenn nun ein 'z' (=#122) verschlüsselt wurde, zog der Algorithmus vom Ergebnis 90 ab.
  • Beim Entschlüsseln kommt der Algorithmus zu dem Ergebnis ' ' (=#32).
  • Er kann das Leerzeichen (#32) nicht vom 'z' (#122) unterscheiden, da 32 + 90 = 122 ist.
Lösung:
  • Es muss 91 abgezogen werden.
    Damit bleiben die Zahlen immer noch im Zahlenraum (123 - 91 = 32)
    Aber aus der 122 wird eine 31 die wiederum kleiner als 32 ist
Ich hoffe ich habe Euch mit dieser Erklärung nicht verwirrt.

Folgende Zeile muss im Algorithmus geändert werden, dann klappt es auch mit dem 'z'

Delphi-Quellcode:
...
      // 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);
...
Vielen Dank an blackdrake, der diesen Fehler gefunden hat.

Liebe Grüße
MaBuSE

[edit=flomei]Irgendwie war hier kein Codehighlighting... Jetzt geht´s... Mfg, flomei[/edit]
[edit=Phoenix]Algorithmuskorrektur eingefügt. Mfg, Phoenix[/edit]
(°¿°) MaBuSE - proud to be a DP member
(°¿°) MaBuSE - proud to be a "Rüsselmops" ;-)
  Mit Zitat antworten Zitat
Dax
(Gast)

n/a Beiträge
 
#2

Re: sehr einfache Verschlüsselung

  Alt 29. Mai 2006, 15:57
In diesem Thread (genauer in diesem Beitrag) erklärt MaBuSE seinen Algorithmus nochmals genauer.

Hier eine leicht gekürzte Fassung:
Zitat von MaBuSE:
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
[edit=Phoenix]Korrektur von Beitrag 1 noch nachgezogen. Mfg, Phoenix[/edit]
  Mit Zitat antworten Zitat
Themen-Optionen Thema durchsuchen
Thema durchsuchen:

Erweiterte Suche
Ansicht

Forumregeln

Es ist dir nicht erlaubt, neue Themen zu verfassen.
Es ist dir nicht erlaubt, auf Beiträge zu antworten.
Es ist dir nicht erlaubt, Anhänge hochzuladen.
Es ist dir nicht erlaubt, deine Beiträge zu bearbeiten.

BB-Code ist an.
Smileys sind an.
[IMG] Code ist an.
HTML-Code ist aus.
Trackbacks are an
Pingbacks are an
Refbacks are aus

Gehe zu:

Impressum · AGB · Datenschutz · Nach oben
Alle Zeitangaben in WEZ +1. Es ist jetzt 18:43 Uhr.
Powered by vBulletin® Copyright ©2000 - 2019, Jelsoft Enterprises Ltd.
LinkBacks Enabled by vBSEO © 2011, Crawlability, Inc.
Delphi-PRAXiS (c) 2002 - 2019 by Daniel R. Wolf