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