VerschlüsselungsProgramm

[MaBuSE]

Zitat:

Zitat von dizzy

[ot]...Postet aber jemand mal ein scherzhaft gemeintes Programm, so hagelt es ernsthafte Verbesserungsvorschläge noch und nöcher :lol: --- die Helf-Disziplin hier ist einfach die beste *g*. Sehr löblich an sich, nur geht so einem scherzhaften Proggie da gewaltig der Witz verloren... was irgendwie ja auch schon wieder spassig ist.
Informatiker haben halt sehr viel Humor, aber der erstreckt sich wohl oft nicht bis in ihr Fachgebiet :)
[/ot]

Hi dizzy,

Ich bin devnull dankbar, dass er diesen Scherz gepostet hat.
Ich selbst habe das Programm nicht downgeloadet und auch nicht getestet, aber eine Umkehrung a la

Delphi-Quellcode:

for i := length(s) downto 1 do Result := Result + s[i];

ist ja deutlich als Scherz zu erkennen. Wobei ich eine ROT13 Verschlüsselung auch als Scherz verstanden hätte ;-)

Ich bin aber Hagen noch dankbarer, da ich in diesem Threat sehr viel über Verschlüsselung gelernt habe. (Ich habe mich nie ernsthaft mit Verschlüsselung beschäftigt).

In Ini-Dateien habe ich oft mit ROT13 verschlüsselt, da ich das im Kopf wieder entschlüsseln kann.
(Wir haben früher unsere Spicker und Briefchen in ROT13 verschlüsselt und konnten das fast in Echtzeit laut Lesen.)

Für kleinere Projekte habe ich "meine" Methode verwendet. (Leicht zu verstehen, leicht anzuwenden, trotzdem für den Laien (normalen Benutzer) nicht zu entschlüsseln)

In wichtigen Projekten habe ich auf externe Komponenten zurückgegriffen die dann z.B. 3DES mit großem Schlüssel und Umschlüsselung des Ergebnisses in Silben (RFC 1760).
Die Komponente heißt DEC. Das steht für Delphi Encryption Compendium und ist Freeware.
Die DEC ist einfach super. Das war das beste was ich seinerzeit gefunden habe.
Leider ist die Komponente so mächtig, das man von den Einstellungen erschlagen wird.
Ich habe mir einfach 2 Funktionen geschrieben (encodeStr(str, pwd:string):string, bzw decode(str, pwd:string):string) die für mich 3DES mit Silben erledigt.

Ich gebe aber ehrlich zu das ich nicht verstehe, das da genau (in der Komponente) gemacht wird.
Deshalb bin ich Hagen sehr dankbar, für seine Erklärungen.

@Hagen: Kennst Du DEC? Kannst Du die empfehlen?

[sakura]

Zitat:

Zitat von MaBuSE

@Hagen: Kennst Du DEC? Kannst Du die empfehlen?

Der ist gut :mrgreen: Sorry, der musste raus.

DEC ist von Hagen komplett entwickelt und geschrieben. Solltest Du also Fragen dazu haben :zwinker:

...:cat:...

[MaBuSE]

Zitat:

Zitat von MaBuSE

@Hagen: Kennst Du DEC? Kannst Du die empfehlen?

ARRRGG!!! :wall: Das Forum hat DEC unterstrichen und ich hab gekuckt.

Ich wusste gar nicht das DEC von Hagen ist. :oops:

Die obige Frage hat sich damit erledigt.

(Jetzt muß ich mir diese DEC doch mal genauer anschauen...)

[MaBuSE]

Zitat:

Zitat von sakura

Zitat:

Zitat von MaBuSE

@Hagen: Kennst Du DEC? Kannst Du die empfehlen?

Der ist gut :mrgreen: Sorry, der musste raus.

DEC ist von Hagen komplett entwickelt und geschrieben. Solltest Du also Fragen dazu haben :zwinker:

...:cat:...

Ist ja gut, ich habs gesehen :-/

Man kann ja nicht alles wissen.

Das erklärt auch, warum der sich so gut auskennt.

[sakura]

Zitat:

Zitat von MaBuSE

