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