Separate PolarSSL from PDKIM. Bug 1192
[users/heiko/exim.git] / src / src / pdkim / base64.c
1 /*
2  *  RFC 1521 base64 encoding/decoding
3  *
4  *  Copyright (C) 2006-2010, Brainspark B.V.
5  *
6  *  This file is part of PolarSSL (http://www.polarssl.org)
7  *  Lead Maintainer: Paul Bakker <polarssl_maintainer at polarssl.org>
8  *
9  *  All rights reserved.
10  *
11  *  This program is free software; you can redistribute it and/or modify
12  *  it under the terms of the GNU General Public License as published by
13  *  the Free Software Foundation; either version 2 of the License, or
14  *  (at your option) any later version.
15  *
16  *  This program is distributed in the hope that it will be useful,
17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  *  GNU General Public License for more details.
20  *
21  *  You should have received a copy of the GNU General Public License along
22  *  with this program; if not, write to the Free Software Foundation, Inc.,
23  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
24  */
25
26 #include "polarssl/config.h"
27
28 #if defined(POLARSSL_BASE64_C)
29
30 #include "polarssl/base64.h"
31
32 static const unsigned char base64_enc_map[64] =
33 {
34     'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
35     'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
36     'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd',
37     'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
38     'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x',
39     'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7',
40     '8', '9', '+', '/'
41 };
42
43 static const unsigned char base64_dec_map[128] =
44 {
45     127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
46     127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
47     127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
48     127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
49     127, 127, 127,  62, 127, 127, 127,  63,  52,  53,
50      54,  55,  56,  57,  58,  59,  60,  61, 127, 127,
51     127,  64, 127, 127, 127,   0,   1,   2,   3,   4,
52       5,   6,   7,   8,   9,  10,  11,  12,  13,  14,
53      15,  16,  17,  18,  19,  20,  21,  22,  23,  24,
54      25, 127, 127, 127, 127, 127, 127,  26,  27,  28,
55      29,  30,  31,  32,  33,  34,  35,  36,  37,  38,
56      39,  40,  41,  42,  43,  44,  45,  46,  47,  48,
57      49,  50,  51, 127, 127, 127, 127, 127
58 };
59
60 /*
61  * Encode a buffer into base64 format
62  */
63 int base64_encode( unsigned char *dst, int *dlen,
64                    const unsigned char *src, int  slen )
65 {
66     int i, n;
67     int C1, C2, C3;
68     unsigned char *p;
69
70     if( slen == 0 )
71         return( 0 );
72
73     n = (slen << 3) / 6;
74
75     switch( (slen << 3) - (n * 6) )
76     {
77         case  2: n += 3; break;
78         case  4: n += 2; break;
79         default: break;
80     }
81
82     if( *dlen < n + 1 )
83     {
84         *dlen = n + 1;
85         return( POLARSSL_ERR_BASE64_BUFFER_TOO_SMALL );
86     }
87
88     n = (slen / 3) * 3;
89
90     for( i = 0, p = dst; i < n; i += 3 )
91     {
92         C1 = *src++;
93         C2 = *src++;
94         C3 = *src++;
95
96         *p++ = base64_enc_map[(C1 >> 2) & 0x3F];
97         *p++ = base64_enc_map[(((C1 &  3) << 4) + (C2 >> 4)) & 0x3F];
98         *p++ = base64_enc_map[(((C2 & 15) << 2) + (C3 >> 6)) & 0x3F];
99         *p++ = base64_enc_map[C3 & 0x3F];
100     }
101
102     if( i < slen )
103     {
104         C1 = *src++;
105         C2 = ((i + 1) < slen) ? *src++ : 0;
106
107         *p++ = base64_enc_map[(C1 >> 2) & 0x3F];
108         *p++ = base64_enc_map[(((C1 & 3) << 4) + (C2 >> 4)) & 0x3F];
109
110         if( (i + 1) < slen )
111              *p++ = base64_enc_map[((C2 & 15) << 2) & 0x3F];
112         else *p++ = '=';
113
114         *p++ = '=';
115     }
116
117     *dlen = p - dst;
118     *p = 0;
119
120     return( 0 );
121 }
122
123 /*
124  * Decode a base64-formatted buffer
125  */
126 int base64_decode( unsigned char *dst, int *dlen,
127                    const unsigned char *src, int  slen )
128 {
129     int i, j, n;
130     unsigned long x;
131     unsigned char *p;
132
133     for( i = j = n = 0; i < slen; i++ )
134     {
135         unsigned char c = src[i];
136
137         if( ( slen - i ) >= 2 &&
138             c == '\r' && src[i + 1] == '\n' )
139             continue;
140
141         if( c == '\n' || c == ' ' || c == '\t' )
142             continue;
143
144         if( c == '=' && ++j > 2 )
145             return( POLARSSL_ERR_BASE64_INVALID_CHARACTER );
146
147         if( c > 127 || base64_dec_map[src[i]] == 127 )
148             return( POLARSSL_ERR_BASE64_INVALID_CHARACTER );
149
150         if( base64_dec_map[c] < 64 && j != 0 )
151             return( POLARSSL_ERR_BASE64_INVALID_CHARACTER );
152
153         n++;
154     }
155
156     if( n == 0 )
157         return( 0 );
158
159     n = ((n * 6) + 7) >> 3;
160
161     if( *dlen < n )
162     {
163         *dlen = n;
164         return( POLARSSL_ERR_BASE64_BUFFER_TOO_SMALL );
165     }
166
167    for( j = 3, n = x = 0, p = dst; i > 0; i--, src++ )
168    {
169         unsigned char c = *src;
170
171         if( c == '\r' || c == '\n' || c == ' ' || c == '\t' )
172             continue;
173
174         j -= ( base64_dec_map[c] == 64 );
175         x  = (x << 6) | ( base64_dec_map[c] & 0x3F );
176
177         if( ++n == 4 )
178         {
179             n = 0;
180             if( j > 0 ) *p++ = (unsigned char)( x >> 16 );
181             if( j > 1 ) *p++ = (unsigned char)( x >>  8 );
182             if( j > 2 ) *p++ = (unsigned char)( x       );
183         }
184     }
185
186     *dlen = p - dst;
187
188     return( 0 );
189 }
190
191 #if defined(POLARSSL_SELF_TEST)
192
193 #include <string.h>
194 #include <stdio.h>
195
196 static const unsigned char base64_test_dec[64] =
197 {
198     0x24, 0x48, 0x6E, 0x56, 0x87, 0x62, 0x5A, 0xBD,
199     0xBF, 0x17, 0xD9, 0xA2, 0xC4, 0x17, 0x1A, 0x01,
200     0x94, 0xED, 0x8F, 0x1E, 0x11, 0xB3, 0xD7, 0x09,
201     0x0C, 0xB6, 0xE9, 0x10, 0x6F, 0x22, 0xEE, 0x13,
202     0xCA, 0xB3, 0x07, 0x05, 0x76, 0xC9, 0xFA, 0x31,
203     0x6C, 0x08, 0x34, 0xFF, 0x8D, 0xC2, 0x6C, 0x38,
204     0x00, 0x43, 0xE9, 0x54, 0x97, 0xAF, 0x50, 0x4B,
205     0xD1, 0x41, 0xBA, 0x95, 0x31, 0x5A, 0x0B, 0x97
206 };
207
208 static const unsigned char base64_test_enc[] =
209     "JEhuVodiWr2/F9mixBcaAZTtjx4Rs9cJDLbpEG8i7hPK"
210     "swcFdsn6MWwINP+Nwmw4AEPpVJevUEvRQbqVMVoLlw==";
211
212 /*
213  * Checkup routine
214  */
215 int base64_self_test( int verbose )
216 {
217     int len;
218     unsigned char *src, buffer[128];
219
220     if( verbose != 0 )
221         printf( "  Base64 encoding test: " );
222
223     len = sizeof( buffer );
224     src = (unsigned char *) base64_test_dec;
225
226     if( base64_encode( buffer, &len, src, 64 ) != 0 ||
227          memcmp( base64_test_enc, buffer, 88 ) != 0 )
228     {
229         if( verbose != 0 )
230             printf( "failed\n" );
231
232         return( 1 );
233     }
234
235     if( verbose != 0 )
236         printf( "passed\n  Base64 decoding test: " );
237
238     len = sizeof( buffer );
239     src = (unsigned char *) base64_test_enc;
240
241     if( base64_decode( buffer, &len, src, 88 ) != 0 ||
242          memcmp( base64_test_dec, buffer, 64 ) != 0 )
243     {
244         if( verbose != 0 )
245             printf( "failed\n" );
246
247         return( 1 );
248     }
249
250     if( verbose != 0 )
251         printf( "passed\n\n" );
252
253     return( 0 );
254 }
255
256 #endif
257
258 #endif