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