Ist ja gut, ich habs gesehen :-/

Ich war aber schneller - und es war bestimmt nicht böse gemeint. Ich weiß auch nicht alles, wäre auch schlimm wenn. Wie groß müssten unsere Köpfe sein :shock:

Also, viel Spaß mit dem DEC, aber vorher :cheers:

...:cat:...

[MaBuSE]

Zitat:

Zitat von sakura

Zitat:

Zitat von MaBuSE

Ist ja gut, ich habs gesehen :-/

Ich war aber schneller - und es war bestimmt nicht böse gemeint. Ich weiß auch nicht alles, wäre auch schlimm wenn. Wie groß müssten unsere Köpfe sein :shock:
Also, viel Spaß mit dem DEC, aber vorher :cheers:

Ich hab mich ja nicht über Dich geärgert, sondern über mich!

:cheers:

[Rackergen2]

Zitat:

Zitat von MaBuSE

Wir haben früher unsere Spicker und Briefchen in ROT13 verschlüsselt und konnten das fast in Echtzeit laut Lesen.

Was? Das find ich toll... Kannst du mir zeigen, wo ich ROT13 finde? ;)

[sCrAPt]

www.rot13.de ...

http://og4all.de/s, sCrAPt

[Rackergen2]

fein fein...

[sCrAPt]

fnt zve jraa qh syvrfraq Ebg68+Ebg0 xnaafg ;)

http://og4all.de/s, sCrAPt

[MaBuSE]

Zitat:

Zitat von sCrAPt

fnt zve jraa qh syvrfraq Ebg68+Ebg0 xnaafg ;)

http://og4all.de/s, sCrAPt

