2 Prozeduren zu langsam

[maximus Caesar]

Hallo!
Ich habe jetzt zwei Prozeduren geschrieben, die mir aber noch zu langsam sind. Ich bekomme Sie nicht schneller hin.
Kennt jemand ne Möglichkeit, dass diese Prozeduren schneller werden?

Prozedur 1:

Delphi-Quellcode:

function TVerschluesselung.Verschluesseln(passwort:String;Text:String):String;
var passwortverschluesselt,schluessel,block1,block2,text2,zeichen,zeichen2:String;
    index,i,i2,i3,i4,i5:Integer;

begin
  //ersten Schlüssel erzeugen
  passwortverschluesselt:=MD5Print(MD5String(Passwort));
  passwortverschluesselt:=MD5Print(MD5String(passwort+passwortverschluesselt+passwort));
  schluessel:=passwortverschluesselt;
  //erster Schlüssel erzeugt

  block1:='';
  block2:='';
  i5:=length(Text);
  text2:=text;
  index:=-1; //BlockIndex

  //verschlüsseln
  repeat
    index:=index+1;
    //Block ausschneiden
    if index<>0 then delete(text2,1,32);
    block1:=text2;
    delete(block1,33,length(block1));
    //Block verschlüsseln
    for i:=1 to length(Block1) do begin
      Zeichen:=Block1[i];

      Zeichen2:=Schluessel[i];
      i2:=ord(Zeichen2[1]);

      i4:=ord(Zeichen[1]);
      i3:=i4+i2;
   //   if i3>255 then i3:=i3-255;
      Block2:=Block2+char(i3);
    end;
    //Neuer Schlüssel
    schluessel:=MD5Print(MD5String(Block1+schluessel+Block1));
  until index>=i5/32;
  result:=String(Block2);
end;

Prozedur 2:

Delphi-Quellcode:

function TVerschluesselung.Entschluesseln(passwort:String;Text:String):String;
var passwortverschluesselt,schluessel,block1,block2,block3,text2,zeichen,zeichen2:String;
    index,i,i2,i3,i4,i5:Integer;
begin
  //ersten Schlüssel erzeugen
  passwortverschluesselt:=MD5Print(MD5String(Passwort));
  passwortverschluesselt:=MD5Print(MD5String(passwort+passwortverschluesselt+passwort));
  schluessel:=passwortverschluesselt;
  //erster Schlüssel erzeugt

  block1:='';
  block2:='';
  i5:=length(Text);
  text2:=text;
  index:=-1; //BlockIndex


  //entschlüsseln
  repeat
    index:=index+1;
    //Block ausschneiden
    if index<>0 then delete(text2,1,32);
    block1:=text2;
    delete(block1,33,length(block1));
    //Block entschlüsseln
    for i:=1 to length(Block1) do begin
      Zeichen:=Block1[i];

      Zeichen2:=Schluessel[i];
      i2:=ord(Zeichen2[1]);

      i4:=ord(Zeichen[1]);
      i3:=i4-i2;
   //   if i3<0 then i3:=i3+255;
      Block2:=Block2+char(i3);
    end;
    //Neuer Schlüssel
    Block3:=Block2;
    delete(Block3,1,index*32);
    delete(Block3,33,length(Block3));
    schluessel:=MD5Print(MD5String(Block3+schluessel+Block3));
  until index>=i5/32;
  result:=String(Block2);
end;

[GuenterS]

hm, du könntest die i5/32 einmal ausrechnen und dann direkt mit dem Ergebnis vergleichen. wird aber net viel bringen denk ich. Es ist aber unnötig sie bei jedem Durchgang neu zu rechnen, da du i5 nicht änderst in der Procedur.

[JasonDX]

Die Division einmalig auszurechnen bringt auch imo nicht viel. Soweit ich das sehe liegt die Schnecke einfach im Algorithmus begraben.
Nachdem du in beiden Prozeduren rekursive for-schleifen hast dürfte die Komplexität bei ca. n² liegen, was sich bei längeren Werten/häufigeren Schleifendurchläufen schon mal stark auf die Geschwindigkeit auswirkt.
Ergo: Du kannst die Prozeduren beschleunigen, indem du den Algorithmus schon auf den Papier optimierst

(btw: es wäre logischer, die repeat-until-schleifen durch for-schleifen zu ersetzen. Logisch dann nicht i5 / 32 sondern i5 div 32 oder i5 shr 5 nehmen )


greetz
Mike

[GuenterS]

Ich hab die eine Funktion mal etwas umgeschrieben, vielleicht probierst ja mal und sagst mir den Zeitunterschied.

Delphi-Quellcode:

function TVerschluesselung.Verschluesseln(passwort: string; Text: string): string;
var
  passwortverschluesselt, schluessel, block1, block2: string;
  text2: string;
  index, i, i2, i3, i4, i5: Integer;
begin
  //ersten Schlüssel erzeugen
  passwortverschluesselt := MD5Print(MD5String(Passwort));
  passwortverschluesselt := MD5Print(MD5String(passwort + passwortverschluesselt
    + passwort));
  schluessel := passwortverschluesselt;
  //erster Schlüssel erzeugt

  block1 := '';
  block2 := '';
  i5 := length(Text) div 32;
  text2 := text;
  index := 0; //BlockIndex

  //verschlüsseln
  repeat
    block1 := copy(text2, index * 32 + 1, 32);

    //Block verschlüsseln
    for i := 1 to length(Block1) do
    begin
      i2 := ord(Schluessel[i]);
      i4 := ord(Block1[i]);
      i3 := i4 + i2;
      Block2 := Block2 + char(i3);
    end;
    index := index + 1;
    //Neuer Schlüssel
    schluessel := MD5Print(MD5String(Block1 + schluessel + Block1));
  until index >= i5;
  result := Block2;
