blob: c4128b40366c72af99441f1ff914045c864d5774 [file] [log] [blame]
SimonB15942102016-04-25 21:34:49 +01001#line 1 "helpers.function"
SimonB0269dad2016-02-17 23:34:30 +00002/*----------------------------------------------------------------------------*/
3/* Headers */
4
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02005#if defined(MBEDTLS_PLATFORM_C)
Manuel Pégourié-Gonnard7f809972015-03-09 17:05:11 +00006#include "mbedtls/platform.h"
Manuel Pégourié-Gonnard3d49b9d2014-06-06 14:48:09 +02007#else
Rich Evans00ab4702015-02-06 13:43:58 +00008#include <stdio.h>
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02009#define mbedtls_printf printf
10#define mbedtls_fprintf fprintf
Manuel Pégourié-Gonnard7551cb92015-05-26 16:04:06 +020011#define mbedtls_calloc calloc
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020012#define mbedtls_free free
13#define mbedtls_exit exit
14#define mbedtls_fprintf fprintf
15#define mbedtls_printf printf
16#define mbedtls_snprintf snprintf
Janos Follath55abc212016-04-18 18:18:48 +010017#define MBEDTLS_EXIT_SUCCESS EXIT_SUCCESS
18#define MBEDTLS_EXIT_FAILURE EXIT_FAILURE
Manuel Pégourié-Gonnard3d49b9d2014-06-06 14:48:09 +020019#endif
20
SimonB0269dad2016-02-17 23:34:30 +000021#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
22#include "mbedtls/memory_buffer_alloc.h"
23#endif
24
Paul Bakkerb3dcbc12011-03-13 16:57:25 +000025#ifdef _MSC_VER
26#include <basetsd.h>
27typedef UINT32 uint32_t;
28#else
Manuel Pégourié-Gonnard93866642015-06-22 19:21:23 +020029#include <stdint.h>
Paul Bakkerb3dcbc12011-03-13 16:57:25 +000030#endif
31
Rich Evans3d62e722015-02-03 11:48:59 +000032#include <stdio.h>
Paul Bakker19343182013-08-16 13:31:10 +020033#include <stdlib.h>
34#include <string.h>
35
SimonB0269dad2016-02-17 23:34:30 +000036
37/*----------------------------------------------------------------------------*/
SimonB8ca7bc42016-04-17 23:24:50 +010038/* Constants */
SimonB0269dad2016-02-17 23:34:30 +000039
SimonB8ca7bc42016-04-17 23:24:50 +010040#define DEPENDENCY_SUPPORTED 0
41#define DEPENDENCY_NOT_SUPPORTED 1
42
43#define KEY_VALUE_MAPPING_FOUND 0
44#define KEY_VALUE_MAPPING_NOT_FOUND -1
45
46#define DISPATCH_TEST_SUCCESS 0
47#define DISPATCH_TEST_FN_NOT_FOUND 1
48#define DISPATCH_INVALID_TEST_DATA 2
49#define DISPATCH_UNSUPPORTED_SUITE 3
SimonB0269dad2016-02-17 23:34:30 +000050
51
52/*----------------------------------------------------------------------------*/
53/* Macros */
54
55#define TEST_ASSERT( TEST ) \
56 do { \
57 if( ! (TEST) ) \
58 { \
59 test_fail( #TEST ); \
60 goto exit; \
61 } \
62 } while( 0 )
63
Rich Evans4c091142015-02-02 12:04:10 +000064#define assert(a) if( !( a ) ) \
65{ \
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020066 mbedtls_fprintf( stderr, "Assertion Failed at %s:%d - %s\n", \
Rich Evans4c091142015-02-02 12:04:10 +000067 __FILE__, __LINE__, #a ); \
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020068 mbedtls_exit( 1 ); \
Rich Evans4c091142015-02-02 12:04:10 +000069}
70
Paul Bakkerb3dcbc12011-03-13 16:57:25 +000071/*
72 * 32-bit integer manipulation macros (big endian)
73 */
Paul Bakker5c2364c2012-10-01 14:41:15 +000074#ifndef GET_UINT32_BE
75#define GET_UINT32_BE(n,b,i) \
Paul Bakkerb3dcbc12011-03-13 16:57:25 +000076{ \
Paul Bakker5c2364c2012-10-01 14:41:15 +000077 (n) = ( (uint32_t) (b)[(i) ] << 24 ) \
78 | ( (uint32_t) (b)[(i) + 1] << 16 ) \
79 | ( (uint32_t) (b)[(i) + 2] << 8 ) \
80 | ( (uint32_t) (b)[(i) + 3] ); \
Paul Bakkerb3dcbc12011-03-13 16:57:25 +000081}
82#endif
83
Paul Bakker5c2364c2012-10-01 14:41:15 +000084#ifndef PUT_UINT32_BE
85#define PUT_UINT32_BE(n,b,i) \
Paul Bakkerb3dcbc12011-03-13 16:57:25 +000086{ \
87 (b)[(i) ] = (unsigned char) ( (n) >> 24 ); \
88 (b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \
89 (b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \
90 (b)[(i) + 3] = (unsigned char) ( (n) ); \
91}
92#endif
93
SimonB0269dad2016-02-17 23:34:30 +000094
95/*----------------------------------------------------------------------------*/
SimonB8ca7bc42016-04-17 23:24:50 +010096/* Global variables */
97
98static int test_errors = 0;
99
100
101/*----------------------------------------------------------------------------*/
SimonB0269dad2016-02-17 23:34:30 +0000102/* Helper Functions */
103
Rich Evans4c091142015-02-02 12:04:10 +0000104static int unhexify( unsigned char *obuf, const char *ibuf )
Paul Bakker367dae42009-06-28 21:50:27 +0000105{
106 unsigned char c, c2;
Rich Evans4c091142015-02-02 12:04:10 +0000107 int len = strlen( ibuf ) / 2;
SimonB0269dad2016-02-17 23:34:30 +0000108 assert( strlen( ibuf ) % 2 == 0 ); /* must be even number of bytes */
Paul Bakker367dae42009-06-28 21:50:27 +0000109
Rich Evans4c091142015-02-02 12:04:10 +0000110 while( *ibuf != 0 )
Paul Bakker367dae42009-06-28 21:50:27 +0000111 {
112 c = *ibuf++;
113 if( c >= '0' && c <= '9' )
114 c -= '0';
115 else if( c >= 'a' && c <= 'f' )
116 c -= 'a' - 10;
117 else if( c >= 'A' && c <= 'F' )
118 c -= 'A' - 10;
119 else
120 assert( 0 );
121
122 c2 = *ibuf++;
123 if( c2 >= '0' && c2 <= '9' )
124 c2 -= '0';
125 else if( c2 >= 'a' && c2 <= 'f' )
126 c2 -= 'a' - 10;
127 else if( c2 >= 'A' && c2 <= 'F' )
128 c2 -= 'A' - 10;
129 else
130 assert( 0 );
131
132 *obuf++ = ( c << 4 ) | c2;
133 }
134
135 return len;
136}
137
Rich Evans42914452015-02-02 12:09:25 +0000138static void hexify( unsigned char *obuf, const unsigned char *ibuf, int len )
Paul Bakker367dae42009-06-28 21:50:27 +0000139{
140 unsigned char l, h;
141
Rich Evans42914452015-02-02 12:09:25 +0000142 while( len != 0 )
Paul Bakker367dae42009-06-28 21:50:27 +0000143 {
Rich Evans42914452015-02-02 12:09:25 +0000144 h = *ibuf / 16;
145 l = *ibuf % 16;
Paul Bakker367dae42009-06-28 21:50:27 +0000146
147 if( h < 10 )
148 *obuf++ = '0' + h;
149 else
150 *obuf++ = 'a' + h - 10;
151
152 if( l < 10 )
153 *obuf++ = '0' + l;
154 else
155 *obuf++ = 'a' + l - 10;
156
157 ++ibuf;
158 len--;
159 }
160}
Paul Bakker9dcc3222011-03-08 14:16:06 +0000161
162/**
Manuel Pégourié-Gonnard0dc5e0d2014-06-13 21:09:26 +0200163 * Allocate and zeroize a buffer.
164 *
165 * If the size if zero, a pointer to a zeroized 1-byte buffer is returned.
166 *
167 * For convenience, dies if allocation fails.
168 */
169static unsigned char *zero_alloc( size_t len )
170{
171 void *p;
Rich Evans42914452015-02-02 12:09:25 +0000172 size_t actual_len = ( len != 0 ) ? len : 1;
Manuel Pégourié-Gonnard0dc5e0d2014-06-13 21:09:26 +0200173
Manuel Pégourié-Gonnard7551cb92015-05-26 16:04:06 +0200174 p = mbedtls_calloc( 1, actual_len );
Paul Bakker4d0cfe82014-07-10 14:37:36 +0200175 assert( p != NULL );
Manuel Pégourié-Gonnard0dc5e0d2014-06-13 21:09:26 +0200176
177 memset( p, 0x00, actual_len );
178
179 return( p );
180}
181
182/**
Manuel Pégourié-Gonnard3d49b9d2014-06-06 14:48:09 +0200183 * Allocate and fill a buffer from hex data.
184 *
185 * The buffer is sized exactly as needed. This allows to detect buffer
186 * overruns (including overreads) when running the test suite under valgrind.
187 *
Manuel Pégourié-Gonnard0dc5e0d2014-06-13 21:09:26 +0200188 * If the size if zero, a pointer to a zeroized 1-byte buffer is returned.
189 *
Manuel Pégourié-Gonnard3d49b9d2014-06-06 14:48:09 +0200190 * For convenience, dies if allocation fails.
191 */
192static unsigned char *unhexify_alloc( const char *ibuf, size_t *olen )
193{
194 unsigned char *obuf;
195
Rich Evans42914452015-02-02 12:09:25 +0000196 *olen = strlen( ibuf ) / 2;
Manuel Pégourié-Gonnard3d49b9d2014-06-06 14:48:09 +0200197
Manuel Pégourié-Gonnard0dc5e0d2014-06-13 21:09:26 +0200198 if( *olen == 0 )
199 return( zero_alloc( *olen ) );
200
Manuel Pégourié-Gonnard7551cb92015-05-26 16:04:06 +0200201 obuf = mbedtls_calloc( 1, *olen );
Paul Bakker4d0cfe82014-07-10 14:37:36 +0200202 assert( obuf != NULL );
Manuel Pégourié-Gonnard3d49b9d2014-06-06 14:48:09 +0200203
204 (void) unhexify( obuf, ibuf );
205
206 return( obuf );
207}
208
209/**
Paul Bakker9dcc3222011-03-08 14:16:06 +0000210 * This function just returns data from rand().
Paul Bakker997bbd12011-03-13 15:45:42 +0000211 * Although predictable and often similar on multiple
212 * runs, this does not result in identical random on
213 * each run. So do not use this if the results of a
214 * test depend on the random data that is generated.
Paul Bakker9dcc3222011-03-08 14:16:06 +0000215 *
216 * rng_state shall be NULL.
217 */
Paul Bakkera3d195c2011-11-27 21:07:34 +0000218static int rnd_std_rand( void *rng_state, unsigned char *output, size_t len )
Paul Bakker9dcc3222011-03-08 14:16:06 +0000219{
Paul Bakkerf96f7b62014-04-30 16:02:38 +0200220#if !defined(__OpenBSD__)
Paul Bakkera3d195c2011-11-27 21:07:34 +0000221 size_t i;
222
Paul Bakker9dcc3222011-03-08 14:16:06 +0000223 if( rng_state != NULL )
224 rng_state = NULL;
225
Paul Bakkera3d195c2011-11-27 21:07:34 +0000226 for( i = 0; i < len; ++i )
227 output[i] = rand();
Paul Bakkerf96f7b62014-04-30 16:02:38 +0200228#else
229 if( rng_state != NULL )
230 rng_state = NULL;
231
232 arc4random_buf( output, len );
233#endif /* !OpenBSD */
Paul Bakkera3d195c2011-11-27 21:07:34 +0000234
235 return( 0 );
Paul Bakker9dcc3222011-03-08 14:16:06 +0000236}
237
238/**
239 * This function only returns zeros
240 *
241 * rng_state shall be NULL.
242 */
Paul Bakkera3d195c2011-11-27 21:07:34 +0000243static int rnd_zero_rand( void *rng_state, unsigned char *output, size_t len )
Paul Bakker9dcc3222011-03-08 14:16:06 +0000244{
245 if( rng_state != NULL )
246 rng_state = NULL;
247
Paul Bakkera3d195c2011-11-27 21:07:34 +0000248 memset( output, 0, len );
249
Paul Bakker9dcc3222011-03-08 14:16:06 +0000250 return( 0 );
251}
252
253typedef struct
254{
255 unsigned char *buf;
Paul Bakkera3d195c2011-11-27 21:07:34 +0000256 size_t length;
Paul Bakker997bbd12011-03-13 15:45:42 +0000257} rnd_buf_info;
Paul Bakker9dcc3222011-03-08 14:16:06 +0000258
259/**
260 * This function returns random based on a buffer it receives.
261 *
Paul Bakker997bbd12011-03-13 15:45:42 +0000262 * rng_state shall be a pointer to a rnd_buf_info structure.
Manuel Pégourié-Gonnarde670f902015-10-30 09:23:19 +0100263 *
Paul Bakker997bbd12011-03-13 15:45:42 +0000264 * The number of bytes released from the buffer on each call to
265 * the random function is specified by per_call. (Can be between
266 * 1 and 4)
Paul Bakker9dcc3222011-03-08 14:16:06 +0000267 *
268 * After the buffer is empty it will return rand();
269 */
Paul Bakkera3d195c2011-11-27 21:07:34 +0000270static int rnd_buffer_rand( void *rng_state, unsigned char *output, size_t len )
Paul Bakker9dcc3222011-03-08 14:16:06 +0000271{
Paul Bakker997bbd12011-03-13 15:45:42 +0000272 rnd_buf_info *info = (rnd_buf_info *) rng_state;
Paul Bakkera3d195c2011-11-27 21:07:34 +0000273 size_t use_len;
Paul Bakker9dcc3222011-03-08 14:16:06 +0000274
275 if( rng_state == NULL )
Paul Bakkera3d195c2011-11-27 21:07:34 +0000276 return( rnd_std_rand( NULL, output, len ) );
Paul Bakker9dcc3222011-03-08 14:16:06 +0000277
Paul Bakkera3d195c2011-11-27 21:07:34 +0000278 use_len = len;
279 if( len > info->length )
280 use_len = info->length;
Paul Bakker997bbd12011-03-13 15:45:42 +0000281
Paul Bakkera3d195c2011-11-27 21:07:34 +0000282 if( use_len )
Paul Bakker9dcc3222011-03-08 14:16:06 +0000283 {
Paul Bakkera3d195c2011-11-27 21:07:34 +0000284 memcpy( output, info->buf, use_len );
285 info->buf += use_len;
286 info->length -= use_len;
Paul Bakker9dcc3222011-03-08 14:16:06 +0000287 }
288
Paul Bakkera3d195c2011-11-27 21:07:34 +0000289 if( len - use_len > 0 )
290 return( rnd_std_rand( NULL, output + use_len, len - use_len ) );
291
292 return( 0 );
Paul Bakker9dcc3222011-03-08 14:16:06 +0000293}
Paul Bakker997bbd12011-03-13 15:45:42 +0000294
295/**
296 * Info structure for the pseudo random function
297 *
298 * Key should be set at the start to a test-unique value.
Paul Bakkerb3dcbc12011-03-13 16:57:25 +0000299 * Do not forget endianness!
Paul Bakker997bbd12011-03-13 15:45:42 +0000300 * State( v0, v1 ) should be set to zero.
301 */
302typedef struct
303{
Paul Bakkerb3dcbc12011-03-13 16:57:25 +0000304 uint32_t key[16];
Paul Bakker997bbd12011-03-13 15:45:42 +0000305 uint32_t v0, v1;
306} rnd_pseudo_info;
307
308/**
309 * This function returns random based on a pseudo random function.
310 * This means the results should be identical on all systems.
311 * Pseudo random is based on the XTEA encryption algorithm to
312 * generate pseudorandom.
313 *
314 * rng_state shall be a pointer to a rnd_pseudo_info structure.
315 */
Paul Bakkera3d195c2011-11-27 21:07:34 +0000316static int rnd_pseudo_rand( void *rng_state, unsigned char *output, size_t len )
Paul Bakker997bbd12011-03-13 15:45:42 +0000317{
318 rnd_pseudo_info *info = (rnd_pseudo_info *) rng_state;
Paul Bakkera3d195c2011-11-27 21:07:34 +0000319 uint32_t i, *k, sum, delta=0x9E3779B9;
Manuel Pégourié-Gonnard217a29c2014-01-03 11:59:09 +0100320 unsigned char result[4], *out = output;
Paul Bakker997bbd12011-03-13 15:45:42 +0000321
322 if( rng_state == NULL )
Paul Bakkera3d195c2011-11-27 21:07:34 +0000323 return( rnd_std_rand( NULL, output, len ) );
Paul Bakker997bbd12011-03-13 15:45:42 +0000324
Paul Bakkerb3dcbc12011-03-13 16:57:25 +0000325 k = info->key;
Paul Bakkera3d195c2011-11-27 21:07:34 +0000326
327 while( len > 0 )
Paul Bakker997bbd12011-03-13 15:45:42 +0000328 {
Paul Bakker40dd5302012-05-15 15:02:38 +0000329 size_t use_len = ( len > 4 ) ? 4 : len;
Paul Bakkera3d195c2011-11-27 21:07:34 +0000330 sum = 0;
331
Paul Bakkera3d195c2011-11-27 21:07:34 +0000332 for( i = 0; i < 32; i++ )
333 {
Rich Evans42914452015-02-02 12:09:25 +0000334 info->v0 += ( ( ( info->v1 << 4 ) ^ ( info->v1 >> 5 ) )
335 + info->v1 ) ^ ( sum + k[sum & 3] );
Paul Bakkera3d195c2011-11-27 21:07:34 +0000336 sum += delta;
Rich Evans42914452015-02-02 12:09:25 +0000337 info->v1 += ( ( ( info->v0 << 4 ) ^ ( info->v0 >> 5 ) )
338 + info->v0 ) ^ ( sum + k[( sum>>11 ) & 3] );
Paul Bakkera3d195c2011-11-27 21:07:34 +0000339 }
340
Paul Bakker5c2364c2012-10-01 14:41:15 +0000341 PUT_UINT32_BE( info->v0, result, 0 );
Manuel Pégourié-Gonnard217a29c2014-01-03 11:59:09 +0100342 memcpy( out, result, use_len );
Paul Bakkera3d195c2011-11-27 21:07:34 +0000343 len -= use_len;
Manuel Pégourié-Gonnard217a29c2014-01-03 11:59:09 +0100344 out += 4;
Paul Bakker997bbd12011-03-13 15:45:42 +0000345 }
346
Paul Bakkera3d195c2011-11-27 21:07:34 +0000347 return( 0 );
Paul Bakker997bbd12011-03-13 15:45:42 +0000348}
SimonB0269dad2016-02-17 23:34:30 +0000349
350static void test_fail( const char *test )
351{
352 test_errors++;
353 if( test_errors == 1 )
354 mbedtls_printf( "FAILED\n" );
355 mbedtls_printf( " %s\n", test );
356}
357