Bug in blowfish behoben
[gnupg.git] / g10 / g10.c
1 /* g10.c - The G10 utility
2  *      Copyright (c) 1997 by Werner Koch (dd9jn)
3  *
4  * This file is part of G10.
5  *
6  * G10 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  * G10 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 <errno.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <unistd.h>
26
27 #include "packet.h"
28 #include "iobuf.h"
29 #include "memory.h"
30 #include "util.h"
31 #include "main.h"
32 #include "options.h"
33 #include "keydb.h"
34 #include "mpi.h"
35 #include "cipher.h"
36 #include "filter.h"
37
38 enum cmd_values { aNull = 0,
39     aSym, aStore, aEncr, aPrimegen, aKeygen, aSign, aSignEncr,
40     aPrintMDs, aSignKey, aClearsig, aListPackets, aEditSig,
41     aKMode, aKModeC, aChangePass,
42 aTest };
43
44
45 static void set_cmd( enum cmd_values *ret_cmd,
46                         enum cmd_values new_cmd );
47 static void print_hex( byte *p, size_t n );
48 static void print_mds( const char *fname );
49 static void do_test(int);
50
51 const char *
52 strusage( int level )
53 {
54     const char *p;
55     switch( level ) {
56       case 10:
57       case 0:   p = "g10 - v" VERSION "; "
58                     "Copyright 1997 Werner Koch (dd9jn)\n" ; break;
59       case 13:  p = "g10"; break;
60       case 14:  p = VERSION; break;
61       case 1:
62       case 11:  p = "Usage: g10 [options] [files] (-h for help)";
63                 break;
64       case 2:
65       case 12:  p =
66     "Syntax: g10 [options] [files]\n"
67     "sign, check, encrypt or decrypt\n"
68     "default operation depends on the input data\n"; break;
69
70       case 26:
71         p = "Please report bugs to <g10-bugs@isil.d.shuttle.de>.\n";
72         break;
73
74       case 30: p = ""
75   #ifndef HAVE_ZLIB_H
76     "   NOTE: This version is compiled without ZLIB support;\n"
77     "         you are not able to process compresssed data!\n"
78   #endif
79   #ifdef HAVE_RSA_CIPHER
80     "WARNING: This version has RSA support! Your are not allowed to\n"
81     "         use it inside the Unites States before Sep 30, 2000!\n"
82   #endif
83         ;
84         break;
85       default:  p = default_strusage(level);
86     }
87     return p;
88 }
89
90 static void
91 set_debug(void)
92 {
93     if( opt.debug & DBG_MEMORY_VALUE )
94         memory_debug_mode = 1;
95     if( opt.debug & DBG_MEMSTAT_VALUE )
96         memory_stat_debug_mode = 1;
97     if( opt.debug & DBG_MPI_VALUE )
98         mpi_debug_mode = 1;
99     if( opt.debug & DBG_CIPHER_VALUE )
100         cipher_debug_mode = 1;
101     if( opt.debug & DBG_IOBUF_VALUE )
102         iobuf_debug_mode = 1;
103 }
104
105
106 static void
107 set_cmd( enum cmd_values *ret_cmd, enum cmd_values new_cmd )
108 {
109     enum cmd_values cmd = *ret_cmd;
110
111     if( !cmd || cmd == new_cmd )
112         cmd = new_cmd;
113     else if( cmd == aSign && new_cmd == aEncr )
114         cmd = aSignEncr;
115     else if( cmd == aEncr && new_cmd == aSign )
116         cmd = aSignEncr;
117     else if( cmd == aKMode && new_cmd == aSym )
118         cmd = aKModeC;
119     else {
120         log_error("conflicting commands\n");
121         exit(2);
122     }
123
124     *ret_cmd = cmd;
125 }
126
127
128 int
129 main( int argc, char **argv )
130 {
131     static ARGPARSE_OPTS opts[] = {
132     { 'a', "armor",     0, "create ascii armored output"},
133     { 'v', "verbose",   0, "verbose" },
134     { 'z', NULL,        1, "set compress level (0 disables)" },
135     { 'n', "dry-run",   0, "don't make any changes" },
136     { 'c', "symmetric", 0, "do only a symmetric encryption" },
137     { 'o', "output",    2, "use as output file" },
138     { 500, "batch",     0, "batch mode: never ask" },
139     { 501, "yes",       0, "assume yes on most questions"},
140     { 502, "no",        0, "assume no on most questions"},
141     { 503, "gen-key",   0, "generate a new key pair" },
142     { 504, "add-key",   0, "add key to the public keyring" },
143     { 505, "delete-key",0, "remove key from public keyring" },
144     { 506, "sign-key"  ,0, "make a signature on a key in the keyring" },
145     { 507, "store",     0, "store only" },
146     { 508, "check-key" ,0, "check signatures on a key in the keyring" },
147     { 509, "keyring"   ,2, "add this keyring to the list of keyrings" },
148     { 's', "sign",      0, "make a signature"},
149     { 't', "textmode",  0, "use canonical text mode"},
150     { 'b', "detach-sign", 0, "make a detached signature"},
151     { 'e', "encrypt",   0, "encrypt data" },
152     { 'd', "decrypt",   0, "decrypt data (default)" },
153     { 'u', "local-user",2, "use this user-id to sign or decrypt" },
154     { 'r', "remote-user", 2, "use this user-id for encryption" },
155     { 'k', NULL      , 0, "list keys" },
156     { 510, "debug"     ,4|16, "set debugging flags" },
157     { 511, "debug-all" ,0, "enable full debugging"},
158     { 512, "cache-all" ,0, "hold everything in memory"},
159     { 513, "gen-prime" , 0, "\r" },
160     { 514, "test"      , 0, "\r" },
161     { 515, "fingerprint", 0, "show the fingerprints"},
162     { 516, "print-mds" , 0, "print all message digests"},
163     { 517, "secret-keyring" ,2, "add this secret keyring to the list" },
164     { 518, "options"   , 2, "read options from file" },
165     { 519, "no-armor",   0, "\r"},
166     { 520, "no-default-keyring", 0, "\r" },
167     { 521, "list-packets",0,"list only the sequence of packets"},
168     { 522, "no-greeting", 0, "\r" },
169     { 523, "passphrase-fd",1, "\r" },
170     { 524, "edit-sig"  ,0, "edit a key signature" },
171     { 525, "change-passphrase", 0, "change the passphrase of your secret keyring"},
172
173     {0} };
174     ARGPARSE_ARGS pargs;
175     IOBUF a;
176     int rc;
177     int orig_argc;
178     char **orig_argv;
179     const char *fname, *fname_print;
180     STRLIST sl, remusr= NULL, locusr=NULL;
181     int nrings=0, sec_nrings=0;
182     armor_filter_context_t afx;
183     const char *s;
184     int detached_sig = 0;
185     FILE *configfp = NULL;
186     char *configname = NULL;
187     unsigned configlineno;
188     int parse_verbose = 0;
189     int default_config =1;
190     int errors=0;
191     int default_keyring = 1;
192     int greeting = 1;
193     enum cmd_values cmd = 0;
194
195
196     opt.compress = -1; /* defaults to standard compress level */
197
198     /* check wether we have a config file on the commandline */
199     orig_argc = argc;
200     orig_argv = argv;
201     pargs.argc = &argc;
202     pargs.argv = &argv;
203     pargs.flags=  1;  /* do not remove the args */
204     while( arg_parse( &pargs, opts) ) {
205         if( pargs.r_opt == 'v' )
206             parse_verbose++;
207         else if( pargs.r_opt == 518 ) {
208             /* yes there is one, so we do not try the default one, but
209              * read the option file when it is encountered at the commandline
210              */
211             default_config = 0;
212         }
213     }
214
215     if( default_config )
216         configname = make_filename("~/.g10", "options", NULL );
217
218     argc = orig_argc;
219     argv = orig_argv;
220     pargs.argc = &argc;
221     pargs.argv = &argv;
222     pargs.flags=  1;  /* do not remove the args */
223   next_pass:
224     if( configname ) {
225         configlineno = 0;
226         configfp = fopen( configname, "r" );
227         if( !configfp ) {
228             if( default_config ) {
229                 if( parse_verbose > 1 )
230                 log_info("note: no default option file '%s'\n", configname );
231             }
232             else
233                 log_fatal("option file '%s': %s\n",
234                                     configname, strerror(errno) );
235             m_free(configname); configname = NULL;
236         }
237         if( parse_verbose > 1 )
238             log_info("reading options from '%s'\n", configname );
239         default_config = 0;
240     }
241
242     while( optfile_parse( configfp, configname, &configlineno,
243                                                 &pargs, opts) ) {
244         switch( pargs.r_opt ) {
245           case 'v': opt.verbose++;
246                     opt.list_sigs=1;
247                     break;
248           case 'z': opt.compress = pargs.r.ret_int; break;
249           case 'a': opt.armor = 1; opt.no_armor=0; break;
250           case 'c': set_cmd( &cmd , aSym); break;
251           case 'o': opt.outfile = pargs.r.ret_str; break;
252           case 'e': set_cmd( &cmd, aEncr); break;
253           case 'b': detached_sig = 1;
254                /* fall trough */
255           case 's': set_cmd( &cmd, aSign );  break;
256           case 't': set_cmd( &cmd , aClearsig);  break;
257           case 'u': /* store the local users */
258             sl = m_alloc( sizeof *sl + strlen(pargs.r.ret_str));
259             strcpy(sl->d, pargs.r.ret_str);
260             sl->next = locusr;
261             locusr = sl;
262             break;
263           case 'r': /* store the remote users */
264             sl = m_alloc( sizeof *sl + strlen(pargs.r.ret_str));
265             strcpy(sl->d, pargs.r.ret_str);
266             sl->next = remusr;
267             remusr = sl;
268             break;
269           case 'k': set_cmd( &cmd, aKMode ); break;
270           case 500: opt.batch = 1; greeting = 0; break;
271           case 501: opt.answer_yes = 1; break;
272           case 502: opt.answer_no = 1; break;
273           case 503: set_cmd( &cmd, aKeygen); break;
274           case 506: set_cmd( &cmd, aSignKey); break;
275           case 507: set_cmd( &cmd, aStore); break;
276           case 508: opt.check_sigs = 1; opt.list_sigs = 1; break;
277           case 509: add_keyring(pargs.r.ret_str); nrings++; break;
278           case 510: opt.debug |= pargs.r.ret_ulong; break;
279           case 511: opt.debug = ~0; break;
280           case 512: opt.cache_all = 1; break;
281           case 513: set_cmd( &cmd, aPrimegen); break;
282           case 514: set_cmd( &cmd, aTest); break;
283           case 515: opt.fingerprint = 1; break;
284           case 516: set_cmd( &cmd, aPrintMDs); break;
285           case 517: add_secret_keyring(pargs.r.ret_str); sec_nrings++; break;
286           case 518:
287             /* config files may not be nested (silently ignore them) */
288             if( !configfp ) {
289                 m_free(configname);
290                 configname = m_strdup(pargs.r.ret_str);
291                 goto next_pass;
292             }
293             break;
294           case 519: opt.no_armor=1; opt.armor=0; break;
295           case 520: default_keyring = 0; break;
296           case 521: set_cmd( &cmd, aListPackets); break;
297           case 522: greeting = 0; break;
298           case 523: set_passphrase_fd( pargs.r.ret_int ); break;
299           case 524: set_cmd( &cmd, aEditSig); break;
300           case 525: set_cmd( &cmd, aChangePass); break;
301           default : errors++; pargs.err = configfp? 1:2; break;
302         }
303     }
304     if( configfp ) {
305         fclose( configfp );
306         configfp = NULL;
307         m_free(configname); configname = NULL;
308         goto next_pass;
309     }
310     m_free( configname ); configname = NULL;
311     if( errors )
312         exit(2);
313
314     set_debug();
315     if( cmd == aKMode || cmd == aKModeC ) { /* kludge to be compatible to pgp */
316         if( cmd == aKModeC ) {
317             opt.fingerprint = 1;
318             cmd = aKMode;
319         }
320         opt.list_sigs = 0;
321         if( opt.verbose > 2 )
322             opt.check_sigs++;
323         if( opt.verbose > 1 )
324             opt.list_sigs++;
325
326         opt.verbose = opt.verbose > 1;
327     }
328     if( opt.verbose > 1 )
329         set_packet_list_mode(1);
330     if( greeting ) {
331         if( *(s=strusage(10))  )
332             tty_printf("%s", s);
333         if( *(s=strusage(30))  )
334             tty_printf("%s", s);
335     }
336
337     if( !sec_nrings || default_keyring ) { /* add default secret rings */
338         char *p = make_filename("~/.g10", "secring.g10", NULL );
339         add_secret_keyring(p);
340         m_free(p);
341     }
342     if( !nrings || default_keyring ) { /* add default ring */
343         char *p = make_filename("~/.g10", "pubring.g10", NULL );
344         add_keyring(p);
345         m_free(p);
346     }
347
348     if( argc ) {
349         fname_print = fname = *argv;
350     }
351     else {
352         fname_print = "[stdin]";
353         fname = NULL;
354     }
355
356     switch( cmd ) {
357       case aStore: /* only store the file */
358         if( argc > 1 )
359             usage(1);
360         if( (rc = encode_store(fname)) )
361             log_error("encode_store('%s'): %s\n",
362                                     fname_print, g10_errstr(rc) );
363         break;
364
365       case aSym: /* encrypt the given file only with the symmetric cipher */
366         if( argc > 1 )
367             usage(1);
368         if( (rc = encode_symmetric(fname)) )
369             log_error("encode_symmetric('%s'): %s\n", fname_print, g10_errstr(rc) );
370         break;
371
372       case aEncr: /* encrypt the given file */
373         if( argc > 1 )
374             usage(1);
375         if( (rc = encode_crypt(fname,remusr)) )
376             log_error("encode_crypt('%s'): %s\n", fname_print, g10_errstr(rc) );
377         break;
378
379       case aSign: /* sign the given file */
380         if( argc > 1 )
381             usage(1);
382         if( (rc = sign_file(fname, detached_sig, locusr, 0, NULL)) )
383             log_error("sign_file('%s'): %s\n", fname_print, g10_errstr(rc) );
384         break;
385
386       case aSignEncr: /* sign and encrypt the given file */
387         if( argc > 1 )
388             usage(1);
389         if( (rc = sign_file(fname, detached_sig, locusr, 1, remusr)) )
390             log_error("sign_file('%s'): %s\n", fname_print, g10_errstr(rc) );
391         break;
392
393
394       case aSignKey: /* sign the key given as argument */
395         if( argc != 1 )
396             usage(1);
397         /* note: fname is the user id! */
398         if( (rc = sign_key(fname, locusr)) )
399             log_error("sign_key('%s'): %s\n", fname_print, g10_errstr(rc) );
400         break;
401
402       case aEditSig: /* Edit a key signature */
403         if( argc != 1 )
404             usage(1);
405         /* note: fname is the user id! */
406         if( (rc = edit_keysigs(fname)) )
407             log_error("edit_keysig('%s'): %s\n", fname_print, g10_errstr(rc) );
408         break;
409
410       case aChangePass: /* Chnage the passphrase */
411         if( argc > 1 ) /* no arg: use default, 1 arg use this one */
412             usage(1);
413         /* note: fname is the user id! */
414         if( (rc = change_passphrase(fname)) )
415             log_error("change_passphrase('%s'): %s\n", fname_print,
416                                                        g10_errstr(rc) );
417         break;
418
419       case aKMode: /* list keyring */
420         if( !argc ) { /* list the default public keyrings */
421             int i, seq=0;
422             const char *s;
423
424             while( s=get_keyring(seq++) ) {
425                 if( !(a = iobuf_open(s)) ) {
426                     log_error("can't open '%s'\n", s);
427                     continue;
428                 }
429                 if( seq > 1 )
430                     putchar('\n');
431                 printf("%s\n", s );
432                 for(i=strlen(s); i; i-- )
433                     putchar('-');
434                 putchar('\n');
435
436                 proc_packets( a );
437                 iobuf_close(a);
438             }
439
440         }
441         else if( argc == 1) { /* list the given keyring */
442             if( !(a = iobuf_open(fname)) )
443                 log_fatal("can't open '%s'\n", fname_print);
444             proc_packets( a );
445             iobuf_close(a);
446         }
447         else
448             usage(1);
449         break;
450
451       case aPrimegen:
452         if( argc == 1 ) {
453             mpi_print( stdout, generate_public_prime( atoi(argv[0]) ), 1);
454             putchar('\n');
455         }
456         else if( argc == 2 ) {
457             mpi_print( stdout, generate_elg_prime( atoi(argv[0]),
458                                                    atoi(argv[1]), NULL ), 1);
459             putchar('\n');
460         }
461         else if( argc == 3 ) {
462             MPI g = mpi_alloc(1);
463             mpi_print( stdout, generate_elg_prime( atoi(argv[0]),
464                                                    atoi(argv[1]), g ), 1);
465             printf("\nGenerator: ");
466             mpi_print( stdout, g, 1 );
467             putchar('\n');
468             mpi_free(g);
469         }
470         else
471             usage(1);
472         break;
473
474       case aPrintMDs:
475         if( !argc )
476             print_mds(NULL);
477         else {
478             for(; argc; argc--, argv++ )
479                 print_mds(*argv);
480         }
481         break;
482
483       case aKeygen: /* generate a key (interactive) */
484         if( argc )
485             usage(1);
486         generate_keypair();
487         break;
488
489       case aTest: do_test( argc? atoi(*argv): 0 ); break;
490
491       case aListPackets:
492         opt.list_packets=1;
493       default:
494         if( argc > 1 )
495             usage(1);
496         if( !(a = iobuf_open(fname)) )
497             log_fatal("can't open '%s'\n", fname_print);
498         if( !opt.no_armor ) {
499             /* push the armor filter, so it can peek at the input data */
500             memset( &afx, 0, sizeof afx);
501             iobuf_push_filter( a, armor_filter, &afx );
502         }
503         if( cmd == aListPackets ) {
504             set_packet_list_mode(1);
505             opt.list_packets=1;
506         }
507         proc_packets( a );
508         iobuf_close(a);
509         break;
510     }
511
512     /* cleanup */
513     FREE_STRLIST(remusr);
514     FREE_STRLIST(locusr);
515     return log_get_errorcount(0)? 2:0;
516 }
517
518
519 static void
520 print_hex( byte *p, size_t n )
521 {
522     int i;
523
524     if( n == 20 ) {
525         for(i=0; i < n ; i++, i++, p += 2 ) {
526             if( i == 10 )
527                 putchar(' ');
528             printf(" %02X%02X", *p, p[1] );
529         }
530     }
531     else {
532         for(i=0; i < n ; i++, p++ ) {
533             if( i && !(i%8) )
534                 putchar(' ');
535             printf(" %02X", *p );
536         }
537     }
538 }
539
540 static void
541 print_mds( const char *fname )
542 {
543     FILE *fp;
544     char buf[1024];
545     size_t n;
546     MD5HANDLE md5;
547     RMDHANDLE rmd160;
548     SHA1HANDLE sha1;
549
550     if( !fname ) {
551         fp = stdin;
552         fname = "[stdin]";
553     }
554     else
555         fp = fopen( fname, "rb" );
556     if( !fp ) {
557         log_error("%s: %s\n", fname, strerror(errno) );
558         return;
559     }
560
561     md5    = md5_open(0);
562     rmd160 = rmd160_open(0);
563     sha1   = sha1_open(0);
564
565     while( (n=fread( buf, 1, DIM(buf), fp )) ) {
566         md5_write( md5, buf, n );
567         rmd160_write( rmd160, buf, n );
568         sha1_write( sha1, buf, n );
569     }
570     if( ferror(fp) )
571         log_error("%s: %s\n", fname, strerror(errno) );
572     else {
573         byte *p;
574
575         md5_final(md5);
576         printf(  "%s:    MD5 =", fname ); print_hex(md5_read(md5), 16 );
577         printf("\n%s: RMD160 =", fname ); print_hex(rmd160_final(rmd160), 20 );
578         printf("\n%s:   SHA1 =", fname ); print_hex(sha1_final(sha1), 20 );
579         putchar('\n');
580     }
581
582
583     md5_close(md5);
584     rmd160_close(rmd160);
585     sha1_close(sha1);
586
587     if( fp != stdin )
588         fclose(fp);
589 }
590
591
592
593 static void
594 do_test(int times)
595 {
596   #if 0
597     MPI t = mpi_alloc( 50 );
598     MPI m = mpi_alloc( 50 );
599     MPI a = mpi_alloc( 50 );
600     MPI b = mpi_alloc( 50 );
601     MPI p = mpi_alloc( 50 );
602     MPI x = mpi_alloc( 50 );
603
604     /* output = b/(a^x) mod p */
605     log_debug("invm %d times ", times);
606     for( ; times > 0; times -- ) {
607         mpi_fromstr(a, "0xef45678343589854354a4545545454554545455"
608                        "aaaaaaaaaaaaa44444fffdecb33434343443331" );
609         mpi_fromstr(b, "0x8765765589854354a4545545454554545455"
610                        "aaaaaaa466577778decb36666343443331" );
611         mpi_invm( t, a, b );
612         fputc('.', stderr); fflush(stderr);
613     }
614
615
616     m_check(NULL);
617   #endif
618 }
619