CNV-Encryption(Verschlüsselung)

[CNV]

Hi, hatte vor ein paar Tagen eine Idee für einen neuen Verschlüsselungsalgorhythmus.
Es ist meine eigene Entwicklung und wäre um Feedback, bzw Verbesserungsvorschläge dankbar. Das Programm befindet sich noch ziemlich am Anfang.

Funktionen:
-Text entschlüsseln und verschlüsseln
-Dateien verschlüsseln und entschlüsseln.

Kurze Erläuterung der Funktionsweise:

Zuerst bestimmt man ein Passwort, aus welchem das Programm ein Zahlenfolge erstellt, die man NICHT zurückrechnen kann. Anschliessend wird ein "Keyfile"(so nenn ich es bis jetzt, falls jemand eine bessere Idee hat bitte Posten) ausgewählt. Mittels diesem wird verschlüsselt und entschlüsselt, es wird dabei jedoch nicht verändert. Der Empfänger, bzw der der es Entshclüsseln will, muss jedcoh EXAKT die gleiche Keyfile haben(der Name ist glaub ich nicht Massgebend). Ich hoffe dass durch diese Kombination ein Bruteforce angriff wirkungslos ist. Mit ein und dem selben Keyfile und verschiedenen Passwörtern, gibt es sehr sehr viele unterschiedliche ergebnisse, beim Verschlüsselten Text. Falls das Passwort bekannt sein würde, und man jedoch das Keyfile nicht hat/kennt, kann man so den text nicht Rekonstruieren. Häuffigkeitsanalysen sind Sinnlos, da es keinem "Muster" folgt.

Wenn jemand spass daran hat, und versucht die Verschlüsselung zu kancken, bzw es gelingt ihm/ihr, so lasst es mich doch bitte wissen, damit ich mein Programm (hoffentlich) dem entsprechend ausbauen kann. Mir persönlich ist jedoch keine Idee gekommen, wie man es Knacken könnte. habe aber auch nicht viel Ahnung von Kryptographie.

Bisher bekannte Fehler:
- Wenn ein Falscher Text zum entschlüsseln eingegeben wird, d.h. wenn er nicht dem "muster" entspricht, so gibt es eine Fehlermeldung, die noch nicht angepasst wurde.


Generelle Info:
Setup: Keins
Dateien: Eine
Veränderungen am System: Keine(Ausgenommen der Speicherplatz ;))
Internetverbindung: Keine
Grösse: 416 KB
Downloadgrösse: 171Kbyte (Rar-Archiv)
Version: 1.1.1

Anmerkungen:
-Design wird noch verbessert werden


Verschlüsselungsbeispiel:
Passwort:

Code:

www.delphipraxis.net

Text

Code:

Freeware:
CNV-Encryption
Autor: Invulnerabilis/CNV
Typ:Verschlüsselungssoftware

Versucht es doch aus, und entschlüsselt es, keyfile im anhang.

Verschlüsselt:

Code:

08A0E40DE0850D80C90E70850AE07C0830AF0BA0C20730930D10CC0E80E20E00D809608F0E107507F06E0EE0D90D8
0DA0680400970DC0EA0E30D80DB0AA0920D70D40D10990DE0B60A10B206E0B80510730B90F20DE0A80C20D40E2093
0D90D40E11520EC0930D10DE0D70E10CF0D70E20E40CF0E30DC08E0920DE08306B0720370C30D30E60D50DA0CF0AE
0C20920AE0E308F0C90E10D90D108C0D00B80A009A0900950DC0910400DE0B70D90DF0D20DD0D11410DC0EC0DA0DF
0DC0920BB0E204C0820D00930E70AF0CE0D10CA0830D80B60810CD0E10D80D00BC0E00A0

Mirror:
http://dl2.uploadgalaxy.com/files/58...ojekt.rar.html

Changelog:
13.8.06 - V 1.1.1
-Kleiner Bugfix: Entschlüsselter Text wurde nicht mehr angezeigt.


13.8.06 - V 1.1.0
- Datei-Modus hinzuegfügt
- Tabulatorreihenfolge überarbeitet
- div. Autofokus dazugefügt


