test_aes_gcm.c

Tests from NIST SP 800-38D

/* Copyright (c) 2014 Cameron Harper
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 * the Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * */

#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>

#include "cmocka.h"

#include "aes.h"
#include "aes_gcm.h"

static void test_MODA_AES_GCM_Encrypt_notext_noaad(void **user)
{
    static const uint8_t key[] = {0x11,0x75,0x4c,0xd7,0x2a,0xec,0x30,0x9b,0xf5,0x2f,0x76,0x87,0x21,0x2e,0x89,0x57};
    static const uint8_t iv[] = {0x3c,0x81,0x9d,0x9a,0x9b,0xed,0x08,0x76,0x15,0x03,0x0b,0x65};
//    static const uint8_t pt[] = {};
//    static const uint8_t aad[] = {};
//    static const uint8_t ct[] = {};
    static const uint8_t tag[] = {0x25,0x03,0x27,0xc6,0x74,0xaa,0xf4,0x77,0xae,0xf2,0x67,0x57,0x48,0xcf,0x69,0x71};

    struct aes_ctxt aes;
    uint8_t out[AES_BLOCK_SIZE];

    MODA_AES_Init(&aes, AES_KEY_128, key);
    MODA_AES_GCM_Encrypt(&aes, iv, sizeof(iv), NULL, NULL, 0, NULL, 0, out, sizeof(tag));

    assert_memory_equal(tag, out, sizeof(tag));
}

static void test_MODA_AES_GCM_Encrypt_notext(void **user)
{
    static const uint8_t key[] = {0x77,0xbe,0x63,0x70,0x89,0x71,0xc4,0xe2,0x40,0xd1,0xcb,0x79,0xe8,0xd7,0x7f,0xeb};
    static const uint8_t iv[] = {0xe0,0xe0,0x0f,0x19,0xfe,0xd7,0xba,0x01,0x36,0xa7,0x97,0xf3};
//    static const uint8_t pt[] = {};
    static const uint8_t aad[] = {0x7a,0x43,0xec,0x1d,0x9c,0x0a,0x5a,0x78,0xa0,0xb1,0x65,0x33,0xa6,0x21,0x3c,0xab};
//    static const uint8_t ct[] = {};
    static const uint8_t tag[] = {0x20,0x9f,0xcc,0x8d,0x36,0x75,0xed,0x93,0x8e,0x9c,0x71,0x66,0x70,0x9d,0xd9,0x46};

    struct aes_ctxt aes;
    uint8_t out[AES_BLOCK_SIZE];

    MODA_AES_Init(&aes, AES_KEY_128, key);
    MODA_AES_GCM_Encrypt(&aes, iv, sizeof(iv), NULL, NULL, 0, aad, sizeof(aad), out, sizeof(tag));

    assert_memory_equal(tag, out, sizeof(tag));
}

static void test_MODA_AES_GCM_Encrypt_notext_partaad(void **user)
{
    static const uint8_t key[] = {0x2f,0xb4,0x5e,0x5b,0x8f,0x99,0x3a,0x2b,0xfe,0xbc,0x4b,0x15,0xb5,0x33,0xe0,0xb4};
    static const uint8_t iv[] = {0x5b,0x05,0x75,0x5f,0x98,0x4d,0x2b,0x90,0xf9,0x4b,0x80,0x27};
//    static const uint8_t pt[] = {};
    static const uint8_t aad[] = {0xe8,0x54,0x91,0xb2,0x20,0x2c,0xaf,0x1d,0x7d,0xce,0x03,0xb9,0x7e,0x09,0x33,0x1c,0x32,0x47,0x39,0x41};
//    static const uint8_t ct[] = {};
    static const uint8_t tag[] = {0xc7,0x5b,0x78,0x32,0xb2,0xa2,0xd9,0xbd,0x82,0x74,0x12,0xb6,0xef,0x57,0x69,0xdb};

    struct aes_ctxt aes;
    uint8_t out[AES_BLOCK_SIZE];

    MODA_AES_Init(&aes, AES_KEY_128, key);
    MODA_AES_GCM_Encrypt(&aes, iv, sizeof(iv), NULL, NULL, 0, aad, sizeof(aad), out, sizeof(tag));

    assert_memory_equal(tag, out, sizeof(tag));
}

