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