[[seoane]]

Ahora mismo se utiliza bastante AES, y creo que por ahí andaba una librería para utilizarlo en delphi. También puedes mirar algo sobre encriptacion de curva elíptica, que también esta muy de moda.

Si no te esta persiguiendo la CIA , también puedes usar métodos mas sencillos. Aquí te dejo un poco de código que cree de hace algún tiempo, utiliza el algoritmo RC4 y solo utiliza funciones de la API de windows.

Código Delphi [-]
type
  HCRYPTPROV  = ULONG;
  PHCRYPTPROV = ^HCRYPTPROV;
  HCRYPTKEY   = ULONG;
  PHCRYPTKEY  = ^HCRYPTKEY;
  HCRYPTHASH  = ULONG;
  PHCRYPTHASH = ^HCRYPTHASH;
  LPAWSTR     = PAnsiChar;
  ALG_ID      = ULONG;

const
  CRYPT_NEWKEYSET = $00000008;
  PROV_RSA_FULL   = 1;
  ALG_TYPE_ANY    = 0;
  ALG_CLASS_HASH  = (4 shl 13);
  ALG_SID_MD5     = 3;
  CALG_MD5        = (ALG_CLASS_HASH or ALG_TYPE_ANY or ALG_SID_MD5);
  HP_HASHVAL      = $0002;
  ALG_CLASS_DATA_ENCRYPT = (3 shl 13);
  ALG_TYPE_STREAM = (4 shl 9);
  ALG_SID_RC4     = 1;
  CALG_RC4        = (ALG_CLASS_DATA_ENCRYPT or ALG_TYPE_STREAM or ALG_SID_RC4);


  function CryptAcquireContext(phProv       :PHCRYPTPROV;
                               pszContainer :LPAWSTR;
                               pszProvider  :LPAWSTR;
                               dwProvType   :DWORD;
                               dwFlags      :DWORD) :BOOL; stdcall;
    external ADVAPI32 name 'CryptAcquireContextA';
  function CryptCreateHash    (hProv   :HCRYPTPROV;
                               Algid   :ALG_ID;
                               hKey    :HCRYPTKEY;
                               dwFlags :DWORD;
                               phHash  :PHCRYPTHASH) :BOOL;stdcall;
    external ADVAPI32 name 'CryptCreateHash';
  function CryptHashData      (hHash             :HCRYPTHASH;
                               const pbData      :PBYTE;
                               dwDataLen         :DWORD;
                               dwFlags           :DWORD) :BOOL;stdcall;
    external ADVAPI32 name 'CryptHashData';
  function CryptEncrypt       (hKey       :HCRYPTKEY;
                               hHash      :HCRYPTHASH;
                               Final      :BOOL;
                               dwFlags    :DWORD;
                               pbData     :PBYTE;
                               pdwDataLen :PDWORD;
                               dwBufLen   :DWORD) :BOOL;stdcall;
    external ADVAPI32 name 'CryptEncrypt';
  function CryptDecrypt       (hKey       :HCRYPTKEY;
                               hHash      :HCRYPTHASH;
                               Final      :BOOL;
                               dwFlags    :DWORD;
                               pbData     :PBYTE;
                               pdwDataLen :PDWORD) :BOOL;stdcall;
    external ADVAPI32 name 'CryptDecrypt';
  function CryptDeriveKey     (hProv     :HCRYPTPROV;
                               Algid     :ALG_ID;
                               hBaseData :HCRYPTHASH;
                               dwFlags   :DWORD;
                               phKey     :PHCRYPTKEY) :BOOL;stdcall;
    external ADVAPI32 name 'CryptDeriveKey'; 
  function CryptDestroyHash   (hHash:HCRYPTHASH) :BOOL;stdcall;
    external ADVAPI32 name 'CryptDestroyHash';
  function CryptReleaseContext(hProv:HCRYPTPROV; dwFlags:DWORD):BOOL;stdcall;
    external ADVAPI32 name 'CryptReleaseContext';

function Cifrar(Texto, Password: string): string;
var
  hProv: HCRYPTPROV;
  hHash: HCRYPTHASH;
  hKey:  HCRYPTKEY;
  Success: BOOL;
  Buffer: array[0..1024] of Char;
  DataLen: DWORD;
  i: Integer;
begin
  Result:= '';
  Success:= CryptAcquireContext(@hProv, nil, nil, PROV_RSA_FULL, 0);
  if (not Success) then
    if GetLastError() = DWORD(NTE_BAD_KEYSET) then
      Success:= CryptAcquireContext(@hProv, nil, nil, PROV_RSA_FULL, CRYPT_NEWKEYSET);
  if Success then
    begin
      if CryptCreateHash(hProv, CALG_MD5, 0, 0, @hHash) then
        begin
          if CryptHashData(hHash, PByte(PChar(Password)), Length(Password), 0) then
            if CryptDeriveKey(hProv, CALG_RC4, hHash, $00800000, @hKey) then
            begin
              FillChar(Buffer,Sizeof(Buffer),0);
              StrLCopy(@Buffer,PChar(Texto),Sizeof(Buffer) - 1);
              DataLen:= StrLen(@Buffer);
              if CryptEncrypt(hKey, 0, TRUE, 0, PByte(@Buffer), @DataLen, Sizeof(Buffer)) then
              begin
                for i:= 0 to DataLen - 1 do
                  Result:= Result + IntToHex(Byte(Buffer[i]),2);
              end;
            end;
          CryptDestroyHash(hHash);
        end;
      CryptReleaseContext(hProv,0);
    end;
end;

function Descifrar(Texto, Password: string): string;
var
  hProv: HCRYPTPROV;
  hHash: HCRYPTHASH;
  hKey:  HCRYPTKEY;
  Success: BOOL;
  Buffer: array[0..1024] of Char;
  DataLen: DWORD;
  i,j: Integer;
begin
  Result:= '';
  if Length(Texto) = 0 then
    Exit;
  if Odd(Length(Texto)) then
    Exit;
  if (Length(Texto) shr 2) > (Sizeof(Buffer) - 1) then
    Exit;
  i:= 0;
  FillChar(Buffer,Sizeof(Buffer),0);
  while Length(Texto) > 0 do
  begin
    if TryStrToInt('$'+copy(Texto,1,2),j) then
    begin
      Buffer[i]:= Char(j);
      Delete(Texto,1,2);
      inc(i);
    end else Exit;
  end;
  Success:= CryptAcquireContext(@hProv, nil, nil, PROV_RSA_FULL, 0);
  if (not Success) then
    if GetLastError() = DWORD(NTE_BAD_KEYSET) then
      Success:= CryptAcquireContext(@hProv, nil, nil, PROV_RSA_FULL, CRYPT_NEWKEYSET);
  if Success then
    begin
      if CryptCreateHash(hProv, CALG_MD5, 0, 0, @hHash) then
        begin
          if CryptHashData(hHash, PByte(PChar(Password)), Length(Password), 0) then
            if CryptDeriveKey(hProv, CALG_RC4, hHash, $00800000, @hKey) then
            begin
              DataLen:= i;
              if CryptDecrypt(hKey, 0, TRUE, 0, PByte(@Buffer), @DataLen) then
              begin
                Result:= Copy(String(PChar(@Buffer)),1,DataLen);
              end;
            end;
          CryptDestroyHash(hHash);
        end;                          
      CryptReleaseContext(hProv,0);
    end;
end;