VerschlüsselungsProgramm

[devnull]

Hi,
ich hab jetzt doch mal, angeregt von anderen Tools ein eigenes Programm geproggt.
Dies ist jedoch nur eine Demo-Version, bei der es euch erlaubt ist
> EINFACHE TEXTE
> MAXIMAL 1000 ZEICHEN
zu kodieren.

Naja, über keine Kritik würde ich mich freun.

devnull

[MaBuSE]

Zitat von Sharky:

Zitat von Luckie:

... Das heißt wiederum, der Seed entspricht dem Passwort oder?

...Aber das Passwort zu verwenden macht eigentich keinen Sinn. Denn wenn dieses geknackt wurde wäre ja auch der Seed bekannt....

Der Seed ist nur der Startwert (Init) eines Zahlengenerators.

Wenn dieser Zahlengenerator zur Verschlüsselung verwendet wird, dann ist der Seed das Passwort. (siehe mein Beisp. oben)

Wenn neben dem Seed noch ein Passwort (key) verwendet wird, das die Verschlüsselung beeinflusst, dann ist meies Verständnisses nach der Seed ein Teil des Schlüsels, das Passwort wäre dann auch Teil des Schlüssels.

[Luckie]

@Sharky: Der von dir zitierte Text von Hagen, war genau das was ich gesucht habe. Jetzt weiß ich, wie das alles zusammenspielt.

[Sharky]

Zitat von Luckie:

@Sharky: Der von dir zitierte Text von Hagen, war genau das was ich gesucht habe. Jetzt weiß ich, wie das alles zusammenspielt.

Es freut mich das ich Dir helfen konnte! Auch wenn es "nur" war weil ich noch ein Posting eines anderen im Hai-Kopf hatte

[michi213]

Hallo

habe mit Begeisterung das Verschlüsselungsverfahren von negaH ausprobiert und es geht wunderbar. Nur habe ich ein kleines Problem:
Der entstehende Code ist ja sehr "kryptisch". Man kann ihn aber ohne Probleme verwenden, solange man ihn vom einen Feld ins andere kopiert. Nur wenn man den entstandenen Code weitergeben will, geht es nicht. Ich habe versucht, ihn in einer Datei zu speichern (indem ich den Code aus einer Memo mit der dortigen Funktion SaveToFile gespeichter habe). Aber wenn ich den Code über den gleichen Weg (natürlich mit loadfromfile) lade, schreibt es mir das teilweise in mehrere Zeilen. Ich nehme an, eines der enthaltenen Zeichen wird als Zeilenumbruch gelesen. Mein Versuch, die einzelnen Zeilen zusammenzufügen und zwischendrinnen #10#13 einzufügen brachte aber nicht korrekt den verschlüsselten Text zustande, das Ende stimmte nicht.

Was muss ich machen, um den verschlüsselten Text verlustfrei zu speichern und wieder zu laden, bzw wie?


MfG Michael

[negaH]

Das "kryptische" Resultat der Verschlüsselung nennt man "Binär". Im Grunde ist das reine Binärformat absolut ungeeignet um es in Labels/Memos etc. anzuzeigen. Deshalb konvertiert man dieses Format normalerweise in ein anderes textbasiertes Format, zb. die HEXadeziamle Darstellung oder morderner in das Internet MIME Base 64 Format.

In eine Datei kannst du Binärdaten aber denoch verlustfrei speichern und auch wieder laden. Dazu musst du nichts konvertieren.

Gruß Hagen

[jmit]

Hallo,

Ihr spricht alle von diesem Programm und der Verschlüsselungsfunktion. Ich kann dieses Programm unter Windows XP SP2 zwar aufrufen. Nach dem Aufruf kann ich auch eine Datei auswählen, aber diese Datei wird nicht verschlüsselt. Ich bekomme immer die Meldung: Keine Datei(en) ausgewählt.

Was mache ich falsch?

Gruß Jörg

[MaBuSE]

Zitat von MaBuSE:

Ich habe oft kleinere Programme, bei denen ich Daten verschlüsseln möchte. (z.B. temp. Dateien)
Die verschlüsselten Daten sind meist "unwichtig" und eine Entschlüsselung würde wenig Sinn machen.
Das mache ich nur um mir nicht in die Karten schauen zu lassen.

Ich verwende auch einen Schlüsselstrom, der mit einem Seed festgelegt wird.
(RandSeed := Startwert) Der Schlüsselstrom wird allerdings durch den Zufallsgenerator von Delphi zur Verfügung gestellt

Ich habe mir eine kleine Funktion geschrieben, um nicht mit Kanonen auf Spatzen zu schießen.
(Für diesen Zweck reicht eine "einfache" Verschlüsselung aus. Es muss ja nicht immer eine 4096bit Schlüssellänge mit einem starken Algorithmus verwendet werden.)

