Shop-Zugangsdaten verschlüsseln

[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 von 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.

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).

[Schokohase]

Zitat von KodeZwerg:

Zitat von 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.

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

[Hobbycoder]

Also bei mir klappt das wunderbar.

Man könnte das ganze noch zur vereinfachten Verwendung noch um ein paar Methoden erweitern, damit es jeder direkt verwenden kann.

Delphi-Quellcode:

uses
   System.SysUtils, System.NetEncoding;

type
  function ProtectData(data: string): TBytes;
  function UnprotectData(data: TBytes): string;
  function ProtectString(data: string): string;
  function UnprotectString(data: string): string;

implementation

function ProtectData(data: string): TBytes;
var
  inBuffer: TBytes;
begin
  inBuffer:=TEncoding.UTF8.GetBytes(data);
  Result:=TProtectedData.Protect(inBuffer);
end;

function UnprotectData(data: TBytes): string;
var
  outBuffer: TBytes;
begin
  outBuffer:=TProtectedData.Unprotect(data);
  Result:=TEncoding.UTF8.GetString(outBuffer)
end;

function ProtectString(data: string): string;
var
  ne: TNetEncoding;
  Buffer: TBytes;
begin
  ne:=TNetEncoding.Create;
  try
    Buffer:=ProtectData(data);
    Result:=ne.Base64.EncodeBytesToString(Buffer);
  finally
    ne.Free;
  end;
end;

function UnprotectString(data: string): string;
var
  ne: TNetEncoding;
  Buffer: TBytes;
begin
  ne:=TNetEncoding.Create;
  try
    Buffer:=ne.Base64.DecodeStringToBytes(data);
    Result:=UnprotectData(Buffer);
  finally
    ne.Free;
  end;
end;

end.

Und um diese Daten auch in INI-Datei zu speichern:

Delphi-Quellcode:

procedure WriteMultiLineStringToIni(ini: TIniFile; Section: string; Ident: string; Value: string);
var
  i: Integer;
  sl: TStringList;
begin
  sl:=TStringList.Create;
  try
    sl.Text:=Value;
    for i:=sl.Count-1 downto 0 do
      if sl[i]='' then sl.Delete(i);
    ini.WriteInteger(Section, Ident+'Count', sl.Count);
    for i:=0 to sl.Count-1 do
      ini.WriteString(Section, Ident+inttostr(i), sl[i]);
  finally
    sl.Free;
  end;
end;

function ReadMultilineStringFromIni(ini: TIniFile; Section: string; Ident: string): string;
var
  i, count: Integer;
  sl: TStringList;
begin
  sl:=TStringList.Create;
  try
    Result:='';
    if ini.SectionExists(Section) then
    begin
      if ini.ValueExists(Section, Ident+'Count') then
      begin
        count:=ini.ReadInteger(Section, Ident+'Count', 0);
        for i:=0 to Count-1 do
          sl.Add(ini.ReadString(Section, Ident+inttostr(i), ''));
        for i:=sl.Count-1 downto 0 do
          if sl[i]='' then sl.Delete(i);
        Result:=sl.Text;
      end;
    end;
  finally
    sl.Free;
  end;
end;

[KodeZwerg]

Zitat von Schokohase:

Zitat von KodeZwerg:

Zitat von 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.

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

Da hatte ich doch glatt vergessen Danke zu Sagen. Das man einen Wert nicht hardcoden sollte, dessen war ich mir bewusst. Ein entschlüsseln sollte hingegen immer funktionieren, egal aus welcher unique variation generation es entstammt. Das AOptionalEntropy kann man Hardcoden aber ob es da noch einen Unterschied macht, das kodierte ist ja bereits auf eine Maschiene/Benutzerkonto limitiert, zumindest gäbe es damit noch ein fünkchen mehr Sicherheit/Einfluss. Ich finde es eine gute Windows dreingabe, die man dank Dir nun einfach nutzen kann.

[Codehunter]

Ich habe hier mit Freude mitgelesen und muss sagen, so einfach und verständlich wurde dieses Thema hier noch nie abgehandelt. Ich hatte vor Jahren hier das selbe aufgeworfen. Da wurde es sehr abstrakt. Im Grunde habt ihr jetzt 5 Jahre später die Lösung auf dem Silbertablett serviert

[freimatz]

Auch von mir wieder ein Danke.
In der Zwischenzeit habe ich die unit-tests verlassen und bin dabei das im Produktiv-Code zu verwenden. Für Base64 verwende ich nun auch TNetEncoding. Allerdings entferne ich alle Zeilenumbrüche.

[KodeZwerg]

Zitat von 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( );"

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;

[Uwe Raabe]

Zitat von KodeZwerg:

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.