Verschlüsselung einigermaßen sicher?

[gunter]

Hi,

hab in einem Programm von mir folgende Funktionen zum Verschlüsseln von Daten verwendet, könnt ihr mir sagen, ob das einigermaßen sicher ist oder total leicht geknackt werden kann, schonmal vielen Dank.

im Hauptprogramm

Delphi-Quellcode:

var prod: string;

function ver(s, prod: shortstring): shortstring; external 'database.dll';
function ent(s, prod: shortstring): shortstring; external 'database.dll';


{$R *.dfm}
procedure TForm1.FormCreate(Sender: TObject);
var i, x: integer;
begin
for i:=3 to 111 do
 begin
 x:=i or round(sqrt(sqr(i)*power(1.5634,i)));
 x:=x mod 99;
 prod:=prod+char(x);
 end;
end;


procedure TForm1.Button1Click(Sender: TObject);
var s, verschl: string;
begin
s:='Dies ist der Teststring';

verschl:=ver(s, prod);
showmessage('Verschlüsselt: '+verschl);
showmessage('Wieder entschlüsselt: '+ent(verschl, prod));

end;

in der DLL:

Delphi-Quellcode:

function num(i: integer; prod: shortstring): integer;
begin
i:=floor(power(sqrt(i*3),3)) mod 128;
if i>length(prod) then i:=2*length(prod)-i;

i:=13 xor ord(prod[i]);

if i>100 then i:=ceil(sqrt(i/0.8));

result:=i;
end;

function ver(s, prod: shortstring): shortstring; export;
var i: integer;
begin
for i:=1 to length(s) do s[i]:=char(num(i, prod) Xor Ord(s[i])+1);
result:=s;
end;

exports
 ver;
 

function ent(s, prod: shortstring): shortstring; export;
var i: integer;
begin
for i:=1 to length(s) do s[i]:=char(num(i, prod) Xor (ord(s[i])-1));
result:=s;
end;

exports
 ent;

[MSCH]

Einfach, da symetrisch. Ohne jetzt den Code ganz genau zu analysieren verwendest du einfache Mathematik. Da die Redundanz in den verschlüsseltem Texten damit nicht verschwindet reicht ein einfaches Trial&Error.
Schau dir mal die Orpheus Lookbox an (freeware mittlerweile), dort findest du DES, RSA, RDL, DSA und so weiter.
grez
msch

[Luckie]

XOR kann und wird nie sicher sein.

Ach kuck dir auch mal das DEC von unserem Hagen an.

BTW. H-A-G-E-N wo bleibst du :cyclops:

[kiar]

der ist bei seiner "ollen" :love:

[Christian Seehase]

Moin Luckie,

Zitat:

Zitat von Luckie

XOR kann und wird nie sicher sein.

:shock:

Eine XOR Verschlüsselung, bei der die Schlüssellänge = Textlänge ist kannt nicht geknackt werden.
Man steht nur vor dem, nicht zu unterschätzenden Problem, den Schlüssel sicher zu übertragen.

[Luckie]

OK, dann war ich falsch informiert.

[Motzi]

Zitat:

Zitat von Christian Seehase

Moin Luckie,

Zitat:

Zitat von Luckie

XOR kann und wird nie sicher sein.

:shock:

Eine XOR Verschlüsselung, bei der die Schlüssellänge = Textlänge ist kannt nicht geknackt werden.
Man steht nur vor dem, nicht zu unterschätzenden Problem, den Schlüssel sicher zu übertragen.

Ja, da es sich hier um ein OneTimePad handelt, allerdings müssen einige wichtige Punkte beachtet werden:

• Der Schlüssel muss zufällig erzeugt sein (aber nicht mit einem simplen Pseudo-Zufallsgenerator, sondern mit einer echten Zufallsquelle!)
• Jeder Schlüssel darf nur einmal verwendet werden

