SQL Server

AEAD AES 128-bit GCM

See more Encryption Examples

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". SQL Server

-- Important: See this note about string length limitations for strings returned by sp_OAMethod calls.
--
CREATE PROCEDURE ChilkatSample
AS
BEGIN
    DECLARE @hr int
    DECLARE @iTmp0 int
    -- Important: Do not use nvarchar(max).  See the warning about using nvarchar(max).
    DECLARE @sTmp0 nvarchar(4000)
    DECLARE @success int
    SELECT @success = 0

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

    DECLARE @crypt int
    EXEC @hr = sp_OACreate 'Chilkat.Crypt2', @crypt OUT
    IF @hr <> 0
    BEGIN
        PRINT 'Failed to create ActiveX component'
        RETURN
    END

    -- Set the encryption algorithm to "AES"	
    EXEC sp_OASetProperty @crypt, 'CryptAlgorithm', 'aes'

    -- Indicate that the Galois/Counter Mode (GCM) should be used:
    EXEC sp_OASetProperty @crypt, 'CipherMode', 'gcm'

    -- KeyLength may be 128, 192, 256
    EXEC sp_OASetProperty @crypt, 'KeyLength', 128

    -- This is the 128-bit AES secret key (in hex format)
    DECLARE @K nvarchar(4000)
    SELECT @K = 'feffe9928665731c6d6a8f9467308308'

    -- This is the 16-byte initialization vector:
    DECLARE @IV nvarchar(4000)
    SELECT @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.
    DECLARE @AAD nvarchar(4000)
    SELECT @AAD = 'feedfacedeadbeeffeedfacedeadbeefabaddad2'

    -- The plain-text bytes (in hex format) to be encrypted.
    DECLARE @PT nvarchar(4000)
    SELECT @PT = 'd9313225f88406e5a55909c5aff5269a86a7a9531534f7da2e4c303d8a318a721c3c0c95956809532fcf0e2449a6b525b16aedf5aa0de657ba637b39'

    -- The expected cipher text (in hex format)
    DECLARE @CT nvarchar(4000)
    SELECT @CT = '42831ec2217774244b7221b784d0d49ce3aa212f2c02a4e035c17e2329aca12e21d514b25466931c7d8f6a5aac84aa051ba30b396a0aac973d58e091'

    -- The expected authenticated tag given the above inputs.
    DECLARE @T nvarchar(4000)
    SELECT @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".
    EXEC sp_OASetProperty @crypt, 'EncodingMode', 'hex'

    -- Set the secret key and IV
    EXEC sp_OAMethod @crypt, 'SetEncodedIV', NULL, @IV, 'hex'
    EXEC sp_OAMethod @crypt, 'SetEncodedKey', NULL, @K, 'hex'

    -- Set the additional authenticated data (AAD)
    EXEC sp_OAMethod @crypt, 'SetEncodedAad', @success OUT, @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.
    DECLARE @ctResult nvarchar(4000)
    EXEC sp_OAMethod @crypt, 'EncryptEncoded', @ctResult OUT, @PT
    EXEC sp_OAGetProperty @crypt, 'LastMethodSuccess', @iTmp0 OUT
    IF @iTmp0 <> 1
      BEGIN
        EXEC sp_OAGetProperty @crypt, 'LastErrorText', @sTmp0 OUT
        PRINT @sTmp0
        EXEC @hr = sp_OADestroy @crypt
        RETURN
      END

    -- Examine the result.  It should be the same (case insensitive) as our expected result:

    PRINT 'computed result: ' + @ctResult

    PRINT 'expected result: ' + @CT

    -- Examine the authenticated tag. It should be the same (case insensitive) as our expected authenticated tag:
    DECLARE @tResult nvarchar(4000)
    EXEC sp_OAMethod @crypt, 'GetEncodedAuthTag', @tResult OUT, 'hex'

    PRINT 'computed authTag: ' + @tResult

    PRINT '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.
    EXEC sp_OAMethod @crypt, 'SetEncodedAuthTag', @success OUT, @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.
    DECLARE @ptResult nvarchar(4000)
    EXEC sp_OAMethod @crypt, 'DecryptEncoded', @ptResult OUT, @CT
    EXEC sp_OAGetProperty @crypt, 'LastMethodSuccess', @iTmp0 OUT
    IF @iTmp0 <> 1
      BEGIN
        -- Failed.  The resultant authenticated tag did not equal the expected authentication tag.
        EXEC sp_OAGetProperty @crypt, 'LastErrorText', @sTmp0 OUT
        PRINT @sTmp0
        EXEC @hr = sp_OADestroy @crypt
        RETURN
      END

    -- Examine the decrypted result.  It should be the same as our expected plaintext (case insensitive)

    PRINT 'plaintext decrypted: ' + @ptResult

    PRINT 'plaintext expected:  ' + @PT

    -- Let's intentionally set the expected authenticated tag to an incorrect value. 
    -- The decrypt operation should fail:
    DECLARE @tInvalid nvarchar(4000)
    SELECT @tInvalid = 'ffaabbbc3221a5db94fae95ae7121a47'

    EXEC sp_OAMethod @crypt, 'SetEncodedAuthTag', @success OUT, @tInvalid, 'hex'

    EXEC sp_OAMethod @crypt, 'DecryptEncoded', @ptResult OUT, @CT
    EXEC sp_OAGetProperty @crypt, 'LastMethodSuccess', @iTmp0 OUT
    IF @iTmp0 <> 1
      BEGIN
        -- Failed.  The resultant authenticated tag did not equal the expected authentication tag.
        EXEC sp_OAGetProperty @crypt, 'LastErrorText', @sTmp0 OUT
        PRINT @sTmp0
      END

    EXEC @hr = sp_OADestroy @crypt


END
GO