PolarSSL v1.1.4
test_suite_base64.c
Go to the documentation of this file.
00001 #include "fct.h"
00002 
00003 #include <polarssl/base64.h>
00004 
00005 #include <polarssl/config.h>
00006 
00007 #ifdef _MSC_VER
00008 #include <basetsd.h>
00009 typedef UINT32 uint32_t;
00010 #else
00011 #include <inttypes.h>
00012 #endif
00013 
00014 /*
00015  * 32-bit integer manipulation macros (big endian)
00016  */
00017 #ifndef GET_ULONG_BE
00018 #define GET_ULONG_BE(n,b,i)                             \
00019 {                                                       \
00020     (n) = ( (unsigned long) (b)[(i)    ] << 24 )        \
00021         | ( (unsigned long) (b)[(i) + 1] << 16 )        \
00022         | ( (unsigned long) (b)[(i) + 2] <<  8 )        \
00023         | ( (unsigned long) (b)[(i) + 3]       );       \
00024 }
00025 #endif
00026 
00027 #ifndef PUT_ULONG_BE
00028 #define PUT_ULONG_BE(n,b,i)                             \
00029 {                                                       \
00030     (b)[(i)    ] = (unsigned char) ( (n) >> 24 );       \
00031     (b)[(i) + 1] = (unsigned char) ( (n) >> 16 );       \
00032     (b)[(i) + 2] = (unsigned char) ( (n) >>  8 );       \
00033     (b)[(i) + 3] = (unsigned char) ( (n)       );       \
00034 }
00035 #endif
00036 
00037 int unhexify(unsigned char *obuf, const char *ibuf)
00038 {
00039     unsigned char c, c2;
00040     int len = strlen(ibuf) / 2;
00041     assert(!(strlen(ibuf) %1)); // must be even number of bytes
00042 
00043     while (*ibuf != 0)
00044     {
00045         c = *ibuf++;
00046         if( c >= '0' && c <= '9' )
00047             c -= '0';
00048         else if( c >= 'a' && c <= 'f' )
00049             c -= 'a' - 10;
00050         else if( c >= 'A' && c <= 'F' )
00051             c -= 'A' - 10;
00052         else
00053             assert( 0 );
00054 
00055         c2 = *ibuf++;
00056         if( c2 >= '0' && c2 <= '9' )
00057             c2 -= '0';
00058         else if( c2 >= 'a' && c2 <= 'f' )
00059             c2 -= 'a' - 10;
00060         else if( c2 >= 'A' && c2 <= 'F' )
00061             c2 -= 'A' - 10;
00062         else
00063             assert( 0 );
00064 
00065         *obuf++ = ( c << 4 ) | c2;
00066     }
00067 
00068     return len;
00069 }
00070 
00071 void hexify(unsigned char *obuf, const unsigned char *ibuf, int len)
00072 {
00073     unsigned char l, h;
00074 
00075     while (len != 0)
00076     {
00077         h = (*ibuf) / 16;
00078         l = (*ibuf) % 16;
00079 
00080         if( h < 10 )
00081             *obuf++ = '0' + h;
00082         else
00083             *obuf++ = 'a' + h - 10;
00084 
00085         if( l < 10 )
00086             *obuf++ = '0' + l;
00087         else
00088             *obuf++ = 'a' + l - 10;
00089 
00090         ++ibuf;
00091         len--;
00092     }
00093 }
00094 
00104 static int rnd_std_rand( void *rng_state, unsigned char *output, size_t len )
00105 {
00106     size_t i;
00107 
00108     if( rng_state != NULL )
00109         rng_state  = NULL;
00110 
00111     for( i = 0; i < len; ++i )
00112         output[i] = rand();
00113 
00114     return( 0 );
00115 }
00116 
00122 static int rnd_zero_rand( void *rng_state, unsigned char *output, size_t len )
00123 {
00124     if( rng_state != NULL )
00125         rng_state  = NULL;
00126 
00127     memset( output, 0, len );
00128 
00129     return( 0 );
00130 }
00131 
00132 typedef struct
00133 {
00134     unsigned char *buf;
00135     size_t length;
00136 } rnd_buf_info;
00137 
00149 static int rnd_buffer_rand( void *rng_state, unsigned char *output, size_t len )
00150 {
00151     rnd_buf_info *info = (rnd_buf_info *) rng_state;
00152     size_t use_len;
00153 
00154     if( rng_state == NULL )
00155         return( rnd_std_rand( NULL, output, len ) );
00156 
00157     use_len = len;
00158     if( len > info->length )
00159         use_len = info->length;
00160 
00161     if( use_len )
00162     {
00163         memcpy( output, info->buf, use_len );
00164         info->buf += use_len;
00165         info->length -= use_len;
00166     }
00167 
00168     if( len - use_len > 0 )
00169         return( rnd_std_rand( NULL, output + use_len, len - use_len ) );
00170 
00171     return( 0 );
00172 }
00173 
00181 typedef struct
00182 {
00183     uint32_t key[16];
00184     uint32_t v0, v1;
00185 } rnd_pseudo_info;
00186 
00195 static int rnd_pseudo_rand( void *rng_state, unsigned char *output, size_t len )
00196 {
00197     rnd_pseudo_info *info = (rnd_pseudo_info *) rng_state;
00198     uint32_t i, *k, sum, delta=0x9E3779B9;
00199     unsigned char result[4];
00200 
00201     if( rng_state == NULL )
00202         return( rnd_std_rand( NULL, output, len ) );
00203 
00204     k = info->key;
00205 
00206     while( len > 0 )
00207     {
00208         size_t use_len = ( len > 4 ) ? 4 : len;
00209         sum = 0;
00210 
00211         for( i = 0; i < 32; i++ )
00212         {
00213             info->v0 += (((info->v1 << 4) ^ (info->v1 >> 5)) + info->v1) ^ (sum + k[sum & 3]);
00214             sum += delta;
00215             info->v1 += (((info->v0 << 4) ^ (info->v0 >> 5)) + info->v0) ^ (sum + k[(sum>>11) & 3]);
00216         }
00217 
00218         PUT_ULONG_BE( info->v0, result, 0 );
00219         memcpy( output, result, use_len );
00220         len -= use_len;
00221     }
00222 
00223     return( 0 );
00224 }
00225 
00226 
00227 FCT_BGN()
00228 {
00229 #ifdef POLARSSL_BASE64_C
00230 
00231 
00232     FCT_SUITE_BGN(test_suite_base64)
00233     {
00234 
00235         FCT_TEST_BGN(test_case_base64_encode_1)
00236         {
00237             unsigned char src_str[1000];
00238             unsigned char dst_str[1000];
00239             size_t len = 1000;
00240         
00241             memset(src_str, 0x00, 1000);
00242             memset(dst_str, 0x00, 1000);
00243         
00244             strcpy( (char *) src_str, "" );
00245             fct_chk( base64_encode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == 0 );
00246             if( 0 == 0 )
00247             {
00248                 fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
00249             }
00250         }
00251         FCT_TEST_END();
00252 
00253 
00254         FCT_TEST_BGN(test_case_base64_encode_2)
00255         {
00256             unsigned char src_str[1000];
00257             unsigned char dst_str[1000];
00258             size_t len = 1000;
00259         
00260             memset(src_str, 0x00, 1000);
00261             memset(dst_str, 0x00, 1000);
00262         
00263             strcpy( (char *) src_str, "f" );
00264             fct_chk( base64_encode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == 0 );
00265             if( 0 == 0 )
00266             {
00267                 fct_chk( strcmp( (char *) dst_str, "Zg==" ) == 0 );
00268             }
00269         }
00270         FCT_TEST_END();
00271 
00272 
00273         FCT_TEST_BGN(test_case_base64_encode_3)
00274         {
00275             unsigned char src_str[1000];
00276             unsigned char dst_str[1000];
00277             size_t len = 1000;
00278         
00279             memset(src_str, 0x00, 1000);
00280             memset(dst_str, 0x00, 1000);
00281         
00282             strcpy( (char *) src_str, "fo" );
00283             fct_chk( base64_encode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == 0 );
00284             if( 0 == 0 )
00285             {
00286                 fct_chk( strcmp( (char *) dst_str, "Zm8=" ) == 0 );
00287             }
00288         }
00289         FCT_TEST_END();
00290 
00291 
00292         FCT_TEST_BGN(test_case_base64_encode_4)
00293         {
00294             unsigned char src_str[1000];
00295             unsigned char dst_str[1000];
00296             size_t len = 1000;
00297         
00298             memset(src_str, 0x00, 1000);
00299             memset(dst_str, 0x00, 1000);
00300         
00301             strcpy( (char *) src_str, "foo" );
00302             fct_chk( base64_encode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == 0 );
00303             if( 0 == 0 )
00304             {
00305                 fct_chk( strcmp( (char *) dst_str, "Zm9v" ) == 0 );
00306             }
00307         }
00308         FCT_TEST_END();
00309 
00310 
00311         FCT_TEST_BGN(test_case_base64_encode_5)
00312         {
00313             unsigned char src_str[1000];
00314             unsigned char dst_str[1000];
00315             size_t len = 1000;
00316         
00317             memset(src_str, 0x00, 1000);
00318             memset(dst_str, 0x00, 1000);
00319         
00320             strcpy( (char *) src_str, "foob" );
00321             fct_chk( base64_encode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == 0 );
00322             if( 0 == 0 )
00323             {
00324                 fct_chk( strcmp( (char *) dst_str, "Zm9vYg==" ) == 0 );
00325             }
00326         }
00327         FCT_TEST_END();
00328 
00329 
00330         FCT_TEST_BGN(test_case_base64_encode_6)
00331         {
00332             unsigned char src_str[1000];
00333             unsigned char dst_str[1000];
00334             size_t len = 1000;
00335         
00336             memset(src_str, 0x00, 1000);
00337             memset(dst_str, 0x00, 1000);
00338         
00339             strcpy( (char *) src_str, "fooba" );
00340             fct_chk( base64_encode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == 0 );
00341             if( 0 == 0 )
00342             {
00343                 fct_chk( strcmp( (char *) dst_str, "Zm9vYmE=" ) == 0 );
00344             }
00345         }
00346         FCT_TEST_END();
00347 
00348 
00349         FCT_TEST_BGN(test_case_base64_encode_7)
00350         {
00351             unsigned char src_str[1000];
00352             unsigned char dst_str[1000];
00353             size_t len = 1000;
00354         
00355             memset(src_str, 0x00, 1000);
00356             memset(dst_str, 0x00, 1000);
00357         
00358             strcpy( (char *) src_str, "foobar" );
00359             fct_chk( base64_encode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == 0 );
00360             if( 0 == 0 )
00361             {
00362                 fct_chk( strcmp( (char *) dst_str, "Zm9vYmFy" ) == 0 );
00363             }
00364         }
00365         FCT_TEST_END();
00366 
00367 
00368         FCT_TEST_BGN(test_case_base64_decode_1)
00369         {
00370             unsigned char src_str[1000];
00371             unsigned char dst_str[1000];
00372             size_t len = 1000;
00373             int res; 
00374         
00375             memset(src_str, 0x00, 1000);
00376             memset(dst_str, 0x00, 1000);
00377             
00378             strcpy( (char *) src_str, "" );
00379             fct_chk( res = base64_decode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == 0 );
00380             if( 0 == 0 )
00381             {
00382                 fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
00383             }
00384         }
00385         FCT_TEST_END();
00386 
00387 
00388         FCT_TEST_BGN(test_case_base64_decode_2)
00389         {
00390             unsigned char src_str[1000];
00391             unsigned char dst_str[1000];
00392             size_t len = 1000;
00393             int res; 
00394         
00395             memset(src_str, 0x00, 1000);
00396             memset(dst_str, 0x00, 1000);
00397             
00398             strcpy( (char *) src_str, "Zg==" );
00399             fct_chk( res = base64_decode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == 0 );
00400             if( 0 == 0 )
00401             {
00402                 fct_chk( strcmp( (char *) dst_str, "f" ) == 0 );
00403             }
00404         }
00405         FCT_TEST_END();
00406 
00407 
00408         FCT_TEST_BGN(test_case_base64_decode_3)
00409         {
00410             unsigned char src_str[1000];
00411             unsigned char dst_str[1000];
00412             size_t len = 1000;
00413             int res; 
00414         
00415             memset(src_str, 0x00, 1000);
00416             memset(dst_str, 0x00, 1000);
00417             
00418             strcpy( (char *) src_str, "Zm8=" );
00419             fct_chk( res = base64_decode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == 0 );
00420             if( 0 == 0 )
00421             {
00422                 fct_chk( strcmp( (char *) dst_str, "fo" ) == 0 );
00423             }
00424         }
00425         FCT_TEST_END();
00426 
00427 
00428         FCT_TEST_BGN(test_case_base64_decode_4)
00429         {
00430             unsigned char src_str[1000];
00431             unsigned char dst_str[1000];
00432             size_t len = 1000;
00433             int res; 
00434         
00435             memset(src_str, 0x00, 1000);
00436             memset(dst_str, 0x00, 1000);
00437             
00438             strcpy( (char *) src_str, "Zm9v" );
00439             fct_chk( res = base64_decode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == 0 );
00440             if( 0 == 0 )
00441             {
00442                 fct_chk( strcmp( (char *) dst_str, "foo" ) == 0 );
00443             }
00444         }
00445         FCT_TEST_END();
00446 
00447 
00448         FCT_TEST_BGN(test_case_base64_decode_5)
00449         {
00450             unsigned char src_str[1000];
00451             unsigned char dst_str[1000];
00452             size_t len = 1000;
00453             int res; 
00454         
00455             memset(src_str, 0x00, 1000);
00456             memset(dst_str, 0x00, 1000);
00457             
00458             strcpy( (char *) src_str, "Zm9vYg==" );
00459             fct_chk( res = base64_decode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == 0 );
00460             if( 0 == 0 )
00461             {
00462                 fct_chk( strcmp( (char *) dst_str, "foob" ) == 0 );
00463             }
00464         }
00465         FCT_TEST_END();
00466 
00467 
00468         FCT_TEST_BGN(test_case_base64_decode_6)
00469         {
00470             unsigned char src_str[1000];
00471             unsigned char dst_str[1000];
00472             size_t len = 1000;
00473             int res; 
00474         
00475             memset(src_str, 0x00, 1000);
00476             memset(dst_str, 0x00, 1000);
00477             
00478             strcpy( (char *) src_str, "Zm9vYmE=" );
00479             fct_chk( res = base64_decode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == 0 );
00480             if( 0 == 0 )
00481             {
00482                 fct_chk( strcmp( (char *) dst_str, "fooba" ) == 0 );
00483             }
00484         }
00485         FCT_TEST_END();
00486 
00487 
00488         FCT_TEST_BGN(test_case_base64_decode_7)
00489         {
00490             unsigned char src_str[1000];
00491             unsigned char dst_str[1000];
00492             size_t len = 1000;
00493             int res; 
00494         
00495             memset(src_str, 0x00, 1000);
00496             memset(dst_str, 0x00, 1000);
00497             
00498             strcpy( (char *) src_str, "Zm9vYmFy" );
00499             fct_chk( res = base64_decode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == 0 );
00500             if( 0 == 0 )
00501             {
00502                 fct_chk( strcmp( (char *) dst_str, "foobar" ) == 0 );
00503             }
00504         }
00505         FCT_TEST_END();
00506 
00507 
00508         FCT_TEST_BGN(base64_encode_buffer_size_just_right)
00509         {
00510             unsigned char src_str[1000];
00511             unsigned char dst_str[1000];
00512             size_t len = 9;
00513         
00514             memset(src_str, 0x00, 1000);
00515             memset(dst_str, 0x00, 1000);
00516         
00517             strcpy( (char *) src_str, "foobar" );
00518             fct_chk( base64_encode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == 0 );
00519             if( 0 == 0 )
00520             {
00521                 fct_chk( strcmp( (char *) dst_str, "Zm9vYmFy" ) == 0 );
00522             }
00523         }
00524         FCT_TEST_END();
00525 
00526 
00527         FCT_TEST_BGN(base64_encode_buffer_size_too_small)
00528         {
00529             unsigned char src_str[1000];
00530             unsigned char dst_str[1000];
00531             size_t len = 8;
00532         
00533             memset(src_str, 0x00, 1000);
00534             memset(dst_str, 0x00, 1000);
00535         
00536             strcpy( (char *) src_str, "foobar" );
00537             fct_chk( base64_encode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == POLARSSL_ERR_BASE64_BUFFER_TOO_SMALL );
00538             if( POLARSSL_ERR_BASE64_BUFFER_TOO_SMALL == 0 )
00539             {
00540                 fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
00541             }
00542         }
00543         FCT_TEST_END();
00544 
00545 
00546         FCT_TEST_BGN(base64_decode_illegal_character)
00547         {
00548             unsigned char src_str[1000];
00549             unsigned char dst_str[1000];
00550             size_t len = 1000;
00551             int res; 
00552         
00553             memset(src_str, 0x00, 1000);
00554             memset(dst_str, 0x00, 1000);
00555             
00556             strcpy( (char *) src_str, "zm#=" );
00557             fct_chk( res = base64_decode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == POLARSSL_ERR_BASE64_INVALID_CHARACTER );
00558             if( POLARSSL_ERR_BASE64_INVALID_CHARACTER == 0 )
00559             {
00560                 fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
00561             }
00562         }
00563         FCT_TEST_END();
00564 
00565 
00566         FCT_TEST_BGN(base64_decode_too_much_equal_signs)
00567         {
00568             unsigned char src_str[1000];
00569             unsigned char dst_str[1000];
00570             size_t len = 1000;
00571             int res; 
00572         
00573             memset(src_str, 0x00, 1000);
00574             memset(dst_str, 0x00, 1000);
00575             
00576             strcpy( (char *) src_str, "zm===" );
00577             fct_chk( res = base64_decode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == POLARSSL_ERR_BASE64_INVALID_CHARACTER );
00578             if( POLARSSL_ERR_BASE64_INVALID_CHARACTER == 0 )
00579             {
00580                 fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
00581             }
00582         }
00583         FCT_TEST_END();
00584 
00585 
00586         FCT_TEST_BGN(base64_decode_invalid_char_after_equal_signs)
00587         {
00588             unsigned char src_str[1000];
00589             unsigned char dst_str[1000];
00590             size_t len = 1000;
00591             int res; 
00592         
00593             memset(src_str, 0x00, 1000);
00594             memset(dst_str, 0x00, 1000);
00595             
00596             strcpy( (char *) src_str, "zm=masd" );
00597             fct_chk( res = base64_decode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == POLARSSL_ERR_BASE64_INVALID_CHARACTER );
00598             if( POLARSSL_ERR_BASE64_INVALID_CHARACTER == 0 )
00599             {
00600                 fct_chk( strcmp( (char *) dst_str, "" ) == 0 );
00601             }
00602         }
00603         FCT_TEST_END();
00604 
00605 #ifdef POLARSSL_SELF_TEST
00606 
00607         FCT_TEST_BGN(base64_selftest)
00608         {
00609             fct_chk( base64_self_test( 0 ) == 0 );
00610         }
00611         FCT_TEST_END();
00612 #endif /* POLARSSL_SELF_TEST */
00613 
00614     }
00615     FCT_SUITE_END();
00616 
00617 #endif /* POLARSSL_BASE64_C */
00618 
00619 }
00620 FCT_END();
00621