12.8.06 - V 1.0.4
- Design übersichtlicher gemacht(Hoffe ich zumindest)
- div. Fehlermeldungen hinzugefügt.

12.8.06 - V 1.0.3
- Tabulatorreihenfolge hinzugefügt. (Falls änderungswünsce bestehen, bitte posten.
- Fehler in der Verschlüsselung wenn man mehr als ein mal auf "Generate Key" gedrückt hat.

Anmerkung:
Verschlüsselung von Dateien erfolgt auf eigene Gefahr, immer in eine Andere Datei speichern.

[edit=Admin]Zeilenumbrüche eingefügt. Mfg, Daniel[/edit]
Beim Entschlüsseln müsst ihr halt die gut gemeinten Zeilenumbrüche wieder Entfernen, sosnt funktioniert es nicht!

[Meflin]

Aua... mach da mal bitte in dein "verschlüsselt" einen Zeilenumbruch (Leerzeichen) rein :?

und btw: Herzlich wilkommen in der DP :party: :dp:

[Matze]

Hi,

ohne Algorithmus (Source-Code) wird man nicht sehr viel über die Sicherheit aussagen können. ;)

Auch von mir herzlich willkommen!

[Dax]

Herzlich willkommen in der DP :)

Dem, was Matze sagt, muss ich mich anschließen. Dein Konzept ist im Moment Security through Obscurity - die Sicherheit deines Algorithmus beruht auf der Unbekannt dessen. Das kann unter Umständen mehr Probleme als Vorteile mit sich bringen..

[CNV]

Danke ;-)
hier der Code, viel spass beim anschauen. habe keine Comments drin. Teilweise ist es ein wenig unübersichtlich(nicht kommentiert)
An manchen Stellen werde ich den Code noch optimieren, und überflüssige kommentare löschen.

Delphi-Quellcode:

function primzerleg(zahl:integer):string;
var
prims:array[0..30] of integer;
check,rest,i,teiler:integer;
strea,dat,src:string;
begin
prims[0]:=2;
prims[1]:=3;
prims[2]:=5;
prims[3]:=7;
prims[4]:=11;
prims[5]:=13;
prims[6]:=17;
prims[7]:=19;
prims[8]:=23;
prims[9]:=29;
prims[10]:=31;
prims[11]:=37;
prims[12]:=41;
prims[13]:=43;
prims[14]:=47;
prims[15]:=53;
prims[16]:=59;
prims[17]:=61;
prims[18]:=67;
prims[19]:=71;
prims[20]:=73;
prims[21]:=79;
prims[22]:=83;
prims[23]:=89;
prims[24]:=97;
prims[25]:=101;
prims[26]:=103;
prims[27]:=107;
prims[28]:=109;
prims[29]:=113;
prims[30]:=127;

result:='';
i:=0;
check:=0;
rest:=0;
repeat
   rest:= zahl mod prims[i];
   if rest = 0 then begin
      zahl:=zahl div prims[i];
      result:=result+inttostr(prims[i]);
      if zahl = 1 then begin
         check:=1;
      end;
   end
   else begin
      i:=i+1;
   end;
until check = 1;
end;
procedure TMain.Generate_KeyClick(Sender: TObject);
var
a,i:integer;
x,add:string;
begin
if KeyEingabe.Text<>'' then begin
checksum.Clear;
 for I := 1 to Length(KeyEingabe.Text) do begin
    a:=ORD(KeyEingabe.text[i]);
    ADD:=primzerleg(a);
    checksum.Text:=checksum.Text+(ADD);
 end;
 Button1.SetFocus;
 end
 else begin
 Application.MessageBox('Please Enter A Password and click on "Generate Key"','Error',MB_OK + MB_ICONWARNING);
 keyEingabe.SetFocus;
 end;
end;

procedure TMain.Button1Click(Sender: TObject);
begin
if opendialog1.Execute then begin
   kfp.Text:=opendialog1.FileName;
   Encrypt.SetFocus;
end;
end;