static void test_MODA_AES_GCM_Encrypt_noaad(void **user)
{
    static const uint8_t key[] = {0x7f,0xdd,0xb5,0x74,0x53,0xc2,0x41,0xd0,0x3e,0xfb,0xed,0x3a,0xc4,0x4e,0x37,0x1c};
    static const uint8_t iv[] = {0xee,0x28,0x3a,0x3f,0xc7,0x55,0x75,0xe3,0x3e,0xfd,0x48,0x87};
    static const uint8_t pt[] = {0xd5,0xde,0x42,0xb4,0x61,0x64,0x6c,0x25,0x5c,0x87,0xbd,0x29,0x62,0xd3,0xb9,0xa2};
//    static const uint8_t aad[] = {};
    static const uint8_t ct[] = {0x2c,0xcd,0xa4,0xa5,0x41,0x5c,0xb9,0x1e,0x13,0x5c,0x2a,0x0f,0x78,0xc9,0xb2,0xfd};
    static const uint8_t tag[] = {0xb3,0x6d,0x1d,0xf9,0xb9,0xd5,0xe5,0x96,0xf8,0x3e,0x8b,0x7f,0x52,0x97,0x1c,0xb3};

    struct aes_ctxt aes;
    uint8_t outText[sizeof(pt)];
    uint8_t outTag[sizeof(tag)];

    MODA_AES_Init(&aes, AES_KEY_128, key);
    MODA_AES_GCM_Encrypt(&aes, iv, sizeof(iv), outText, pt, sizeof(pt), NULL, 0, outTag, sizeof(outTag));

    assert_memory_equal(tag, outTag, sizeof(outTag));
    assert_memory_equal(ct, outText, sizeof(outText));
}

static void test_MODA_AES_GCM_Encrypt_parttext_noaad(void **user)
{
    static const uint8_t key[] = {0xfe,0x9b,0xb4,0x7d,0xeb,0x3a,0x61,0xe4,0x23,0xc2,0x23,0x18,0x41,0xcf,0xd1,0xfb};
    static const uint8_t iv[] = {0x4d,0x32,0x8e,0xb7,0x76,0xf5,0x00,0xa2,0xf7,0xfb,0x47,0xaa};
    static const uint8_t pt[] = {0xf1,0xcc,0x38,0x18,0xe4,0x21,0x87,0x6b,0xb6,0xb8,0xbb,0xd6,0xc9};

    static const uint8_t ct[] = {0xb8,0x8c,0x5c,0x19,0x77,0xb3,0x5b,0x51,0x7b,0x0a,0xea,0xe9,0x67};
    static const uint8_t tag[] = {0x43,0xfd,0x47,0x27,0xfe,0x5c,0xdb,0x4b,0x5b,0x42,0x81,0x8d,0xea,0x7e,0xf8,0xc9};

    struct aes_ctxt aes;
    uint8_t outText[sizeof(pt)];
    uint8_t outTag[sizeof(tag)];

    MODA_AES_Init(&aes, AES_KEY_128, key);
    MODA_AES_GCM_Encrypt(&aes, iv, sizeof(iv), outText, pt, sizeof(pt), NULL, 0, outTag, sizeof(outTag));

    assert_memory_equal(tag, outTag, sizeof(outTag));
    assert_memory_equal(ct, outText, sizeof(outText));
}

