core: Silence newer compiler warnings.
[gpgme.git] / src / 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 Lesser 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://gnu.org/licenses/>.
19  * SPDX-License-Identifier: LGPL-2.1-or-later
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <assert.h>
27
28 #include "gpgme.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 _gpgme_b64dec_start (struct b64state *state, const char *title)
68 {
69   memset (state, 0, sizeof *state);
70   if (title)
71     {
72       state->title = strdup (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 _gpgme_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       free (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           /*FALLTHRU*/
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           assert (!"invalid state");
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 _gpgme_b64dec_finish (struct b64state *state)
246 {
247   if (state->lasterr)
248     return state->lasterr;
249
250   free (state->title);
251   state->title = NULL;
252   return state->invalid_encoding? gpg_error(GPG_ERR_BAD_DATA): 0;
253 }