gpg: Add option --weak-digest to gpg and gpgv.
[gnupg.git] / g10 / sig-check.c
1 /* sig-check.c -  Check a signature
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003,
3  *               2004, 2006 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <assert.h>
26
27 #include "gpg.h"
28 #include "util.h"
29 #include "packet.h"
30 #include "keydb.h"
31 #include "main.h"
32 #include "status.h"
33 #include "i18n.h"
34 #include "options.h"
35 #include "pkglue.h"
36
37
38
39
40 static int do_check( PKT_public_key *pk, PKT_signature *sig,
41                      gcry_md_hd_t digest,
42                      int *r_expired, int *r_revoked, PKT_public_key *ret_pk);
43
44 /****************
45  * Check the signature which is contained in SIG.
46  * The MD_HANDLE should be currently open, so that this function
47  * is able to append some data, before finalizing the digest.
48  */
49 int
50 signature_check (PKT_signature *sig, gcry_md_hd_t digest)
51 {
52     return signature_check2( sig, digest, NULL, NULL, NULL, NULL );
53 }
54
55 int
56 signature_check2 (PKT_signature *sig, gcry_md_hd_t digest, u32 *r_expiredate,
57                   int *r_expired, int *r_revoked, PKT_public_key *pk )
58 {
59     int rc=0;
60     int pk_internal;
61
62     if (pk)
63       pk_internal = 0;
64     else
65       {
66         pk_internal = 1;
67         pk = xmalloc_clear( sizeof *pk );
68       }
69
70     if ( (rc=openpgp_md_test_algo(sig->digest_algo)) )
71       ; /* We don't have this digest. */
72     else if ((rc=openpgp_pk_test_algo(sig->pubkey_algo)))
73       ; /* We don't have this pubkey algo. */
74     else if (!gcry_md_is_enabled (digest,sig->digest_algo))
75       {
76         /* Sanity check that the md has a context for the hash that the
77            sig is expecting.  This can happen if a onepass sig header does
78            not match the actual sig, and also if the clearsign "Hash:"
79            header is missing or does not match the actual sig. */
80
81         log_info(_("WARNING: signature digest conflict in message\n"));
82         rc = GPG_ERR_GENERAL;
83       }
84     else if( get_pubkey( pk, sig->keyid ) )
85         rc = GPG_ERR_NO_PUBKEY;
86     else if(!pk->flags.valid && !pk->flags.primary)
87       {
88         /* You cannot have a good sig from an invalid subkey.  */
89         rc = GPG_ERR_BAD_PUBKEY;
90       }
91     else
92       {
93         if(r_expiredate)
94           *r_expiredate = pk->expiredate;
95
96         rc = do_check( pk, sig, digest, r_expired, r_revoked, NULL );
97
98         /* Check the backsig.  This is a 0x19 signature from the
99            subkey on the primary key.  The idea here is that it should
100            not be possible for someone to "steal" subkeys and claim
101            them as their own.  The attacker couldn't actually use the
102            subkey, but they could try and claim ownership of any
103            signaures issued by it. */
104         if(rc==0 && !pk->flags.primary && pk->flags.backsig < 2)
105           {
106             if (!pk->flags.backsig)
107               {
108                 log_info(_("WARNING: signing subkey %s is not"
109                            " cross-certified\n"),keystr_from_pk(pk));
110                 log_info(_("please see %s for more information\n"),
111                          "https://gnupg.org/faq/subkey-cross-certify.html");
112                 /* --require-cross-certification makes this warning an
113                      error.  TODO: change the default to require this
114                      after more keys have backsigs. */
115                 if(opt.flags.require_cross_cert)
116                   rc = GPG_ERR_GENERAL;
117               }
118             else if(pk->flags.backsig == 1)
119               {
120                 log_info(_("WARNING: signing subkey %s has an invalid"
121                            " cross-certification\n"),keystr_from_pk(pk));
122                 rc = GPG_ERR_GENERAL;
123               }
124           }
125       }
126
127     if (pk_internal || rc)
128       {
129         release_public_key_parts (pk);
130         if (pk_internal)
131           xfree (pk);
132         else
133           /* Be very sure that the caller doesn't try to use *PK.  */
134           memset (pk, 0, sizeof (*pk));
135       }
136
137     if( !rc && sig->sig_class < 2 && is_status_enabled() ) {
138         /* This signature id works best with DLP algorithms because
139          * they use a random parameter for every signature.  Instead of
140          * this sig-id we could have also used the hash of the document
141          * and the timestamp, but the drawback of this is, that it is
142          * not possible to sign more than one identical document within
143          * one second.  Some remote batch processing applications might
144          * like this feature here.
145          *
146          * Note that before 2.0.10, we used RIPE-MD160 for the hash
147          * and accidently didn't include the timestamp and algorithm
148          * information in the hash.  Given that this feature is not
149          * commonly used and that a replay attacks detection should
150          * not solely be based on this feature (because it does not
151          * work with RSA), we take the freedom and switch to SHA-1
152          * with 2.0.10 to take advantage of hardware supported SHA-1
153          * implementations.  We also include the missing information
154          * in the hash.  Note also the SIG_ID as computed by gpg 1.x
155          * and gpg 2.x didn't matched either because 2.x used to print
156          * MPIs not in PGP format.  */
157         u32 a = sig->timestamp;
158         int nsig = pubkey_get_nsig( sig->pubkey_algo );
159         unsigned char *p, *buffer;
160         size_t n, nbytes;
161         int i;
162         char hashbuf[20];
163
164         nbytes = 6;
165         for (i=0; i < nsig; i++ )
166           {
167             if (gcry_mpi_print (GCRYMPI_FMT_USG, NULL, 0, &n, sig->data[i]))
168               BUG();
169             nbytes += n;
170           }
171
172         /* Make buffer large enough to be later used as output buffer.  */
173         if (nbytes < 100)
174           nbytes = 100;
175         nbytes += 10;  /* Safety margin.  */
176
177         /* Fill and hash buffer.  */
178         buffer = p = xmalloc (nbytes);
179         *p++ = sig->pubkey_algo;
180         *p++ = sig->digest_algo;
181         *p++ = (a >> 24) & 0xff;
182         *p++ = (a >> 16) & 0xff;
183         *p++ = (a >>  8) & 0xff;
184         *p++ =  a & 0xff;
185         nbytes -= 6;
186         for (i=0; i < nsig; i++ )
187           {
188             if (gcry_mpi_print (GCRYMPI_FMT_PGP, p, nbytes, &n, sig->data[i]))
189               BUG();
190             p += n;
191             nbytes -= n;
192           }
193         gcry_md_hash_buffer (GCRY_MD_SHA1, hashbuf, buffer, p-buffer);
194
195         p = make_radix64_string (hashbuf, 20);
196         sprintf (buffer, "%s %s %lu",
197                  p, strtimestamp (sig->timestamp), (ulong)sig->timestamp);
198         xfree (p);
199         write_status_text (STATUS_SIG_ID, buffer);
200         xfree (buffer);
201     }
202
203     return rc;
204 }
205
206
207 static int
208 do_check_messages( PKT_public_key *pk, PKT_signature *sig,
209                    int *r_expired, int *r_revoked )
210 {
211     u32 cur_time;
212
213     if(r_expired)
214       *r_expired = 0;
215     if(r_revoked)
216       *r_revoked = 0;
217
218     if( pk->timestamp > sig->timestamp )
219       {
220         ulong d = pk->timestamp - sig->timestamp;
221         log_info(d==1
222                  ?_("public key %s is %lu second newer than the signature\n")
223                  :_("public key %s is %lu seconds newer than the signature\n"),
224                  keystr_from_pk(pk),d );
225         if( !opt.ignore_time_conflict )
226           return GPG_ERR_TIME_CONFLICT; /* pubkey newer than signature.  */
227       }
228
229     cur_time = make_timestamp();
230     if( pk->timestamp > cur_time )
231       {
232         ulong d = pk->timestamp - cur_time;
233         log_info( d==1
234                   ? _("key %s was created %lu second"
235                       " in the future (time warp or clock problem)\n")
236                   : _("key %s was created %lu seconds"
237                       " in the future (time warp or clock problem)\n"),
238                   keystr_from_pk(pk),d );
239         if( !opt.ignore_time_conflict )
240           return GPG_ERR_TIME_CONFLICT;
241       }
242
243     /* Check whether the key has expired.  We check the has_expired
244        flag which is set after a full evaluation of the key (getkey.c)
245        as well as a simple compare to the current time in case the
246        merge has for whatever reasons not been done.  */
247     if( pk->has_expired || (pk->expiredate && pk->expiredate < cur_time)) {
248         char buf[11];
249         if (opt.verbose)
250           log_info(_("Note: signature key %s expired %s\n"),
251                    keystr_from_pk(pk), asctimestamp( pk->expiredate ) );
252         sprintf(buf,"%lu",(ulong)pk->expiredate);
253         write_status_text(STATUS_KEYEXPIRED,buf);
254         if(r_expired)
255           *r_expired = 1;
256     }
257
258     if (pk->flags.revoked)
259       {
260         if (opt.verbose)
261           log_info (_("Note: signature key %s has been revoked\n"),
262                     keystr_from_pk(pk));
263         if (r_revoked)
264           *r_revoked=1;
265       }
266
267     return 0;
268 }
269
270
271 static int
272 do_check( PKT_public_key *pk, PKT_signature *sig, gcry_md_hd_t digest,
273           int *r_expired, int *r_revoked, PKT_public_key *ret_pk )
274 {
275     gcry_mpi_t result = NULL;
276     int rc = 0;
277     const struct weakhash *weak;
278
279     if( (rc=do_check_messages(pk,sig,r_expired,r_revoked)) )
280         return rc;
281
282     if (!opt.flags.allow_weak_digest_algos)
283       {
284         if (sig->digest_algo == GCRY_MD_MD5)
285           return GPG_ERR_DIGEST_ALGO;
286         for (weak = opt.additional_weak_digests; weak; weak = weak->next)
287           if (sig->digest_algo == weak->algo)
288             return GPG_ERR_DIGEST_ALGO;
289       }
290
291     /* Make sure the digest algo is enabled (in case of a detached
292        signature).  */
293     gcry_md_enable (digest, sig->digest_algo);
294
295     /* Complete the digest. */
296     if( sig->version >= 4 )
297         gcry_md_putc( digest, sig->version );
298     gcry_md_putc( digest, sig->sig_class );
299     if( sig->version < 4 ) {
300         u32 a = sig->timestamp;
301         gcry_md_putc( digest, (a >> 24) & 0xff );
302         gcry_md_putc( digest, (a >> 16) & 0xff );
303         gcry_md_putc( digest, (a >>     8) & 0xff );
304         gcry_md_putc( digest,  a           & 0xff );
305     }
306     else {
307         byte buf[6];
308         size_t n;
309         gcry_md_putc( digest, sig->pubkey_algo );
310         gcry_md_putc( digest, sig->digest_algo );
311         if( sig->hashed ) {
312             n = sig->hashed->len;
313             gcry_md_putc (digest, (n >> 8) );
314             gcry_md_putc (digest,  n       );
315             gcry_md_write (digest, sig->hashed->data, n);
316             n += 6;
317         }
318         else {
319           /* Two octets for the (empty) length of the hashed
320              section. */
321           gcry_md_putc (digest, 0);
322           gcry_md_putc (digest, 0);
323           n = 6;
324         }
325         /* add some magic */
326         buf[0] = sig->version;
327         buf[1] = 0xff;
328         buf[2] = n >> 24;
329         buf[3] = n >> 16;
330         buf[4] = n >>  8;
331         buf[5] = n;
332         gcry_md_write( digest, buf, 6 );
333     }
334     gcry_md_final( digest );
335
336     result = encode_md_value (pk, digest, sig->digest_algo );
337     if (!result)
338         return GPG_ERR_GENERAL;
339     rc = pk_verify( pk->pubkey_algo, result, sig->data, pk->pkey );
340     gcry_mpi_release (result);
341
342     if( !rc && sig->flags.unknown_critical )
343       {
344         log_info(_("assuming bad signature from key %s"
345                    " due to an unknown critical bit\n"),keystr_from_pk(pk));
346         rc = GPG_ERR_BAD_SIGNATURE;
347       }
348
349     if(!rc && ret_pk)
350       copy_public_key(ret_pk,pk);
351
352     return rc;
353 }
354
355
356
357 static void
358 hash_uid_node( KBNODE unode, gcry_md_hd_t md, PKT_signature *sig )
359 {
360     PKT_user_id *uid = unode->pkt->pkt.user_id;
361
362     assert( unode->pkt->pkttype == PKT_USER_ID );
363     if( uid->attrib_data ) {
364         if( sig->version >=4 ) {
365             byte buf[5];
366             buf[0] = 0xd1;                   /* packet of type 17 */
367             buf[1] = uid->attrib_len >> 24;  /* always use 4 length bytes */
368             buf[2] = uid->attrib_len >> 16;
369             buf[3] = uid->attrib_len >>  8;
370             buf[4] = uid->attrib_len;
371             gcry_md_write( md, buf, 5 );
372         }
373         gcry_md_write( md, uid->attrib_data, uid->attrib_len );
374     }
375     else {
376         if( sig->version >=4 ) {
377             byte buf[5];
378             buf[0] = 0xb4;            /* indicates a userid packet */
379             buf[1] = uid->len >> 24;  /* always use 4 length bytes */
380             buf[2] = uid->len >> 16;
381             buf[3] = uid->len >>  8;
382             buf[4] = uid->len;
383             gcry_md_write( md, buf, 5 );
384         }
385         gcry_md_write( md, uid->name, uid->len );
386     }
387 }
388
389 static void
390 cache_sig_result ( PKT_signature *sig, int result )
391 {
392     if ( !result ) {
393         sig->flags.checked = 1;
394         sig->flags.valid = 1;
395     }
396     else if ( gpg_err_code (result) == GPG_ERR_BAD_SIGNATURE ) {
397         sig->flags.checked = 1;
398         sig->flags.valid = 0;
399     }
400     else {
401         sig->flags.checked = 0;
402         sig->flags.valid = 0;
403     }
404 }
405
406 /* Check the revocation keys to see if any of them have revoked our
407    pk.  sig is the revocation sig.  pk is the key it is on.  This code
408    will need to be modified if gpg ever becomes multi-threaded.  Note
409    that this guarantees that a designated revocation sig will never be
410    considered valid unless it is actually valid, as well as being
411    issued by a revocation key in a valid direct signature.  Note also
412    that this is written so that a revoked revoker can still issue
413    revocations: i.e. If A revokes B, but A is revoked, B is still
414    revoked.  I'm not completely convinced this is the proper behavior,
415    but it matches how PGP does it. -dms */
416
417 /* Returns 0 if sig is valid (i.e. pk is revoked), non-0 if not
418    revoked.  It is important that GPG_ERR_NO_PUBKEY is only returned
419    when a revocation signature is from a valid revocation key
420    designated in a revkey subpacket, but the revocation key itself
421    isn't present. */
422 int
423 check_revocation_keys(PKT_public_key *pk,PKT_signature *sig)
424 {
425   static int busy=0;
426   int i;
427   int rc = GPG_ERR_GENERAL;
428
429   assert(IS_KEY_REV(sig));
430   assert((sig->keyid[0]!=pk->keyid[0]) || (sig->keyid[0]!=pk->keyid[1]));
431
432   if (busy)
433     {
434       /* Return an error (i.e. not revoked), but mark the pk as
435          uncacheable as we don't really know its revocation status
436          until it is checked directly.  */
437       pk->flags.dont_cache = 1;
438       return rc;
439     }
440
441   busy=1;
442
443   /*  es_printf("looking at %08lX with a sig from %08lX\n",(ulong)pk->keyid[1],
444       (ulong)sig->keyid[1]); */
445
446   /* is the issuer of the sig one of our revokers? */
447   if( !pk->revkey && pk->numrevkeys )
448      BUG();
449   else
450       for(i=0;i<pk->numrevkeys;i++)
451         {
452           u32 keyid[2];
453
454           keyid_from_fingerprint(pk->revkey[i].fpr,MAX_FINGERPRINT_LEN,keyid);
455
456           if(keyid[0]==sig->keyid[0] && keyid[1]==sig->keyid[1])
457             {
458               gcry_md_hd_t md;
459
460               if (gcry_md_open (&md, sig->digest_algo, 0))
461                 BUG ();
462               hash_public_key(md,pk);
463               rc=signature_check(sig,md);
464               cache_sig_result(sig,rc);
465               gcry_md_close (md);
466               break;
467             }
468         }
469
470   busy=0;
471
472   return rc;
473 }
474
475 /* Backsigs (0x19) have the same format as binding sigs (0x18), but
476    this function is simpler than check_key_signature in a few ways.
477    For example, there is no support for expiring backsigs since it is
478    questionable what such a thing actually means.  Note also that the
479    sig cache check here, unlike other sig caches in GnuPG, is not
480    persistent. */
481 int
482 check_backsig(PKT_public_key *main_pk,PKT_public_key *sub_pk,
483               PKT_signature *backsig)
484 {
485   gcry_md_hd_t md;
486   int rc;
487
488   /* Always check whether the algorithm is available.  Although
489      gcry_md_open woyuld throw an error, some libgcrypt versions will
490      print a debug message in that case too. */
491   if ((rc=openpgp_md_test_algo (backsig->digest_algo)))
492     return rc;
493
494   if(!opt.no_sig_cache && backsig->flags.checked)
495     return backsig->flags.valid? 0 : gpg_error (GPG_ERR_BAD_SIGNATURE);
496
497   rc = gcry_md_open (&md, backsig->digest_algo,0);
498   if (!rc)
499     {
500       hash_public_key(md,main_pk);
501       hash_public_key(md,sub_pk);
502       rc=do_check(sub_pk,backsig,md,NULL,NULL,NULL);
503       cache_sig_result(backsig,rc);
504       gcry_md_close(md);
505     }
506
507   return rc;
508 }
509
510
511 /****************
512  * check the signature pointed to by NODE. This is a key signature.
513  * If the function detects a self-signature, it uses the PK from
514  * ROOT and does not read any public key.
515  */
516 int
517 check_key_signature( KBNODE root, KBNODE node, int *is_selfsig )
518 {
519   return check_key_signature2(root, node, NULL, NULL, is_selfsig, NULL, NULL );
520 }
521
522 /* If check_pk is set, then use it to check the signature in node
523    rather than getting it from root or the keydb.  If ret_pk is set,
524    fill in the public key that was used to verify the signature.
525    ret_pk is only meaningful when the verification was successful. */
526 /* TODO: add r_revoked here as well.  It has the same problems as
527    r_expiredate and r_expired and the cache. */
528 int
529 check_key_signature2( KBNODE root, KBNODE node, PKT_public_key *check_pk,
530                       PKT_public_key *ret_pk, int *is_selfsig,
531                       u32 *r_expiredate, int *r_expired )
532 {
533     gcry_md_hd_t md;
534     PKT_public_key *pk;
535     PKT_signature *sig;
536     int algo;
537     int rc;
538
539     if( is_selfsig )
540         *is_selfsig = 0;
541     if( r_expiredate )
542         *r_expiredate = 0;
543     if( r_expired )
544         *r_expired = 0;
545     assert( node->pkt->pkttype == PKT_SIGNATURE );
546     assert( root->pkt->pkttype == PKT_PUBLIC_KEY );
547
548     pk = root->pkt->pkt.public_key;
549     sig = node->pkt->pkt.signature;
550     algo = sig->digest_algo;
551
552     /* Check whether we have cached the result of a previous signature
553        check.  Note that we may no longer have the pubkey or hash
554        needed to verify a sig, but can still use the cached value.  A
555        cache refresh detects and clears these cases. */
556     if ( !opt.no_sig_cache ) {
557         if (sig->flags.checked) { /*cached status available*/
558             if( is_selfsig ) {
559                 u32 keyid[2];
560
561                 keyid_from_pk( pk, keyid );
562                 if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
563                     *is_selfsig = 1;
564             }
565             /* BUG: This is wrong for non-self-sigs.. needs to be the
566                actual pk */
567             if((rc=do_check_messages(pk,sig,r_expired,NULL)))
568               return rc;
569             return sig->flags.valid? 0 : gpg_error (GPG_ERR_BAD_SIGNATURE);
570         }
571     }
572
573     if( (rc=openpgp_pk_test_algo(sig->pubkey_algo)) )
574         return rc;
575     if( (rc=openpgp_md_test_algo(algo)) )
576         return rc;
577
578     if( sig->sig_class == 0x20 ) { /* key revocation */
579         u32 keyid[2];
580         keyid_from_pk( pk, keyid );
581
582         /* is it a designated revoker? */
583         if(keyid[0]!=sig->keyid[0] || keyid[1]!=sig->keyid[1])
584           rc=check_revocation_keys(pk,sig);
585         else
586           {
587             if (gcry_md_open (&md, algo, 0 ))
588               BUG ();
589             hash_public_key( md, pk );
590             rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
591             cache_sig_result ( sig, rc );
592             gcry_md_close(md);
593           }
594     }
595     else if( sig->sig_class == 0x28 ) { /* subkey revocation */
596         KBNODE snode = find_prev_kbnode( root, node, PKT_PUBLIC_SUBKEY );
597
598         if( snode ) {
599             if (gcry_md_open (&md, algo, 0))
600               BUG ();
601             hash_public_key( md, pk );
602             hash_public_key( md, snode->pkt->pkt.public_key );
603             rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
604             cache_sig_result ( sig, rc );
605             gcry_md_close(md);
606         }
607         else
608           {
609             if (opt.verbose)
610               log_info (_("key %s: no subkey for subkey"
611                           " revocation signature\n"),keystr_from_pk(pk));
612             rc = GPG_ERR_SIG_CLASS;
613           }
614     }
615     else if( sig->sig_class == 0x18 ) { /* key binding */
616         KBNODE snode = find_prev_kbnode( root, node, PKT_PUBLIC_SUBKEY );
617
618         if( snode ) {
619             if( is_selfsig ) {  /* does this make sense????? */
620                 u32 keyid[2];   /* it should always be a selfsig */
621
622                 keyid_from_pk( pk, keyid );
623                 if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
624                     *is_selfsig = 1;
625             }
626             if (gcry_md_open (&md, algo, 0))
627               BUG ();
628             hash_public_key( md, pk );
629             hash_public_key( md, snode->pkt->pkt.public_key );
630             rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
631             cache_sig_result ( sig, rc );
632             gcry_md_close(md);
633         }
634         else
635           {
636             if (opt.verbose)
637               log_info(_("key %s: no subkey for subkey"
638                          " binding signature\n"),keystr_from_pk(pk));
639             rc = GPG_ERR_SIG_CLASS;
640           }
641     }
642     else if( sig->sig_class == 0x1f ) { /* direct key signature */
643         if (gcry_md_open (&md, algo, 0 ))
644           BUG ();
645         hash_public_key( md, pk );
646         rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
647         cache_sig_result ( sig, rc );
648         gcry_md_close(md);
649     }
650     else { /* all other classes */
651         KBNODE unode = find_prev_kbnode( root, node, PKT_USER_ID );
652
653         if( unode ) {
654             u32 keyid[2];
655
656             keyid_from_pk( pk, keyid );
657             if (gcry_md_open (&md, algo, 0 ))
658               BUG ();
659             hash_public_key( md, pk );
660             hash_uid_node( unode, md, sig );
661             if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
662               {
663                 if( is_selfsig )
664                   *is_selfsig = 1;
665                 rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
666               }
667             else if (check_pk)
668               rc=do_check(check_pk,sig,md,r_expired,NULL,ret_pk);
669             else
670               rc=signature_check2(sig,md,r_expiredate,r_expired,NULL,ret_pk);
671
672             cache_sig_result ( sig, rc );
673             gcry_md_close(md);
674         }
675         else
676           {
677             if (!opt.quiet)
678               log_info ("key %s: no user ID for key signature packet"
679                         " of class %02x\n",keystr_from_pk(pk),sig->sig_class);
680             rc = GPG_ERR_SIG_CLASS;
681           }
682     }
683
684     return rc;
685 }