Mitlerweile kann ich das nicht mehr so gut. :-(

Als Stütze benutze ich heutzutage eine kleine Matrix
(aus den oberen Buchstaben werden die unteren und umgekert)

ABCDEFGHIJKLM
NOPQRSTUVWXYZ

01234
56789

----------------

Folgende Verschlüsselung ist auch nicht schlecht.
Damit dürften wohl unsere ausländischen Freunde die meisten Probleme haben.

Zitat:

Gmäeß eneir Sutide eneir elgnihcesn Uvinisterät ist es nchit witihcg, in wlecehr Rneflogheie die Bstachuebn in eneim Wrot snid, das ezniige, was wcthiig ist, ist dsas der estre und der leztte Bstabchue an der ritihcegn Pstoiion sehten. Der Rset knan ttoaelr Bsinöldn sien, todzterm knan man ihn onhe Pemoblre lseen. Das legit daarn, dsas wir nihct jeedn Bstachuebn enzelin leesn, snderon das Wrot als Gnaezs.

[Aenogym]

Zitat:

Zitat:

Gmäeß eneir Sutide eneir elgnihcesn Uvinisterät ist es nchit witihcg, in wlecehr Rneflogheie die Bstachuebn in eneim Wrot snid, das ezniige, was wcthiig ist, ist dsas der estre und der leztte Bstabchue an der ritihcegn Pstoiion sehten. Der Rset knan ttoaelr Bsinöldn sien, todzterm knan man ihn onhe Pemoblre lseen. Das legit daarn, dsas wir nihct jeedn Bstachuebn enzelin leesn, snderon das Wrot als Gnaezs.

also das finde ich ja geil. vor allem, weil man es wirklich fließend lesen kann. ist ja hammer :mrgreen:

edit: das pack ich mir gleich in meine signatur (zumindest in dem forum, wo die so lang sein dürfen :D )

Aenogym

[Luckie]

Erstens ist das schon ein alter Hut und zweitens hat das nun gar nichts mehr mit Verschlüsselung zu tun. :warn:

[MaBuSE]

Zitat:

Zitat von Luckie

Erstens ist das schon ein alter Hut und zweitens hat das nun gar nichts mehr mit Verschlüsselung zu tun. :warn:

1. Hast Du Recht, das ist ein alter Hut.
und
2. doch, das ist eine Verschlüsselung!!! Und zwar eine "Transposition". :warn:

Das Scherzprogramm (1. Beitrag in diesem Thread) ist auch eine "Transposition" !!!

Im Wikipedia steht:

Verschlüsselung nennt man den Vorgang, bei dem ein Klartext mit Hilfe eines Verschlüsselungsverfahrens (Algorithmus) in einen Geheimtext umgewandelt wird.

Den umgekehrten Vorgang nennt man Entschlüsselung.

Man unterscheidet 4 Verschlüsselungsarten:

Transposition
Bei einer Transposition werden die Zeichen untereinander vertauscht. Zum Beispiel wenn man ein Text rückwärts schreibt oder jeden 2. mit jedem 5. Buchstaben vertauscht.

Substitution
Bei der Substitution werden Zeichen durch andere ersetzt. Zum Beispiel können alle Buchstaben durch Zahlen ersetzt werden.

Chiffrierung
Bei der Chiffrierung werden alle Zeichen einzeln anhand eines Verschlüsselungsverfahrens verschlüsselt. Beispiel hierfür ist die Cesar Verschlüsselung bei welcher ein Zeichen aus dem Alphabet als Schlüssel verwendet wird und anhand der Position des Buchstabens im Alphabet die Buchstaben des Klartextes zyklisch verschoben werden.

Codierung
Beim Codieren werden alle Zeichen eines Zeichenvorrats einem anderen Zeichenvorrat zugeordnet. Ein Beispiel hierfür ist die codierung aller Alphabetischen Zeichen in den ASCII Code.

[edit]hier der Link zum Wikipedia: http://de.wikipedia.org/wiki/Verschl%FCsselung[/edit]
[edit]noch ein Link: http://de.wikipedia.org/wiki/Kategorie:Kryptologie[/edit]

[TeronG]

Zitat:

Zitat von dizzy

[ot].... Postet aber jemand mal ein scherzhaft gemeintes Programm, so hagelt es ernsthafte Verbesserungsvorschläge noch und nöcher :lol: ....[/ot]

Jo ... der witz ist wohl voll in die Hose gegangen .. aber wenigstens hab ich nun ne recht ordentliche Verschlüsselung in meinen Proggies :-D
Weiter so Jungs :wink:

[papillon03]

Für Fetischisten der Objectorientierung :zwinker: habe ich versucht, das ganze mal in zwei Klassen zu Kapseln:

Delphi-Quellcode:

unit rc4;

// Code written by Hagen ([url]http://www.delphipraxis.net/topic12881,15.html[/url])
// unit created by maximov 29.07.2004
// Encapsulation in Class papillon03 5.11.2004

interface

type

TCryptBytes = array[Byte] of Byte;

TtrRC4Crypt = class(TObject)
private
  FcBytes: TCryptBytes;
  FcI, FcJ: Byte;
public
  constructor Create;
  destructor Destroy; override;
  procedure Init(const Key: string);
  procedure CodeBytes(const Source; var Dest; Count: Integer);
  function  Code(const Value: string): string;
  function  CodeOnce(const Value, Password: String): string;
  procedure SelfEncryptByteArray;
  procedure Clear;
  property CryptBytes: TCryptBytes read FcBytes;
end;

TtrRC4Random = class(TObject)
private
  Frc4crypt: TtrRC4Crypt;
public
  constructor Create;
  destructor Destroy; override;
  function Random: Cardinal;
end;


implementation

type
  PByteArray = ^TByteArray;
  TByteArray = array[0..($FFFF shr 1)-1] of byte;

function TtrRC4Crypt.Code(const Value: string): string;
var
  Count: Integer;
begin
  Count := Length(Value);
  SetLength(Result, Count);
  CodeBytes(Value[1], Result[1], Count);
end;

function TtrRC4Crypt.CodeOnce(const Value, Password: string): string;
begin
  Init(Password);
  try
    Result := Code(Value);
  finally
    Clear;
  end;
end;


procedure TtrRC4Crypt.Init(const Key: String);
var
  r,s,t,k: Byte;
  u,l: Integer;
begin
  l := Length(Key);
  FcI := 0;
  FcJ := 0;
  for s := 0 to 255 do FcBytes[s] := s;
  r := 0;
  u := 0;
  for s := 0 to 255 do
  begin
    if u < l then k := PByteArray(Key)[u] else k := 0;
    Inc(u);
    if u >= l then u := 0;

    Inc(r, FcBytes[s] + k);
    t := FcBytes[s];
    FcBytes[s] := FcBytes[r];
    FcBytes[r] := t;
  end;
end;

procedure TtrRC4Crypt.CodeBytes(const Source; var Dest; Count: Integer);
var
  s: Integer;
  t: Byte;
begin
  for s := 0 to Count -1 do
  begin
    Inc(FcI);
    t := FcBytes[FcI];
    Inc(FcJ, t);
    FcBytes[FcI] := FcBytes[FcJ];
    FcBytes[FcJ] := t;
    Inc(t, FcBytes[FcI]);
    TByteArray(Dest)[s] := TByteArray(Source)[s] xor FcBytes[t];
  end;
end;

procedure TtrRC4Crypt.Clear;
begin
  FillChar(FcBytes, SizeOf(FcBytes), 0);
  FcI := 0;
  FcJ := 0;
end;

constructor TtrRC4Crypt.Create;
begin
end;

destructor TtrRC4Crypt.Destroy;
begin
  Clear;
  inherited;
end;

procedure TtrRC4Crypt.SelfEncryptByteArray;
begin
  CodeBytes(FcBytes, FcBytes, SizeOf(FcBytes));
end;

constructor TtrRC4Random.Create;
begin
  inherited;
  Frc4crypt := TtrRC4Crypt.Create;
  with Frc4crypt do begin
    Init('5C103319-9C6F-4F88-BBDC-752779958047');
  end;
end;

destructor TtrRC4Random.Destroy;
begin
  Frc4crypt.Free;
  inherited;
end;

function TtrRC4Random.Random: Cardinal;
type
  PRC4Cast = ^TRC4Cast;
  TRC4Cast = record
    FirstSBOX: Cardinal;
  end;

begin
// verschlüssele die dynamsiche SBOX von RC4Random.D mit sich selber und gebe die 4 ersten Bytes
// als Zufallswert zurück !!
  with Frc4crypt do begin
    SelfEncryptByteArray;
    Result := PRC4Cast(@CryptBytes).FirstSBOX;
  end;
end;

end.

Natürlich ergibt sich dadurch ein gewisser Overhead, ich hoffe aber trotzdem was beigetragen zu haben. Insbesondere bei Random wäre super, wenn jemand die Gleichwertigkeit verifizieren könnte.

Ciao Papillon03

[maximov]

Zitat:

Zitat von papillon03

....
Natürlich ergibt sich dadurch ein gewisser Overhead, ich hoffe aber trotzdem was beigetragen zu haben. Insbesondere bei Random wäre super, wenn jemand die Gleichwertigkeit verifizieren könnte.

Ciao Papillon03

Ich hatte die random funktion tatsächlich mal getestet: Sie liefert sehr gute ergebnisse, auch wenn sie wesentlich langsamer als delphi.random ist. Die durchschnittswerte waren bei beiden funktionen sehr nah an 0.5, also genau da wo sie sein sollten 8)