Es kommt also immer auf den Verwendungszweck an.

ps: Falls Sich jemand für den Code interessiert:

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

Zu diesem Codeschnipsel habe ich folgende Anfrage per PN bekommen, die ich nachfolgend beantworten möchte.
(Da ich grundsätzlich Fragen zu Threads nicht privat, sondern öffentlich beantworte, mache ich das hier)
Das Codebeispiel ist auch in der Codelib zu finden. Evtl kann ein Mod diesen Beitrag zur Erläuterung anhängen (Danke)
http://www.delphipraxis.net/internal...ct.php?t=30306

Inhalt der PN

hay,
ich hab grade ein Tagebuch geschrieben (neue Version werde ich heute abend noch ins forum stellen), in dem verwende ich einen quellcode von dir um die einträge zu verschlüsseln.
hier noch dein quellcode:

Delphi-Quellcode:

function myCoder(s: string; password: Integer; decode: Boolean):string;
...
end;

den code finde ich sehr sehr gut, nur ein problem habe ich damit... ich versteh ihn nicht richtig.
kannst du mri bitte den code erklären, weil wenn ich einen code benutze möchte ich auch wissen wie er funktioniert.

big thx.

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 90 um
      // den Wert nochmal in den Bereich zu bekommen
      if (c<32) or (c>122) then c := c-(x*90);
    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

[gizzy]

Zitat von maximov:

Also entschlüsseln geht bei mir doch nicht!? Bei dir

//edit: Verdammt! geht doch...aber nicht mit deinem code (mabuse). So muss sein:

Delphi-Quellcode:

var 
  x: TRC4Context; 
  str1, str2, str3: string; 
begin 
  readLn(str1);
  setLength(str2,length(str1)); 
  writeLn('text: '+str1);
  
  RC4Init(x,'Passwort'); 
  RC4Code(x, str1[1], str2[1], Length(str1)); // verschlüsseln   
  Rc4Done(x);
  
  writeLn('coded: '+str2);
  setLength(str3,length(str2)); 

  RC4Init(x,'Passwort'); 
  RC4Code(x, str2[1], str3[1], Length(str2)); // entschlüsseln 
  Rc4Done(x);
   
  writeLn('encoded: '+str3);
  readLn;
end.

Super sache! danke.

Hallo,

ich hab mir die Verschlüsselung von negaH mal angeguckt und ausprobiert, leider bekomme ich Fehler. Ich muss zb. den schon codierten string nochmal codieren um das ich ein einigermaßen richtiges ergebniss rausbekomme. auls result erhalte ich für einen String zb. Seegurke => Seegurk. Ich habe das alles in zwei functions gemacht.

Hier die function und der Aufruf:

Delphi-Quellcode:

function rc4coding(encstr: String; pw: String): String; //Zum verschlüsseln
var
  x: TRC4Context;
  str1,str2, str3: string;
begin
  str1:= encstr;
  setLength(str2,length(str1));

  RC4Init(x,pw);
  RC4Code(x, str1[1], str2[1], Length(str1)); // verschlüsseln
  Rc4Done(x);

  result:=str2;
end;

Delphi-Quellcode:

function rc4decoding(dencstr: String; pw: String): String; //entschlüsseln
var
  x: TRC4Context;
  str1,str2, str3: string;
begin
  str1:=dencstr;
  setLength(str2,length(str1));

  RC4Init(x,pw);
  RC4Code(x, str1[1], str2[1], Length(str1)); // verschlüsseln
  Rc4Done(x);

   setLength(str3,length(str1));

  RC4Init(x,pw);
  RC4Code(x, str2[1], str3[1], Length(str2)); // entschlüsseln
  Rc4Done(x);



  result:=str3;

end;

Delphi-Quellcode:

//Aufruf:
   string:= rc4coding(MeinString,'passwort'); //codieren
   string:= rc4decoding(MeinString,'passwort'); /decodieren

Ich weiß leider nicht ob das so richtig ist. Am besten wäre natürlich jemand könnte das nochmal in einer function darstellen.

Vielen Dank schon mal im Voraus.

[IceTube]

hä?

Das ist aber nicht dein Ernst, dass das eine Demo Version ist...und bei Freeware geadded ist?

Und nichts für Ungut, aber solch ein Programm schreibt man innerhalb einer Stunde wenn nicht weniger, also das find ich stark.....

Naja Meine Meinung dazuuu

lg

[Tormentor32]

Wenn du den Thread gelesen hättest, dann hättest du auch mitbekommen, dass es sich nur um einen Scherz handelte!