PolarSSL v1.2.8
test_suite_base64.c
Go to the documentation of this file.
1 #include "fct.h"
2 #include <polarssl/config.h>
3 
4 #include <polarssl/base64.h>
5 
6 #ifdef _MSC_VER
7 #include <basetsd.h>
8 typedef UINT32 uint32_t;
9 #else
10 #include <inttypes.h>
11 #endif
12 
13 /*
14  * 32-bit integer manipulation macros (big endian)
15  */
16 #ifndef GET_UINT32_BE
17 #define GET_UINT32_BE(n,b,i) \
18 { \
19  (n) = ( (uint32_t) (b)[(i) ] << 24 ) \
20  | ( (uint32_t) (b)[(i) + 1] << 16 ) \
21  | ( (uint32_t) (b)[(i) + 2] << 8 ) \
22  | ( (uint32_t) (b)[(i) + 3] ); \
23 }
24 #endif
25 
26 #ifndef PUT_UINT32_BE
27 #define PUT_UINT32_BE(n,b,i) \
28 { \
29  (b)[(i) ] = (unsigned char) ( (n) >> 24 ); \
30  (b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \
31  (b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \
32  (b)[(i) + 3] = (unsigned char) ( (n) ); \
33 }
34 #endif
35 
36 int unhexify(unsigned char *obuf, const char *ibuf)
37 {
38  unsigned char c, c2;
39  int len = strlen(ibuf) / 2;
40  assert(!(strlen(ibuf) %1)); // must be even number of bytes
41 
42  while (*ibuf != 0)
43  {
44  c = *ibuf++;
45  if( c >= '0' && c <= '9' )
46  c -= '0';
47  else if( c >= 'a' && c <= 'f' )
48  c -= 'a' - 10;
49  else if( c >= 'A' && c <= 'F' )
50  c -= 'A' - 10;
51  else
52  assert( 0 );
53 
54  c2 = *ibuf++;
55  if( c2 >= '0' && c2 <= '9' )
56  c2 -= '0';
57  else if( c2 >= 'a' && c2 <= 'f' )
58  c2 -= 'a' - 10;
59  else if( c2 >= 'A' && c2 <= 'F' )
60  c2 -= 'A' - 10;
61  else
62  assert( 0 );
63 
64  *obuf++ = ( c << 4 ) | c2;
65  }
66 
67  return len;
68 }
69 
70 void hexify(unsigned char *obuf, const unsigned char *ibuf, int len)
71 {
72  unsigned char l, h;
73 
74  while (len != 0)
75  {
76  h = (*ibuf) / 16;
77  l = (*ibuf) % 16;
78 
79  if( h < 10 )
80  *obuf++ = '0' + h;
81  else
82  *obuf++ = 'a' + h - 10;
83 
84  if( l < 10 )
85  *obuf++ = '0' + l;
86  else
87  *obuf++ = 'a' + l - 10;
88 
89  ++ibuf;
90  len--;
91  }
92 }
93 
103 static int rnd_std_rand( void *rng_state, unsigned char *output, size_t len )
104 {
105  size_t i;
106 
107  if( rng_state != NULL )
108  rng_state = NULL;
109 
110  for( i = 0; i < len; ++i )
111  output[i] = rand();
112 
113  return( 0 );
114 }
115 
121 static int rnd_zero_rand( void *rng_state, unsigned char *output, size_t len )
122 {
123  if( rng_state != NULL )
124  rng_state = NULL;
125 
126  memset( output, 0, len );
127 
128  return( 0 );
129 }
130 
131 typedef struct
132 {
133  unsigned char *buf;
134  size_t length;
135 } rnd_buf_info;
136 
148 static int rnd_buffer_rand( void *rng_state, unsigned char *output, size_t len )
149 {
150  rnd_buf_info *info = (rnd_buf_info *) rng_state;
151  size_t use_len;
152 
153  if( rng_state == NULL )
154  return( rnd_std_rand( NULL, output, len ) );
155 
156  use_len = len;
157  if( len > info->length )
158  use_len = info->length;
159 
160  if( use_len )
161  {
162  memcpy( output, info->buf, use_len );
163  info->buf += use_len;
164  info->length -= use_len;
165  }
166 
167  if( len - use_len > 0 )
168  return( rnd_std_rand( NULL, output + use_len, len - use_len ) );
169 
170  return( 0 );
171 }
172 
180 typedef struct
181 {
182  uint32_t key[16];
183  uint32_t v0, v1;
185 
194 static int rnd_pseudo_rand( void *rng_state, unsigned char *output, size_t len )
195 {
196  rnd_pseudo_info *info = (rnd_pseudo_info *) rng_state;
197  uint32_t i, *k, sum, delta=0x9E3779B9;
198  unsigned char result[4];
199 
200  if( rng_state == NULL )
201  return( rnd_std_rand( NULL, output, len ) );
202 
203  k = info->key;
204 
205  while( len > 0 )
206  {
207  size_t use_len = ( len > 4 ) ? 4 : len;
208  sum = 0;
209 
210  for( i = 0; i < 32; i++ )
211  {
212  info->v0 += (((info->v1 << 4) ^ (info->v1 >> 5)) + info->v1) ^ (sum + k[sum & 3]);
213  sum += delta;
214  info->v1 += (((info->v0 << 4) ^ (info->v0 >> 5)) + info->v0) ^ (sum + k[(sum>>11) & 3]);
215  }
216 
217  PUT_UINT32_BE( info->v0, result, 0 );
218  memcpy( output, result, use_len );
219  len -= use_len;
220  }
221 
222  return( 0 );
223 }
224 
225 
227 {
228 #ifdef POLARSSL_BASE64_C
229 
230 
231  FCT_SUITE_BGN(test_suite_base64)
232  {
233 
234  FCT_TEST_BGN(test_case_base64_encode_1)
235  {
236  unsigned char src_str[1000];
237  unsigned char dst_str[1000];
238  size_t len = 1000;
239 
240  memset(src_str, 0x00, 1000);
241  memset(dst_str, 0x00, 1000);
242 
243  strcpy( (char *) src_str, "" );
244  fct_chk( base64_encode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == 0 );
245  if( 0 == 0 )
246  {
247  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
248  }
249  }
250  FCT_TEST_END();
251 
252 
253  FCT_TEST_BGN(test_case_base64_encode_2)
254  {
255  unsigned char src_str[1000];
256  unsigned char dst_str[1000];
257  size_t len = 1000;
258 
259  memset(src_str, 0x00, 1000);
260  memset(dst_str, 0x00, 1000);
261 
262  strcpy( (char *) src_str, "f" );
263  fct_chk( base64_encode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == 0 );
264  if( 0 == 0 )
265  {
266  fct_chk( strcmp( (char *) dst_str, "Zg==" ) == 0 );
267  }
268  }
269  FCT_TEST_END();
270 
271 
272  FCT_TEST_BGN(test_case_base64_encode_3)
273  {
274  unsigned char src_str[1000];
275  unsigned char dst_str[1000];
276  size_t len = 1000;
277 
278  memset(src_str, 0x00, 1000);
279  memset(dst_str, 0x00, 1000);
280 
281  strcpy( (char *) src_str, "fo" );
282  fct_chk( base64_encode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == 0 );
283  if( 0 == 0 )
284  {
285  fct_chk( strcmp( (char *) dst_str, "Zm8=" ) == 0 );
286  }
287  }
288  FCT_TEST_END();
289 
290 
291  FCT_TEST_BGN(test_case_base64_encode_4)
292  {
293  unsigned char src_str[1000];
294  unsigned char dst_str[1000];
295  size_t len = 1000;
296 
297  memset(src_str, 0x00, 1000);
298  memset(dst_str, 0x00, 1000);
299 
300  strcpy( (char *) src_str, "foo" );
301  fct_chk( base64_encode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == 0 );
302  if( 0 == 0 )
303  {
304  fct_chk( strcmp( (char *) dst_str, "Zm9v" ) == 0 );
305  }
306  }
307  FCT_TEST_END();
308 
309 
310  FCT_TEST_BGN(test_case_base64_encode_5)
311  {
312  unsigned char src_str[1000];
313  unsigned char dst_str[1000];
314  size_t len = 1000;
315 
316  memset(src_str, 0x00, 1000);
317  memset(dst_str, 0x00, 1000);
318 
319  strcpy( (char *) src_str, "foob" );
320  fct_chk( base64_encode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == 0 );
321  if( 0 == 0 )
322  {
323  fct_chk( strcmp( (char *) dst_str, "Zm9vYg==" ) == 0 );
324  }
325  }
326  FCT_TEST_END();
327 
328 
329  FCT_TEST_BGN(test_case_base64_encode_6)
330  {
331  unsigned char src_str[1000];
332  unsigned char dst_str[1000];
333  size_t len = 1000;
334 
335  memset(src_str, 0x00, 1000);
336  memset(dst_str, 0x00, 1000);
337 
338  strcpy( (char *) src_str, "fooba" );
339  fct_chk( base64_encode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == 0 );
340  if( 0 == 0 )
341  {
342  fct_chk( strcmp( (char *) dst_str, "Zm9vYmE=" ) == 0 );
343  }
344  }
345  FCT_TEST_END();
346 
347 
348  FCT_TEST_BGN(test_case_base64_encode_7)
349  {
350  unsigned char src_str[1000];
351  unsigned char dst_str[1000];
352  size_t len = 1000;
353 
354  memset(src_str, 0x00, 1000);
355  memset(dst_str, 0x00, 1000);
356 
357  strcpy( (char *) src_str, "foobar" );
358  fct_chk( base64_encode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == 0 );
359  if( 0 == 0 )
360  {
361  fct_chk( strcmp( (char *) dst_str, "Zm9vYmFy" ) == 0 );
362  }
363  }
364  FCT_TEST_END();
365 
366 
367  FCT_TEST_BGN(test_case_base64_decode_1)
368  {
369  unsigned char src_str[1000];
370  unsigned char dst_str[1000];
371  size_t len = 1000;
372  int res;
373 
374  memset(src_str, 0x00, 1000);
375  memset(dst_str, 0x00, 1000);
376 
377  strcpy( (char *) src_str, "" );
378  fct_chk( res = base64_decode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == 0 );
379  if( 0 == 0 )
380  {
381  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
382  }
383  }
384  FCT_TEST_END();
385 
386 
387  FCT_TEST_BGN(test_case_base64_decode_2)
388  {
389  unsigned char src_str[1000];
390  unsigned char dst_str[1000];
391  size_t len = 1000;
392  int res;
393 
394  memset(src_str, 0x00, 1000);
395  memset(dst_str, 0x00, 1000);
396 
397  strcpy( (char *) src_str, "Zg==" );
398  fct_chk( res = base64_decode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == 0 );
399  if( 0 == 0 )
400  {
401  fct_chk( strcmp( (char *) dst_str, "f" ) == 0 );
402  }
403  }
404  FCT_TEST_END();
405 
406 
407  FCT_TEST_BGN(test_case_base64_decode_3)
408  {
409  unsigned char src_str[1000];
410  unsigned char dst_str[1000];
411  size_t len = 1000;
412  int res;
413 
414  memset(src_str, 0x00, 1000);
415  memset(dst_str, 0x00, 1000);
416 
417  strcpy( (char *) src_str, "Zm8=" );
418  fct_chk( res = base64_decode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == 0 );
419  if( 0 == 0 )
420  {
421  fct_chk( strcmp( (char *) dst_str, "fo" ) == 0 );
422  }
423  }
424  FCT_TEST_END();
425 
426 
427  FCT_TEST_BGN(test_case_base64_decode_4)
428  {
429  unsigned char src_str[1000];
430  unsigned char dst_str[1000];
431  size_t len = 1000;
432  int res;
433 
434  memset(src_str, 0x00, 1000);
435  memset(dst_str, 0x00, 1000);
436 
437  strcpy( (char *) src_str, "Zm9v" );
438  fct_chk( res = base64_decode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == 0 );
439  if( 0 == 0 )
440  {
441  fct_chk( strcmp( (char *) dst_str, "foo" ) == 0 );
442  }
443  }
444  FCT_TEST_END();
445 
446 
447  FCT_TEST_BGN(test_case_base64_decode_5)
448  {
449  unsigned char src_str[1000];
450  unsigned char dst_str[1000];
451  size_t len = 1000;
452  int res;
453 
454  memset(src_str, 0x00, 1000);
455  memset(dst_str, 0x00, 1000);
456 
457  strcpy( (char *) src_str, "Zm9vYg==" );
458  fct_chk( res = base64_decode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == 0 );
459  if( 0 == 0 )
460  {
461  fct_chk( strcmp( (char *) dst_str, "foob" ) == 0 );
462  }
463  }
464  FCT_TEST_END();
465 
466 
467  FCT_TEST_BGN(test_case_base64_decode_6)
468  {
469  unsigned char src_str[1000];
470  unsigned char dst_str[1000];
471  size_t len = 1000;
472  int res;
473 
474  memset(src_str, 0x00, 1000);
475  memset(dst_str, 0x00, 1000);
476 
477  strcpy( (char *) src_str, "Zm9vYmE=" );
478  fct_chk( res = base64_decode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == 0 );
479  if( 0 == 0 )
480  {
481  fct_chk( strcmp( (char *) dst_str, "fooba" ) == 0 );
482  }
483  }
484  FCT_TEST_END();
485 
486 
487  FCT_TEST_BGN(test_case_base64_decode_7)
488  {
489  unsigned char src_str[1000];
490  unsigned char dst_str[1000];
491  size_t len = 1000;
492  int res;
493 
494  memset(src_str, 0x00, 1000);
495  memset(dst_str, 0x00, 1000);
496 
497  strcpy( (char *) src_str, "Zm9vYmFy" );
498  fct_chk( res = base64_decode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == 0 );
499  if( 0 == 0 )
500  {
501  fct_chk( strcmp( (char *) dst_str, "foobar" ) == 0 );
502  }
503  }
504  FCT_TEST_END();
505 
506 
507  FCT_TEST_BGN(base64_encode_buffer_size_just_right)
508  {
509  unsigned char src_str[1000];
510  unsigned char dst_str[1000];
511  size_t len = 9;
512 
513  memset(src_str, 0x00, 1000);
514  memset(dst_str, 0x00, 1000);
515 
516  strcpy( (char *) src_str, "foobar" );
517  fct_chk( base64_encode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == 0 );
518  if( 0 == 0 )
519  {
520  fct_chk( strcmp( (char *) dst_str, "Zm9vYmFy" ) == 0 );
521  }
522  }
523  FCT_TEST_END();
524 
525 
526  FCT_TEST_BGN(base64_encode_buffer_size_too_small)
527  {
528  unsigned char src_str[1000];
529  unsigned char dst_str[1000];
530  size_t len = 8;
531 
532  memset(src_str, 0x00, 1000);
533  memset(dst_str, 0x00, 1000);
534 
535  strcpy( (char *) src_str, "foobar" );
536  fct_chk( base64_encode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == POLARSSL_ERR_BASE64_BUFFER_TOO_SMALL );
538  {
539  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
540  }
541  }
542  FCT_TEST_END();
543 
544 
545  FCT_TEST_BGN(base64_decode_illegal_character)
546  {
547  unsigned char src_str[1000];
548  unsigned char dst_str[1000];
549  size_t len = 1000;
550  int res;
551 
552  memset(src_str, 0x00, 1000);
553  memset(dst_str, 0x00, 1000);
554 
555  strcpy( (char *) src_str, "zm#=" );
556  fct_chk( res = base64_decode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == POLARSSL_ERR_BASE64_INVALID_CHARACTER );
558  {
559  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
560  }
561  }
562  FCT_TEST_END();
563 
564 
565  FCT_TEST_BGN(base64_decode_too_much_equal_signs)
566  {
567  unsigned char src_str[1000];
568  unsigned char dst_str[1000];
569  size_t len = 1000;
570  int res;
571 
572  memset(src_str, 0x00, 1000);
573  memset(dst_str, 0x00, 1000);
574 
575  strcpy( (char *) src_str, "zm===" );
576  fct_chk( res = base64_decode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == POLARSSL_ERR_BASE64_INVALID_CHARACTER );
578  {
579  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
580  }
581  }
582  FCT_TEST_END();
583 
584 
585  FCT_TEST_BGN(base64_decode_invalid_char_after_equal_signs)
586  {
587  unsigned char src_str[1000];
588  unsigned char dst_str[1000];
589  size_t len = 1000;
590  int res;
591 
592  memset(src_str, 0x00, 1000);
593  memset(dst_str, 0x00, 1000);
594 
595  strcpy( (char *) src_str, "zm=masd" );
596  fct_chk( res = base64_decode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == POLARSSL_ERR_BASE64_INVALID_CHARACTER );
598  {
599  fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
600  }
601  }
602  FCT_TEST_END();
603 
604 #ifdef POLARSSL_SELF_TEST
605 
606  FCT_TEST_BGN(base64_selftest)
607  {
608  fct_chk( base64_self_test( 0 ) == 0 );
609  }
610  FCT_TEST_END();
611 #endif /* POLARSSL_SELF_TEST */
612 
613  }
614  FCT_SUITE_END();
615 
616 #endif /* POLARSSL_BASE64_C */
617 
618 }
619 FCT_END();
620