static void test_MODA_AES_GCM_Encrypt(void **user)
{
    static const uint8_t key[] = {0xc9,0x39,0xcc,0x13,0x39,0x7c,0x1d,0x37,0xde,0x6a,0xe0,0xe1,0xcb,0x7c,0x42,0x3c};
    static const uint8_t iv[] = {0xb3,0xd8,0xcc,0x01,0x7c,0xbb,0x89,0xb3,0x9e,0x0f,0x67,0xe2};
    static const uint8_t pt[] = {0xc3,0xb3,0xc4,0x1f,0x11,0x3a,0x31,0xb7,0x3d,0x9a,0x5c,0xd4,0x32,0x10,0x30,0x69};
    static const uint8_t aad[] = {0x24,0x82,0x56,0x02,0xbd,0x12,0xa9,0x84,0xe0,0x09,0x2d,0x3e,0x44,0x8e,0xda,0x5f};
    static const uint8_t ct[] = {0x93,0xfe,0x7d,0x9e,0x9b,0xfd,0x10,0x34,0x8a,0x56,0x06,0xe5,0xca,0xfa,0x73,0x54};
    static const uint8_t tag[] = {0x00,0x32,0xa1,0xdc,0x85,0xf1,0xc9,0x78,0x69,0x25,0xa2,0xe7,0x1d,0x82,0x72,0xdd};

    struct aes_ctxt aes;
    uint8_t outText[sizeof(pt)];
    uint8_t outTag[sizeof(tag)];

    MODA_AES_Init(&aes, AES_KEY_128, key);
    MODA_AES_GCM_Encrypt(&aes, iv, sizeof(iv), outText, pt, sizeof(pt), aad, sizeof(aad), outTag, sizeof(outTag));

    assert_memory_equal(tag, outTag, sizeof(outTag));
    assert_memory_equal(ct, outText, sizeof(outText));
}

static void test_MODA_AES_GCM_Encrypt_oddiv(void **user)
{
    static const uint8_t key[] = {0x83,0xf9,0xd9,0x7d,0x4a,0xb7,0x59,0xfd,0xdc,0xc3,0xef,0x54,0xa0,0xe2,0xa8,0xec};
    static const uint8_t iv[] = {0xcf};
    static const uint8_t pt[] = {0x77,0xe6,0x32,0x9c,0xf9,0x42,0x4f,0x71,0xc8,0x08,0xdf,0x91,0x70,0xbf,0xd2,0x98};
    static const uint8_t aad[] = {0x6d,0xd4,0x9e,0xae,0xb4,0x10,0x3d,0xac,0x8f,0x97,0xe3,0x23,0x49,0x46,0xdd,0x2d};
    static const uint8_t ct[] = {0x50,0xde,0x86,0xa7,0xa9,0x2a,0x8a,0x5e,0xa3,0x3d,0xb5,0x69,0x6b,0x96,0xcd,0x77};
    static const uint8_t tag[] = {0xaa,0x18,0x1e,0x84,0xbc,0x8b,0x4b,0xf5,0xa6,0x89,0x27,0xc4,0x09,0xd4,0x22,0xcb};

    struct aes_ctxt aes;
    uint8_t outText[sizeof(pt)];
    uint8_t outTag[sizeof(tag)];

    MODA_AES_Init(&aes, AES_KEY_128, key);
    MODA_AES_GCM_Encrypt(&aes, iv, sizeof(iv), outText, pt, sizeof(pt), aad, sizeof(aad), outTag, sizeof(outTag));

    assert_memory_equal(tag, outTag, sizeof(outTag));
    assert_memory_equal(ct, outText, sizeof(outText));
}

static void test_MODA_AES_GCM_Decrypt_notext_noaad(void **user)
{
    bool retval;
    static const uint8_t key[] = {0x11,0x75,0x4c,0xd7,0x2a,0xec,0x30,0x9b,0xf5,0x2f,0x76,0x87,0x21,0x2e,0x89,0x57};
    static const uint8_t iv[] = {0x3c,0x81,0x9d,0x9a,0x9b,0xed,0x08,0x76,0x15,0x03,0x0b,0x65};
//    static const uint8_t pt[] = {};
//    static const uint8_t aad[] = {};
//    static const uint8_t ct[] = {};
    static const uint8_t tag[] = {0x25,0x03,0x27,0xc6,0x74,0xaa,0xf4,0x77,0xae,0xf2,0x67,0x57,0x48,0xcf,0x69,0x71};
    static const uint8_t badTag[] = {0x00};

    struct aes_ctxt aes;
    
    MODA_AES_Init(&aes, AES_KEY_128, key);
    retval = MODA_AES_GCM_Decrypt(&aes, iv, sizeof(iv), NULL, NULL, 0, NULL, 0, tag, sizeof(tag));
    assert_true(retval);

    retval = MODA_AES_GCM_Decrypt(&aes, iv, sizeof(iv), NULL, NULL, 0, NULL, 0, badTag, sizeof(badTag));

    assert_false(retval);
}

