1/* /////////////////////////////////////////////////////////////////////////////
2 * File:        b64.c
3 *
4 * Purpose:     Implementation file for the b64 library
5 *
6 * Created:     18th October 2004
7 * Updated:     2nd August 2006
8 *
9 * Home:        http://synesis.com.au/software/
10 *
11 * Copyright (c) 2004-2006, Matthew Wilson and Synesis Software
12 * All rights reserved.
13 *
14 * Redistribution and use in source and binary forms, with or without
15 * modification, are permitted provided that the following conditions are met:
16 *
17 * - Redistributions of source code must retain the above copyright notice, this
18 *   list of conditions and the following disclaimer.
19 * - Redistributions in binary form must reproduce the above copyright notice,
20 *   this list of conditions and the following disclaimer in the documentation
21 *   and/or other materials provided with the distribution.
22 * - Neither the name(s) of Matthew Wilson and Synesis Software nor the names of
23 *   any contributors may be used to endorse or promote products derived from
24 *   this software without specific prior written permission.
25 *
26 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
27 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
30 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36 * POSSIBILITY OF SUCH DAMAGE.
37 *
38 * ////////////////////////////////////////////////////////////////////////// */
39
40
41/** \file b64.c Implementation file for the b64 library
42 */
43
44#include "SecBase64P.h"
45
46#include <assert.h>
47#include <string.h>
48
49/* /////////////////////////////////////////////////////////////////////////////
50 * Constants and definitions
51 */
52
53#ifndef B64_DOCUMENTATION_SKIP_SECTION
54# define NUM_PLAIN_DATA_BYTES        (3)
55# define NUM_ENCODED_DATA_BYTES      (4)
56#endif /* !B64_DOCUMENTATION_SKIP_SECTION */
57
58/* /////////////////////////////////////////////////////////////////////////////
59 * Warnings
60 */
61
62#if defined(_MSC_VER) && \
63    _MSC_VER < 1000
64# pragma warning(disable : 4705)
65#endif /* _MSC_VER < 1000 */
66
67/* /////////////////////////////////////////////////////////////////////////////
68 * Data
69 */
70
71static const char           b64_chars[] =   "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
72
73static const signed char    b64_indexes[]   =
74{
75    /* 0 - 31 / 0x00 - 0x1f */
76        -1, -1, -1, -1, -1, -1, -1, -1
77    ,   -1, -1, -1, -1, -1, -1, -1, -1
78    ,   -1, -1, -1, -1, -1, -1, -1, -1
79    ,   -1, -1, -1, -1, -1, -1, -1, -1
80    /* 32 - 63 / 0x20 - 0x3f */
81    ,   -1, -1, -1, -1, -1, -1, -1, -1
82    ,   -1, -1, -1, 62, -1, -1, -1, 63  /* ... , '+', ... '/' */
83    ,   52, 53, 54, 55, 56, 57, 58, 59  /* '0' - '7' */
84    ,   60, 61, -1, -1, -1, -1, -1, -1  /* '8', '9', ... */
85    /* 64 - 95 / 0x40 - 0x5f */
86    ,   -1, 0,  1,  2,  3,  4,  5,  6   /* ..., 'A' - 'G' */
87    ,   7,  8,  9,  10, 11, 12, 13, 14  /* 'H' - 'O' */
88    ,   15, 16, 17, 18, 19, 20, 21, 22  /* 'P' - 'W' */
89    ,   23, 24, 25, -1, -1, -1, -1, -1  /* 'X', 'Y', 'Z', ... */
90    /* 96 - 127 / 0x60 - 0x7f */
91    ,   -1, 26, 27, 28, 29, 30, 31, 32  /* ..., 'a' - 'g' */
92    ,   33, 34, 35, 36, 37, 38, 39, 40  /* 'h' - 'o' */
93    ,   41, 42, 43, 44, 45, 46, 47, 48  /* 'p' - 'w' */
94    ,   49, 50, 51, -1, -1, -1, -1, -1  /* 'x', 'y', 'z', ... */
95
96    ,   -1, -1, -1, -1, -1, -1, -1, -1
97    ,   -1, -1, -1, -1, -1, -1, -1, -1
98    ,   -1, -1, -1, -1, -1, -1, -1, -1
99    ,   -1, -1, -1, -1, -1, -1, -1, -1
100
101    ,   -1, -1, -1, -1, -1, -1, -1, -1
102    ,   -1, -1, -1, -1, -1, -1, -1, -1
103    ,   -1, -1, -1, -1, -1, -1, -1, -1
104    ,   -1, -1, -1, -1, -1, -1, -1, -1
105
106    ,   -1, -1, -1, -1, -1, -1, -1, -1
107    ,   -1, -1, -1, -1, -1, -1, -1, -1
108    ,   -1, -1, -1, -1, -1, -1, -1, -1
109    ,   -1, -1, -1, -1, -1, -1, -1, -1
110
111    ,   -1, -1, -1, -1, -1, -1, -1, -1
112    ,   -1, -1, -1, -1, -1, -1, -1, -1
113    ,   -1, -1, -1, -1, -1, -1, -1, -1
114    ,   -1, -1, -1, -1, -1, -1, -1, -1
115};
116
117/* /////////////////////////////////////////////////////////////////////////////
118 * Helper functions
119 */
120
121/** This function reads in 3 bytes at a time, and translates them into 4
122 * characters.
123 */
124static size_t SecBase64Encode_(  unsigned char const *src
125                        ,   size_t              srcSize
126                        ,   char *const         dest
127                        ,   size_t              destLen
128                        ,   unsigned            lineLen
129                        ,   SecBase64Result     *rc)
130{
131    size_t  total   =   ((srcSize + (NUM_PLAIN_DATA_BYTES - 1)) / NUM_PLAIN_DATA_BYTES) * NUM_ENCODED_DATA_BYTES;
132
133    assert(NULL != rc);
134    *rc = kSecB64_R_OK;
135
136    if(lineLen > 0)
137    {
138        size_t    numLines    =   (total + (lineLen - 1)) / lineLen;
139
140        total += 2 * (numLines - 1);
141    }
142
143    if(NULL == dest)
144    {
145        return total;
146    }
147    else if(destLen < total)
148    {
149        *rc = kSecB64_R_INSUFFICIENT_BUFFER;
150
151        return 0;
152    }
153    else
154    {
155        char    *p      =   dest;
156        char    *end    =   dest + destLen;
157        size_t  len     =   0;
158
159        for(; NUM_PLAIN_DATA_BYTES <= srcSize; srcSize -= NUM_PLAIN_DATA_BYTES)
160        {
161            char    characters[NUM_ENCODED_DATA_BYTES];
162
163            /*
164             *
165             * |       0       |       1       |       2       |
166             *
167             * |               |               |               |
168             * |       |       |       |       |       |       |
169             * |   |   |   |   |   |   |   |   |   |   |   |   |
170             * | | | | | | | | | | | | | | | | | | | | | | | | |
171             *
172             * |     0     |     1     |     2     |     3     |
173             *
174             */
175
176            /* characters[0] is the 6 left-most bits of src[0] */
177            characters[0] = (char)((src[0] & 0xfc) >> 2);
178            /* characters[0] is the right-most 2 bits of src[0] and the left-most 4 bits of src[1] */
179            characters[1] = (char)(((src[0] & 0x03) << 4) + ((src[1] & 0xf0) >> 4));
180            /* characters[0] is the right-most 4 bits of src[1] and the 2 left-most bits of src[2] */
181            characters[2] = (char)(((src[1] & 0x0f) << 2) + ((src[2] & 0xc0) >> 6));
182            /* characters[3] is the right-most 6 bits of src[2] */
183            characters[3] = (char)(src[2] & 0x3f);
184
185#ifndef __WATCOMC__
186            assert(characters[0] >= 0 && characters[0] < 64);
187            assert(characters[1] >= 0 && characters[1] < 64);
188            assert(characters[2] >= 0 && characters[2] < 64);
189            assert(characters[3] >= 0 && characters[3] < 64);
190#endif /* __WATCOMC__ */
191
192            src += NUM_PLAIN_DATA_BYTES;
193            *p++ = b64_chars[(unsigned char)characters[0]];
194            assert(NULL != strchr(b64_chars, *(p-1)));
195            ++len;
196            assert(len != lineLen);
197
198            *p++ = b64_chars[(unsigned char)characters[1]];
199            assert(NULL != strchr(b64_chars, *(p-1)));
200            ++len;
201            assert(len != lineLen);
202
203            *p++ = b64_chars[(unsigned char)characters[2]];
204            assert(NULL != strchr(b64_chars, *(p-1)));
205            ++len;
206            assert(len != lineLen);
207
208            *p++ = b64_chars[(unsigned char)characters[3]];
209            assert(NULL != strchr(b64_chars, *(p-1)));
210
211            if( ++len == lineLen &&
212                p != end)
213            {
214                *p++ = '\r';
215                *p++ = '\n';
216                len = 0;
217            }
218        }
219
220        if(0 != srcSize)
221        {
222            /* Deal with the overspill, by boosting it up to three bytes (using 0s)
223             * and then appending '=' for any missing characters.
224             *
225             * This is done into a temporary buffer, so we can call ourselves and
226             * have the output continue to be written direct to the destination.
227             */
228
229            unsigned char   dummy[NUM_PLAIN_DATA_BYTES];
230            size_t          i;
231
232            for(i = 0; i < srcSize; ++i)
233            {
234                dummy[i] = *src++;
235            }
236
237            for(; i < NUM_PLAIN_DATA_BYTES; ++i)
238            {
239                dummy[i] = '\0';
240            }
241
242            SecBase64Encode_(&dummy[0], NUM_PLAIN_DATA_BYTES, p, NUM_ENCODED_DATA_BYTES * (1 + 2), 0, rc);
243
244            for(p += 1 + srcSize; srcSize++ < NUM_PLAIN_DATA_BYTES; )
245            {
246                *p++ = '=';
247            }
248        }
249
250        return total;
251    }
252}
253
254/** This function reads in a character string in 4-character chunks, and writes
255 * out the converted form in 3-byte chunks to the destination.
256 */
257static size_t SecBase64Decode_(  char const      *src
258                        ,   size_t          srcLen
259                        ,   unsigned char   *dest
260                        ,   size_t          destSize
261                        ,   unsigned        flags
262                        ,   char const      **badChar
263                        ,   SecBase64Result *rc)
264{
265    const size_t    wholeChunks     =   (srcLen / NUM_ENCODED_DATA_BYTES);
266    const size_t    remainderBytes  =   (srcLen % NUM_ENCODED_DATA_BYTES);
267    size_t          maxTotal        =   (wholeChunks + (0 != remainderBytes)) * NUM_PLAIN_DATA_BYTES;
268    unsigned char   *dest_          =   dest;
269
270    ((void)remainderBytes);
271
272    assert(NULL != badChar);
273    assert(NULL != rc);
274
275    *badChar    =   NULL;
276    *rc         =   kSecB64_R_OK;
277
278    if(NULL == dest)
279    {
280        return maxTotal;
281    }
282    else if(destSize < maxTotal)
283    {
284        *rc = kSecB64_R_INSUFFICIENT_BUFFER;
285
286        return 0;
287    }
288    else
289    {
290        /* Now we iterate through the src, collecting together four characters
291         * at a time from the Base-64 alphabet, until the end-point is reached.
292         *
293         *
294         */
295
296        char const          *begin      =   src;
297        char const  *const  end         =   begin + srcLen;
298        size_t              currIndex   =   0;
299        size_t              numPads     =   0;
300        signed char         indexes[NUM_ENCODED_DATA_BYTES];    /* 4 */
301
302        for(; begin != end; ++begin)
303        {
304            const char  ch  =   *begin;
305
306            if('=' == ch)
307            {
308                assert(currIndex < NUM_ENCODED_DATA_BYTES);
309
310                indexes[currIndex++] = '\0';
311
312                ++numPads;
313            }
314            else
315            {
316                signed char ix   =   b64_indexes[(unsigned char)ch];
317
318                if(-1 == ix)
319                {
320                    switch(ch)
321                    {
322                        case    ' ':
323                        case    '\t':
324                        case    '\b':
325                        case    '\v':
326                            if(kSecB64_F_STOP_ON_UNEXPECTED_WS & flags)
327                            {
328                                *rc         =   kSecB64_R_DATA_ERROR;
329                                *badChar    =   begin;
330                                return 0;
331                            }
332                            else
333                            {
334                                /* Fall through */
335                            }
336                        case    '\r':
337                        case    '\n':
338                            continue;
339                        default:
340                            if(kSecB64_F_STOP_ON_UNKNOWN_CHAR & flags)
341                            {
342                                *rc         =   kSecB64_R_DATA_ERROR;
343                                *badChar    =   begin;
344                                return 0;
345                            }
346                            else
347                            {
348                                continue;
349                            }
350                    }
351                }
352                else
353                {
354                    numPads = 0;
355
356                    assert(currIndex < NUM_ENCODED_DATA_BYTES);
357
358                    indexes[currIndex++] = ix;
359                }
360            }
361
362            if(NUM_ENCODED_DATA_BYTES == currIndex)
363            {
364                unsigned char   bytes[NUM_PLAIN_DATA_BYTES];        /* 3 */
365
366                bytes[0] = (unsigned char)((indexes[0] << 2) + ((indexes[1] & 0x30) >> 4));
367
368                currIndex = 0;
369
370                *dest++ = bytes[0];
371                if(2 != numPads)
372                {
373                    bytes[1] = (unsigned char)(((indexes[1] & 0xf) << 4) + ((indexes[2] & 0x3c) >> 2));
374
375                    *dest++ = bytes[1];
376
377                    if(1 != numPads)
378                    {
379                        bytes[2] = (unsigned char)(((indexes[2] & 0x3) << 6) + indexes[3]);
380
381                        *dest++ = bytes[2];
382                    }
383                }
384                if(0 != numPads)
385                {
386                    break;
387                }
388            }
389        }
390
391        return (size_t)(dest - dest_);
392    }
393}
394
395/* /////////////////////////////////////////////////////////////////////////////
396 * API functions
397 */
398
399size_t SecBase64Encode(void const *src, size_t srcSize, char *dest, size_t destLen)
400{
401    /* Use Null Object (Variable) here for rc, so do not need to check
402     * elsewhere.
403     */
404    SecBase64Result  rc_;
405
406    return SecBase64Encode_((unsigned char const*)src, srcSize, dest, destLen, 0, &rc_);
407}
408
409size_t SecBase64Encode2( void const *src
410                ,   size_t          srcSize
411                ,   char            *dest
412                ,   size_t          destLen
413                ,   unsigned        flags
414                ,   int             lineLen /* = -1 */
415                ,   SecBase64Result *rc     /* = NULL */)
416{
417    /* Use Null Object (Variable) here for rc, so do not need to check
418     * elsewhere
419     */
420    SecBase64Result  rc_;
421    if(NULL == rc)
422    {
423        rc = &rc_;
424    }
425
426    switch(kSecB64_F_LINE_LEN_MASK & flags)
427    {
428        case    kSecB64_F_LINE_LEN_USE_PARAM:
429            if(lineLen >= 0)
430            {
431                break;
432            }
433            /* Fall through to 64 */
434        case    kSecB64_F_LINE_LEN_64:
435            lineLen = 64;
436            break;
437        case    kSecB64_F_LINE_LEN_76:
438            lineLen = 76;
439            break;
440        default:
441            assert(!"Bad line length flag specified to SecBase64Encode2()");
442        case    kSecB64_F_LINE_LEN_INFINITE:
443            lineLen = 0;
444            break;
445    }
446
447    assert(0 == (lineLen % 4));
448
449    return SecBase64Encode_((unsigned char const*)src, srcSize, dest, destLen, (unsigned)lineLen, rc);
450}
451
452size_t SecBase64Decode(char const *src, size_t srcLen, void *dest, size_t destSize)
453{
454    /* Use Null Object (Variable) here for rc and badChar, so do not need to
455     * check elsewhere.
456     */
457    char const  *badChar_;
458    SecBase64Result      rc_;
459
460    return SecBase64Decode_(src, srcLen, (unsigned char*)dest, destSize, kSecB64_F_STOP_ON_NOTHING, &badChar_, &rc_);
461}
462
463size_t SecBase64Decode2( char const  *src
464                ,   size_t      srcLen
465                ,   void        *dest
466                ,   size_t      destSize
467                ,   unsigned    flags
468                ,   char const  **badChar   /* = NULL */
469                ,   SecBase64Result      *rc         /* = NULL */)
470{
471    char const      *badChar_;
472    SecBase64Result          rc_;
473
474    /* Use Null Object (Variable) here for rc and badChar, so do not need to
475     * check elsewhere.
476     */
477    if(NULL == badChar)
478    {
479        badChar = &badChar_;
480    }
481    if(NULL == rc)
482    {
483        rc = &rc_;
484    }
485
486    return SecBase64Decode_(src, srcLen, (unsigned char*)dest, destSize, flags, badChar, rc);
487}
488
489/* ////////////////////////////////////////////////////////////////////////// */
490