* armor.c (parse_hash_header, armor_filter): Accept the new SHAs in the
[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, "TIGER192", s2-s ) )
252             found |= 8;
253         else if( !strncmp( s, "TIGER", s2-s ) ) /* used by old versions */
254             found |= 8;
255         else if( !strncmp( s, "SHA256", s2-s ) )
256             found |= 16;
257         else if( !strncmp( s, "SHA384", s2-s ) )
258             found |= 32;
259         else if( !strncmp( s, "SHA512", s2-s ) )
260             found |= 64;
261         else
262             return 0;
263         for(; *s2 && (*s2==' ' || *s2 == '\t'); s2++ )
264             ;
265         if( *s2 && *s2 != ',' )
266             return 0;
267         if( *s2 )
268             s2++;
269     }
270     return found;
271 }
272
273
274
275 /****************
276  * Check whether this is a armor line.
277  * returns: -1 if it is not a armor header or the index number of the
278  * armor header.
279  */
280 static int
281 is_armor_header( byte *line, unsigned len )
282 {
283     const char *s;
284     byte *save_p, *p;
285     int save_c;
286     int i;
287
288     if( len < 15 )
289         return -1; /* too short */
290     if( memcmp( line, "-----", 5 ) )
291         return -1; /* no */
292     p = strstr( line+5, "-----");
293     if( !p )
294         return -1;
295     save_p = p;
296     p += 5;
297
298     /* Some mail programs on Windows seem to add spaces to the end of
299        the line.  This becomes strict if --openpgp is set. */
300
301     if(!opt.rfc2440)
302       while(*p==' ')
303         p++;
304
305     if( *p == '\r' )
306         p++;
307     if( *p == '\n' )
308         p++;
309     if( *p )
310         return -1; /* garbage after dashes */
311     save_c = *save_p; *save_p = 0;
312     p = line+5;
313     for(i=0; (s=head_strings[i]); i++ )
314         if( !strcmp(s, p) )
315             break;
316     *save_p = save_c;
317     if( !s )
318         return -1; /* unknown armor line */
319
320     if( opt.verbose > 1 )
321         log_info(_("armor: %s\n"), head_strings[i]);
322     return i;
323 }
324
325
326
327 /****************
328  * Parse a header lines
329  * Return 0: Empty line (end of header lines)
330  *       -1: invalid header line
331  *       >0: Good header line
332  */
333 static int
334 parse_header_line( armor_filter_context_t *afx, byte *line, unsigned int len )
335 {
336     byte *p;
337     int hashes=0;
338     unsigned int len2;
339
340     len2 = check_trailing_ws( line, len );
341     if( !len2 ) {
342         afx->buffer_pos = len2;  /* (it is not the fine way to do it here) */
343         return 0; /* WS only: same as empty line */
344     }
345     len = len2;
346     line[len2] = 0;
347
348     p = strchr( line, ':');
349     if( !p || !p[1] ) {
350         log_error(_("invalid armor header: "));
351         print_string( stderr, line, len, 0 );
352         putc('\n', stderr);
353         return -1;
354     }
355
356     if( opt.verbose ) {
357         log_info(_("armor header: "));
358         print_string( stderr, line, len, 0 );
359         putc('\n', stderr);
360     }
361
362     if( afx->in_cleartext ) {
363         if( (hashes=parse_hash_header( line )) )
364             afx->hashes |= hashes;
365         else if( strlen(line) > 15 && !memcmp( line, "NotDashEscaped:", 15 ) )
366             afx->not_dash_escaped = 1;
367         else {
368             log_error(_("invalid clearsig header\n"));
369             return -1;
370         }
371     }
372     return 1;
373 }
374
375
376
377 /* figure out whether the data is armored or not */
378 static int
379 check_input( armor_filter_context_t *afx, IOBUF a )
380 {
381     int rc = 0;
382     int i;
383     byte *line;
384     unsigned len;
385     unsigned maxlen;
386     int hdr_line = -1;
387
388     /* read the first line to see whether this is armored data */
389     maxlen = MAX_LINELEN;
390     len = afx->buffer_len = iobuf_read_line( a, &afx->buffer,
391                                              &afx->buffer_size, &maxlen );
392     line = afx->buffer;
393     if( !maxlen ) {
394         /* line has been truncated: assume not armored */
395         afx->inp_checked = 1;
396         afx->inp_bypass = 1;
397         return 0;
398     }
399
400     if( !len ) {
401         return -1; /* eof */
402     }
403
404     /* (the line is always a C string but maybe longer) */
405     if( *line == '\n' || ( len && (*line == '\r' && line[1]=='\n') ) )
406         ;
407     else if( !is_armored( line ) ) {
408         afx->inp_checked = 1;
409         afx->inp_bypass = 1;
410         return 0;
411     }
412
413     /* find the armor header */
414     while(len) {
415         i = is_armor_header( line, len );
416         if( i >= 0 && !(afx->only_keyblocks && i != 1 && i != 5 && i != 6 )) {
417             hdr_line = i;
418             if( hdr_line == BEGIN_SIGNED_MSG_IDX ) {
419                 if( afx->in_cleartext ) {
420                     log_error(_("nested clear text signatures\n"));
421                     rc = G10ERR_INVALID_ARMOR;
422                 }
423                 afx->in_cleartext = 1;
424             }
425             break;
426         }
427         /* read the next line (skip all truncated lines) */
428         do {
429             maxlen = MAX_LINELEN;
430             afx->buffer_len = iobuf_read_line( a, &afx->buffer,
431                                                &afx->buffer_size, &maxlen );
432             line = afx->buffer;
433             len = afx->buffer_len;
434         } while( !maxlen );
435     }
436
437     /* parse the header lines */
438     while(len) {
439         /* read the next line (skip all truncated lines) */
440         do {
441             maxlen = MAX_LINELEN;
442             afx->buffer_len = iobuf_read_line( a, &afx->buffer,
443                                                &afx->buffer_size, &maxlen );
444             line = afx->buffer;
445             len = afx->buffer_len;
446         } while( !maxlen );
447
448         i = parse_header_line( afx, line, len );
449         if( i <= 0 ) {
450             if( i )
451                 rc = G10ERR_INVALID_ARMOR;
452             break;
453         }
454     }
455
456
457     if( rc )
458         invalid_armor();
459     else if( afx->in_cleartext )
460         afx->faked = 1;
461     else {
462         afx->inp_checked = 1;
463         afx->crc = CRCINIT;
464         afx->idx = 0;
465         afx->radbuf[0] = 0;
466     }
467
468     return rc;
469 }
470
471
472
473 /****************
474  * Fake a literal data packet and wait for the next armor line
475  * fixme: empty line handling and null length clear text signature are
476  *        not implemented/checked.
477  */
478 static int
479 fake_packet( armor_filter_context_t *afx, IOBUF a,
480              size_t *retn, byte *buf, size_t size  )
481 {
482     int rc = 0;
483     size_t len = 0;
484     int lastline = 0;
485     unsigned maxlen, n;
486     byte *p;
487
488     len = 2;    /* reserve 2 bytes for the length header */
489     size -= 2;  /* and 2 for the terminating header */
490     while( !rc && len < size ) {
491         /* copy what we have in the line buffer */
492         if( afx->faked == 1 )
493             afx->faked++; /* skip the first (empty) line */
494         else {
495             while( len < size && afx->buffer_pos < afx->buffer_len )
496                 buf[len++] = afx->buffer[afx->buffer_pos++];
497             if( len >= size )
498                 continue;
499         }
500
501         /* read the next line */
502         maxlen = MAX_LINELEN;
503         afx->buffer_pos = 0;
504         afx->buffer_len = iobuf_read_line( a, &afx->buffer,
505                                            &afx->buffer_size, &maxlen );
506         if( !afx->buffer_len ) {
507             rc = -1; /* eof (should not happen) */
508             continue;
509         }
510         if( !maxlen )
511             afx->truncated++;
512         if( !afx->not_dash_escaped ) {
513             int crlf;
514             p = afx->buffer;
515             n = afx->buffer_len;
516             crlf = n > 1 && p[n-2] == '\r' && p[n-1]=='\n';
517
518             /* PGP2 does not treat a tab as white space character */
519             afx->buffer_len = trim_trailing_chars( p, n,
520                                          afx->pgp2mode ? " \r\n" : " \t\r\n");
521             /* the buffer is always allocated with enough space to append
522              * the removed [CR], LF and a Nul
523              * The reason for this complicated procedure is to keep at least
524              * the original type of lineending - handling of the removed
525              * trailing spaces seems to be impossible in our method
526              * of faking a packet; either we have to use a temporary file
527              * or calculate the hash here in this module and somehow find
528              * a way to send the hash down the processing line (well, a special
529              * faked packet could do the job).
530              */
531             if( crlf )
532                 afx->buffer[afx->buffer_len++] = '\r';
533             afx->buffer[afx->buffer_len++] = '\n';
534             afx->buffer[afx->buffer_len] = 0;
535         }
536         p = afx->buffer;
537         n = afx->buffer_len;
538
539         if( n > 2 && *p == '-' ) {
540             /* check for dash escaped or armor header */
541             if( p[1] == ' ' && !afx->not_dash_escaped ) {
542                 /* issue a warning if it is not regular encoded */
543                 if( p[2] != '-' && !( n > 6 && !memcmp(p+2, "From ", 5))) {
544                     log_info(_("invalid dash escaped line: "));
545                     print_string( stderr, p, n, 0 );
546                     putc('\n', stderr);
547                 }
548                 afx->buffer_pos = 2; /* skip */
549             }
550             else if( n >= 15 &&  p[1] == '-' && p[2] == '-' && p[3] == '-' ) {
551                 int type = is_armor_header( p, n );
552                 if( afx->not_dash_escaped && type != BEGIN_SIGNATURE )
553                     ; /* this is okay */
554                 else {
555                     if( type != BEGIN_SIGNATURE ) {
556                         log_info(_("unexpected armor:"));
557                         print_string( stderr, p, n, 0 );
558                         putc('\n', stderr);
559                     }
560                     lastline = 1;
561                     rc = -1;
562                 }
563             }
564         }
565     }
566
567     buf[0] = (len-2) >> 8;
568     buf[1] = (len-2);
569     if( lastline ) { /* write last (ending) length header */
570         if( buf[0] || buf[1] ) { /* only if we have some text */
571             buf[len++] = 0;
572             buf[len++] = 0;
573         }
574         rc = 0;
575         afx->faked = 0;
576         afx->in_cleartext = 0;
577         /* and now read the header lines */
578         afx->buffer_pos = 0;
579         for(;;) {
580             int i;
581
582             /* read the next line (skip all truncated lines) */
583             do {
584                 maxlen = MAX_LINELEN;
585                 afx->buffer_len = iobuf_read_line( a, &afx->buffer,
586                                                  &afx->buffer_size, &maxlen );
587             } while( !maxlen );
588             p = afx->buffer;
589             n = afx->buffer_len;
590             if( !n ) {
591                 rc = -1;
592                 break; /* eof */
593             }
594             i = parse_header_line( afx, p , n );
595             if( i <= 0 ) {
596                 if( i )
597                     invalid_armor();
598                 break;
599             }
600         }
601         afx->inp_checked = 1;
602         afx->crc = CRCINIT;
603         afx->idx = 0;
604         afx->radbuf[0] = 0;
605     }
606
607     *retn = len;
608     return rc;
609 }
610
611
612 static int
613 invalid_crc(void)
614 {
615     if ( opt.ignore_crc_error )
616         return 0;
617     log_inc_errorcount();
618     return G10ERR_INVALID_ARMOR;
619 }
620
621
622 static int
623 radix64_read( armor_filter_context_t *afx, IOBUF a, size_t *retn,
624               byte *buf, size_t size )
625 {
626     byte val;
627     int c=0, c2; /*init c because gcc is not clever enough for the continue*/
628     int checkcrc=0;
629     int rc = 0;
630     size_t n = 0;
631     int  idx, i;
632     u32 crc;
633
634     crc = afx->crc;
635     idx = afx->idx;
636     val = afx->radbuf[0];
637     for( n=0; n < size; ) {
638
639         if( afx->buffer_pos < afx->buffer_len )
640             c = afx->buffer[afx->buffer_pos++];
641         else { /* read the next line */
642             unsigned maxlen = MAX_LINELEN;
643             afx->buffer_pos = 0;
644             afx->buffer_len = iobuf_read_line( a, &afx->buffer,
645                                                &afx->buffer_size, &maxlen );
646             if( !maxlen )
647                 afx->truncated++;
648             if( !afx->buffer_len )
649                 break; /* eof */
650             continue;
651         }
652
653       again:
654         if( c == '\n' || c == ' ' || c == '\r' || c == '\t' )
655             continue;
656         else if( c == '=' ) { /* pad character: stop */
657             /* some mailers leave quoted-printable encoded characters
658              * so we try to workaround this */
659             if( afx->buffer_pos+2 < afx->buffer_len ) {
660                 int cc1, cc2, cc3;
661                 cc1 = afx->buffer[afx->buffer_pos];
662                 cc2 = afx->buffer[afx->buffer_pos+1];
663                 cc3 = afx->buffer[afx->buffer_pos+2];
664                 if( isxdigit(cc1) && isxdigit(cc2)
665                                   && strchr( "=\n\r\t ", cc3 )) {
666                     /* well it seems to be the case - adjust */
667                     c = isdigit(cc1)? (cc1 - '0'): (ascii_toupper(cc1)-'A'+10);
668                     c <<= 4;
669                     c |= isdigit(cc2)? (cc2 - '0'): (ascii_toupper(cc2)-'A'+10);
670                     afx->buffer_pos += 2;
671                     afx->qp_detected = 1;
672                     goto again;
673                 }
674             }
675
676             if( idx == 1 )
677                 buf[n++] = val;
678             checkcrc++;
679             break;
680         }
681         else if( (c = asctobin[(c2=c)]) == 255 ) {
682             log_error(_("invalid radix64 character %02x skipped\n"), c2);
683             continue;
684         }
685         switch(idx) {
686           case 0: val =  c << 2; break;
687           case 1: val |= (c>>4)&3; buf[n++]=val;val=(c<<4)&0xf0;break;
688           case 2: val |= (c>>2)&15; buf[n++]=val;val=(c<<6)&0xc0;break;
689           case 3: val |= c&0x3f; buf[n++] = val; break;
690         }
691         idx = (idx+1) % 4;
692     }
693
694     for(i=0; i < n; i++ )
695         crc = (crc << 8) ^ crc_table[((crc >> 16)&0xff) ^ buf[i]];
696     crc &= 0x00ffffff;
697     afx->crc = crc;
698     afx->idx = idx;
699     afx->radbuf[0] = val;
700
701     if( checkcrc ) {
702         afx->any_data = 1;
703         afx->inp_checked=0;
704         afx->faked = 0;
705         for(;;) { /* skip lf and pad characters */
706             if( afx->buffer_pos < afx->buffer_len )
707                 c = afx->buffer[afx->buffer_pos++];
708             else { /* read the next line */
709                 unsigned maxlen = MAX_LINELEN;
710                 afx->buffer_pos = 0;
711                 afx->buffer_len = iobuf_read_line( a, &afx->buffer,
712                                                    &afx->buffer_size, &maxlen );
713                 if( !maxlen )
714                     afx->truncated++;
715                 if( !afx->buffer_len )
716                     break; /* eof */
717                 continue;
718             }
719             if( c == '\n' || c == ' ' || c == '\r'
720                 || c == '\t' || c == '=' )
721                 continue;
722             break;
723         }
724         if( c == -1 )
725             log_error(_("premature eof (no CRC)\n"));
726         else {
727             u32 mycrc = 0;
728             idx = 0;
729             do {
730                 if( (c = asctobin[c]) == 255 )
731                     break;
732                 switch(idx) {
733                   case 0: val =  c << 2; break;
734                   case 1: val |= (c>>4)&3; mycrc |= val << 16;val=(c<<4)&0xf0;break;
735                   case 2: val |= (c>>2)&15; mycrc |= val << 8;val=(c<<6)&0xc0;break;
736                   case 3: val |= c&0x3f; mycrc |= val; break;
737                 }
738                 for(;;) {
739                     if( afx->buffer_pos < afx->buffer_len )
740                         c = afx->buffer[afx->buffer_pos++];
741                     else { /* read the next line */
742                         unsigned maxlen = MAX_LINELEN;
743                         afx->buffer_pos = 0;
744                         afx->buffer_len = iobuf_read_line( a, &afx->buffer,
745                                                            &afx->buffer_size,
746                                                                 &maxlen );
747                         if( !maxlen )
748                             afx->truncated++;
749                         if( !afx->buffer_len )
750                             break; /* eof */
751                         continue;
752                     }
753                     break;
754                 }
755                 if( !afx->buffer_len )
756                     break; /* eof */
757             } while( ++idx < 4 );
758             if( c == -1 ) {
759                 log_info(_("premature eof (in CRC)\n"));
760                 rc = invalid_crc();
761                             }
762             else if( idx != 4 ) {
763                 log_info(_("malformed CRC\n"));
764                 rc = invalid_crc();
765             }
766             else if( mycrc != afx->crc ) {
767                 log_info (_("CRC error; %06lx - %06lx\n"),
768                                     (ulong)afx->crc, (ulong)mycrc);
769                 rc = invalid_crc();
770             }
771             else {
772                 rc = 0;
773                 /* FIXME: Here we should emit another control packet,
774                  * so that we know in mainproc that we are processing
775                  * a clearsign message */
776               #if 0
777                 for(rc=0;!rc;) {
778                     rc = 0 /*check_trailer( &fhdr, c )*/;
779                     if( !rc ) {
780                         if( (c=iobuf_get(a)) == -1 )
781                             rc = 2;
782                     }
783                 }
784                 if( rc == -1 )
785                     rc = 0;
786                 else if( rc == 2 ) {
787                     log_error(_("premature eof (in Trailer)\n"));
788                     rc = G10ERR_INVALID_ARMOR;
789                 }
790                 else {
791                     log_error(_("error in trailer line\n"));
792                     rc = G10ERR_INVALID_ARMOR;
793                 }
794               #endif
795             }
796         }
797     }
798
799     if( !n )
800         rc = -1;
801
802     *retn = n;
803     return rc;
804 }
805
806 /****************
807  * This filter is used to handle the armor stuff
808  */
809 int
810 armor_filter( void *opaque, int control,
811              IOBUF a, byte *buf, size_t *ret_len)
812 {
813     size_t size = *ret_len;
814     armor_filter_context_t *afx = opaque;
815     int rc=0, i, c;
816     byte radbuf[3];
817     int  idx, idx2;
818     size_t n=0;
819     u32 crc;
820   #if 0
821     static FILE *fp ;
822
823     if( !fp ) {
824         fp = fopen("armor.out", "w");
825         assert(fp);
826     }
827   #endif
828
829     if( DBG_FILTER )
830         log_debug("armor-filter: control: %d\n", control );
831     if( control == IOBUFCTRL_UNDERFLOW && afx->inp_bypass ) {
832         n = 0;
833         if( afx->buffer_len ) {
834             for(; n < size && afx->buffer_pos < afx->buffer_len; n++ )
835                 buf[n++] = afx->buffer[afx->buffer_pos++];
836             if( afx->buffer_pos >= afx->buffer_len )
837                 afx->buffer_len = 0;
838         }
839         for(; n < size; n++ ) {
840             if( (c=iobuf_get(a)) == -1 )
841                 break;
842             buf[n] = c & 0xff;
843         }
844         if( !n )
845             rc = -1;
846         *ret_len = n;
847     }
848     else if( control == IOBUFCTRL_UNDERFLOW ) {
849         /* We need some space for the faked packet.  The minmum required
850          * size is ~18 + length of the session marker */
851         if( size < 50 ) 
852             BUG(); /* supplied buffer too short */
853
854         if( afx->faked )
855             rc = fake_packet( afx, a, &n, buf, size );
856         else if( !afx->inp_checked ) {
857             rc = check_input( afx, a );
858             if( afx->inp_bypass ) {
859                 for(n=0; n < size && afx->buffer_pos < afx->buffer_len; )
860                     buf[n++] = afx->buffer[afx->buffer_pos++];
861                 if( afx->buffer_pos >= afx->buffer_len )
862                     afx->buffer_len = 0;
863                 if( !n )
864                     rc = -1;
865             }
866             else if( afx->faked ) {
867                 unsigned int hashes = afx->hashes;
868                 const byte *sesmark;
869                 size_t sesmarklen;
870                 
871                 sesmark = get_session_marker( &sesmarklen );
872                 if ( sesmarklen > 20 )
873                     BUG();
874
875                 /* the buffer is at least 15+n*15 bytes long, so it
876                  * is easy to construct the packets */
877
878                 hashes &= 1|2|4|8|16|32|64;
879                 if( !hashes ) {
880                     hashes |= 4;  /* default to MD 5 */
881                     /* This is non-ideal since PGP 5-8 have the same
882                        end-of-line bugs as PGP 2. However, we only
883                        enable pgp2mode if there is no Hash: header. */
884                     if( opt.pgp2_workarounds )
885                         afx->pgp2mode = 1;
886                 }
887                 n=0;
888                 /* first a gpg control packet */
889                 buf[n++] = 0xff; /* new format, type 63, 1 length byte */
890                 n++;   /* see below */
891                 memcpy(buf+n, sesmark, sesmarklen ); n+= sesmarklen;
892                 buf[n++] = CTRLPKT_CLEARSIGN_START; 
893                 buf[n++] = afx->not_dash_escaped? 0:1; /* sigclass */
894                 if( hashes & 1 )
895                     buf[n++] = DIGEST_ALGO_RMD160;
896                 if( hashes & 2 )
897                     buf[n++] = DIGEST_ALGO_SHA1;
898                 if( hashes & 4 )
899                     buf[n++] = DIGEST_ALGO_MD5;
900                 if( hashes & 8 )
901                     buf[n++] = DIGEST_ALGO_TIGER;
902                 if( hashes & 16 )
903                     buf[n++] = DIGEST_ALGO_SHA256;
904                 if( hashes & 32 )
905                     buf[n++] = DIGEST_ALGO_SHA384;
906                 if( hashes & 64 )
907                     buf[n++] = DIGEST_ALGO_SHA512;
908                 buf[1] = n - 2;
909
910                 /* followed by a plaintext packet */
911                 buf[n++] = 0xaf; /* old packet format, type 11, var length */
912                 buf[n++] = 0;    /* set the length header */
913                 buf[n++] = 6;
914                 buf[n++] = 't';  /* canonical text mode */
915                 buf[n++] = 0;    /* namelength */
916                 memset(buf+n, 0, 4); /* timestamp */
917                 n += 4;
918             }
919             else if( !rc )
920                 rc = radix64_read( afx, a, &n, buf, size );
921         }
922         else
923             rc = radix64_read( afx, a, &n, buf, size );
924       #if 0
925         if( n )
926             if( fwrite(buf, n, 1, fp ) != 1 )
927                 BUG();
928       #endif
929         *ret_len = n;
930     }
931     else if( control == IOBUFCTRL_FLUSH && !afx->cancel ) {
932         if( !afx->status ) { /* write the header line */
933             const char *s;
934
935             if( afx->what >= DIM(head_strings) )
936                 log_bug("afx->what=%d", afx->what);
937             iobuf_writestr(a, "-----");
938             iobuf_writestr(a, head_strings[afx->what] );
939             iobuf_writestr(a, "-----" LF );
940             if( !opt.no_version )
941                 iobuf_writestr(a, "Version: GnuPG v"  VERSION " ("
942                                               PRINTABLE_OS_NAME ")" LF );
943
944             /* write the comment string or a default one */
945             s = opt.comment_string;
946             if( s && *s ) {
947                 iobuf_writestr(a, "Comment: " );
948                 for( ; *s; s++ ) {
949                     if( *s == '\n' )
950                         iobuf_writestr(a, "\\n" );
951                     else if( *s == '\r' )
952                         iobuf_writestr(a, "\\r" );
953                     else if( *s == '\v' )
954                         iobuf_writestr(a, "\\v" );
955                     else
956                         iobuf_put(a, *s );
957                 }
958                 iobuf_writestr(a, LF );
959             }
960
961             if ( afx->hdrlines ) {
962                 for ( s = afx->hdrlines; *s; s++ ) {
963                   #ifdef HAVE_DOSISH_SYSTEM
964                     if ( *s == '\n' )
965                         iobuf_put( a, '\r');
966                   #endif
967                     iobuf_put(a, *s );
968                 }
969             }
970             iobuf_writestr(a, LF );
971             afx->status++;
972             afx->idx = 0;
973             afx->idx2 = 0;
974             afx->crc = CRCINIT;
975
976         }
977         crc = afx->crc;
978         idx = afx->idx;
979         idx2 = afx->idx2;
980         for(i=0; i < idx; i++ )
981             radbuf[i] = afx->radbuf[i];
982
983         for(i=0; i < size; i++ )
984             crc = (crc << 8) ^ crc_table[((crc >> 16)&0xff) ^ buf[i]];
985         crc &= 0x00ffffff;
986
987         for( ; size; buf++, size-- ) {
988             radbuf[idx++] = *buf;
989             if( idx > 2 ) {
990                 idx = 0;
991                 c = bintoasc[(*radbuf >> 2) & 077];
992                 iobuf_put(a, c);
993                 c = bintoasc[(((*radbuf<<4)&060)|((radbuf[1] >> 4)&017))&077];
994                 iobuf_put(a, c);
995                 c = bintoasc[(((radbuf[1]<<2)&074)|((radbuf[2]>>6)&03))&077];
996                 iobuf_put(a, c);
997                 c = bintoasc[radbuf[2]&077];
998                 iobuf_put(a, c);
999                 if( ++idx2 >= (64/4) ) { /* pgp doesn't like 72 here */
1000                     iobuf_writestr(a, LF );
1001                     idx2=0;
1002                 }
1003             }
1004         }
1005         for(i=0; i < idx; i++ )
1006             afx->radbuf[i] = radbuf[i];
1007         afx->idx = idx;
1008         afx->idx2 = idx2;
1009         afx->crc  = crc;
1010     }
1011     else if( control == IOBUFCTRL_INIT ) {
1012         if( !is_initialized )
1013             initialize();
1014     }
1015     else if( control == IOBUFCTRL_CANCEL ) {
1016         afx->cancel = 1;
1017     }
1018     else if( control == IOBUFCTRL_FREE ) {
1019         if( afx->cancel )
1020             ;
1021         else if( afx->status ) { /* pad, write cecksum, and bottom line */
1022             crc = afx->crc;
1023             idx = afx->idx;
1024             idx2 = afx->idx2;
1025             for(i=0; i < idx; i++ )
1026                 radbuf[i] = afx->radbuf[i];
1027             if( idx ) {
1028                 c = bintoasc[(*radbuf>>2)&077];
1029                 iobuf_put(a, c);
1030                 if( idx == 1 ) {
1031                     c = bintoasc[((*radbuf << 4) & 060) & 077];
1032                     iobuf_put(a, c);
1033                     iobuf_put(a, '=');
1034                     iobuf_put(a, '=');
1035                 }
1036                 else { /* 2 */
1037                     c = bintoasc[(((*radbuf<<4)&060)|((radbuf[1]>>4)&017))&077];
1038                     iobuf_put(a, c);
1039                     c = bintoasc[((radbuf[1] << 2) & 074) & 077];
1040                     iobuf_put(a, c);
1041                     iobuf_put(a, '=');
1042                 }
1043                 if( ++idx2 >= (64/4) ) { /* pgp doesn't like 72 here */
1044                     iobuf_writestr(a, LF );
1045                     idx2=0;
1046                 }
1047             }
1048             /* may need a linefeed */
1049             if( idx2 )
1050                 iobuf_writestr(a, LF );
1051             /* write the CRC */
1052             iobuf_put(a, '=');
1053             radbuf[0] = crc >>16;
1054             radbuf[1] = crc >> 8;
1055             radbuf[2] = crc;
1056             c = bintoasc[(*radbuf >> 2) & 077];
1057             iobuf_put(a, c);
1058             c = bintoasc[(((*radbuf<<4)&060)|((radbuf[1] >> 4)&017))&077];
1059             iobuf_put(a, c);
1060             c = bintoasc[(((radbuf[1]<<2)&074)|((radbuf[2]>>6)&03))&077];
1061             iobuf_put(a, c);
1062             c = bintoasc[radbuf[2]&077];
1063             iobuf_put(a, c);
1064             iobuf_writestr(a, LF );
1065             /* and the the trailer */
1066             if( afx->what >= DIM(tail_strings) )
1067                 log_bug("afx->what=%d", afx->what);
1068             iobuf_writestr(a, "-----");
1069             iobuf_writestr(a, tail_strings[afx->what] );
1070             iobuf_writestr(a, "-----" LF );
1071         }
1072         else if( !afx->any_data && !afx->inp_bypass ) {
1073             log_error(_("no valid OpenPGP data found.\n"));
1074             afx->no_openpgp_data = 1;
1075             write_status_text( STATUS_NODATA, "1" );
1076         }
1077         if( afx->truncated )
1078             log_info(_("invalid armor: line longer than %d characters\n"),
1079                       MAX_LINELEN );
1080         /* issue an error to enforce dissemination of correct software */
1081         if( afx->qp_detected )
1082             log_error(_("quoted printable character in armor - "
1083                         "probably a buggy MTA has been used\n") );
1084         m_free( afx->buffer );
1085         afx->buffer = NULL;
1086     }
1087     else if( control == IOBUFCTRL_DESC )
1088         *(char**)buf = "armor_filter";
1089     return rc;
1090 }
1091
1092
1093 /****************
1094  * create a radix64 encoded string.
1095  */
1096 char *
1097 make_radix64_string( const byte *data, size_t len )
1098 {
1099     char *buffer, *p;
1100
1101     buffer = p = m_alloc( (len+2)/3*4 + 1 );
1102     for( ; len >= 3 ; len -= 3, data += 3 ) {
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)|((data[2]>>6)&03))&077];
1106         *p++ = bintoasc[data[2]&077];
1107     }
1108     if( len == 2 ) {
1109         *p++ = bintoasc[(data[0] >> 2) & 077];
1110         *p++ = bintoasc[(((data[0] <<4)&060)|((data[1] >> 4)&017))&077];
1111         *p++ = bintoasc[((data[1]<<2)&074)];
1112     }
1113     else if( len == 1 ) {
1114         *p++ = bintoasc[(data[0] >> 2) & 077];
1115         *p++ = bintoasc[(data[0] <<4)&060];
1116     }
1117     *p = 0;
1118     return buffer;
1119 }
1120
1121
1122 /***********************************************
1123  *  For the pipemode command we can't use the armor filter for various
1124  *  reasons, so we use this new unarmor_pump stuff to remove the armor 
1125  */
1126
1127 enum unarmor_state_e {
1128     STA_init = 0,
1129     STA_bypass,
1130     STA_wait_newline,
1131     STA_wait_dash,
1132     STA_first_dash, 
1133     STA_compare_header,
1134     STA_found_header_wait_newline,
1135     STA_skip_header_lines,
1136     STA_skip_header_lines_non_ws,
1137     STA_read_data,
1138     STA_wait_crc,
1139     STA_read_crc,
1140     STA_ready
1141 };
1142
1143 struct unarmor_pump_s {
1144     enum unarmor_state_e state;
1145     byte val;
1146     int checkcrc;
1147     int pos;   /* counts from 0..3 */
1148     u32 crc;
1149     u32 mycrc; /* the one store in the data */
1150 };
1151
1152
1153
1154 UnarmorPump
1155 unarmor_pump_new (void)
1156 {
1157     UnarmorPump x;
1158
1159     if( !is_initialized )
1160         initialize();
1161     x = m_alloc_clear (sizeof *x);
1162     return x;
1163 }
1164
1165 void
1166 unarmor_pump_release (UnarmorPump x)
1167 {
1168     m_free (x);
1169 }
1170
1171 /* 
1172  * Get the next character from the ascii armor taken from the IOBUF
1173  * created earlier by unarmor_pump_new().
1174  * Return:  c = Character
1175  *        256 = ignore this value
1176  *         -1 = End of current armor 
1177  *         -2 = Premature EOF (not used)
1178  *         -3 = Invalid armor
1179  */
1180 int
1181 unarmor_pump (UnarmorPump x, int c)
1182 {
1183     int rval = 256; /* default is to ignore the return value */
1184
1185     switch (x->state) {
1186       case STA_init:
1187         { 
1188             byte tmp[1];
1189             tmp[0] = c; 
1190             if ( is_armored (tmp) )
1191                 x->state = c == '-'? STA_first_dash : STA_wait_newline;
1192             else {
1193                 x->state = STA_bypass;
1194                 return c;
1195             }
1196         }
1197         break;
1198       case STA_bypass:
1199         return c; /* return here to avoid crc calculation */
1200       case STA_wait_newline:
1201         if (c == '\n')
1202             x->state = STA_wait_dash;
1203         break;
1204       case STA_wait_dash:
1205         x->state = c == '-'? STA_first_dash : STA_wait_newline;
1206         break;
1207       case STA_first_dash: /* just need for initalization */
1208         x->pos = 0;
1209         x->state = STA_compare_header;
1210       case STA_compare_header:
1211         if ( "-----BEGIN PGP SIGNATURE-----"[++x->pos] == c ) {
1212             if ( x->pos == 28 ) 
1213                 x->state = STA_found_header_wait_newline;
1214         }
1215         else 
1216             x->state = c == '\n'? STA_wait_dash : STA_wait_newline;
1217         break;
1218       case STA_found_header_wait_newline:
1219         /* to make CR,LF issues easier we simply allow for white space
1220            behind the 5 dashes */
1221         if ( c == '\n' )
1222             x->state = STA_skip_header_lines;
1223         else if ( c != '\r' && c != ' ' && c != '\t' )
1224             x->state = STA_wait_dash; /* garbage after the header line */
1225         break;
1226       case STA_skip_header_lines:
1227         /* i.e. wait for one empty line */
1228         if ( c == '\n' ) {
1229             x->state = STA_read_data;
1230             x->crc = CRCINIT;
1231             x->val = 0;
1232             x->pos = 0;
1233         }
1234         else if ( c != '\r' && c != ' ' && c != '\t' )
1235             x->state = STA_skip_header_lines_non_ws;
1236         break;
1237       case STA_skip_header_lines_non_ws:
1238         /* like above but we already encountered non white space */
1239         if ( c == '\n' )
1240             x->state = STA_skip_header_lines;
1241         break;
1242       case STA_read_data:
1243         /* fixme: we don't check for the trailing dash lines but rely
1244          * on the armor stop characters */
1245         if( c == '\n' || c == ' ' || c == '\r' || c == '\t' )
1246             break; /* skip all kind of white space */
1247
1248         if( c == '=' ) { /* pad character: stop */
1249             if( x->pos == 1 ) /* in this case val has some value */
1250                 rval = x->val;
1251             x->state = STA_wait_crc;
1252             break;
1253         }
1254
1255         {
1256             int c2;
1257             if( (c = asctobin[(c2=c)]) == 255 ) {
1258                 log_error(_("invalid radix64 character %02x skipped\n"), c2);
1259                 break;
1260             }
1261         }
1262         
1263         switch(x->pos) {
1264           case 0:
1265             x->val = c << 2;
1266             break;
1267           case 1:
1268             x->val |= (c>>4)&3;
1269             rval = x->val;
1270             x->val = (c<<4)&0xf0;
1271             break;
1272           case 2:
1273             x->val |= (c>>2)&15;
1274             rval = x->val;
1275             x->val = (c<<6)&0xc0;
1276             break;
1277           case 3:
1278             x->val |= c&0x3f;
1279             rval = x->val;
1280             break;
1281         }
1282         x->pos = (x->pos+1) % 4;
1283         break;
1284       case STA_wait_crc:
1285         if( c == '\n' || c == ' ' || c == '\r' || c == '\t' || c == '=' )
1286             break; /* skip ws and pad characters */
1287         /* assume that we are at the next line */
1288         x->state = STA_read_crc;
1289         x->pos = 0;
1290         x->mycrc = 0;
1291       case STA_read_crc:
1292         if( (c = asctobin[c]) == 255 ) {
1293             rval = -1; /* ready */
1294             if( x->crc != x->mycrc ) {
1295                 log_info (_("CRC error; %06lx - %06lx\n"),
1296                           (ulong)x->crc, (ulong)x->mycrc);
1297                 if ( invalid_crc() )
1298                     rval = -3;
1299             }
1300             x->state = STA_ready; /* not sure whether this is correct */
1301             break;
1302         }
1303         
1304         switch(x->pos) {
1305           case 0:
1306             x->val = c << 2;
1307             break;
1308           case 1:
1309             x->val |= (c>>4)&3;
1310             x->mycrc |= x->val << 16;
1311             x->val = (c<<4)&0xf0;
1312             break;
1313           case 2:
1314             x->val |= (c>>2)&15;
1315             x->mycrc |= x->val << 8;
1316             x->val = (c<<6)&0xc0;
1317             break;
1318           case 3:
1319             x->val |= c&0x3f;
1320             x->mycrc |= x->val;
1321             break;
1322         }
1323         x->pos = (x->pos+1) % 4;
1324         break;
1325       case STA_ready:
1326         rval = -1;
1327         break;
1328     }
1329
1330     if ( !(rval & ~255) ) { /* compute the CRC */
1331         x->crc = (x->crc << 8) ^ crc_table[((x->crc >> 16)&0xff) ^ rval];
1332         x->crc &= 0x00ffffff;
1333     }
1334
1335     return rval;
1336 }
1337
1338