static void test_MODA_AES_GCM_Decrypt_notext(void **user)
{
    bool retval;
    static const uint8_t key[] = {0x77,0xbe,0x63,0x70,0x89,0x71,0xc4,0xe2,0x40,0xd1,0xcb,0x79,0xe8,0xd7,0x7f,0xeb};
    static const uint8_t iv[] = {0xe0,0xe0,0x0f,0x19,0xfe,0xd7,0xba,0x01,0x36,0xa7,0x97,0xf3};
//    static const uint8_t pt[] = {};
    static const uint8_t aad[] = {0x7a,0x43,0xec,0x1d,0x9c,0x0a,0x5a,0x78,0xa0,0xb1,0x65,0x33,0xa6,0x21,0x3c,0xab};
//    static const uint8_t ct[] = {};
    static const uint8_t tag[] = {0x20,0x9f,0xcc,0x8d,0x36,0x75,0xed,0x93,0x8e,0x9c,0x71,0x66,0x70,0x9d,0xd9,0x46};
    static const uint8_t badTag[] = {0x00};

    struct aes_ctxt aes;
    
    MODA_AES_Init(&aes, AES_KEY_128, key);
    retval = MODA_AES_GCM_Decrypt(&aes, iv, sizeof(iv), NULL, NULL, 0, aad, sizeof(aad), tag, sizeof(tag));    
    assert_true(retval);
    
    retval = MODA_AES_GCM_Decrypt(&aes, iv, sizeof(iv), NULL, NULL, 0, aad, sizeof(aad), badTag, sizeof(badTag));
    assert_false(retval);
}

static void test_MODA_AES_GCM_Decrypt_notext_partaad(void **user)
{
    bool retval;
    static const uint8_t key[] = {0x2f,0xb4,0x5e,0x5b,0x8f,0x99,0x3a,0x2b,0xfe,0xbc,0x4b,0x15,0xb5,0x33,0xe0,0xb4};
    static const uint8_t iv[] = {0x5b,0x05,0x75,0x5f,0x98,0x4d,0x2b,0x90,0xf9,0x4b,0x80,0x27};
//    static const uint8_t pt[] = {};
    static const uint8_t aad[] = {0xe8,0x54,0x91,0xb2,0x20,0x2c,0xaf,0x1d,0x7d,0xce,0x03,0xb9,0x7e,0x09,0x33,0x1c,0x32,0x47,0x39,0x41};
//    static const uint8_t ct[] = {};
    static const uint8_t tag[] = {0xc7,0x5b,0x78,0x32,0xb2,0xa2,0xd9,0xbd,0x82,0x74,0x12,0xb6,0xef,0x57,0x69,0xdb};
    static const uint8_t badTag[] = {0x00};

    struct aes_ctxt aes;
    
    MODA_AES_Init(&aes, AES_KEY_128, key);
    retval = MODA_AES_GCM_Decrypt(&aes, iv, sizeof(iv), NULL, NULL, 0, aad, sizeof(aad), tag, sizeof(tag));
    assert_true(retval);
    
    retval = MODA_AES_GCM_Decrypt(&aes, iv, sizeof(iv), NULL, NULL, 0, aad, sizeof(aad), badTag, sizeof(badTag));
    assert_false(retval);
}

