Der DEC x32 ASM in x64/PurePascal Konvertierungsthread

[hugie]

Da wäre es langsam interessant, eine existierende OpenSource lib die weit verbreitet ist, via wrapper für delphi zur verfügung zu stellen.
Z.B. libgcrypt o.ä. Ist lgpl, sollte also auch in proprietärer Software einsetzbar sein.
Viele c/c++ OS Projekte sind up-to-date, häufig eingesetzt, gut geprüft etc.

Soweit ich weiß ist es doch relativ unkompliziert eine .dll oder .so via wrapper aus delphi heraus anzusprechen.
Damit würde man sich das regelmäßige neuentwickeln sparen, man müsste "nur" die api immer aktuell halten.
Ok, es ist kein PurePascal, aber sicherlich doch eine alternative Lösung zu unseren Problemen hier.

Gibt es da vielleicht schon was?

Lg

[jaenicke]

Ich habe in der Zwischenzeit die meisten Anpassungen selbst durchgeführt, zumindest für die Teile, die ich benötige.

Eine zusätzliche DLL wäre zwar kein echtes Problem, möchte ich aber eigentlich nicht.

[Schorschi5566]

Hallo zusammen,

darf man fragen ob das Projekt Dec 6.0 noch weiter verfolgt wird?

Wäre schon toll und war doch schon bald fertig, oder?

Ich habe mir auch mal die Kryptoroutinen von gammatester angesehen aber hätte da schon so meine Probleme um die von mir verwendeten DEC-Funktionen umzusetzen.

Sowas zum Beispiel:

Delphi-Quellcode:

function EncryptString(const Password: RawByteString; const Value: RawByteString): RawByteString;
var
  Salt, SessionKey: Binary;
begin
  Salt := RandomBinary(16);
  with TCipher_Rijndael.Create do
    try
      SessionKey := THash_SHA1.KDFx(Password, Salt, Context.KeySize,
        TFormat_Copy);
      mode := cmCFS8; 
      Init(SessionKey);
      Result := TFormat_MIME64.Encode(Salt + EncodeBinary(Value, TFormat_Copy));
    finally
      Free;
      ProtectBinary(Salt);
      ProtectBinary(SessionKey);
    end;
end;

Weiß jemand was die Entsprechung mit den gammatester-Kryptoroutinen wäre? Geht das damit?


Grüße,
Uwe

[Jens01]

Also auf DEC hoffe ich nicht mehr. Ich habe das System von Gammatester erfolgreich umgestellt.
Das, was Du möchtest, sollte auch (irgendwie) funktionieren.

Ich muß bei mir gucken, Moment.

[Jens01]

So habe ich das gemacht. Das ist anscheinend von mir aus einem Beispiel von ihm zusammengestrickt :

Delphi-Quellcode:

function Encrypt(const AText: string; const APassword: string): string;
{ -Encrypt file InName to OutName using password }
// http://www.wolfgang-ehrhardt.de/crypt_en.html
const
  bufSize = $C000;
var
  N              : word;
  len            : int64;
  hdr            : TFCA256Hdr;
  cxe            : TAES_EAXContext;
  auth           : TFCA256_AuthBlock;
  TextOut, TextIn: TStringStream;
  buf            : array [0 .. bufSize - 1] of Byte;
begin
  randomize;
  TextIn  := TStringStream.Create(AText);
  TextOut := TStringStream.Create;
  try
    len := TextIn.Size;
    GetSalt(hdr.salt);

    if FCA_EAX256_initS(cxe, APassword, hdr) <> 0 then
      raise Exception.Create('Fehler'); 

    TextOut.WriteBuffer(hdr, SizeOf(hdr));

    while len > 0 do
    begin
      if len > SizeOf(buf) then
        N := SizeOf(buf)
      else
        N := len;
      TextIn.ReadBuffer(buf, N);
      dec(len, N);
      if FCA_EAX256_encrypt(cxe, buf, N) <> 0 then
        raise Exception.Create('Fehler'); 
      TextOut.WriteBuffer(buf, N);
    end;
    FCA_EAX256_final(cxe, auth);
    TextOut.WriteBuffer(auth, SizeOf(auth));
    Result := Base64EncStr(TextOut.DataString);
  finally
    TextOut.Free;
    TextIn.Free;
  end;
end;

function Decrypt(const AText: string; const APassword: string): string;
{ -Decrypt file InName to OutName using password sPW }
// http://www.wolfgang-ehrhardt.de/crypt_en.html
const
  bufSize = $C000;
var
  N              : word;
  I, len         : longint;
  hdrk           : TFCA256Hdr;
  hdrf           : TFCA256Hdr;
  cxe            : TAES_EAXContext;
  cxh            : TFCA_HMAC256_Context;
  authf          : TFCA256_AuthBlock;
  authc          : TFCA256_AuthBlock;
  UseEAX         : boolean;
  TextOut, TextIn: TStringStream;
  buf            : array [0 .. bufSize - 1] of Byte;
