Delphi-PRAXiS - Delphi AES Verschlüsselung

Hallo,

ich möchte Strings mit AES verschlüsseln

habe folgendes gefunden:

Code:

			unit cryptoUtils;

interface

function AES128_Encrypt(Value, Password: string): string;

function AES128_Decrypt(Value, Password: string): string;

implementation

uses

  SysUtils, Windows, IdCoderMIME, IdGlobal;

//-------------------------------------------------------------------------------------------------------------------------

//    Base64 Encode/Decode

//-------------------------------------------------------------------------------------------------------------------------

function Base64_Encode(Value: TBytes): string;

var

  Encoder: TIdEncoderMIME;

begin

  Encoder := TIdEncoderMIME.Create(nil);

  try

    Result := Encoder.EncodeBytes(TIdBytes(Value));

  finally

    Encoder.Free;

  end;

end;

function Base64_Decode(Value: string): TBytes;

var

  Encoder: TIdDecoderMIME;

begin

  Encoder := TIdDecoderMIME.Create(nil);

  try

    Result := TBytes(Encoder.DecodeBytes(Value));

  finally

    Encoder.Free;

  end;

end;

//-------------------------------------------------------------------------------------------------------------------------

//    WinCrypt.h

//-------------------------------------------------------------------------------------------------------------------------

type

  HCRYPTPROV  = Cardinal;

  HCRYPTKEY   = Cardinal;

  ALG_ID      = Cardinal;

  HCRYPTHASH  = Cardinal;

const

  _lib_ADVAPI32    = 'ADVAPI32.dll';

  CALG_SHA_256     = 32780;

  CALG_AES_128     = 26126;

  CRYPT_NEWKEYSET  = $00000008;

  PROV_RSA_AES     = 24;

  KP_MODE          = 4;

  CRYPT_MODE_CBC   = 1;

function CryptAcquireContext(var Prov: HCRYPTPROV; Container: PChar; Provider: PChar; ProvType: LongWord; Flags: LongWord): LongBool; stdcall; external _lib_ADVAPI32 name 'CryptAcquireContextW';

function CryptDeriveKey(Prov: HCRYPTPROV; Algid: ALG_ID; BaseData: HCRYPTHASH; Flags: LongWord; var Key: HCRYPTKEY): LongBool; stdcall; external _lib_ADVAPI32 name 'CryptDeriveKey';

function CryptSetKeyParam(hKey: HCRYPTKEY; dwParam: LongInt; pbData: PBYTE; dwFlags: LongInt): LongBool stdcall; stdcall; external _lib_ADVAPI32 name 'CryptSetKeyParam';

function CryptEncrypt(Key: HCRYPTKEY; Hash: HCRYPTHASH; Final: LongBool; Flags: LongWord; pbData: PBYTE; var Len: LongInt; BufLen: LongInt): LongBool;stdcall;external _lib_ADVAPI32 name 'CryptEncrypt';

function CryptDecrypt(Key: HCRYPTKEY; Hash: HCRYPTHASH; Final: LongBool; Flags: LongWord; pbData: PBYTE; var Len: LongInt): LongBool; stdcall; external _lib_ADVAPI32 name 'CryptDecrypt';

function CryptCreateHash(Prov: HCRYPTPROV; Algid: ALG_ID; Key: HCRYPTKEY; Flags: LongWord; var Hash: HCRYPTHASH): LongBool; stdcall; external _lib_ADVAPI32 name 'CryptCreateHash';

function CryptHashData(Hash: HCRYPTHASH; Data: PChar; DataLen: LongWord; Flags: LongWord): LongBool; stdcall; external _lib_ADVAPI32 name 'CryptHashData';

function CryptReleaseContext(hProv: HCRYPTPROV; dwFlags: LongWord): LongBool; stdcall; external _lib_ADVAPI32 name 'CryptReleaseContext';

function CryptDestroyHash(hHash: HCRYPTHASH): LongBool; stdcall; external _lib_ADVAPI32 name 'CryptDestroyHash';

function CryptDestroyKey(hKey: HCRYPTKEY): LongBool; stdcall; external _lib_ADVAPI32 name 'CryptDestroyKey';

//-------------------------------------------------------------------------------------------------------------------------

{$WARN SYMBOL_PLATFORM OFF}

function __CryptAcquireContext(ProviderType: Integer): HCRYPTPROV;

begin

  if (not CryptAcquireContext(Result, nil, nil, ProviderType, 0)) then

  begin

    if HRESULT(GetLastError) = NTE_BAD_KEYSET then

      Win32Check(CryptAcquireContext(Result, nil, nil, ProviderType, CRYPT_NEWKEYSET))

    else

      RaiseLastOSError;

  end;

end;

function __AES128_DeriveKeyFromPassword(m_hProv: HCRYPTPROV; Password: string): HCRYPTKEY;