procedure TMain.FormCreate(Sender: TObject);
begin
Main.Width:=1024;
Encrypt.Clear;
theresult.Clear;
decrypt.Clear;
end;

procedure TMain.StartClick(Sender: TObject);
var Source,Data,Stream:TMemoryStream;
var resz,Str:String;
var Y,B:Byte;
var z,drei,zw,res,dl,i,wait,x:integer;
var mem:TMemo;
begin
if checksum.Text='' then begin
   Application.MessageBox('Please Enter A Password and click on "Generate Key"','Error',MB_OK + MB_ICONWARNING);
   Keyeingabe.SetFocus;
end
else begin
   if kfp.Text='' then begin
      Application.MessageBox('Please Select a Keyfile!','Error',MB_OK + MB_ICONWARNING);
      Button1.SetFocus;
   end
      else begin
         theresult.Clear;
         Stream:=TMemoryStream.Create;
         Stream.LoadFromFile(kfp.Text);
         try
            i:=1;
            dl:=1;
            wait:=0;
            x:=0;
            z:=0;
            if text_mode.Checked then begin
               if encrypt.Text='' then begin
                  Application.MessageBox('Please enter a Text to encrypt it!','Error',MB_OK + MB_ICONWARNING);
                  encrypt.SetFocus;
               end
               else begin
                  While i<=Length(Encrypt.Text) do begin
                     repeat
                        Stream.ReadBuffer(B,SizeOf(B));
                        if wait = 0 then begin
                           i:=i+1;
                           res:=B+ORD(Encrypt.text[i-1]);
                           theresult.Text:=theresult.Text+IntToHex(res,3);
                           if x*2 <= length(Checksum.Text)-2 then begin
                              x:=x+1;
                              wait:=StrToInt(checksum.Text[x*2])+StrToInt(checksum.Text[x*2-1]);
                           end
                           else begin
                              x:=1;
                              wait:=StrToInt(checksum.Text[x*2])+StrToInt(checksum.Text[x*2-1]);
                           end;
                        end
                        else begin
                           wait:=wait-1;
                        end;
                        if Stream.Position>=Stream.Size then Stream.Position:=0
                     until wait > 0;
                  end;
               end;
            end
            else if file_mode.Checked then begin
               if opendialog1.FileName<>'' then begin
                  if savedialog1.execute then begin
                     Source:=TMemoryStream.Create;
                     Source.LoadFromFile(Encrypt.Text);
                     Data:=TMemoryStream.Create;
                     progressbar1.Visible:=true;
                     progressbar1.Min:=0;
                     progressbar1.Max:=Source.Size;
                     Mem:=TMemo.Create(Main);
                     While source.Position<source.Size do begin
                        Stream.Read(B,SizeOf(B));
                        progressbar1.Position:=Source.Position;
                        Source.Read(Y,SizeOF(Y));
                        res:=B+Y;
                        str:=IntToHex(res,3);
                        For i:=1 to 3 do begin
                           res:=Ord(str[i]);
                           Data.Write(res,1);
                        end;
                        if x*2 <= length(Checksum.Text)-2 then begin
                           x:=x+1;
                           wait:=StrToInt(checksum.Text[x*2])+StrToInt(checksum.Text[x*2-1]);
                        end
                        else begin
                           x:=1;
                           wait:=StrToInt(checksum.Text[x*2])+StrToInt(checksum.Text[x*2-1]);
                        end;
                        if Stream.Position>=Stream.Size-wait then begin
                           Stream.Position:=0;
                        end
                        else begin
                           Stream.Position:=Stream.Position+wait;
                        end;
                     end;
                     Data.SaveToFile(savedialog1.FileName);
                     theresult.Text:=Savedialog1.FileName;
                     Source.Free;
                  end;
               end
               else begin
                  Application.MessageBox('Please select a File which you want to encrypt!','Error',MB_OK + MB_ICONWARNING);
                  File_Search.SetFocus;
               end;
            end;
         finally
         Stream.Free;
         progressbar1.Visible:=false;
      end;
   end;
