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