begin
  if AText = '' then
    Exit('');
  TextIn  := TStringStream.Create(Base64DecStr(AText));
  TextOut := TStringStream.Create;
  try
    len := TextIn.Size - SizeOf(hdrf) - SizeOf(authf);
    TextIn.ReadBuffer(hdrf, SizeOf(hdrf));

    if (hdrf.FCASig <> C_FCA_Sig) or (hdrf.Flags and $F0 <> $A0) then
      raise Exception.Create('Fehler'); 

    if hdrf.Flags and $02 <> 0 then
    begin
      writeln(#7'*** Warning: Found zlib compression flag, use t_zlibex to inflate <outfile>');
    end;

    if not(hdrf.Flags and $04 <> 0) then
    begin
      raise Exception.Create('Fehler'); 
    end;

    hdrk   := hdrf;
    UseEAX := odd(hdrf.Flags);
    if UseEAX then
    begin
      if FCA_EAX256_initS(cxe, APassword, hdrk) <> 0 then
        raise Exception.Create('Fehler');
    end
    else
    begin
      if FCA_HMAC256_initS(cxh, APassword, hdrk) <> 0 then
        raise Exception.Create('Fehler'); 
    end;
    if hdrf.PW_ver <> hdrk.PW_ver then
      raise Exception.Create('Fehler'); 

    while len > 0 do
    begin
      if len > SizeOf(buf) then
        N := SizeOf(buf)
      else
        N := len;
      TextIn.ReadBuffer(buf, N);
      dec(len, N);
      if UseEAX then
      begin
        if FCA_EAX256_decrypt(cxe, buf, N) <> 0 then
          raise Exception.Create('Fehler'); 
      end
      else
      begin
        if FCA_HMAC256_decrypt(cxh, buf, N) <> 0 then
          raise Exception.Create('Fehler'); 
      end;
      TextOut.WriteBuffer(buf, N);
    end;
    if UseEAX then
    begin
      FCA_EAX256_final(cxe, authc);
    end
    else
    begin
      FCA_HMAC256_final(cxh, authc);
    end;
    TextIn.ReadBuffer(authf, SizeOf(authf));
    for I := 0 to 15 do
    begin
      if authf[I] <> authc[I] then
      begin
        raise Exception.Create('Fehler'); 
      end;
    end;
    Result := TextOut.DataString;
  finally
    TextOut.Free;
    TextIn.Free;
  end;
end;

[Schorschi5566]

Hallo Jens01,

vielen Dank. Werde ich mal ausprobieren.

Schade, wenn das mit DEC nichts mehr werden sollte. Ist ja doch um Einiges einfacher anzuwenden...


Grüße,
Uwe

[Jens01]

Zitat:

Ist ja doch um Einiges einfacher anzuwenden...

Glaube ich gar nicht. Man muß sich nur noch mal durch diese nicht so einfache Routinen durcharbeiten. Bei DEC hast Du das wahrscheinlich schon gemacht.
Gammatester ist aber öfter mal hier im Forum.

[JamesTKirk]

Zitat von Assertor:

Das läuft in x64 Delphi, das RDX Register scheint dem FPC x64 Compiler aber nicht zu gefallen:

Zitat:

Error: Unknown identifier "RDX"

Gleich in der ersten Zeile bei SHL RDX, 3.

Nun gut, ich kenne FPC nicht weiter, möglicherweise ist dies bekannt und über Defines steuerbar. Ggf bleibt dort der Weg über PurePascal, was wegen der breiteren Unterstützung ja mit o.g. Delphi Code möglich ist.

Ist zwar schon ne Weile her der Post, aber dennoch sollte man erklären woran es hier hakt: FPC arbeitet standardmäßig im AT&T Syntax Modus, wobei register mit einem "%"-Prefix benannt sind und noch dazu Source und Destination Register vertauscht sind. Will man den Intel Modus verwenden (der für i386 und x86_64 unterstützt ist), so muss man eine {$asmmode intel} Direktive einfügen.

Eine Anmerkung noch zu Calling Conventions: diese sind unter x86_64-win64 und x86_64-[alles andere] unterschiedlich. Letztere verwenden die Linux x86_64 ABI während nur Windows hier sein eigenes Süppchen kocht. Für FPC würde ich dennoch eine PurePascal Implementierung vorziehen, da es ja noch einige Plattformen mehr gibt (Achtung: auch mit unterschiedlicher Endianess!).

Gruß,
Sven

[gammatester]

Zitat von Schorschi5566:

Delphi-Quellcode:

      SessionKey := THash_SHA1.KDFx(Password, Salt, Context.KeySize,
        TFormat_Copy);
      mode := cmCFS8;

Weiß jemand was die Entsprechung mit den gammatester-Kryptoroutinen wäre? Geht das damit?

Das geht so überhaupt nicht! Es liegt aber nicht an meinen Routinen, sondern an den häufigen selbstgestrickten DEC-Routinen:

Zitat:

class function TDECHash.KDFx
// DEC's own KDF, even stronger

oder die selbstgebastelten Betriebsmodi, die zwar gut gemeint und wahrscheinlich auch sicher sind, allerdings mit nichts und niemand in der restlichen Welt kompatibel.

[jaenicke]

Zitat von JamesTKirk:

Eine Anmerkung noch zu Calling Conventions: diese sind unter x86_64-win64 und x86_64-[alles andere] unterschiedlich. Letztere verwenden die Linux x86_64 ABI während nur Windows hier sein eigenes Süppchen kocht.

Genau genommen fällt UEFI aus dem "alles andere" auch heraus und nutzt die selbe Konvention wie Windows.