end;
end;
procedure TMain.dcrptClick(Sender: TObject);
var Source,Data,Stream:TFileStream;
var resz,Str:String;
var Y,B:Byte;
var hex,z,zw,res,dl,i,wait,x:integer;
begin
if checksum.Text='' then begin
   Application.MessageBox('Please Enter A Password and click on "Generate Key"','Error',MB_OK + MB_ICONWARNING);
   Keyeingabe.SetFocus;
end
else begin
   if kfp.Text='' then begin
      Application.MessageBox('Please Select a Keyfile!','Error',MB_OK + MB_ICONWARNING);
      Button1.SetFocus;
   end
   else begin
      if decrypt.Text='' then begin
         Application.MessageBox('Please enter a Text to decrypt it!','Error',MB_OK + MB_ICONWARNING)
      end
      else begin
         theresult.Clear;
         Stream:=TFileStream.Create(kfp.text,fmOpenRead);
         try
            i:=1;
            wait:=0;
            x:=0;
            if text_mode.Checked then begin
               if decrypt.Text='' then begin
                  Application.MessageBox('Please enter a Text to encrypt it!','Error',MB_OK + MB_ICONWARNING);
                  encrypt.SetFocus;
               end
               else begin
                  While i<=(Length(Decrypt.Text)div 3) do begin
                     repeat
                        Stream.ReadBuffer(B,SizeOf(B));
                        if wait = 0 then begin
                           z:=i*3;
                           Str:='$'+Decrypt.text[z-2]+Decrypt.text[z-1]+Decrypt.text[z];
                           zw:=StrToInt(Str);
                           res:=zw-B;
                           i:=i+1;
                           theresult.Text:=theresult.Text+CHR(res);
                           if x*2 <= length(Checksum.Text)-2 then begin
                              x:=x+1;
                              wait:=StrToInt(checksum.Text[x*2])+StrToInt(checksum.Text[x*2-1]);
                           end
                           else begin
                              x:=1;
                              wait:=StrToInt(checksum.Text[x*2])+StrToInt(checksum.Text[x*2-1]);
                           end;
                        end
                        else begin
                           wait:=wait-1;
                        end;
                        if Stream.Position>=Stream.Size then Stream.Position:=0
                     until wait > 0;
                  end;
               end;
               end
               else if file_mode.Checked then begin
                  if opendialog1.FileName<>'' then begin
                     if savedialog1.Execute then begin
                        Data:=TFilestream.Create(savedialog1.FileName,fmcreate);
                        Source:=TFileStream.Create(decrypt.Text,fmOpenRead);
                        progressbar1.Visible:=true;
                        progressbar1.Min:=0;
                        progressbar1.Max:=Source.Size;
                        Data.Position:=0;
                        Source.Position:=0;
                        stream.Position:=0;
                        While source.Position<source.Size do begin
                           Stream.Read(B,SizeOf(B));
                           progressbar1.Position:=Source.Position;
                           resz:='$';
                           For I:= 1 to 3 do begin
                              Source.Read(Y,1);
                              resz:=resz+CHR(Y);
                           end;
                           Y:=StrToInt(resz);
                           res:=Y-B;
                           resz:=IntToHex(res,2);
                           resz:='$'+resz;
                           Data.Write(res,1);
                           if x*2 <= length(Checksum.Text)-2 then begin
                              x:=x+1;
                              wait:=StrToInt(checksum.Text[x*2])+StrToInt(checksum.Text[x*2-1]);
                           end
                           else begin
                              x:=1;
                              wait:=StrToInt(checksum.Text[x*2])+StrToInt(checksum.Text[x*2-1]);
                           end;
                           if Stream.Position>=Stream.Size-wait then begin
                              Stream.Position:=0
                           end
                           else begin
                              Stream.Position:=Stream.Position+wait;
                           end;
                        end;
                     end;
                  end;
                  theresult.Text:=Savedialog1.FileName;
               end;
            finally
            Stream.Free;
            Data.Free;
            Source.Free;
            progressbar1.Visible:=false;
         end;
      end;
   end;
end;
end;

[Dax]

Also... Wo soll ich anfangen?

