See ChangeLog: Wed Oct 4 13:16:18 CEST 2000 Werner Koch
[gnupg.git] / g10 / keylist.c
1 /* keylist.c
2  *      Copyright (C) 1998, 1999, 2000 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 "options.h"
29 #include "packet.h"
30 #include "errors.h"
31 #include "keydb.h"
32 #include <gcrypt.h>
33 #include "util.h"
34 #include "trustdb.h"
35 #include "main.h"
36 #include "i18n.h"
37
38 static void list_all(int);
39 static void list_one( STRLIST names, int secret);
40 static void list_keyblock( KBNODE keyblock, int secret );
41 static void fingerprint( PKT_public_key *pk, PKT_secret_key *sk );
42
43
44 /****************
45  * List the keys
46  * If list is NULL, all available keys are listed
47  */
48 void
49 public_key_list( STRLIST list )
50 {
51     if( !list )
52         list_all(0);
53     else
54         list_one( list, 0 );
55 }
56
57 void
58 secret_key_list( STRLIST list )
59 {
60     if( !list )
61         list_all(1);
62     else  /* List by user id */
63         list_one( list, 1 );
64 }
65
66
67 static void
68 list_all( int secret )
69 {
70     KBPOS kbpos;
71     KBNODE keyblock = NULL;
72     int rc=0;
73     int lastresno;
74
75     rc = enum_keyblocks( secret? 5:0, &kbpos, &keyblock );
76     if( rc ) {
77         if( rc != -1 )
78             log_error("enum_keyblocks(open) failed: %s\n", gpg_errstr(rc) );
79         goto leave;
80     }
81
82     lastresno = -1;
83     while( !(rc = enum_keyblocks( 1, &kbpos, &keyblock )) ) {
84         if( lastresno != kbpos.resno ) {
85             const char *s = keyblock_resource_name( &kbpos );
86             int i;
87
88             lastresno = kbpos.resno;
89             printf("%s\n", s );
90             for(i=strlen(s); i; i-- )
91                 putchar('-');
92             putchar('\n');
93         }
94         merge_keys_and_selfsig( keyblock );
95         list_keyblock( keyblock, secret );
96         release_kbnode( keyblock ); keyblock = NULL;
97     }
98
99     if( rc && rc != -1 )
100         log_error("enum_keyblocks(read) failed: %s\n", gpg_errstr(rc));
101
102   leave:
103     enum_keyblocks( 2, &kbpos, &keyblock ); /* close */
104     release_kbnode( keyblock );
105 }
106
107
108 /****************
109  * Check whether the user ID at NODE is valid; that is it has a
110  * valid self-signature but no later valid revocation.
111  * Caller has to pass the keyID of the primary in mainkey.
112  * Returns: NULL = valid
113  *          string with the reason why it is invalid
114  */
115 static const char *
116 is_uid_valid ( KBNODE keyblock, KBNODE uidnode, u32 *mainkid )
117 {
118     KBNODE node;
119     PKT_signature *selfsig = NULL; /* the latest valid self signature */
120
121     /* The key signature verify function can's handle secret keys yet and
122      * becuase we are not sure whether the duplication of user IDs and
123      * self-signatures should be kept on secret keys we are not going to fix
124      * it there. */
125     if ( keyblock->pkt->pkttype == PKT_SECRET_KEY )
126         return NULL;
127
128     assert ( uidnode->pkt->pkttype == PKT_USER_ID
129              || uidnode->pkt->pkttype == PKT_PHOTO_ID );
130
131     /* first find out about the latest valid self-signature */
132     for ( node = uidnode->next; node; node = node->next ) {
133         PKT_signature *sig;
134
135         if ( node->pkt->pkttype == PKT_USER_ID
136              || node->pkt->pkttype == PKT_PHOTO_ID
137              || node->pkt->pkttype == PKT_PUBLIC_SUBKEY
138              || node->pkt->pkttype == PKT_SECRET_SUBKEY )
139             break;
140         if ( node->pkt->pkttype != PKT_SIGNATURE )
141             continue;
142         sig = node->pkt->pkt.signature;
143         if ( mainkid[0] != sig->keyid[0] || mainkid[1] != sig->keyid[1] )
144             continue; /* we only care about self-signatures for now */
145
146         if ( (sig->sig_class&~3) == 0x10 ) { /* regular self signature */
147             if ( !check_key_signature( keyblock, node, NULL ) ) {
148                 if ( !selfsig )
149                     selfsig = sig; /* use the first valid sig */
150                 else if ( sig->timestamp > selfsig->timestamp
151                           && sig->sig_class >= selfsig->sig_class )
152                     selfsig = sig; /* but this one is newer */
153             }
154         }
155     }
156
157     if ( !selfsig )
158         return _("invalid"); /* no valid self signature */
159
160     /* watch out for a newer revocation */
161     for ( node = uidnode->next; node; node = node->next ) {
162         PKT_signature *sig;
163
164         if ( node->pkt->pkttype == PKT_USER_ID
165              || node->pkt->pkttype == PKT_PHOTO_ID
166              || node->pkt->pkttype == PKT_PUBLIC_SUBKEY
167              || node->pkt->pkttype == PKT_SECRET_SUBKEY )
168             break;
169         if ( node->pkt->pkttype != PKT_SIGNATURE )
170             continue;
171         sig = node->pkt->pkt.signature;
172         if ( mainkid[0] != sig->keyid[0] || mainkid[1] != sig->keyid[1] )
173             continue; /* we only care about self-signatures for now */
174
175         if ( sig->sig_class == 0x30
176              && sig->timestamp >= selfsig->timestamp ) {
177             if ( !check_key_signature( keyblock, node, NULL ) )
178                 return _("revoked");
179         }
180     }
181
182     return NULL; /* UID is valid */
183 }
184
185
186 static void
187 list_one( STRLIST names, int secret )
188 {
189     int rc = 0;
190     KBNODE keyblock = NULL;
191     GETKEY_CTX ctx;
192
193     if( secret ) {
194         rc = get_seckey_bynames( &ctx, NULL, names, &keyblock );
195         if( rc ) {
196             log_error("error reading key: %s\n",  gpg_errstr(rc) );
197             get_seckey_end( ctx );
198             return;
199         }
200         do {
201             merge_keys_and_selfsig( keyblock );
202             list_keyblock( keyblock, 1 );
203             release_kbnode( keyblock );
204         } while( !get_seckey_next( ctx, NULL, &keyblock ) );
205         get_seckey_end( ctx );
206     }
207     else {
208         rc = get_pubkey_bynames( &ctx, NULL, names, &keyblock );
209         if( rc ) {
210             log_error("error reading key: %s\n", gpg_errstr(rc) );
211             get_pubkey_end( ctx );
212             return;
213         }
214         do {
215             merge_keys_and_selfsig( keyblock );
216             list_keyblock( keyblock, 0 );
217             release_kbnode( keyblock );
218         } while( !get_pubkey_next( ctx, NULL, &keyblock ) );
219         get_pubkey_end( ctx );
220     }
221 }
222
223 static void
224 print_key_data( PKT_public_key *pk, u32 *keyid )
225 {
226     int n = pk ? pubkey_get_npkey( pk->pubkey_algo ) : 0;
227     int i;
228
229     for(i=0; i < n; i++ ) {
230         printf("pkd:%d:%u:", i, gcry_mpi_get_nbits( pk->pkey[i] ) );
231         mpi_print(stdout, pk->pkey[i], 1 );
232         putchar(':');
233         putchar('\n');
234     }
235 }
236
237
238 static void
239 list_keyblock( KBNODE keyblock, int secret )
240 {
241     int rc = 0;
242     KBNODE kbctx;
243     KBNODE node;
244     PKT_public_key *pk;
245     PKT_secret_key *sk;
246     u32 keyid[2];
247     int any=0;
248     int trustletter = 0;
249     int ulti_hack = 0;
250
251     /* get the keyid from the keyblock */
252     node = find_kbnode( keyblock, secret? PKT_SECRET_KEY : PKT_PUBLIC_KEY );
253     if( !node ) {
254         log_error("Oops; key lost!\n");
255         dump_kbnode( keyblock );
256         return;
257     }
258
259     if( secret ) {
260         pk = NULL;
261         sk = node->pkt->pkt.secret_key;
262         keyid_from_sk( sk, keyid );
263         if( opt.with_colons )
264             printf("sec:u:%u:%d:%08lX%08lX:%s:%s:::",
265                     nbits_from_sk( sk ),
266                     sk->pubkey_algo,
267                     (ulong)keyid[0],(ulong)keyid[1],
268                     datestr_from_sk( sk ),
269                     sk->expiredate? strtimestamp(sk->expiredate):""
270                     /* fixme: add LID here */ );
271         else
272             printf("sec  %4u%c/%08lX %s ", nbits_from_sk( sk ),
273                                        pubkey_letter( sk->pubkey_algo ),
274                                        (ulong)keyid[1],
275                                        datestr_from_sk( sk ) );
276     }
277     else {
278         pk = node->pkt->pkt.public_key;
279         sk = NULL;
280         keyid_from_pk( pk, keyid );
281         if( opt.with_colons ) {
282             if ( opt.fast_list_mode ) {
283                 fputs( "pub::", stdout );
284                 trustletter = 0;
285             }
286             else {
287                 trustletter = query_trust_info( pk, NULL );
288                 if( trustletter == 'u' )
289                     ulti_hack = 1;
290                 printf("pub:%c:", trustletter );
291             }
292             printf("%u:%d:%08lX%08lX:%s:%s:",
293                     nbits_from_pk( pk ),
294                     pk->pubkey_algo,
295                     (ulong)keyid[0],(ulong)keyid[1],
296                     datestr_from_pk( pk ),
297                     pk->expiredate? strtimestamp(pk->expiredate):"" );
298             if( pk->local_id )
299                 printf("%lu", pk->local_id );
300             putchar(':');
301             if( pk->local_id && !opt.fast_list_mode )
302                 putchar( get_ownertrust_info( pk->local_id ) );
303             putchar(':');
304         }
305         else
306             printf("pub  %4u%c/%08lX %s ", nbits_from_pk( pk ),
307                                        pubkey_letter( pk->pubkey_algo ),
308                                        (ulong)keyid[1],
309                                        datestr_from_pk( pk ) );
310     }
311
312     for( kbctx=NULL; (node=walk_kbnode( keyblock, &kbctx, 0)) ; ) {
313         if( node->pkt->pkttype == PKT_USER_ID && !opt.fast_list_mode ) {
314             if( any ) {
315                 if ( opt.with_colons ) {
316                     byte namehash[20];
317
318                     if( pk && !ulti_hack ) {
319                         if( node->pkt->pkt.user_id->photo ) {
320                             gcry_md_hash_buffer( GCRY_MD_RMD160, namehash,
321                                             node->pkt->pkt.user_id->name,
322                                             node->pkt->pkt.user_id->len  );
323                         }
324                         else {
325                             gcry_md_hash_buffer( GCRY_MD_RMD160, namehash,
326                                             node->pkt->pkt.user_id->name,
327                                             node->pkt->pkt.user_id->len  );
328                         }
329                         trustletter = query_trust_info( pk, namehash );
330                     }
331                     else
332                         trustletter = 'u';
333                     printf("uid:%c::::::::", trustletter);
334                 }
335                 else
336                     printf("uid%*s", 28, "");
337             }
338             if( opt.with_colons ) {
339                 print_string( stdout,  node->pkt->pkt.user_id->name,
340                               node->pkt->pkt.user_id->len, ':' );
341                 putchar(':');
342             }
343             else {
344                 const char *s = is_uid_valid ( keyblock, node, keyid );
345                 if ( s )
346                     printf ("[%s] ", s );
347                 print_utf8_string( stdout,  node->pkt->pkt.user_id->name,
348                                    node->pkt->pkt.user_id->len );
349             }
350
351             putchar('\n');
352             if( !any ) {
353                 if( opt.fingerprint )
354                     fingerprint( pk, sk );
355                 if( opt.with_key_data )
356                     print_key_data( pk, keyid );
357                 any = 1;
358             }
359         }
360         else if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
361             u32 keyid2[2];
362             PKT_public_key *pk2 = node->pkt->pkt.public_key;
363
364             if( !any ) {
365                 putchar('\n');
366                 if( opt.fingerprint )
367                     fingerprint( pk, sk ); /* of the main key */
368                 any = 1;
369             }
370
371
372
373             keyid_from_pk( pk2, keyid2 );
374             if( opt.with_colons ) {
375                 if ( opt.fast_list_mode ) {
376                     fputs( "sub::", stdout );
377                 }
378                 else {
379                     printf("sub:%c:", trustletter );
380                 }
381                 printf("%u:%d:%08lX%08lX:%s:%s:",
382                         nbits_from_pk( pk2 ),
383                         pk2->pubkey_algo,
384                         (ulong)keyid2[0],(ulong)keyid2[1],
385                         datestr_from_pk( pk2 ),
386                         pk2->expiredate? strtimestamp(pk2->expiredate):""
387                         /* fixme: add LID and ownertrust here */
388                                                 );
389                 if( pk->local_id ) /* use the local_id of the main key??? */
390                     printf("%lu", pk->local_id );
391                 putchar(':');
392                 putchar(':');
393                 putchar('\n');
394             }
395             else {
396                 printf("sub  %4u%c/%08lX %s", nbits_from_pk( pk2 ),
397                                            pubkey_letter( pk2->pubkey_algo ),
398                                            (ulong)keyid2[1],
399                                            datestr_from_pk( pk2 ) );
400                 if( pk2->expiredate ) {
401                     printf(_(" [expires: %s]"), expirestr_from_pk( pk2 ) );
402                 }
403                 putchar('\n');
404             }
405             if( opt.fingerprint > 1 )
406                 fingerprint( pk2, NULL );
407             if( opt.with_key_data )
408                 print_key_data( pk2, keyid2 );
409         }
410         else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
411             u32 keyid2[2];
412             PKT_secret_key *sk2 = node->pkt->pkt.secret_key;
413
414             if( !any ) {
415                 putchar('\n');
416                 if( opt.fingerprint )
417                     fingerprint( pk, sk ); /* of the main key */
418                 any = 1;
419             }
420
421             keyid_from_sk( sk2, keyid2 );
422             if( opt.with_colons )
423                 printf("ssb::%u:%d:%08lX%08lX:%s:%s:::\n",
424                         nbits_from_sk( sk2 ),
425                         sk2->pubkey_algo,
426                         (ulong)keyid2[0],(ulong)keyid2[1],
427                         datestr_from_sk( sk2 ),
428                         sk2->expiredate? strtimestamp(sk2->expiredate):""
429                         /* fixme: add LID */
430                                                 );
431             else
432                 printf("ssb  %4u%c/%08lX %s\n", nbits_from_sk( sk2 ),
433                                            pubkey_letter( sk2->pubkey_algo ),
434                                            (ulong)keyid2[1],
435                                            datestr_from_sk( sk2 ) );
436             if( opt.fingerprint > 1 )
437                 fingerprint( NULL, sk2 );
438
439         }
440         else if( opt.list_sigs && node->pkt->pkttype == PKT_SIGNATURE ) {
441             PKT_signature *sig = node->pkt->pkt.signature;
442             int sigrc;
443            char *sigstr;
444
445             if( !any ) { /* no user id, (maybe a revocation follows)*/
446                 if( sig->sig_class == 0x20 )
447                     puts("[revoked]");
448                 else if( sig->sig_class == 0x18 )
449                     puts("[key binding]");
450                 else if( sig->sig_class == 0x28 )
451                     puts("[subkey revoked]");
452                 else
453                     putchar('\n');
454                 if( opt.fingerprint )
455                     fingerprint( pk, sk );
456                 any=1;
457             }
458
459             if( sig->sig_class == 0x20 || sig->sig_class == 0x28
460                                        || sig->sig_class == 0x30 )
461                sigstr = "rev";
462             else if( (sig->sig_class&~3) == 0x10 )
463                sigstr = "sig";
464             else if( sig->sig_class == 0x18 )
465                sigstr = "sig";
466             else {
467                 if( opt.with_colons )
468                     printf("sig::::::::::%02x:\n",sig->sig_class );
469                 else
470                     printf("sig                             "
471                        "[unexpected signature class 0x%02x]\n",sig->sig_class );
472                 continue;
473             }
474             if( opt.check_sigs ) {
475                 fflush(stdout);
476                 rc = check_key_signature( keyblock, node, NULL );
477                 switch( rc ) {
478                   case 0:                  sigrc = '!'; break;
479                   case GPGERR_BAD_SIGN:    sigrc = '-'; break;
480                   case GPGERR_NO_PUBKEY:   sigrc = '?'; break;
481                   default:                 sigrc = '%'; break;
482                 }
483             }
484             else {
485                 rc = 0;
486                 sigrc = ' ';
487             }
488            fputs( sigstr, stdout );
489             if( opt.with_colons ) {
490                 putchar(':');
491                 if( sigrc != ' ' )
492                     putchar(sigrc);
493                 printf("::%d:%08lX%08lX:%s::::", sig->pubkey_algo,
494                                                  (ulong)sig->keyid[0],
495                            (ulong)sig->keyid[1], datestr_from_sig(sig));
496             }
497             else
498                 printf("%c       %08lX %s  ",
499                     sigrc, (ulong)sig->keyid[1], datestr_from_sig(sig));
500             if( sigrc == '%' )
501                 printf("[%s] ", gpg_errstr(rc) );
502             else if( sigrc == '?' )
503                 ;
504             else if ( !opt.fast_list_mode ) {
505                 size_t n;
506                 char *p = get_user_id( sig->keyid, &n );
507                 if( opt.with_colons )
508                     print_string( stdout, p, n, ':' );
509                 else
510                     print_utf8_string( stdout, p, n );
511                 gcry_free(p);
512             }
513             if( opt.with_colons )
514                 printf(":%02x:", sig->sig_class );
515             putchar('\n');
516             /* FIXME: check or list other sigs here (subpkt PRIV_ADD_SIG)*/
517         }
518     }
519     if( !any ) {/* oops, no user id */
520         if( opt.with_colons )
521             putchar(':');
522         putchar('\n');
523     }
524     else if( !opt.with_colons )
525         putchar('\n');  /* separator line */
526 }
527
528
529
530 static void
531 fingerprint( PKT_public_key *pk, PKT_secret_key *sk )
532 {
533     byte *array, *p;
534     size_t i, n;
535
536     p = array = pk? fingerprint_from_pk( pk, NULL, &n )
537                    : fingerprint_from_sk( sk, NULL, &n );
538     if( opt.with_colons ) {
539         printf("fpr:::::::::");
540         for(i=0; i < n ; i++, p++ )
541             printf("%02X", *p );
542         putchar(':');
543     }
544     else {
545         printf("     Key fingerprint =");
546         if( n == 20 ) {
547             for(i=0; i < n ; i++, i++, p += 2 ) {
548                 if( i == 10 )
549                     putchar(' ');
550                 printf(" %02X%02X", *p, p[1] );
551             }
552         }
553         else {
554             for(i=0; i < n ; i++, p++ ) {
555                 if( i && !(i%8) )
556                     putchar(' ');
557                 printf(" %02X", *p );
558             }
559         }
560     }
561     putchar('\n');
562     gcry_free(array);
563 }
564