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