Du hast eigentlich nichts anderes gemacht, als das Rad neu zu erfinden. Was du hier hast, ist im Prinzip nichts anderes als eine Polyalphabetische Verschlüsselung. Deine Alphabete sind im Keyfile (jedes Zeichen entspricht dem Startpunkt eines Alphabets), und dein Schlüssel ist deine "Checksumme", die nichts anderes ist als eine Aneinanderreihung der Primfaktoren der Charcodes der Zeichen deines Schlüssels. Die Umwandlung der verschlüsselten Zeichen in ihre Hex-Repräsentation verdreifacht die Länge des verschlüsselten Outputs - und damit die Information darin. Zusätzliche Information, die ein Algorithmus in seinen Output einfügt, erleicht es Codeknackern immer, ihrer Arbeit nachzugehen (danke Hagen, hoffentlich stimmt das so ;)).

Die einzige größere Veränderung an der Vigenere-Chiffre, die du vorgenommen hast, ist das Ding namens "wait". Es bestimmt, welches das nächste "Ursprungsalphabet" wird, mit dem das nächste Zeichen verschlüsselt wird. Aber das ist auch nichts weiter als eine kleine Verwirrung des Schreibers. Sowohl Checksumme, Keyfile als auch "wait" sind nur Verwirrungen. Dein Verfahren kann man auch mit einem "normalen" Vigenere-Chiffre einsetzen, durch die geeignete Wahl eines Schlüssels. Wie man diesen aus dem in deinem Verfahren eingesetzten Schlüssel errechnet kann ich (noch) nicht genau sagen, aber es ist zweiffellos möglich.

Alles was hier steht ist natürlich wie immer Gewähr ;)

PS: Die Vigenere-Chiffre wurde 1854 geknackt.

[negaH]

Zitat:

Zuerst bestimmt man ein Passwort, aus welchem das Programm ein Zahlenfolge erstellt, die man NICHT zurückrechnen kann. Anschliessend wird ein "Keyfile"(so nenn ich es bis jetzt, falls jemand eine bessere Idee hat bitte Posten) ausgewählt. Mittels diesem wird verschlüsselt und entschlüsselt, es wird dabei jedoch nicht verändert. Der Empfänger, bzw der der es Entshclüsseln will, muss jedcoh EXAKT die gleiche Keyfile haben(der Name ist glaub ich nicht Massgebend). Ich hoffe dass durch diese Kombination ein Bruteforce angriff wirkungslos ist.

Nein ist er nicht. Das "Keyfile", was ich eher als "SBox" bezeichnen würde, muß mit der verschlüsselten Datei auch übertragen werden, dh. es muß mit den Daten über eine unsicherer Datenübertragung ausgetauscht werden. Wir können also davon ausgehen das ein Angreifer dieses "KeyFile" kennt. Somit hat der Angreifer alle notwendigen Informationen bis auf das benutzte Passwort.

Nun gehen wir gedanklich einen Angriff durch der so bei sicheren Algorithmen garaniert unmöglich zum 1 zu 1 knacken einer Nachricht führen wird.

Wir erzeugen ein "KeyFile" als ANgreifer das aus lauter NULLEN besteht, und senden das derjenigen Person die wir angreifen wollen. Dein Algo selber benutzt die Bytes in "KeyFile" als einfachster Additions-Offset auf die Daten. Dh. steht im KeyFile ein Byte mit Wert 0 so wird 0 auf das Datenbyte addiert um es zu verschlüsseln. Da wir mit 0 addieren ist unverschlüsselte Daten == verschlüsselte Daten.

Das heist, durch simples Austauschen des "KeyFiles" mit einem speziell präpariertem KeyFile wird deine Verschlüsselung absolut untauglich.

Probleme die ich mit deinem Verfahren sehe:

1.) generell arbeitest du mit viel zu vielen String-Umwandlungen. Aussser einem Performanceverlust hat das noch den Nachteil der unnötigen Nachrichtenexpansion. Dh. dein Algo. vergrößert die Nachrichtengröße in Bytes OHNE das daraus ein Vorteil in Punkto SIcherheit, Geschwindigkeit oder Useablity erwächst.


