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