Change all quotes in strings and comments to the new GNU standard.
[gnupg.git] / sm / base64.c
1 /* base64.c
2  * Copyright (C) 2001, 2003, 2010 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 <unistd.h>
26 #include <time.h>
27 #include <assert.h>
28
29 #include "gpgsm.h"
30
31
32 #include <ksba.h>
33
34 #include "i18n.h"
35
36 #ifdef HAVE_DOSISH_SYSTEM
37   #define LF "\r\n"
38 #else
39   #define LF "\n"
40 #endif
41
42 /* Data used by the reader callbacks.  */
43 struct reader_cb_parm_s
44 {
45   estream_t fp;
46
47   unsigned char line[1024];
48   int linelen;
49   int readpos;
50   int have_lf;
51   unsigned long line_counter;
52
53   int allow_multi_pem;  /* Allow processing of multiple PEM objects. */
54   int autodetect;       /* Try to detect the input encoding. */
55   int assume_pem;       /* Assume input encoding is PEM. */
56   int assume_base64;    /* Assume input is base64 encoded. */
57
58   int identified;
59   int is_pem;
60   int is_base64;
61   int stop_seen;
62   int might_be_smime;
63
64   int eof_seen;
65
66   struct {
67     int idx;
68     unsigned char val;
69     int stop_seen;
70   } base64;
71 };
72
73
74 /* Data used by the writer callbacks.  */
75 struct writer_cb_parm_s
76 {
77   estream_t stream;    /* Output stream.  */
78
79   const char *pem_name;
80
81   int wrote_begin;
82   int did_finish;
83
84   struct {
85     int idx;
86     int quad_count;
87     unsigned char radbuf[4];
88   } base64;
89
90 };
91
92
93 /* context for this module's functions */
94 struct base64_context_s {
95   union {
96     struct reader_cb_parm_s rparm;
97     struct writer_cb_parm_s wparm;
98   } u;
99
100   union {
101     ksba_reader_t reader;
102     ksba_writer_t writer;
103   } u2;
104 };
105
106
107 /* The base-64 character list */
108 static char bintoasc[64] =
109        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
110        "abcdefghijklmnopqrstuvwxyz"
111        "0123456789+/";
112 /* The reverse base-64 list */
113 static unsigned char asctobin[256] = {
114   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
115   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
116   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
117   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3e, 0xff, 0xff, 0xff, 0x3f,
118   0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0xff, 0xff,
119   0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
120   0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12,
121   0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0xff, 0xff, 0xff, 0xff, 0xff,
122   0xff, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
123   0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
124   0x31, 0x32, 0x33, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
125   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
126   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
127   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
128   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
129   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
130   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
131   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
132   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
133   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
134   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
135   0xff, 0xff, 0xff, 0xff
136 };
137
138
139 static int
140 has_only_base64 (const unsigned char *line, int linelen)
141 {
142   if (linelen < 20)
143     return 0;
144   for (; linelen; line++, linelen--)
145     {
146       if (*line == '\n' || (linelen > 1 && *line == '\r' && line[1] == '\n'))
147           break;
148       if ( !strchr (bintoasc, *line) )
149         return 0;
150     }
151   return 1;  /* yes */
152 }
153
154 static int
155 is_empty_line (const unsigned char *line, int linelen)
156 {
157   if (linelen >= 2 && *line == '\r' && line[1] == '\n')
158     return 1;
159   if (linelen >= 1 && *line == '\n')
160     return 1;
161   return 0;
162 }
163
164
165 static int
166 base64_reader_cb (void *cb_value, char *buffer, size_t count, size_t *nread)
167 {
168   struct reader_cb_parm_s *parm = cb_value;
169   size_t n;
170   int c, c2;
171
172   *nread = 0;
173   if (!buffer)
174     return -1; /* not supported */
175
176  next:
177   if (!parm->linelen)
178     {
179       /* read an entire line or up to the size of the buffer */
180       parm->line_counter++;
181       parm->have_lf = 0;
182       for (n=0; n < DIM(parm->line);)
183         {
184           c = es_getc (parm->fp);
185           if (c == EOF)
186             {
187               parm->eof_seen = 1;
188               if (es_ferror (parm->fp))
189                 return -1;
190               break;
191             }
192           parm->line[n++] = c;
193           if (c == '\n')
194             {
195               parm->have_lf = 1;
196               /* Fixme: we need to skip overlong lines while detecting
197                  the dashed lines */
198               break;
199             }
200         }
201       parm->linelen = n;
202       if (!n)
203         return -1; /* eof */
204       parm->readpos = 0;
205     }
206
207   if (!parm->identified)
208     {
209       if (!parm->autodetect)
210         {
211           if (parm->assume_pem)
212             {
213               /* wait for the header line */
214               parm->linelen = parm->readpos = 0;
215               if (!parm->have_lf
216                   || strncmp ((char*)parm->line, "-----BEGIN ", 11)
217                   || !strncmp ((char*)parm->line+11, "PGP ", 4))
218                 goto next;
219               parm->is_pem = 1;
220             }
221           else if (parm->assume_base64)
222             parm->is_base64 = 1;
223         }
224       else if (parm->line_counter == 1 && !parm->have_lf)
225         {
226           /* first line too long - assume DER encoding */
227           parm->is_pem = 0;
228         }
229       else if (parm->line_counter == 1 && parm->linelen && *parm->line == 0x30)
230         {
231           /* the very first byte does pretty much look like a SEQUENCE tag*/
232           parm->is_pem = 0;
233         }
234       else if ( parm->have_lf
235                 && !strncmp ((char*)parm->line, "-----BEGIN ", 11)
236                 && strncmp ((char *)parm->line+11, "PGP ", 4) )
237         {
238           /* Fixme: we must only compare if the line really starts at
239              the beginning */
240           parm->is_pem = 1;
241           parm->linelen = parm->readpos = 0;
242         }
243       else if ( parm->have_lf && parm->line_counter == 1
244                 && parm->linelen >= 13
245                 && !ascii_memcasecmp (parm->line, "Content-Type:", 13))
246         { /* might be a S/MIME body */
247           parm->might_be_smime = 1;
248           parm->linelen = parm->readpos = 0;
249           goto next;
250         }
251       else if (parm->might_be_smime == 1
252                && is_empty_line (parm->line, parm->linelen))
253         {
254           parm->might_be_smime = 2;
255           parm->linelen = parm->readpos = 0;
256           goto next;
257         }
258       else if (parm->might_be_smime == 2)
259         {
260           parm->might_be_smime = 0;
261           if ( !has_only_base64 (parm->line, parm->linelen))
262             {
263               parm->linelen = parm->readpos = 0;
264               goto next;
265             }
266           parm->is_pem = 1;
267         }
268       else
269         {
270           parm->linelen = parm->readpos = 0;
271           goto next;
272         }
273       parm->identified = 1;
274       parm->base64.stop_seen = 0;
275       parm->base64.idx = 0;
276     }
277
278
279   n = 0;
280   if (parm->is_pem || parm->is_base64)
281     {
282       if (parm->is_pem && parm->have_lf
283           && !strncmp ((char*)parm->line, "-----END ", 9))
284         {
285           parm->identified = 0;
286           parm->linelen = parm->readpos = 0;
287
288           /* If the caller want to read multiple PEM objects from one
289              file, we have to reset our internal state and return a
290              EOF immediately. The caller is the expected to use
291              ksba_reader_clear to clear the EOF condition and continue
292              to read.  If we don't want to do that we just return 0
293              bytes which will force the ksba_reader to skip until
294              EOF. */
295           if (parm->allow_multi_pem)
296             {
297               parm->identified = 0;
298               parm->autodetect = 0;
299               parm->assume_pem = 1;
300               parm->stop_seen = 0;
301               return -1; /* Send EOF now. */
302             }
303         }
304       else if (parm->stop_seen)
305         { /* skip the rest of the line */
306           parm->linelen = parm->readpos = 0;
307         }
308       else
309         {
310           int idx = parm->base64.idx;
311           unsigned char val = parm->base64.val;
312
313           while (n < count && parm->readpos < parm->linelen )
314             {
315               c = parm->line[parm->readpos++];
316               if (c == '\n' || c == ' ' || c == '\r' || c == '\t')
317                 continue;
318               if (c == '=')
319                 { /* pad character: stop */
320                   if (idx == 1)
321                     buffer[n++] = val;
322                   parm->stop_seen = 1;
323                   break;
324                 }
325               if( (c = asctobin[(c2=c)]) == 255 )
326                 {
327                   log_error (_("invalid radix64 character %02x skipped\n"),
328                              c2);
329                   continue;
330                 }
331               switch (idx)
332                 {
333                 case 0:
334                   val = c << 2;
335                   break;
336                 case 1:
337                   val |= (c>>4)&3;
338                   buffer[n++] = val;
339                   val = (c<<4)&0xf0;
340                   break;
341                 case 2:
342                   val |= (c>>2)&15;
343                   buffer[n++] = val;
344                   val = (c<<6)&0xc0;
345                   break;
346                 case 3:
347                   val |= c&0x3f;
348                   buffer[n++] = val;
349                   break;
350                 }
351               idx = (idx+1) % 4;
352             }
353           if (parm->readpos == parm->linelen)
354             parm->linelen = parm->readpos = 0;
355
356           parm->base64.idx = idx;
357           parm->base64.val = val;
358         }
359     }
360   else
361     { /* DER encoded */
362       while (n < count && parm->readpos < parm->linelen)
363           buffer[n++] = parm->line[parm->readpos++];
364       if (parm->readpos == parm->linelen)
365         parm->linelen = parm->readpos = 0;
366     }
367
368   *nread = n;
369   return 0;
370 }
371
372
373
374 static int
375 simple_reader_cb (void *cb_value, char *buffer, size_t count, size_t *nread)
376 {
377   struct reader_cb_parm_s *parm = cb_value;
378   size_t n;
379   int c = 0;
380
381   *nread = 0;
382   if (!buffer)
383     return -1; /* not supported */
384
385   for (n=0; n < count; n++)
386     {
387       c = es_getc (parm->fp);
388       if (c == EOF)
389         {
390           parm->eof_seen = 1;
391           if (es_ferror (parm->fp))
392             return -1;
393           if (n)
394             break; /* Return what we have before an EOF.  */
395           return -1;
396         }
397       *(byte *)buffer++ = c;
398     }
399
400   *nread = n;
401   return 0;
402 }
403
404
405
406 \f
407 static int
408 base64_writer_cb (void *cb_value, const void *buffer, size_t count)
409 {
410   struct writer_cb_parm_s *parm = cb_value;
411   unsigned char radbuf[4];
412   int i, c, idx, quad_count;
413   const unsigned char *p;
414   estream_t stream = parm->stream;
415
416   if (!count)
417     return 0;
418
419   if (!parm->wrote_begin)
420     {
421       if (parm->pem_name)
422         {
423           es_fputs ("-----BEGIN ", stream);
424           es_fputs (parm->pem_name, stream);
425           es_fputs ("-----\n", stream);
426         }
427       parm->wrote_begin = 1;
428       parm->base64.idx = 0;
429       parm->base64.quad_count = 0;
430     }
431
432   idx = parm->base64.idx;
433   quad_count = parm->base64.quad_count;
434   for (i=0; i < idx; i++)
435     radbuf[i] = parm->base64.radbuf[i];
436
437   for (p=buffer; count; p++, count--)
438     {
439       radbuf[idx++] = *p;
440       if (idx > 2)
441         {
442           idx = 0;
443           c = bintoasc[(*radbuf >> 2) & 077];
444           es_putc (c, stream);
445           c = bintoasc[(((*radbuf<<4)&060)|((radbuf[1] >> 4)&017))&077];
446           es_putc (c, stream);
447           c = bintoasc[(((radbuf[1]<<2)&074)|((radbuf[2]>>6)&03))&077];
448           es_putc (c, stream);
449           c = bintoasc[radbuf[2]&077];
450           es_putc (c, stream);
451           if (++quad_count >= (64/4))
452             {
453               es_fputs (LF, stream);
454               quad_count = 0;
455             }
456         }
457     }
458   for (i=0; i < idx; i++)
459     parm->base64.radbuf[i] = radbuf[i];
460   parm->base64.idx = idx;
461   parm->base64.quad_count = quad_count;
462
463   return es_ferror (stream)? gpg_error_from_syserror () : 0;
464 }
465
466
467 /* This callback is only used in stream mode.  Hiowever, we don't
468    restrict it to this.  */
469 static int
470 plain_writer_cb (void *cb_value, const void *buffer, size_t count)
471 {
472   struct writer_cb_parm_s *parm = cb_value;
473   estream_t stream = parm->stream;
474
475   if (!count)
476     return 0;
477
478   es_write (stream, buffer, count, NULL);
479
480   return es_ferror (stream)? gpg_error_from_syserror () : 0;
481 }
482
483
484 static int
485 base64_finish_write (struct writer_cb_parm_s *parm)
486 {
487   unsigned char *radbuf;
488   int c, idx, quad_count;
489   estream_t stream = parm->stream;
490
491   if (!parm->wrote_begin)
492     return 0; /* Nothing written or we are not called in base-64 mode. */
493
494   /* flush the base64 encoding */
495   idx = parm->base64.idx;
496   quad_count = parm->base64.quad_count;
497   if (idx)
498     {
499       radbuf = parm->base64.radbuf;
500
501       c = bintoasc[(*radbuf>>2)&077];
502       es_putc (c, stream);
503       if (idx == 1)
504         {
505           c = bintoasc[((*radbuf << 4) & 060) & 077];
506           es_putc (c, stream);
507           es_putc ('=', stream);
508           es_putc ('=', stream);
509         }
510       else
511         {
512           c = bintoasc[(((*radbuf<<4)&060)|((radbuf[1]>>4)&017))&077];
513           es_putc (c, stream);
514           c = bintoasc[((radbuf[1] << 2) & 074) & 077];
515           es_putc (c, stream);
516           es_putc ('=', stream);
517
518         }
519       if (++quad_count >= (64/4))
520         {
521           es_fputs (LF, stream);
522           quad_count = 0;
523         }
524     }
525
526   if (quad_count)
527     es_fputs (LF, stream);
528
529   if (parm->pem_name)
530     {
531       es_fputs ("-----END ", stream);
532       es_fputs (parm->pem_name, stream);
533       es_fputs ("-----\n", stream);
534     }
535
536   return es_ferror (stream)? gpg_error_from_syserror () : 0;
537 }
538
539
540
541 \f
542 /* Create a reader for the given file descriptor.  Depending on the
543    control information an input decoding is automagically choosen.
544    The function returns a Base64Context object which must be passed to
545    the gpgme_destroy_reader function.  The created KsbaReader object
546    is also returned, but the caller must not call the
547    ksba_reader_release function on.  If ALLOW_MULTI_PEM is true, the
548    reader expects that the caller uses ksba_reader_clear after EOF
549    until no more objects were found. */
550 int
551 gpgsm_create_reader (Base64Context *ctx,
552                      ctrl_t ctrl, estream_t fp, int allow_multi_pem,
553                      ksba_reader_t *r_reader)
554 {
555   int rc;
556   ksba_reader_t r;
557
558   *r_reader = NULL;
559   *ctx = xtrycalloc (1, sizeof **ctx);
560   if (!*ctx)
561     return out_of_core ();
562   (*ctx)->u.rparm.allow_multi_pem = allow_multi_pem;
563
564   rc = ksba_reader_new (&r);
565   if (rc)
566     {
567       xfree (*ctx); *ctx = NULL;
568       return rc;
569     }
570
571   (*ctx)->u.rparm.fp = fp;
572   if (ctrl->is_pem)
573     {
574       (*ctx)->u.rparm.assume_pem = 1;
575       (*ctx)->u.rparm.assume_base64 = 1;
576       rc = ksba_reader_set_cb (r, base64_reader_cb, &(*ctx)->u.rparm);
577     }
578   else if (ctrl->is_base64)
579     {
580       (*ctx)->u.rparm.assume_base64 = 1;
581       rc = ksba_reader_set_cb (r, base64_reader_cb, &(*ctx)->u.rparm);
582     }
583   else if (ctrl->autodetect_encoding)
584     {
585       (*ctx)->u.rparm.autodetect = 1;
586       rc = ksba_reader_set_cb (r, base64_reader_cb, &(*ctx)->u.rparm);
587     }
588   else
589       rc = ksba_reader_set_cb (r, simple_reader_cb, &(*ctx)->u.rparm);
590
591   if (rc)
592     {
593       ksba_reader_release (r);
594       xfree (*ctx); *ctx = NULL;
595       return rc;
596     }
597
598   (*ctx)->u2.reader = r;
599   *r_reader = r;
600   return 0;
601 }
602
603
604 int
605 gpgsm_reader_eof_seen (Base64Context ctx)
606 {
607   return ctx && ctx->u.rparm.eof_seen;
608 }
609
610 void
611 gpgsm_destroy_reader (Base64Context ctx)
612 {
613   if (!ctx)
614     return;
615
616   ksba_reader_release (ctx->u2.reader);
617   xfree (ctx);
618 }
619
620
621 \f
622 /* Create a writer for the given STREAM.  Depending on
623    the control information an output encoding is automagically
624    choosen.  The function returns a Base64Context object which must be
625    passed to the gpgme_destroy_writer function.  The created
626    KsbaWriter object is also returned, but the caller must not call
627    the ksba_reader_release function on it. */
628 int
629 gpgsm_create_writer (Base64Context *ctx, ctrl_t ctrl, estream_t stream,
630                      ksba_writer_t *r_writer)
631 {
632   int rc;
633   ksba_writer_t w;
634
635   *r_writer = NULL;
636   *ctx = xtrycalloc (1, sizeof **ctx);
637   if (!*ctx)
638     return out_of_core ();
639
640   rc = ksba_writer_new (&w);
641   if (rc)
642     {
643       xfree (*ctx); *ctx = NULL;
644       return rc;
645     }
646
647   if (ctrl->create_pem || ctrl->create_base64)
648     {
649       (*ctx)->u.wparm.stream = stream;
650       if (ctrl->create_pem)
651         (*ctx)->u.wparm.pem_name = ctrl->pem_name? ctrl->pem_name
652                                                  : "CMS OBJECT";
653       rc = ksba_writer_set_cb (w, base64_writer_cb, &(*ctx)->u.wparm);
654     }
655   else if (stream)
656     {
657       (*ctx)->u.wparm.stream = stream;
658       rc = ksba_writer_set_cb (w, plain_writer_cb, &(*ctx)->u.wparm);
659     }
660   else
661     rc = gpg_error (GPG_ERR_INV_ARG);
662
663   if (rc)
664     {
665       ksba_writer_release (w);
666       xfree (*ctx); *ctx = NULL;
667       return rc;
668     }
669
670   (*ctx)->u2.writer = w;
671   *r_writer = w;
672   return 0;
673 }
674
675
676 int
677 gpgsm_finish_writer (Base64Context ctx)
678 {
679   struct writer_cb_parm_s *parm;
680
681   if (!ctx)
682     return gpg_error (GPG_ERR_INV_VALUE);
683   parm = &ctx->u.wparm;
684   if (parm->did_finish)
685     return 0; /* Already done. */
686   parm->did_finish = 1;
687   if (!parm->stream)
688     return 0; /* Callback was not used.  */
689   return base64_finish_write (parm);
690 }
691
692 void
693 gpgsm_destroy_writer (Base64Context ctx)
694 {
695   if (!ctx)
696     return;
697
698   ksba_writer_release (ctx->u2.writer);
699   xfree (ctx);
700 }