* options.h, g10.c (main), keyserver.c (keyserver_refresh): Maintain and
[gnupg.git] / g10 / armor.c
1 /* armor.c - Armor flter
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <assert.h>
27 #include <ctype.h>
28
29 #include "errors.h"
30 #include "iobuf.h"
31 #include "memory.h"
32 #include "util.h"
33 #include "filter.h"
34 #include "packet.h"
35 #include "options.h"
36 #include "main.h"
37 #include "status.h"
38 #include "i18n.h"
39
40 #ifdef HAVE_DOSISH_SYSTEM
41   #define LF "\r\n"
42 #else
43   #define LF "\n"
44 #endif
45
46 #define MAX_LINELEN 20000
47
48 #define CRCINIT 0xB704CE
49 #define CRCPOLY 0X864CFB
50 #define CRCUPDATE(a,c) do {                                                 \
51                         a = ((a) << 8) ^ crc_table[((a)&0xff >> 16) ^ (c)]; \
52                         a &= 0x00ffffff;                                    \
53                     } while(0)
54 static u32 crc_table[256];
55 static byte bintoasc[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
56                          "abcdefghijklmnopqrstuvwxyz"
57                          "0123456789+/";
58 static byte asctobin[256]; /* runtime initialized */
59 static int is_initialized;
60
61
62 typedef enum {
63     fhdrHASArmor = 0,
64     fhdrNOArmor,
65     fhdrINIT,
66     fhdrINITCont,
67     fhdrINITSkip,
68     fhdrCHECKBegin,
69     fhdrWAITHeader,
70     fhdrWAITClearsig,
71     fhdrSKIPHeader,
72     fhdrCLEARSIG,
73     fhdrREADClearsig,
74     fhdrNullClearsig,
75     fhdrEMPTYClearsig,
76     fhdrCHECKClearsig,
77     fhdrCHECKClearsig2,
78     fhdrCHECKDashEscaped,
79     fhdrCHECKDashEscaped2,
80     fhdrCHECKDashEscaped3,
81     fhdrREADClearsigNext,
82     fhdrENDClearsig,
83     fhdrENDClearsigHelp,
84     fhdrTESTSpaces,
85     fhdrCLEARSIGSimple,
86     fhdrCLEARSIGSimpleNext,
87     fhdrTEXT,
88     fhdrTEXTSimple,
89     fhdrERROR,
90     fhdrERRORShow,
91     fhdrEOF
92 } fhdr_state_t;
93
94
95 /* if we encounter this armor string with this index, go
96  * into a mode which fakes packets and wait for the next armor */
97 #define BEGIN_SIGNATURE 2
98 #define BEGIN_SIGNED_MSG_IDX 3
99 static char *head_strings[] = {
100     "BEGIN PGP MESSAGE",
101     "BEGIN PGP PUBLIC KEY BLOCK",
102     "BEGIN PGP SIGNATURE",
103     "BEGIN PGP SIGNED MESSAGE",
104     "BEGIN PGP ARMORED FILE",       /* gnupg extension */
105     "BEGIN PGP PRIVATE KEY BLOCK",
106     "BEGIN PGP SECRET KEY BLOCK",   /* only used by pgp2 */
107     NULL
108 };
109 static char *tail_strings[] = {
110     "END PGP MESSAGE",
111     "END PGP PUBLIC KEY BLOCK",
112     "END PGP SIGNATURE",
113     "END dummy",
114     "END PGP ARMORED FILE",
115     "END PGP PRIVATE KEY BLOCK",
116     "END PGP SECRET KEY BLOCK",
117     NULL
118 };
119
120
121
122 static void
123 initialize(void)
124 {
125     int i, j;
126     u32 t;
127     byte *s;
128
129     /* init the crc lookup table */
130     crc_table[0] = 0;
131     for(i=j=0; j < 128; j++ ) {
132         t = crc_table[j];
133         if( t & 0x00800000 ) {
134             t <<= 1;
135             crc_table[i++] = t ^ CRCPOLY;
136             crc_table[i++] = t;
137         }
138         else {
139             t <<= 1;
140             crc_table[i++] = t;
141             crc_table[i++] = t ^ CRCPOLY;
142         }
143     }
144     /* build the helptable for radix64 to bin conversion */
145     for(i=0; i < 256; i++ )
146         asctobin[i] = 255; /* used to detect invalid characters */
147     for(s=bintoasc,i=0; *s; s++,i++ )
148         asctobin[*s] = i;
149
150     is_initialized=1;
151 }
152
153 /****************
154  * Check whether this is an armored file or not See also
155  * parse-packet.c for details on this code For unknown historic
156  * reasons we use a string here but only the first byte will be used.
157  * Returns: True if it seems to be armored
158  */
159 static int
160 is_armored( const byte *buf )
161 {
162     int ctb, pkttype;
163
164     ctb = *buf;
165     if( !(ctb & 0x80) )
166         return 1; /* invalid packet: assume it is armored */
167     pkttype =  ctb & 0x40 ? (ctb & 0x3f) : ((ctb>>2)&0xf);
168     switch( pkttype ) {
169       case PKT_MARKER:
170       case PKT_SYMKEY_ENC:
171       case PKT_ONEPASS_SIG:
172       case PKT_PUBLIC_KEY:
173       case PKT_SECRET_KEY:
174       case PKT_PUBKEY_ENC:
175       case PKT_SIGNATURE:
176       case PKT_COMMENT:
177       case PKT_OLD_COMMENT:
178       case PKT_PLAINTEXT:
179       case PKT_COMPRESSED:
180       case PKT_ENCRYPTED:
181         return 0; /* seems to be a regular packet: not armored */
182     }
183
184     return 1;
185 }
186
187
188 /****************
189  * Try to check whether the iobuf is armored
190  * Returns true if this may be the case; the caller should use the
191  *         filter to do further processing.
192  */
193 int
194 use_armor_filter( IOBUF a )
195 {
196     byte buf[1];
197     int n;
198
199     /* fixme: there might be a problem with iobuf_peek */
200     n = iobuf_peek(a, buf, 1 );
201     if( n == -1 )
202         return 0; /* EOF, doesn't matter whether armored or not */
203     if( !n )
204         return 1; /* can't check it: try armored */
205     return is_armored(buf);
206 }
207
208
209
210
211 static void
212 invalid_armor(void)
213 {
214     write_status(STATUS_BADARMOR);
215     g10_exit(1); /* stop here */
216 }
217
218
219 /****************
220  * check whether the armor header is valid on a signed message.
221  * this is for security reasons: the header lines are not included in the
222  * hash and by using some creative formatting rules, Mallory could fake
223  * any text at the beginning of a document; assuming it is read with
224  * a simple viewer. We only allow the Hash Header.
225  */
226 static int
227 parse_hash_header( const char *line )
228 {
229     const char *s, *s2;
230     unsigned found = 0;
231
232     if( strlen(line) < 6  || strlen(line) > 60 )
233         return 0; /* too short or too long */
234     if( memcmp( line, "Hash:", 5 ) )
235         return 0; /* invalid header */
236     s = line+5;
237     for(s=line+5;;s=s2) {
238         for(; *s && (*s==' ' || *s == '\t'); s++ )
239             ;
240         if( !*s )
241             break;
242         for(s2=s+1; *s2 && *s2!=' ' && *s2 != '\t' && *s2 != ','; s2++ )
243             ;
244         if( !strncmp( s, "RIPEMD160", s2-s ) )
245             found |= 1;
246         else if( !strncmp( s, "SHA1", s2-s ) )
247             found |= 2;
248         else if( !strncmp( s, "MD5", s2-s ) )
249             found |= 4;
250         else if( !strncmp( s, "TIGER192", s2-s ) )
251             found |= 8;
252         else if( !strncmp( s, "TIGER", s2-s ) ) /* used by old versions */
253             found |= 8;
254         else
255             return 0;
256         for(; *s2 && (*s2==' ' || *s2 == '\t'); s2++ )
257             ;
258         if( *s2 && *s2 != ',' )
259             return 0;
260         if( *s2 )
261             s2++;
262     }
263     return found;
264 }
265
266
267
268 /****************
269  * Check whether this is a armor line.
270  * returns: -1 if it is not a armor header or the index number of the
271  * armor header.
272  */
273 static int
274 is_armor_header( byte *line, unsigned len )
275 {
276     const char *s;
277     byte *save_p, *p;
278     int save_c;
279     int i;
280
281     if( len < 15 )
282         return -1; /* too short */
283     if( memcmp( line, "-----", 5 ) )
284         return -1; /* no */
285     p = strstr( line+5, "-----");
286     if( !p )
287         return -1;
288     save_p = p;
289     p += 5;
290
291     /* Some mail programs on Windows seem to add spaces to the end of
292        the line.  This becomes strict if --openpgp is set. */
293
294     if(!opt.rfc2440)
295       while(*p==' ')
296         p++;
297
298     if( *p == '\r' )
299         p++;
300     if( *p == '\n' )
301         p++;
302     if( *p )
303         return -1; /* garbage after dashes */
304     save_c = *save_p; *save_p = 0;
305     p = line+5;
306     for(i=0; (s=head_strings[i]); i++ )
307         if( !strcmp(s, p) )
308             break;
309     *save_p = save_c;
310     if( !s )
311         return -1; /* unknown armor line */
312
313     if( opt.verbose > 1 )
314         log_info(_("armor: %s\n"), head_strings[i]);
315     return i;
316 }
317
318
319
320 /****************
321  * Parse a header lines
322  * Return 0: Empty line (end of header lines)
323  *       -1: invalid header line
324  *       >0: Good header line
325  */
326 static int
327 parse_header_line( armor_filter_context_t *afx, byte *line, unsigned int len )
328 {
329     byte *p;
330     int hashes=0;
331     unsigned int len2;
332
333     len2 = check_trailing_ws( line, len );
334     if( !len2 ) {
335         afx->buffer_pos = len2;  /* (it is not the fine way to do it here) */
336         return 0; /* WS only: same as empty line */
337     }
338     len = len2;
339     line[len2] = 0;
340
341     p = strchr( line, ':');
342     if( !p || !p[1] ) {
343         log_error(_("invalid armor header: "));
344         print_string( stderr, line, len, 0 );
345         putc('\n', stderr);
346         return -1;
347     }
348
349     if( opt.verbose ) {
350         log_info(_("armor header: "));
351         print_string( stderr, line, len, 0 );
352         putc('\n', stderr);
353     }
354
355     if( afx->in_cleartext ) {
356         if( (hashes=parse_hash_header( line )) )
357             afx->hashes |= hashes;
358         else if( strlen(line) > 15 && !memcmp( line, "NotDashEscaped:", 15 ) )
359             afx->not_dash_escaped = 1;
360         else {
361             log_error(_("invalid clearsig header\n"));
362             return -1;
363         }
364     }
365     return 1;
366 }
367
368
369
370 /* figure out whether the data is armored or not */
371 static int
372 check_input( armor_filter_context_t *afx, IOBUF a )
373 {
374     int rc = 0;
375     int i;
376     byte *line;
377     unsigned len;
378     unsigned maxlen;
379     int hdr_line = -1;
380
381     /* read the first line to see whether this is armored data */
382     maxlen = MAX_LINELEN;
383     len = afx->buffer_len = iobuf_read_line( a, &afx->buffer,
384                                              &afx->buffer_size, &maxlen );
385     line = afx->buffer;
386     if( !maxlen ) {
387         /* line has been truncated: assume not armored */
388         afx->inp_checked = 1;
389         afx->inp_bypass = 1;
390         return 0;
391     }
392
393     if( !len ) {
394         return -1; /* eof */
395     }
396
397     /* (the line is always a C string but maybe longer) */
398     if( *line == '\n' || ( len && (*line == '\r' && line[1]=='\n') ) )
399         ;
400     else if( !is_armored( line ) ) {
401         afx->inp_checked = 1;
402         afx->inp_bypass = 1;
403         return 0;
404     }
405
406     /* find the armor header */
407     while(len) {
408         i = is_armor_header( line, len );
409         if( i >= 0 && !(afx->only_keyblocks && i != 1 && i != 5 && i != 6 )) {
410             hdr_line = i;
411             if( hdr_line == BEGIN_SIGNED_MSG_IDX ) {
412                 if( afx->in_cleartext ) {
413                     log_error(_("nested clear text signatures\n"));
414                     rc = G10ERR_INVALID_ARMOR;
415                 }
416                 afx->in_cleartext = 1;
417             }
418             break;
419         }
420         /* read the next line (skip all truncated lines) */
421         do {
422             maxlen = MAX_LINELEN;
423             afx->buffer_len = iobuf_read_line( a, &afx->buffer,
424                                                &afx->buffer_size, &maxlen );
425             line = afx->buffer;
426             len = afx->buffer_len;
427         } while( !maxlen );
428     }
429
430     /* parse the header lines */
431     while(len) {
432         /* read the next line (skip all truncated lines) */
433         do {
434             maxlen = MAX_LINELEN;
435             afx->buffer_len = iobuf_read_line( a, &afx->buffer,
436                                                &afx->buffer_size, &maxlen );
437             line = afx->buffer;
438             len = afx->buffer_len;
439         } while( !maxlen );
440
441         i = parse_header_line( afx, line, len );
442         if( i <= 0 ) {
443             if( i )
444                 rc = G10ERR_INVALID_ARMOR;
445             break;
446         }
447     }
448
449
450     if( rc )
451         invalid_armor();
452     else if( afx->in_cleartext )
453         afx->faked = 1;
454     else {
455         afx->inp_checked = 1;
456         afx->crc = CRCINIT;
457         afx->idx = 0;
458         afx->radbuf[0] = 0;
459     }
460
461     return rc;
462 }
463
464
465
466 /****************
467  * Fake a literal data packet and wait for the next armor line
468  * fixme: empty line handling and null length clear text signature are
469  *        not implemented/checked.
470  */
471 static int
472 fake_packet( armor_filter_context_t *afx, IOBUF a,
473              size_t *retn, byte *buf, size_t size  )
474 {
475     int rc = 0;
476     size_t len = 0;
477     int lastline = 0;
478     unsigned maxlen, n;
479     byte *p;
480
481     len = 2;    /* reserve 2 bytes for the length header */
482     size -= 2;  /* and 2 for the terminating header */
483     while( !rc && len < size ) {
484         /* copy what we have in the line buffer */
485         if( afx->faked == 1 )
486             afx->faked++; /* skip the first (empty) line */
487         else {
488             while( len < size && afx->buffer_pos < afx->buffer_len )
489                 buf[len++] = afx->buffer[afx->buffer_pos++];
490             if( len >= size )
491                 continue;
492         }
493
494         /* read the next line */
495         maxlen = MAX_LINELEN;
496         afx->buffer_pos = 0;
497         afx->buffer_len = iobuf_read_line( a, &afx->buffer,
498                                            &afx->buffer_size, &maxlen );
499         if( !afx->buffer_len ) {
500             rc = -1; /* eof (should not happen) */
501             continue;
502         }
503         if( !maxlen )
504             afx->truncated++;
505         if( !afx->not_dash_escaped ) {
506             int crlf;
507             p = afx->buffer;
508             n = afx->buffer_len;
509             crlf = n > 1 && p[n-2] == '\r' && p[n-1]=='\n';
510
511             /* PGP2 does not treat a tab as white space character */
512             afx->buffer_len = trim_trailing_chars( p, n,
513                                          afx->pgp2mode ? " \r\n" : " \t\r\n");
514             /* the buffer is always allocated with enough space to append
515              * the removed [CR], LF and a Nul
516              * The reason for this complicated procedure is to keep at least
517              * the original type of lineending - handling of the removed
518              * trailing spaces seems to be impossible in our method
519              * of faking a packet; either we have to use a temporary file
520              * or calculate the hash here in this module and somehow find
521              * a way to send the hash down the processing line (well, a special
522              * faked packet could do the job).
523              */
524             if( crlf )
525                 afx->buffer[afx->buffer_len++] = '\r';
526             afx->buffer[afx->buffer_len++] = '\n';
527             afx->buffer[afx->buffer_len] = 0;
528         }
529         p = afx->buffer;
530         n = afx->buffer_len;
531
532         if( n > 2 && *p == '-' ) {
533             /* check for dash escaped or armor header */
534             if( p[1] == ' ' && !afx->not_dash_escaped ) {
535                 /* issue a warning if it is not regular encoded */
536                 if( p[2] != '-' && !( n > 6 && !memcmp(p+2, "From ", 5))) {
537                     log_info(_("invalid dash escaped line: "));
538                     print_string( stderr, p, n, 0 );
539                     putc('\n', stderr);
540                 }
541                 afx->buffer_pos = 2; /* skip */
542             }
543             else if( n >= 15 &&  p[1] == '-' && p[2] == '-' && p[3] == '-' ) {
544                 int type = is_armor_header( p, n );
545                 if( afx->not_dash_escaped && type != BEGIN_SIGNATURE )
546                     ; /* this is okay */
547                 else {
548                     if( type != BEGIN_SIGNATURE ) {
549                         log_info(_("unexpected armor:"));
550                         print_string( stderr, p, n, 0 );
551                         putc('\n', stderr);
552                     }
553                     lastline = 1;
554                     rc = -1;
555                 }
556             }
557         }
558     }
559
560     buf[0] = (len-2) >> 8;
561     buf[1] = (len-2);
562     if( lastline ) { /* write last (ending) length header */
563         if( buf[0] || buf[1] ) { /* only if we have some text */
564             buf[len++] = 0;
565             buf[len++] = 0;
566         }
567         rc = 0;
568         afx->faked = 0;
569         afx->in_cleartext = 0;
570         /* and now read the header lines */
571         afx->buffer_pos = 0;
572         for(;;) {
573             int i;
574
575             /* read the next line (skip all truncated lines) */
576             do {
577                 maxlen = MAX_LINELEN;
578                 afx->buffer_len = iobuf_read_line( a, &afx->buffer,
579                                                  &afx->buffer_size, &maxlen );
580             } while( !maxlen );
581             p = afx->buffer;
582             n = afx->buffer_len;
583             if( !n ) {
584                 rc = -1;
585                 break; /* eof */
586             }
587             i = parse_header_line( afx, p , n );
588             if( i <= 0 ) {
589                 if( i )
590                     invalid_armor();
591                 break;
592             }
593         }
594         afx->inp_checked = 1;
595         afx->crc = CRCINIT;
596         afx->idx = 0;
597         afx->radbuf[0] = 0;
598     }
599
600     *retn = len;
601     return rc;
602 }
603
604
605 static int
606 invalid_crc(void)
607 {
608     if ( opt.ignore_crc_error )
609         return 0;
610     log_inc_errorcount();
611     return G10ERR_INVALID_ARMOR;
612 }
613
614
615 static int
616 radix64_read( armor_filter_context_t *afx, IOBUF a, size_t *retn,
617               byte *buf, size_t size )
618 {
619     byte val;
620     int c=0, c2; /*init c because gcc is not clever enough for the continue*/
621     int checkcrc=0;
622     int rc = 0;
623     size_t n = 0;
624     int  idx, i;
625     u32 crc;
626
627     crc = afx->crc;
628     idx = afx->idx;
629     val = afx->radbuf[0];
630     for( n=0; n < size; ) {
631
632         if( afx->buffer_pos < afx->buffer_len )
633             c = afx->buffer[afx->buffer_pos++];
634         else { /* read the next line */
635             unsigned maxlen = MAX_LINELEN;
636             afx->buffer_pos = 0;
637             afx->buffer_len = iobuf_read_line( a, &afx->buffer,
638                                                &afx->buffer_size, &maxlen );
639             if( !maxlen )
640                 afx->truncated++;
641             if( !afx->buffer_len )
642                 break; /* eof */
643             continue;
644         }
645
646       again:
647         if( c == '\n' || c == ' ' || c == '\r' || c == '\t' )
648             continue;
649         else if( c == '=' ) { /* pad character: stop */
650             /* some mailers leave quoted-printable encoded characters
651              * so we try to workaround this */
652             if( afx->buffer_pos+2 < afx->buffer_len ) {
653                 int cc1, cc2, cc3;
654                 cc1 = afx->buffer[afx->buffer_pos];
655                 cc2 = afx->buffer[afx->buffer_pos+1];
656                 cc3 = afx->buffer[afx->buffer_pos+2];
657                 if( isxdigit(cc1) && isxdigit(cc2)
658                                   && strchr( "=\n\r\t ", cc3 )) {
659                     /* well it seems to be the case - adjust */
660                     c = isdigit(cc1)? (cc1 - '0'): (ascii_toupper(cc1)-'A'+10);
661                     c <<= 4;
662                     c |= isdigit(cc2)? (cc2 - '0'): (ascii_toupper(cc2)-'A'+10);
663                     afx->buffer_pos += 2;
664                     afx->qp_detected = 1;
665                     goto again;
666                 }
667             }
668
669             if( idx == 1 )
670                 buf[n++] = val;
671             checkcrc++;
672             break;
673         }
674         else if( (c = asctobin[(c2=c)]) == 255 ) {
675             log_error(_("invalid radix64 character %02x skipped\n"), c2);
676             continue;
677         }
678         switch(idx) {
679           case 0: val =  c << 2; break;
680           case 1: val |= (c>>4)&3; buf[n++]=val;val=(c<<4)&0xf0;break;
681           case 2: val |= (c>>2)&15; buf[n++]=val;val=(c<<6)&0xc0;break;
682           case 3: val |= c&0x3f; buf[n++] = val; break;
683         }
684         idx = (idx+1) % 4;
685     }
686
687     for(i=0; i < n; i++ )
688         crc = (crc << 8) ^ crc_table[((crc >> 16)&0xff) ^ buf[i]];
689     crc &= 0x00ffffff;
690     afx->crc = crc;
691     afx->idx = idx;
692     afx->radbuf[0] = val;
693
694     if( checkcrc ) {
695         afx->any_data = 1;
696         afx->inp_checked=0;
697         afx->faked = 0;
698         for(;;) { /* skip lf and pad characters */
699             if( afx->buffer_pos < afx->buffer_len )
700                 c = afx->buffer[afx->buffer_pos++];
701             else { /* read the next line */
702                 unsigned maxlen = MAX_LINELEN;
703                 afx->buffer_pos = 0;
704                 afx->buffer_len = iobuf_read_line( a, &afx->buffer,
705                                                    &afx->buffer_size, &maxlen );
706                 if( !maxlen )
707                     afx->truncated++;
708                 if( !afx->buffer_len )
709                     break; /* eof */
710                 continue;
711             }
712             if( c == '\n' || c == ' ' || c == '\r'
713                 || c == '\t' || c == '=' )
714                 continue;
715             break;
716         }
717         if( c == -1 )
718             log_error(_("premature eof (no CRC)\n"));
719         else {
720             u32 mycrc = 0;
721             idx = 0;
722             do {
723                 if( (c = asctobin[c]) == 255 )
724                     break;
725                 switch(idx) {
726                   case 0: val =  c << 2; break;
727                   case 1: val |= (c>>4)&3; mycrc |= val << 16;val=(c<<4)&0xf0;break;
728                   case 2: val |= (c>>2)&15; mycrc |= val << 8;val=(c<<6)&0xc0;break;
729                   case 3: val |= c&0x3f; mycrc |= val; break;
730                 }
731                 for(;;) {
732                     if( afx->buffer_pos < afx->buffer_len )
733                         c = afx->buffer[afx->buffer_pos++];
734                     else { /* read the next line */
735                         unsigned maxlen = MAX_LINELEN;
736                         afx->buffer_pos = 0;
737                         afx->buffer_len = iobuf_read_line( a, &afx->buffer,
738                                                            &afx->buffer_size,
739                                                                 &maxlen );
740                         if( !maxlen )
741                             afx->truncated++;
742                         if( !afx->buffer_len )
743                             break; /* eof */
744                         continue;
745                     }
746                     break;
747                 }
748                 if( !afx->buffer_len )
749                     break; /* eof */
750             } while( ++idx < 4 );
751             if( c == -1 ) {
752                 log_info(_("premature eof (in CRC)\n"));
753                 rc = invalid_crc();
754                             }
755             else if( idx != 4 ) {
756                 log_info(_("malformed CRC\n"));
757                 rc = invalid_crc();
758             }
759             else if( mycrc != afx->crc ) {
760                 log_info (_("CRC error; %06lx - %06lx\n"),
761                                     (ulong)afx->crc, (ulong)mycrc);
762                 rc = invalid_crc();
763             }
764             else {
765                 rc = 0;
766                 /* FIXME: Here we should emit another control packet,
767                  * so that we know in mainproc that we are processing
768                  * a clearsign message */
769               #if 0
770                 for(rc=0;!rc;) {
771                     rc = 0 /*check_trailer( &fhdr, c )*/;
772                     if( !rc ) {
773                         if( (c=iobuf_get(a)) == -1 )
774                             rc = 2;
775                     }
776                 }
777                 if( rc == -1 )
778                     rc = 0;
779                 else if( rc == 2 ) {
780                     log_error(_("premature eof (in Trailer)\n"));
781                     rc = G10ERR_INVALID_ARMOR;
782                 }
783                 else {
784                     log_error(_("error in trailer line\n"));
785                     rc = G10ERR_INVALID_ARMOR;
786                 }
787               #endif
788             }
789         }
790     }
791
792     if( !n )
793         rc = -1;
794
795     *retn = n;
796     return rc;
797 }
798
799 /****************
800  * This filter is used to handle the armor stuff
801  */
802 int
803 armor_filter( void *opaque, int control,
804              IOBUF a, byte *buf, size_t *ret_len)
805 {
806     size_t size = *ret_len;
807     armor_filter_context_t *afx = opaque;
808     int rc=0, i, c;
809     byte radbuf[3];
810     int  idx, idx2;
811     size_t n=0;
812     u32 crc;
813   #if 0
814     static FILE *fp ;
815
816     if( !fp ) {
817         fp = fopen("armor.out", "w");
818         assert(fp);
819     }
820   #endif
821
822     if( DBG_FILTER )
823         log_debug("armor-filter: control: %d\n", control );
824     if( control == IOBUFCTRL_UNDERFLOW && afx->inp_bypass ) {
825         n = 0;
826         if( afx->buffer_len ) {
827             for(; n < size && afx->buffer_pos < afx->buffer_len; n++ )
828                 buf[n++] = afx->buffer[afx->buffer_pos++];
829             if( afx->buffer_pos >= afx->buffer_len )
830                 afx->buffer_len = 0;
831         }
832         for(; n < size; n++ ) {
833             if( (c=iobuf_get(a)) == -1 )
834                 break;
835             buf[n] = c & 0xff;
836         }
837         if( !n )
838             rc = -1;
839         *ret_len = n;
840     }
841     else if( control == IOBUFCTRL_UNDERFLOW ) {
842         /* We need some space for the faked packet.  The minmum required
843          * size is ~18 + length of the session marker */
844         if( size < 50 ) 
845             BUG(); /* supplied buffer too short */
846
847         if( afx->faked )
848             rc = fake_packet( afx, a, &n, buf, size );
849         else if( !afx->inp_checked ) {
850             rc = check_input( afx, a );
851             if( afx->inp_bypass ) {
852                 for(n=0; n < size && afx->buffer_pos < afx->buffer_len; )
853                     buf[n++] = afx->buffer[afx->buffer_pos++];
854                 if( afx->buffer_pos >= afx->buffer_len )
855                     afx->buffer_len = 0;
856                 if( !n )
857                     rc = -1;
858             }
859             else if( afx->faked ) {
860                 unsigned int hashes = afx->hashes;
861                 const byte *sesmark;
862                 size_t sesmarklen;
863                 
864                 sesmark = get_session_marker( &sesmarklen );
865                 if ( sesmarklen > 20 )
866                     BUG();
867
868                 /* the buffer is at least 15+n*15 bytes long, so it
869                  * is easy to construct the packets */
870
871                 hashes &= 1|2|4|8;
872                 if( !hashes ) {
873                     hashes |= 4;  /* default to MD 5 */
874                     if( opt.pgp2_workarounds )
875                         afx->pgp2mode = 1;
876                 }
877                 n=0;
878                 /* first a gpg control packet */
879                 buf[n++] = 0xff; /* new format, type 63, 1 length byte */
880                 n++;   /* see below */
881                 memcpy(buf+n, sesmark, sesmarklen ); n+= sesmarklen;
882                 buf[n++] = CTRLPKT_CLEARSIGN_START; 
883                 buf[n++] = afx->not_dash_escaped? 0:1; /* sigclass */
884                 if( hashes & 1 ) 
885                     buf[n++] = DIGEST_ALGO_RMD160;
886                 if( hashes & 2 ) 
887                     buf[n++] = DIGEST_ALGO_SHA1;
888                 if( hashes & 4 ) 
889                     buf[n++] = DIGEST_ALGO_MD5;
890                 if( hashes & 8 ) 
891                     buf[n++] = DIGEST_ALGO_TIGER;
892                 buf[1] = n - 2;
893
894                 /* followed by a plaintext packet */
895                 buf[n++] = 0xaf; /* old packet format, type 11, var length */
896                 buf[n++] = 0;    /* set the length header */
897                 buf[n++] = 6;
898                 buf[n++] = 't';  /* canonical text mode */
899                 buf[n++] = 0;    /* namelength */
900                 memset(buf+n, 0, 4); /* timestamp */
901                 n += 4;
902             }
903             else if( !rc )
904                 rc = radix64_read( afx, a, &n, buf, size );
905         }
906         else
907             rc = radix64_read( afx, a, &n, buf, size );
908       #if 0
909         if( n )
910             if( fwrite(buf, n, 1, fp ) != 1 )
911                 BUG();
912       #endif
913         *ret_len = n;
914     }
915     else if( control == IOBUFCTRL_FLUSH && !afx->cancel ) {
916         if( !afx->status ) { /* write the header line */
917             const char *s;
918
919             if( afx->what >= DIM(head_strings) )
920                 log_bug("afx->what=%d", afx->what);
921             iobuf_writestr(a, "-----");
922             iobuf_writestr(a, head_strings[afx->what] );
923             iobuf_writestr(a, "-----" LF );
924             if( !opt.no_version )
925                 iobuf_writestr(a, "Version: GnuPG v"  VERSION " ("
926                                               PRINTABLE_OS_NAME ")" LF );
927
928             /* write the comment string or a default one */
929             s = opt.comment_string;
930             if( s && *s ) {
931                 iobuf_writestr(a, "Comment: " );
932                 for( ; *s; s++ ) {
933                     if( *s == '\n' )
934                         iobuf_writestr(a, "\\n" );
935                     else if( *s == '\r' )
936                         iobuf_writestr(a, "\\r" );
937                     else if( *s == '\v' )
938                         iobuf_writestr(a, "\\v" );
939                     else
940                         iobuf_put(a, *s );
941                 }
942                 iobuf_writestr(a, LF );
943             }
944
945             if ( afx->hdrlines ) {
946                 for ( s = afx->hdrlines; *s; s++ ) {
947                   #ifdef HAVE_DOSISH_SYSTEM
948                     if ( *s == '\n' )
949                         iobuf_put( a, '\r');
950                   #endif
951                     iobuf_put(a, *s );
952                 }
953             }
954             iobuf_writestr(a, LF );
955             afx->status++;
956             afx->idx = 0;
957             afx->idx2 = 0;
958             afx->crc = CRCINIT;
959
960         }
961         crc = afx->crc;
962         idx = afx->idx;
963         idx2 = afx->idx2;
964         for(i=0; i < idx; i++ )
965             radbuf[i] = afx->radbuf[i];
966
967         for(i=0; i < size; i++ )
968             crc = (crc << 8) ^ crc_table[((crc >> 16)&0xff) ^ buf[i]];
969         crc &= 0x00ffffff;
970
971         for( ; size; buf++, size-- ) {
972             radbuf[idx++] = *buf;
973             if( idx > 2 ) {
974                 idx = 0;
975                 c = bintoasc[(*radbuf >> 2) & 077];
976                 iobuf_put(a, c);
977                 c = bintoasc[(((*radbuf<<4)&060)|((radbuf[1] >> 4)&017))&077];
978                 iobuf_put(a, c);
979                 c = bintoasc[(((radbuf[1]<<2)&074)|((radbuf[2]>>6)&03))&077];
980                 iobuf_put(a, c);
981                 c = bintoasc[radbuf[2]&077];
982                 iobuf_put(a, c);
983                 if( ++idx2 >= (64/4) ) { /* pgp doesn't like 72 here */
984                     iobuf_writestr(a, LF );
985                     idx2=0;
986                 }
987             }
988         }
989         for(i=0; i < idx; i++ )
990             afx->radbuf[i] = radbuf[i];
991         afx->idx = idx;
992         afx->idx2 = idx2;
993         afx->crc  = crc;
994     }
995     else if( control == IOBUFCTRL_INIT ) {
996         if( !is_initialized )
997             initialize();
998     }
999     else if( control == IOBUFCTRL_CANCEL ) {
1000         afx->cancel = 1;
1001     }
1002     else if( control == IOBUFCTRL_FREE ) {
1003         if( afx->cancel )
1004             ;
1005         else if( afx->status ) { /* pad, write cecksum, and bottom line */
1006             crc = afx->crc;
1007             idx = afx->idx;
1008             idx2 = afx->idx2;
1009             for(i=0; i < idx; i++ )
1010                 radbuf[i] = afx->radbuf[i];
1011             if( idx ) {
1012                 c = bintoasc[(*radbuf>>2)&077];
1013                 iobuf_put(a, c);
1014                 if( idx == 1 ) {
1015                     c = bintoasc[((*radbuf << 4) & 060) & 077];
1016                     iobuf_put(a, c);
1017                     iobuf_put(a, '=');
1018                     iobuf_put(a, '=');
1019                 }
1020                 else { /* 2 */
1021                     c = bintoasc[(((*radbuf<<4)&060)|((radbuf[1]>>4)&017))&077];
1022                     iobuf_put(a, c);
1023                     c = bintoasc[((radbuf[1] << 2) & 074) & 077];
1024                     iobuf_put(a, c);
1025                     iobuf_put(a, '=');
1026                 }
1027                 if( ++idx2 >= (64/4) ) { /* pgp doesn't like 72 here */
1028                     iobuf_writestr(a, LF );
1029                     idx2=0;
1030                 }
1031             }
1032             /* may need a linefeed */
1033             if( idx2 )
1034                 iobuf_writestr(a, LF );
1035             /* write the CRC */
1036             iobuf_put(a, '=');
1037             radbuf[0] = crc >>16;
1038             radbuf[1] = crc >> 8;
1039             radbuf[2] = crc;
1040             c = bintoasc[(*radbuf >> 2) & 077];
1041             iobuf_put(a, c);
1042             c = bintoasc[(((*radbuf<<4)&060)|((radbuf[1] >> 4)&017))&077];
1043             iobuf_put(a, c);
1044             c = bintoasc[(((radbuf[1]<<2)&074)|((radbuf[2]>>6)&03))&077];
1045             iobuf_put(a, c);
1046             c = bintoasc[radbuf[2]&077];
1047             iobuf_put(a, c);
1048             iobuf_writestr(a, LF );
1049             /* and the the trailer */
1050             if( afx->what >= DIM(tail_strings) )
1051                 log_bug("afx->what=%d", afx->what);
1052             iobuf_writestr(a, "-----");
1053             iobuf_writestr(a, tail_strings[afx->what] );
1054             iobuf_writestr(a, "-----" LF );
1055         }
1056         else if( !afx->any_data && !afx->inp_bypass ) {
1057             log_error(_("no valid OpenPGP data found.\n"));
1058             afx->no_openpgp_data = 1;
1059             write_status_text( STATUS_NODATA, "1" );
1060         }
1061         if( afx->truncated )
1062             log_info(_("invalid armor: line longer than %d characters\n"),
1063                       MAX_LINELEN );
1064         /* issue an error to enforce dissemination of correct software */
1065         if( afx->qp_detected )
1066             log_error(_("quoted printable character in armor - "
1067                         "probably a buggy MTA has been used\n") );
1068         m_free( afx->buffer );
1069         afx->buffer = NULL;
1070     }
1071     else if( control == IOBUFCTRL_DESC )
1072         *(char**)buf = "armor_filter";
1073     return rc;
1074 }
1075
1076
1077 /****************
1078  * create a radix64 encoded string.
1079  */
1080 char *
1081 make_radix64_string( const byte *data, size_t len )
1082 {
1083     char *buffer, *p;
1084
1085     buffer = p = m_alloc( (len+2)/3*4 + 1 );
1086     for( ; len >= 3 ; len -= 3, data += 3 ) {
1087         *p++ = bintoasc[(data[0] >> 2) & 077];
1088         *p++ = bintoasc[(((data[0] <<4)&060)|((data[1] >> 4)&017))&077];
1089         *p++ = bintoasc[(((data[1]<<2)&074)|((data[2]>>6)&03))&077];
1090         *p++ = bintoasc[data[2]&077];
1091     }
1092     if( len == 2 ) {
1093         *p++ = bintoasc[(data[0] >> 2) & 077];
1094         *p++ = bintoasc[(((data[0] <<4)&060)|((data[1] >> 4)&017))&077];
1095         *p++ = bintoasc[((data[1]<<2)&074)];
1096     }
1097     else if( len == 1 ) {
1098         *p++ = bintoasc[(data[0] >> 2) & 077];
1099         *p++ = bintoasc[(data[0] <<4)&060];
1100     }
1101     *p = 0;
1102     return buffer;
1103 }
1104
1105
1106 /***********************************************
1107  *  For the pipemode command we can't use the armor filter for various
1108  *  reasons, so we use this new unarmor_pump stuff to remove the armor 
1109  */
1110
1111 enum unarmor_state_e {
1112     STA_init = 0,
1113     STA_bypass,
1114     STA_wait_newline,
1115     STA_wait_dash,
1116     STA_first_dash, 
1117     STA_compare_header,
1118     STA_found_header_wait_newline,
1119     STA_skip_header_lines,
1120     STA_skip_header_lines_non_ws,
1121     STA_read_data,
1122     STA_wait_crc,
1123     STA_read_crc,
1124     STA_ready
1125 };
1126
1127 struct unarmor_pump_s {
1128     enum unarmor_state_e state;
1129     byte val;
1130     int checkcrc;
1131     int pos;   /* counts from 0..3 */
1132     u32 crc;
1133     u32 mycrc; /* the one store in the data */
1134 };
1135
1136
1137
1138 UnarmorPump
1139 unarmor_pump_new (void)
1140 {
1141     UnarmorPump x;
1142
1143     if( !is_initialized )
1144         initialize();
1145     x = m_alloc_clear (sizeof *x);
1146     return x;
1147 }
1148
1149 void
1150 unarmor_pump_release (UnarmorPump x)
1151 {
1152     m_free (x);
1153 }
1154
1155 /* 
1156  * Get the next character from the ascii armor taken from the IOBUF
1157  * created earlier by unarmor_pump_new().
1158  * Return:  c = Character
1159  *        256 = ignore this value
1160  *         -1 = End of current armor 
1161  *         -2 = Premature EOF (not used)
1162  *         -3 = Invalid armor
1163  */
1164 int
1165 unarmor_pump (UnarmorPump x, int c)
1166 {
1167     int rval = 256; /* default is to ignore the return value */
1168
1169     switch (x->state) {
1170       case STA_init:
1171         { 
1172             byte tmp[1];
1173             tmp[0] = c; 
1174             if ( is_armored (tmp) )
1175                 x->state = c == '-'? STA_first_dash : STA_wait_newline;
1176             else {
1177                 x->state = STA_bypass;
1178                 return c;
1179             }
1180         }
1181         break;
1182       case STA_bypass:
1183         return c; /* return here to avoid crc calculation */
1184       case STA_wait_newline:
1185         if (c == '\n')
1186             x->state = STA_wait_dash;
1187         break;
1188       case STA_wait_dash:
1189         x->state = c == '-'? STA_first_dash : STA_wait_newline;
1190         break;
1191       case STA_first_dash: /* just need for initalization */
1192         x->pos = 0;
1193         x->state = STA_compare_header;
1194       case STA_compare_header:
1195         if ( "-----BEGIN PGP SIGNATURE-----"[++x->pos] == c ) {
1196             if ( x->pos == 28 ) 
1197                 x->state = STA_found_header_wait_newline;
1198         }
1199         else 
1200             x->state = c == '\n'? STA_wait_dash : STA_wait_newline;
1201         break;
1202       case STA_found_header_wait_newline:
1203         /* to make CR,LF issues easier we simply allow for white space
1204            behind the 5 dashes */
1205         if ( c == '\n' )
1206             x->state = STA_skip_header_lines;
1207         else if ( c != '\r' && c != ' ' && c != '\t' )
1208             x->state = STA_wait_dash; /* garbage after the header line */
1209         break;
1210       case STA_skip_header_lines:
1211         /* i.e. wait for one empty line */
1212         if ( c == '\n' ) {
1213             x->state = STA_read_data;
1214             x->crc = CRCINIT;
1215             x->val = 0;
1216             x->pos = 0;
1217         }
1218         else if ( c != '\r' && c != ' ' && c != '\t' )
1219             x->state = STA_skip_header_lines_non_ws;
1220         break;
1221       case STA_skip_header_lines_non_ws:
1222         /* like above but we already encountered non white space */
1223         if ( c == '\n' )
1224             x->state = STA_skip_header_lines;
1225         break;
1226       case STA_read_data:
1227         /* fixme: we don't check for the trailing dash lines but rely
1228          * on the armor stop characters */
1229         if( c == '\n' || c == ' ' || c == '\r' || c == '\t' )
1230             break; /* skip all kind of white space */
1231
1232         if( c == '=' ) { /* pad character: stop */
1233             if( x->pos == 1 ) /* in this case val has some value */
1234                 rval = x->val;
1235             x->state = STA_wait_crc;
1236             break;
1237         }
1238
1239         {
1240             int c2;
1241             if( (c = asctobin[(c2=c)]) == 255 ) {
1242                 log_error(_("invalid radix64 character %02x skipped\n"), c2);
1243                 break;
1244             }
1245         }
1246         
1247         switch(x->pos) {
1248           case 0:
1249             x->val = c << 2;
1250             break;
1251           case 1:
1252             x->val |= (c>>4)&3;
1253             rval = x->val;
1254             x->val = (c<<4)&0xf0;
1255             break;
1256           case 2:
1257             x->val |= (c>>2)&15;
1258             rval = x->val;
1259             x->val = (c<<6)&0xc0;
1260             break;
1261           case 3:
1262             x->val |= c&0x3f;
1263             rval = x->val;
1264             break;
1265         }
1266         x->pos = (x->pos+1) % 4;
1267         break;
1268       case STA_wait_crc:
1269         if( c == '\n' || c == ' ' || c == '\r' || c == '\t' || c == '=' )
1270             break; /* skip ws and pad characters */
1271         /* assume that we are at the next line */
1272         x->state = STA_read_crc;
1273         x->pos = 0;
1274         x->mycrc = 0;
1275       case STA_read_crc:
1276         if( (c = asctobin[c]) == 255 ) {
1277             rval = -1; /* ready */
1278             if( x->crc != x->mycrc ) {
1279                 log_info (_("CRC error; %06lx - %06lx\n"),
1280                           (ulong)x->crc, (ulong)x->mycrc);
1281                 if ( invalid_crc() )
1282                     rval = -3;
1283             }
1284             x->state = STA_ready; /* not sure whether this is correct */
1285             break;
1286         }
1287         
1288         switch(x->pos) {
1289           case 0:
1290             x->val = c << 2;
1291             break;
1292           case 1:
1293             x->val |= (c>>4)&3;
1294             x->mycrc |= x->val << 16;
1295             x->val = (c<<4)&0xf0;
1296             break;
1297           case 2:
1298             x->val |= (c>>2)&15;
1299             x->mycrc |= x->val << 8;
1300             x->val = (c<<6)&0xc0;
1301             break;
1302           case 3:
1303             x->val |= c&0x3f;
1304             x->mycrc |= x->val;
1305             break;
1306         }
1307         x->pos = (x->pos+1) % 4;
1308         break;
1309       case STA_ready:
1310         rval = -1;
1311         break;
1312     }
1313
1314     if ( !(rval & ~255) ) { /* compute the CRC */
1315         x->crc = (x->crc << 8) ^ crc_table[((x->crc >> 16)&0xff) ^ rval];
1316         x->crc &= 0x00ffffff;
1317     }
1318
1319     return rval;
1320 }
1321
1322