src/src/base64.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) Tom Kistner <tom@duncanthrax.net> 2004, 2015 */
   6 /* License: GPL */
   7
   8 /* Copyright (c) University of Cambridge 1995 - 2018 */
   9 /* See the file NOTICE for conditions of use and distribution. */
  10
  11
  12 #include "exim.h"
  13 #ifdef WITH_CONTENT_SCAN        /* file-IO specific decode function */
  14 # include "mime.h"
  15
  16 /* BASE64 decoder matrix */
  17 static unsigned char mime_b64[256]={
  18 /*   0 */  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
  19 /*  16 */  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
  20 /*  32 */  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,   62,  128,  128,  128,   63,
  21 /*  48 */   52,   53,   54,   55,   56,   57,   58,   59,   60,   61,  128,  128,  128,  255,  128,  128,
  22 /*  64 */  128,    0,    1,    2,    3,    4,    5,    6,    7,    8,    9,   10,   11,   12,   13,   14,
  23 /*  80 */   15,   16,   17,   18,   19,   20,   21,   22,   23,   24,   25,  128,  128,  128,  128,  128,
  24 /*  96 */  128,   26,   27,   28,   29,   30,   31,   32,   33,   34,   35,   36,   37,   38,   39,   40,
  25 /* 112 */   41,   42,   43,   44,   45,   46,   47,   48,   49,   50,   51,  128,  128,  128,  128,  128,
  26 /* 128 */  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
  27 /* 144 */  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
  28 /* 160 */  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
  29 /* 176 */  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
  30 /* 192 */  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
  31 /* 208 */  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
  32 /* 224 */  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
  33 /* 240 */  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128
  34 };
  35
  36 /* decode base64 MIME part */
  37 ssize_t
  38 mime_decode_base64(FILE * in, FILE * out, uschar * boundary)
  39 {
  40 uschar ibuf[MIME_MAX_LINE_LENGTH], obuf[MIME_MAX_LINE_LENGTH];
  41 uschar *ipos, *opos;
  42 ssize_t len, size = 0;
  43 int bytestate = 0;
  44
  45 opos = obuf;
  46
  47 while (Ufgets(ibuf, MIME_MAX_LINE_LENGTH, in) != NULL)
  48   {
  49   if (boundary != NULL
  50      && Ustrncmp(ibuf, "--", 2) == 0
  51      && Ustrncmp((ibuf+2), boundary, Ustrlen(boundary)) == 0
  52      )
  53     break;
  54
  55   for (ipos = ibuf ; *ipos != '\r' && *ipos != '\n' && *ipos != 0; ++ipos)
  56     if (*ipos == '=')                   /* skip padding */
  57       ++bytestate;
  58
  59     else if (mime_b64[*ipos] == 128)    /* skip bad characters */
  60       mime_set_anomaly(MIME_ANOMALY_BROKEN_BASE64);
  61
  62     /* simple state-machine */
  63     else switch((bytestate++) & 3)
  64       {
  65       case 0:
  66         *opos = mime_b64[*ipos] << 2; break;
  67       case 1:
  68         *opos++ |= mime_b64[*ipos] >> 4;
  69         *opos = mime_b64[*ipos] << 4; break;
  70       case 2:
  71         *opos++ |= mime_b64[*ipos] >> 2;
  72         *opos = mime_b64[*ipos] << 6; break;
  73       case 3:
  74         *opos++ |= mime_b64[*ipos]; break;
  75       }
  76
  77   /* something to write? */
  78   len = opos - obuf;
  79   if (len > 0)
  80     {
  81     if (fwrite(obuf, 1, len, out) != len) return -1; /* error */
  82     size += len;
  83     /* copy incomplete last byte to start of obuf, where we continue */
  84     if ((bytestate & 3) != 0)
  85       *obuf = *opos;
  86     opos = obuf;
  87     }
  88   } /* while */
  89
  90 /* write out last byte if it was incomplete */
  91 if (bytestate & 3)
  92   {
  93   if (fwrite(obuf, 1, 1, out) != 1) return -1;
  94   ++size;
  95   }
  96
  97 return size;
  98 }
  99
 100 #endif  /*WITH_CONTENT_SCAN*/
 101
 102 /*************************************************
 103  *************************************************
 104  *************************************************
 105  *************************************************
 106  *************************************************
 107  *************************************************
 108  *************************************************
 109  *************************************************
 110  *************************************************
 111  *************************************************
 112  *************************************************
 113  *************************************************
 114  *************************************************
 115  *************************************************
 116  *************************************************
 117  *************************************************/
 118
 119
 120 /*************************************************
 121 *          Decode byte-string in base 64         *
 122 *************************************************/
 123
 124 /* This function decodes a string in base 64 format as defined in RFC 2045
 125 (MIME) and required by the SMTP AUTH extension (RFC 2554). The decoding
 126 algorithm is written out in a straightforward way. Turning it into some kind of
 127 compact loop is messy and would probably run more slowly.
 128
 129 Arguments:
 130   code        points to the coded string, zero-terminated
 131   ptr         where to put the pointer to the result, which is in
 132               allocated store, and zero-terminated
 133
 134 Returns:      the number of bytes in the result,
 135               or -1 if the input was malformed
 136
 137 Whitespace in the input is ignored.
 138 A zero is added on to the end to make it easy in cases where the result is to
 139 be interpreted as text. This is not included in the count. */
 140
 141 static uschar dec64table[] = {
 142   255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, /*  0-15 */
 143   255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, /* 16-31 */
 144   255,255,255,255,255,255,255,255,255,255,255, 62,255,255,255, 63, /* 32-47 */
 145    52, 53, 54, 55, 56, 57, 58, 59, 60, 61,255,255,255,255,255,255, /* 48-63 */
 146   255,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, /* 64-79 */
 147    15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,255,255,255,255,255, /* 80-95 */
 148   255, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, /* 96-111 */
 149    41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,255,255,255,255,255  /* 112-127*/
 150 };
 151
 152 int
 153 b64decode(const uschar *code, uschar **ptr)
 154 {
 155
 156 int x, y;
 157 uschar *result;
 158
 159 {
 160   int l = Ustrlen(code);
 161   *ptr = result = store_get(1 + l/4 * 3 + l%4);
 162 }
 163
 164 /* Each cycle of the loop handles a quantum of 4 input bytes. For the last
 165 quantum this may decode to 1, 2, or 3 output bytes. */
 166
 167 while ((x = *code++) != 0)
 168   {
 169   if (isspace(x)) continue;
 170   /* debug_printf("b64d: '%c'\n", x); */
 171
 172   if (x > 127 || (x = dec64table[x]) == 255) return -1;
 173
 174   while (isspace(y = *code++)) ;
 175   /* debug_printf("b64d: '%c'\n", y); */
 176   if (y > 127 || (y = dec64table[y]) == 255)
 177     return -1;
 178
 179   *result++ = (x << 2) | (y >> 4);
 180   /* debug_printf("b64d:      -> %02x\n", result[-1]); */
 181
 182   while (isspace(x = *code++)) ;
 183   /* debug_printf("b64d: '%c'\n", x); */
 184   if (x == '=')         /* endmarker, but there should be another */
 185     {
 186     while (isspace(x = *code++)) ;
 187     /* debug_printf("b64d: '%c'\n", x); */
 188     if (x != '=') return -1;
 189     while (isspace(y = *code++)) ;
 190     if (y != 0) return -1;
 191     /* debug_printf("b64d: DONE\n"); */
 192     break;
 193     }
 194   else
 195     {
 196     if (x > 127 || (x = dec64table[x]) == 255) return -1;
 197     *result++ = (y << 4) | (x >> 2);
 198     /* debug_printf("b64d:      -> %02x\n", result[-1]); */
 199
 200     while (isspace(y = *code++)) ;
 201     /* debug_printf("b64d: '%c'\n", y); */
 202     if (y == '=')
 203       {
 204       while (isspace(y = *code++)) ;
 205       if (y != 0) return -1;
 206       /* debug_printf("b64d: DONE\n"); */
 207       break;
 208       }
 209     else
 210       {
 211       if (y > 127 || (y = dec64table[y]) == 255) return -1;
 212       *result++ = (x << 6) | y;
 213       /* debug_printf("b64d:      -> %02x\n", result[-1]); */
 214       }
 215     }
 216   }
 217
 218 *result = 0;
 219 return result - *ptr;
 220 }
 221
 222
 223 /*************************************************
 224 *          Encode byte-string in base 64         *
 225 *************************************************/
 226
 227 /* This function encodes a string of bytes, containing any values whatsoever,
 228 in base 64 as defined in RFC 2045 (MIME) and required by the SMTP AUTH
 229 extension (RFC 2554). The encoding algorithm is written out in a
 230 straightforward way. Turning it into some kind of compact loop is messy and
 231 would probably run more slowly.
 232
 233 Arguments:
 234   clear       points to the clear text bytes
 235   len         the number of bytes to encode
 236
 237 Returns:      a pointer to the zero-terminated base 64 string, which
 238               is in working store
 239 */
 240
 241 static uschar *enc64table =
 242   US"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 243
 244 uschar *
 245 b64encode(uschar *clear, int len)
 246 {
 247 uschar *code = store_get(4*((len+2)/3) + 1);
 248 uschar *p = code;
 249
 250 while (len-- >0)
 251   {
 252   int x, y;
 253
 254   x = *clear++;
 255   *p++ = enc64table[(x >> 2) & 63];
 256
 257   if (len-- <= 0)
 258     {
 259     *p++ = enc64table[(x << 4) & 63];
 260     *p++ = '=';
 261     *p++ = '=';
 262     break;
 263     }
 264
 265   y = *clear++;
 266   *p++ = enc64table[((x << 4) | ((y >> 4) & 15)) & 63];
 267
 268   if (len-- <= 0)
 269     {
 270     *p++ = enc64table[(y << 2) & 63];
 271     *p++ = '=';
 272     break;
 273     }
 274
 275   x = *clear++;
 276   *p++ = enc64table[((y << 2) | ((x >> 6) & 3)) & 63];
 277
 278   *p++ = enc64table[x & 63];
 279   }
 280
 281 *p = 0;
 282
 283 return code;
 284 }
 285
 286
 287 /* End of base64.c */
 288 /* vi: sw ai sw=2
 289 */