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