end;

[maximus Caesar]

Spitze!
Benötigt nur noch 2/25 der Zeit!

Das einzige was an der Prozedure noch nicht passt ist, wenn der Text eine Länge hat, die nicht genau durch 32 Teilbar ist, also mit Rest, werden die Restlichen ZEichen nicht verschlüsselt. Aber das dürfte kein PRoblem sein, dass kann ich ja hinten Anhängen. Kannst du noch die zweite Prozedure anpassen?
Danke!

Die Angepasste Verschlüsselungs Prozedur sieht jetzt so aus:

Delphi-Quellcode:

function TVerschluesselung.Verschluesseln(passwort: string; Text: string): string;
var
  passwortverschluesselt, schluessel, block1, block2: string;
  text2: string;
  index, i, i2, i3, i4, i5: Integer;
begin
  //ersten Schlüssel erzeugen
  passwortverschluesselt := MD5Print(MD5String(Passwort));
  passwortverschluesselt := MD5Print(MD5String(passwort + passwortverschluesselt
    + passwort));
  schluessel := passwortverschluesselt;
  //erster Schlüssel erzeugt

  block1 := '';
  block2 := '';
  i5 := length(Text) div 32;
  text2 := text;
  index := 0; //BlockIndex

  //verschlüsseln
  repeat
    block1 := copy(text2, index * 32 + 1, 32);

    //Block verschlüsseln
    for i := 1 to length(Block1) do
    begin
      i2 := ord(Schluessel[i]);
      i4 := ord(Block1[i]);
      i3 := i4 + i2;
      Block2 := Block2 + char(i3);
    end;
    index := index + 1;
    //Neuer Schlüssel
    schluessel := MD5Print(MD5String(Block1 + schluessel + Block1));
  until index >= i5;
  if length(Text)/32 > i5 then begin
    block1 := copy(text2, index * 32 + 1, 32);
    for i := 1 to length(Block1) do
    begin
      i2 := ord(Schluessel[i]);
      i4 := ord(Block1[i]);
      i3 := i4 + i2;
      Block2 := Block2 + char(i3);
    end;
  end;
  result := Block2;
end;

[GuenterS]

ich denke du brauchst nichts anhängen sondern einfach nur die Bedingung der repeat ... until schleife ändern

Delphi-Quellcode:

function TVerschluesselung.Verschluesseln(passwort: string; Text: string): string; 
var 
  passwortverschluesselt, schluessel, block1, block2: string; 
  text2: string; 
  index, i, i2, i3, i4, i5: Integer; 
begin 
  //ersten Schlüssel erzeugen 
  passwortverschluesselt := MD5Print(MD5String(Passwort)); 
  passwortverschluesselt := MD5Print(MD5String(passwort + passwortverschluesselt 
    + passwort)); 
  schluessel := passwortverschluesselt; 
  //erster Schlüssel erzeugt 

  block1 := ''; 
  block2 := ''; 
  i5 := length(Text) div 32; 
  text2 := text; 
  index := 0; //BlockIndex 

  //verschlüsseln 
  repeat 
    block1 := copy(text2, index * 32 + 1, 32); 

    //Block verschlüsseln 
    for i := 1 to length(Block1) do 
    begin 
      i2 := ord(Schluessel[i]); 
      i4 := ord(Block1[i]); 
      i3 := i4 + i2; 
      Block2 := Block2 + char(i3); 
    end; 
    index := index + 1; 
    //Neuer Schlüssel 
    schluessel := MD5Print(MD5String(Block1 + schluessel + Block1)); 
  until index > i5; 
  result := Block2; 
end;

Damit sollte auch der Rest verschlüsselt werden.

[maximus Caesar]

Danke! KAnnst du auch noch die Entschlüsselungs Prozedur Anpassen?

[GuenterS]

Na gut, mir war eh grad fad.

Delphi-Quellcode:

function TVerschluesselung.Entschluesseln(passwort: string; Text: string):
  string;
var
  passwortverschluesselt, schluessel: string;
  block1, block2, text2: string;
  index, i, i5: Integer;
begin
  //ersten Schlüssel erzeugen
  passwortverschluesselt := MD5Print(MD5String(Passwort));
  passwortverschluesselt := MD5Print(MD5String(passwort + passwortverschluesselt
    + passwort));
  schluessel := passwortverschluesselt;
  //erster Schlüssel erzeugt

  block1 := '';
  block2 := '';
  i5 := length(Text) div 32;
  text2 := text;
  index := 0; //BlockIndex

  //entschlüsseln
  repeat
    //Block ausschneiden
    block1 := copy(text2, 1 + index * 32, 32);
    //Block entschlüsseln
    for i := 1 to length(Block1) do
      Block1[i] := chr(ord(Block1[i]) - ord(Schluessel[i]));
    block2 := block2 + block1;
    index := index + 1;
    //Neuer Schlüssel
    schluessel := MD5Print(MD5String(Block1 + schluessel + Block1));
  until index > i5;
  result := Block2;
end;

Habs nicht probiert ... sagst mir wieder obs schneller gworden ist?

[maximus Caesar]

eindeutig Schneller!
Benötigt nur noch 11/30tel der ZEit!
Danke!!!!!!

[GuenterS]

11/30igstel ?

Hm, dachte eigentlich, dass es fast noch schneller hätte sein müssen, als die erste Procedur.