PS: Willkommen in der DP :dp:

[mr47]

Man kann einen Text auch in einzelne Zeichen zerlegen und dann in AscII-Code umwandeln. Danach noch evt den Ascii-Code mit einer Formel (z.B.: Ascii-code*2+100) oder so bearbeiten. Zum entschlüsseln dann einfach Codiertes-Zeichen-100:2. Allerdings muss man zwischen jedes Zeichen ein Trennzeichen z.B: ; setzen. So hab ich des mal gemacht. Des funktioniert einwandfrei.

Was meint ihr, wie sicher das ist??

//edit: Vpu xnaa nhpu Ebg68!

[Luckie]

Nicht sehr sicher. Eine einfache Häufigkeitsanalyse sollte reichen, um den Code zu knacken.

[negaH]

Zitat:

Die durchschnittswerte waren bei beiden funktionen sehr nah an 0.5, also genau da wo sie sein sollten

Tja die Statistik mit den Durchschnittswerten !?

Nachfolgende Random Funktion ist sogar noch besser und schneller und liefert den Perfekten Durchschnitt von 0.5 !!

Delphi-Quellcode:

var
  Counter: Byte = 0;

function BestRandom: Boolean;
begin
  Result := Odd(Counter);
  Inc(Counter);
end;

Schön, als Demonstration zeigt dies das zur Beurteilung eines Zufallsgenerators eben nicht nur eine Durchschnittsstatistik ausreicht.