2.) Keyshedullung -> das ist das wo du das Passwort in deren Primzahlfaktoren zerlegst. Nette Idee aber mathematisch golt die Regel: Eine natürliche Zahl lässt sich EINEINDEUTIG über deren Primzahlzerlegung in Parimzahlpotenzen darstellen. Ergo: deine Primzahlfaktoren des umgewandelten Passwortes beschreibt eineindeutig dieses Paswort und kann somit sehr wohl in das Originalpoasswort zurückgerechnet werden.

Frage? Wie muß eine Funktion aussehen die bestimmte Eingangsdaten so auf Ausgangsdaten mappt das man nicht mehr von den Ausgangsdaten eineindeutig zu den Eingangsdaten zurückrechnen kann ?

Jede Funktion die ohne Informationsverlust eine Menge X auf Y abbilden kann, wird auch die Menge Y auf X zurück abbilden können. Exakt das macht dein Keyshedulling.

Du benötigst aber eine Funktion die einen Informationsverlust beim Mappen von X nach Y enthält. Das heist es gibt theoretisch zu einer Menge Y ganz viele verschiedene Mengen X'. Man kann also eine Menge Y auf eine Menge X' mappen aber es gibt viele verschiedene Mengen X' die ein gleiches Y erzeugen würden.
Durch den Informationsverlust beim Mappen entsteht also eine "Einweg-funktion", eine Funktion die eindeutig njur in eine Richtung mappen kann, und in der Gegenrichtung eben nicht mehr eindeutig mappen kann.
Solche Funktionen sind Hash-Funktionen, oder Secure One Way Function.

3.) deine kryptographisch relevante Funktion die du benutzt ist die ADDITION. Das ist bei weitem viel zu wenig komplex. Du benutzt keinerlei Substitutionen oder ähnlich annerkannte Grundalgos. sondern nutzt nur die einfachste TRansposition die es gibt. Transpositions-verschlüsselungen sind die am leichtesten brechbaren Cipher, zb. Cäsar.


Gruß Hagen

[CNV]

Danke für die Grosszügigen antworten. Nun zu ein paar Pukten kann ich shcon mal eine Antwort geben.

Zitat:

2.) Keyshedullung -> das ist das wo du das Passwort in deren Primzahlfaktoren zerlegst. Nette Idee aber mathematisch golt die Regel: Eine natürliche Zahl lässt sich EINEINDEUTIG über deren Primzahlzerlegung in Parimzahlpotenzen darstellen. Ergo: deine Primzahlfaktoren des umgewandelten Passwortes beschreibt eineindeutig dieses Paswort und kann somit sehr wohl in das Originalpoasswort zurückgerechnet werden.

Klar kan man dies zurückrechnen, ich meinte nicht dass du kannst es aus der "checksum" nicht zurückrechnen kannst. Ich ging nur von der Annahme aus, dass man nur die Keyfile und das verschlüsselte File/text hat, denn dann brauchst du das Passwort. Zudem wird wait immer aus 2 ziffern die nebeneinander stehen berechnet, was den Rückschluss auf die Ursprüngliche "Checksum" erschwert. jedoch werde ich das sowieso noch ändern, denn wenn man nur einen teil des passworts hat, d-h- den vorderen teil, wird schon mal ein Teil des Textes/der datei richtig entshclüsselt.

Zitat:

Wir können also davon ausgehen das ein Angreifer dieses "KeyFile" kennt. Somit hat der Angreifer alle notwendigen Informationen bis auf das benutzte Passwort.

Nun, was bringt dir die Keyfile ohne das Passwort? Dem Text könntest du je nach Keyfile in irgendetwas zurückrechnen, was einen Sinn ergiebt. Solange der text gleich lang bleibt.
Jedoch bin ich von der Annahme ausgegangen, dass man sich das Keyfile nicht per Email oder Internet übergibt. Wenn du das keyfile nicht hast, hast du wohl nur noch sehr wenig Chancen auf den Ursprungstext zurück zu kommen. Des weiteren kannst du das passwort ruhig ugeschützt per Email verschicken, da dies ja nur "indirekt" gebraucht wird.

