¿Cómo AES-128 encripta una cadena usando una contraseña en Delphi y descifra en C#?

encryption turbopower

Question

Me gustaría que AES-128 cifrara una cadena en Delphi con una contraseña. Me gustaría subir esto a mi servidor y ser capaz de descifrar dada la misma contraseña en C #.

En Delphi, estoy usando TurboPower LockBox 3:

function EncryptText_AES_128(input: string; password: string): string;
var
  Codec: TCodec;
  CipherText: AnsiString;
begin
  Codec := TCodec.Create(nil);
  try
    Codec.CryptoLibrary := TCryptographicLibrary.Create(Codec);
    //
    Codec.StreamCipherId := BlockCipher_ProgID;
    Codec.BlockCipherId := Format(AES_ProgId, [128]);
    Codec.ChainModeId := CBC_ProgId;
    //
    Codec.Password := Password;
    Codec.EncryptString(input, CipherText);
    //
    Result := string(CipherText);
  finally
    Codec.Free;
  end;
end;

¿Cómo puedo descifrar la cadena resultante en C #? Puedo cambiar el código Delphi. Nada está en producción todavía. Ni siquiera estoy atrapado en el uso de LockBox. Pero me gustaría evitar poner esto en una DLL para P / Invoke.

(Mi ejemplo muestra que mi secuencia cifrada es en sí misma una cadena. Esto no es un requisito para mí. Una secuencia de bytes está bien).

Answer 1

• No use LockBox 3. No es una biblioteca de buena calidad.
• No devuelva datos cifrados en cadenas de "texto". Los datos encriptados son secuencias arbitrarias de bytes, no cadenas (como datos de texto). Delphi usa cadenas de "longitud controlada" y puede almacenar casi cualquier cosa, pero puede que tenga problemas al pasar cadenas que contienen secuencias de bytes que podrían ser interpretadas de forma incorrecta por otros idiomas, es decir, $ 00 por una aplicación C / C ++. .). Si la biblioteca usa cadenas, bueno, es un síntoma, es una biblioteca de baja calidad
• ¡No transforme datos encriptados! Cuando conviertes tu ANSIString encriptado en un Unicode (creo que esa es la razón de tu último elenco), estás destruyendo el valor encriptado. Si pasa esa secuencia, no se podrá descifrar a menos que se aplique la transformación inversa, siempre que no sea "con pérdida".

Answer 2

A diferencia de cualquier cebo de llama trol que puedas leer, LockBox 3 es en realidad una biblioteca criptográfica de buena calidad. El cumplimiento de los estándares de LB3 es impecable. Es posible que tenga problemas de interoperabilidad con otros idiomas y bibliotecas en relación con las opciones que están fuera del estándar. Si utiliza Lockbox en el lado Delphi, entonces solo necesita asegurarse de que estas opciones se manejen de la misma manera en el lado del otro idioma. Si esto no es posible, entonces debe elegir otra biblioteca. Trataré con cada una de estas opciones a continuación.

No hay nada de malo con las soluciones alternativas (OpenSSL, CryptoAPI y Eldos). Algunos de ellos pueden ser black-box. Esto podría ser un problema para algunas personas.

1. Conversión de contraseña a clave. AES-128 usa una clave de 16 bytes. Además, el mecanismo estándar para generar una clave a partir de "datos clave" o "datos de contraseña" se basa de forma nativa en una semilla de entrada de 16 bytes. Es más seguro para la interoperabilidad generar la clave binaria a partir de la contraseña de cadena en el lado Delphi, y simplemente transportar la clave binaria al otro lado, en lugar de transportar la contraseña de cadena. Esto se debe a que el algoritmo para convertir una contraseña de cadena a una clave binaria de 16 bytes está fuera del estándar AES. Nether-the-less, puedes hacerlo de cualquier manera. Cuando a lockbox se le da una contraseña de cadena para inicializar un códec AES-128, mira la carga útil de la cadena como una matriz de bytes. Si la carga útil es precisamente de 16 bytes, entonces genial, se puede pasar directamente al algoritmo de generación de clave AES, que se especifica en el estándar. Si la carga útil de la cuerda no es precisamente de 16 bytes, la carga útil se reducirá a hash con SHA-1 para producir una salida de hash de 20 bytes. Los 16 bytes bajos de este hash se pasan a la función de generación de clave AES estándar. Por lo tanto, sus opciones para garantizar la interoperabilidad en relación con la inicialización de claves son:

   1.1. Transporte claves binarias en lugar de contraseñas de cadena.

   1.2. Si la Opción 1.2 es demasiado inconveniente, transporta la contraseña, pero imita el mismo algoritmo de contraseña a clave en el otro lado.

   1.3. Si 1 y 2 no funcionan por alguna razón, intente restringir las contraseñas a exactamente 16 bytes (8 caracteres UTF-8 o 16 puntos de código UTF-16). Esto debería ser bastante seguro si la implementación del otro idioma es medio decente.

