blob: 1fcb681b98bf17193cddf06e41c598e893a6eff3 [file] [log] [blame]
Paul Bakker33b43f12013-08-20 11:48:36 +02001/* BEGIN_HEADER */
Manuel Pégourié-Gonnard7f809972015-03-09 17:05:11 +00002#include "mbedtls/gcm.h"
Paul Bakker33b43f12013-08-20 11:48:36 +02003/* END_HEADER */
Paul Bakker89e80c92012-03-20 13:50:09 +00004
Paul Bakker33b43f12013-08-20 11:48:36 +02005/* BEGIN_DEPENDENCIES
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02006 * depends_on:MBEDTLS_GCM_C
Paul Bakker33b43f12013-08-20 11:48:36 +02007 * END_DEPENDENCIES
8 */
Paul Bakker89e80c92012-03-20 13:50:09 +00009
Paul Bakker33b43f12013-08-20 11:48:36 +020010/* BEGIN_CASE */
Ron Eldor5a21fd62016-12-16 16:15:56 +020011void gcm_bad_parameters( int cipher_id, int direction,
Azim Khan5fcca462018-06-29 11:05:32 +010012 data_t *key_str, data_t *src_str,
13 data_t *iv_str, data_t *add_str,
Ron Eldor5a21fd62016-12-16 16:15:56 +020014 int tag_len_bits, int gcm_result )
15{
Ron Eldor5a21fd62016-12-16 16:15:56 +020016 unsigned char output[128];
17 unsigned char tag_output[16];
18 mbedtls_gcm_context ctx;
Azim Khan317efe82017-08-02 17:33:54 +010019 size_t tag_len = tag_len_bits / 8;
Ron Eldor5a21fd62016-12-16 16:15:56 +020020
21 mbedtls_gcm_init( &ctx );
22
Ron Eldor5a21fd62016-12-16 16:15:56 +020023 memset( output, 0x00, sizeof( output ) );
24 memset( tag_output, 0x00, sizeof( tag_output ) );
Darryl Green11999bb2018-03-13 15:22:58 +000025
Azim Khan317efe82017-08-02 17:33:54 +010026 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 +020029
30exit:
31 mbedtls_gcm_free( &ctx );
32}
33/* END_CASE */
34
35/* BEGIN_CASE */
Azim Khan5fcca462018-06-29 11:05:32 +010036void 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 +010040 int init_result )
Paul Bakker89e80c92012-03-20 13:50:09 +000041{
Paul Bakker89e80c92012-03-20 13:50:09 +000042 unsigned char output[128];
43 unsigned char tag_output[16];
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020044 mbedtls_gcm_context ctx;
Azim Khanf1aaec92017-05-30 14:23:15 +010045 size_t tag_len = tag_len_bits / 8;
Paul Bakker89e80c92012-03-20 13:50:09 +000046
Manuel Pégourié-Gonnardc34e8dd2015-04-28 21:42:17 +020047 mbedtls_gcm_init( &ctx );
48
Paul Bakker89e80c92012-03-20 13:50:09 +000049 memset(output, 0x00, 128);
50 memset(tag_output, 0x00, 16);
51
Paul Bakker89e80c92012-03-20 13:50:09 +000052
Azim Khand30ca132017-06-09 04:32:58 +010053 TEST_ASSERT( mbedtls_gcm_setkey( &ctx, cipher_id, key_str->x, key_str->len * 8 ) == init_result );
Paul Bakker33b43f12013-08-20 11:48:36 +020054 if( init_result == 0 )
Paul Bakker89e80c92012-03-20 13:50:09 +000055 {
Azim Khand30ca132017-06-09 04:32:58 +010056 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 +000057
Azim Khand30ca132017-06-09 04:32:58 +010058 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 +000060 }
Manuel Pégourié-Gonnard4fe92002013-09-13 13:45:58 +020061
Paul Bakkerbd51b262014-07-10 15:26:12 +020062exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020063 mbedtls_gcm_free( &ctx );
Paul Bakker89e80c92012-03-20 13:50:09 +000064}
Paul Bakker33b43f12013-08-20 11:48:36 +020065/* END_CASE */
Paul Bakker89e80c92012-03-20 13:50:09 +000066
Paul Bakker33b43f12013-08-20 11:48:36 +020067/* BEGIN_CASE */
Azim Khan5fcca462018-06-29 11:05:32 +010068void 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 +000073{
Paul Bakker89e80c92012-03-20 13:50:09 +000074 unsigned char output[128];
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020075 mbedtls_gcm_context ctx;
Paul Bakker89e80c92012-03-20 13:50:09 +000076 int ret;
Azim Khanf1aaec92017-05-30 14:23:15 +010077 size_t tag_len = tag_len_bits / 8;
Paul Bakker89e80c92012-03-20 13:50:09 +000078
Manuel Pégourié-Gonnardc34e8dd2015-04-28 21:42:17 +020079 mbedtls_gcm_init( &ctx );
80
Paul Bakker89e80c92012-03-20 13:50:09 +000081 memset(output, 0x00, 128);
82
Paul Bakker89e80c92012-03-20 13:50:09 +000083
Azim Khand30ca132017-06-09 04:32:58 +010084 TEST_ASSERT( mbedtls_gcm_setkey( &ctx, cipher_id, key_str->x, key_str->len * 8 ) == init_result );
Paul Bakker33b43f12013-08-20 11:48:36 +020085 if( init_result == 0 )
Paul Bakker89e80c92012-03-20 13:50:09 +000086 {
Azim Khand30ca132017-06-09 04:32:58 +010087 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 +000088
Azim Khan46c9b1f2017-05-31 20:46:35 +010089 if( strcmp( "FAIL", result ) == 0 )
Paul Bakker89e80c92012-03-20 13:50:09 +000090 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020091 TEST_ASSERT( ret == MBEDTLS_ERR_GCM_AUTH_FAILED );
Paul Bakker89e80c92012-03-20 13:50:09 +000092 }
93 else
94 {
Manuel Pégourié-Gonnardf7ce67f2013-09-03 20:17:35 +020095 TEST_ASSERT( ret == 0 );
Paul Bakker89e80c92012-03-20 13:50:09 +000096
Azim Khand30ca132017-06-09 04:32:58 +010097 TEST_ASSERT( hexcmp( output, pt_result->x, src_str->len, pt_result->len ) == 0 );
Paul Bakker89e80c92012-03-20 13:50:09 +000098 }
99 }
Manuel Pégourié-Gonnard4fe92002013-09-13 13:45:58 +0200100
Paul Bakkerbd51b262014-07-10 15:26:12 +0200101exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200102 mbedtls_gcm_free( &ctx );
Paul Bakker89e80c92012-03-20 13:50:09 +0000103}
Paul Bakker33b43f12013-08-20 11:48:36 +0200104/* END_CASE */
Paul Bakker89e80c92012-03-20 13:50:09 +0000105
k-stachowiak8ffc92a2018-12-12 14:21:59 +0100106/* 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 +0100266/* 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 +0200275/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
Azim Khanf1aaec92017-05-30 14:23:15 +0100276void gcm_selftest( )
Paul Bakker89e80c92012-03-20 13:50:09 +0000277{
Andres AG93012e82016-09-09 09:10:28 +0100278 TEST_ASSERT( mbedtls_gcm_self_test( 1 ) == 0 );
Paul Bakker89e80c92012-03-20 13:50:09 +0000279}
Paul Bakker33b43f12013-08-20 11:48:36 +0200280/* END_CASE */