Aber Luckie hat schon recht, eine simple XOR-Verschlüsselung ist definitiv nicht sicher! Wenn es wen interessiert wie man eine solche Verschlüsselung knackt, so kann er sich mal diese beiden Threads aus dem Delphi-Forum anschaun:
http://www.delphi-forum.de/viewtopic.php?t=13611
http://www.delphi-forum.de/viewtopic.php?t=14337

[negaH]

Zitat:

XOR kann und wird nie sicher sein.

Das ist natürlich nicht richtig. Die XOR Operation als solches ist sogar ideal für Verschlüsselungen. Auf binärer Ebene beträgt die Wahrscheinlichkeit das ein Bit durch ein anderes Bit XOR verknüpft, exakt 50% das das Ausgangsbit negiert wird bzw. eben 50% das es nicht negiert wird. Bei 2 möglichen Zuständen, eben 0 oder 1, ist diese exakte 50%'tige Wahrscheinlichkeit absolut ideal. Eine ähnliche Operation wäre die Modulare Division, eg. der mod Operator, zu einer Primzahl. Beide Operationen sind in der Kryptograhpie die häufigsten Operationen überhaupt. Die XOR Verknüpfung ist sogar nur ein Spezialfall dieser Modularen Operation, nämlich mod 2, und 2 eine Primzahl. Würde man mod 5 rechnen so würde sich eine Gleichverteilung zu 1/5 ergeben = 20% auf jeden möglichen Zustand.

Das Entscheidene ist nicht die XOR Operation selber sondern der Wert mit dem XOR verknüpft wird, sprich der Schlüssel. Bei der theoretisch perfekten Verschlüsselung, dem OTP, wird ein absoult zufälliger Schlüssel mit der Message XOR verknüpft. Da dieser Schlüssel nur einmal verwendet werden darf und exakt so lang wie die Message sein muß und aus echtem Zufall bestehen muß, ist die OTP Verschlüsselung im Grunde unpraktisch. Dieses Manko versucht man nun zu umgehen indem man die Bytesequenz eines solch langen Schlüssels durch einen Pseudo-Zufalls-Strom erzeugt. Aber genau das ist das Problem. Denn viele einfache "Zufalls"-generatoren lassen sich knacken. Somit ist die wichtige Eigenschaft zur perfekten Verschlüsselung gebrochen.

Gruß Hagen

[negaH]

@Gunter,

Kannst du mal genauer erklären wie dein Algo. auf mathematischer Basis funktioniert ?

Grundsätzlich ist es die Aufgabe des Designers des Verfahrens zu beweisen das er sicher sein muß, bzw. sollte.
Nach lesen deines Sources stellen sich mir aber einige Fragen bezüglich der math. Grundlagen und der technischen Umsetzung. Z.b. das Arbeiten mit gerundeten Floating-Points innerhalb einer Verschlüsselung bringt arge Probleme mit sich. Die Rundungsregeln auf einem Rechner mit Co-Prozessor sind nämlich stark abhänig von der Co-Prozessor Konfiguration. D.h. deine Verschl. kann durchaus auf verschiendene Rechnern unterschiedliche Resultate erzeugen trotz gleichem Schlüssel.

Des weiteren sehe ich hier in der DP nun schon zum zweiten Male die Anwendung von IntPower() und begreife aber dabei nicht welche math. Grundlage dahinter steckt die das sicher machen soll.

Zudem sehe ich einige modulare Operationen zu zusammengesetzen Zahlen, sprich Nicht-Primzahlen. Eine modulare Division zu Ringen deren Basis keine Primzahl ist, bedeutet immer das sich die Komplexität des Verfahrens reduziert. Z.b. mod 99 = mod (3*3*11) somit enthält der Ring mod 99 nicht 99-1 eindeutige teilerfremde Elemente sondern nur 3+11 = 14. Damit wäre die Komplexität der modulare Operation stark reduziert.


Gruß Hagen