2. Contraseñas UTF-16 contra ansi-string / UTF-8 Esto no es tanto una opción, sino una trampa para jugadores jóvenes. Los programadores tienden a pensar en "cadenas" como "cadenas". Pero no es así. En Delphi 2010, la carga de las cadenas se almacena en una codificación UTF-16LE con un tamaño de unidad de código de 2 bytes. Pero en otros lenguajes, como PHP y python, en el modo predeterminado, las cadenas son codificaciones de unidad de código de un byte, ya sea UTF-8 o algo basado en una base de página de códigos de MS Windows (que MS llama "ansistring"). Vale la pena recordar que la codificación UTF-16 de ''mypassword'' no es lo mismo que UTF-8 ''mypassword''.

3. Configuración IV. El estándar AES no trata la cuestión de cómo configurar el códec ''Vector de inicialización (IV). El tamaño del IV es el mismo que el del bloque subyacente. Para AES esto es 128 bits o 16 bytes. Al encriptar, lockbox crea un nonce de 16 bytes. Este nonce se convierte en el valor de IV, y se emite en el claro en la cabecera del mensaje de texto cifrado. Lea la documentación del método / política del otro lado para la inicialización IV. Tus opciones son:

   3.1 Si el otro lado lo antepone al texto cifrado, entonces eres dulce.

   3.2 De lo contrario, en el otro lado, al descifrar, lea los primeros 16 bytes del texto cifrado usted mismo, y pase el resto al códec foráneo. Antes de descifrar, dígale al códec extraño qué es el IV (suponiendo que su API sea capaz de hacerlo).

4. Cuantificación de bloques El tamaño de bloque AES es de 16 bytes. Cuando el mensaje de texto plano no es precisamente un múltiplo entero de 16 bytes, se debe hacer algo para convertirlo en un múltiplo completo. Este procedimiento se llama cuantificación de bloque y no se trata en el estándar, sino que queda en la implementación. Muchas implementaciones usarán relleno de bloques. No hay un esquema estándar de relleno de bloques y hay muchos para elegir. LockBox no usa relleno de bloque para CBC (otros modos pueden ser un caso diferente). Si el texto sin formato es un número entero de bloques, no se necesita ni se realiza ninguna cuantificación; de lo contrario, se utiliza el robo estándar de CipherText. Si el tamaño del texto simple es muy pequeño (entre 1 y 15 bytes) no es posible el robo de texto cifrado, y en su lugar se usa un esquema de relleno. Para garantizar la interoperabilidad en relación con la cuantificación de bloques, sus opciones son:

   4.1 Verifique su documentación para el códec foráneo en relación con la cuantificación de bloque (puede estar bajo el título de "relleno de mensaje"). Si el códec externo utiliza el robo de texto cifrado, entonces eres dulce (solo asegúrate de que no haya mensajes cortos).

   4.2 De lo contrario, podría hacer su propio relleno. En el lado de la caja de seguridad, la caja de seguridad no hace nada con los mensajes que ya están en bloques enteros. Es muy probable que el códec extranjero tenga la misma política, pero nuevamente debe verificar la documentación del códec extranjero.

Answer 3

Finalmente encontré una solución compatible entre Delphi y C # para AES-128. También funciona en Wine. Aquí está mi código Delphi:

unit TntLXCryptoUtils;

interface

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

implementation

uses
  SysUtils, Windows, IdCoderMIME, TntLXUtils;

