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