cac8672ed7b52ba5a775e5f534d10566fc67dfe9
[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,
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, "change-passphrase", 0, "change the passphrase of your secret keyring"},
162     { 515, "fingerprint", 0, "show the fingerprints"},
163     { 516, "print-mds" , 0, "print all message digests"},
164     { 517, "secret-keyring" ,2, "add this secret keyring to the list" },
165     { 518, "options"   , 2, "read options from file" },
166     { 519, "no-armor",   0, "\r"},
167     { 520, "no-default-keyring", 0, "\r" },
168     { 521, "list-packets",0,"list only the sequence of packets"},
169     { 522, "no-greeting", 0, "\r" },
170     { 523, "passphrase-fd",1, "\r" },
171     { 524, "edit-sig"  ,0, "edit a key signature" },
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           default : errors++; pargs.err = configfp? 1:2; break;
301         }
302     }
303     if( configfp ) {
304         fclose( configfp );
305         configfp = NULL;
306         m_free(configname); configname = NULL;
307         goto next_pass;
308     }
309     m_free( configname ); configname = NULL;
310     if( errors )
311         exit(2);
312
313     set_debug();
314     if( cmd == aKMode || cmd == aKModeC ) { /* kludge to be compatible to pgp */
315         if( cmd == aKModeC ) {
316             opt.fingerprint = 1;
317             cmd = aKMode;
318         }
319         opt.list_sigs = 0;
320         if( opt.verbose > 2 )
321             opt.check_sigs++;
322         if( opt.verbose > 1 )
323             opt.list_sigs++;
324
325         opt.verbose = opt.verbose > 1;
326     }
327     if( opt.verbose > 1 )
328         set_packet_list_mode(1);
329     if( greeting ) {
330         if( *(s=strusage(10))  )
331             tty_printf("%s", s);
332         if( *(s=strusage(30))  )
333             tty_printf("%s", s);
334     }
335
336     if( !sec_nrings || default_keyring ) { /* add default secret rings */
337         char *p = make_filename("~/.g10", "secring.g10", NULL );
338         add_secret_keyring(p);
339         m_free(p);
340     }
341     if( !nrings || default_keyring ) { /* add default ring */
342         char *p = make_filename("~/.g10", "pubring.g10", NULL );
343         add_keyring(p);
344         m_free(p);
345     }
346
347     if( argc ) {
348         fname_print = fname = *argv;
349     }
350     else {
351         fname_print = "[stdin]";
352         fname = NULL;
353     }
354
355     switch( cmd ) {
356       case aStore: /* only store the file */
357         if( argc > 1 )
358             usage(1);
359         if( (rc = encode_store(fname)) )
360             log_error("encode_store('%s'): %s\n",
361                                     fname_print, g10_errstr(rc) );
362         break;
363
364       case aSym: /* encrypt the given file only with the symmetric cipher */
365         if( argc > 1 )
366             usage(1);
367         if( (rc = encode_symmetric(fname)) )
368             log_error("encode_symmetric('%s'): %s\n", fname_print, g10_errstr(rc) );
369         break;
370
371       case aEncr: /* encrypt the given file */
372         if( argc > 1 )
373             usage(1);
374         if( (rc = encode_crypt(fname,remusr)) )
375             log_error("encode_crypt('%s'): %s\n", fname_print, g10_errstr(rc) );
376         break;
377
378       case aSign: /* sign the given file */
379         if( argc > 1 )
380             usage(1);
381         if( (rc = sign_file(fname, detached_sig, locusr, 0, NULL)) )
382             log_error("sign_file('%s'): %s\n", fname_print, g10_errstr(rc) );
383         break;
384
385       case aSignEncr: /* sign and encrypt the given file */
386         if( argc > 1 )
387             usage(1);
388         if( (rc = sign_file(fname, detached_sig, locusr, 1, remusr)) )
389             log_error("sign_file('%s'): %s\n", fname_print, g10_errstr(rc) );
390         break;
391
392
393       case aSignKey: /* sign the key given as argument */
394         if( argc != 1 )
395             usage(1);
396         /* note: fname is the user id! */
397         if( (rc = sign_key(fname, locusr)) )
398             log_error("sign_key('%s'): %s\n", fname_print, g10_errstr(rc) );
399         break;
400
401       case aEditSig: /* Edit a key signature */
402         if( argc != 1 )
403             usage(1);
404         /* note: fname is the user id! */
405         if( (rc = edit_keysigs(fname)) )
406             log_error("edit_keysig('%s'): %s\n", fname_print, g10_errstr(rc) );
407         break;
408
409       case aKMode: /* list keyring */
410         if( !argc ) { /* list the default public keyrings */
411             int i, seq=0;
412             const char *s;
413
414             while( s=get_keyring(seq++) ) {
415                 if( !(a = iobuf_open(s)) ) {
416                     log_error("can't open '%s'\n", s);
417                     continue;
418                 }
419                 if( seq > 1 )
420                     putchar('\n');
421                 printf("%s\n", s );
422                 for(i=strlen(s); i; i-- )
423                     putchar('-');
424                 putchar('\n');
425
426                 proc_packets( a );
427                 iobuf_close(a);
428             }
429
430         }
431         else if( argc == 1) { /* list the given keyring */
432             if( !(a = iobuf_open(fname)) )
433                 log_fatal("can't open '%s'\n", fname_print);
434             proc_packets( a );
435             iobuf_close(a);
436         }
437         else
438             usage(1);
439         break;
440
441       case aPrimegen:
442         if( argc == 1 ) {
443             mpi_print( stdout, generate_public_prime( atoi(argv[0]) ), 1);
444             putchar('\n');
445         }
446         else if( argc == 2 ) {
447             mpi_print( stdout, generate_elg_prime( atoi(argv[0]),
448                                                    atoi(argv[1]), NULL ), 1);
449             putchar('\n');
450         }
451         else if( argc == 3 ) {
452             MPI g = mpi_alloc(1);
453             mpi_print( stdout, generate_elg_prime( atoi(argv[0]),
454                                                    atoi(argv[1]), g ), 1);
455             printf("\nGenerator: ");
456             mpi_print( stdout, g, 1 );
457             putchar('\n');
458             mpi_free(g);
459         }
460         else
461             usage(1);
462         break;
463
464       case aPrintMDs:
465         if( !argc )
466             print_mds(NULL);
467         else {
468             for(; argc; argc--, argv++ )
469                 print_mds(*argv);
470         }
471         break;
472
473       case aKeygen: /* generate a key (interactive) */
474         if( argc )
475             usage(1);
476         generate_keypair();
477         break;
478
479       case aTest: do_test( argc? atoi(*argv): 0 ); break;
480
481       case aListPackets:
482         opt.list_packets=1;
483       default:
484         if( argc > 1 )
485             usage(1);
486         if( !(a = iobuf_open(fname)) )
487             log_fatal("can't open '%s'\n", fname_print);
488         if( !opt.no_armor ) {
489             /* push the armor filter, so it can peek at the input data */
490             memset( &afx, 0, sizeof afx);
491             iobuf_push_filter( a, armor_filter, &afx );
492         }
493         if( cmd == aListPackets ) {
494             set_packet_list_mode(1);
495             opt.list_packets=1;
496         }
497         proc_packets( a );
498         iobuf_close(a);
499         break;
500     }
501
502     /* cleanup */
503     FREE_STRLIST(remusr);
504     FREE_STRLIST(locusr);
505     return log_get_errorcount(0)? 2:0;
506 }
507
508
509 static void
510 print_hex( byte *p, size_t n )
511 {
512     int i;
513
514     if( n == 20 ) {
515         for(i=0; i < n ; i++, i++, p += 2 ) {
516             if( i == 10 )
517                 putchar(' ');
518             printf(" %02X%02X", *p, p[1] );
519         }
520     }
521     else {
522         for(i=0; i < n ; i++, p++ ) {
523             if( i && !(i%8) )
524                 putchar(' ');
525             printf(" %02X", *p );
526         }
527     }
528 }
529
530 static void
531 print_mds( const char *fname )
532 {
533     FILE *fp;
534     char buf[1024];
535     size_t n;
536     MD5HANDLE md5;
537     RMDHANDLE rmd160;
538     SHA1HANDLE sha1;
539
540     if( !fname ) {
541         fp = stdin;
542         fname = "[stdin]";
543     }
544     else
545         fp = fopen( fname, "rb" );
546     if( !fp ) {
547         log_error("%s: %s\n", fname, strerror(errno) );
548         return;
549     }
550
551     md5    = md5_open(0);
552     rmd160 = rmd160_open(0);
553     sha1   = sha1_open(0);
554
555     while( (n=fread( buf, 1, DIM(buf), fp )) ) {
556         md5_write( md5, buf, n );
557         rmd160_write( rmd160, buf, n );
558         sha1_write( sha1, buf, n );
559     }
560     if( ferror(fp) )
561         log_error("%s: %s\n", fname, strerror(errno) );
562     else {
563         byte *p;
564
565         md5_final(md5);
566         printf(  "%s:    MD5 =", fname ); print_hex(md5_read(md5), 16 );
567         printf("\n%s: RMD160 =", fname ); print_hex(rmd160_final(rmd160), 20 );
568         printf("\n%s:   SHA1 =", fname ); print_hex(sha1_final(sha1), 20 );
569         putchar('\n');
570     }
571
572
573     md5_close(md5);
574     rmd160_close(rmd160);
575     sha1_close(sha1);
576
577     if( fp != stdin )
578         fclose(fp);
579 }
580
581
582
583 static void
584 do_test(int times)
585 {
586   #if 0
587     MPI t = mpi_alloc( 50 );
588     MPI m = mpi_alloc( 50 );
589     MPI a = mpi_alloc( 50 );
590     MPI b = mpi_alloc( 50 );
591     MPI p = mpi_alloc( 50 );
592     MPI x = mpi_alloc( 50 );
593
594     /* output = b/(a^x) mod p */
595     log_debug("invm %d times ", times);
596     for( ; times > 0; times -- ) {
597         mpi_fromstr(a, "0xef45678343589854354a4545545454554545455"
598                        "aaaaaaaaaaaaa44444fffdecb33434343443331" );
599         mpi_fromstr(b, "0x8765765589854354a4545545454554545455"
600                        "aaaaaaa466577778decb36666343443331" );
601         mpi_invm( t, a, b );
602         fputc('.', stderr); fflush(stderr);
603     }
604
605
606     m_check(NULL);
607   #endif
608 }
609