00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024 #include "polarssl/config.h"
00025
00026 #if defined(POLARSSL_BASE64_C)
00027
00028 #include "polarssl/base64.h"
00029
00030 static const unsigned char base64_enc_map[64] =
00031 {
00032 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
00033 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
00034 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd',
00035 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
00036 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x',
00037 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7',
00038 '8', '9', '+', '/'
00039 };
00040
00041 static const unsigned char base64_dec_map[128] =
00042 {
00043 127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
00044 127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
00045 127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
00046 127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
00047 127, 127, 127, 62, 127, 127, 127, 63, 52, 53,
00048 54, 55, 56, 57, 58, 59, 60, 61, 127, 127,
00049 127, 64, 127, 127, 127, 0, 1, 2, 3, 4,
00050 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
00051 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
00052 25, 127, 127, 127, 127, 127, 127, 26, 27, 28,
00053 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
00054 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
00055 49, 50, 51, 127, 127, 127, 127, 127
00056 };
00057
00058
00059
00060
00061 int base64_encode( unsigned char *dst, int *dlen,
00062 unsigned char *src, int slen )
00063 {
00064 int i, n;
00065 int C1, C2, C3;
00066 unsigned char *p;
00067
00068 if( slen == 0 )
00069 return( 0 );
00070
00071 n = (slen << 3) / 6;
00072
00073 switch( (slen << 3) - (n * 6) )
00074 {
00075 case 2: n += 3; break;
00076 case 4: n += 2; break;
00077 default: break;
00078 }
00079
00080 if( *dlen < n + 1 )
00081 {
00082 *dlen = n + 1;
00083 return( POLARSSL_ERR_BASE64_BUFFER_TOO_SMALL );
00084 }
00085
00086 n = (slen / 3) * 3;
00087
00088 for( i = 0, p = dst; i < n; i += 3 )
00089 {
00090 C1 = *src++;
00091 C2 = *src++;
00092 C3 = *src++;
00093
00094 *p++ = base64_enc_map[(C1 >> 2) & 0x3F];
00095 *p++ = base64_enc_map[(((C1 & 3) << 4) + (C2 >> 4)) & 0x3F];
00096 *p++ = base64_enc_map[(((C2 & 15) << 2) + (C3 >> 6)) & 0x3F];
00097 *p++ = base64_enc_map[C3 & 0x3F];
00098 }
00099
00100 if( i < slen )
00101 {
00102 C1 = *src++;
00103 C2 = ((i + 1) < slen) ? *src++ : 0;
00104
00105 *p++ = base64_enc_map[(C1 >> 2) & 0x3F];
00106 *p++ = base64_enc_map[(((C1 & 3) << 4) + (C2 >> 4)) & 0x3F];
00107
00108 if( (i + 1) < slen )
00109 *p++ = base64_enc_map[((C2 & 15) << 2) & 0x3F];
00110 else *p++ = '=';
00111
00112 *p++ = '=';
00113 }
00114
00115 *dlen = p - dst;
00116 *p = 0;
00117
00118 return( 0 );
00119 }
00120
00121
00122
00123
00124 int base64_decode( unsigned char *dst, int *dlen,
00125 unsigned char *src, int slen )
00126 {
00127 int i, j, n;
00128 unsigned long x;
00129 unsigned char *p;
00130
00131 for( i = j = n = 0; i < slen; i++ )
00132 {
00133 if( ( slen - i ) >= 2 &&
00134 src[i] == '\r' && src[i + 1] == '\n' )
00135 continue;
00136
00137 if( src[i] == '\n' )
00138 continue;
00139
00140 if( src[i] == '=' && ++j > 2 )
00141 return( POLARSSL_ERR_BASE64_INVALID_CHARACTER );
00142
00143 if( src[i] > 127 || base64_dec_map[src[i]] == 127 )
00144 return( POLARSSL_ERR_BASE64_INVALID_CHARACTER );
00145
00146 if( base64_dec_map[src[i]] < 64 && j != 0 )
00147 return( POLARSSL_ERR_BASE64_INVALID_CHARACTER );
00148
00149 n++;
00150 }
00151
00152 if( n == 0 )
00153 return( 0 );
00154
00155 n = ((n * 6) + 7) >> 3;
00156
00157 if( *dlen < n )
00158 {
00159 *dlen = n;
00160 return( POLARSSL_ERR_BASE64_BUFFER_TOO_SMALL );
00161 }
00162
00163 for( j = 3, n = x = 0, p = dst; i > 0; i--, src++ )
00164 {
00165 if( *src == '\r' || *src == '\n' )
00166 continue;
00167
00168 j -= ( base64_dec_map[*src] == 64 );
00169 x = (x << 6) | ( base64_dec_map[*src] & 0x3F );
00170
00171 if( ++n == 4 )
00172 {
00173 n = 0;
00174 if( j > 0 ) *p++ = (unsigned char)( x >> 16 );
00175 if( j > 1 ) *p++ = (unsigned char)( x >> 8 );
00176 if( j > 2 ) *p++ = (unsigned char)( x );
00177 }
00178 }
00179
00180 *dlen = p - dst;
00181
00182 return( 0 );
00183 }
00184
00185 #if defined(POLARSSL_SELF_TEST)
00186
00187 #include <string.h>
00188 #include <stdio.h>
00189
00190 static const unsigned char base64_test_dec[64] =
00191 {
00192 0x24, 0x48, 0x6E, 0x56, 0x87, 0x62, 0x5A, 0xBD,
00193 0xBF, 0x17, 0xD9, 0xA2, 0xC4, 0x17, 0x1A, 0x01,
00194 0x94, 0xED, 0x8F, 0x1E, 0x11, 0xB3, 0xD7, 0x09,
00195 0x0C, 0xB6, 0xE9, 0x10, 0x6F, 0x22, 0xEE, 0x13,
00196 0xCA, 0xB3, 0x07, 0x05, 0x76, 0xC9, 0xFA, 0x31,
00197 0x6C, 0x08, 0x34, 0xFF, 0x8D, 0xC2, 0x6C, 0x38,
00198 0x00, 0x43, 0xE9, 0x54, 0x97, 0xAF, 0x50, 0x4B,
00199 0xD1, 0x41, 0xBA, 0x95, 0x31, 0x5A, 0x0B, 0x97
00200 };
00201
00202 static const unsigned char base64_test_enc[] =
00203 "JEhuVodiWr2/F9mixBcaAZTtjx4Rs9cJDLbpEG8i7hPK"
00204 "swcFdsn6MWwINP+Nwmw4AEPpVJevUEvRQbqVMVoLlw==";
00205
00206
00207
00208
00209 int base64_self_test( int verbose )
00210 {
00211 int len;
00212 unsigned char *src, buffer[128];
00213
00214 if( verbose != 0 )
00215 printf( " Base64 encoding test: " );
00216
00217 len = sizeof( buffer );
00218 src = (unsigned char *) base64_test_dec;
00219
00220 if( base64_encode( buffer, &len, src, 64 ) != 0 ||
00221 memcmp( base64_test_enc, buffer, 88 ) != 0 )
00222 {
00223 if( verbose != 0 )
00224 printf( "failed\n" );
00225
00226 return( 1 );
00227 }
00228
00229 if( verbose != 0 )
00230 printf( "passed\n Base64 decoding test: " );
00231
00232 len = sizeof( buffer );
00233 src = (unsigned char *) base64_test_enc;
00234
00235 if( base64_decode( buffer, &len, src, 88 ) != 0 ||
00236 memcmp( base64_test_dec, buffer, 64 ) != 0 )
00237 {
00238 if( verbose != 0 )
00239 printf( "failed\n" );
00240
00241 return( 1 );
00242 }
00243
00244 if( verbose != 0 )
00245 printf( "passed\n\n" );
00246
00247 return( 0 );
00248 }
00249
00250 #endif
00251
00252 #endif