Zitat:

3.) deine kryptographisch relevante Funktion die du benutzt ist die ADDITION. Das ist bei weitem viel zu wenig komplex. Du benutzt keinerlei Substitutionen oder ähnlich annerkannte Grundalgos. sondern nutzt nur die einfachste TRansposition die es gibt. Transpositions-verschlüsselungen sind die am leichtesten brechbaren Cipher, zb. Cäsar.

Das ist mir schon klar, nur war das das einzige was einem 14 jährigen schlüer in 10 Minuten eingefallen ist.

Zitat:

Wir erzeugen ein "KeyFile" als ANgreifer das aus lauter NULLEN besteht, und senden das derjenigen Person die wir angreifen wollen. Dein Algo selber benutzt die Bytes in "KeyFile" als einfachster Additions-Offset auf die Daten. Dh. steht im KeyFile ein Byte mit Wert 0 so wird 0 auf das Datenbyte addiert um es zu verschlüsseln. Da wir mit 0 addieren ist unverschlüsselte Daten == verschlüsselte Daten.

Sorry, aber ich sehe den Sinn in der Aktion wohl nicht ganz.

Wie gesagt ist mein Programm nochin den Kinderschuhen, un dich habe vor es ncoh zu verbessern.

[negaH]

Zitat:

Sorry, aber ich sehe den Sinn in der Aktion wohl nicht ganz.

Ja, ist schon klar ;)

Der Sinn ist sehr einfach, es ist ein Beweis dafür das es sehr einfache Angriffe gegen deine Methode gibt, die das Ding sehr unsicher machen. Unsicher eben deshalb weil ein Angreifer in der Lage ist ein beliebiges Benutzerpasswort quasis unsicher zu machen. Mit einem KeyFile aus lauter Nullen zb. wird mit jedem beliebigen Passwort rein garnichts durch dein Verfahren verschlüsselt. Die Inputdaten sind identisch mit den Outputdaten.

Probiere es einfach mal aus. Du entfernst deine sinnlosen Konvertierungen mit IntToStr() und so'n Quatsch und benutzt stattdessen den Datentyp Byte oder ähnlich. Mit einem KeyFile aus lauter Nullen wirst du dann sehen das das Passwort egal ist und garnichts verschlüsselt wird.

Wo ist das Problem ?

1.) Ein guter Cipher wird absolut sicherstellen das alle möglichen Passwörter absolut gleiche Sicherheiten erzeugen. Es gibt also keine Passwörter die stärker oder schwächer als andere Passwörter sind.
In deinem Falle kann man aber über das KeyFile die Stärke eines Passwortes soweit verändern das im Grunde garnichts verschlüsselt wird.

2.) Die Sicherheitsstufen können von -100% bis +100% gehen
100% -> ein Cipher verschlüsselt so sicher das er nicht geknackt werden kann ausser mit einer Brute Force Attacke
0% -> keine Verschlüsselung, der Anwender weis das er nichts verschlüsselt hat und das seine Daten unsicher sind. Er wird dementsprechend handeln.
-100% -> der User verschlüsselt mit zb. deinem Programm seine Daten. Er GLAUBT es ist sicher und wir WISSEN das es unsicher sein muß.

-100% sicher ist dein Algo. Das ist demzufolge unsicherer als garnicht zu verschlüsseln, da sich der Anwender in Sicherheit wähnt die nicht existent ist.

3.) mein DEMO-Angriff ist offensichtlich durchführbar und stellt somit ein durch rein logische Analyse ermittelter Angriff dar. Das ist ein sehr starkes Indiz dafür das du noch einige Sachen an deinem Verfahren verändern solltest. Denn wichtig ist nur eines -> gibt es andere Verfahren die im vergleich zu deinem es anders machen und dadurch sicher sind, ja die gibt es.


Ich empfehle dir das Buch "Angewandte Kryptographie" von Bruce Schneier. Er geht sehr gut auf die Designkriterien guter Verschlüsselungen ein.

Gruß Hagen