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