Procedure TEADecrypt

Code (Delphi)

procedure TEADecrypt(

const AKey: TTEAKey;

const AEncryptedData, AData: Pointer;

const ADataSize: Cardinal

); overload;

function TEADecrypt(

const AKey: TTEAKey;

const AEncryptedData: RawByteString

): RawByteString; overload;

procedure TEADecrypt(

const AKey: TTEAKey;

AInPlaceData: TEncryptBuffer

); overload;

Note

AData value can also point to the same place as AEncryptedData - to make "in place" decryption, but it is better to use overloaded variant of TEADecrypt with AInPlace parameter.

Tip

Using salt in TEADeriveKey function means that final size of encrypted/decrypted data will change - because salt must be stored with encrypted data. If you do not use salt - the data size will be the same. However, data size for TEADecrypt function is never changed (even if salt is used).

Important!

TEA has a few weaknesses. Most notably, it suffers from equivalent keys—each key is equivalent to three others, which means that the effective key size is only 126 bits. As a result, TEA is especially bad as a cryptographic hash function. TEA is also susceptible to a related-key attack which requires 2^23 chosen plaintexts under a related-key pair, with 2^32 time complexity.

Code (Delphi)

var

Key: TTEAKey;

MS: TMemoryStream;

Data: Pointer;

DataSize: Integer;

FS: TFileStream;

begin

MS := TMemoryStream.Create;

try

// Load C:\Text.bin file into MS

MS.LoadFromFile('C:\Text.bin');

// Allocate buffer for decryption - must have the same size

DataSize := MS.Size;

Data := AllocMem(DataSize);

try

// Create new key from password

Key := TEADeriveKey('password'); // - always the same for the same password

// Decrypt MS into Data

TEADecrypt(Key, MS.Memory, Data, MS.Size { same as DataSize } );

// Wipe key from memory - do this as soon as possible

TEADestroyKey(Key); // - same as SecureFree(Key);

// No longer needed, so we can safely delete it

SecureFree(MS);

// Save decrypted buffer into C:\Text.txt

FS := TFileStream.Create('C:\Text.txt', fmCreate or fmShareExclusive);

try

 FS.WriteBuffer(Data^, DataSize);

finally

 FreeAndNil(FS);

end;

finally

SecureFree(Data, DataSize);

end;

finally

FreeAndNil(MS);

end;

end;

Code (Delphi)

var

Key: TTEAKey;

EncryptedText: RawByteString;

S: String;

begin

// Create new key from password

Key := TEADeriveKey('password'); // - always the same for the same password

// Encrypt some text with the above key

// (meaning "encrypt some text with the above password")

EncryptedText := TEAEncrypt(Key, 'clear text');

// Wipe key from memory - do this as soon as possible

TEADestroyKey(Key); // - same as SecureFree(Key);

// EncryptedText contains encrypted RAW bytes

// Do not output EncryptedText to any place which expects human-readable text

// Debug output

// Encrypted text is RAW bytes, so we need to convert it to something readable

// Encrypted value will be the same for the same original text and password

Edit1.Text := HexEncodeString(EncryptedText);

// _____________________________________________

// Create new key from password

Key := TEADeriveKey('password'); // - always the same for the same password

// Decrypt text back

// Use encrypted RAW binary, not the hex-converted text

S := TEADecrypt(Key, EncryptedText);

// Wipe key from memory - do this as soon as possible

TEADestroyKey(Key); // - same as SecureFree(Key);

// Wipe also all data

SecureFree(EncryptedText);

// Now S = 'clear text'

// Call SecureFree for all data once you have finished working with it

SecureFree(S);

end;

Code (Delphi)

var

Key: TTEAKey;

EncryptedData: TEncryptBuffer;

FS: TFileStream;

begin

// Mark buffer as emtpy

EncryptedData.pbData := nil;

EncryptedData.cbData := 0;

try

// Load C:\Text.bin file into EncryptedData

FS := TFileStream.Create('C:\Text.bin', fmOpenRead or fmShareDenyWrite);

try

EncryptedData.cbData := FS.Size;

EncryptedData.pbData := AllocMem(EncryptedData.cbData);

FS.ReadBuffer(EncryptedData.pbData^, EncryptedData.cbData);

finally

FreeAndNil(FS);

end;

// Create new key from password

Key := TEADeriveKey('password'); // - always the same for the same password

// Decrypt EncryptedData in place

TEADecrypt(Key, EncryptedData);

// Wipe key from memory - do this as soon as possible

TEADestroyKey(Key); // - same as SecureFree(Key);

// EncryptedData now holds unencrypted "clear text" data

// Save "clear text" data into new file

FS := TFileStream.Create('C:\Text.txt', fmCreate or fmShareExclusive);

try

FS.WriteBuffer(EncryptedData.pbData^, EncryptedData.cbData);

finally

FreeAndNil(FS);

end;

finally

SecureFree(EncryptedData);

end;

end;