delphi AES encrypt

xe8 ok
unit TntLXCryptoUtils;

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( const Value : TIdBytes ) : string;

  var

    Encoder : TIdEncoderMIME;

  begin

    Encoder := TIdEncoderMIME.Create( nil );

    try

      Result := Encoder.EncodeBytes( Value );

    finally

      Encoder.Free;

    end;

  end;

function Base64_Decode( Value : string ) : TIdBytes;

  var

    Encoder : TIdDecoderMIME;

  begin

    Encoder := TIdDecoderMIME.Create( nil );

    try

      Result := 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_ = ;

  CALG_AES_ = ;

  CRYPT_NEWKEYSET = $;

  PROV_RSA_AES = ;

  KP_MODE = ;

  CRYPT_MODE_CBC = ;

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

    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_, , , hHash ) );

    try

      Win32Check( CryptHashData( hHash, PChar( Password ),

        Length( Password ) * SizeOf( Char ),  ) );

      Win32Check( CryptDeriveKey( m_hProv, CALG_AES_, hHash, , Result ) );

      // Wine uses a different default mode of CRYPT_MODE_EBC

      Mode := CRYPT_MODE_CBC;

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

    finally

      CryptDestroyHash( hHash );

    end;

  end;

procedure mybytes(

  const astr : string;

  var Buffer : TIdBytes );

  var

    abytes : TBytes;

  begin

    abytes := TEncoding.Unicode.GetBytes( astr );

    Buffer := RawToBytes( abytes, Length( abytes ) );

  end;

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

  var

    hCProv : HCRYPTPROV;

    hKey : HCRYPTKEY;

    lul_datalen : Integer;

    lul_buflen : Integer;

    Buffer : TIdBytes;

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

          mybytes( Value + '        ', Buffer );

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

          lul_buflen := Length( Buffer );

          // encrypt to buffer

          Win32Check( CryptEncrypt( hKey, , True, , @Buffer[  ], lul_datalen,

            lul_buflen ) );

          SetLength( Buffer, lul_datalen );

          // base 64 result

          Result := Base64_Encode( Buffer );

        finally

          CryptDestroyKey( hKey );

        end;

      finally

        CryptReleaseContext( hCProv,  );

      end;

    end;

  end;

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

  var

    hCProv : HCRYPTPROV;

    hKey : HCRYPTKEY;

    lul_datalen : Integer;

    Buffer : TIdBytes;

    abuffer : 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, , True, , @Buffer[  ],

            lul_datalen ) );

          BytesToRaw( Buffer, abuffer, lul_datalen );

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

        finally

          CryptDestroyKey( hKey );

        end;

      finally

        CryptReleaseContext( hCProv,  );

      end;

    end;

  end;

end.
秒客网

delphi AES encrypt

相关文章
