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