1:
2:
3:
4:
5:
6:

{$0-}
procedure blubb;
begin
  ...
end;
{$0+}                    

1:

uses Math;                    

1:
2:
3:
4:
5:

var  
  X, Y:  Integer;
  Wort:  String;     // Direkt String
  fChar: PChar;
  binlm, bigpass, endhash: string;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

  bigpass:=Copy(AnsiUpperCase(Wort)+#0+#0+#0+#0+#0+#0+#0+#0+#0+#0+#0+#0+#0+#0,0,14);
  anf:=parityshift(Copy(bigpass,0,7));
  ende:=Copy(bigpass,8,7);
  ende:=parityshift2(ende);
  alpha:=DecodeText('KGS!@#$%',anf);
  alpha:=HexStrToString(alpha);
  beta:=DecodeText('KGS!@#$%',ende);
  beta:=HexStrToString(beta);
  binlm:=alpha+beta;
  endhash:=StringToHexStr(binlm);                    

1:
2:
3:
4:
5:
6:
7:

  bigpass:=Copy(AnsiUpperCase(Wort)+#0+#0+#0+#0+#0+#0+#0+#0+#0+#0+#0+#0+#0+#0,0,14);
  anf:=parityshift(Copy(bigpass,0,7));
  ende:=Copy(bigpass,8,7);
  ende:=parityshift2(ende);
  alpha:=DecodeText('KGS!@#$%',anf);
  beta:=DecodeText('KGS!@#$%',ende);
  binlm:=alpha+beta;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

function HexStrToString(const value:string):string;
begin
   SetLength(Result, Length(value) div 2);
   if Length(value) > 0 then
      HexToBin(PChar(value), PChar(Result), Length(value));
end;

function StringToHexStr(const value:string):string;
begin
   SetLength(Result, Length(value)*2);
   if Length(value) > 0 then
      BinToHex(PChar(value), PChar(Result), Length(value));
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:

bigpass := Copy(AnsiUpperCase(Wort)+#0+#0+#0+#0+#0+#0
         +#0+#0+#0+#0+#0+#0+#0+#0,0,14);
anf := ParityShift(Copy(Bigpass, 0, 7));
ende := Copy(Bigpass, 8, 7);
ende := ParityShift(ende);
alpha := DecodeText('KGS!@#$%', anf);
alpha := HexStrToString(alpha);
beta := DecodeText('KGS!@#$%', ende);
beta := HexStrToString(beta);
binlm := alpha + beta;
endhash := StringToHexStr(binlm);                    

1:
2:
3:
4:
5:
6:
7:
8:

bigpass := Copy(AnsiUpperCase(Wort)+#0+#0+#0+#0+#0+#0
         +#0+#0+#0+#0+#0+#0+#0+#0,0,14);
anf := ParityShift(Copy(Bigpass, 0, 7));
ende := Copy(Bigpass, 8, 7);
ende := ParityShift(ende);
alpha := DecodeText('KGS!@#$%', anf);
beta := DecodeText('KGS!@#$%', ende);
binlm := alpha + beta;                    

1:
2:

binlm := HexStrToString(DecodeText('KGS!@#$%', anf)) + HexStrToString(DecodeText('KGS!@#$%', ende));
endhash:=StringToHexStr(binlm);                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

  bigpass:=Copy(AnsiUpperCase(Wort)+#0+#0+#0+#0+#0+#0+#0+#0+#0+#0+#0+#0+#0+#0,0,14);
  anf:=parityshift(Copy(bigpass,0,7));
  ende:=Copy(bigpass,8,7);
  ende:=parityshift2(ende);
  alpha:=DecodeText('KGS!@#$%',anf);
  beta:=DecodeText('KGS!@#$%',ende);
  alpha:=HexStrToString(alpha);       // Umwandeln
  beta:=HexStrToString(beta);         // Umwandeln
  binlm:=alpha+beta;
  endhash:=StringToHexStr(binlm);     // Zurückwandeln                    

1:
2:
3:
4:
5:
6:
7:

  bigpass:=Copy(AnsiUpperCase(Wort)+#0+#0+#0+#0+#0+#0+#0+#0+#0+#0+#0+#0+#0+#0,0,14);
  anf:=parityshift(Copy(bigpass,0,7));
  ende:=Copy(bigpass,8,7);
  ende:=parityshift2(ende);
  alpha:=DecodeText('KGS!@#$%',anf);
  beta:=DecodeText('KGS!@#$%',ende);
  binlm:=alpha+beta;     // Kein Umwandeln und kein Zurückwandeln                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:

procedure Gen2();
var  
  X, Y:  Integer;
  Wort:  String;     // Direkt String
  fChar: PChar;
  binlm, bigpass: string;
begin
  SetLength(Wort, 1);         // String = 1 Zeichen lang
  fChar  := @Wort[1];         // Pointer auf den 1. Char --> schneller Zugriff
  fChar^ := Chr(Ord('A') - 33);

  for X := 0 to combs do
  begin
    Y := 1;
    inc(fChar^);

    while Wort[Y] > 'z' do
    begin
      inc(Y);

      if Y > Length(Wort) then
      begin
        SetLength(Wort, Y);     // Eventuell String verlängern
        Wort[Y] := '!';
      end
      else
        inc(Wort[Y]);

      Wort[Y - 1] := '!';
    end;
  bigpass:=Copy(AnsiUpperCase(Wort)+#0+#0+#0+#0+#0+#0+#0+#0+#0+#0+#0+#0+#0+#0,0,14);
  anf:=parityshift(Copy(bigpass,0,7));
  ende:=Copy(bigpass,8,7);
  ende:=parityshift2(ende);
  alpha:=DecodeText('KGS!@#$%',anf);
  //alpha:=HexStrToString(alpha);
  beta:=DecodeText('KGS!@#$%',ende);
  //beta:=HexStrToString(beta);
  binlm:=alpha+beta;
  //endhash:=StringToHexStr(binlm);
  end;
end;
procedure Gen3();
var  
  X, Y:  Integer;
  Wort:  String;     // Direkt String
  fChar: PChar;
  binlm, bigpass: string;
begin
  SetLength(Wort, 1);         // String = 1 Zeichen lang
  fChar  := @Wort[1];         // Pointer auf den 1. Char --> schneller Zugriff
  fChar^ := Chr(Ord('A') - 33);

  for X := 0 to combs do
  begin
    Y := 1;
    inc(fChar^);

    while Wort[Y] > 'z' do
    begin
      inc(Y);

      if Y > Length(Wort) then
      begin
        SetLength(Wort, Y);     // Eventuell String verlängern
        Wort[Y] := '!';
      end
      else
        inc(Wort[Y]);

      Wort[Y - 1] := '!';
    end;
  bigpass:=Copy(AnsiUpperCase(Wort)+#0+#0+#0+#0+#0+#0+#0+#0+#0+#0+#0+#0+#0+#0,0,14);
  anf:=parityshift(Copy(bigpass,0,7));
  ende:=Copy(bigpass,8,7);
  ende:=parityshift2(ende);
  alpha:=DecodeText('KGS!@#$%',anf);
  alpha:=HexStrToString(alpha);
  beta:=DecodeText('KGS!@#$%',ende);
  beta:=HexStrToString(beta);
  binlm:=alpha+beta;
  endhash:=StringToHexStr(binlm);
  end;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:

function DecodeText(Inputtext, Key: String): String;
begin
  with TCipher_1DES.Create do
  try
    Mode := cmECBx;
    Init(Key);
    Result := EncodeBinary(Inputtext, TFormat_HEXL);
  finally
    Free;
  end;
end;                    

1:

Copy(AnsiUpperCase(Wort)+#0+#0+#0+#0+#0+#0+#0+#0+#0+#0+#0+#0+#0+#0, 0, 14);                    

1:
2:

  for I:=Length(Wort) to 14 do
    Wort:=Wort+#0;                    

1:
2:
3:
4:
5:
6:

TKey = array [0..15] of byte;
TBlock = array [0..63] of byte;

InitializeKey(KeyString: String; var Key: TKey);

Encode(const Key: TKey; var Block: TBlock);                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:

function DecodeText(Inputtext, Key: String): String;
begin
  with TCipher_1DES.Create do
  try
    Mode := cmECBx;
    Init(Key);
    Result := EncodeBinary(Inputtext, TFormat_HEXL);
  finally
    Free;
  end;
end;                    

1:
2:
3:

  begin
      DoEncode(@S[0], @D[0], 8);
  end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

  begin                               // Size = 8 und Context.Blocksize <> 1
    if Context.BlockSize = 1 then
    begin
      DoEncode(S, D, 8);
      FState := csEncode;
    end else
    begin
      Dec(Size, 8);
      I := 0;
      while I <= Size do
      begin
        DoEncode(@S[I], @D[I], 8);
        Inc(I, 8);
      end;
      Dec(Size, I - 8);
      if Size > 0 then
        if Size mod Context.BlockSize = 0 then
        begin
          DoEncode(@S[I], @D[I], Size);
          FState := csEncode;
        end;
    end;
  end;                    

1:

DoEncode(S, D, 8);                    

1:
2:
3:
4:

"Nimm Adresse von X"
"Addiere 0"
"Das ist ein Wert"
"Davon die Adresse"                    

1:

"Nimm die Adresse von X"                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:

// Erstellen und initialisieren
Chipher := TDECCipher.Create;
Cipher.Mode := cmECBx;
Cipher.Init(Key);

// mit dem objekt arbeiten
Cipher.EncodeBinary(...);
Cipher.EncodeBinary(...);
Cipher.EncodeBinary(...);
Cipher.EncodeBinary(...);

Cipher.DecodeBinary(...);
Cipher.DecodeBinary(...);
Cipher.DecodeBinary(...);
Cipher.DecodeBinary(...);

// Wenn nicht mehr gebraucht, dann freigeben.
Chipher.Free;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:

procedure Gen();
var
  X, Y, I, Len, p:  Integer;
  Wort: arr8;
  Key: arr8;
begin
  with TCipher_1DES.Create do
  Len := 0;
  for X := 0 to 7 do
    wort[X] := (Ord('A')-65);

  inc(wort[0],32);
  for X := 0 to combs do
  begin
    Y := 0;
    inc(wort[Y]);

    while wort[Y] > Ord('z') do
    begin
      if (X = 90) or (X = 8190) or (X = 737190) or (X = 66347190) or (X = 5971247190) or (X = 537412247190) then
         inc(wort[Y + 1],32);

      inc(wort[Y + 1]);
      wort[Y] := ord('!');
      inc(Y);
      Len := max(Y, Len);   // Mysteriöserweise schneller mit diesem Unsinn
    end;
    anf:=parityshift(Wort);
    try
      Mode := cmECBx;
      TDECCipher.Init(anf);
      Result := EncodeBinary('KGS!@#$%', TFormat_HEXL);
    finally
      Free;
    end; 
  end;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:

  TDECCipherClass = class of TDECCipher;
  TDECCipher = class(TDECObject)
  private
    FData: PByteArray;
    FDataSize: Integer;
  protected
    FBufferIndex: Integer;
    FUserSize: Integer;
    FBuffer: PByteArray;
    FVector: PByteArray;
    FFeedback: PByteArray;
    FUser: Pointer;
    FUserSave: Pointer;
    procedure DoInit(Key: Array of Byte); virtual; abstract;
    procedure DoEncode(Source, Dest: Pointer); virtual; abstract;
  public
    constructor Create; override;
    class function Context: TCipherContext; virtual; abstract;
    procedure Init(Key: Array of Byte; IFiller: Byte = $FF);
    procedure Protect; virtual;
    procedure Encode(const Source; var Dest);
    function  EncodeBinary(): Binary;
  published
  end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:

procedure Gen();
var
  X, Y, I, Len, p:  Integer;
  Wort: arr8;
  Key: arr8;
begin
  with TCipher_1DES.Create do begin  //das hier fehlte bei dir: so wird das with-Statement nur auf Len bezogen..
  Len := 0;
  for X := 0 to 7 do
    wort[X] := (Ord('A')-65);

  inc(wort[0],32);
  for X := 0 to combs do
  begin
    Y := 0;
    inc(wort[Y]);

    while wort[Y] > Ord('z') do
    begin
      if (X = 90) or (X = 8190) or (X = 737190) or (X = 66347190) or (X = 5971247190) or (X = 537412247190) then
         inc(wort[Y + 1],32);

      inc(wort[Y + 1]);
      wort[Y] := ord('!');
      inc(Y);
      Len := max(Y, Len);   // Mysteriöserweise schneller mit diesem Unsinn
    end;
    anf:=parityshift(Wort);
    try
      Mode := cmECBx;
      TDECCipher.Init(anf);
      Result := EncodeBinary('KGS!@#$%', TFormat_HEXL);
    finally
      Free;
    end; 
  end;
end;                    

1:

if (a=3) and (b=4) and (c=5)                    

1:
2:
3:
4:
5:
6:
7:
8:

function _max(Zahl1,Zahl2:integer):integer;inline;
asm
    cmp eax,edx;
    jb @@switch;
    ret;
  @@switch:
    xchg eax,edx;
end;                    

1:
2:
3:
4:
5:
6:
7:

function _max(Zahl1,Zahl2:integer):integer;inline;
asm
    cmp eax,edx;
    jge @@done;
    xchg eax,edx;
    @@done:
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:

procedure TCipher_1DES.DoInitKey(const Data: array of Byte; Key: PLongArray; Reverse: Boolean);
const
  ROT: array[0..15] of Byte = (1,2,4,6,8,10,12,14,15,17,19,21,23,25,27,28);
var
  I,J,L,M,N: LongWord;
  PC_M,PC_R: array[0..55] of Byte;
  K: array[0..31] of LongWord;
begin
  FillChar(K, SizeOf(K), 0);
  for I := 0 to 55 do
    if Data[DES_PC1[I] shr 3] and ($80 shr (DES_PC1[I] and $07)) <> 0 then PC_M[I] := 1
      else PC_M[I] := 0;
  for I := 0 to 15 do
  begin
    if Reverse then M := (15 - I) shl 1
      else M := I shl 1;
    N := M + 1;
    for J := 0 to 27 do
    begin
      L := J + ROT[I];
      if L < 28 then PC_R[J] := PC_M[L] else PC_R[J] := PC_M[L - 28];
    end;
    for J := 28 to 55 do
    begin
      L := J + ROT[I];
      if L < 56 then PC_R[J] := PC_M[L] else PC_R[J] := PC_M[L - 28];
    end;
    L := $1000000;
    for J := 0 to 23 do
    begin
      L := L shr 1;
      if PC_R[DES_PC2[J     ]] <> 0 then K[M] := K[M] or L;
      if PC_R[DES_PC2[J + 24]] <> 0 then K[N] := K[N] or L;
    end;
  end;
  for I := 0 to 15 do
  begin
    M := I shl 1;
    N := M + 1;
    Key[0] := K[M] and $00FC0000 shl  6 or
              K[M] and $00000FC0 shl 10 or
              K[N] and $00FC0000 shr 10 or
              K[N] and $00000FC0 shr  6;
    Key[1] := K[M] and $0003F000 shl 12 or
              K[M] and $0000003F shl 16 or
              K[N] and $0003F000 shr  4 or
              K[N] and $0000003F;
    Key := @Key[2];      
  end;
end;