TrustedFirmware Git Browser
Code Review Sign In
review.trustedfirmware.org / mirror / mbed-tls / 55427964b1073e566acfa36786bc4ab3ad901b9c / . / tests / suites / test_suite_gcm.function
blob: 1fcb681b98bf17193cddf06e41c598e893a6eff3 [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
Azim Khand30ca132017-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 Bakker89e80c92012-03-20 13:50:09 +0000[diff] [blame]60 }
Manuel Pégourié-Gonnard4fe92002013-09-13 13:45:58 +0200[diff] [blame]61
Paul Bakkerbd51b262014-07-10 15:26:12 +0200[diff] [blame]62exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200[diff] [blame]63 mbedtls_gcm_free( &ctx );
Paul Bakker89e80c92012-03-20 13:50:09 +0000[diff] [blame]64}
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]65/* END_CASE */
Paul Bakker89e80c92012-03-20 13:50:09 +0000[diff] [blame]66
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]67/* BEGIN_CASE */
Azim Khan5fcca462018-06-29 11:05:32 +0100[diff] [blame]68void 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 Bakker89e80c92012-03-20 13:50:09 +0000[diff] [blame]73{
Paul Bakker89e80c92012-03-20 13:50:09 +0000[diff] [blame]74 unsigned char output[128];
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200[diff] [blame]75 mbedtls_gcm_context ctx;
Paul Bakker89e80c92012-03-20 13:50:09 +0000[diff] [blame]76 int ret;
Azim Khanf1aaec92017-05-30 14:23:15 +0100[diff] [blame]77 size_t tag_len = tag_len_bits / 8;
Paul Bakker89e80c92012-03-20 13:50:09 +0000[diff] [blame]78
Manuel Pégourié-Gonnardc34e8dd2015-04-28 21:42:17 +0200[diff] [blame]79 mbedtls_gcm_init( &ctx );
80
Paul Bakker89e80c92012-03-20 13:50:09 +0000[diff] [blame]81 memset(output, 0x00, 128);
82
Paul Bakker89e80c92012-03-20 13:50:09 +0000[diff] [blame]83
Azim Khand30ca132017-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 Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]85 if( init_result == 0 )
Paul Bakker89e80c92012-03-20 13:50:09 +0000[diff] [blame]86 {
Azim Khand30ca132017-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 Bakker89e80c92012-03-20 13:50:09 +0000[diff] [blame]88
Azim Khan46c9b1f2017-05-31 20:46:35 +0100[diff] [blame]89 if( strcmp( "FAIL", result ) == 0 )
Paul Bakker89e80c92012-03-20 13:50:09 +0000[diff] [blame]90 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200[diff] [blame]91 TEST_ASSERT( ret == MBEDTLS_ERR_GCM_AUTH_FAILED );
Paul Bakker89e80c92012-03-20 13:50:09 +0000[diff] [blame]92 }
93 else
94 {
Manuel Pégourié-Gonnardf7ce67f2013-09-03 20:17:35 +0200[diff] [blame]95 TEST_ASSERT( ret == 0 );
Paul Bakker89e80c92012-03-20 13:50:09 +0000[diff] [blame]96
Azim Khand30ca132017-06-09 04:32:58 +0100[diff] [blame]97 TEST_ASSERT( hexcmp( output, pt_result->x, src_str->len, pt_result->len ) == 0 );
Paul Bakker89e80c92012-03-20 13:50:09 +0000[diff] [blame]98 }
99 }
Manuel Pégourié-Gonnard4fe92002013-09-13 13:45:58 +0200[diff] [blame]100
Paul Bakkerbd51b262014-07-10 15:26:12 +0200[diff] [blame]101exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200[diff] [blame]102 mbedtls_gcm_free( &ctx );
Paul Bakker89e80c92012-03-20 13:50:09 +0000[diff] [blame]103}
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]104/* END_CASE */
Paul Bakker89e80c92012-03-20 13:50:09 +0000[diff] [blame]105
k-stachowiak8ffc92a2018-12-12 14:21:59 +0100[diff] [blame]106/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
107void 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
261exit:
262 mbedtls_gcm_free( &ctx );
263}
264/* END_CASE */
265
k-stachowiak5fccb3e2018-12-12 15:51:26 +0100[diff] [blame]266/* BEGIN_CASE */
267void gcm_valid_param( )
268{
269 TEST_VALID_PARAM( mbedtls_gcm_free( NULL ) );
270exit:
271 return;
272}
273/* END_CASE */
274
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200[diff] [blame]275/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
Azim Khanf1aaec92017-05-30 14:23:15 +0100[diff] [blame]276void gcm_selftest( )
Paul Bakker89e80c92012-03-20 13:50:09 +0000[diff] [blame]277{
Andres AG93012e82016-09-09 09:10:28 +0100[diff] [blame]278 TEST_ASSERT( mbedtls_gcm_self_test( 1 ) == 0 );
Paul Bakker89e80c92012-03-20 13:50:09 +0000[diff] [blame]279}
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]280/* END_CASE */