Bei der grafischen Analyse der LCG Algorithmen == Delphi Random(), wird man feststellen das sich in den grafischen Bildern starke sich wiederholende Artefakte ergeben. D.h. LCG's sind keineswegs gute Zufallsgeneratoren, sie reichen gerademal für Statistische Berechnungen aus.
Im Gegensatz dazu würde obige RC4 basierte Funktion ein grafisches Bild ergeben das ein Weises Rauschen darstellt, also absolut keine Regelmäßigkeiten enthält.

Gruß Hagen

[Luckie]

Ich muss den Thread noch mal hervor holen, weil ich da jetzt ein kleines Verständnisproblem habe. Bei den Verschlüsselungsalgorithmen ist immer wieder vom Seed die Rede. Was ist das eigentlich, die 'Saat'?

Dann habe ich hier die einfache Variante von Hagens RC4 Implementierung. Wo ist da der/die Seed?

Und an welcher Stelle sieht man, dass es eine 2048 Bit tiefe Verschlüsselung ist?

Dann zeigt Hagen hier wie man den RC4 Algorithmus zu einen Zufallsgenerator umfunktionieren kann. Wo und wie brauche ich das, um mit RC4 ein sicheres Verschlüsselungsprogramm zu schreiben?

Ist es ein Schwachpunkt, wenn ich von den zu verschlüsselnden Daten einen Hash bilde, die Daten verschlüssele und den Hash mit zu den Daten lege, um nach dem Entschlüsseln überprüfen zu können, ob die Daten korrekt entschlüsselt wurden?

Ich überlege nämlich, ob ich mit dem RC4 Algorithmus ein einfaches, kleines nonVCL Verschlüsselungsprogramm schreibe.

[MaBuSE]

Zitat:

Zitat von Luckie

Ich muss den Thread noch mal hervor holen, weil ich da jetzt ein kleines Verständnisproblem habe. Bei den Verschlüsselungsalgorithmen ist immer wieder vom Seed die Rede. Was ist das eigentlich, die 'Saat'?

Dann habe ich hier die einfache Variante von Hagens RC4 Implementierung. Wo ist da der/die Seed?

Ich zitiere mal den Beitrag http://www.delphipraxis.net/internal...=211572#211572

Das ist eine Delphi Unit von maximov die den RC4 von Hagen kapselt.

Code:

