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