* getkey.c: Set MAX_PK_CACHE_ENTRIES and MAX_UID_CACHE_ENTRIES to
[gnupg.git] / g10 / armor.c
1 /* armor.c - Armor flter
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003
3  *                                             Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG 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 General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <errno.h>
27 #include <assert.h>
28 #include <ctype.h>
29
30 #include "errors.h"
31 #include "iobuf.h"
32 #include "memory.h"
33 #include "util.h"
34 #include "filter.h"
35 #include "packet.h"
36 #include "options.h"
37 #include "main.h"
38 #include "status.h"
39 #include "i18n.h"
40
41 #ifdef HAVE_DOSISH_SYSTEM
42 #define LF "\r\n"
43 #else
44 #define LF "\n"
45 #endif
46
47 #define MAX_LINELEN 20000
48
49 #define CRCINIT 0xB704CE
50 #define CRCPOLY 0X864CFB
51 #define CRCUPDATE(a,c) do {                                                 \
52                         a = ((a) << 8) ^ crc_table[((a)&0xff >> 16) ^ (c)]; \
53                         a &= 0x00ffffff;                                    \
54                     } while(0)
55 static u32 crc_table[256];
56 static byte bintoasc[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
57                          "abcdefghijklmnopqrstuvwxyz"
58                          "0123456789+/";
59 static byte asctobin[256]; /* runtime initialized */
60 static int is_initialized;
61
62
63 typedef enum {
64     fhdrHASArmor = 0,
65     fhdrNOArmor,
66     fhdrINIT,
67     fhdrINITCont,
68     fhdrINITSkip,
69     fhdrCHECKBegin,
70     fhdrWAITHeader,
71     fhdrWAITClearsig,
72     fhdrSKIPHeader,
73     fhdrCLEARSIG,
74     fhdrREADClearsig,
75     fhdrNullClearsig,
76     fhdrEMPTYClearsig,
77     fhdrCHECKClearsig,
78     fhdrCHECKClearsig2,
79     fhdrCHECKDashEscaped,
80     fhdrCHECKDashEscaped2,
81     fhdrCHECKDashEscaped3,
82     fhdrREADClearsigNext,
83     fhdrENDClearsig,
84     fhdrENDClearsigHelp,
85     fhdrTESTSpaces,
86     fhdrCLEARSIGSimple,
87     fhdrCLEARSIGSimpleNext,
88     fhdrTEXT,
89     fhdrTEXTSimple,
90     fhdrERROR,
91     fhdrERRORShow,
92     fhdrEOF
93 } fhdr_state_t;
94
95
96 /* if we encounter this armor string with this index, go
97  * into a mode which fakes packets and wait for the next armor */
98 #define BEGIN_SIGNATURE 2
99 #define BEGIN_SIGNED_MSG_IDX 3
100 static char *head_strings[] = {
101     "BEGIN PGP MESSAGE",
102     "BEGIN PGP PUBLIC KEY BLOCK",
103     "BEGIN PGP SIGNATURE",
104     "BEGIN PGP SIGNED MESSAGE",
105     "BEGIN PGP ARMORED FILE",       /* gnupg extension */
106     "BEGIN PGP PRIVATE KEY BLOCK",
107     "BEGIN PGP SECRET KEY BLOCK",   /* only used by pgp2 */
108     NULL
109 };
110 static char *tail_strings[] = {
111     "END PGP MESSAGE",
112     "END PGP PUBLIC KEY BLOCK",
113     "END PGP SIGNATURE",
114     "END dummy",
115     "END PGP ARMORED FILE",
116     "END PGP PRIVATE KEY BLOCK",
117     "END PGP SECRET KEY BLOCK",
118     NULL
119 };
120
121
122
123 static void
124 initialize(void)
125 {
126     int i, j;
127     u32 t;
128     byte *s;
129
130     /* init the crc lookup table */
131     crc_table[0] = 0;
132     for(i=j=0; j < 128; j++ ) {
133         t = crc_table[j];
134         if( t & 0x00800000 ) {
135             t <<= 1;
136             crc_table[i++] = t ^ CRCPOLY;
137             crc_table[i++] = t;
138         }
139         else {
140             t <<= 1;
141             crc_table[i++] = t;
142             crc_table[i++] = t ^ CRCPOLY;
143         }
144     }
145     /* build the helptable for radix64 to bin conversion */
146     for(i=0; i < 256; i++ )
147         asctobin[i] = 255; /* used to detect invalid characters */
148     for(s=bintoasc,i=0; *s; s++,i++ )
149         asctobin[*s] = i;
150
151     is_initialized=1;
152 }
153
154 /****************
155  * Check whether this is an armored file or not See also
156  * parse-packet.c for details on this code For unknown historic
157  * reasons we use a string here but only the first byte will be used.
158  * Returns: True if it seems to be armored
159  */
160 static int
161 is_armored( const byte *buf )
162 {
163     int ctb, pkttype;
164
165     ctb = *buf;
166     if( !(ctb & 0x80) )
167         return 1; /* invalid packet: assume it is armored */
168     pkttype =  ctb & 0x40 ? (ctb & 0x3f) : ((ctb>>2)&0xf);
169     switch( pkttype ) {
170       case PKT_MARKER:
171       case PKT_SYMKEY_ENC:
172       case PKT_ONEPASS_SIG:
173       case PKT_PUBLIC_KEY:
174       case PKT_SECRET_KEY:
175       case PKT_PUBKEY_ENC:
176       case PKT_SIGNATURE:
177       case PKT_COMMENT:
178       case PKT_OLD_COMMENT:
179       case PKT_PLAINTEXT:
180       case PKT_COMPRESSED:
181       case PKT_ENCRYPTED:
182         return 0; /* seems to be a regular packet: not armored */
183     }
184
185     return 1;
186 }
187
188
189 /****************
190  * Try to check whether the iobuf is armored
191  * Returns true if this may be the case; the caller should use the
192  *         filter to do further processing.
193  */
194 int
195 use_armor_filter( IOBUF a )
196 {
197     byte buf[1];
198     int n;
199
200     /* fixme: there might be a problem with iobuf_peek */
201     n = iobuf_peek(a, buf, 1 );
202     if( n == -1 )
203         return 0; /* EOF, doesn't matter whether armored or not */
204     if( !n )
205         return 1; /* can't check it: try armored */
206     return is_armored(buf);
207 }
208
209
210
211
212 static void
213 invalid_armor(void)
214 {
215     write_status(STATUS_BADARMOR);
216     g10_exit(1); /* stop here */
217 }
218
219
220 /****************
221  * check whether the armor header is valid on a signed message.
222  * this is for security reasons: the header lines are not included in the
223  * hash and by using some creative formatting rules, Mallory could fake
224  * any text at the beginning of a document; assuming it is read with
225  * a simple viewer. We only allow the Hash Header.
226  */
227 static int
228 parse_hash_header( const char *line )
229 {
230     const char *s, *s2;
231     unsigned found = 0;
232
233     if( strlen(line) < 6  || strlen(line) > 60 )
234         return 0; /* too short or too long */
235     if( memcmp( line, "Hash:", 5 ) )
236         return 0; /* invalid header */
237     s = line+5;
238     for(s=line+5;;s=s2) {
239         for(; *s && (*s==' ' || *s == '\t'); s++ )
240             ;
241         if( !*s )
242             break;
243         for(s2=s+1; *s2 && *s2!=' ' && *s2 != '\t' && *s2 != ','; s2++ )
244             ;
245         if( !strncmp( s, "RIPEMD160", s2-s ) )
246             found |= 1;
247         else if( !strncmp( s, "SHA1", s2-s ) )
248             found |= 2;
249         else if( !strncmp( s, "MD5", s2-s ) )
250             found |= 4;
251         else if( !strncmp( s, "SHA256", s2-s ) )
252             found |= 8;
253         else if( !strncmp( s, "SHA384", s2-s ) )
254             found |= 16;
255         else if( !strncmp( s, "SHA512", s2-s ) )
256             found |= 32;
257         else
258             return 0;
259         for(; *s2 && (*s2==' ' || *s2 == '\t'); s2++ )
260             ;
261         if( *s2 && *s2 != ',' )
262             return 0;
263         if( *s2 )
264             s2++;
265     }
266     return found;
267 }
268
269
270
271 /****************
272  * Check whether this is a armor line.
273  * returns: -1 if it is not a armor header or the index number of the
274  * armor header.
275  */
276 static int
277 is_armor_header( byte *line, unsigned len )
278 {
279     const char *s;
280     byte *save_p, *p;
281     int save_c;
282     int i;
283
284     if( len < 15 )
285         return -1; /* too short */
286     if( memcmp( line, "-----", 5 ) )
287         return -1; /* no */
288     p = strstr( line+5, "-----");
289     if( !p )
290         return -1;
291     save_p = p;
292     p += 5;
293
294     /* Some mail programs on Windows seem to add spaces to the end of
295        the line.  This becomes strict if --openpgp is set. */
296
297     if(!RFC2440)
298       while(*p==' ')
299         p++;
300
301     if( *p == '\r' )
302         p++;
303     if( *p == '\n' )
304         p++;
305     if( *p )
306         return -1; /* garbage after dashes */
307     save_c = *save_p; *save_p = 0;
308     p = line+5;
309     for(i=0; (s=head_strings[i]); i++ )
310         if( !strcmp(s, p) )
311             break;
312     *save_p = save_c;
313     if( !s )
314         return -1; /* unknown armor line */
315
316     if( opt.verbose > 1 )
317         log_info(_("armor: %s\n"), head_strings[i]);
318     return i;
319 }
320
321
322
323 /****************
324  * Parse a header lines
325  * Return 0: Empty line (end of header lines)
326  *       -1: invalid header line
327  *       >0: Good header line
328  */
329 static int
330 parse_header_line( armor_filter_context_t *afx, byte *line, unsigned int len )
331 {
332     byte *p;
333     int hashes=0;
334     unsigned int len2;
335
336     len2 = check_trailing_ws( line, len );
337     if( !len2 ) {
338         afx->buffer_pos = len2;  /* (it is not the fine way to do it here) */
339         return 0; /* WS only: same as empty line */
340     }
341     len = len2;
342     line[len2] = 0;
343
344     p = strchr( line, ':');
345     if( !p || !p[1] ) {
346         log_error(_("invalid armor header: "));
347         print_string( stderr, line, len, 0 );
348         putc('\n', stderr);
349         return -1;
350     }
351
352     if( opt.verbose ) {
353         log_info(_("armor header: "));
354         print_string( stderr, line, len, 0 );
355         putc('\n', stderr);
356     }
357
358     if( afx->in_cleartext ) {
359         if( (hashes=parse_hash_header( line )) )
360             afx->hashes |= hashes;
361         else if( strlen(line) > 15 && !memcmp( line, "NotDashEscaped:", 15 ) )
362             afx->not_dash_escaped = 1;
363         else {
364             log_error(_("invalid clearsig header\n"));
365             return -1;
366         }
367     }
368     return 1;
369 }
370
371
372
373 /* figure out whether the data is armored or not */
374 static int
375 check_input( armor_filter_context_t *afx, IOBUF a )
376 {
377     int rc = 0;
378     int i;
379     byte *line;
380     unsigned len;
381     unsigned maxlen;
382     int hdr_line = -1;
383
384     /* read the first line to see whether this is armored data */
385     maxlen = MAX_LINELEN;
386     len = afx->buffer_len = iobuf_read_line( a, &afx->buffer,
387                                              &afx->buffer_size, &maxlen );
388     line = afx->buffer;
389     if( !maxlen ) {
390         /* line has been truncated: assume not armored */
391         afx->inp_checked = 1;
392         afx->inp_bypass = 1;
393         return 0;
394     }
395
396     if( !len ) {
397         return -1; /* eof */
398     }
399
400     /* (the line is always a C string but maybe longer) */
401     if( *line == '\n' || ( len && (*line == '\r' && line[1]=='\n') ) )
402         ;
403     else if( !is_armored( line ) ) {
404         afx->inp_checked = 1;
405         afx->inp_bypass = 1;
406         return 0;
407     }
408
409     /* find the armor header */
410     while(len) {
411         i = is_armor_header( line, len );
412         if( i >= 0 && !(afx->only_keyblocks && i != 1 && i != 5 && i != 6 )) {
413             hdr_line = i;
414             if( hdr_line == BEGIN_SIGNED_MSG_IDX ) {
415                 if( afx->in_cleartext ) {
416                     log_error(_("nested clear text signatures\n"));
417                     rc = G10ERR_INVALID_ARMOR;
418                 }
419                 afx->in_cleartext = 1;
420             }
421             break;
422         }
423         /* read the next line (skip all truncated lines) */
424         do {
425             maxlen = MAX_LINELEN;
426             afx->buffer_len = iobuf_read_line( a, &afx->buffer,
427                                                &afx->buffer_size, &maxlen );
428             line = afx->buffer;
429             len = afx->buffer_len;
430         } while( !maxlen );
431     }
432
433     /* parse the header lines */
434     while(len) {
435         /* read the next line (skip all truncated lines) */
436         do {
437             maxlen = MAX_LINELEN;
438             afx->buffer_len = iobuf_read_line( a, &afx->buffer,
439                                                &afx->buffer_size, &maxlen );
440             line = afx->buffer;
441             len = afx->buffer_len;
442         } while( !maxlen );
443
444         i = parse_header_line( afx, line, len );
445         if( i <= 0 ) {
446             if( i )
447                 rc = G10ERR_INVALID_ARMOR;
448             break;
449         }
450     }
451
452
453     if( rc )
454         invalid_armor();
455     else if( afx->in_cleartext )
456         afx->faked = 1;
457     else {
458         afx->inp_checked = 1;
459         afx->crc = CRCINIT;
460         afx->idx = 0;
461         afx->radbuf[0] = 0;
462     }
463
464     return rc;
465 }
466
467
468
469 /****************
470  * Fake a literal data packet and wait for the next armor line
471  * fixme: empty line handling and null length clear text signature are
472  *        not implemented/checked.
473  */
474 static int
475 fake_packet( armor_filter_context_t *afx, IOBUF a,
476              size_t *retn, byte *buf, size_t size  )
477 {
478     int rc = 0;
479     size_t len = 0;
480     int lastline = 0;
481     unsigned maxlen, n;
482     byte *p;
483
484     len = 2;    /* reserve 2 bytes for the length header */
485     size -= 2;  /* and 2 for the terminating header */
486     while( !rc && len < size ) {
487         /* copy what we have in the line buffer */
488         if( afx->faked == 1 )
489             afx->faked++; /* skip the first (empty) line */
490         else {
491             while( len < size && afx->buffer_pos < afx->buffer_len )
492                 buf[len++] = afx->buffer[afx->buffer_pos++];
493             if( len >= size )
494                 continue;
495         }
496
497         /* read the next line */
498         maxlen = MAX_LINELEN;
499         afx->buffer_pos = 0;
500         afx->buffer_len = iobuf_read_line( a, &afx->buffer,
501                                            &afx->buffer_size, &maxlen );
502         if( !afx->buffer_len ) {
503             rc = -1; /* eof (should not happen) */
504             continue;
505         }
506         if( !maxlen )
507             afx->truncated++;
508         if( !afx->not_dash_escaped ) {
509             int crlf;
510             p = afx->buffer;
511             n = afx->buffer_len;
512             crlf = n > 1 && p[n-2] == '\r' && p[n-1]=='\n';
513
514             /* PGP2 does not treat a tab as white space character */
515             afx->buffer_len = trim_trailing_chars( p, n,
516                                          afx->pgp2mode ? " \r\n" : " \t\r\n");
517             /* the buffer is always allocated with enough space to append
518              * the removed [CR], LF and a Nul
519              * The reason for this complicated procedure is to keep at least
520              * the original type of lineending - handling of the removed
521              * trailing spaces seems to be impossible in our method
522              * of faking a packet; either we have to use a temporary file
523              * or calculate the hash here in this module and somehow find
524              * a way to send the hash down the processing line (well, a special
525              * faked packet could do the job).
526              */
527             if( crlf )
528                 afx->buffer[afx->buffer_len++] = '\r';
529             afx->buffer[afx->buffer_len++] = '\n';
530             afx->buffer[afx->buffer_len] = 0;
531         }
532         p = afx->buffer;
533         n = afx->buffer_len;
534
535         if( n > 2 && *p == '-' ) {
536             /* check for dash escaped or armor header */
537             if( p[1] == ' ' && !afx->not_dash_escaped ) {
538                 /* issue a warning if it is not regular encoded */
539                 if( p[2] != '-' && !( n > 6 && !memcmp(p+2, "From ", 5))) {
540                     log_info(_("invalid dash escaped line: "));
541                     print_string( stderr, p, n, 0 );
542                     putc('\n', stderr);
543                 }
544                 afx->buffer_pos = 2; /* skip */
545             }
546             else if( n >= 15 &&  p[1] == '-' && p[2] == '-' && p[3] == '-' ) {
547                 int type = is_armor_header( p, n );
548                 if( afx->not_dash_escaped && type != BEGIN_SIGNATURE )
549                     ; /* this is okay */
550                 else {
551                     if( type != BEGIN_SIGNATURE ) {
552                         log_info(_("unexpected armor:"));
553                         print_string( stderr, p, n, 0 );
554                         putc('\n', stderr);
555                     }
556                     lastline = 1;
557                     rc = -1;
558                 }
559             }
560         }
561     }
562
563     buf[0] = (len-2) >> 8;
564     buf[1] = (len-2);
565     if( lastline ) { /* write last (ending) length header */
566         if( buf[0] || buf[1] ) { /* only if we have some text */
567             buf[len++] = 0;
568             buf[len++] = 0;
569         }
570         rc = 0;
571         afx->faked = 0;
572         afx->in_cleartext = 0;
573         /* and now read the header lines */
574         afx->buffer_pos = 0;
575         for(;;) {
576             int i;
577
578             /* read the next line (skip all truncated lines) */
579             do {
580                 maxlen = MAX_LINELEN;
581                 afx->buffer_len = iobuf_read_line( a, &afx->buffer,
582                                                  &afx->buffer_size, &maxlen );
583             } while( !maxlen );
584             p = afx->buffer;
585             n = afx->buffer_len;
586             if( !n ) {
587                 rc = -1;
588                 break; /* eof */
589             }
590             i = parse_header_line( afx, p , n );
591             if( i <= 0 ) {
592                 if( i )
593                     invalid_armor();
594                 break;
595             }
596         }
597         afx->inp_checked = 1;
598         afx->crc = CRCINIT;
599         afx->idx = 0;
600         afx->radbuf[0] = 0;
601     }
602
603     *retn = len;
604     return rc;
605 }
606
607
608 static int
609 invalid_crc(void)
610 {
611     if ( opt.ignore_crc_error )
612         return 0;
613     log_inc_errorcount();
614     return G10ERR_INVALID_ARMOR;
615 }
616
617
618 static int
619 radix64_read( armor_filter_context_t *afx, IOBUF a, size_t *retn,
620               byte *buf, size_t size )
621 {
622     byte val;
623     int c=0, c2; /*init c because gcc is not clever enough for the continue*/
624     int checkcrc=0;
625     int rc = 0;
626     size_t n = 0;
627     int  idx, i;
628     u32 crc;
629
630     crc = afx->crc;
631     idx = afx->idx;
632     val = afx->radbuf[0];
633     for( n=0; n < size; ) {
634
635         if( afx->buffer_pos < afx->buffer_len )
636             c = afx->buffer[afx->buffer_pos++];
637         else { /* read the next line */
638             unsigned maxlen = MAX_LINELEN;
639             afx->buffer_pos = 0;
640             afx->buffer_len = iobuf_read_line( a, &afx->buffer,
641                                                &afx->buffer_size, &maxlen );
642             if( !maxlen )
643                 afx->truncated++;
644             if( !afx->buffer_len )
645                 break; /* eof */
646             continue;
647         }
648
649       again:
650         if( c == '\n' || c == ' ' || c == '\r' || c == '\t' )
651             continue;
652         else if( c == '=' ) { /* pad character: stop */
653             /* some mailers leave quoted-printable encoded characters
654              * so we try to workaround this */
655             if( afx->buffer_pos+2 < afx->buffer_len ) {
656                 int cc1, cc2, cc3;
657                 cc1 = afx->buffer[afx->buffer_pos];
658                 cc2 = afx->buffer[afx->buffer_pos+1];
659                 cc3 = afx->buffer[afx->buffer_pos+2];
660                 if( isxdigit(cc1) && isxdigit(cc2)
661                                   && strchr( "=\n\r\t ", cc3 )) {
662                     /* well it seems to be the case - adjust */
663                     c = isdigit(cc1)? (cc1 - '0'): (ascii_toupper(cc1)-'A'+10);
664                     c <<= 4;
665                     c |= isdigit(cc2)? (cc2 - '0'): (ascii_toupper(cc2)-'A'+10);
666                     afx->buffer_pos += 2;
667                     afx->qp_detected = 1;
668                     goto again;
669                 }
670             }
671
672             if( idx == 1 )
673                 buf[n++] = val;
674             checkcrc++;
675             break;
676         }
677         else if( (c = asctobin[(c2=c)]) == 255 ) {
678             log_error(_("invalid radix64 character %02x skipped\n"), c2);
679             continue;
680         }
681         switch(idx) {
682           case 0: val =  c << 2; break;
683           case 1: val |= (c>>4)&3; buf[n++]=val;val=(c<<4)&0xf0;break;
684           case 2: val |= (c>>2)&15; buf[n++]=val;val=(c<<6)&0xc0;break;
685           case 3: val |= c&0x3f; buf[n++] = val; break;
686         }
687         idx = (idx+1) % 4;
688     }
689
690     for(i=0; i < n; i++ )
691         crc = (crc << 8) ^ crc_table[((crc >> 16)&0xff) ^ buf[i]];
692     crc &= 0x00ffffff;
693     afx->crc = crc;
694     afx->idx = idx;
695     afx->radbuf[0] = val;
696
697     if( checkcrc ) {
698         afx->any_data = 1;
699         afx->inp_checked=0;
700         afx->faked = 0;
701         for(;;) { /* skip lf and pad characters */
702             if( afx->buffer_pos < afx->buffer_len )
703                 c = afx->buffer[afx->buffer_pos++];
704             else { /* read the next line */
705                 unsigned maxlen = MAX_LINELEN;
706                 afx->buffer_pos = 0;
707                 afx->buffer_len = iobuf_read_line( a, &afx->buffer,
708                                                    &afx->buffer_size, &maxlen );
709                 if( !maxlen )
710                     afx->truncated++;
711                 if( !afx->buffer_len )
712                     break; /* eof */
713                 continue;
714             }
715             if( c == '\n' || c == ' ' || c == '\r'
716                 || c == '\t' || c == '=' )
717                 continue;
718             break;
719         }
720         if( c == -1 )
721             log_error(_("premature eof (no CRC)\n"));
722         else {
723             u32 mycrc = 0;
724             idx = 0;
725             do {
726                 if( (c = asctobin[c]) == 255 )
727                     break;
728                 switch(idx) {
729                   case 0: val =  c << 2; break;
730                   case 1: val |= (c>>4)&3; mycrc |= val << 16;val=(c<<4)&0xf0;break;
731                   case 2: val |= (c>>2)&15; mycrc |= val << 8;val=(c<<6)&0xc0;break;
732                   case 3: val |= c&0x3f; mycrc |= val; break;
733                 }
734                 for(;;) {
735                     if( afx->buffer_pos < afx->buffer_len )
736                         c = afx->buffer[afx->buffer_pos++];
737                     else { /* read the next line */
738                         unsigned maxlen = MAX_LINELEN;
739                         afx->buffer_pos = 0;
740                         afx->buffer_len = iobuf_read_line( a, &afx->buffer,
741                                                            &afx->buffer_size,
742                                                                 &maxlen );
743                         if( !maxlen )
744                             afx->truncated++;
745                         if( !afx->buffer_len )
746                             break; /* eof */
747                         continue;
748                     }
749                     break;
750                 }
751                 if( !afx->buffer_len )
752                     break; /* eof */
753             } while( ++idx < 4 );
754             if( c == -1 ) {
755                 log_info(_("premature eof (in CRC)\n"));
756                 rc = invalid_crc();
757                             }
758             else if( idx != 4 ) {
759                 log_info(_("malformed CRC\n"));
760                 rc = invalid_crc();
761             }
762             else if( mycrc != afx->crc ) {
763                 log_info (_("CRC error; %06lx - %06lx\n"),
764                                     (ulong)afx->crc, (ulong)mycrc);
765                 rc = invalid_crc();
766             }
767             else {
768                 rc = 0;
769                 /* FIXME: Here we should emit another control packet,
770                  * so that we know in mainproc that we are processing
771                  * a clearsign message */
772 #if 0
773                 for(rc=0;!rc;) {
774                     rc = 0 /*check_trailer( &fhdr, c )*/;
775                     if( !rc ) {
776                         if( (c=iobuf_get(a)) == -1 )
777                             rc = 2;
778                     }
779                 }
780                 if( rc == -1 )
781                     rc = 0;
782                 else if( rc == 2 ) {
783                     log_error(_("premature eof (in Trailer)\n"));
784                     rc = G10ERR_INVALID_ARMOR;
785                 }
786                 else {
787                     log_error(_("error in trailer line\n"));
788                     rc = G10ERR_INVALID_ARMOR;
789                 }
790 #endif
791             }
792         }
793     }
794
795     if( !n )
796         rc = -1;
797
798     *retn = n;
799     return rc;
800 }
801
802 /****************
803  * This filter is used to handle the armor stuff
804  */
805 int
806 armor_filter( void *opaque, int control,
807              IOBUF a, byte *buf, size_t *ret_len)
808 {
809     size_t size = *ret_len;
810     armor_filter_context_t *afx = opaque;
811     int rc=0, i, c;
812     byte radbuf[3];
813     int  idx, idx2;
814     size_t n=0;
815     u32 crc;
816 #if 0
817     static FILE *fp ;
818
819     if( !fp ) {
820         fp = fopen("armor.out", "w");
821         assert(fp);
822     }
823 #endif
824
825     if( DBG_FILTER )
826         log_debug("armor-filter: control: %d\n", control );
827     if( control == IOBUFCTRL_UNDERFLOW && afx->inp_bypass ) {
828         n = 0;
829         if( afx->buffer_len ) {
830             for(; n < size && afx->buffer_pos < afx->buffer_len; n++ )
831                 buf[n++] = afx->buffer[afx->buffer_pos++];
832             if( afx->buffer_pos >= afx->buffer_len )
833                 afx->buffer_len = 0;
834         }
835         for(; n < size; n++ ) {
836             if( (c=iobuf_get(a)) == -1 )
837                 break;
838             buf[n] = c & 0xff;
839         }
840         if( !n )
841             rc = -1;
842         *ret_len = n;
843     }
844     else if( control == IOBUFCTRL_UNDERFLOW ) {
845         /* We need some space for the faked packet.  The minmum required
846          * size is ~18 + length of the session marker */
847         if( size < 50 ) 
848             BUG(); /* supplied buffer too short */
849
850         if( afx->faked )
851             rc = fake_packet( afx, a, &n, buf, size );
852         else if( !afx->inp_checked ) {
853             rc = check_input( afx, a );
854             if( afx->inp_bypass ) {
855                 for(n=0; n < size && afx->buffer_pos < afx->buffer_len; )
856                     buf[n++] = afx->buffer[afx->buffer_pos++];
857                 if( afx->buffer_pos >= afx->buffer_len )
858                     afx->buffer_len = 0;
859                 if( !n )
860                     rc = -1;
861             }
862             else if( afx->faked ) {
863                 unsigned int hashes = afx->hashes;
864                 const byte *sesmark;
865                 size_t sesmarklen;
866                 
867                 sesmark = get_session_marker( &sesmarklen );
868                 if ( sesmarklen > 20 )
869                     BUG();
870
871                 /* the buffer is at least 15+n*15 bytes long, so it
872                  * is easy to construct the packets */
873
874                 hashes &= 1|2|4|8|16|32|64;
875                 if( !hashes ) {
876                     hashes |= 4;  /* default to MD 5 */
877                     /* This is non-ideal since PGP 5-8 have the same
878                        end-of-line bugs as PGP 2. However, we only
879                        enable pgp2mode if there is no Hash: header. */
880                     if( opt.pgp2_workarounds )
881                         afx->pgp2mode = 1;
882                 }
883                 n=0;
884                 /* first a gpg control packet */
885                 buf[n++] = 0xff; /* new format, type 63, 1 length byte */
886                 n++;   /* see below */
887                 memcpy(buf+n, sesmark, sesmarklen ); n+= sesmarklen;
888                 buf[n++] = CTRLPKT_CLEARSIGN_START; 
889                 buf[n++] = afx->not_dash_escaped? 0:1; /* sigclass */
890                 if( hashes & 1 )
891                     buf[n++] = DIGEST_ALGO_RMD160;
892                 if( hashes & 2 )
893                     buf[n++] = DIGEST_ALGO_SHA1;
894                 if( hashes & 4 )
895                     buf[n++] = DIGEST_ALGO_MD5;
896                 if( hashes & 8 )
897                     buf[n++] = DIGEST_ALGO_SHA256;
898                 if( hashes & 16 )
899                     buf[n++] = DIGEST_ALGO_SHA384;
900                 if( hashes & 32 )
901                     buf[n++] = DIGEST_ALGO_SHA512;
902                 buf[1] = n - 2;
903
904                 /* followed by a plaintext packet */
905                 buf[n++] = 0xaf; /* old packet format, type 11, var length */
906                 buf[n++] = 0;    /* set the length header */
907                 buf[n++] = 6;
908                 buf[n++] = 't';  /* canonical text mode */
909                 buf[n++] = 0;    /* namelength */
910                 memset(buf+n, 0, 4); /* timestamp */
911                 n += 4;
912             }
913             else if( !rc )
914                 rc = radix64_read( afx, a, &n, buf, size );
915         }
916         else
917             rc = radix64_read( afx, a, &n, buf, size );
918 #if 0
919         if( n )
920             if( fwrite(buf, n, 1, fp ) != 1 )
921                 BUG();
922 #endif
923         *ret_len = n;
924     }
925     else if( control == IOBUFCTRL_FLUSH && !afx->cancel ) {
926         if( !afx->status ) { /* write the header line */
927             const char *s;
928             STRLIST comment=opt.comments;
929
930             if( afx->what >= DIM(head_strings) )
931                 log_bug("afx->what=%d", afx->what);
932             iobuf_writestr(a, "-----");
933             iobuf_writestr(a, head_strings[afx->what] );
934             iobuf_writestr(a, "-----" LF );
935             if( !opt.no_version )
936                 iobuf_writestr(a, "Version: GnuPG v"  VERSION " ("
937                                               PRINTABLE_OS_NAME ")" LF );
938
939             /* write the comment strings */
940             for(s=comment->d;comment;comment=comment->next,s=comment->d)
941               {
942                 iobuf_writestr(a, "Comment: " );
943                 for( ; *s; s++ )
944                   {
945                     if( *s == '\n' )
946                       iobuf_writestr(a, "\\n" );
947                     else if( *s == '\r' )
948                       iobuf_writestr(a, "\\r" );
949                     else if( *s == '\v' )
950                       iobuf_writestr(a, "\\v" );
951                     else
952                       iobuf_put(a, *s );
953                   }
954                 iobuf_writestr(a, LF );
955               }
956
957             if ( afx->hdrlines ) {
958                 for ( s = afx->hdrlines; *s; s++ ) {
959 #ifdef HAVE_DOSISH_SYSTEM
960                     if ( *s == '\n' )
961                         iobuf_put( a, '\r');
962 #endif
963                     iobuf_put(a, *s );
964                 }
965             }
966             iobuf_writestr(a, LF );
967             afx->status++;
968             afx->idx = 0;
969             afx->idx2 = 0;
970             afx->crc = CRCINIT;
971
972         }
973         crc = afx->crc;
974         idx = afx->idx;
975         idx2 = afx->idx2;
976         for(i=0; i < idx; i++ )
977             radbuf[i] = afx->radbuf[i];
978
979         for(i=0; i < size; i++ )
980             crc = (crc << 8) ^ crc_table[((crc >> 16)&0xff) ^ buf[i]];
981         crc &= 0x00ffffff;
982
983         for( ; size; buf++, size-- ) {
984             radbuf[idx++] = *buf;
985             if( idx > 2 ) {
986                 idx = 0;
987                 c = bintoasc[(*radbuf >> 2) & 077];
988                 iobuf_put(a, c);
989                 c = bintoasc[(((*radbuf<<4)&060)|((radbuf[1] >> 4)&017))&077];
990                 iobuf_put(a, c);
991                 c = bintoasc[(((radbuf[1]<<2)&074)|((radbuf[2]>>6)&03))&077];
992                 iobuf_put(a, c);
993                 c = bintoasc[radbuf[2]&077];
994                 iobuf_put(a, c);
995                 if( ++idx2 >= (64/4) ) { /* pgp doesn't like 72 here */
996                     iobuf_writestr(a, LF );
997                     idx2=0;
998                 }
999             }
1000         }
1001         for(i=0; i < idx; i++ )
1002             afx->radbuf[i] = radbuf[i];
1003         afx->idx = idx;
1004         afx->idx2 = idx2;
1005         afx->crc  = crc;
1006     }
1007     else if( control == IOBUFCTRL_INIT ) {
1008         if( !is_initialized )
1009             initialize();
1010     }
1011     else if( control == IOBUFCTRL_CANCEL ) {
1012         afx->cancel = 1;
1013     }
1014     else if( control == IOBUFCTRL_FREE ) {
1015         if( afx->cancel )
1016             ;
1017         else if( afx->status ) { /* pad, write cecksum, and bottom line */
1018             crc = afx->crc;
1019             idx = afx->idx;
1020             idx2 = afx->idx2;
1021             for(i=0; i < idx; i++ )
1022                 radbuf[i] = afx->radbuf[i];
1023             if( idx ) {
1024                 c = bintoasc[(*radbuf>>2)&077];
1025                 iobuf_put(a, c);
1026                 if( idx == 1 ) {
1027                     c = bintoasc[((*radbuf << 4) & 060) & 077];
1028                     iobuf_put(a, c);
1029                     iobuf_put(a, '=');
1030                     iobuf_put(a, '=');
1031                 }
1032                 else { /* 2 */
1033                     c = bintoasc[(((*radbuf<<4)&060)|((radbuf[1]>>4)&017))&077];
1034                     iobuf_put(a, c);
1035                     c = bintoasc[((radbuf[1] << 2) & 074) & 077];
1036                     iobuf_put(a, c);
1037                     iobuf_put(a, '=');
1038                 }
1039                 if( ++idx2 >= (64/4) ) { /* pgp doesn't like 72 here */
1040                     iobuf_writestr(a, LF );
1041                     idx2=0;
1042                 }
1043             }
1044             /* may need a linefeed */
1045             if( idx2 )
1046                 iobuf_writestr(a, LF );
1047             /* write the CRC */
1048             iobuf_put(a, '=');
1049             radbuf[0] = crc >>16;
1050             radbuf[1] = crc >> 8;
1051             radbuf[2] = crc;
1052             c = bintoasc[(*radbuf >> 2) & 077];
1053             iobuf_put(a, c);
1054             c = bintoasc[(((*radbuf<<4)&060)|((radbuf[1] >> 4)&017))&077];
1055             iobuf_put(a, c);
1056             c = bintoasc[(((radbuf[1]<<2)&074)|((radbuf[2]>>6)&03))&077];
1057             iobuf_put(a, c);
1058             c = bintoasc[radbuf[2]&077];
1059             iobuf_put(a, c);
1060             iobuf_writestr(a, LF );
1061             /* and the the trailer */
1062             if( afx->what >= DIM(tail_strings) )
1063                 log_bug("afx->what=%d", afx->what);
1064             iobuf_writestr(a, "-----");
1065             iobuf_writestr(a, tail_strings[afx->what] );
1066             iobuf_writestr(a, "-----" LF );
1067         }
1068         else if( !afx->any_data && !afx->inp_bypass ) {
1069             log_error(_("no valid OpenPGP data found.\n"));
1070             afx->no_openpgp_data = 1;
1071             write_status_text( STATUS_NODATA, "1" );
1072         }
1073         if( afx->truncated )
1074             log_info(_("invalid armor: line longer than %d characters\n"),
1075                       MAX_LINELEN );
1076         /* issue an error to enforce dissemination of correct software */
1077         if( afx->qp_detected )
1078             log_error(_("quoted printable character in armor - "
1079                         "probably a buggy MTA has been used\n") );
1080         m_free( afx->buffer );
1081         afx->buffer = NULL;
1082     }
1083     else if( control == IOBUFCTRL_DESC )
1084         *(char**)buf = "armor_filter";
1085     return rc;
1086 }
1087
1088
1089 /****************
1090  * create a radix64 encoded string.
1091  */
1092 char *
1093 make_radix64_string( const byte *data, size_t len )
1094 {
1095     char *buffer, *p;
1096
1097     buffer = p = m_alloc( (len+2)/3*4 + 1 );
1098     for( ; len >= 3 ; len -= 3, data += 3 ) {
1099         *p++ = bintoasc[(data[0] >> 2) & 077];
1100         *p++ = bintoasc[(((data[0] <<4)&060)|((data[1] >> 4)&017))&077];
1101         *p++ = bintoasc[(((data[1]<<2)&074)|((data[2]>>6)&03))&077];
1102         *p++ = bintoasc[data[2]&077];
1103     }
1104     if( len == 2 ) {
1105         *p++ = bintoasc[(data[0] >> 2) & 077];
1106         *p++ = bintoasc[(((data[0] <<4)&060)|((data[1] >> 4)&017))&077];
1107         *p++ = bintoasc[((data[1]<<2)&074)];
1108     }
1109     else if( len == 1 ) {
1110         *p++ = bintoasc[(data[0] >> 2) & 077];
1111         *p++ = bintoasc[(data[0] <<4)&060];
1112     }
1113     *p = 0;
1114     return buffer;
1115 }
1116
1117
1118 /***********************************************
1119  *  For the pipemode command we can't use the armor filter for various
1120  *  reasons, so we use this new unarmor_pump stuff to remove the armor 
1121  */
1122
1123 enum unarmor_state_e {
1124     STA_init = 0,
1125     STA_bypass,
1126     STA_wait_newline,
1127     STA_wait_dash,
1128     STA_first_dash, 
1129     STA_compare_header,
1130     STA_found_header_wait_newline,
1131     STA_skip_header_lines,
1132     STA_skip_header_lines_non_ws,
1133     STA_read_data,
1134     STA_wait_crc,
1135     STA_read_crc,
1136     STA_ready
1137 };
1138
1139 struct unarmor_pump_s {
1140     enum unarmor_state_e state;
1141     byte val;
1142     int checkcrc;
1143     int pos;   /* counts from 0..3 */
1144     u32 crc;
1145     u32 mycrc; /* the one store in the data */
1146 };
1147
1148
1149
1150 UnarmorPump
1151 unarmor_pump_new (void)
1152 {
1153     UnarmorPump x;
1154
1155     if( !is_initialized )
1156         initialize();
1157     x = m_alloc_clear (sizeof *x);
1158     return x;
1159 }
1160
1161 void
1162 unarmor_pump_release (UnarmorPump x)
1163 {
1164     m_free (x);
1165 }
1166
1167 /* 
1168  * Get the next character from the ascii armor taken from the IOBUF
1169  * created earlier by unarmor_pump_new().
1170  * Return:  c = Character
1171  *        256 = ignore this value
1172  *         -1 = End of current armor 
1173  *         -2 = Premature EOF (not used)
1174  *         -3 = Invalid armor
1175  */
1176 int
1177 unarmor_pump (UnarmorPump x, int c)
1178 {
1179     int rval = 256; /* default is to ignore the return value */
1180
1181     switch (x->state) {
1182       case STA_init:
1183         { 
1184             byte tmp[1];
1185             tmp[0] = c; 
1186             if ( is_armored (tmp) )
1187                 x->state = c == '-'? STA_first_dash : STA_wait_newline;
1188             else {
1189                 x->state = STA_bypass;
1190                 return c;
1191             }
1192         }
1193         break;
1194       case STA_bypass:
1195         return c; /* return here to avoid crc calculation */
1196       case STA_wait_newline:
1197         if (c == '\n')
1198             x->state = STA_wait_dash;
1199         break;
1200       case STA_wait_dash:
1201         x->state = c == '-'? STA_first_dash : STA_wait_newline;
1202         break;
1203       case STA_first_dash: /* just need for initalization */
1204         x->pos = 0;
1205         x->state = STA_compare_header;
1206       case STA_compare_header:
1207         if ( "-----BEGIN PGP SIGNATURE-----"[++x->pos] == c ) {
1208             if ( x->pos == 28 ) 
1209                 x->state = STA_found_header_wait_newline;
1210         }
1211         else 
1212             x->state = c == '\n'? STA_wait_dash : STA_wait_newline;
1213         break;
1214       case STA_found_header_wait_newline:
1215         /* to make CR,LF issues easier we simply allow for white space
1216            behind the 5 dashes */
1217         if ( c == '\n' )
1218             x->state = STA_skip_header_lines;
1219         else if ( c != '\r' && c != ' ' && c != '\t' )
1220             x->state = STA_wait_dash; /* garbage after the header line */
1221         break;
1222       case STA_skip_header_lines:
1223         /* i.e. wait for one empty line */
1224         if ( c == '\n' ) {
1225             x->state = STA_read_data;
1226             x->crc = CRCINIT;
1227             x->val = 0;
1228             x->pos = 0;
1229         }
1230         else if ( c != '\r' && c != ' ' && c != '\t' )
1231             x->state = STA_skip_header_lines_non_ws;
1232         break;
1233       case STA_skip_header_lines_non_ws:
1234         /* like above but we already encountered non white space */
1235         if ( c == '\n' )
1236             x->state = STA_skip_header_lines;
1237         break;
1238       case STA_read_data:
1239         /* fixme: we don't check for the trailing dash lines but rely
1240          * on the armor stop characters */
1241         if( c == '\n' || c == ' ' || c == '\r' || c == '\t' )
1242             break; /* skip all kind of white space */
1243
1244         if( c == '=' ) { /* pad character: stop */
1245             if( x->pos == 1 ) /* in this case val has some value */
1246                 rval = x->val;
1247             x->state = STA_wait_crc;
1248             break;
1249         }
1250
1251         {
1252             int c2;
1253             if( (c = asctobin[(c2=c)]) == 255 ) {
1254                 log_error(_("invalid radix64 character %02x skipped\n"), c2);
1255                 break;
1256             }
1257         }
1258         
1259         switch(x->pos) {
1260           case 0:
1261             x->val = c << 2;
1262             break;
1263           case 1:
1264             x->val |= (c>>4)&3;
1265             rval = x->val;
1266             x->val = (c<<4)&0xf0;
1267             break;
1268           case 2:
1269             x->val |= (c>>2)&15;
1270             rval = x->val;
1271             x->val = (c<<6)&0xc0;
1272             break;
1273           case 3:
1274             x->val |= c&0x3f;
1275             rval = x->val;
1276             break;
1277         }
1278         x->pos = (x->pos+1) % 4;
1279         break;
1280       case STA_wait_crc:
1281         if( c == '\n' || c == ' ' || c == '\r' || c == '\t' || c == '=' )
1282             break; /* skip ws and pad characters */
1283         /* assume that we are at the next line */
1284         x->state = STA_read_crc;
1285         x->pos = 0;
1286         x->mycrc = 0;
1287       case STA_read_crc:
1288         if( (c = asctobin[c]) == 255 ) {
1289             rval = -1; /* ready */
1290             if( x->crc != x->mycrc ) {
1291                 log_info (_("CRC error; %06lx - %06lx\n"),
1292                           (ulong)x->crc, (ulong)x->mycrc);
1293                 if ( invalid_crc() )
1294                     rval = -3;
1295             }
1296             x->state = STA_ready; /* not sure whether this is correct */
1297             break;
1298         }
1299         
1300         switch(x->pos) {
1301           case 0:
1302             x->val = c << 2;
1303             break;
1304           case 1:
1305             x->val |= (c>>4)&3;
1306             x->mycrc |= x->val << 16;
1307             x->val = (c<<4)&0xf0;
1308             break;
1309           case 2:
1310             x->val |= (c>>2)&15;
1311             x->mycrc |= x->val << 8;
1312             x->val = (c<<6)&0xc0;
1313             break;
1314           case 3:
1315             x->val |= c&0x3f;
1316             x->mycrc |= x->val;
1317             break;
1318         }
1319         x->pos = (x->pos+1) % 4;
1320         break;
1321       case STA_ready:
1322         rval = -1;
1323         break;
1324     }
1325
1326     if ( !(rval & ~255) ) { /* compute the CRC */
1327         x->crc = (x->crc << 8) ^ crc_table[((x->crc >> 16)&0xff) ^ rval];
1328         x->crc &= 0x00ffffff;
1329     }
1330
1331     return rval;
1332 }