...
[b]procedure [/b]RC4Seed([b]const [/b]Seed: [b]String[/b]); 
[b]begin [/b]
  RC4Init(RC4Random, [color=#ff0000][b]Seed[/b][/color]); 
[b]end[/b]; 
...
[b]initialization [/b]
  RC4Seed([color=#00008b]'5C103319-9C6F-4F88-BBDC-752779958047'[/color]); 
[b]end[/b].

[Luckie]

Schön, den beitrag kenne ich, aber leider wirft ja gerade der Code die Fragen auf. :roll:

[Sharky]

Zitat:

Zitat von Luckie

... Was ist das eigentlich, die 'Saat'?

Hai Michael,
meinst Du Saat oder Salt?

[Luckie]

Ich habe den englischen Asudruck Seed der immer wieder auftaucht einfach übersetzt, um schon male inen Hinweis zu bekommen. Das ergab das deutsche Wort Saat. hat mir aber auch nicht viel geholfen.

[Sharky]

Hai,

der Seed ist der Startzahl die verwendet wird wenn eine Folge von Zufallszahlen erzeugt wird.
Wenn Du also immer den selben Seed setzt bekommst Du immer die selbe Folge von Zufalszahlen. In Delphi wird dies "umgangen" in dem Du Randomize aufrufst und hierbei der Seed auf eine Zahl gesetzt wird die sich (glaube ich) aus der Systemzeit berechnet.

[Luckie]

Das heißt, verwende ich beim ver- und entschlüsseln einen unterschiedlichen Seed, dann werden die Daten nicht korrekt entschlüsselt. Das heißt wiederum, der Seed entspricht dem Passwort oder?

[Sharky]

Zitat:

Zitat von Luckie

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

Uff... so genau bin ich da auch nicht eingestiegen ;-)

Aber das Passwort zu verwenden macht eigentich keinen Sinn. Denn wenn dieses geknackt wurde wäre ja auch der Seed bekannt.
Bei einer Verschlüsselung verwendest Du ja neben dem Passwort noch einen Salt. Über diesen zusammengesetzten Schlüssel bildest Du dan eine Einweg Hashfunktion und mit Ergebniss verschlüsselst Du die Daten. Der Salt muss dafür natürlich unverschlüsselt in der Datei mit abgelegt werden. Denn Seed (Startwert) den Du benötigst um einen Salt (Zufallswert) erzeugen zu können legst Du in deinem Programm fest (z.B. eine GUID).

[Sharky]

Zitat:

Zitat von Sharky

Zitat:

Zitat von Luckie

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

Uff... so genau bin ich da auch nicht eingestiegen ;-)

Aber das Passwort zu verwenden macht eigentich keinen Sinn. Denn wenn dieses geknackt wurde wäre ja auch der Seed bekannt.
Bei einer Verschlüsselung verwendest Du ja neben dem Passwort noch einen Salt. Über diesen zusammengesetzten Schlüssel bildest Du dan eine Einweg Hashfunktion und mit Ergebniss verschlüsselst Du die Daten. Der Salt muss dafür [d]natürlich unverschlüsselt[/d] in der Datei mit abgelegt werden. Denn Seed (Startwert) den Du benötigst um einen Salt (Zufallswert) erzeugen zu können legst Du in deinem Programm fest (z.B. eine GUID).

[edit]Das mit dem unverschlüsselt war natürlich unsinn[/edit]
Ich habe hier noch einen Text von Hagen in dem er mir das einal erklärt hat. Ich hoffe er hat nichts dagegen wenn ich ihn hier post :oops:

Zitat:

Zitat von negaH

Du verschlüsselst eine Datei und dabei gibt es wichtige Punkte wie man dies macht
1.) das Passwort muß in einen Sessionkey umgewandelt werden. Dazu wird das Passwort und ein Zufallserzeugter Salt benutzt. Beide Werte werden verbunden, und zwar Salt und dann Passwort. Der Salt sollte mindestens 128 Bit groß sein. Nun wird über diesen binären Wert eine Hashfunktion angewendet. Diese Hashfunktion sollte eine MGF = Mask Generation Funktion sein. Dazu wird eben NICHT einfach nur ein Hash über Salt || Passwort erzeugt, sondern die hashfunktion wird mehrmalig über sich selber angewendet und mit einem Zähler versehen. Also so ähnlich wie beim S/KEY OTP Verfahren.
2.) nun haben wir unseren Sessionkey der nur mit Hilfe des relativ kurzen Passwortes errechenbar ist. Der Salt stellt sicher das ein Angreifer nicht so ohne weiteres eine Dictionary Attacke durchführen kann. Desweiteren Randomisiert der Salt auch den erzeugten Sessionkey, d.h. mit gleichem Passwort wird aber immer ein unterschiedlicher Salt benutzt und somit immer ein unterschiedlicher Sessionkey produziert. Ergo auch die Verschlüsselung der gleichen Inhalte unterscheidet sich, sogar ohne expliziten InitVecter des Ciphers.
3.) nun, es wird nun ein zweiter Salt_2 benötigt, ebenfalls 128 Bit lang. Dieser Salt dient zur Randomisierung der Verschlüsselung. Dazu wird wiederum aus Hash(Salt_2 || Sessionkey) ein Hash produziert. Wie du siehst benutzen wir unseren Sessionkey und einen zweiten Salt dazu. Der erzeugte Hashwert + Salt_2 wird nun VOR die Message gehangen, also Data := Salt_2 || Hash(Salt_2 || Sessionkey) || Message, anschließend wird Data verschlüsselt. Da Salt_2 zufällig ist wird Hash(Salt_2 || Sessionkey) ebenfalls zufällig und die die Message zudem mit Zufallsdaten expandiert.
3.) nachdem so die Nachricht verschlüsselt wurde, muss natürlich noch der 1. Salt davor gehangen werden. Dies benötigen wir damit bei der Entschlüsselung auch der Sessionkey reproduiziert werden kann.

