src/util/base64.c

   1 /* Base64 encode/decode implementation. */
   2
   3 #ifdef HAVE_CONFIG_H
   4 #include "config.h"
   5 #endif
   6
   7 #include <string.h>
   8
   9 #include "elinks.h"
  10
  11 #include "util/base64.h"
  12 #include "util/error.h"
  13 #include "util/memory.h"
  14
  15 static unsigned char base64_chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  16
  17 unsigned char *
  18 base64_encode(register unsigned char *in)
  19 {
  20         assert(in && *in);
  21         if_assert_failed return NULL;
  22
  23         return base64_encode_bin(in, strlen(in), NULL);
  24 }
  25
  26 unsigned char *
  27 base64_encode_bin(register unsigned char *in, int inlen, int *outlen)
  28 {
  29         unsigned char *out;
  30         unsigned char *outstr;
  31
  32         assert(in && *in);
  33         if_assert_failed return NULL;
  34
  35         out = outstr = mem_alloc((inlen / 3) * 4 + 4 + 1);
  36         if (!out) return NULL;
  37
  38         while (inlen >= 3) {
  39                 *out++ = base64_chars[ *in >> 2 ];
  40                 *out++ = base64_chars[ (*in << 4 | *(in + 1) >> 4) & 63 ];
  41                 *out++ = base64_chars[ (*(in + 1) << 2 | *(in + 2) >> 6) & 63 ];
  42                 *out++ = base64_chars[ *(in + 2) & 63 ];
  43                 inlen -= 3; in += 3;
  44         }
  45         if (inlen == 1) {
  46                 *out++ = base64_chars[ *in >> 2 ];
  47                 *out++ = base64_chars[ *in << 4 & 63 ];
  48                 *out++ = '=';
  49                 *out++ = '=';
  50         }
  51         if (inlen == 2) {
  52                 *out++ = base64_chars[ *in >> 2 ];
  53                 *out++ = base64_chars[ (*in << 4 | *(in + 1) >> 4) & 63 ];
  54                 *out++ = base64_chars[ (*(in + 1) << 2) & 63 ];
  55                 *out++ = '=';
  56         }
  57         *out = 0;
  58
  59         if (outlen)
  60                 *outlen = out-outstr;
  61
  62         return outstr;
  63 }
  64
  65 /* Base64 decoding is used only with the CONFIG_FORMHIST or CONFIG_GSSAPI
  66    feature, so i'll #ifdef it */
  67 #if  defined(CONFIG_FORMHIST) || defined(CONFIG_GSSAPI)
  68
  69 unsigned char *
  70 base64_decode(register unsigned char *in)
  71 {
  72         assert(in && *in);
  73         if_assert_failed return NULL;
  74
  75         return base64_decode_bin(in, strlen(in), NULL);
  76 }
  77
  78 /* base64_decode:  @in string to decode
  79  *                 returns the string decoded (must be freed by the caller) */
  80 unsigned char *
  81 base64_decode_bin(register unsigned char *in, int inlen, int *outlen)
  82 {
  83         static unsigned char is_base64_char[256]; /* static to force initialization at zero */
  84         static unsigned char decode[256];
  85         unsigned char *out;
  86         unsigned char *outstr;
  87         int count = 0;
  88         unsigned int bits = 0;
  89         static int once = 0;
  90
  91         assert(in && *in);
  92         if_assert_failed return NULL;
  93
  94         outstr = out = mem_alloc(inlen / 4 * 3 + 1);
  95         if (!outstr) return NULL;
  96
  97         if (!once) {
  98                 int i = sizeof(base64_chars) - 1;
  99
 100                 while (i >= 0) {
 101                         is_base64_char[base64_chars[i]] = 1;
 102                         decode[base64_chars[i]] = i;
 103                         i--;
 104                 }
 105                 once = 1;
 106         }
 107
 108         while (*in) {
 109                 if (*in == '=') break;
 110                 if (!is_base64_char[*in])
 111                         goto decode_error;
 112
 113                 bits += decode[*in];
 114                 count++;
 115                 if (count == 4) {
 116                         *out++ = bits >> 16;
 117                         *out++ = (bits >> 8) & 0xff;
 118                         *out++ = bits & 0xff;
 119                         bits = 0;
 120                         count = 0;
 121                 } else {
 122                         bits <<= 6;
 123                 }
 124
 125                 ++in;
 126         }
 127
 128         if (!*in) {
 129                 if (count) goto decode_error;
 130         } else { /* '=' */
 131                 switch (count) {
 132                         case 1:
 133                                 goto decode_error;
 134                                 break;
 135                         case 2:
 136                                 *out++ = bits >> 10;
 137                                 break;
 138                         case 3:
 139                                 *out++ = bits >> 16;
 140                                 *out++ = (bits >> 8) & 0xff;
 141                                 break;
 142                 }
 143         }
 144
 145         *out = 0;
 146
 147         if (outlen)
 148                 *outlen = out-outstr;
 149
 150         return outstr;
 151
 152 decode_error:
 153         mem_free(outstr);
 154         return NULL;
 155 }
 156
 157 #endif /* CONFIG_FORMHIST */