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