Nochmal als Formel:
Ciphertext = Ck(Key, Plaintext) ist die verschlüsselung.
Digest = MGF(Data, Index) ist eine Mask Generation Funktion mit hilfe eines hashs.
Salt_Key = > 128 Bit Zufallswert für den Sessionkey
Salt_Msg = > 128 Bit Zufallswert für die Nachricht
|| = Konkatenation, Zusammenhängen von binären Daten

[MaBuSE]

Zitat:

Zitat von Luckie

Das heißt, verwende ich beim ver- und entschlüsseln einen unterschiedlichen Seed, dann werden die Daten nicht korrekt entschlüsselt. Das heißt wiederum, der Seed entspricht dem Passwort oder?

Im Prinzip ja:

Wie schon in dem gutem altem Turbo Pascal, kannst Du bei den Zufallszahlen auch den Seed setzten.
Früher hatte ich mal so verschlüsselt ;-)

@Hagen: Bitte nicht hauen ;-) (Ich bin mir ziemlich sicher, das diese Verschlüsselung nicht sicher ist)

• [edit]
  Ich wusste doch, das Hagen dazu was geschieben hat, war sogar in diesem Thread.
  [equote="Hagen schieb in http://www.delphipraxis.net/internal...=207146#207146 "]Die Verwendung von Random() in der Kryptographie scheint meiner Meinung nach die meist empfohlene und die schwachsinnigste Idee unter Delphi Programmierern zu sein.[/equote]
  Also nicht benutzen, das Beispiel dient nur zur Demostration was der Seed ist. (Initialisierungswert eines Zahlengenerators)
  Und das der Seed durchaus auch das Passwort sein kann.
  [/edit]

Delphi-Quellcode:

...
procedure TForm1.Button1Click(Sender: TObject);
var
  i: Integer;
  s: string;
begin
  s := 'Test';

  // Verschlüsseln
  RandSeed := 5;
  for i := 1 to length(s) do
  begin
    s[i] := chr(ord(s[i]) XOR Round(random(255)));
  end;

  // Entschlüseln (Copy und Paste (ohne Änderung) von Verschlüsseln)
  RandSeed := 5;
  for i := 1 to length(s) do
  begin
    s[i] := chr(ord(s[i]) XOR Round(random(255)));
  end;

  // string ausgeben (Kontrolle)
  Caption := s;
end;
...

Aber in der Hilfe von Delphi steht:

Zitat:

Um den Zufallszahlengenerator zu initialisieren, rufen Sie Randomize einmal auf oder weisen der Variable RandSeed vor dem Aufruf von Random einen Wert zu.

Hinweis: Die Implementierung der Funktion Random kann sich bei einer anderen Compiler-Version ändern. Sie sollten Random daher nicht für Verschlüsselungen oder andere Einsatzbereiche verwenden, in denen reproduzierbare Pseudozufallszahlen benötigt werden.

Falls Du das mal Testen willst, hier das Ganze als Funktion:

Delphi-Quellcode:

function MachWas(s: string; Schluessel: LongInt): string;
var
  i: Integer;
begin
  RandSeed := Schluessel;
  for i := 1 to length(s) do
  begin
    s[i] := chr(ord(s[i]) XOR Round(random(255)));
  end;
  Result := s;
end;

[MaBuSE]

Zitat:

Zitat von Sharky

Zitat:

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. :thumb: Jetzt weiß ich, wie das alles zusammenspielt.

[Sharky]

Zitat:

Zitat von Luckie

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

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

[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. :gruebel:

Was mache ich falsch?

Gruß Jörg

[MaBuSE]

Zitat:

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 :mrgreen:

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:

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

[IceTube]

hä? :cyclops:

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

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! :wink: