Procedure TEAEncrypt

Code (Delphi)

procedure TEAEncrypt(

const AKey: TTEAKey;

const AData, AEncryptedData: Pointer;

const ADataSize: Cardinal

); overload;

function TEAEncrypt(

const AKey: TTEAKey;

const AData: RawByteString

): RawByteString; overload;

procedure TEAEncrypt(

const AKey: TTEAKey;

AInPlaceData: TEncryptBuffer

); overload;

Note

AEncryptedData value can also point to the same place as AData - to make "in place" encryption, but it is better to use overloaded variant of TEAEncrypt 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 TEAEncrypt 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;

EncryptedData: Pointer;

EncryptedDataSize: Integer;

FS: TFileStream;

begin

MS := TMemoryStream.Create;

try

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

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

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

EncryptedDataSize := MS.Size;

EncryptedData := AllocMem(EncryptedDataSize);

try

// Create new key from password

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

// Encrypt MS into EncryptedData

TEAEncrypt(Key, MS.Memory, EncryptedData, MS.Size { same as EncryptedDataSize } );

// 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 encrypted buffer into C:\Text.bin

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

try

 FS.WriteBuffer(EncryptedData^, EncryptedDataSize);

finally

 FreeAndNil(FS);

end;

finally

SecureFree(EncryptedData, EncryptedDataSize);

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;

Data: TEncryptBuffer;

FS: TFileStream;

begin

// Mark buffer as emtpy

Data.pbData := nil;

Data.cbData := 0;

try

// Load C:\Text.txt file into Data

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

try

Data.cbData := FS.Size;

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

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

finally

FreeAndNil(FS);

end;

// Create new key from password

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

// Encrypt Data in place

TEAEncrypt(Key, Data);

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

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

// Data now holds encrypted binary data

// Debug output

Memo1.Lines.Text := HexEncodeToString(Data.pbData, Data.cbData);

// Save encrypted data into new file

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

try

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

finally

FreeAndNil(FS);

end;

finally

SecureFree(Data);

end;

end;