Shop-Zugangsdaten verschlüsseln

[freimatz]

Danke.

[Schokohase]

Nichts was ein Class Helper nicht lösen könnte

Delphi-Quellcode:

uses
  System.Classes, System.IniFiles, System.SysUtils;

type
  TCustomIniFileHelper = class helper for TCustomIniFile
  public
    function ReadBytes( const Section, Name: string ): TBytes;
    procedure WriteBytes( const Section, Name: string; const Value: TBytes );
  end;

implementation

{ TCustomIniFileHelper }

function TCustomIniFileHelper.ReadBytes( const Section, Name: string ): TBytes;
var
  stream: TBytesStream;
begin
  stream := TBytesStream.Create( );
  try
    Self.ReadBinaryStream( Section, Name, stream );
    Result := stream.Bytes;
  finally
    stream.Free( );
  end;
end;

procedure TCustomIniFileHelper.WriteBytes( const Section, Name: string; const Value: TBytes );
var
  stream: TBytesStream;
begin
  stream := TBytesStream.Create( Value );
  try
    Self.WriteBinaryStream( Section, Name, stream );
  finally
    stream.Free( );
  end;
end;

[KodeZwerg]

*entfernt, ich verstehe TE gerade nicht*

[freimatz]

Tja, Sorry Kathinka, das war für die Katz ;-)

Zitat:

Zitat von freimatz (Beitrag 1412424)

... in einer INI-Datei o.ä. ...

Wenn man eine "INI-Datei" verwendet geht das schon, nicht aber bei "o.ä." :-D

Zitat:

Zitat von freimatz (Beitrag 1412424)

(Nein ich brauche kein Beispiel wie base64 geht)

[freimatz]

Vielleicht doch? ...
Den Code habe ich für meine Bedürfnisse erweitert. Ich bin Jetzt auf XE2. Dank Kodezwerg konnte ich das auch da zum Laufen bringen.
Bei der ersten Erweiterung geht um Base 64. Als Grundlage nahme ich das Beispiel oben mit "procedure SmallTest( );"

Delphi-Quellcode:

uses
  ...
  Soap.EncdDecd,
...
function EncryptStringToBase64(const S: String): String;
var
  inBuffer, outBuffer, encrypted: TBytes;
