diplodocus.org Git - nmh/blob - sbr/base64.c

   1 /* base64.c -- routines for converting to base64
   2  *
   3  * This code is Copyright (c) 2012, by the authors of nmh.  See the
   4  * COPYRIGHT file in the root directory of the nmh distribution for
   5  * complete copyright information.
   6  */
   7
   8 #include "h/mh.h"
   9 #include "error.h"
  10 #include "h/mime.h"
  11 #include <inttypes.h>
  12
  13 static const char nib2b64[0x40+1] =
  14         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  15
  16 /*
  17  * Copy data from one file to another, converting to base64-encoding.
  18  *
  19  * Arguments include:
  20  *
  21  * in           - Input filehandle (unencoded data)
  22  * out          - Output filename (base64-encoded data)
  23  * crlf         - If set, output encoded CRLF for every LF on input.
  24  *
  25  * Returns OK on success, NOTOK otherwise.
  26  */
  27 int
  28 writeBase64aux (FILE *in, FILE *out, int crlf)
  29 {
  30     unsigned int cc, n;
  31     unsigned char inbuf[3];
  32
  33     bool skipnl = false;
  34     n = BPERLIN;
  35     while ((cc = fread (inbuf, sizeof(*inbuf), sizeof(inbuf), in)) > 0) {
  36         unsigned long bits;
  37         char *bp;
  38         char outbuf[4];
  39
  40         if (cc < sizeof(inbuf)) {
  41             inbuf[2] = 0;
  42             if (cc < sizeof(inbuf) - 1)
  43                 inbuf[1] = 0;
  44         }
  45
  46         /*
  47          * Convert a LF to a CRLF if desired.  That means we need to push
  48          * data back into the input stream.
  49          */
  50
  51         if (crlf) {
  52             unsigned int i;
  53
  54             for (i = 0; i < cc; i++) {
  55                 if (inbuf[i] == '\n' && !skipnl) {
  56                     inbuf[i] = '\r';
  57                     /*
  58                      * If it's the last character in the buffer, we can just
  59                      * substitute a \r and push a \n back.  Otherwise shuffle
  60                      * everything down and push the last character back.
  61                      */
  62                     if (i == cc - 1) {
  63                         /*
  64                          * If we're at the end of the input, there might be
  65                          * more room in inbuf; if so, add it there.  Otherwise
  66                          * push it back to the input.
  67                          */
  68                         if (cc < sizeof(inbuf))
  69                             inbuf[cc++] = '\n';
  70                         else
  71                             ungetc('\n', in);
  72                         skipnl = true;
  73                     } else {
  74                         /* This only works as long as sizeof(inbuf) == 3 */
  75                         ungetc(inbuf[cc - 1], in);
  76                         if (cc == 3 && i == 0)
  77                             inbuf[2] = inbuf[1];
  78                         inbuf[++i] = '\n';
  79                     }
  80                 } else {
  81                     skipnl = false;
  82                 }
  83             }
  84         }
  85
  86         bits = (inbuf[0] & 0xff) << 16;
  87         bits |= (inbuf[1] & 0xff) << 8;
  88         bits |= inbuf[2] & 0xff;
  89
  90         for (bp = outbuf + sizeof(outbuf); bp > outbuf; bits >>= 6)
  91             *--bp = nib2b64[bits & 0x3f];
  92         if (cc < sizeof(inbuf)) {
  93             outbuf[3] = '=';
  94             if (cc < sizeof inbuf - 1)
  95                 outbuf[2] = '=';
  96         }
  97
  98         if (fwrite (outbuf, sizeof(*outbuf), sizeof(outbuf), out) <
  99             sizeof outbuf) {
 100             advise ("writeBase64aux", "fwrite");
 101         }
 102
 103         if (cc < sizeof(inbuf)) {
 104             putc ('\n', out);
 105             return OK;
 106         }
 107
 108         if (--n <= 0) {
 109             n = BPERLIN;
 110             putc ('\n', out);
 111         }
 112     }
 113     if (n != BPERLIN)
 114         putc ('\n', out);
 115
 116     return OK;
 117 }
 118
 119
 120 /* Caller is responsible for ensuring that the out array is long
 121    enough.  Given length is that of in, out should be have at
 122    least this capacity:
 123      4 * [length/3]  +  length/57  +  2
 124    But double the length will certainly be sufficient. */
 125 int
 126 writeBase64 (const unsigned char *in, size_t length, unsigned char *out)
 127 {
 128     unsigned int n = BPERLIN;
 129
 130     while (1) {
 131         unsigned long bits;
 132         unsigned char *bp;
 133         unsigned int cc;
 134         for (cc = 0; length > 0 && cc < 3; ++cc, --length)
 135           /* empty */ ;
 136
 137         if (cc == 0)
 138             break;
 139
 140         bits = (in[0] & 0xff) << 16;
 141         if (cc > 1) {
 142             bits |= (in[1] & 0xff) << 8;
 143             if (cc > 2) {
 144                 bits |= in[2] & 0xff;
 145             }
 146         }
 147
 148         for (bp = out + 4; bp > out; bits >>= 6)
 149             *--bp = nib2b64[bits & 0x3f];
 150         if (cc < 3) {
 151             out[3] = '=';
 152             if (cc < 2)
 153                 out[2] = '=';
 154             out += 4;
 155             n = 0;
 156             break;
 157         }
 158
 159         in += 3;
 160         out += 4;
 161         if (--n <= 0) {
 162             n = BPERLIN;
 163             *out++ = '\n';
 164         }
 165     }
 166     if (n != BPERLIN)
 167         *out++ = '\n';
 168
 169     *out = '\0';
 170
 171     return OK;
 172 }
 173
 174 /*
 175  * Essentially a duplicate of writeBase64, but without line wrapping or
 176  * newline termination (note: string IS NUL terminated)
 177  */
 178
 179 int
 180 writeBase64raw (const unsigned char *in, size_t length, unsigned char *out)
 181 {
 182     while (1) {
 183         unsigned long bits;
 184         unsigned char *bp;
 185         unsigned int cc;
 186         for (cc = 0; length > 0 && cc < 3; ++cc, --length)
 187           /* empty */ ;
 188
 189         if (cc == 0)
 190             break;
 191
 192         bits = (in[0] & 0xff) << 16;
 193         if (cc > 1) {
 194             bits |= (in[1] & 0xff) << 8;
 195             if (cc > 2) {
 196                 bits |= in[2] & 0xff;
 197             }
 198         }
 199
 200         for (bp = out + 4; bp > out; bits >>= 6)
 201             *--bp = nib2b64[bits & 0x3f];
 202         if (cc < 3) {
 203             out[3] = '=';
 204             if (cc < 2)
 205                 out[2] = '=';
 206             out += 4;
 207             break;
 208         }
 209
 210         in += 3;
 211         out += 4;
 212     }
 213
 214     *out = '\0';
 215
 216     return OK;
 217 }
 218
 219
 220 static const unsigned char b642nib[0x80] = {
 221     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 222     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 223     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 224     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 225     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 226     0xff, 0xff, 0xff, 0x3e, 0xff, 0xff, 0xff, 0x3f,
 227     0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b,
 228     0x3c, 0x3d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 229     0xff, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
 230     0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
 231     0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,
 232     0x17, 0x18, 0x19, 0xff, 0xff, 0xff, 0xff, 0xff,
 233     0xff, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
 234     0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
 235     0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
 236     0x31, 0x32, 0x33, 0xff, 0xff, 0xff, 0xff, 0xff
 237 };
 238
 239 /*
 240  * Decode a base64 string.  The result, decoded, must be freed by the caller.
 241  *
 242  * encoded      - the string to be decoded
 243  * decoded      - the decoded bytes
 244  * len          - number of decoded bytes
 245  * skip-crs     - non-zero for text content, and for which CR's should be
 246  *                skipped
 247  */
 248 int
 249 decodeBase64 (const char *encoded, unsigned char **decoded, size_t *len,
 250               int skip_crs)
 251 {
 252     const char *cp = encoded;
 253     int bitno, skip;
 254     uint32_t bits;
 255     /* Size the decoded string very conservatively. */
 256     charstring_t decoded_c = charstring_create (strlen (encoded));
 257
 258     bitno = 18;
 259     bits = 0L;
 260     skip = 0;
 261
 262     bool self_delimiting = false;
 263     for (; *cp; ++cp) {
 264         switch (*cp) {
 265             unsigned char value;
 266
 267             default:
 268                 if (isspace ((unsigned char) *cp)) {
 269                     break;
 270                 }
 271                 if (skip  ||  (((unsigned char) *cp) & 0x80)  ||
 272                     (value = b642nib[((unsigned char) *cp) & 0x7f]) > 0x3f) {
 273                     inform("invalid base64 byte %#x: %.42s",
 274                         *(unsigned char *)cp, cp);
 275                     charstring_free (decoded_c);
 276                     *decoded = NULL;
 277
 278                     return NOTOK;
 279                 }
 280
 281                 bits |= value << bitno;
 282 test_end:
 283                 if ((bitno -= 6) < 0) {
 284                     char b = (char) ((bits >> 16) & 0xff);
 285
 286                     if (! skip_crs  ||  b != '\r') {
 287                         charstring_push_back (decoded_c, b);
 288                     }
 289                     if (skip < 2) {
 290                         b = (bits >> 8) & 0xff;
 291                         if (! skip_crs  ||  b != '\r') {
 292                             charstring_push_back (decoded_c, b);
 293                         }
 294                         if (skip < 1) {
 295                             b = bits & 0xff;
 296                             if (! skip_crs  ||  b != '\r') {
 297                                 charstring_push_back (decoded_c, b);
 298                             }
 299                         }
 300                     }
 301
 302                     bitno = 18;
 303                     bits = 0L;
 304                     skip = 0;
 305                 }
 306                 break;
 307
 308             case '=':
 309                 if (++skip <= 3)
 310                     goto test_end;
 311                 self_delimiting = true;
 312                 break;
 313         }
 314     }
 315
 316     if (! self_delimiting  &&  bitno != 18) {
 317         /* Show some context for the error. */
 318         cp -= min(cp - encoded, 20);
 319         inform("premature ending (bitno %d) near %s", bitno, cp);
 320         charstring_free (decoded_c);
 321         *decoded = NULL;
 322
 323         return NOTOK;
 324     }
 325
 326     *decoded = (unsigned char *) charstring_buffer_copy (decoded_c);
 327     *len = charstring_bytes (decoded_c);
 328     charstring_free (decoded_c);
 329
 330     return OK;
 331 }
 332
 333
 334 /*
 335  * Prepare an unsigned char array for display by replacing non-printable
 336  * ASCII bytes with their hex representation.  Assumes ASCII input.  output
 337  * is allocated by the function and must be freed by the caller.
 338  */
 339 void
 340 hexify (const unsigned char *input, size_t len, char **output)
 341 {
 342     /* Start with a charstring capacity that's arbitrarily larger than len. */
 343     const charstring_t tmp = charstring_create (2 * len);
 344     const unsigned char *cp = input;
 345     size_t i;
 346
 347     for (i = 0; i < len; ++i, ++cp) {
 348         if (isascii(*cp) && isprint(*cp)) {
 349             charstring_push_back (tmp, (const char) *cp);
 350         } else {
 351             char s[16];
 352             const int num = snprintf(s, sizeof s, "[0x%02x]", *cp);
 353
 354             if (num <= 0  ||  (unsigned int) num >= sizeof s) {
 355                 inform("hexify failed to write nonprintable character, needed %d bytes", num + 1);
 356             } else {
 357                 charstring_append_cstring (tmp, s);
 358             }
 359         }
 360     }
 361
 362     *output = charstring_buffer_copy (tmp);
 363     charstring_free (tmp);
 364 }