//-------------------------------------------------------------------------------------------------------------------------
//    Base64 Encode/Decode
//-------------------------------------------------------------------------------------------------------------------------

function Base64_Encode(Value: TBytes): string;
var
  Encoder: TIdEncoderMIME;
begin
  Encoder := TIdEncoderMIME.Create(nil);
  try
    Result := Encoder.EncodeBytes(Value);
  finally
    Encoder.Free;
  end;
end;

function Base64_Decode(Value: string): TBytes;
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_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.

Y aquí está mi código C #:

public class TntCryptoUtils
{
    private static ICryptoTransform __Get_AES128_Transform(string password, bool AsDecryptor)
    {
        const int KEY_SIZE = 16;
        var sha256CryptoServiceProvider = new SHA256CryptoServiceProvider();
        var hash = sha256CryptoServiceProvider.ComputeHash(Encoding.Unicode.GetBytes(password));
        var key = new byte[KEY_SIZE];
        var iv = new byte[KEY_SIZE];
        Buffer.BlockCopy(hash, 0, key, 0, KEY_SIZE);
        //Buffer.BlockCopy(hash, KEY_SIZE, iv, 0, KEY_SIZE); // On the Windows side, the IV is always 0 (zero)
        //
        if (AsDecryptor)
            return new AesCryptoServiceProvider().CreateDecryptor(key, iv);
        else
            return new AesCryptoServiceProvider().CreateEncryptor(key, iv);
    }

    public static string AES128_Encrypt(string Value, string Password)
    {
        byte[] Buffer = Encoding.Unicode.GetBytes(Value);
        //
        using (ICryptoTransform transform = __Get_AES128_Transform(Password, false))
        {
            byte[] encyptedBlob = transform.TransformFinalBlock(Buffer, 0, Buffer.Length);
            return Convert.ToBase64String(encyptedBlob);
        }
    }

    public static string AES128_Decrypt(string Value, string Password)
    {
        byte[] Buffer = Convert.FromBase64String(Value);
        //
        using (ICryptoTransform transform = __Get_AES128_Transform(Password, true))
        {
            byte[] decyptedBlob = transform.TransformFinalBlock(Buffer, 0, Buffer.Length);
            return Encoding.Unicode.GetString(decyptedBlob);
        }
    }
}

Answer 4

Acabo de tener el mismo problema. Sé que este es un tema viejo, pero me ayudó mucho. Solo lo dejo aquí para el registro.

Function LockBoxDecrypt(Password As String, Data() As Byte) As String

    Dim AesProvider = AesCryptoServiceProvider.Create()
    Dim IV(15) As Byte, PaddedData(15) As Byte

    Array.Copy(Data, 0, IV, 0, 8)
    Array.Copy(Data, 8, PaddedData, 0, Data.Length - 8)

    AesProvider.Key = SHA1.Create().ComputeHash(Encoding.Default.GetBytes(Password)).Take(16).ToArray()
    AesProvider.IV = IV
    AesProvider.Mode = CipherMode.CFB
    AesProvider.Padding = PaddingMode.None

    Return Encoding.Default.GetString(AesProvider.CreateDecryptor().TransformFinalBlock(PaddedData, 0, PaddedData.Length), 0, Data.Length - 8)

End Function

Según la respuesta de Sean, supongo que el modo debería cambiarse a CTS cuando tenga más de 1 bloque. No lo intenté, porque 1 bloque es suficiente para mí, pero debería ser fácil adaptar el código.

Answer 5

Pude implementar con éxito el código Delphi de Troy en 10.2 Tokio con un par de modificaciones.

Eliminé TNTLxUtils de los Usos porque no era necesario (y no lo tenía) y agregué IdGlobal. La razón para usar IdGlobal es que necesita convertir el tipo TBytes a TIdBytes en la función Base64_Encode y TIBytes a TBytes en Base64_Decode.

Nota: Esta unidad solo funcionará en aplicaciones de 32 bits ya que hace referencia a la API de Windows de 32 bits.

Gracias, Troy, por apuntarme en la dirección correcta para obtener un método de cifrado gratuito que no requiera la compra de un kit de herramientas para implementar.

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.