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