begin
  inBuffer := TEncoding.UTF8.GetBytes( S );
  encrypted := TProtectedData.Protect( inbuffer ); // verschlüsseln
  Result := EncodeBase64(encrypted,Length(encrypted));
  Result := StringReplace(Result, #13#10, '', [rfReplaceAll]);
end;

function DecryptBase64ToString(const S: String): String;
var outBuffer, encrypted: TBytes;
begin
  encrypted := DecodeBase64(S);
  outBuffer := TProtectedData.Unprotect( encrypted ); // entschlüsseln
  Result := TEncoding.UTF8.GetString( outBuffer );
end;

Dazu habe ich einen unit-test gemacht:

Delphi-Quellcode:

procedure TTest_LoginCrypt.Test_Basic1();
var
  orginal: String;
  crypt: String;
  decrypt: String;
begin
  orginal := 'DesÜsch a Passwörd!';
  crypt := EncryptStringToBase64(orginal);
  decrypt := DecryptBase64ToString(crypt);
  CheckEquals(orginal, decrypt, 'decrypt');
end;

Der läuft gut. Anders sieht es mit dem nächsten aus.

Delphi-Quellcode:

procedure TTest_LoginCrypt.Test_Basic2();
const expected =
  'AQAAANCMnd8BFdERjHoAwE/Cl+sBAAAAR6WMUwdNMUWKnnyFGb2XNAAAAAACAAAAAAAQZgAAAAEAACAAAAB54/kNaa'+
  'FIZe84QZZTmPvuZ9asbR6NoCsGdTGhpYDS4AAAAAAOgAAAAAIAACAAAAD44yDX7VmMRv6NO3Sf1fBdJXAd6YmB1HRb'+
  '75aqGm1XCyAAAAAx+BMspmyEA9ymHt02gmt60xXA0JRYzzEtQirpBUSGvUAAAADD6HkiNivbUlSN1LW8293Bq7ktHA'+
  'ca7+3zscNrTPbfqo7zg/cQZLFhIPHVaW8Gqp+fsa9Nx3p4u/XRI0EdsT1n';
var
  orginal: String;
  crypt: String;
  decrypt: String;
begin
  orginal := 'DesÜsch a Passwörd!';
  crypt := EncryptStringToBase64(orginal);
  CheckEquals(expected, crypt, 'crypt');
  decrypt := DecryptBase64ToString(crypt);
  CheckEquals(orginal, decrypt, 'decrypt');
end;

Beim ersten Mal geht er schief, klar denke ich die Daten passen nicht. Ich kopiere mir die richtigen Daten aus dem Debugger oder unit-test Ergebnis raus. Aber bei jedem Durchlauf werden andere Daten erwartet.
Wo ist mein Denkfehler?

[Schokohase]

Weil bei jedem Protect mit einem zusätzlichen (zufälligem) Salt verschlüsselt wird (macht die API von selber). Dadurch ist die Verschlüsselte Code-Folge immer unterschiedlich auch wenn die zu verschlüsselnden Daten gleich sind.

[KodeZwerg]

Zitat:

Zitat von freimatz (Beitrag 1412529)

Vielleicht doch? ...
Den Code habe ich für meine Bedürfnisse erweitert. Ich bin Jetzt auf XE2. Dank Kodezwerg konnte ich das auch da zum Laufen bringen.
Bei der ersten Erweiterung geht um Base 64. Als Grundlage nahme ich das Beispiel oben mit "procedure SmallTest( );"

Also für Base64 nehm ich nix was aus einer Delphi Unit kommt, da bläht sich Datei mit viel ungenutzten Indy methoden auf.
Ich nutze sowas hier, ich wollte es ursprünglich auch als noch zwei weitere Helfer posten, aber ich kam mit Deinem Text nicht so ganz klar.
Hier ist mein Base64 Kompromiss der keine Speziellen Units braucht. Ob schneller oder langsamer als andere kann ich nicht sagen, habs noch nicht gebencht.

Delphi-Quellcode:

const
  Codes64 = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+/';

function Encode64(S: string): string;
var
  i: Integer;
  a: Integer;
  x: Integer;
  b: Integer;
begin
  Result := '';
  a := 0;
  b := 0;
  for i := 1 to Length(s) do
  begin
    x := Ord(s[i]);
    b := b * 256 + x;
    a := a + 8;
    while a >= 6 do
    begin
      a := a - 6;
      x := b div (1 shl a);
      b := b mod (1 shl a);
      Result := Result + Codes64[x + 1];
    end;
  end;
  if a > 0 then
  begin
    x := b shl (6 - a);
    Result := Result + Codes64[x + 1];
  end;
end;

function Decode64(S: string): string;
var
  i: Integer;
  a: Integer;
  x: Integer;
  b: Integer;
begin
  Result := '';
  a := 0;
  b := 0;
  for i := 1 to Length(s) do
  begin
    x := Pos(s[i], codes64) - 1;
    if x >= 0 then
    begin
      b := b * 64 + x;
      a := a + 6;
      if a >= 8 then
      begin
        a := a - 8;
        x := b shr a;
        b := b mod (1 shl a);
        x := x mod 256;
        Result := Result + chr(x);
      end;
    end
    else
      Exit;
  end;
end;

[KodeZwerg]

Zitat:

Zitat von Schokohase (Beitrag 1412530)

Weil bei jedem Protect mit einem zusätzlichen (zufälligem) Salt verschlüsselt wird (macht die API von selber). Dadurch ist die Verschlüsselte Code-Folge immer unterschiedlich auch wenn die zu verschlüsselnden Daten gleich sind.

Wenn ich das richtig gesehen habe, hast Du bereits ein Overload eingebaut damit man selbst den Salt bestimmen kann, was ja einem Passwort recht nahe kommt, zumindest für den Lokal Angemeldeten User. Oder ich verstehe da etwas falsch (AOptionalEntropy).

[Uwe Raabe]

Zitat:

Zitat von KodeZwerg (Beitrag 1412534)

Also für Base64 nehm ich nix was aus einer Delphi Unit kommt, da bläht sich Datei mit viel ungenutzten Indy methoden auf.

Das trifft aber seit einigen Delphi-Versionen nicht mehr zu. System.NetEncoding stellt Base64 recht einfach zur Verfügung und benötigt selbst auch nur System.Classes, System.SysUtils und System.RTLConsts - also Units, die vermutlich eh in jedem Programm schon eingebunden werden.

[Schokohase]

Zitat:

Zitat von KodeZwerg (Beitrag 1412535)

Zitat:

Zitat von Schokohase (Beitrag 1412530)

Weil bei jedem Protect mit einem zusätzlichen (zufälligem) Salt verschlüsselt wird (macht die API von selber). Dadurch ist die Verschlüsselte Code-Folge immer unterschiedlich auch wenn die zu verschlüsselnden Daten gleich sind.

Wenn ich das richtig gesehen habe, hast Du bereits ein Overload eingebaut damit man selbst den Salt bestimmen kann, was ja einem Passwort recht nahe kommt, zumindest für den Lokal Angemeldeten User. Oder ich verstehe da etwas falsch (AOptionalEntropy).

Ja, man kann damit Komplexität der Verschlüsselung zu vergrößern. Und ja, zum Entschlüsseln wird diese Bytefolge benötigt. Man könnte das durchaus im weitesten Sinne als Passwort verstehen.

Trotz allem bekommt man bei gleichen Eingangswerten beim Protect immer unterschiedliche Byte-Folgen zurück