489f73dccf04c28f6752fc1d8219fb2b47ee110e
[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           {
550             /* check for dash escaped or armor header */
551             if( p[1] == ' ' && !afx->not_dash_escaped )
552               {
553                 /* It's a dash-escaped line */
554                 afx->buffer_pos = 2; /* skip */
555               }
556             else if( n >= 15 &&  p[1] == '-' && p[2] == '-' && p[3] == '-' )
557               {
558                 /* It's armor header */
559                 int type = is_armor_header( p, n );
560                 if( afx->not_dash_escaped && type != BEGIN_SIGNATURE )
561                   ; /* this is okay */
562                 else {
563                   if( type != BEGIN_SIGNATURE ) {
564                     log_info(_("unexpected armor: "));
565                     print_string( stderr, p, n, 0 );
566                     putc('\n', stderr);
567                   }
568                   lastline = 1;
569                   rc = -1;
570                 }
571               }
572           }
573     }
574
575     if( lastline ) { /* write last (ending) length header */
576         if(tempbuf_len<192)
577           buf[len++]=tempbuf_len;
578         else
579           {
580             buf[len++]=((tempbuf_len-192)/256) + 192;
581             buf[len++]=(tempbuf_len-192) % 256;
582           }
583         memcpy(&buf[len],tempbuf,tempbuf_len);
584         len+=tempbuf_len;
585
586         rc = 0;
587         afx->faked = 0;
588         afx->in_cleartext = 0;
589         /* and now read the header lines */
590         afx->buffer_pos = 0;
591         for(;;) {
592             int i;
593
594             /* read the next line (skip all truncated lines) */
595             do {
596                 maxlen = MAX_LINELEN;
597                 afx->buffer_len = iobuf_read_line( a, &afx->buffer,
598                                                  &afx->buffer_size, &maxlen );
599             } while( !maxlen );
600             p = afx->buffer;
601             n = afx->buffer_len;
602             if( !n ) {
603                 rc = -1;
604                 break; /* eof */
605             }
606             i = parse_header_line( afx, p , n );
607             if( i <= 0 ) {
608                 if( i )
609                     invalid_armor();
610                 break;
611             }
612         }
613         afx->inp_checked = 1;
614         afx->crc = CRCINIT;
615         afx->idx = 0;
616         afx->radbuf[0] = 0;
617     }
618
619     *retn = len;
620     return rc;
621 }
622
623
624 static int
625 invalid_crc(void)
626 {
627     if ( opt.ignore_crc_error )
628         return 0;
629     log_inc_errorcount();
630     return G10ERR_INVALID_ARMOR;
631 }
632
633
634 static int
635 radix64_read( armor_filter_context_t *afx, IOBUF a, size_t *retn,
636               byte *buf, size_t size )
637 {
638     byte val;
639     int c=0, c2; /*init c because gcc is not clever enough for the continue*/
640     int checkcrc=0;
641     int rc = 0;
642     size_t n = 0;
643     int  idx, i;
644     u32 crc;
645
646     crc = afx->crc;
647     idx = afx->idx;
648     val = afx->radbuf[0];
649     for( n=0; n < size; ) {
650
651         if( afx->buffer_pos < afx->buffer_len )
652             c = afx->buffer[afx->buffer_pos++];
653         else { /* read the next line */
654             unsigned maxlen = MAX_LINELEN;
655             afx->buffer_pos = 0;
656             afx->buffer_len = iobuf_read_line( a, &afx->buffer,
657                                                &afx->buffer_size, &maxlen );
658             if( !maxlen )
659                 afx->truncated++;
660             if( !afx->buffer_len )
661                 break; /* eof */
662             continue;
663         }
664
665       again:
666         if( c == '\n' || c == ' ' || c == '\r' || c == '\t' )
667             continue;
668         else if( c == '=' ) { /* pad character: stop */
669             /* some mailers leave quoted-printable encoded characters
670              * so we try to workaround this */
671             if( afx->buffer_pos+2 < afx->buffer_len ) {
672                 int cc1, cc2, cc3;
673                 cc1 = afx->buffer[afx->buffer_pos];
674                 cc2 = afx->buffer[afx->buffer_pos+1];
675                 cc3 = afx->buffer[afx->buffer_pos+2];
676                 if( isxdigit(cc1) && isxdigit(cc2)
677                                   && strchr( "=\n\r\t ", cc3 )) {
678                     /* well it seems to be the case - adjust */
679                     c = isdigit(cc1)? (cc1 - '0'): (ascii_toupper(cc1)-'A'+10);
680                     c <<= 4;
681                     c |= isdigit(cc2)? (cc2 - '0'): (ascii_toupper(cc2)-'A'+10);
682                     afx->buffer_pos += 2;
683                     afx->qp_detected = 1;
684                     goto again;
685                 }
686             }
687
688             if( idx == 1 )
689                 buf[n++] = val;
690             checkcrc++;
691             break;
692         }
693         else if( (c = asctobin[(c2=c)]) == 255 ) {
694             log_error(_("invalid radix64 character %02X skipped\n"), c2);
695             continue;
696         }
697         switch(idx) {
698           case 0: val =  c << 2; break;
699           case 1: val |= (c>>4)&3; buf[n++]=val;val=(c<<4)&0xf0;break;
700           case 2: val |= (c>>2)&15; buf[n++]=val;val=(c<<6)&0xc0;break;
701           case 3: val |= c&0x3f; buf[n++] = val; break;
702         }
703         idx = (idx+1) % 4;
704     }
705
706     for(i=0; i < n; i++ )
707         crc = (crc << 8) ^ crc_table[((crc >> 16)&0xff) ^ buf[i]];
708     crc &= 0x00ffffff;
709     afx->crc = crc;
710     afx->idx = idx;
711     afx->radbuf[0] = val;
712
713     if( checkcrc ) {
714         afx->any_data = 1;
715         afx->inp_checked=0;
716         afx->faked = 0;
717         for(;;) { /* skip lf and pad characters */
718             if( afx->buffer_pos < afx->buffer_len )
719                 c = afx->buffer[afx->buffer_pos++];
720             else { /* read the next line */
721                 unsigned maxlen = MAX_LINELEN;
722                 afx->buffer_pos = 0;
723                 afx->buffer_len = iobuf_read_line( a, &afx->buffer,
724                                                    &afx->buffer_size, &maxlen );
725                 if( !maxlen )
726                     afx->truncated++;
727                 if( !afx->buffer_len )
728                     break; /* eof */
729                 continue;
730             }
731             if( c == '\n' || c == ' ' || c == '\r'
732                 || c == '\t' || c == '=' )
733                 continue;
734             break;
735         }
736         if( c == -1 )
737             log_error(_("premature eof (no CRC)\n"));
738         else {
739             u32 mycrc = 0;
740             idx = 0;
741             do {
742                 if( (c = asctobin[c]) == 255 )
743                     break;
744                 switch(idx) {
745                   case 0: val =  c << 2; break;
746                   case 1: val |= (c>>4)&3; mycrc |= val << 16;val=(c<<4)&0xf0;break;
747                   case 2: val |= (c>>2)&15; mycrc |= val << 8;val=(c<<6)&0xc0;break;
748                   case 3: val |= c&0x3f; mycrc |= val; break;
749                 }
750                 for(;;) {
751                     if( afx->buffer_pos < afx->buffer_len )
752                         c = afx->buffer[afx->buffer_pos++];
753                     else { /* read the next line */
754                         unsigned maxlen = MAX_LINELEN;
755                         afx->buffer_pos = 0;
756                         afx->buffer_len = iobuf_read_line( a, &afx->buffer,
757                                                            &afx->buffer_size,
758                                                                 &maxlen );
759                         if( !maxlen )
760                             afx->truncated++;
761                         if( !afx->buffer_len )
762                             break; /* eof */
763                         continue;
764                     }
765                     break;
766                 }
767                 if( !afx->buffer_len )
768                     break; /* eof */
769             } while( ++idx < 4 );
770             if( c == -1 ) {
771                 log_info(_("premature eof (in CRC)\n"));
772                 rc = invalid_crc();
773             }
774             else if( idx == 0 ) {
775                 /* No CRC at all is legal ("MAY") */
776                 rc=0;
777             }
778             else if( idx != 4 ) {
779                 log_info(_("malformed CRC\n"));
780                 rc = invalid_crc();
781             }
782             else if( mycrc != afx->crc ) {
783                 log_info (_("CRC error; %06lX - %06lX\n"),
784                                     (ulong)afx->crc, (ulong)mycrc);
785                 rc = invalid_crc();
786             }
787             else {
788                 rc = 0;
789                 /* FIXME: Here we should emit another control packet,
790                  * so that we know in mainproc that we are processing
791                  * a clearsign message */
792 #if 0
793                 for(rc=0;!rc;) {
794                     rc = 0 /*check_trailer( &fhdr, c )*/;
795                     if( !rc ) {
796                         if( (c=iobuf_get(a)) == -1 )
797                             rc = 2;
798                     }
799                 }
800                 if( rc == -1 )
801                     rc = 0;
802                 else if( rc == 2 ) {
803                     log_error(_("premature eof (in trailer)\n"));
804                     rc = G10ERR_INVALID_ARMOR;
805                 }
806                 else {
807                     log_error(_("error in trailer line\n"));
808                     rc = G10ERR_INVALID_ARMOR;
809                 }
810 #endif
811             }
812         }
813     }
814
815     if( !n )
816         rc = -1;
817
818     *retn = n;
819     return rc;
820 }
821
822 /****************
823  * This filter is used to handle the armor stuff
824  */
825 int
826 armor_filter( void *opaque, int control,
827              IOBUF a, byte *buf, size_t *ret_len)
828 {
829     size_t size = *ret_len;
830     armor_filter_context_t *afx = opaque;
831     int rc=0, i, c;
832     byte radbuf[3];
833     int  idx, idx2;
834     size_t n=0;
835     u32 crc;
836 #if 0
837     static FILE *fp ;
838
839     if( !fp ) {
840         fp = fopen("armor.out", "w");
841         assert(fp);
842     }
843 #endif
844
845     if( DBG_FILTER )
846         log_debug("armor-filter: control: %d\n", control );
847     if( control == IOBUFCTRL_UNDERFLOW && afx->inp_bypass ) {
848         n = 0;
849         if( afx->buffer_len ) {
850             for(; n < size && afx->buffer_pos < afx->buffer_len; n++ )
851                 buf[n++] = afx->buffer[afx->buffer_pos++];
852             if( afx->buffer_pos >= afx->buffer_len )
853                 afx->buffer_len = 0;
854         }
855         for(; n < size; n++ ) {
856             if( (c=iobuf_get(a)) == -1 )
857                 break;
858             buf[n] = c & 0xff;
859         }
860         if( !n )
861             rc = -1;
862         *ret_len = n;
863     }
864     else if( control == IOBUFCTRL_UNDERFLOW ) {
865         /* We need some space for the faked packet.  The minmum
866          * required size is the PARTIAL_CHUNK size plus a byte for the
867          * length itself */
868         if( size < PARTIAL_CHUNK+1 ) 
869             BUG(); /* supplied buffer too short */
870
871         if( afx->faked )
872             rc = fake_packet( afx, a, &n, buf, size );
873         else if( !afx->inp_checked ) {
874             rc = check_input( afx, a );
875             if( afx->inp_bypass ) {
876                 for(n=0; n < size && afx->buffer_pos < afx->buffer_len; )
877                     buf[n++] = afx->buffer[afx->buffer_pos++];
878                 if( afx->buffer_pos >= afx->buffer_len )
879                     afx->buffer_len = 0;
880                 if( !n )
881                     rc = -1;
882             }
883             else if( afx->faked ) {
884                 unsigned int hashes = afx->hashes;
885                 const byte *sesmark;
886                 size_t sesmarklen;
887                 
888                 sesmark = get_session_marker( &sesmarklen );
889                 if ( sesmarklen > 20 )
890                     BUG();
891
892                 /* the buffer is at least 15+n*15 bytes long, so it
893                  * is easy to construct the packets */
894
895                 hashes &= 1|2|4|8|16|32|64;
896                 if( !hashes ) {
897                     hashes |= 4;  /* default to MD 5 */
898                     /* This is non-ideal since PGP 5-8 have the same
899                        end-of-line bugs as PGP 2. However, we only
900                        enable pgp2mode if there is no Hash: header. */
901                     if( opt.pgp2_workarounds )
902                         afx->pgp2mode = 1;
903                 }
904                 n=0;
905                 /* First a gpg control packet... */
906                 buf[n++] = 0xff; /* new format, type 63, 1 length byte */
907                 n++;   /* see below */
908                 memcpy(buf+n, sesmark, sesmarklen ); n+= sesmarklen;
909                 buf[n++] = CTRLPKT_CLEARSIGN_START; 
910                 buf[n++] = afx->not_dash_escaped? 0:1; /* sigclass */
911                 if( hashes & 1 )
912                     buf[n++] = DIGEST_ALGO_RMD160;
913                 if( hashes & 2 )
914                     buf[n++] = DIGEST_ALGO_SHA1;
915                 if( hashes & 4 )
916                     buf[n++] = DIGEST_ALGO_MD5;
917                 if( hashes & 8 )
918                     buf[n++] = DIGEST_ALGO_SHA256;
919                 if( hashes & 16 )
920                     buf[n++] = DIGEST_ALGO_SHA384;
921                 if( hashes & 32 )
922                     buf[n++] = DIGEST_ALGO_SHA512;
923                 buf[1] = n - 2;
924
925                 /* ...followed by an invented plaintext packet.
926                    Amusingly enough, this packet is not compliant with
927                    2440 as the initial partial length is less than 512
928                    bytes.  Of course, we'll accept it anyway ;) */
929
930                 buf[n++] = 0xCB; /* new packet format, type 11 */
931                 buf[n++] = 0xE1; /* 2^1 == 2 bytes */
932                 buf[n++] = 't';  /* canonical text mode */
933                 buf[n++] = 0;    /* namelength */
934                 buf[n++] = 0xE2; /* 2^2 == 4 more bytes */
935                 memset(buf+n, 0, 4); /* timestamp */
936                 n += 4;
937             }
938             else if( !rc )
939                 rc = radix64_read( afx, a, &n, buf, size );
940         }
941         else
942             rc = radix64_read( afx, a, &n, buf, size );
943 #if 0
944         if( n )
945             if( fwrite(buf, n, 1, fp ) != 1 )
946                 BUG();
947 #endif
948         *ret_len = n;
949     }
950     else if( control == IOBUFCTRL_FLUSH && !afx->cancel ) {
951         if( !afx->status ) { /* write the header line */
952             const char *s;
953             STRLIST comment=opt.comments;
954
955             if( afx->what >= DIM(head_strings) )
956                 log_bug("afx->what=%d", afx->what);
957             iobuf_writestr(a, "-----");
958             iobuf_writestr(a, head_strings[afx->what] );
959             iobuf_writestr(a, "-----" LF );
960             if( !opt.no_version )
961                 iobuf_writestr(a, "Version: GnuPG v"  VERSION " ("
962                                               PRINTABLE_OS_NAME ")" LF );
963
964             /* write the comment strings */
965             for(s=comment->d;comment;comment=comment->next,s=comment->d)
966               {
967                 iobuf_writestr(a, "Comment: " );
968                 for( ; *s; s++ )
969                   {
970                     if( *s == '\n' )
971                       iobuf_writestr(a, "\\n" );
972                     else if( *s == '\r' )
973                       iobuf_writestr(a, "\\r" );
974                     else if( *s == '\v' )
975                       iobuf_writestr(a, "\\v" );
976                     else
977                       iobuf_put(a, *s );
978                   }
979                 iobuf_writestr(a, LF );
980               }
981
982             if ( afx->hdrlines ) {
983                 for ( s = afx->hdrlines; *s; s++ ) {
984 #ifdef HAVE_DOSISH_SYSTEM
985                     if ( *s == '\n' )
986                         iobuf_put( a, '\r');
987 #endif
988                     iobuf_put(a, *s );
989                 }
990             }
991             iobuf_writestr(a, LF );
992             afx->status++;
993             afx->idx = 0;
994             afx->idx2 = 0;
995             afx->crc = CRCINIT;
996
997         }
998         crc = afx->crc;
999         idx = afx->idx;
1000         idx2 = afx->idx2;
1001         for(i=0; i < idx; i++ )
1002             radbuf[i] = afx->radbuf[i];
1003
1004         for(i=0; i < size; i++ )
1005             crc = (crc << 8) ^ crc_table[((crc >> 16)&0xff) ^ buf[i]];
1006         crc &= 0x00ffffff;
1007
1008         for( ; size; buf++, size-- ) {
1009             radbuf[idx++] = *buf;
1010             if( idx > 2 ) {
1011                 idx = 0;
1012                 c = bintoasc[(*radbuf >> 2) & 077];
1013                 iobuf_put(a, c);
1014                 c = bintoasc[(((*radbuf<<4)&060)|((radbuf[1] >> 4)&017))&077];
1015                 iobuf_put(a, c);
1016                 c = bintoasc[(((radbuf[1]<<2)&074)|((radbuf[2]>>6)&03))&077];
1017                 iobuf_put(a, c);
1018                 c = bintoasc[radbuf[2]&077];
1019                 iobuf_put(a, c);
1020                 if( ++idx2 >= (64/4) ) { /* pgp doesn't like 72 here */
1021                     iobuf_writestr(a, LF );
1022                     idx2=0;
1023                 }
1024             }
1025         }
1026         for(i=0; i < idx; i++ )
1027             afx->radbuf[i] = radbuf[i];
1028         afx->idx = idx;
1029         afx->idx2 = idx2;
1030         afx->crc  = crc;
1031     }
1032     else if( control == IOBUFCTRL_INIT ) {
1033         if( !is_initialized )
1034             initialize();
1035     }
1036     else if( control == IOBUFCTRL_CANCEL ) {
1037         afx->cancel = 1;
1038     }
1039     else if( control == IOBUFCTRL_FREE ) {
1040         if( afx->cancel )
1041             ;
1042         else if( afx->status ) { /* pad, write cecksum, and bottom line */
1043             crc = afx->crc;
1044             idx = afx->idx;
1045             idx2 = afx->idx2;
1046             for(i=0; i < idx; i++ )
1047                 radbuf[i] = afx->radbuf[i];
1048             if( idx ) {
1049                 c = bintoasc[(*radbuf>>2)&077];
1050                 iobuf_put(a, c);
1051                 if( idx == 1 ) {
1052                     c = bintoasc[((*radbuf << 4) & 060) & 077];
1053                     iobuf_put(a, c);
1054                     iobuf_put(a, '=');
1055                     iobuf_put(a, '=');
1056                 }
1057                 else { /* 2 */
1058                     c = bintoasc[(((*radbuf<<4)&060)|((radbuf[1]>>4)&017))&077];
1059                     iobuf_put(a, c);
1060                     c = bintoasc[((radbuf[1] << 2) & 074) & 077];
1061                     iobuf_put(a, c);
1062                     iobuf_put(a, '=');
1063                 }
1064                 if( ++idx2 >= (64/4) ) { /* pgp doesn't like 72 here */
1065                     iobuf_writestr(a, LF );
1066                     idx2=0;
1067                 }
1068             }
1069             /* may need a linefeed */
1070             if( idx2 )
1071                 iobuf_writestr(a, LF );
1072             /* write the CRC */
1073             iobuf_put(a, '=');
1074             radbuf[0] = crc >>16;
1075             radbuf[1] = crc >> 8;
1076             radbuf[2] = crc;
1077             c = bintoasc[(*radbuf >> 2) & 077];
1078             iobuf_put(a, c);
1079             c = bintoasc[(((*radbuf<<4)&060)|((radbuf[1] >> 4)&017))&077];
1080             iobuf_put(a, c);
1081             c = bintoasc[(((radbuf[1]<<2)&074)|((radbuf[2]>>6)&03))&077];
1082             iobuf_put(a, c);
1083             c = bintoasc[radbuf[2]&077];
1084             iobuf_put(a, c);
1085             iobuf_writestr(a, LF );
1086             /* and the the trailer */
1087             if( afx->what >= DIM(tail_strings) )
1088                 log_bug("afx->what=%d", afx->what);
1089             iobuf_writestr(a, "-----");
1090             iobuf_writestr(a, tail_strings[afx->what] );
1091             iobuf_writestr(a, "-----" LF );
1092         }
1093         else if( !afx->any_data && !afx->inp_bypass ) {
1094             log_error(_("no valid OpenPGP data found.\n"));
1095             afx->no_openpgp_data = 1;
1096             write_status_text( STATUS_NODATA, "1" );
1097         }
1098         if( afx->truncated )
1099             log_info(_("invalid armor: line longer than %d characters\n"),
1100                       MAX_LINELEN );
1101         /* issue an error to enforce dissemination of correct software */
1102         if( afx->qp_detected )
1103             log_error(_("quoted printable character in armor - "
1104                         "probably a buggy MTA has been used\n") );
1105         m_free( afx->buffer );
1106         afx->buffer = NULL;
1107     }
1108     else if( control == IOBUFCTRL_DESC )
1109         *(char**)buf = "armor_filter";
1110     return rc;
1111 }
1112
1113
1114 /****************
1115  * create a radix64 encoded string.
1116  */
1117 char *
1118 make_radix64_string( const byte *data, size_t len )
1119 {
1120     char *buffer, *p;
1121
1122     buffer = p = m_alloc( (len+2)/3*4 + 1 );
1123     for( ; len >= 3 ; len -= 3, data += 3 ) {
1124         *p++ = bintoasc[(data[0] >> 2) & 077];
1125         *p++ = bintoasc[(((data[0] <<4)&060)|((data[1] >> 4)&017))&077];
1126         *p++ = bintoasc[(((data[1]<<2)&074)|((data[2]>>6)&03))&077];
1127         *p++ = bintoasc[data[2]&077];
1128     }
1129     if( len == 2 ) {
1130         *p++ = bintoasc[(data[0] >> 2) & 077];
1131         *p++ = bintoasc[(((data[0] <<4)&060)|((data[1] >> 4)&017))&077];
1132         *p++ = bintoasc[((data[1]<<2)&074)];
1133     }
1134     else if( len == 1 ) {
1135         *p++ = bintoasc[(data[0] >> 2) & 077];
1136         *p++ = bintoasc[(data[0] <<4)&060];
1137     }
1138     *p = 0;
1139     return buffer;
1140 }
1141
1142
1143 /***********************************************
1144  *  For the pipemode command we can't use the armor filter for various
1145  *  reasons, so we use this new unarmor_pump stuff to remove the armor 
1146  */
1147
1148 enum unarmor_state_e {
1149     STA_init = 0,
1150     STA_bypass,
1151     STA_wait_newline,
1152     STA_wait_dash,
1153     STA_first_dash, 
1154     STA_compare_header,
1155     STA_found_header_wait_newline,
1156     STA_skip_header_lines,
1157     STA_skip_header_lines_non_ws,
1158     STA_read_data,
1159     STA_wait_crc,
1160     STA_read_crc,
1161     STA_ready
1162 };
1163
1164 struct unarmor_pump_s {
1165     enum unarmor_state_e state;
1166     byte val;
1167     int checkcrc;
1168     int pos;   /* counts from 0..3 */
1169     u32 crc;
1170     u32 mycrc; /* the one store in the data */
1171 };
1172
1173
1174
1175 UnarmorPump
1176 unarmor_pump_new (void)
1177 {
1178     UnarmorPump x;
1179
1180     if( !is_initialized )
1181         initialize();
1182     x = m_alloc_clear (sizeof *x);
1183     return x;
1184 }
1185
1186 void
1187 unarmor_pump_release (UnarmorPump x)
1188 {
1189     m_free (x);
1190 }
1191
1192 /* 
1193  * Get the next character from the ascii armor taken from the IOBUF
1194  * created earlier by unarmor_pump_new().
1195  * Return:  c = Character
1196  *        256 = ignore this value
1197  *         -1 = End of current armor 
1198  *         -2 = Premature EOF (not used)
1199  *         -3 = Invalid armor
1200  */
1201 int
1202 unarmor_pump (UnarmorPump x, int c)
1203 {
1204     int rval = 256; /* default is to ignore the return value */
1205
1206     switch (x->state) {
1207       case STA_init:
1208         { 
1209             byte tmp[1];
1210             tmp[0] = c; 
1211             if ( is_armored (tmp) )
1212                 x->state = c == '-'? STA_first_dash : STA_wait_newline;
1213             else {
1214                 x->state = STA_bypass;
1215                 return c;
1216             }
1217         }
1218         break;
1219       case STA_bypass:
1220         return c; /* return here to avoid crc calculation */
1221       case STA_wait_newline:
1222         if (c == '\n')
1223             x->state = STA_wait_dash;
1224         break;
1225       case STA_wait_dash:
1226         x->state = c == '-'? STA_first_dash : STA_wait_newline;
1227         break;
1228       case STA_first_dash: /* just need for initalization */
1229         x->pos = 0;
1230         x->state = STA_compare_header;
1231       case STA_compare_header:
1232         if ( "-----BEGIN PGP SIGNATURE-----"[++x->pos] == c ) {
1233             if ( x->pos == 28 ) 
1234                 x->state = STA_found_header_wait_newline;
1235         }
1236         else 
1237             x->state = c == '\n'? STA_wait_dash : STA_wait_newline;
1238         break;
1239       case STA_found_header_wait_newline:
1240         /* to make CR,LF issues easier we simply allow for white space
1241            behind the 5 dashes */
1242         if ( c == '\n' )
1243             x->state = STA_skip_header_lines;
1244         else if ( c != '\r' && c != ' ' && c != '\t' )
1245             x->state = STA_wait_dash; /* garbage after the header line */
1246         break;
1247       case STA_skip_header_lines:
1248         /* i.e. wait for one empty line */
1249         if ( c == '\n' ) {
1250             x->state = STA_read_data;
1251             x->crc = CRCINIT;
1252             x->val = 0;
1253             x->pos = 0;
1254         }
1255         else if ( c != '\r' && c != ' ' && c != '\t' )
1256             x->state = STA_skip_header_lines_non_ws;
1257         break;
1258       case STA_skip_header_lines_non_ws:
1259         /* like above but we already encountered non white space */
1260         if ( c == '\n' )
1261             x->state = STA_skip_header_lines;
1262         break;
1263       case STA_read_data:
1264         /* fixme: we don't check for the trailing dash lines but rely
1265          * on the armor stop characters */
1266         if( c == '\n' || c == ' ' || c == '\r' || c == '\t' )
1267             break; /* skip all kind of white space */
1268
1269         if( c == '=' ) { /* pad character: stop */
1270             if( x->pos == 1 ) /* in this case val has some value */
1271                 rval = x->val;
1272             x->state = STA_wait_crc;
1273             break;
1274         }
1275
1276         {
1277             int c2;
1278             if( (c = asctobin[(c2=c)]) == 255 ) {
1279                 log_error(_("invalid radix64 character %02X skipped\n"), c2);
1280                 break;
1281             }
1282         }
1283         
1284         switch(x->pos) {
1285           case 0:
1286             x->val = c << 2;
1287             break;
1288           case 1:
1289             x->val |= (c>>4)&3;
1290             rval = x->val;
1291             x->val = (c<<4)&0xf0;
1292             break;
1293           case 2:
1294             x->val |= (c>>2)&15;
1295             rval = x->val;
1296             x->val = (c<<6)&0xc0;
1297             break;
1298           case 3:
1299             x->val |= c&0x3f;
1300             rval = x->val;
1301             break;
1302         }
1303         x->pos = (x->pos+1) % 4;
1304         break;
1305       case STA_wait_crc:
1306         if( c == '\n' || c == ' ' || c == '\r' || c == '\t' || c == '=' )
1307             break; /* skip ws and pad characters */
1308         /* assume that we are at the next line */
1309         x->state = STA_read_crc;
1310         x->pos = 0;
1311         x->mycrc = 0;
1312       case STA_read_crc:
1313         if( (c = asctobin[c]) == 255 ) {
1314             rval = -1; /* ready */
1315             if( x->crc != x->mycrc ) {
1316                 log_info (_("CRC error; %06lX - %06lX\n"),
1317                           (ulong)x->crc, (ulong)x->mycrc);
1318                 if ( invalid_crc() )
1319                     rval = -3;
1320             }
1321             x->state = STA_ready; /* not sure whether this is correct */
1322             break;
1323         }
1324         
1325         switch(x->pos) {
1326           case 0:
1327             x->val = c << 2;
1328             break;
1329           case 1:
1330             x->val |= (c>>4)&3;
1331             x->mycrc |= x->val << 16;
1332             x->val = (c<<4)&0xf0;
1333             break;
1334           case 2:
1335             x->val |= (c>>2)&15;
1336             x->mycrc |= x->val << 8;
1337             x->val = (c<<6)&0xc0;
1338             break;
1339           case 3:
1340             x->val |= c&0x3f;
1341             x->mycrc |= x->val;
1342             break;
1343         }
1344         x->pos = (x->pos+1) % 4;
1345         break;
1346       case STA_ready:
1347         rval = -1;
1348         break;
1349     }
1350
1351     if ( !(rval & ~255) ) { /* compute the CRC */
1352         x->crc = (x->crc << 8) ^ crc_table[((x->crc >> 16)&0xff) ^ rval];
1353         x->crc &= 0x00ffffff;
1354     }
1355
1356     return rval;
1357 }