common/b64dec.c

   1 /* b64dec.c - Simple Base64 decoder.
   2  * Copyright (C) 2008, 2011 Free Software Foundation, Inc.
   3  * Copyright (C) 2008, 2011, 2016 g10 Code GmbH
   4  *
   5  * This file is part of GnuPG.
   6  *
   7  * This file is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU Lesser General Public License as
   9  * published by the Free Software Foundation; either version 2.1 of
  10  * the License, or (at your option) any later version.
  11  *
  12  * This file is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public License
  18  * along with this program; if not, see <https://www.gnu.org/licenses/>.
  19  */
  20
  21 #include <config.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <errno.h>
  26 #include <assert.h>
  27
  28 #include "i18n.h"
  29 #include "util.h"
  30
  31
  32 /* The reverse base-64 list used for base-64 decoding. */
  33 static unsigned char const asctobin[128] =
  34   {
  35     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  36     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  37     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  38     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  39     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  40     0xff, 0xff, 0xff, 0x3e, 0xff, 0xff, 0xff, 0x3f,
  41     0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b,
  42     0x3c, 0x3d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  43     0xff, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
  44     0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
  45     0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,
  46     0x17, 0x18, 0x19, 0xff, 0xff, 0xff, 0xff, 0xff,
  47     0xff, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
  48     0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
  49     0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
  50     0x31, 0x32, 0x33, 0xff, 0xff, 0xff, 0xff, 0xff
  51   };
  52
  53 enum decoder_states
  54   {
  55     s_init, s_idle, s_lfseen, s_beginseen, s_waitheader, s_waitblank, s_begin,
  56     s_b64_0, s_b64_1, s_b64_2, s_b64_3,
  57     s_waitendtitle, s_waitend
  58   };
  59
  60
  61
  62 /* Initialize the context for the base64 decoder.  If TITLE is NULL a
  63    plain base64 decoding is done.  If it is the empty string the
  64    decoder will skip everything until a "-----BEGIN " line has been
  65    seen, decoding ends at a "----END " line.  */
  66 gpg_error_t
  67 b64dec_start (struct b64state *state, const char *title)
  68 {
  69   memset (state, 0, sizeof *state);
  70   if (title)
  71     {
  72       state->title = xtrystrdup (title);
  73       if (!state->title)
  74         state->lasterr = gpg_error_from_syserror ();
  75       else
  76         state->idx = s_init;
  77     }
  78   else
  79     state->idx = s_b64_0;
  80   return state->lasterr;
  81 }
  82
  83
  84 /* Do in-place decoding of base-64 data of LENGTH in BUFFER.  Stores the
  85    new length of the buffer at R_NBYTES. */
  86 gpg_error_t
  87 b64dec_proc (struct b64state *state, void *buffer, size_t length,
  88              size_t *r_nbytes)
  89 {
  90   enum decoder_states ds = state->idx;
  91   unsigned char val = state->radbuf[0];
  92   int pos = state->quad_count;
  93   char *d, *s;
  94
  95   if (state->lasterr)
  96     return state->lasterr;
  97
  98   if (state->stop_seen)
  99     {
 100       *r_nbytes = 0;
 101       state->lasterr = gpg_error (GPG_ERR_EOF);
 102       xfree (state->title);
 103       state->title = NULL;
 104       return state->lasterr;
 105     }
 106
 107   for (s=d=buffer; length && !state->stop_seen; length--, s++)
 108     {
 109     again:
 110       switch (ds)
 111         {
 112         case s_idle:
 113           if (*s == '\n')
 114             {
 115               ds = s_lfseen;
 116               pos = 0;
 117             }
 118           break;
 119         case s_init:
 120           ds = s_lfseen;
 121           /* fall through */
 122         case s_lfseen:
 123           if (*s != "-----BEGIN "[pos])
 124             {
 125               ds = s_idle;
 126               goto again;
 127             }
 128           else if (pos == 10)
 129             {
 130               pos = 0;
 131               ds = s_beginseen;
 132             }
 133           else
 134             pos++;
 135           break;
 136         case s_beginseen:
 137           if (*s != "PGP "[pos])
 138             ds = s_begin; /* Not a PGP armor.  */
 139           else if (pos == 3)
 140             ds = s_waitheader;
 141           else
 142             pos++;
 143           break;
 144         case s_waitheader:
 145           if (*s == '\n')
 146             ds = s_waitblank;
 147           break;
 148         case s_waitblank:
 149           if (*s == '\n')
 150             ds = s_b64_0; /* blank line found.  */
 151           else if (*s == ' ' || *s == '\r' || *s == '\t')
 152             ; /* Ignore spaces. */
 153           else
 154             {
 155               /* Armor header line.  Note that we don't care that our
 156                * FSM accepts a header prefixed with spaces.  */
 157               ds = s_waitheader; /* Wait for next header.  */
 158             }
 159           break;
 160         case s_begin:
 161           if (*s == '\n')
 162             ds = s_b64_0;
 163           break;
 164         case s_b64_0:
 165         case s_b64_1:
 166         case s_b64_2:
 167         case s_b64_3:
 168           {
 169             int c;
 170
 171             if (*s == '-' && state->title)
 172               {
 173                 /* Not a valid Base64 character: assume end
 174                    header.  */
 175                 ds = s_waitend;
 176               }
 177             else if (*s == '=')
 178               {
 179                 /* Pad character: stop */
 180                 if (ds == s_b64_1)
 181                   *d++ = val;
 182                 ds = state->title? s_waitendtitle : s_waitend;
 183               }
 184             else if (*s == '\n' || *s == ' ' || *s == '\r' || *s == '\t')
 185               ; /* Skip white spaces. */
 186             else if ( (*s & 0x80)
 187                       || (c = asctobin[*(unsigned char *)s]) == 255)
 188               {
 189                 /* Skip invalid encodings.  */
 190                 state->invalid_encoding = 1;
 191               }
 192             else if (ds == s_b64_0)
 193               {
 194                 val = c << 2;
 195                 ds = s_b64_1;
 196               }
 197             else if (ds == s_b64_1)
 198               {
 199                 val |= (c>>4)&3;
 200                 *d++ = val;
 201                 val = (c<<4)&0xf0;
 202                 ds = s_b64_2;
 203               }
 204             else if (ds == s_b64_2)
 205               {
 206                 val |= (c>>2)&15;
 207                 *d++ = val;
 208                 val = (c<<6)&0xc0;
 209                 ds = s_b64_3;
 210               }
 211             else
 212               {
 213                 val |= c&0x3f;
 214                 *d++ = val;
 215                 ds = s_b64_0;
 216               }
 217           }
 218           break;
 219         case s_waitendtitle:
 220           if (*s == '-')
 221             ds = s_waitend;
 222           break;
 223         case s_waitend:
 224           if ( *s == '\n')
 225             state->stop_seen = 1;
 226           break;
 227         default:
 228           BUG();
 229         }
 230     }
 231
 232
 233   state->idx = ds;
 234   state->radbuf[0] = val;
 235   state->quad_count = pos;
 236   *r_nbytes = (d -(char*) buffer);
 237   return 0;
 238 }
 239
 240
 241 /* This function needs to be called before releasing the decoder
 242    state.  It may return an error code in case an encoding error has
 243    been found during decoding. */
 244 gpg_error_t
 245 b64dec_finish (struct b64state *state)
 246 {
 247   xfree (state->title);
 248   state->title = NULL;
 249
 250   if (state->lasterr)
 251     return state->lasterr;
 252
 253   return state->invalid_encoding? gpg_error(GPG_ERR_BAD_DATA): 0;
 254 }