changes from laptop
[gnupg.git] / g10 / armor.c
1 /* armor.c - Armor filter
2  *      Copyright (C) 1998 Free Software Foundation, Inc.
3  *
4  * This file is part of GNUPG.
5  *
6  * GNUPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GNUPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <assert.h>
27
28 #include "errors.h"
29 #include "iobuf.h"
30 #include "memory.h"
31 #include "util.h"
32 #include "filter.h"
33 #include "packet.h"
34 #include "options.h"
35 #include "main.h"
36 #include "status.h"
37
38
39 #define CRCINIT 0xB704CE
40 #define CRCPOLY 0X864CFB
41 #define CRCUPDATE(a,c) do {                                                 \
42                         a = ((a) << 8) ^ crc_table[((a)&0xff >> 16) ^ (c)]; \
43                         a &= 0x00ffffff;                                    \
44                     } while(0)
45 static u32 crc_table[256];
46 static byte bintoasc[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
47                          "abcdefghijklmnopqrstuvwxyz"
48                          "0123456789+/";
49 static byte asctobin[256]; /* runtime initialized */
50 static int is_initialized;
51
52
53 typedef enum {
54     fhdrHASArmor,
55     fhdrNOArmor,
56     fhdrINIT,
57     fhdrINITCont,
58     fhdrINITSkip,
59     fhdrCHECKBegin,
60     fhdrWAITHeader,
61     fhdrWAITClearsig,
62     fhdrSKIPHeader,
63     fhdrCLEARSIG,
64     fhdrREADClearsig,
65     fhdrEMPTYClearsig,
66     fhdrCHECKClearsig,
67     fhdrCHECKClearsig2,
68     fhdrCHECKDashEscaped,
69     fhdrCHECKDashEscaped2,
70     fhdrCHECKDashEscaped3,
71     fhdrREADClearsigNext,
72     fhdrENDClearsig,
73     fhdrENDClearsigHelp,
74     fhdrTESTSpaces,
75     fhdrTEXT,
76     fhdrERROR,
77     fhdrERRORShow,
78     fhdrEOF
79 } fhdr_state_t;
80
81
82 /* if we encounter this armor string with this index, go
83  * into a mode which fakes packets and wait for the next armor */
84 #define BEGIN_SIGNED_MSG_IDX 3
85 static char *head_strings[] = {
86     "BEGIN PGP MESSAGE",
87     "BEGIN PGP PUBLIC KEY BLOCK",
88     "BEGIN PGP SIGNATURE",
89     "BEGIN PGP SIGNED MESSAGE",
90     "BEGIN PGP ARMORED FILE",
91     NULL
92 };
93 static char *tail_strings[] = {
94     "END PGP MESSAGE",
95     "END PGP PUBLIC KEY BLOCK",
96     "END PGP SIGNATURE",
97     "END dummy",
98     "END PGP ARMORED FILE",
99     NULL
100 };
101
102
103 static fhdr_state_t find_header( fhdr_state_t state, byte *buf,
104                      size_t *r_buflen, IOBUF a, size_t n, unsigned *r_empty);
105
106
107 static void
108 initialize(void)
109 {
110     int i, j;
111     u32 t;
112     byte *s;
113
114     /* init the crc lookup table */
115     crc_table[0] = 0;
116     for(i=j=0; j < 128; j++ ) {
117         t = crc_table[j];
118         if( t & 0x00800000 ) {
119             t <<= 1;
120             crc_table[i++] = t ^ CRCPOLY;
121             crc_table[i++] = t;
122         }
123         else {
124             t <<= 1;
125             crc_table[i++] = t;
126             crc_table[i++] = t ^ CRCPOLY;
127         }
128     }
129     /* build the helptable for radix64 to bin conversion */
130     for(i=0; i < 256; i++ )
131         asctobin[i] = 255; /* used to detect invalid characters */
132     for(s=bintoasc,i=0; *s; s++,i++ )
133         asctobin[*s] = i;
134
135     is_initialized=1;
136 }
137
138 /****************
139  * Check whether this is an armored file or not
140  * See also parse-packet.c for details on this code
141  * Returns: True if it seems to be armored
142  */
143 static int
144 is_armored( byte *buf )
145 {
146     int ctb, pkttype;
147
148     ctb = *buf;
149     if( !(ctb & 0x80) )
150         return 1; /* invalid packet: assume it is armored */
151     pkttype =  ctb & 0x40 ? (ctb & 0x3f) : ((ctb>>2)&0xf);
152     switch( pkttype ) {
153       case PKT_MARKER:
154       case PKT_PUBLIC_CERT:
155       case PKT_SECRET_CERT:
156       case PKT_PUBKEY_ENC:
157       case PKT_SIGNATURE:
158       case PKT_COMMENT:
159       case PKT_PLAINTEXT:
160       case PKT_COMPRESSED:
161       case PKT_ENCRYPTED:
162         return 0; /* seems to be a regular packet: not armored */
163     }
164
165     return 1;
166 }
167
168
169 /****************
170  * Try to check whether the iobuf is armored
171  * Returns true if this may be the case; the caller should use the
172  *         filter to do further processing.
173  */
174 int
175 use_armor_filter( IOBUF a )
176 {
177     byte buf[1];
178     int n;
179
180     n = iobuf_peek(a, buf, 1 );
181     if( n == -1 )
182         return 0; /* EOF, doesn't matter whether armored or not */
183     if( !n )
184         return 1; /* can't check it: try armored */
185     return is_armored(buf);
186 }
187
188
189
190
191 static void
192 invalid_armor(void)
193 {
194     write_status(STATUS_BADARMOR);
195     g10_exit(1); /* stop here */
196 }
197
198
199 /****************
200  * check whether the armor header is valid on a signed message.
201  * this is for security reasons: the header lines are not included in the
202  * hash and by using some creative formatting rules, Mallory could fake
203  * any text at the beginning of a document; assuming it is read with
204  * a simple viewer. We only allow the Hash Header.
205  */
206 static int
207 parse_hash_header( const char *line )
208 {
209     const char *s, *s2;
210     unsigned found = 0;
211
212     if( strlen(line) < 6  || strlen(line) > 60 )
213         return 0; /* too short or too long */
214     if( memcmp( line, "Hash:", 5 ) )
215         return 0; /* invalid header */
216     s = line+5;
217     for(s=line+5;;s=s2) {
218         for(; *s && (*s==' ' || *s == '\t'); s++ )
219             ;
220         if( !*s )
221             break;
222         for(s2=s+1; *s2 && *s2!=' ' && *s2 != '\t' && *s2 != ','; s2++ )
223             ;
224         if( !strncmp( s, "RIPEMD160", s2-s ) )
225             found |= 1;
226         else if( !strncmp( s, "SHA1", s2-s ) )
227             found |= 2;
228         else if( !strncmp( s, "MD5", s2-s ) )
229             found |= 4;
230         else if( !strncmp( s, "MD2", s2-s ) )
231             found |= 8;
232         else
233             return 0;
234         for(; *s2 && (*s2==' ' || *s2 == '\t'); s2++ )
235             ;
236         if( *s2 && *s2 != ',' )
237             return 0;
238         if( *s2 )
239             s2++;
240     }
241     return found;
242 }
243
244
245 /****************
246  * parse an ascii armor.
247  * Returns: the state,
248  *          the remaining bytes in BUF are returned in RBUFLEN.
249  *          r_empty return the # of empty lines before the buffer
250  */
251 static fhdr_state_t
252 find_header( fhdr_state_t state, byte *buf, size_t *r_buflen,
253                                         IOBUF a, size_t n, unsigned *r_empty)
254 {
255     int c=0, i;
256     const char *s;
257     byte *p;
258     size_t buflen;
259     int cont;
260     int clearsig=0;
261     int hdr_line=0;
262     unsigned empty = 0;
263
264     buflen = *r_buflen;
265     assert(buflen >= 100 );
266     buflen -= 3; /* reserved room for CR,LF and one extra */
267
268     do {
269         switch( state ) {
270           case fhdrHASArmor:
271             /* read at least the first byte to check whether it is armored
272              * or not */
273             c = 0;
274             for(n=0; n < 28 && (c=iobuf_get2(a)) != -1 && c != '\n'; )
275                 buf[n++] = c;
276             if( !n && c == '\n' )
277                 state = fhdrCHECKBegin;
278             else if( !n  || c == -1 )
279                 state = fhdrNOArmor; /* too short */
280             else if( !is_armored( buf ) )
281                 state = fhdrNOArmor;
282             else if( c == '\n' )
283                 state = fhdrCHECKBegin;
284             else
285                 state = fhdrINITCont;
286             break;
287
288           case fhdrINIT: /* read some stuff into buffer */
289             n = 0;
290           case fhdrINITCont: /* read more stuff into buffer */
291             c = 0;
292             for(; n < buflen && (c=iobuf_get2(a)) != -1 && c != '\n'; )
293                 buf[n++] = c;
294             state = c == '\n' ? fhdrCHECKBegin :
295                      c == -1  ? fhdrEOF : fhdrINITSkip;
296             break;
297
298           case fhdrINITSkip:
299             if( c == '\n' )
300                 n = 0;
301             else {
302                 while( (c=iobuf_get2(a)) != -1 && c != '\n' )
303                     ;
304             }
305             state =  c == -1? fhdrEOF : fhdrINIT;
306             break;
307
308           case fhdrSKIPHeader:
309             while( (c=iobuf_get2(a)) != -1 && c != '\n' )
310                 ;
311             state =  c == -1? fhdrEOF : fhdrWAITHeader;
312             break;
313
314           case fhdrWAITHeader: /* wait for Header lines */
315             c = 0;
316             for(n=0; n < buflen && (c=iobuf_get2(a)) != -1 && c != '\n'; )
317                 buf[n++] = c;
318             buf[n] = 0;
319             if( n < buflen || c == '\n' ) {
320                 if( n && buf[0] != '\r') { /* maybe a header */
321                     if( strchr( buf, ':') ) { /* yes */
322                         if( buf[n-1] == '\r' )
323                             buf[--n] = 0;
324                         if( opt.verbose ) {
325                             log_info("armor header: ");
326                             print_string( stderr, buf, n, 0 );
327                             putc('\n', stderr);
328                         }
329                         if( clearsig && !parse_hash_header( buf ) ) {
330                             log_error("invalid clearsig header\n");
331                             state = fhdrERROR;
332                         }
333                         else
334                             state = fhdrWAITHeader;
335                     }
336                     else
337                         state = fhdrCHECKDashEscaped3;
338                 }
339                 else if( !n || (buf[0] == '\r' && !buf[1]) ) { /* empty line */
340                     if( clearsig )
341                         state = fhdrWAITClearsig;
342                     else {
343                         /* this is not really correct: if we do not have
344                          * a clearsig and no armor lines we are not allowed
345                          * to have an empty line */
346                         n = 0;
347                         state = fhdrTEXT;
348                     }
349                 }
350                 else {
351                     log_error("invalid armor header: ");
352                     print_string( stderr, buf, n, 0 );
353                     putc('\n', stderr);
354                     state = fhdrERROR;
355                 }
356             }
357             else if( c != -1 ) {
358                 if( strchr( buf, ':') ) { /* buffer to short, but this is okay*/
359                     if( opt.verbose ) {
360                         log_info("armor header: ");
361                         print_string( stderr, buf, n, 0 );
362                         fputs("[...]\n", stderr);  /* indicate it is truncated */
363                     }
364                     state = fhdrSKIPHeader;  /* skip rest of line */
365                 }
366                 else /* line too long */
367                     state = fhdrERROR;
368             }
369             else
370                 state = fhdrEOF;
371             break;
372
373           case fhdrWAITClearsig: /* skip all empty lines (for clearsig) */
374             c = 0;
375             for(n=0; n < buflen && (c=iobuf_get2(a)) != -1 && c != '\n'; )
376                 buf[n++] = c;
377             if( n < buflen || c == '\n' ) {
378                 buf[n] = 0;
379                 if( !n || (buf[0]=='\r' && !buf[1]) ) /* empty line */
380                     ;
381                 else
382                     state = fhdrCHECKDashEscaped3;
383             }
384             else {
385                 /* fixme: we should check whether this line continues
386                  *   it is possible that we have only read ws until here
387                  *   and more stuff is to come */
388                 state = fhdrEOF;
389             }
390             break;
391
392           case fhdrENDClearsig:
393           case fhdrCHECKBegin:
394             state = state == fhdrCHECKBegin ? fhdrINITSkip : fhdrERRORShow;
395             if( n < 15 )
396                 break;  /* too short */
397             if( memcmp( buf, "-----", 5 ) )
398                 break;
399             buf[n] = 0;
400             p = strstr(buf+5, "-----");
401             if( !p )
402                 break;
403             *p = 0;
404             p += 5;
405             if( *p == '\r' )
406                 p++;
407             if( *p )
408                 break; /* garbage after dashes */
409             p = buf+5;
410             for(i=0; (s=head_strings[i]); i++ )
411                 if( !strcmp(s, p) )
412                     break;
413             if( !s )
414                 break; /* unknown begin line */
415             /* found the begin line */
416             hdr_line = i;
417             state = fhdrWAITHeader;
418             if( hdr_line == BEGIN_SIGNED_MSG_IDX )
419                 clearsig = 1;
420             if( opt.verbose > 1 )
421                 log_info("armor: %s\n", head_strings[hdr_line]);
422             break;
423
424           case fhdrCLEARSIG:
425           case fhdrEMPTYClearsig:
426           case fhdrREADClearsig:
427             /* we are at the start of a line: read a clearsig into the buffer
428              * we have to look for a header line or dashed escaped text*/
429             n = 0;
430             c = 0;
431             while( n < buflen && (c=iobuf_get2(a)) != -1 && c != '\n' )
432                 buf[n++] = c;
433             buf[n] = 0;
434             if( c == -1 )
435                 state = fhdrEOF;
436             else if( !n || ( buf[0]=='\r' && !buf[1] ) ) {
437                 state = fhdrEMPTYClearsig;
438                 empty++;
439             }
440             else if( c == '\n' )
441                 state = fhdrCHECKClearsig2;
442             else
443                 state = fhdrCHECKClearsig;
444             break;
445
446           case fhdrCHECKDashEscaped3:
447             if( !(n > 1 && buf[0] == '-' && buf[1] == ' ' ) ) {
448                 state = fhdrTEXT;
449                 break;
450             }
451             /* fall through */
452           case fhdrCHECKDashEscaped2:
453           case fhdrCHECKDashEscaped:
454             /* check dash escaped line */
455             if( buf[2] == '-' || ( n > 6 && !memcmp(buf+2, "From ", 5))) {
456                 for(i=2; i < n; i++ )
457                     buf[i-2] = buf[i];
458                 n -= 2;
459                 buf[n] = 0; /* not really needed */
460                 state = state == fhdrCHECKDashEscaped3 ? fhdrTEXT :
461                         state == fhdrCHECKDashEscaped2 ?
462                                  fhdrREADClearsig : fhdrTESTSpaces;
463             }
464             else {
465                 log_error("invalid dash escaped line: ");
466                 print_string( stderr, buf, n, 0 );
467                 putc('\n', stderr);
468                 state = fhdrERROR;
469             }
470             break;
471
472           case fhdrCHECKClearsig:
473             /* check the clearsig line */
474             if( n > 15 && !memcmp(buf, "-----", 5 ) )
475                 state = fhdrENDClearsig;
476             else if( buf[0] == '-' && buf[1] == ' ' )
477                 state = fhdrCHECKDashEscaped;
478             else {
479                 state = fhdrTESTSpaces;
480             }
481             break;
482
483           case fhdrCHECKClearsig2:
484             /* check the clearsig line */
485             if( n > 15 && !memcmp(buf, "-----", 5 ) )
486                 state = fhdrENDClearsig;
487             else if( buf[0] == '-' && buf[1] == ' ' )
488                 state = fhdrCHECKDashEscaped2;
489             else {
490                 state = fhdrREADClearsig;
491             }
492             break;
493
494           case fhdrREADClearsigNext:
495             /* Read to the end of the line, do not care about checking
496              * for dashed escaped text of headers */
497             c = 0;
498             n = 0;
499             while( n < buflen && (c=iobuf_get2(a)) != -1 && c != '\n' )
500                 buf[n++] = c;
501             buf[n] = 0;
502             if( c == -1 )
503                 state = fhdrEOF;
504             else if( c == '\n' )
505                 state = fhdrREADClearsig;
506             else
507                 state = fhdrTESTSpaces;
508             break;
509
510           case fhdrTESTSpaces: {
511             /* but must check whether the rest of the line
512              * only contains white spaces; this is problematic
513              * since we may have to restore the stuff.  simply
514              * counting spaces is not enough, because it may be a
515              * mix of different white space characters */
516             IOBUF b = iobuf_temp();
517             while( (c=iobuf_get2(a)) != -1 && c != '\n' ) {
518                 iobuf_put(b,c);
519                 if( c != ' ' && c != '\t' && c != '\r' )
520                     break;
521             }
522             if( c == '\n' ) {
523                 /* okay we can skip the rest of the line */
524                 iobuf_close(b);
525                 state = fhdrREADClearsig;
526             }
527             else {
528                 iobuf_unget_and_close_temp(a,b);
529                 state = fhdrREADClearsigNext;
530             }
531           } break;
532
533           case fhdrERRORShow:
534             log_error("invalid clear text header: ");
535             print_string( stderr, buf, n, 0 );
536             putc('\n', stderr);
537             state = fhdrERROR;
538             break;
539
540           default: BUG();
541         }
542         switch( state ) {
543           case fhdrINIT:
544           case fhdrINITCont:
545           case fhdrINITSkip:
546           case fhdrCHECKBegin:
547           case fhdrWAITHeader:
548           case fhdrWAITClearsig:
549           case fhdrSKIPHeader:
550           case fhdrEMPTYClearsig:
551           case fhdrCHECKClearsig:
552           case fhdrCHECKClearsig2:
553           case fhdrCHECKDashEscaped:
554           case fhdrCHECKDashEscaped2:
555           case fhdrCHECKDashEscaped3:
556           case fhdrTESTSpaces:
557           case fhdrERRORShow:
558             cont = 1;
559             break;
560           default: cont = 0;
561         }
562     } while( cont );
563
564     if( clearsig && state == fhdrTEXT )
565         state = fhdrCLEARSIG;
566
567     if( state == fhdrCLEARSIG || state == fhdrREADClearsig ) {
568         /* append CR,LF after removing trailing wspaces */
569         for(p=buf+n-1; n; n--, p-- ) {
570             assert( *p != '\n' );
571             if( *p != ' ' && *p != '\t' && *p != '\r' ) {
572                 p[1] = '\r';
573                 p[2] = '\n';
574                 n += 2;
575                 break;
576             }
577         }
578         if( !n ) {
579             buf[0] = '\r';
580             buf[1] = '\n';
581             n = 2;
582         }
583     }
584
585
586     *r_buflen = n;
587     *r_empty = empty;
588     return state;
589 }
590
591
592 /* figure out whether the data is armored or not */
593 static int
594 check_input( armor_filter_context_t *afx, IOBUF a )
595 {
596     int rc = 0;
597     size_t n;
598     fhdr_state_t state = afx->parse_state;
599     unsigned emplines;
600
601     if( state != fhdrENDClearsig )
602         state = fhdrHASArmor;
603
604     n = DIM(afx->helpbuf);
605     state = find_header( state, afx->helpbuf, &n, a, afx->helplen, &emplines);
606     switch( state ) {
607       case fhdrNOArmor:
608         afx->inp_checked = 1;
609         afx->inp_bypass = 1;
610         afx->helplen = n;
611         break;
612
613       case fhdrERROR:
614         invalid_armor();
615         break;
616
617       case fhdrEOF:
618         rc = -1;
619         break;
620
621       case fhdrCLEARSIG: /* start fake package mode (for clear signatures) */
622         afx->helplen = n;
623         afx->helpidx = 0;
624         afx->faked = 1;
625         break;
626
627       case fhdrTEXT:
628         afx->helplen = n;
629         afx->helpidx = 0;
630         afx->inp_checked = 1;
631         afx->crc = CRCINIT;
632         afx->idx = 0;
633         afx->radbuf[0] = 0;
634         break;
635
636       default: BUG();
637     }
638
639     afx->parse_state = state;
640     return rc;
641 }
642
643
644
645 /* fake a literal data packet and wait for an armor line */
646 static int
647 fake_packet( armor_filter_context_t *afx, IOBUF a,
648              size_t *retn, byte *buf, size_t size  )
649 {
650     int rc = 0;
651     size_t len = 0;
652     size_t n, nn;
653     fhdr_state_t state = afx->parse_state;
654     unsigned emplines = afx->empty;
655
656     len = 2;    /* reserve 2 bytes for the length header */
657     size -= 3;  /* and 1 for empline handling and 2 for the term header */
658     while( !rc && len < size ) {
659         if( emplines ) {
660             while( emplines && len < size ) {
661                 buf[len++] = '\r';
662                 buf[len++] = '\n';
663                 emplines--;
664             }
665             continue;
666         }
667         if( state == fhdrENDClearsigHelp ) {
668             state = fhdrENDClearsig;
669             afx->faked = 0;
670             rc = -1;
671             continue;
672         }
673         if( afx->helpidx < afx->helplen ) { /* flush the last buffer */
674             n = afx->helplen;
675             for(nn=afx->helpidx; len < size && nn < n ; nn++ )
676                 buf[len++] = afx->helpbuf[nn];
677             afx->helpidx = nn;
678             continue;
679         }
680         if( state == fhdrEOF ) {
681             rc = -1;
682             continue;
683         }
684         /* read a new one */
685         n = DIM(afx->helpbuf);
686         afx->helpidx = 0;
687         state = find_header( state, afx->helpbuf, &n, a, 0, &emplines );
688         switch( state) {
689           case fhdrERROR:
690             invalid_armor();
691             break;
692
693           case fhdrEOF:
694             rc = -1;
695             break;
696
697           case fhdrCLEARSIG:
698             BUG();
699
700           case fhdrREADClearsig:
701           case fhdrREADClearsigNext:
702             afx->helplen = n;
703             break;
704
705           case fhdrENDClearsig:
706             assert( emplines );
707             emplines--; /* don't count the last one */
708             state = fhdrENDClearsigHelp;
709             afx->helplen = n;
710             break;
711
712           default: BUG();
713         }
714     }
715     buf[0] = (len-2) >> 8;
716     buf[1] = (len-2);
717     if( state == fhdrENDClearsig ) { /* write last (ending) length header */
718         buf[len++] = 0;
719         buf[len++] = 0;
720         rc = 0;
721     }
722
723     afx->parse_state = state;
724     afx->empty = emplines;
725     *retn = len;
726     return rc;
727 }
728
729
730
731 static int
732 radix64_read( armor_filter_context_t *afx, IOBUF a, size_t *retn,
733               byte *buf, size_t size )
734 {
735     byte val;
736     int c, c2;
737     int checkcrc=0;
738     int rc = 0;
739     size_t n = 0;
740     int  idx, i;
741     u32 crc;
742
743     crc = afx->crc;
744     idx = afx->idx;
745     val = afx->radbuf[0];
746     for( n=0; n < size; ) {
747         if( afx->helpidx < afx->helplen )
748             c = afx->helpbuf[afx->helpidx++];
749         else if( (c=iobuf_get(a)) == -1 )
750             break;
751         if( c == '\n' || c == ' ' || c == '\r' || c == '\t' )
752             continue;
753         else if( c == '=' ) { /* pad character: stop */
754             if( idx == 1 )
755                 buf[n++] = val;
756             checkcrc++;
757             break;
758         }
759         else if( (c = asctobin[(c2=c)]) == 255 ) {
760             log_error("invalid radix64 character %02x skipped\n", c2);
761             continue;
762         }
763         switch(idx) {
764           case 0: val =  c << 2; break;
765           case 1: val |= (c>>4)&3; buf[n++]=val;val=(c<<4)&0xf0;break;
766           case 2: val |= (c>>2)&15; buf[n++]=val;val=(c<<6)&0xc0;break;
767           case 3: val |= c&0x3f; buf[n++] = val; break;
768         }
769         idx = (idx+1) % 4;
770     }
771     for(i=0; i < n; i++ )
772         crc = (crc << 8) ^ crc_table[((crc >> 16)&0xff) ^ buf[i]];
773     crc &= 0x00ffffff;
774     afx->crc = crc;
775     afx->idx = idx;
776     afx->radbuf[0] = val;
777     if( checkcrc ) {
778         afx->inp_eof = 1; /*assume eof */
779         for(;;) { /* skip lf and pad characters */
780             if( afx->helpidx < afx->helplen )
781                 c = afx->helpbuf[afx->helpidx++];
782             else if( (c=iobuf_get(a)) == -1 )
783                 break;
784             if( c == '\n' || c == ' ' || c == '\r'
785                 || c == '\t' || c == '=' )
786                 continue;
787             break;
788         }
789         if( c == -1 )
790             log_error("premature eof (no CRC)\n");
791         else {
792             u32 mycrc = 0;
793             idx = 0;
794             do {
795                 if( (c = asctobin[c]) == 255 )
796                     break;
797                 switch(idx) {
798                   case 0: val =  c << 2; break;
799                   case 1: val |= (c>>4)&3; mycrc |= val << 16;val=(c<<4)&0xf0;break;
800                   case 2: val |= (c>>2)&15; mycrc |= val << 8;val=(c<<6)&0xc0;break;
801                   case 3: val |= c&0x3f; mycrc |= val; break;
802                 }
803                 if( afx->helpidx < afx->helplen )
804                     c = afx->helpbuf[afx->helpidx++];
805                 else if( (c=iobuf_get(a)) == -1 )
806                     break;
807             } while( ++idx < 4 );
808             if( c == -1 )
809                 log_error("premature eof (in CRC)\n");
810             else if( idx != 4 )
811                 log_error("malformed CRC\n");
812             else if( mycrc != afx->crc )
813                 log_error("CRC error; %06lx - %06lx\n",
814                                     (ulong)afx->crc, (ulong)mycrc);
815             else {
816                 rc = 0;
817               #if 0
818                 for(rc=0;!rc;) {
819                     rc = 0 /*check_trailer( &fhdr, c )*/;
820                     if( !rc ) {
821                         if( afx->helpidx < afx->helplen )
822                             c = afx->helpbuf[afx->helpidx++];
823                         else if( (c=iobuf_get(a)) == -1 )
824                             rc = 2;
825                     }
826                 }
827                 if( rc == -1 )
828                     rc = 0;
829                 else if( rc == 2 )
830                     log_error("premature eof (in Trailer)\n");
831                 else
832                     log_error("error in trailer line\n");
833               #endif
834             }
835         }
836     }
837
838     if( !n )
839         rc = -1;
840
841     *retn = n;
842     return rc;
843 }
844
845
846 /****************
847  * This filter is used to handle the armor stuff
848  */
849 int
850 armor_filter( void *opaque, int control,
851              IOBUF a, byte *buf, size_t *ret_len)
852 {
853     size_t size = *ret_len;
854     armor_filter_context_t *afx = opaque;
855     int rc=0, i, c;
856     byte radbuf[3];
857     int  idx, idx2;
858     size_t n=0;
859     u32 crc;
860   #if 0
861     static FILE *fp ;
862
863     if( !fp ) {
864         fp = fopen("armor.out", "w");
865         assert(fp);
866     }
867   #endif
868
869     if( DBG_FILTER )
870         log_debug("armor-filter: control: %d\n", control );
871     if( control == IOBUFCTRL_UNDERFLOW && afx->inp_bypass ) {
872         for( n=0; n < size; n++ ) {
873             if( (c=iobuf_get(a)) == -1 )
874                 break;
875             buf[n] = c & 0xff;
876         }
877         if( !n )
878             rc = -1;
879         *ret_len = n;
880     }
881     else if( control == IOBUFCTRL_UNDERFLOW ) {
882         if( size < 30 )
883             BUG(); /* supplied buffer too short */
884
885         if( afx->inp_eof ) {
886             *ret_len = 0;
887             if( DBG_FILTER )
888                 log_debug("armor-filter: eof due to inp_eof flag\n" );
889             return -1;
890         }
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 && n < afx->helplen; n++ )
898                     buf[n] = afx->helpbuf[n];
899                 if( !n )
900                     rc = -1;
901                 assert( n == afx->helplen );
902                 afx->helplen = 0;
903             }
904             else if( afx->faked ) {
905                 /* the buffer is at least 30 bytes long, so it
906                  * is easy to construct the packets */
907
908                 /* first a onepass signature packet */
909                 buf[0] = 0x90; /* old packet format, type 4, 1 length byte */
910                 buf[1] = 13;   /* length */
911                 buf[2] = 3;    /* version */
912                 buf[3] = 0x01; /* sigclass 0x01 (data in canonical text mode)*/
913                 buf[4] = 0;    /* digest algo (don't know) */
914                 buf[5] = 0;    /* public key algo (don't know) */
915                 memset(buf+6, 0, 8); /* don't know the keyid */
916                 buf[14] = 1;   /* this is the last one */
917
918                 /* followed by a plaintext packet */
919                 buf[15] = 0xaf; /* old packet format, type 11, var length */
920                 buf[16] = 0;    /* set the length header */
921                 buf[17] = 6;
922                 buf[18] = 't';  /* canonical text mode */
923                 buf[19] = 0;    /* namelength */
924                 memset(buf+20, 0, 4); /* timestamp */
925                 n = 24;
926             }
927             else if( !rc )
928                 rc = radix64_read( afx, a, &n, buf, size );
929         }
930         else
931             rc = radix64_read( afx, a, &n, buf, size );
932       #if 0
933         if( n )
934             if( fwrite(buf, n, 1, fp ) != 1 )
935                 BUG();
936       #endif
937         *ret_len = n;
938     }
939     else if( control == IOBUFCTRL_FLUSH ) {
940         if( !afx->status ) { /* write the header line */
941             if( afx->what >= DIM(head_strings) )
942                 log_bug("afx->what=%d", afx->what);
943             iobuf_writestr(a, "-----");
944             iobuf_writestr(a, head_strings[afx->what] );
945             iobuf_writestr(a, "-----\n");
946             iobuf_writestr(a, "Version: GNUPG v"  VERSION " ("
947                                             PRINTABLE_OS_NAME ")\n");
948             iobuf_writestr(a, "Comment: This is an alpha version!\n");
949             if( afx->hdrlines )
950                 iobuf_writestr(a, afx->hdrlines);
951             iobuf_put(a, '\n');
952             afx->status++;
953             afx->idx = 0;
954             afx->idx2 = 0;
955             afx->crc = CRCINIT;
956         }
957         crc = afx->crc;
958         idx = afx->idx;
959         idx2 = afx->idx2;
960         for(i=0; i < idx; i++ )
961             radbuf[i] = afx->radbuf[i];
962
963         for(i=0; i < size; i++ )
964             crc = (crc << 8) ^ crc_table[((crc >> 16)&0xff) ^ buf[i]];
965         crc &= 0x00ffffff;
966
967         for( ; size; buf++, size-- ) {
968             radbuf[idx++] = *buf;
969             if( idx > 2 ) {
970                 idx = 0;
971                 c = bintoasc[(*radbuf >> 2) & 077];
972                 iobuf_put(a, c);
973                 c = bintoasc[(((*radbuf<<4)&060)|((radbuf[1] >> 4)&017))&077];
974                 iobuf_put(a, c);
975                 c = bintoasc[(((radbuf[1]<<2)&074)|((radbuf[2]>>6)&03))&077];
976                 iobuf_put(a, c);
977                 c = bintoasc[radbuf[2]&077];
978                 iobuf_put(a, c);
979                 if( ++idx2 > (72/4) ) {
980                     iobuf_put(a, '\n');
981                     idx2=0;
982                 }
983             }
984         }
985         for(i=0; i < idx; i++ )
986             afx->radbuf[i] = radbuf[i];
987         afx->idx = idx;
988         afx->idx2 = idx2;
989         afx->crc  = crc;
990     }
991     else if( control == IOBUFCTRL_INIT ) {
992         if( !is_initialized )
993             initialize();
994     }
995     else if( control == IOBUFCTRL_FREE ) {
996         if( afx->status ) { /* pad, write cecksum, and bottom line */
997             crc = afx->crc;
998             idx = afx->idx;
999             idx2 = afx->idx2;
1000             for(i=0; i < idx; i++ )
1001                 radbuf[i] = afx->radbuf[i];
1002             if( idx ) {
1003                 c = bintoasc[(*radbuf>>2)&077];
1004                 iobuf_put(a, c);
1005                 if( idx == 1 ) {
1006                     c = bintoasc[((*radbuf << 4) & 060) & 077];
1007                     iobuf_put(a, c);
1008                     iobuf_put(a, '=');
1009                     iobuf_put(a, '=');
1010                 }
1011                 else { /* 2 */
1012                     c = bintoasc[(((*radbuf<<4)&060)|((radbuf[1]>>4)&017))&077];
1013                     iobuf_put(a, c);
1014                     c = bintoasc[((radbuf[1] << 2) & 074) & 077];
1015                     iobuf_put(a, c);
1016                     iobuf_put(a, '=');
1017                 }
1018                 ++idx2;
1019             }
1020             /* may need a linefeed */
1021             if( idx2 <= (72/4) )
1022                 iobuf_put(a, '\n');
1023             /* write the CRC */
1024             iobuf_put(a, '=');
1025             radbuf[0] = crc >>16;
1026             radbuf[1] = crc >> 8;
1027             radbuf[2] = crc;
1028             c = bintoasc[(*radbuf >> 2) & 077];
1029             iobuf_put(a, c);
1030             c = bintoasc[(((*radbuf<<4)&060)|((radbuf[1] >> 4)&017))&077];
1031             iobuf_put(a, c);
1032             c = bintoasc[(((radbuf[1]<<2)&074)|((radbuf[2]>>6)&03))&077];
1033             iobuf_put(a, c);
1034             c = bintoasc[radbuf[2]&077];
1035             iobuf_put(a, c);
1036             iobuf_put(a, '\n');
1037             /* and the the trailer */
1038             if( afx->what >= DIM(tail_strings) )
1039                 log_bug("afx->what=%d", afx->what);
1040             iobuf_writestr(a, "-----");
1041             iobuf_writestr(a, tail_strings[afx->what] );
1042             iobuf_writestr(a, "-----\n");
1043         }
1044     }
1045     else if( control == IOBUFCTRL_DESC )
1046         *(char**)buf = "armor_filter";
1047     return rc;
1048 }
1049
1050
1051