(Delphi DLL) AEAD AES 128-bit GCM

Demonstrates AES encryption using the Galois/Counter Mode (GCM). GCM is an authenticated encryption mode with "additional data" (often referred to as AEAD). GCM is a cipher mode that can be applied to any symmetric encryption algorithm with a 16-byte block size, such as AES and Twofish. In GCM mode, the block encryption algorithm is transformed into a stream encryption algorithm, and therefore no padding occurs (and the PaddingScheme property does not apply). The "additional data" (known as the AAD) does not get encrypted but plays a role in the computation of the resulting "authenticated tag".

Chilkat for Delphi Downloads Chilkat non-ActiveX DLL for Delphi Chilkat ActiveX DLL for Delphi * The examples here use the non-ActiveX DLL.

uses
    Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
    Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, Crypt2;

...

procedure TForm1.Button1Click(Sender: TObject);
var
crypt: HCkCrypt2;
K: PWideChar;
IV: PWideChar;
AAD: PWideChar;
PT: PWideChar;
CT: PWideChar;
T: PWideChar;
success: Boolean;
ctResult: PWideChar;
tResult: PWideChar;
ptResult: PWideChar;
tInvalid: PWideChar;

begin
// This example assumes the Chilkat API to have been previously unlocked.
// See Global Unlock Sample for sample code.

crypt := CkCrypt2_Create();

// Set the encryption algorithm to "AES"	
CkCrypt2_putCryptAlgorithm(crypt,'aes');

// Indicate that the Galois/Counter Mode (GCM) should be used:
CkCrypt2_putCipherMode(crypt,'gcm');

// KeyLength may be 128, 192, 256
CkCrypt2_putKeyLength(crypt,128);

// This is the 128-bit AES secret key (in hex format)
K := 'feffe9928665731c6d6a8f9467308308';

// This is the 16-byte initialization vector:
IV := 'cafebabefacedbaddecaf888';

// This is the additional data to be used as input to the GCM AEAD algorithm,
// but is not included in the output.  It plays a role in the computation of the
// resulting authenticated tag.
AAD := 'feedfacedeadbeeffeedfacedeadbeefabaddad2';

// The plain-text bytes (in hex format) to be encrypted.
PT := 'd9313225f88406e5a55909c5aff5269a86a7a9531534f7da2e4c303d8a318a721c3c0c95956809532fcf0e2449a6b525b16aedf5aa0de657ba637b39';

// The expected cipher text (in hex format)
CT := '42831ec2217774244b7221b784d0d49ce3aa212f2c02a4e035c17e2329aca12e21d514b25466931c7d8f6a5aac84aa051ba30b396a0aac973d58e091';

// The expected authenticated tag given the above inputs.
T := '5bc94fbc3221a5db94fae95ae7121a47';

// Note: The above data are the values for test vector #4 from 
// the PDF document at: http://csrc.nist.gov/groups/ST/toolkit/BCM/documents/proposedmodes/gcm/gcm-spec.pdf

// EncodingMode specifies the encoding of the output for
// encryption, and the input for decryption.
// It may be "hex", "url", "base64", or "quoted-printable".
CkCrypt2_putEncodingMode(crypt,'hex');

// Set the secret key and IV
CkCrypt2_SetEncodedIV(crypt,IV,'hex');
CkCrypt2_SetEncodedKey(crypt,K,'hex');

// Set the additional authenticated data (AAD)
success := CkCrypt2_SetEncodedAad(crypt,AAD,'hex');

// For the purpose of duplicating the test vectors, we are using the EncryptEncoded method.
// This method decodes the input string according to the encoding specified by the EncodingMode
// property, which in this case is "hex".  The decoded bytes are encrypted using the mode specified
// by the CipherMode property.  The resulting
// encrypted bytes are encoded (again using the encoding mode specified by EncodingMode),
// and the result is returned.
// <b>Note:</b> The CipherMode property sets the block mode of operation (gcm, cfb, cbc, ofb, ecb, etc.) 
// for any of the Chilkat encryption/decryption methods (such as EncryptBytes, EncryptString, 
// CkEncryptFile, etc.)   Just because GCM mode is demonstrated with EncryptEncoded/DecryptEncoded,
// does not imply that GCM mode is specific to only these methods.
ctResult := CkCrypt2__encryptEncoded(crypt,PT);
if (CkCrypt2_getLastMethodSuccess(crypt) <> True) then
  begin
    Memo1.Lines.Add(CkCrypt2__lastErrorText(crypt));
    Exit;
  end;

// Examine the result.  It should be the same (case insensitive) as our expected result:
Memo1.Lines.Add('computed result: ' + ctResult);
Memo1.Lines.Add('expected result: ' + CT);

// Examine the authenticated tag. It should be the same (case insensitive) as our expected authenticated tag:
tResult := CkCrypt2__getEncodedAuthTag(crypt,'hex');
Memo1.Lines.Add('computed authTag: ' + tResult);
Memo1.Lines.Add('expected authTag: ' + T);

// -------------------------------------------------------------------------------------
// Now let's GCM decrypt...
// -------------------------------------------------------------------------------------

// Before GCM decrypting, we must set the authenticated tag to the value that is expected.
// The decryption will fail if the resulting authenticated tag is not equal (case insensitive) to 
// the expected result.
// Note: The return value of SetEncodedAuthTag indicates whether the string passed was a valid
// representation of the encoding specified in the 2nd arg.
success := CkCrypt2_SetEncodedAuthTag(crypt,T,'hex');

// All of our properties (IV, secret key, cipher mode, and AAD) are already set from the code above...

// So let's decrypt CT to and check to see if we get PT.
ptResult := CkCrypt2__decryptEncoded(crypt,CT);
if (CkCrypt2_getLastMethodSuccess(crypt) <> True) then
  begin
    // Failed.  The resultant authenticated tag did not equal the expected authentication tag.
    Memo1.Lines.Add(CkCrypt2__lastErrorText(crypt));
    Exit;
  end;

// Examine the decrypted result.  It should be the same as our expected plaintext (case insensitive)
Memo1.Lines.Add('plaintext decrypted: ' + ptResult);
Memo1.Lines.Add('plaintext expected:  ' + PT);

// Let's intentionally set the expected authenticated tag to an incorrect value. 
// The decrypt operation should fail:
tInvalid := 'ffaabbbc3221a5db94fae95ae7121a47';

success := CkCrypt2_SetEncodedAuthTag(crypt,tInvalid,'hex');

ptResult := CkCrypt2__decryptEncoded(crypt,CT);
if (CkCrypt2_getLastMethodSuccess(crypt) <> True) then
  begin
    // Failed.  The resultant authenticated tag did not equal the expected authentication tag.
    Memo1.Lines.Add(CkCrypt2__lastErrorText(crypt));
  end;

CkCrypt2_Dispose(crypt);

end;