var

  hHash: HCRYPTHASH;

  Mode: DWORD;

begin

  Win32Check(CryptCreateHash(m_hProv, CALG_SHA_256, 0, 0, hHash));

  try

    Win32Check(CryptHashData(hHash, PChar(Password), Length(Password) * SizeOf(Char), 0));

    Win32Check(CryptDeriveKey(m_hProv, CALG_AES_128, hHash, 0, Result));

    // Wine uses a different default mode of CRYPT_MODE_EBC

    Mode := CRYPT_MODE_CBC;

    Win32Check(CryptSetKeyParam(Result, KP_MODE, Pointer(@Mode), 0));

  finally

    CryptDestroyHash(hHash);

  end;

end;

function AES128_Encrypt(Value, Password: string): string;

var

  hCProv: HCRYPTPROV;

  hKey: HCRYPTKEY;

  lul_datalen: Integer;

  lul_buflen: Integer;

  Buffer: TBytes;

begin

  Assert(Password <> '');

  if (Value = '') then

    Result := ''

  else begin

    hCProv := __CryptAcquireContext(PROV_RSA_AES);

    try

      hKey := __AES128_DeriveKeyFromPassword(hCProv, Password);

      try

        // allocate buffer space

        lul_datalen := Length(Value) * SizeOf(Char);

        Buffer := TEncoding.Unicode.GetBytes(Value + '        ');

        lul_buflen := Length(Buffer);

        // encrypt to buffer

        Win32Check(CryptEncrypt(hKey, 0, True, 0, @Buffer[0], lul_datalen, lul_buflen));

        SetLength(Buffer, lul_datalen);

        // base 64 result

        Result := Base64_Encode(Buffer);

      finally

        CryptDestroyKey(hKey);

      end;

    finally

      CryptReleaseContext(hCProv, 0);

    end;

  end;

end;

function AES128_Decrypt(Value, Password: string): string;

var

  hCProv: HCRYPTPROV;

  hKey: HCRYPTKEY;

  lul_datalen: Integer;

  Buffer: TBytes;

begin

  Assert(Password <> '');

  if Value = '' then

    Result := ''

  else begin

    hCProv := __CryptAcquireContext(PROV_RSA_AES);

    try

      hKey := __AES128_DeriveKeyFromPassword(hCProv, Password);

      try

        // decode base64

        Buffer := Base64_Decode(Value);

        // allocate buffer space

        lul_datalen := Length(Buffer);

        // decrypt buffer to to string

        Win32Check(CryptDecrypt(hKey, 0, True, 0, @Buffer[0], lul_datalen));

        Result := TEncoding.Unicode.GetString(Buffer, 0, lul_datalen);

      finally

        CryptDestroyKey(hKey);

      end;

    finally

      CryptReleaseContext(hCProv, 0);

    end;

  end;

end;

end.

sdimain.dfm

Code:

			unit SDIMAIN;

interface

uses Winapi.Windows, System.Classes, Vcl.Graphics, Vcl.Forms, Vcl.Controls,

  Vcl.Menus, Vcl.Dialogs, Vcl.StdCtrls, Vcl.Buttons, Vcl.ExtCtrls, Vcl.ComCtrls,

  Vcl.ImgList, Vcl.StdActns, Vcl.ActnList, Vcl.ToolWin, System.ImageList,

  System.Actions, CryptoUtils;

type

  TSDIAppForm = class(TForm)

    txtText: TEdit;

    Label1: TLabel;

    txtCrypt: TEdit;

    Button2: TButton;

    btnEncrypt: TButton;

    Label2: TLabel;

    txtPasswort: TEdit;

    Label3: TLabel;

    procedure btnEncryptClick(Sender: TObject);

    procedure Button2Click(Sender: TObject);

    procedure FormCreate(Sender: TObject);

  private

    { Private-Deklarationen }

  public

    { Public-Deklarationen }

  end;

var

  SDIAppForm: TSDIAppForm;

implementation

{$R *.dfm}

procedure TSDIAppForm.btnEncryptClick(Sender: TObject);

begin

txtCrypt.Text:= AES128_Encrypt(txttext.Text,txtPasswort.text)

end;

procedure TSDIAppForm.Button2Click(Sender: TObject);

begin

txttext.text:= AES128_Decrypt(txtcrypt.Text,txtPasswort.text)

end;

procedure TSDIAppForm.FormCreate(Sender: TObject);

begin

end;

end.

gebe ich nun
in txtcrypt = asdf und txtpasswort asdf ein (wo ja nichts rauskommen kann) erhalte ich folgenden Fehler:
EOSError mit der Meldung 'Systemfehler. Code: -2146893819. Ungültige Daten'

Nutze ich den korrekten verschlüsselungsstring und das korrekte passwort , entschlüsselt er mir das auch korrekt, was mache ich falsch ?