static void test_MODA_AES_GCM_Decrypt_noaad(void **user)
{
    bool retval;
    static const uint8_t key[] = {0x7f,0xdd,0xb5,0x74,0x53,0xc2,0x41,0xd0,0x3e,0xfb,0xed,0x3a,0xc4,0x4e,0x37,0x1c};
    static const uint8_t iv[] = {0xee,0x28,0x3a,0x3f,0xc7,0x55,0x75,0xe3,0x3e,0xfd,0x48,0x87};
    static const uint8_t pt[] = {0xd5,0xde,0x42,0xb4,0x61,0x64,0x6c,0x25,0x5c,0x87,0xbd,0x29,0x62,0xd3,0xb9,0xa2};
//    static const uint8_t aad[] = {};
    static const uint8_t ct[] = {0x2c,0xcd,0xa4,0xa5,0x41,0x5c,0xb9,0x1e,0x13,0x5c,0x2a,0x0f,0x78,0xc9,0xb2,0xfd};
    static const uint8_t tag[] = {0xb3,0x6d,0x1d,0xf9,0xb9,0xd5,0xe5,0x96,0xf8,0x3e,0x8b,0x7f,0x52,0x97,0x1c,0xb3};
    static const uint8_t badTag[] = {0x00};

    struct aes_ctxt aes;
    uint8_t outText[sizeof(pt)];
    
    MODA_AES_Init(&aes, AES_KEY_128, key);
    retval = MODA_AES_GCM_Decrypt(&aes, iv, sizeof(iv), outText, ct, sizeof(ct), NULL, 0, tag, sizeof(tag));
    assert_true(retval);
    assert_memory_equal(pt, outText, sizeof(outText));

    retval = MODA_AES_GCM_Decrypt(&aes, iv, sizeof(iv), outText, ct, sizeof(ct), NULL, 0, badTag, sizeof(badTag));
    assert_false(retval);   
}

static void test_MODA_AES_GCM_Decrypt_parttext_noaad(void **user)
{    
    static const uint8_t key[] = {0xfe,0x9b,0xb4,0x7d,0xeb,0x3a,0x61,0xe4,0x23,0xc2,0x23,0x18,0x41,0xcf,0xd1,0xfb};
    static const uint8_t iv[] = {0x4d,0x32,0x8e,0xb7,0x76,0xf5,0x00,0xa2,0xf7,0xfb,0x47,0xaa};
    static const uint8_t pt[] = {0xf1,0xcc,0x38,0x18,0xe4,0x21,0x87,0x6b,0xb6,0xb8,0xbb,0xd6,0xc9};

    static const uint8_t ct[] = {0xb8,0x8c,0x5c,0x19,0x77,0xb3,0x5b,0x51,0x7b,0x0a,0xea,0xe9,0x67};
    static const uint8_t tag[] = {0x43,0xfd,0x47,0x27,0xfe,0x5c,0xdb,0x4b,0x5b,0x42,0x81,0x8d,0xea,0x7e,0xf8,0xc9};
    
    struct aes_ctxt aes;
    uint8_t outText[sizeof(pt)];
    
    MODA_AES_Init(&aes, AES_KEY_128, key);
    assert_true(MODA_AES_GCM_Decrypt(&aes, iv, sizeof(iv), outText, ct, sizeof(ct), NULL, 0, tag, sizeof(tag)));

    assert_memory_equal(pt, outText, sizeof(outText));
}

static void test_MODA_AES_GCM_Decrypt(void **user)
{
    bool retval;
    static const uint8_t key[] = {0xc9,0x39,0xcc,0x13,0x39,0x7c,0x1d,0x37,0xde,0x6a,0xe0,0xe1,0xcb,0x7c,0x42,0x3c};
    static const uint8_t iv[] = {0xb3,0xd8,0xcc,0x01,0x7c,0xbb,0x89,0xb3,0x9e,0x0f,0x67,0xe2};
    static const uint8_t pt[] = {0xc3,0xb3,0xc4,0x1f,0x11,0x3a,0x31,0xb7,0x3d,0x9a,0x5c,0xd4,0x32,0x10,0x30,0x69};
    static const uint8_t aad[] = {0x24,0x82,0x56,0x02,0xbd,0x12,0xa9,0x84,0xe0,0x09,0x2d,0x3e,0x44,0x8e,0xda,0x5f};
    static const uint8_t ct[] = {0x93,0xfe,0x7d,0x9e,0x9b,0xfd,0x10,0x34,0x8a,0x56,0x06,0xe5,0xca,0xfa,0x73,0x54};
    static const uint8_t tag[] = {0x00,0x32,0xa1,0xdc,0x85,0xf1,0xc9,0x78,0x69,0x25,0xa2,0xe7,0x1d,0x82,0x72,0xdd};
    static const uint8_t badTag[] = {0xff};

    struct aes_ctxt aes;
    uint8_t outText[sizeof(pt)];
    
    MODA_AES_Init(&aes, AES_KEY_128, key);
    retval = MODA_AES_GCM_Decrypt(&aes, iv, sizeof(iv), outText, ct, sizeof(ct), aad, sizeof(aad), tag, sizeof(tag));
    assert_true(retval);
    assert_memory_equal(pt, outText, sizeof(outText));

    retval = MODA_AES_GCM_Decrypt(&aes, iv, sizeof(iv), outText, ct, sizeof(ct), aad, sizeof(aad), badTag, sizeof(badTag));
    assert_false(retval);       
}

