Line data Source code
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 <http://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 0 : b64dec_start (struct b64state *state, const char *title)
68 : {
69 0 : memset (state, 0, sizeof *state);
70 0 : if (title)
71 : {
72 0 : state->title = xtrystrdup (title);
73 0 : if (!state->title)
74 0 : state->lasterr = gpg_error_from_syserror ();
75 : else
76 0 : state->idx = s_init;
77 : }
78 : else
79 0 : state->idx = s_b64_0;
80 0 : 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 0 : b64dec_proc (struct b64state *state, void *buffer, size_t length,
88 : size_t *r_nbytes)
89 : {
90 0 : enum decoder_states ds = state->idx;
91 0 : unsigned char val = state->radbuf[0];
92 0 : int pos = state->quad_count;
93 : char *d, *s;
94 :
95 0 : if (state->lasterr)
96 0 : return state->lasterr;
97 :
98 0 : if (state->stop_seen)
99 : {
100 0 : *r_nbytes = 0;
101 0 : state->lasterr = gpg_error (GPG_ERR_EOF);
102 0 : xfree (state->title);
103 0 : state->title = NULL;
104 0 : return state->lasterr;
105 : }
106 :
107 0 : for (s=d=buffer; length && !state->stop_seen; length--, s++)
108 : {
109 : again:
110 0 : switch (ds)
111 : {
112 : case s_idle:
113 0 : if (*s == '\n')
114 : {
115 0 : ds = s_lfseen;
116 0 : pos = 0;
117 : }
118 0 : break;
119 : case s_init:
120 0 : ds = s_lfseen;
121 : case s_lfseen:
122 0 : if (*s != "-----BEGIN "[pos])
123 : {
124 0 : ds = s_idle;
125 0 : goto again;
126 : }
127 0 : else if (pos == 10)
128 : {
129 0 : pos = 0;
130 0 : ds = s_beginseen;
131 : }
132 : else
133 0 : pos++;
134 0 : break;
135 : case s_beginseen:
136 0 : if (*s != "PGP "[pos])
137 0 : ds = s_begin; /* Not a PGP armor. */
138 0 : else if (pos == 3)
139 0 : ds = s_waitheader;
140 : else
141 0 : pos++;
142 0 : break;
143 : case s_waitheader:
144 0 : if (*s == '\n')
145 0 : ds = s_waitblank;
146 0 : break;
147 : case s_waitblank:
148 0 : if (*s == '\n')
149 0 : ds = s_b64_0; /* blank line found. */
150 0 : else if (*s == ' ' || *s == '\r' || *s == '\t')
151 : ; /* Ignore spaces. */
152 : else
153 : {
154 : /* Armor header line. Note that we don't care that our
155 : * FSM accepts a header prefixed with spaces. */
156 0 : ds = s_waitheader; /* Wait for next header. */
157 : }
158 0 : break;
159 : case s_begin:
160 0 : if (*s == '\n')
161 0 : ds = s_b64_0;
162 0 : break;
163 : case s_b64_0:
164 : case s_b64_1:
165 : case s_b64_2:
166 : case s_b64_3:
167 : {
168 : int c;
169 :
170 0 : if (*s == '-' && state->title)
171 : {
172 : /* Not a valid Base64 character: assume end
173 : header. */
174 0 : ds = s_waitend;
175 : }
176 0 : else if (*s == '=')
177 : {
178 : /* Pad character: stop */
179 0 : if (ds == s_b64_1)
180 0 : *d++ = val;
181 0 : ds = state->title? s_waitendtitle : s_waitend;
182 : }
183 0 : else if (*s == '\n' || *s == ' ' || *s == '\r' || *s == '\t')
184 : ; /* Skip white spaces. */
185 0 : else if ( (*s & 0x80)
186 0 : || (c = asctobin[*(unsigned char *)s]) == 255)
187 : {
188 : /* Skip invalid encodings. */
189 0 : state->invalid_encoding = 1;
190 : }
191 0 : else if (ds == s_b64_0)
192 : {
193 0 : val = c << 2;
194 0 : ds = s_b64_1;
195 : }
196 0 : else if (ds == s_b64_1)
197 : {
198 0 : val |= (c>>4)&3;
199 0 : *d++ = val;
200 0 : val = (c<<4)&0xf0;
201 0 : ds = s_b64_2;
202 : }
203 0 : else if (ds == s_b64_2)
204 : {
205 0 : val |= (c>>2)&15;
206 0 : *d++ = val;
207 0 : val = (c<<6)&0xc0;
208 0 : ds = s_b64_3;
209 : }
210 : else
211 : {
212 0 : val |= c&0x3f;
213 0 : *d++ = val;
214 0 : ds = s_b64_0;
215 : }
216 : }
217 0 : break;
218 : case s_waitendtitle:
219 0 : if (*s == '-')
220 0 : ds = s_waitend;
221 0 : break;
222 : case s_waitend:
223 0 : if ( *s == '\n')
224 0 : state->stop_seen = 1;
225 0 : break;
226 : default:
227 0 : BUG();
228 : }
229 : }
230 :
231 :
232 0 : state->idx = ds;
233 0 : state->radbuf[0] = val;
234 0 : state->quad_count = pos;
235 0 : *r_nbytes = (d -(char*) buffer);
236 0 : return 0;
237 : }
238 :
239 :
240 : /* This function needs to be called before releasing the decoder
241 : state. It may return an error code in case an encoding error has
242 : been found during decoding. */
243 : gpg_error_t
244 0 : b64dec_finish (struct b64state *state)
245 : {
246 0 : xfree (state->title);
247 0 : state->title = NULL;
248 :
249 0 : if (state->lasterr)
250 0 : return state->lasterr;
251 :
252 0 : return state->invalid_encoding? gpg_error(GPG_ERR_BAD_DATA): 0;
253 : }
|
