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