third_party/mbedtls/repo/tests/suites/test_suite_gcm.function

   1 /* BEGIN_HEADER */
   2 #include "mbedtls/gcm.h"
   3 /* END_HEADER */
   4
   5 /* BEGIN_DEPENDENCIES
   6  * depends_on:MBEDTLS_GCM_C
   7  * END_DEPENDENCIES
   8  */
   9
  10 /* BEGIN_CASE */
  11 void gcm_bad_parameters( int cipher_id, int direction,
  12                          data_t *key_str, data_t *src_str,
  13                          data_t *iv_str, data_t *add_str,
  14                          int tag_len_bits, int gcm_result )
  15 {
  16     unsigned char output[128];
  17     unsigned char tag_output[16];
  18     mbedtls_gcm_context ctx;
  19     size_t tag_len = tag_len_bits / 8;
  20
  21     mbedtls_gcm_init( &ctx );
  22
  23     memset( output, 0x00, sizeof( output ) );
  24     memset( tag_output, 0x00, sizeof( tag_output ) );
  25
  26     TEST_ASSERT( mbedtls_gcm_setkey( &ctx, cipher_id, key_str->x, key_str->len * 8 ) == 0 );
  27     TEST_ASSERT( mbedtls_gcm_crypt_and_tag( &ctx, direction, src_str->len, iv_str->x, iv_str->len,
  28                  add_str->x, add_str->len, src_str->x, output, tag_len, tag_output ) == gcm_result );
  29
  30 exit:
  31     mbedtls_gcm_free( &ctx );
  32 }
  33 /* END_CASE */
  34
  35 /* BEGIN_CASE */
  36 void gcm_encrypt_and_tag( int cipher_id, data_t * key_str,
  37                           data_t * src_str, data_t * iv_str,
  38                           data_t * add_str, data_t * hex_dst_string,
  39                           int tag_len_bits, data_t * hex_tag_string,
  40                           int init_result )
  41 {
  42     unsigned char output[128];
  43     unsigned char tag_output[16];
  44     mbedtls_gcm_context ctx;
  45     size_t tag_len = tag_len_bits / 8;
  46
  47     mbedtls_gcm_init( &ctx );
  48
  49     memset(output, 0x00, 128);
  50     memset(tag_output, 0x00, 16);
  51
  52
  53     TEST_ASSERT( mbedtls_gcm_setkey( &ctx, cipher_id, key_str->x, key_str->len * 8 ) == init_result );
  54     if( init_result == 0 )
  55     {
  56         TEST_ASSERT( mbedtls_gcm_crypt_and_tag( &ctx, MBEDTLS_GCM_ENCRYPT, src_str->len, iv_str->x, iv_str->len, add_str->x, add_str->len, src_str->x, output, tag_len, tag_output ) == 0 );
  57
  58         TEST_ASSERT( hexcmp( output, hex_dst_string->x, src_str->len, hex_dst_string->len ) == 0 );
  59         TEST_ASSERT( hexcmp( tag_output, hex_tag_string->x, tag_len, hex_tag_string->len ) == 0 );
  60     }
  61
  62 exit:
  63     mbedtls_gcm_free( &ctx );
  64 }
  65 /* END_CASE */
  66
  67 /* BEGIN_CASE */
  68 void gcm_decrypt_and_verify( int cipher_id, data_t * key_str,
  69                              data_t * src_str, data_t * iv_str,
  70                              data_t * add_str, int tag_len_bits,
  71                              data_t * tag_str, char * result,
  72                              data_t * pt_result, int init_result )
  73 {
  74     unsigned char output[128];
  75     mbedtls_gcm_context ctx;
  76     int ret;
  77     size_t tag_len = tag_len_bits / 8;
  78
  79     mbedtls_gcm_init( &ctx );
  80
  81     memset(output, 0x00, 128);
  82
  83
  84     TEST_ASSERT( mbedtls_gcm_setkey( &ctx, cipher_id, key_str->x, key_str->len * 8 ) == init_result );
  85     if( init_result == 0 )
  86     {
  87         ret = mbedtls_gcm_auth_decrypt( &ctx, src_str->len, iv_str->x, iv_str->len, add_str->x, add_str->len, tag_str->x, tag_len, src_str->x, output );
  88
  89         if( strcmp( "FAIL", result ) == 0 )
  90         {
  91             TEST_ASSERT( ret == MBEDTLS_ERR_GCM_AUTH_FAILED );
  92         }
  93         else
  94         {
  95             TEST_ASSERT( ret == 0 );
  96
  97             TEST_ASSERT( hexcmp( output, pt_result->x, src_str->len, pt_result->len ) == 0 );
  98         }
  99     }
 100
 101 exit:
 102     mbedtls_gcm_free( &ctx );
 103 }
 104 /* END_CASE */
 105
 106 /* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
 107 void gcm_invalid_param( )
 108 {
 109     mbedtls_gcm_context ctx;
 110     unsigned char valid_buffer[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
 111     mbedtls_cipher_id_t valid_cipher = MBEDTLS_CIPHER_ID_AES;
 112     int valid_mode = MBEDTLS_GCM_ENCRYPT;
 113     int valid_len = sizeof(valid_buffer);
 114     int valid_bitlen = 128, invalid_bitlen = 1;
 115
 116     mbedtls_gcm_init( &ctx );
 117
 118     /* mbedtls_gcm_init() */
 119     TEST_INVALID_PARAM( mbedtls_gcm_init( NULL ) );
 120
 121     /* mbedtls_gcm_setkey */
 122     TEST_INVALID_PARAM_RET(
 123         MBEDTLS_ERR_GCM_BAD_INPUT,
 124         mbedtls_gcm_setkey( NULL, valid_cipher, valid_buffer, valid_bitlen ) );
 125     TEST_INVALID_PARAM_RET(
 126         MBEDTLS_ERR_GCM_BAD_INPUT,
 127         mbedtls_gcm_setkey( &ctx, valid_cipher, NULL, valid_bitlen ) );
 128     TEST_INVALID_PARAM_RET(
 129         MBEDTLS_ERR_GCM_BAD_INPUT,
 130         mbedtls_gcm_setkey( &ctx, valid_cipher, valid_buffer, invalid_bitlen ) );
 131
 132     /* mbedtls_gcm_crypt_and_tag() */
 133     TEST_INVALID_PARAM_RET(
 134         MBEDTLS_ERR_GCM_BAD_INPUT,
 135         mbedtls_gcm_crypt_and_tag( NULL, valid_mode, valid_len,
 136                                    valid_buffer, valid_len,
 137                                    valid_buffer, valid_len,
 138                                    valid_buffer, valid_buffer,
 139                                    valid_len, valid_buffer ) );
 140     TEST_INVALID_PARAM_RET(
 141         MBEDTLS_ERR_GCM_BAD_INPUT,
 142         mbedtls_gcm_crypt_and_tag( &ctx, valid_mode, valid_len,
 143                                    NULL, valid_len,
 144                                    valid_buffer, valid_len,
 145                                    valid_buffer, valid_buffer,
 146                                    valid_len, valid_buffer ) );
 147     TEST_INVALID_PARAM_RET(
 148         MBEDTLS_ERR_GCM_BAD_INPUT,
 149         mbedtls_gcm_crypt_and_tag( &ctx, valid_mode, valid_len,
 150                                    valid_buffer, valid_len,
 151                                    NULL, valid_len,
 152                                    valid_buffer, valid_buffer,
 153                                    valid_len, valid_buffer ) );
 154     TEST_INVALID_PARAM_RET(
 155         MBEDTLS_ERR_GCM_BAD_INPUT,
 156         mbedtls_gcm_crypt_and_tag( &ctx, valid_mode, valid_len,
 157                                    valid_buffer, valid_len,
 158                                    valid_buffer, valid_len,
 159                                    NULL, valid_buffer,
 160                                    valid_len, valid_buffer ) );
 161     TEST_INVALID_PARAM_RET(
 162         MBEDTLS_ERR_GCM_BAD_INPUT,
 163         mbedtls_gcm_crypt_and_tag( &ctx, valid_mode, valid_len,
 164                                    valid_buffer, valid_len,
 165                                    valid_buffer, valid_len,
 166                                    valid_buffer, NULL,
 167                                    valid_len, valid_buffer ) );
 168     TEST_INVALID_PARAM_RET(
 169         MBEDTLS_ERR_GCM_BAD_INPUT,
 170         mbedtls_gcm_crypt_and_tag( &ctx, valid_mode, valid_len,
 171                                    valid_buffer, valid_len,
 172                                    valid_buffer, valid_len,
 173                                    valid_buffer, valid_buffer,
 174                                    valid_len, NULL ) );
 175
 176     /* mbedtls_gcm_auth_decrypt() */
 177     TEST_INVALID_PARAM_RET(
 178         MBEDTLS_ERR_GCM_BAD_INPUT,
 179         mbedtls_gcm_auth_decrypt( NULL, valid_len,
 180                                   valid_buffer, valid_len,
 181                                   valid_buffer, valid_len,
 182                                   valid_buffer, valid_len,
 183                                   valid_buffer, valid_buffer) );
 184     TEST_INVALID_PARAM_RET(
 185         MBEDTLS_ERR_GCM_BAD_INPUT,
 186         mbedtls_gcm_auth_decrypt( &ctx, valid_len,
 187                                   NULL, valid_len,
 188                                   valid_buffer, valid_len,
 189                                   valid_buffer, valid_len,
 190                                   valid_buffer, valid_buffer) );
 191     TEST_INVALID_PARAM_RET(
 192         MBEDTLS_ERR_GCM_BAD_INPUT,
 193         mbedtls_gcm_auth_decrypt( &ctx, valid_len,
 194                                   valid_buffer, valid_len,
 195                                   NULL, valid_len,
 196                                   valid_buffer, valid_len,
 197                                   valid_buffer, valid_buffer) );
 198     TEST_INVALID_PARAM_RET(
 199         MBEDTLS_ERR_GCM_BAD_INPUT,
 200         mbedtls_gcm_auth_decrypt( &ctx, valid_len,
 201                                   valid_buffer, valid_len,
 202                                   valid_buffer, valid_len,
 203                                   NULL, valid_len,
 204                                   valid_buffer, valid_buffer) );
 205     TEST_INVALID_PARAM_RET(
 206         MBEDTLS_ERR_GCM_BAD_INPUT,
 207         mbedtls_gcm_auth_decrypt( &ctx, valid_len,
 208                                   valid_buffer, valid_len,
 209                                   valid_buffer, valid_len,
 210                                   valid_buffer, valid_len,
 211                                   NULL, valid_buffer) );
 212     TEST_INVALID_PARAM_RET(
 213         MBEDTLS_ERR_GCM_BAD_INPUT,
 214         mbedtls_gcm_auth_decrypt( &ctx, valid_len,
 215                                   valid_buffer, valid_len,
 216                                   valid_buffer, valid_len,
 217                                   valid_buffer, valid_len,
 218                                   valid_buffer, NULL) );
 219
 220     /* mbedtls_gcm_starts() */
 221     TEST_INVALID_PARAM_RET(
 222         MBEDTLS_ERR_GCM_BAD_INPUT,
 223         mbedtls_gcm_starts( NULL, valid_mode,
 224                             valid_buffer, valid_len,
 225                             valid_buffer, valid_len ) );
 226
 227     TEST_INVALID_PARAM_RET(
 228         MBEDTLS_ERR_GCM_BAD_INPUT,
 229         mbedtls_gcm_starts( &ctx, valid_mode,
 230                             NULL, valid_len,
 231                             valid_buffer, valid_len ) );
 232
 233     TEST_INVALID_PARAM_RET(
 234         MBEDTLS_ERR_GCM_BAD_INPUT,
 235         mbedtls_gcm_starts( &ctx, valid_mode,
 236                             valid_buffer, valid_len,
 237                             NULL, valid_len ) );
 238
 239     /* mbedtls_gcm_update() */
 240     TEST_INVALID_PARAM_RET(
 241         MBEDTLS_ERR_GCM_BAD_INPUT,
 242         mbedtls_gcm_update( NULL, valid_len,
 243                             valid_buffer, valid_buffer ) );
 244     TEST_INVALID_PARAM_RET(
 245         MBEDTLS_ERR_GCM_BAD_INPUT,
 246         mbedtls_gcm_update( &ctx, valid_len,
 247                             NULL, valid_buffer ) );
 248     TEST_INVALID_PARAM_RET(
 249         MBEDTLS_ERR_GCM_BAD_INPUT,
 250         mbedtls_gcm_update( &ctx, valid_len,
 251                             valid_buffer, NULL ) );
 252
 253     /* mbedtls_gcm_finish() */
 254     TEST_INVALID_PARAM_RET(
 255         MBEDTLS_ERR_GCM_BAD_INPUT,
 256         mbedtls_gcm_finish( NULL, valid_buffer, valid_len ) );
 257     TEST_INVALID_PARAM_RET(
 258         MBEDTLS_ERR_GCM_BAD_INPUT,
 259         mbedtls_gcm_finish( &ctx, NULL, valid_len ) );
 260
 261 exit:
 262     mbedtls_gcm_free( &ctx );
 263 }
 264 /* END_CASE */
 265
 266 /* BEGIN_CASE */
 267 void gcm_valid_param( )
 268 {
 269     TEST_VALID_PARAM( mbedtls_gcm_free( NULL ) );
 270 exit:
 271     return;
 272 }
 273 /* END_CASE */
 274
 275 /* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
 276 void gcm_selftest(  )
 277 {
 278     TEST_ASSERT( mbedtls_gcm_self_test( 1 ) == 0 );
 279 }
 280 /* END_CASE */