gpg: Print warning when rejecting weak digests
[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           {
286             print_digest_rejected_note(sig->digest_algo);
287             return GPG_ERR_DIGEST_ALGO;
288           }
289         for (weak = opt.additional_weak_digests; weak; weak = weak->next)
290           if (sig->digest_algo == weak->algo)
291             {
292               print_digest_rejected_note(sig->digest_algo);
293               return GPG_ERR_DIGEST_ALGO;
294             }
295       }
296
297     /* Make sure the digest algo is enabled (in case of a detached
298        signature).  */
299     gcry_md_enable (digest, sig->digest_algo);
300
301     /* Complete the digest. */
302     if( sig->version >= 4 )
303         gcry_md_putc( digest, sig->version );
304     gcry_md_putc( digest, sig->sig_class );
305     if( sig->version < 4 ) {
306         u32 a = sig->timestamp;
307         gcry_md_putc( digest, (a >> 24) & 0xff );
308         gcry_md_putc( digest, (a >> 16) & 0xff );
309         gcry_md_putc( digest, (a >>     8) & 0xff );
310         gcry_md_putc( digest,  a           & 0xff );
311     }
312     else {
313         byte buf[6];
314         size_t n;
315         gcry_md_putc( digest, sig->pubkey_algo );
316         gcry_md_putc( digest, sig->digest_algo );
317         if( sig->hashed ) {
318             n = sig->hashed->len;
319             gcry_md_putc (digest, (n >> 8) );
320             gcry_md_putc (digest,  n       );
321             gcry_md_write (digest, sig->hashed->data, n);
322             n += 6;
323         }
324         else {
325           /* Two octets for the (empty) length of the hashed
326              section. */
327           gcry_md_putc (digest, 0);
328           gcry_md_putc (digest, 0);
329           n = 6;
330         }
331         /* add some magic */
332         buf[0] = sig->version;
333         buf[1] = 0xff;
334         buf[2] = n >> 24;
335         buf[3] = n >> 16;
336         buf[4] = n >>  8;
337         buf[5] = n;
338         gcry_md_write( digest, buf, 6 );
339     }
340     gcry_md_final( digest );
341
342     result = encode_md_value (pk, digest, sig->digest_algo );
343     if (!result)
344         return GPG_ERR_GENERAL;
345     rc = pk_verify( pk->pubkey_algo, result, sig->data, pk->pkey );
346     gcry_mpi_release (result);
347
348     if( !rc && sig->flags.unknown_critical )
349       {
350         log_info(_("assuming bad signature from key %s"
351                    " due to an unknown critical bit\n"),keystr_from_pk(pk));
352         rc = GPG_ERR_BAD_SIGNATURE;
353       }
354
355     if(!rc && ret_pk)
356       copy_public_key(ret_pk,pk);
357
358     return rc;
359 }
360
361
362
363 static void
364 hash_uid_node( KBNODE unode, gcry_md_hd_t md, PKT_signature *sig )
365 {
366     PKT_user_id *uid = unode->pkt->pkt.user_id;
367
368     assert( unode->pkt->pkttype == PKT_USER_ID );
369     if( uid->attrib_data ) {
370         if( sig->version >=4 ) {
371             byte buf[5];
372             buf[0] = 0xd1;                   /* packet of type 17 */
373             buf[1] = uid->attrib_len >> 24;  /* always use 4 length bytes */
374             buf[2] = uid->attrib_len >> 16;
375             buf[3] = uid->attrib_len >>  8;
376             buf[4] = uid->attrib_len;
377             gcry_md_write( md, buf, 5 );
378         }
379         gcry_md_write( md, uid->attrib_data, uid->attrib_len );
380     }
381     else {
382         if( sig->version >=4 ) {
383             byte buf[5];
384             buf[0] = 0xb4;            /* indicates a userid packet */
385             buf[1] = uid->len >> 24;  /* always use 4 length bytes */
386             buf[2] = uid->len >> 16;
387             buf[3] = uid->len >>  8;
388             buf[4] = uid->len;
389             gcry_md_write( md, buf, 5 );
390         }
391         gcry_md_write( md, uid->name, uid->len );
392     }
393 }
394
395 static void
396 cache_sig_result ( PKT_signature *sig, int result )
397 {
398     if ( !result ) {
399         sig->flags.checked = 1;
400         sig->flags.valid = 1;
401     }
402     else if ( gpg_err_code (result) == GPG_ERR_BAD_SIGNATURE ) {
403         sig->flags.checked = 1;
404         sig->flags.valid = 0;
405     }
406     else {
407         sig->flags.checked = 0;
408         sig->flags.valid = 0;
409     }
410 }
411
412 /* Check the revocation keys to see if any of them have revoked our
413    pk.  sig is the revocation sig.  pk is the key it is on.  This code
414    will need to be modified if gpg ever becomes multi-threaded.  Note
415    that this guarantees that a designated revocation sig will never be
416    considered valid unless it is actually valid, as well as being
417    issued by a revocation key in a valid direct signature.  Note also
418    that this is written so that a revoked revoker can still issue
419    revocations: i.e. If A revokes B, but A is revoked, B is still
420    revoked.  I'm not completely convinced this is the proper behavior,
421    but it matches how PGP does it. -dms */
422
423 /* Returns 0 if sig is valid (i.e. pk is revoked), non-0 if not
424    revoked.  It is important that GPG_ERR_NO_PUBKEY is only returned
425    when a revocation signature is from a valid revocation key
426    designated in a revkey subpacket, but the revocation key itself
427    isn't present. */
428 int
429 check_revocation_keys(PKT_public_key *pk,PKT_signature *sig)
430 {
431   static int busy=0;
432   int i;
433   int rc = GPG_ERR_GENERAL;
434
435   assert(IS_KEY_REV(sig));
436   assert((sig->keyid[0]!=pk->keyid[0]) || (sig->keyid[0]!=pk->keyid[1]));
437
438   if (busy)
439     {
440       /* Return an error (i.e. not revoked), but mark the pk as
441          uncacheable as we don't really know its revocation status
442          until it is checked directly.  */
443       pk->flags.dont_cache = 1;
444       return rc;
445     }
446
447   busy=1;
448
449   /*  es_printf("looking at %08lX with a sig from %08lX\n",(ulong)pk->keyid[1],
450       (ulong)sig->keyid[1]); */
451
452   /* is the issuer of the sig one of our revokers? */
453   if( !pk->revkey && pk->numrevkeys )
454      BUG();
455   else
456       for(i=0;i<pk->numrevkeys;i++)
457         {
458           u32 keyid[2];
459
460           keyid_from_fingerprint(pk->revkey[i].fpr,MAX_FINGERPRINT_LEN,keyid);
461
462           if(keyid[0]==sig->keyid[0] && keyid[1]==sig->keyid[1])
463             {
464               gcry_md_hd_t md;
465
466               if (gcry_md_open (&md, sig->digest_algo, 0))
467                 BUG ();
468               hash_public_key(md,pk);
469               rc=signature_check(sig,md);
470               cache_sig_result(sig,rc);
471               gcry_md_close (md);
472               break;
473             }
474         }
475
476   busy=0;
477
478   return rc;
479 }
480
481 /* Backsigs (0x19) have the same format as binding sigs (0x18), but
482    this function is simpler than check_key_signature in a few ways.
483    For example, there is no support for expiring backsigs since it is
484    questionable what such a thing actually means.  Note also that the
485    sig cache check here, unlike other sig caches in GnuPG, is not
486    persistent. */
487 int
488 check_backsig(PKT_public_key *main_pk,PKT_public_key *sub_pk,
489               PKT_signature *backsig)
490 {
491   gcry_md_hd_t md;
492   int rc;
493
494   /* Always check whether the algorithm is available.  Although
495      gcry_md_open woyuld throw an error, some libgcrypt versions will
496      print a debug message in that case too. */
497   if ((rc=openpgp_md_test_algo (backsig->digest_algo)))
498     return rc;
499
500   if(!opt.no_sig_cache && backsig->flags.checked)
501     return backsig->flags.valid? 0 : gpg_error (GPG_ERR_BAD_SIGNATURE);
502
503   rc = gcry_md_open (&md, backsig->digest_algo,0);
504   if (!rc)
505     {
506       hash_public_key(md,main_pk);
507       hash_public_key(md,sub_pk);
508       rc=do_check(sub_pk,backsig,md,NULL,NULL,NULL);
509       cache_sig_result(backsig,rc);
510       gcry_md_close(md);
511     }
512
513   return rc;
514 }
515
516
517 /****************
518  * check the signature pointed to by NODE. This is a key signature.
519  * If the function detects a self-signature, it uses the PK from
520  * ROOT and does not read any public key.
521  */
522 int
523 check_key_signature( KBNODE root, KBNODE node, int *is_selfsig )
524 {
525   return check_key_signature2(root, node, NULL, NULL, is_selfsig, NULL, NULL );
526 }
527
528 /* If check_pk is set, then use it to check the signature in node
529    rather than getting it from root or the keydb.  If ret_pk is set,
530    fill in the public key that was used to verify the signature.
531    ret_pk is only meaningful when the verification was successful. */
532 /* TODO: add r_revoked here as well.  It has the same problems as
533    r_expiredate and r_expired and the cache. */
534 int
535 check_key_signature2( KBNODE root, KBNODE node, PKT_public_key *check_pk,
536                       PKT_public_key *ret_pk, int *is_selfsig,
537                       u32 *r_expiredate, int *r_expired )
538 {
539     gcry_md_hd_t md;
540     PKT_public_key *pk;
541     PKT_signature *sig;
542     int algo;
543     int rc;
544
545     if( is_selfsig )
546         *is_selfsig = 0;
547     if( r_expiredate )
548         *r_expiredate = 0;
549     if( r_expired )
550         *r_expired = 0;
551     assert( node->pkt->pkttype == PKT_SIGNATURE );
552     assert( root->pkt->pkttype == PKT_PUBLIC_KEY );
553
554     pk = root->pkt->pkt.public_key;
555     sig = node->pkt->pkt.signature;
556     algo = sig->digest_algo;
557
558     /* Check whether we have cached the result of a previous signature
559        check.  Note that we may no longer have the pubkey or hash
560        needed to verify a sig, but can still use the cached value.  A
561        cache refresh detects and clears these cases. */
562     if ( !opt.no_sig_cache ) {
563         if (sig->flags.checked) { /*cached status available*/
564             if( is_selfsig ) {
565                 u32 keyid[2];
566
567                 keyid_from_pk( pk, keyid );
568                 if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
569                     *is_selfsig = 1;
570             }
571             /* BUG: This is wrong for non-self-sigs.. needs to be the
572                actual pk */
573             if((rc=do_check_messages(pk,sig,r_expired,NULL)))
574               return rc;
575             return sig->flags.valid? 0 : gpg_error (GPG_ERR_BAD_SIGNATURE);
576         }
577     }
578
579     if( (rc=openpgp_pk_test_algo(sig->pubkey_algo)) )
580         return rc;
581     if( (rc=openpgp_md_test_algo(algo)) )
582         return rc;
583
584     if( sig->sig_class == 0x20 ) { /* key revocation */
585         u32 keyid[2];
586         keyid_from_pk( pk, keyid );
587
588         /* is it a designated revoker? */
589         if(keyid[0]!=sig->keyid[0] || keyid[1]!=sig->keyid[1])
590           rc=check_revocation_keys(pk,sig);
591         else
592           {
593             if (gcry_md_open (&md, algo, 0 ))
594               BUG ();
595             hash_public_key( md, pk );
596             rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
597             cache_sig_result ( sig, rc );
598             gcry_md_close(md);
599           }
600     }
601     else if( sig->sig_class == 0x28 ) { /* subkey revocation */
602         KBNODE snode = find_prev_kbnode( root, node, PKT_PUBLIC_SUBKEY );
603
604         if( snode ) {
605             if (gcry_md_open (&md, algo, 0))
606               BUG ();
607             hash_public_key( md, pk );
608             hash_public_key( md, snode->pkt->pkt.public_key );
609             rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
610             cache_sig_result ( sig, rc );
611             gcry_md_close(md);
612         }
613         else
614           {
615             if (opt.verbose)
616               log_info (_("key %s: no subkey for subkey"
617                           " revocation signature\n"),keystr_from_pk(pk));
618             rc = GPG_ERR_SIG_CLASS;
619           }
620     }
621     else if( sig->sig_class == 0x18 ) { /* key binding */
622         KBNODE snode = find_prev_kbnode( root, node, PKT_PUBLIC_SUBKEY );
623
624         if( snode ) {
625             if( is_selfsig ) {  /* does this make sense????? */
626                 u32 keyid[2];   /* it should always be a selfsig */
627
628                 keyid_from_pk( pk, keyid );
629                 if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
630                     *is_selfsig = 1;
631             }
632             if (gcry_md_open (&md, algo, 0))
633               BUG ();
634             hash_public_key( md, pk );
635             hash_public_key( md, snode->pkt->pkt.public_key );
636             rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
637             cache_sig_result ( sig, rc );
638             gcry_md_close(md);
639         }
640         else
641           {
642             if (opt.verbose)
643               log_info(_("key %s: no subkey for subkey"
644                          " binding signature\n"),keystr_from_pk(pk));
645             rc = GPG_ERR_SIG_CLASS;
646           }
647     }
648     else if( sig->sig_class == 0x1f ) { /* direct key signature */
649         if (gcry_md_open (&md, algo, 0 ))
650           BUG ();
651         hash_public_key( md, pk );
652         rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
653         cache_sig_result ( sig, rc );
654         gcry_md_close(md);
655     }
656     else { /* all other classes */
657         KBNODE unode = find_prev_kbnode( root, node, PKT_USER_ID );
658
659         if( unode ) {
660             u32 keyid[2];
661
662             keyid_from_pk( pk, keyid );
663             if (gcry_md_open (&md, algo, 0 ))
664               BUG ();
665             hash_public_key( md, pk );
666             hash_uid_node( unode, md, sig );
667             if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
668               {
669                 if( is_selfsig )
670                   *is_selfsig = 1;
671                 rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
672               }
673             else if (check_pk)
674               rc=do_check(check_pk,sig,md,r_expired,NULL,ret_pk);
675             else
676               rc=signature_check2(sig,md,r_expiredate,r_expired,NULL,ret_pk);
677
678             cache_sig_result ( sig, rc );
679             gcry_md_close(md);
680         }
681         else
682           {
683             if (!opt.quiet)
684               log_info ("key %s: no user ID for key signature packet"
685                         " of class %02x\n",keystr_from_pk(pk),sig->sig_class);
686             rc = GPG_ERR_SIG_CLASS;
687           }
688     }
689
690     return rc;
691 }