static void test_MODA_AES_GCM_Decrypt_oddiv(void **user)
{
    bool retval;
    static const uint8_t key[] = {0x83,0xf9,0xd9,0x7d,0x4a,0xb7,0x59,0xfd,0xdc,0xc3,0xef,0x54,0xa0,0xe2,0xa8,0xec};
    static const uint8_t iv[] = {0xcf};
    static const uint8_t pt[] = {0x77,0xe6,0x32,0x9c,0xf9,0x42,0x4f,0x71,0xc8,0x08,0xdf,0x91,0x70,0xbf,0xd2,0x98};
    static const uint8_t aad[] = {0x6d,0xd4,0x9e,0xae,0xb4,0x10,0x3d,0xac,0x8f,0x97,0xe3,0x23,0x49,0x46,0xdd,0x2d};
    static const uint8_t ct[] = {0x50,0xde,0x86,0xa7,0xa9,0x2a,0x8a,0x5e,0xa3,0x3d,0xb5,0x69,0x6b,0x96,0xcd,0x77};
    static const uint8_t tag[] = {0xaa,0x18,0x1e,0x84,0xbc,0x8b,0x4b,0xf5,0xa6,0x89,0x27,0xc4,0x09,0xd4,0x22,0xcb};
    static const uint8_t badTag[] = {0x00};

    struct aes_ctxt aes;
    uint8_t outText[sizeof(pt)];
    
    MODA_AES_Init(&aes, AES_KEY_128, key);
    retval = MODA_AES_GCM_Decrypt(&aes, iv, sizeof(iv), outText, ct, sizeof(ct), aad, sizeof(aad), tag, sizeof(tag));
    assert_true(retval);
    assert_memory_equal(pt, outText, sizeof(outText));

    retval = MODA_AES_GCM_Decrypt(&aes, iv, sizeof(iv), outText, ct, sizeof(ct), aad, sizeof(aad), badTag, sizeof(badTag));
    assert_false(retval);        
}

int main(void)
{
    const struct CMUnitTest tests[] = {
        cmocka_unit_test(test_MODA_AES_GCM_Encrypt_notext_noaad),                 
        cmocka_unit_test(test_MODA_AES_GCM_Encrypt_notext),     
        cmocka_unit_test(test_MODA_AES_GCM_Encrypt_notext_partaad),     
        cmocka_unit_test(test_MODA_AES_GCM_Encrypt_noaad),     
        cmocka_unit_test(test_MODA_AES_GCM_Encrypt_parttext_noaad),     
        cmocka_unit_test(test_MODA_AES_GCM_Encrypt),     
        cmocka_unit_test(test_MODA_AES_GCM_Encrypt_oddiv),     
        cmocka_unit_test(test_MODA_AES_GCM_Decrypt_notext),             
        cmocka_unit_test(test_MODA_AES_GCM_Decrypt_notext_noaad),             
        cmocka_unit_test(test_MODA_AES_GCM_Decrypt_notext_partaad),             
        cmocka_unit_test(test_MODA_AES_GCM_Decrypt_noaad),             
        cmocka_unit_test(test_MODA_AES_GCM_Decrypt_parttext_noaad),             
        cmocka_unit_test(test_MODA_AES_GCM_Decrypt),             
        cmocka_unit_test(test_MODA_AES_GCM_Decrypt_oddiv),             
    };

    return cmocka_run_group_tests(tests, NULL, NULL);
}