* armor.c (parse_hash_header, armor_filter), g10.c (print_hex, print_mds),
[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
929             if( afx->what >= DIM(head_strings) )
930                 log_bug("afx->what=%d", afx->what);
931             iobuf_writestr(a, "-----");
932             iobuf_writestr(a, head_strings[afx->what] );
933             iobuf_writestr(a, "-----" LF );
934             if( !opt.no_version )
935                 iobuf_writestr(a, "Version: GnuPG v"  VERSION " ("
936                                               PRINTABLE_OS_NAME ")" LF );
937
938             /* write the comment string or a default one */
939             s = opt.comment_string;
940             if( s && *s ) {
941                 iobuf_writestr(a, "Comment: " );
942                 for( ; *s; s++ ) {
943                     if( *s == '\n' )
944                         iobuf_writestr(a, "\\n" );
945                     else if( *s == '\r' )
946                         iobuf_writestr(a, "\\r" );
947                     else if( *s == '\v' )
948                         iobuf_writestr(a, "\\v" );
949                     else
950                         iobuf_put(a, *s );
951                 }
952                 iobuf_writestr(a, LF );
953             }
954
955             if ( afx->hdrlines ) {
956                 for ( s = afx->hdrlines; *s; s++ ) {
957 #ifdef HAVE_DOSISH_SYSTEM
958                     if ( *s == '\n' )
959                         iobuf_put( a, '\r');
960 #endif
961                     iobuf_put(a, *s );
962                 }
963             }
964             iobuf_writestr(a, LF );
965             afx->status++;
966             afx->idx = 0;
967             afx->idx2 = 0;
968             afx->crc = CRCINIT;
969
970         }
971         crc = afx->crc;
972         idx = afx->idx;
973         idx2 = afx->idx2;
974         for(i=0; i < idx; i++ )
975             radbuf[i] = afx->radbuf[i];
976
977         for(i=0; i < size; i++ )
978             crc = (crc << 8) ^ crc_table[((crc >> 16)&0xff) ^ buf[i]];
979         crc &= 0x00ffffff;
980
981         for( ; size; buf++, size-- ) {
982             radbuf[idx++] = *buf;
983             if( idx > 2 ) {
984                 idx = 0;
985                 c = bintoasc[(*radbuf >> 2) & 077];
986                 iobuf_put(a, c);
987                 c = bintoasc[(((*radbuf<<4)&060)|((radbuf[1] >> 4)&017))&077];
988                 iobuf_put(a, c);
989                 c = bintoasc[(((radbuf[1]<<2)&074)|((radbuf[2]>>6)&03))&077];
990                 iobuf_put(a, c);
991                 c = bintoasc[radbuf[2]&077];
992                 iobuf_put(a, c);
993                 if( ++idx2 >= (64/4) ) { /* pgp doesn't like 72 here */
994                     iobuf_writestr(a, LF );
995                     idx2=0;
996                 }
997             }
998         }
999         for(i=0; i < idx; i++ )
1000             afx->radbuf[i] = radbuf[i];
1001         afx->idx = idx;
1002         afx->idx2 = idx2;
1003         afx->crc  = crc;
1004     }
1005     else if( control == IOBUFCTRL_INIT ) {
1006         if( !is_initialized )
1007             initialize();
1008     }
1009     else if( control == IOBUFCTRL_CANCEL ) {
1010         afx->cancel = 1;
1011     }
1012     else if( control == IOBUFCTRL_FREE ) {
1013         if( afx->cancel )
1014             ;
1015         else if( afx->status ) { /* pad, write cecksum, and bottom line */
1016             crc = afx->crc;
1017             idx = afx->idx;
1018             idx2 = afx->idx2;
1019             for(i=0; i < idx; i++ )
1020                 radbuf[i] = afx->radbuf[i];
1021             if( idx ) {
1022                 c = bintoasc[(*radbuf>>2)&077];
1023                 iobuf_put(a, c);
1024                 if( idx == 1 ) {
1025                     c = bintoasc[((*radbuf << 4) & 060) & 077];
1026                     iobuf_put(a, c);
1027                     iobuf_put(a, '=');
1028                     iobuf_put(a, '=');
1029                 }
1030                 else { /* 2 */
1031                     c = bintoasc[(((*radbuf<<4)&060)|((radbuf[1]>>4)&017))&077];
1032                     iobuf_put(a, c);
1033                     c = bintoasc[((radbuf[1] << 2) & 074) & 077];
1034                     iobuf_put(a, c);
1035                     iobuf_put(a, '=');
1036                 }
1037                 if( ++idx2 >= (64/4) ) { /* pgp doesn't like 72 here */
1038                     iobuf_writestr(a, LF );
1039                     idx2=0;
1040                 }
1041             }
1042             /* may need a linefeed */
1043             if( idx2 )
1044                 iobuf_writestr(a, LF );
1045             /* write the CRC */
1046             iobuf_put(a, '=');
1047             radbuf[0] = crc >>16;
1048             radbuf[1] = crc >> 8;
1049             radbuf[2] = crc;
1050             c = bintoasc[(*radbuf >> 2) & 077];
1051             iobuf_put(a, c);
1052             c = bintoasc[(((*radbuf<<4)&060)|((radbuf[1] >> 4)&017))&077];
1053             iobuf_put(a, c);
1054             c = bintoasc[(((radbuf[1]<<2)&074)|((radbuf[2]>>6)&03))&077];
1055             iobuf_put(a, c);
1056             c = bintoasc[radbuf[2]&077];
1057             iobuf_put(a, c);
1058             iobuf_writestr(a, LF );
1059             /* and the the trailer */
1060             if( afx->what >= DIM(tail_strings) )
1061                 log_bug("afx->what=%d", afx->what);
1062             iobuf_writestr(a, "-----");
1063             iobuf_writestr(a, tail_strings[afx->what] );
1064             iobuf_writestr(a, "-----" LF );
1065         }
1066         else if( !afx->any_data && !afx->inp_bypass ) {
1067             log_error(_("no valid OpenPGP data found.\n"));
1068             afx->no_openpgp_data = 1;
1069             write_status_text( STATUS_NODATA, "1" );
1070         }
1071         if( afx->truncated )
1072             log_info(_("invalid armor: line longer than %d characters\n"),
1073                       MAX_LINELEN );
1074         /* issue an error to enforce dissemination of correct software */
1075         if( afx->qp_detected )
1076             log_error(_("quoted printable character in armor - "
1077                         "probably a buggy MTA has been used\n") );
1078         m_free( afx->buffer );
1079         afx->buffer = NULL;
1080     }
1081     else if( control == IOBUFCTRL_DESC )
1082         *(char**)buf = "armor_filter";
1083     return rc;
1084 }
1085
1086
1087 /****************
1088  * create a radix64 encoded string.
1089  */
1090 char *
1091 make_radix64_string( const byte *data, size_t len )
1092 {
1093     char *buffer, *p;
1094
1095     buffer = p = m_alloc( (len+2)/3*4 + 1 );
1096     for( ; len >= 3 ; len -= 3, data += 3 ) {
1097         *p++ = bintoasc[(data[0] >> 2) & 077];
1098         *p++ = bintoasc[(((data[0] <<4)&060)|((data[1] >> 4)&017))&077];
1099         *p++ = bintoasc[(((data[1]<<2)&074)|((data[2]>>6)&03))&077];
1100         *p++ = bintoasc[data[2]&077];
1101     }
1102     if( len == 2 ) {
1103         *p++ = bintoasc[(data[0] >> 2) & 077];
1104         *p++ = bintoasc[(((data[0] <<4)&060)|((data[1] >> 4)&017))&077];
1105         *p++ = bintoasc[((data[1]<<2)&074)];
1106     }
1107     else if( len == 1 ) {
1108         *p++ = bintoasc[(data[0] >> 2) & 077];
1109         *p++ = bintoasc[(data[0] <<4)&060];
1110     }
1111     *p = 0;
1112     return buffer;
1113 }
1114
1115
1116 /***********************************************
1117  *  For the pipemode command we can't use the armor filter for various
1118  *  reasons, so we use this new unarmor_pump stuff to remove the armor 
1119  */
1120
1121 enum unarmor_state_e {
1122     STA_init = 0,
1123     STA_bypass,
1124     STA_wait_newline,
1125     STA_wait_dash,
1126     STA_first_dash, 
1127     STA_compare_header,
1128     STA_found_header_wait_newline,
1129     STA_skip_header_lines,
1130     STA_skip_header_lines_non_ws,
1131     STA_read_data,
1132     STA_wait_crc,
1133     STA_read_crc,
1134     STA_ready
1135 };
1136
1137 struct unarmor_pump_s {
1138     enum unarmor_state_e state;
1139     byte val;
1140     int checkcrc;
1141     int pos;   /* counts from 0..3 */
1142     u32 crc;
1143     u32 mycrc; /* the one store in the data */
1144 };
1145
1146
1147
1148 UnarmorPump
1149 unarmor_pump_new (void)
1150 {
1151     UnarmorPump x;
1152
1153     if( !is_initialized )
1154         initialize();
1155     x = m_alloc_clear (sizeof *x);
1156     return x;
1157 }
1158
1159 void
1160 unarmor_pump_release (UnarmorPump x)
1161 {
1162     m_free (x);
1163 }
1164
1165 /* 
1166  * Get the next character from the ascii armor taken from the IOBUF
1167  * created earlier by unarmor_pump_new().
1168  * Return:  c = Character
1169  *        256 = ignore this value
1170  *         -1 = End of current armor 
1171  *         -2 = Premature EOF (not used)
1172  *         -3 = Invalid armor
1173  */
1174 int
1175 unarmor_pump (UnarmorPump x, int c)
1176 {
1177     int rval = 256; /* default is to ignore the return value */
1178
1179     switch (x->state) {
1180       case STA_init:
1181         { 
1182             byte tmp[1];
1183             tmp[0] = c; 
1184             if ( is_armored (tmp) )
1185                 x->state = c == '-'? STA_first_dash : STA_wait_newline;
1186             else {
1187                 x->state = STA_bypass;
1188                 return c;
1189             }
1190         }
1191         break;
1192       case STA_bypass:
1193         return c; /* return here to avoid crc calculation */
1194       case STA_wait_newline:
1195         if (c == '\n')
1196             x->state = STA_wait_dash;
1197         break;
1198       case STA_wait_dash:
1199         x->state = c == '-'? STA_first_dash : STA_wait_newline;
1200         break;
1201       case STA_first_dash: /* just need for initalization */
1202         x->pos = 0;
1203         x->state = STA_compare_header;
1204       case STA_compare_header:
1205         if ( "-----BEGIN PGP SIGNATURE-----"[++x->pos] == c ) {
1206             if ( x->pos == 28 ) 
1207                 x->state = STA_found_header_wait_newline;
1208         }
1209         else 
1210             x->state = c == '\n'? STA_wait_dash : STA_wait_newline;
1211         break;
1212       case STA_found_header_wait_newline:
1213         /* to make CR,LF issues easier we simply allow for white space
1214            behind the 5 dashes */
1215         if ( c == '\n' )
1216             x->state = STA_skip_header_lines;
1217         else if ( c != '\r' && c != ' ' && c != '\t' )
1218             x->state = STA_wait_dash; /* garbage after the header line */
1219         break;
1220       case STA_skip_header_lines:
1221         /* i.e. wait for one empty line */
1222         if ( c == '\n' ) {
1223             x->state = STA_read_data;
1224             x->crc = CRCINIT;
1225             x->val = 0;
1226             x->pos = 0;
1227         }
1228         else if ( c != '\r' && c != ' ' && c != '\t' )
1229             x->state = STA_skip_header_lines_non_ws;
1230         break;
1231       case STA_skip_header_lines_non_ws:
1232         /* like above but we already encountered non white space */
1233         if ( c == '\n' )
1234             x->state = STA_skip_header_lines;
1235         break;
1236       case STA_read_data:
1237         /* fixme: we don't check for the trailing dash lines but rely
1238          * on the armor stop characters */
1239         if( c == '\n' || c == ' ' || c == '\r' || c == '\t' )
1240             break; /* skip all kind of white space */
1241
1242         if( c == '=' ) { /* pad character: stop */
1243             if( x->pos == 1 ) /* in this case val has some value */
1244                 rval = x->val;
1245             x->state = STA_wait_crc;
1246             break;
1247         }
1248
1249         {
1250             int c2;
1251             if( (c = asctobin[(c2=c)]) == 255 ) {
1252                 log_error(_("invalid radix64 character %02x skipped\n"), c2);
1253                 break;
1254             }
1255         }
1256         
1257         switch(x->pos) {
1258           case 0:
1259             x->val = c << 2;
1260             break;
1261           case 1:
1262             x->val |= (c>>4)&3;
1263             rval = x->val;
1264             x->val = (c<<4)&0xf0;
1265             break;
1266           case 2:
1267             x->val |= (c>>2)&15;
1268             rval = x->val;
1269             x->val = (c<<6)&0xc0;
1270             break;
1271           case 3:
1272             x->val |= c&0x3f;
1273             rval = x->val;
1274             break;
1275         }
1276         x->pos = (x->pos+1) % 4;
1277         break;
1278       case STA_wait_crc:
1279         if( c == '\n' || c == ' ' || c == '\r' || c == '\t' || c == '=' )
1280             break; /* skip ws and pad characters */
1281         /* assume that we are at the next line */
1282         x->state = STA_read_crc;
1283         x->pos = 0;
1284         x->mycrc = 0;
1285       case STA_read_crc:
1286         if( (c = asctobin[c]) == 255 ) {
1287             rval = -1; /* ready */
1288             if( x->crc != x->mycrc ) {
1289                 log_info (_("CRC error; %06lx - %06lx\n"),
1290                           (ulong)x->crc, (ulong)x->mycrc);
1291                 if ( invalid_crc() )
1292                     rval = -3;
1293             }
1294             x->state = STA_ready; /* not sure whether this is correct */
1295             break;
1296         }
1297         
1298         switch(x->pos) {
1299           case 0:
1300             x->val = c << 2;
1301             break;
1302           case 1:
1303             x->val |= (c>>4)&3;
1304             x->mycrc |= x->val << 16;
1305             x->val = (c<<4)&0xf0;
1306             break;
1307           case 2:
1308             x->val |= (c>>2)&15;
1309             x->mycrc |= x->val << 8;
1310             x->val = (c<<6)&0xc0;
1311             break;
1312           case 3:
1313             x->val |= c&0x3f;
1314             x->mycrc |= x->val;
1315             break;
1316         }
1317         x->pos = (x->pos+1) % 4;
1318         break;
1319       case STA_ready:
1320         rval = -1;
1321         break;
1322     }
1323
1324     if ( !(rval & ~255) ) { /* compute the CRC */
1325         x->crc = (x->crc << 8) ^ crc_table[((x->crc >> 16)&0xff) ^ rval];
1326         x->crc &= 0x00ffffff;
1327     }
1328
1329     return rval;
1330 }