Paul Bakker | 33b43f1 | 2013-08-20 11:48:36 +0200 | [diff] [blame] | 1 | /* BEGIN_HEADER */ |
Manuel Pégourié-Gonnard | 7f80997 | 2015-03-09 17:05:11 +0000 | [diff] [blame] | 2 | #include "mbedtls/gcm.h" |
Paul Bakker | 33b43f1 | 2013-08-20 11:48:36 +0200 | [diff] [blame] | 3 | /* END_HEADER */ |
Paul Bakker | 89e80c9 | 2012-03-20 13:50:09 +0000 | [diff] [blame] | 4 | |
Paul Bakker | 33b43f1 | 2013-08-20 11:48:36 +0200 | [diff] [blame] | 5 | /* BEGIN_DEPENDENCIES |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 6 | * depends_on:MBEDTLS_GCM_C |
Paul Bakker | 33b43f1 | 2013-08-20 11:48:36 +0200 | [diff] [blame] | 7 | * END_DEPENDENCIES |
| 8 | */ |
Paul Bakker | 89e80c9 | 2012-03-20 13:50:09 +0000 | [diff] [blame] | 9 | |
Paul Bakker | 33b43f1 | 2013-08-20 11:48:36 +0200 | [diff] [blame] | 10 | /* BEGIN_CASE */ |
Ron Eldor | 5a21fd6 | 2016-12-16 16:15:56 +0200 | [diff] [blame] | 11 | void gcm_bad_parameters( int cipher_id, int direction, |
Azim Khan | 5fcca46 | 2018-06-29 11:05:32 +0100 | [diff] [blame] | 12 | data_t *key_str, data_t *src_str, |
| 13 | data_t *iv_str, data_t *add_str, |
Ron Eldor | 5a21fd6 | 2016-12-16 16:15:56 +0200 | [diff] [blame] | 14 | int tag_len_bits, int gcm_result ) |
| 15 | { |
Ron Eldor | 5a21fd6 | 2016-12-16 16:15:56 +0200 | [diff] [blame] | 16 | unsigned char output[128]; |
| 17 | unsigned char tag_output[16]; |
| 18 | mbedtls_gcm_context ctx; |
Azim Khan | 317efe8 | 2017-08-02 17:33:54 +0100 | [diff] [blame] | 19 | size_t tag_len = tag_len_bits / 8; |
Ron Eldor | 5a21fd6 | 2016-12-16 16:15:56 +0200 | [diff] [blame] | 20 | |
| 21 | mbedtls_gcm_init( &ctx ); |
| 22 | |
Ron Eldor | 5a21fd6 | 2016-12-16 16:15:56 +0200 | [diff] [blame] | 23 | memset( output, 0x00, sizeof( output ) ); |
| 24 | memset( tag_output, 0x00, sizeof( tag_output ) ); |
Darryl Green | 11999bb | 2018-03-13 15:22:58 +0000 | [diff] [blame] | 25 | |
Azim Khan | 317efe8 | 2017-08-02 17:33:54 +0100 | [diff] [blame] | 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 ); |
Ron Eldor | 5a21fd6 | 2016-12-16 16:15:56 +0200 | [diff] [blame] | 29 | |
| 30 | exit: |
| 31 | mbedtls_gcm_free( &ctx ); |
| 32 | } |
| 33 | /* END_CASE */ |
| 34 | |
| 35 | /* BEGIN_CASE */ |
Azim Khan | 5fcca46 | 2018-06-29 11:05:32 +0100 | [diff] [blame] | 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, |
Azim Khan | d30ca13 | 2017-06-09 04:32:58 +0100 | [diff] [blame] | 40 | int init_result ) |
Paul Bakker | 89e80c9 | 2012-03-20 13:50:09 +0000 | [diff] [blame] | 41 | { |
Paul Bakker | 89e80c9 | 2012-03-20 13:50:09 +0000 | [diff] [blame] | 42 | unsigned char output[128]; |
| 43 | unsigned char tag_output[16]; |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 44 | mbedtls_gcm_context ctx; |
Azim Khan | f1aaec9 | 2017-05-30 14:23:15 +0100 | [diff] [blame] | 45 | size_t tag_len = tag_len_bits / 8; |
Paul Bakker | 89e80c9 | 2012-03-20 13:50:09 +0000 | [diff] [blame] | 46 | |
Manuel Pégourié-Gonnard | c34e8dd | 2015-04-28 21:42:17 +0200 | [diff] [blame] | 47 | mbedtls_gcm_init( &ctx ); |
| 48 | |
Paul Bakker | 89e80c9 | 2012-03-20 13:50:09 +0000 | [diff] [blame] | 49 | memset(output, 0x00, 128); |
| 50 | memset(tag_output, 0x00, 16); |
| 51 | |
Paul Bakker | 89e80c9 | 2012-03-20 13:50:09 +0000 | [diff] [blame] | 52 | |
Azim Khan | d30ca13 | 2017-06-09 04:32:58 +0100 | [diff] [blame] | 53 | TEST_ASSERT( mbedtls_gcm_setkey( &ctx, cipher_id, key_str->x, key_str->len * 8 ) == init_result ); |
Paul Bakker | 33b43f1 | 2013-08-20 11:48:36 +0200 | [diff] [blame] | 54 | if( init_result == 0 ) |
Paul Bakker | 89e80c9 | 2012-03-20 13:50:09 +0000 | [diff] [blame] | 55 | { |
Azim Khan | d30ca13 | 2017-06-09 04:32:58 +0100 | [diff] [blame] | 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 ); |
Paul Bakker | 89e80c9 | 2012-03-20 13:50:09 +0000 | [diff] [blame] | 57 | |
Azim Khan | d30ca13 | 2017-06-09 04:32:58 +0100 | [diff] [blame] | 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 ); |
Paul Bakker | 89e80c9 | 2012-03-20 13:50:09 +0000 | [diff] [blame] | 60 | } |
Manuel Pégourié-Gonnard | 4fe9200 | 2013-09-13 13:45:58 +0200 | [diff] [blame] | 61 | |
Paul Bakker | bd51b26 | 2014-07-10 15:26:12 +0200 | [diff] [blame] | 62 | exit: |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 63 | mbedtls_gcm_free( &ctx ); |
Paul Bakker | 89e80c9 | 2012-03-20 13:50:09 +0000 | [diff] [blame] | 64 | } |
Paul Bakker | 33b43f1 | 2013-08-20 11:48:36 +0200 | [diff] [blame] | 65 | /* END_CASE */ |
Paul Bakker | 89e80c9 | 2012-03-20 13:50:09 +0000 | [diff] [blame] | 66 | |
Paul Bakker | 33b43f1 | 2013-08-20 11:48:36 +0200 | [diff] [blame] | 67 | /* BEGIN_CASE */ |
Azim Khan | 5fcca46 | 2018-06-29 11:05:32 +0100 | [diff] [blame] | 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 ) |
Paul Bakker | 89e80c9 | 2012-03-20 13:50:09 +0000 | [diff] [blame] | 73 | { |
Paul Bakker | 89e80c9 | 2012-03-20 13:50:09 +0000 | [diff] [blame] | 74 | unsigned char output[128]; |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 75 | mbedtls_gcm_context ctx; |
Paul Bakker | 89e80c9 | 2012-03-20 13:50:09 +0000 | [diff] [blame] | 76 | int ret; |
Azim Khan | f1aaec9 | 2017-05-30 14:23:15 +0100 | [diff] [blame] | 77 | size_t tag_len = tag_len_bits / 8; |
Paul Bakker | 89e80c9 | 2012-03-20 13:50:09 +0000 | [diff] [blame] | 78 | |
Manuel Pégourié-Gonnard | c34e8dd | 2015-04-28 21:42:17 +0200 | [diff] [blame] | 79 | mbedtls_gcm_init( &ctx ); |
| 80 | |
Paul Bakker | 89e80c9 | 2012-03-20 13:50:09 +0000 | [diff] [blame] | 81 | memset(output, 0x00, 128); |
| 82 | |
Paul Bakker | 89e80c9 | 2012-03-20 13:50:09 +0000 | [diff] [blame] | 83 | |
Azim Khan | d30ca13 | 2017-06-09 04:32:58 +0100 | [diff] [blame] | 84 | TEST_ASSERT( mbedtls_gcm_setkey( &ctx, cipher_id, key_str->x, key_str->len * 8 ) == init_result ); |
Paul Bakker | 33b43f1 | 2013-08-20 11:48:36 +0200 | [diff] [blame] | 85 | if( init_result == 0 ) |
Paul Bakker | 89e80c9 | 2012-03-20 13:50:09 +0000 | [diff] [blame] | 86 | { |
Azim Khan | d30ca13 | 2017-06-09 04:32:58 +0100 | [diff] [blame] | 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 ); |
Paul Bakker | 89e80c9 | 2012-03-20 13:50:09 +0000 | [diff] [blame] | 88 | |
Azim Khan | 46c9b1f | 2017-05-31 20:46:35 +0100 | [diff] [blame] | 89 | if( strcmp( "FAIL", result ) == 0 ) |
Paul Bakker | 89e80c9 | 2012-03-20 13:50:09 +0000 | [diff] [blame] | 90 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 91 | TEST_ASSERT( ret == MBEDTLS_ERR_GCM_AUTH_FAILED ); |
Paul Bakker | 89e80c9 | 2012-03-20 13:50:09 +0000 | [diff] [blame] | 92 | } |
| 93 | else |
| 94 | { |
Manuel Pégourié-Gonnard | f7ce67f | 2013-09-03 20:17:35 +0200 | [diff] [blame] | 95 | TEST_ASSERT( ret == 0 ); |
Paul Bakker | 89e80c9 | 2012-03-20 13:50:09 +0000 | [diff] [blame] | 96 | |
Azim Khan | d30ca13 | 2017-06-09 04:32:58 +0100 | [diff] [blame] | 97 | TEST_ASSERT( hexcmp( output, pt_result->x, src_str->len, pt_result->len ) == 0 ); |
Paul Bakker | 89e80c9 | 2012-03-20 13:50:09 +0000 | [diff] [blame] | 98 | } |
| 99 | } |
Manuel Pégourié-Gonnard | 4fe9200 | 2013-09-13 13:45:58 +0200 | [diff] [blame] | 100 | |
Paul Bakker | bd51b26 | 2014-07-10 15:26:12 +0200 | [diff] [blame] | 101 | exit: |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 102 | mbedtls_gcm_free( &ctx ); |
Paul Bakker | 89e80c9 | 2012-03-20 13:50:09 +0000 | [diff] [blame] | 103 | } |
Paul Bakker | 33b43f1 | 2013-08-20 11:48:36 +0200 | [diff] [blame] | 104 | /* END_CASE */ |
Paul Bakker | 89e80c9 | 2012-03-20 13:50:09 +0000 | [diff] [blame] | 105 | |
k-stachowiak | 8ffc92a | 2018-12-12 14:21:59 +0100 | [diff] [blame] | 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 | |
k-stachowiak | 5fccb3e | 2018-12-12 15:51:26 +0100 | [diff] [blame] | 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 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 275 | /* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */ |
Azim Khan | f1aaec9 | 2017-05-30 14:23:15 +0100 | [diff] [blame] | 276 | void gcm_selftest( ) |
Paul Bakker | 89e80c9 | 2012-03-20 13:50:09 +0000 | [diff] [blame] | 277 | { |
Andres AG | 93012e8 | 2016-09-09 09:10:28 +0100 | [diff] [blame] | 278 | TEST_ASSERT( mbedtls_gcm_self_test( 1 ) == 0 ); |
Paul Bakker | 89e80c9 | 2012-03-20 13:50:09 +0000 | [diff] [blame] | 279 | } |
Paul Bakker | 33b43f1 | 2013-08-20 11:48:36 +0200 | [diff] [blame] | 280 | /* END_CASE */ |