* keylist.c (list_keyblock_print): Always use the new listing format where
[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 != 4 ) {
776                 log_info(_("malformed CRC\n"));
777                 rc = invalid_crc();
778             }
779             else if( mycrc != afx->crc ) {
780                 log_info (_("CRC error; %06lx - %06lx\n"),
781                                     (ulong)afx->crc, (ulong)mycrc);
782                 rc = invalid_crc();
783             }
784             else {
785                 rc = 0;
786                 /* FIXME: Here we should emit another control packet,
787                  * so that we know in mainproc that we are processing
788                  * a clearsign message */
789 #if 0
790                 for(rc=0;!rc;) {
791                     rc = 0 /*check_trailer( &fhdr, c )*/;
792                     if( !rc ) {
793                         if( (c=iobuf_get(a)) == -1 )
794                             rc = 2;
795                     }
796                 }
797                 if( rc == -1 )
798                     rc = 0;
799                 else if( rc == 2 ) {
800                     log_error(_("premature eof (in Trailer)\n"));
801                     rc = G10ERR_INVALID_ARMOR;
802                 }
803                 else {
804                     log_error(_("error in trailer line\n"));
805                     rc = G10ERR_INVALID_ARMOR;
806                 }
807 #endif
808             }
809         }
810     }
811
812     if( !n )
813         rc = -1;
814
815     *retn = n;
816     return rc;
817 }
818
819 /****************
820  * This filter is used to handle the armor stuff
821  */
822 int
823 armor_filter( void *opaque, int control,
824              IOBUF a, byte *buf, size_t *ret_len)
825 {
826     size_t size = *ret_len;
827     armor_filter_context_t *afx = opaque;
828     int rc=0, i, c;
829     byte radbuf[3];
830     int  idx, idx2;
831     size_t n=0;
832     u32 crc;
833 #if 0
834     static FILE *fp ;
835
836     if( !fp ) {
837         fp = fopen("armor.out", "w");
838         assert(fp);
839     }
840 #endif
841
842     if( DBG_FILTER )
843         log_debug("armor-filter: control: %d\n", control );
844     if( control == IOBUFCTRL_UNDERFLOW && afx->inp_bypass ) {
845         n = 0;
846         if( afx->buffer_len ) {
847             for(; n < size && afx->buffer_pos < afx->buffer_len; n++ )
848                 buf[n++] = afx->buffer[afx->buffer_pos++];
849             if( afx->buffer_pos >= afx->buffer_len )
850                 afx->buffer_len = 0;
851         }
852         for(; n < size; n++ ) {
853             if( (c=iobuf_get(a)) == -1 )
854                 break;
855             buf[n] = c & 0xff;
856         }
857         if( !n )
858             rc = -1;
859         *ret_len = n;
860     }
861     else if( control == IOBUFCTRL_UNDERFLOW ) {
862         /* We need some space for the faked packet.  The minmum
863          * required size is the PARTIAL_CHUNK size plus a byte for the
864          * length itself */
865         if( size < PARTIAL_CHUNK+1 ) 
866             BUG(); /* supplied buffer too short */
867
868         if( afx->faked )
869             rc = fake_packet( afx, a, &n, buf, size );
870         else if( !afx->inp_checked ) {
871             rc = check_input( afx, a );
872             if( afx->inp_bypass ) {
873                 for(n=0; n < size && afx->buffer_pos < afx->buffer_len; )
874                     buf[n++] = afx->buffer[afx->buffer_pos++];
875                 if( afx->buffer_pos >= afx->buffer_len )
876                     afx->buffer_len = 0;
877                 if( !n )
878                     rc = -1;
879             }
880             else if( afx->faked ) {
881                 unsigned int hashes = afx->hashes;
882                 const byte *sesmark;
883                 size_t sesmarklen;
884                 
885                 sesmark = get_session_marker( &sesmarklen );
886                 if ( sesmarklen > 20 )
887                     BUG();
888
889                 /* the buffer is at least 15+n*15 bytes long, so it
890                  * is easy to construct the packets */
891
892                 hashes &= 1|2|4|8|16|32|64;
893                 if( !hashes ) {
894                     hashes |= 4;  /* default to MD 5 */
895                     /* This is non-ideal since PGP 5-8 have the same
896                        end-of-line bugs as PGP 2. However, we only
897                        enable pgp2mode if there is no Hash: header. */
898                     if( opt.pgp2_workarounds )
899                         afx->pgp2mode = 1;
900                 }
901                 n=0;
902                 /* First a gpg control packet... */
903                 buf[n++] = 0xff; /* new format, type 63, 1 length byte */
904                 n++;   /* see below */
905                 memcpy(buf+n, sesmark, sesmarklen ); n+= sesmarklen;
906                 buf[n++] = CTRLPKT_CLEARSIGN_START; 
907                 buf[n++] = afx->not_dash_escaped? 0:1; /* sigclass */
908                 if( hashes & 1 )
909                     buf[n++] = DIGEST_ALGO_RMD160;
910                 if( hashes & 2 )
911                     buf[n++] = DIGEST_ALGO_SHA1;
912                 if( hashes & 4 )
913                     buf[n++] = DIGEST_ALGO_MD5;
914                 if( hashes & 8 )
915                     buf[n++] = DIGEST_ALGO_SHA256;
916                 if( hashes & 16 )
917                     buf[n++] = DIGEST_ALGO_SHA384;
918                 if( hashes & 32 )
919                     buf[n++] = DIGEST_ALGO_SHA512;
920                 buf[1] = n - 2;
921
922                 /* ...followed by an invented plaintext packet.
923                    Amusingly enough, this packet is not compliant with
924                    2440 as the initial partial length is less than 512
925                    bytes.  Of course, we'll accept it anyway ;) */
926
927                 buf[n++] = 0xCB; /* new packet format, type 11 */
928                 buf[n++] = 0xE1; /* 2^1 == 2 bytes */
929                 buf[n++] = 't';  /* canonical text mode */
930                 buf[n++] = 0;    /* namelength */
931                 buf[n++] = 0xE2; /* 2^2 == 4 more bytes */
932                 memset(buf+n, 0, 4); /* timestamp */
933                 n += 4;
934             }
935             else if( !rc )
936                 rc = radix64_read( afx, a, &n, buf, size );
937         }
938         else
939             rc = radix64_read( afx, a, &n, buf, size );
940 #if 0
941         if( n )
942             if( fwrite(buf, n, 1, fp ) != 1 )
943                 BUG();
944 #endif
945         *ret_len = n;
946     }
947     else if( control == IOBUFCTRL_FLUSH && !afx->cancel ) {
948         if( !afx->status ) { /* write the header line */
949             const char *s;
950             STRLIST comment=opt.comments;
951
952             if( afx->what >= DIM(head_strings) )
953                 log_bug("afx->what=%d", afx->what);
954             iobuf_writestr(a, "-----");
955             iobuf_writestr(a, head_strings[afx->what] );
956             iobuf_writestr(a, "-----" LF );
957             if( !opt.no_version )
958                 iobuf_writestr(a, "Version: GnuPG v"  VERSION " ("
959                                               PRINTABLE_OS_NAME ")" LF );
960
961             /* write the comment strings */
962             for(s=comment->d;comment;comment=comment->next,s=comment->d)
963               {
964                 iobuf_writestr(a, "Comment: " );
965                 for( ; *s; s++ )
966                   {
967                     if( *s == '\n' )
968                       iobuf_writestr(a, "\\n" );
969                     else if( *s == '\r' )
970                       iobuf_writestr(a, "\\r" );
971                     else if( *s == '\v' )
972                       iobuf_writestr(a, "\\v" );
973                     else
974                       iobuf_put(a, *s );
975                   }
976                 iobuf_writestr(a, LF );
977               }
978
979             if ( afx->hdrlines ) {
980                 for ( s = afx->hdrlines; *s; s++ ) {
981 #ifdef HAVE_DOSISH_SYSTEM
982                     if ( *s == '\n' )
983                         iobuf_put( a, '\r');
984 #endif
985                     iobuf_put(a, *s );
986                 }
987             }
988             iobuf_writestr(a, LF );
989             afx->status++;
990             afx->idx = 0;
991             afx->idx2 = 0;
992             afx->crc = CRCINIT;
993
994         }
995         crc = afx->crc;
996         idx = afx->idx;
997         idx2 = afx->idx2;
998         for(i=0; i < idx; i++ )
999             radbuf[i] = afx->radbuf[i];
1000
1001         for(i=0; i < size; i++ )
1002             crc = (crc << 8) ^ crc_table[((crc >> 16)&0xff) ^ buf[i]];
1003         crc &= 0x00ffffff;
1004
1005         for( ; size; buf++, size-- ) {
1006             radbuf[idx++] = *buf;
1007             if( idx > 2 ) {
1008                 idx = 0;
1009                 c = bintoasc[(*radbuf >> 2) & 077];
1010                 iobuf_put(a, c);
1011                 c = bintoasc[(((*radbuf<<4)&060)|((radbuf[1] >> 4)&017))&077];
1012                 iobuf_put(a, c);
1013                 c = bintoasc[(((radbuf[1]<<2)&074)|((radbuf[2]>>6)&03))&077];
1014                 iobuf_put(a, c);
1015                 c = bintoasc[radbuf[2]&077];
1016                 iobuf_put(a, c);
1017                 if( ++idx2 >= (64/4) ) { /* pgp doesn't like 72 here */
1018                     iobuf_writestr(a, LF );
1019                     idx2=0;
1020                 }
1021             }
1022         }
1023         for(i=0; i < idx; i++ )
1024             afx->radbuf[i] = radbuf[i];
1025         afx->idx = idx;
1026         afx->idx2 = idx2;
1027         afx->crc  = crc;
1028     }
1029     else if( control == IOBUFCTRL_INIT ) {
1030         if( !is_initialized )
1031             initialize();
1032     }
1033     else if( control == IOBUFCTRL_CANCEL ) {
1034         afx->cancel = 1;
1035     }
1036     else if( control == IOBUFCTRL_FREE ) {
1037         if( afx->cancel )
1038             ;
1039         else if( afx->status ) { /* pad, write cecksum, and bottom line */
1040             crc = afx->crc;
1041             idx = afx->idx;
1042             idx2 = afx->idx2;
1043             for(i=0; i < idx; i++ )
1044                 radbuf[i] = afx->radbuf[i];
1045             if( idx ) {
1046                 c = bintoasc[(*radbuf>>2)&077];
1047                 iobuf_put(a, c);
1048                 if( idx == 1 ) {
1049                     c = bintoasc[((*radbuf << 4) & 060) & 077];
1050                     iobuf_put(a, c);
1051                     iobuf_put(a, '=');
1052                     iobuf_put(a, '=');
1053                 }
1054                 else { /* 2 */
1055                     c = bintoasc[(((*radbuf<<4)&060)|((radbuf[1]>>4)&017))&077];
1056                     iobuf_put(a, c);
1057                     c = bintoasc[((radbuf[1] << 2) & 074) & 077];
1058                     iobuf_put(a, c);
1059                     iobuf_put(a, '=');
1060                 }
1061                 if( ++idx2 >= (64/4) ) { /* pgp doesn't like 72 here */
1062                     iobuf_writestr(a, LF );
1063                     idx2=0;
1064                 }
1065             }
1066             /* may need a linefeed */
1067             if( idx2 )
1068                 iobuf_writestr(a, LF );
1069             /* write the CRC */
1070             iobuf_put(a, '=');
1071             radbuf[0] = crc >>16;
1072             radbuf[1] = crc >> 8;
1073             radbuf[2] = crc;
1074             c = bintoasc[(*radbuf >> 2) & 077];
1075             iobuf_put(a, c);
1076             c = bintoasc[(((*radbuf<<4)&060)|((radbuf[1] >> 4)&017))&077];
1077             iobuf_put(a, c);
1078             c = bintoasc[(((radbuf[1]<<2)&074)|((radbuf[2]>>6)&03))&077];
1079             iobuf_put(a, c);
1080             c = bintoasc[radbuf[2]&077];
1081             iobuf_put(a, c);
1082             iobuf_writestr(a, LF );
1083             /* and the the trailer */
1084             if( afx->what >= DIM(tail_strings) )
1085                 log_bug("afx->what=%d", afx->what);
1086             iobuf_writestr(a, "-----");
1087             iobuf_writestr(a, tail_strings[afx->what] );
1088             iobuf_writestr(a, "-----" LF );
1089         }
1090         else if( !afx->any_data && !afx->inp_bypass ) {
1091             log_error(_("no valid OpenPGP data found.\n"));
1092             afx->no_openpgp_data = 1;
1093             write_status_text( STATUS_NODATA, "1" );
1094         }
1095         if( afx->truncated )
1096             log_info(_("invalid armor: line longer than %d characters\n"),
1097                       MAX_LINELEN );
1098         /* issue an error to enforce dissemination of correct software */
1099         if( afx->qp_detected )
1100             log_error(_("quoted printable character in armor - "
1101                         "probably a buggy MTA has been used\n") );
1102         m_free( afx->buffer );
1103         afx->buffer = NULL;
1104     }
1105     else if( control == IOBUFCTRL_DESC )
1106         *(char**)buf = "armor_filter";
1107     return rc;
1108 }
1109
1110
1111 /****************
1112  * create a radix64 encoded string.
1113  */
1114 char *
1115 make_radix64_string( const byte *data, size_t len )
1116 {
1117     char *buffer, *p;
1118
1119     buffer = p = m_alloc( (len+2)/3*4 + 1 );
1120     for( ; len >= 3 ; len -= 3, data += 3 ) {
1121         *p++ = bintoasc[(data[0] >> 2) & 077];
1122         *p++ = bintoasc[(((data[0] <<4)&060)|((data[1] >> 4)&017))&077];
1123         *p++ = bintoasc[(((data[1]<<2)&074)|((data[2]>>6)&03))&077];
1124         *p++ = bintoasc[data[2]&077];
1125     }
1126     if( len == 2 ) {
1127         *p++ = bintoasc[(data[0] >> 2) & 077];
1128         *p++ = bintoasc[(((data[0] <<4)&060)|((data[1] >> 4)&017))&077];
1129         *p++ = bintoasc[((data[1]<<2)&074)];
1130     }
1131     else if( len == 1 ) {
1132         *p++ = bintoasc[(data[0] >> 2) & 077];
1133         *p++ = bintoasc[(data[0] <<4)&060];
1134     }
1135     *p = 0;
1136     return buffer;
1137 }
1138
1139
1140 /***********************************************
1141  *  For the pipemode command we can't use the armor filter for various
1142  *  reasons, so we use this new unarmor_pump stuff to remove the armor 
1143  */
1144
1145 enum unarmor_state_e {
1146     STA_init = 0,
1147     STA_bypass,
1148     STA_wait_newline,
1149     STA_wait_dash,
1150     STA_first_dash, 
1151     STA_compare_header,
1152     STA_found_header_wait_newline,
1153     STA_skip_header_lines,
1154     STA_skip_header_lines_non_ws,
1155     STA_read_data,
1156     STA_wait_crc,
1157     STA_read_crc,
1158     STA_ready
1159 };
1160
1161 struct unarmor_pump_s {
1162     enum unarmor_state_e state;
1163     byte val;
1164     int checkcrc;
1165     int pos;   /* counts from 0..3 */
1166     u32 crc;
1167     u32 mycrc; /* the one store in the data */
1168 };
1169
1170
1171
1172 UnarmorPump
1173 unarmor_pump_new (void)
1174 {
1175     UnarmorPump x;
1176
1177     if( !is_initialized )
1178         initialize();
1179     x = m_alloc_clear (sizeof *x);
1180     return x;
1181 }
1182
1183 void
1184 unarmor_pump_release (UnarmorPump x)
1185 {
1186     m_free (x);
1187 }
1188
1189 /* 
1190  * Get the next character from the ascii armor taken from the IOBUF
1191  * created earlier by unarmor_pump_new().
1192  * Return:  c = Character
1193  *        256 = ignore this value
1194  *         -1 = End of current armor 
1195  *         -2 = Premature EOF (not used)
1196  *         -3 = Invalid armor
1197  */
1198 int
1199 unarmor_pump (UnarmorPump x, int c)
1200 {
1201     int rval = 256; /* default is to ignore the return value */
1202
1203     switch (x->state) {
1204       case STA_init:
1205         { 
1206             byte tmp[1];
1207             tmp[0] = c; 
1208             if ( is_armored (tmp) )
1209                 x->state = c == '-'? STA_first_dash : STA_wait_newline;
1210             else {
1211                 x->state = STA_bypass;
1212                 return c;
1213             }
1214         }
1215         break;
1216       case STA_bypass:
1217         return c; /* return here to avoid crc calculation */
1218       case STA_wait_newline:
1219         if (c == '\n')
1220             x->state = STA_wait_dash;
1221         break;
1222       case STA_wait_dash:
1223         x->state = c == '-'? STA_first_dash : STA_wait_newline;
1224         break;
1225       case STA_first_dash: /* just need for initalization */
1226         x->pos = 0;
1227         x->state = STA_compare_header;
1228       case STA_compare_header:
1229         if ( "-----BEGIN PGP SIGNATURE-----"[++x->pos] == c ) {
1230             if ( x->pos == 28 ) 
1231                 x->state = STA_found_header_wait_newline;
1232         }
1233         else 
1234             x->state = c == '\n'? STA_wait_dash : STA_wait_newline;
1235         break;
1236       case STA_found_header_wait_newline:
1237         /* to make CR,LF issues easier we simply allow for white space
1238            behind the 5 dashes */
1239         if ( c == '\n' )
1240             x->state = STA_skip_header_lines;
1241         else if ( c != '\r' && c != ' ' && c != '\t' )
1242             x->state = STA_wait_dash; /* garbage after the header line */
1243         break;
1244       case STA_skip_header_lines:
1245         /* i.e. wait for one empty line */
1246         if ( c == '\n' ) {
1247             x->state = STA_read_data;
1248             x->crc = CRCINIT;
1249             x->val = 0;
1250             x->pos = 0;
1251         }
1252         else if ( c != '\r' && c != ' ' && c != '\t' )
1253             x->state = STA_skip_header_lines_non_ws;
1254         break;
1255       case STA_skip_header_lines_non_ws:
1256         /* like above but we already encountered non white space */
1257         if ( c == '\n' )
1258             x->state = STA_skip_header_lines;
1259         break;
1260       case STA_read_data:
1261         /* fixme: we don't check for the trailing dash lines but rely
1262          * on the armor stop characters */
1263         if( c == '\n' || c == ' ' || c == '\r' || c == '\t' )
1264             break; /* skip all kind of white space */
1265
1266         if( c == '=' ) { /* pad character: stop */
1267             if( x->pos == 1 ) /* in this case val has some value */
1268                 rval = x->val;
1269             x->state = STA_wait_crc;
1270             break;
1271         }
1272
1273         {
1274             int c2;
1275             if( (c = asctobin[(c2=c)]) == 255 ) {
1276                 log_error(_("invalid radix64 character %02x skipped\n"), c2);
1277                 break;
1278             }
1279         }
1280         
1281         switch(x->pos) {
1282           case 0:
1283             x->val = c << 2;
1284             break;
1285           case 1:
1286             x->val |= (c>>4)&3;
1287             rval = x->val;
1288             x->val = (c<<4)&0xf0;
1289             break;
1290           case 2:
1291             x->val |= (c>>2)&15;
1292             rval = x->val;
1293             x->val = (c<<6)&0xc0;
1294             break;
1295           case 3:
1296             x->val |= c&0x3f;
1297             rval = x->val;
1298             break;
1299         }
1300         x->pos = (x->pos+1) % 4;
1301         break;
1302       case STA_wait_crc:
1303         if( c == '\n' || c == ' ' || c == '\r' || c == '\t' || c == '=' )
1304             break; /* skip ws and pad characters */
1305         /* assume that we are at the next line */
1306         x->state = STA_read_crc;
1307         x->pos = 0;
1308         x->mycrc = 0;
1309       case STA_read_crc:
1310         if( (c = asctobin[c]) == 255 ) {
1311             rval = -1; /* ready */
1312             if( x->crc != x->mycrc ) {
1313                 log_info (_("CRC error; %06lx - %06lx\n"),
1314                           (ulong)x->crc, (ulong)x->mycrc);
1315                 if ( invalid_crc() )
1316                     rval = -3;
1317             }
1318             x->state = STA_ready; /* not sure whether this is correct */
1319             break;
1320         }
1321         
1322         switch(x->pos) {
1323           case 0:
1324             x->val = c << 2;
1325             break;
1326           case 1:
1327             x->val |= (c>>4)&3;
1328             x->mycrc |= x->val << 16;
1329             x->val = (c<<4)&0xf0;
1330             break;
1331           case 2:
1332             x->val |= (c>>2)&15;
1333             x->mycrc |= x->val << 8;
1334             x->val = (c<<6)&0xc0;
1335             break;
1336           case 3:
1337             x->val |= c&0x3f;
1338             x->mycrc |= x->val;
1339             break;
1340         }
1341         x->pos = (x->pos+1) % 4;
1342         break;
1343       case STA_ready:
1344         rval = -1;
1345         break;
1346     }
1347
1348     if ( !(rval & ~255) ) { /* compute the CRC */
1349         x->crc = (x->crc << 8) ^ crc_table[((x->crc >> 16)&0xff) ^ rval];
1350         x->crc &= 0x00ffffff;
1351     }
1352
1353     return rval;
1354 }