1 /* sig-check.c - Check a signature
2 * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003,
3 * 2004, 2006 Free Software Foundation, Inc.
5 * This file is part of GnuPG.
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.
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.
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/>.
38 /* Context used by the compare function. */
39 struct cmp_help_context_s
47 static int do_check( PKT_public_key *pk, PKT_signature *sig,
49 int *r_expired, int *r_revoked, PKT_public_key *ret_pk);
52 * Check the signature which is contained in SIG.
53 * The MD_HANDLE should be currently open, so that this function
54 * is able to append some data, before finalizing the digest.
57 signature_check (PKT_signature *sig, gcry_md_hd_t digest)
59 return signature_check2( sig, digest, NULL, NULL, NULL, NULL );
63 signature_check2 (PKT_signature *sig, gcry_md_hd_t digest, u32 *r_expiredate,
64 int *r_expired, int *r_revoked, PKT_public_key *ret_pk )
66 PKT_public_key *pk = xmalloc_clear( sizeof *pk );
69 if ( (rc=openpgp_md_test_algo(sig->digest_algo)) )
70 ; /* We don't have this digest. */
71 else if ((rc=openpgp_pk_test_algo(sig->pubkey_algo)))
72 ; /* We don't have this pubkey algo. */
73 else if (!gcry_md_is_enabled (digest,sig->digest_algo))
75 /* Sanity check that the md has a context for the hash that the
76 sig is expecting. This can happen if a onepass sig header does
77 not match the actual sig, and also if the clearsign "Hash:"
78 header is missing or does not match the actual sig. */
80 log_info(_("WARNING: signature digest conflict in message\n"));
83 else if( get_pubkey( pk, sig->keyid ) )
84 rc = G10ERR_NO_PUBKEY;
85 else if(!pk->is_valid && !pk->is_primary)
86 rc=G10ERR_BAD_PUBKEY; /* you cannot have a good sig from an
91 *r_expiredate = pk->expiredate;
93 rc = do_check( pk, sig, digest, r_expired, r_revoked, ret_pk );
95 /* Check the backsig. This is a 0x19 signature from the
96 subkey on the primary key. The idea here is that it should
97 not be possible for someone to "steal" subkeys and claim
98 them as their own. The attacker couldn't actually use the
99 subkey, but they could try and claim ownership of any
100 signaures issued by it. */
101 if(rc==0 && !pk->is_primary && pk->backsig<2)
105 log_info(_("WARNING: signing subkey %s is not"
106 " cross-certified\n"),keystr_from_pk(pk));
107 log_info(_("please see %s for more information\n"),
108 "https://gnupg.org/faq/subkey-cross-certify.html");
109 /* --require-cross-certification makes this warning an
110 error. TODO: change the default to require this
111 after more keys have backsigs. */
112 if(opt.flags.require_cross_cert)
115 else if(pk->backsig==1)
117 log_info(_("WARNING: signing subkey %s has an invalid"
118 " cross-certification\n"),keystr_from_pk(pk));
124 free_public_key( pk );
126 if( !rc && sig->sig_class < 2 && is_status_enabled() ) {
127 /* This signature id works best with DLP algorithms because
128 * they use a random parameter for every signature. Instead of
129 * this sig-id we could have also used the hash of the document
130 * and the timestamp, but the drawback of this is, that it is
131 * not possible to sign more than one identical document within
132 * one second. Some remote batch processing applications might
133 * like this feature here.
135 * Note that before 2.0.10, we used RIPE-MD160 for the hash
136 * and accidently didn't include the timestamp and algorithm
137 * information in the hash. Given that this feature is not
138 * commonly used and that a replay attacks detection should
139 * not solely be based on this feature (because it does not
140 * work with RSA), we take the freedom and switch to SHA-1
141 * with 2.0.10 to take advantage of hardware supported SHA-1
142 * implementations. We also include the missing information
143 * in the hash. Note also the SIG_ID as computed by gpg 1.x
144 * and gpg 2.x didn't matched either because 2.x used to print
145 * MPIs not in PGP format. */
146 u32 a = sig->timestamp;
147 int nsig = pubkey_get_nsig( sig->pubkey_algo );
148 unsigned char *p, *buffer;
154 for (i=0; i < nsig; i++ )
156 if (gcry_mpi_print (GCRYMPI_FMT_USG, NULL, 0, &n, sig->data[i]))
161 /* Make buffer large enough to be later used as output buffer. */
164 nbytes += 10; /* Safety margin. */
166 /* Fill and hash buffer. */
167 buffer = p = xmalloc (nbytes);
168 *p++ = sig->pubkey_algo;
169 *p++ = sig->digest_algo;
170 *p++ = (a >> 24) & 0xff;
171 *p++ = (a >> 16) & 0xff;
172 *p++ = (a >> 8) & 0xff;
175 for (i=0; i < nsig; i++ )
177 if (gcry_mpi_print (GCRYMPI_FMT_PGP, p, nbytes, &n, sig->data[i]))
182 gcry_md_hash_buffer (GCRY_MD_SHA1, hashbuf, buffer, p-buffer);
184 p = make_radix64_string (hashbuf, 20);
185 sprintf (buffer, "%s %s %lu",
186 p, strtimestamp (sig->timestamp), (ulong)sig->timestamp);
188 write_status_text (STATUS_SIG_ID, buffer);
197 do_check_messages( PKT_public_key *pk, PKT_signature *sig,
198 int *r_expired, int *r_revoked )
207 if( pk->timestamp > sig->timestamp )
209 ulong d = pk->timestamp - sig->timestamp;
211 ?_("public key %s is %lu second newer than the signature\n")
212 :_("public key %s is %lu seconds newer than the signature\n"),
213 keystr_from_pk(pk),d );
214 if( !opt.ignore_time_conflict )
215 return G10ERR_TIME_CONFLICT; /* pubkey newer than signature */
218 cur_time = make_timestamp();
219 if( pk->timestamp > cur_time )
221 ulong d = pk->timestamp - cur_time;
223 ? _("key %s was created %lu second"
224 " in the future (time warp or clock problem)\n")
225 : _("key %s was created %lu seconds"
226 " in the future (time warp or clock problem)\n"),
227 keystr_from_pk(pk),d );
228 if( !opt.ignore_time_conflict )
229 return G10ERR_TIME_CONFLICT;
232 /* Check whether the key has expired. We check the has_expired
233 flag which is set after a full evaluation of the key (getkey.c)
234 as well as a simple compare to the current time in case the
235 merge has for whatever reasons not been done. */
236 if( pk->has_expired || (pk->expiredate && pk->expiredate < cur_time)) {
239 log_info(_("NOTE: signature key %s expired %s\n"),
240 keystr_from_pk(pk), asctimestamp( pk->expiredate ) );
241 /* SIGEXPIRED is deprecated. Use KEYEXPIRED. */
242 snprintf (buf, sizeof buf,"%lu",(ulong)pk->expiredate);
243 write_status_text(STATUS_KEYEXPIRED,buf);
244 write_status(STATUS_SIGEXPIRED);
252 log_info (_("NOTE: signature key %s has been revoked\n"),
263 do_check( PKT_public_key *pk, PKT_signature *sig, gcry_md_hd_t digest,
264 int *r_expired, int *r_revoked, PKT_public_key *ret_pk )
266 gcry_mpi_t result = NULL;
269 if( (rc=do_check_messages(pk,sig,r_expired,r_revoked)) )
272 if (sig->digest_algo == GCRY_MD_MD5
273 && !opt.flags.allow_weak_digest_algos)
275 print_md5_rejected_note ();
276 return GPG_ERR_DIGEST_ALGO;
279 /* Make sure the digest algo is enabled (in case of a detached
281 gcry_md_enable (digest, sig->digest_algo);
283 /* Complete the digest. */
284 if( sig->version >= 4 )
285 gcry_md_putc( digest, sig->version );
286 gcry_md_putc( digest, sig->sig_class );
287 if( sig->version < 4 ) {
288 u32 a = sig->timestamp;
289 gcry_md_putc( digest, (a >> 24) & 0xff );
290 gcry_md_putc( digest, (a >> 16) & 0xff );
291 gcry_md_putc( digest, (a >> 8) & 0xff );
292 gcry_md_putc( digest, a & 0xff );
297 gcry_md_putc( digest, sig->pubkey_algo );
298 gcry_md_putc( digest, sig->digest_algo );
300 n = sig->hashed->len;
301 gcry_md_putc (digest, (n >> 8) );
302 gcry_md_putc (digest, n );
303 gcry_md_write (digest, sig->hashed->data, n);
307 /* Two octets for the (empty) length of the hashed
309 gcry_md_putc (digest, 0);
310 gcry_md_putc (digest, 0);
314 buf[0] = sig->version;
320 gcry_md_write( digest, buf, 6 );
322 gcry_md_final( digest );
324 result = encode_md_value( pk, NULL, digest, sig->digest_algo );
326 return G10ERR_GENERAL;
327 rc = pk_verify( pk->pubkey_algo, result, sig->data, pk->pkey );
328 gcry_mpi_release (result);
330 if( !rc && sig->flags.unknown_critical )
332 log_info(_("assuming bad signature from key %s"
333 " due to an unknown critical bit\n"),keystr_from_pk(pk));
334 rc = G10ERR_BAD_SIGN;
338 copy_public_key(ret_pk,pk);
346 hash_uid_node( KBNODE unode, gcry_md_hd_t md, PKT_signature *sig )
348 PKT_user_id *uid = unode->pkt->pkt.user_id;
350 assert( unode->pkt->pkttype == PKT_USER_ID );
351 if( uid->attrib_data ) {
352 if( sig->version >=4 ) {
354 buf[0] = 0xd1; /* packet of type 17 */
355 buf[1] = uid->attrib_len >> 24; /* always use 4 length bytes */
356 buf[2] = uid->attrib_len >> 16;
357 buf[3] = uid->attrib_len >> 8;
358 buf[4] = uid->attrib_len;
359 gcry_md_write( md, buf, 5 );
361 gcry_md_write( md, uid->attrib_data, uid->attrib_len );
364 if( sig->version >=4 ) {
366 buf[0] = 0xb4; /* indicates a userid packet */
367 buf[1] = uid->len >> 24; /* always use 4 length bytes */
368 buf[2] = uid->len >> 16;
369 buf[3] = uid->len >> 8;
371 gcry_md_write( md, buf, 5 );
373 gcry_md_write( md, uid->name, uid->len );
378 cache_sig_result ( PKT_signature *sig, int result )
381 sig->flags.checked = 1;
382 sig->flags.valid = 1;
384 else if ( gpg_err_code (result) == GPG_ERR_BAD_SIGNATURE ) {
385 sig->flags.checked = 1;
386 sig->flags.valid = 0;
389 sig->flags.checked = 0;
390 sig->flags.valid = 0;
394 /* Check the revocation keys to see if any of them have revoked our
395 pk. sig is the revocation sig. pk is the key it is on. This code
396 will need to be modified if gpg ever becomes multi-threaded. Note
397 that this guarantees that a designated revocation sig will never be
398 considered valid unless it is actually valid, as well as being
399 issued by a revocation key in a valid direct signature. Note also
400 that this is written so that a revoked revoker can still issue
401 revocations: i.e. If A revokes B, but A is revoked, B is still
402 revoked. I'm not completely convinced this is the proper behavior,
403 but it matches how PGP does it. -dms */
405 /* Returns 0 if sig is valid (i.e. pk is revoked), non-0 if not
406 revoked. It is important that G10ERR_NO_PUBKEY is only returned
407 when a revocation signature is from a valid revocation key
408 designated in a revkey subpacket, but the revocation key itself
411 check_revocation_keys(PKT_public_key *pk,PKT_signature *sig)
414 int i,rc=G10ERR_GENERAL;
416 assert(IS_KEY_REV(sig));
417 assert((sig->keyid[0]!=pk->keyid[0]) || (sig->keyid[0]!=pk->keyid[1]));
421 /* return an error (i.e. not revoked), but mark the pk as
422 uncacheable as we don't really know its revocation status
423 until it is checked directly. */
431 /* printf("looking at %08lX with a sig from %08lX\n",(ulong)pk->keyid[1],
432 (ulong)sig->keyid[1]); */
434 /* is the issuer of the sig one of our revokers? */
435 if( !pk->revkey && pk->numrevkeys )
438 for(i=0;i<pk->numrevkeys;i++)
442 keyid_from_fingerprint(pk->revkey[i].fpr,MAX_FINGERPRINT_LEN,keyid);
444 if(keyid[0]==sig->keyid[0] && keyid[1]==sig->keyid[1])
448 if (gcry_md_open (&md, sig->digest_algo, 0))
450 hash_public_key(md,pk);
451 rc=signature_check(sig,md);
452 cache_sig_result(sig,rc);
463 /* Backsigs (0x19) have the same format as binding sigs (0x18), but
464 this function is simpler than check_key_signature in a few ways.
465 For example, there is no support for expiring backsigs since it is
466 questionable what such a thing actually means. Note also that the
467 sig cache check here, unlike other sig caches in GnuPG, is not
470 check_backsig(PKT_public_key *main_pk,PKT_public_key *sub_pk,
471 PKT_signature *backsig)
476 /* Always check whether the algorithm is available. Although
477 gcry_md_open woyuld throw an error, some libgcrypt versions will
478 print a debug message in that case too. */
479 if ((rc=openpgp_md_test_algo (backsig->digest_algo)))
482 if(!opt.no_sig_cache && backsig->flags.checked)
483 return backsig->flags.valid? 0 : gpg_error (GPG_ERR_BAD_SIGNATURE);
485 rc = gcry_md_open (&md, backsig->digest_algo,0);
488 hash_public_key(md,main_pk);
489 hash_public_key(md,sub_pk);
490 rc=do_check(sub_pk,backsig,md,NULL,NULL,NULL);
491 cache_sig_result(backsig,rc);
500 * check the signature pointed to by NODE. This is a key signature.
501 * If the function detects a self-signature, it uses the PK from
502 * ROOT and does not read any public key.
505 check_key_signature( KBNODE root, KBNODE node, int *is_selfsig )
507 return check_key_signature2(root, node, NULL, NULL, is_selfsig, NULL, NULL );
510 /* If check_pk is set, then use it to check the signature in node
511 rather than getting it from root or the keydb. If ret_pk is set,
512 fill in the public key that was used to verify the signature.
513 ret_pk is only meaningful when the verification was successful. */
514 /* TODO: add r_revoked here as well. It has the same problems as
515 r_expiredate and r_expired and the cache. */
517 check_key_signature2( KBNODE root, KBNODE node, PKT_public_key *check_pk,
518 PKT_public_key *ret_pk, int *is_selfsig,
519 u32 *r_expiredate, int *r_expired )
533 assert( node->pkt->pkttype == PKT_SIGNATURE );
534 assert( root->pkt->pkttype == PKT_PUBLIC_KEY );
536 pk = root->pkt->pkt.public_key;
537 sig = node->pkt->pkt.signature;
538 algo = sig->digest_algo;
540 /* Check whether we have cached the result of a previous signature
541 check. Note that we may no longer have the pubkey or hash
542 needed to verify a sig, but can still use the cached value. A
543 cache refresh detects and clears these cases.
544 For safety reasons we ignore cache entries from MD5 signatures. */
545 if ( !opt.no_sig_cache ) {
546 if (sig->flags.checked && sig->digest_algo != DIGEST_ALGO_MD5) {
547 /*cached status available*/
551 keyid_from_pk( pk, keyid );
552 if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
555 /* BUG: This is wrong for non-self-sigs.. needs to be the
557 if((rc=do_check_messages(pk,sig,r_expired,NULL)))
559 return sig->flags.valid? 0 : gpg_error (GPG_ERR_BAD_SIGNATURE);
563 if( (rc=openpgp_pk_test_algo(sig->pubkey_algo)) )
565 if( (rc=openpgp_md_test_algo(algo)) )
568 if( sig->sig_class == 0x20 ) { /* key revocation */
570 keyid_from_pk( pk, keyid );
572 /* is it a designated revoker? */
573 if(keyid[0]!=sig->keyid[0] || keyid[1]!=sig->keyid[1])
574 rc=check_revocation_keys(pk,sig);
577 if (gcry_md_open (&md, algo, 0 ))
579 hash_public_key( md, pk );
580 rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
581 cache_sig_result ( sig, rc );
585 else if( sig->sig_class == 0x28 ) { /* subkey revocation */
586 KBNODE snode = find_prev_kbnode( root, node, PKT_PUBLIC_SUBKEY );
589 if (gcry_md_open (&md, algo, 0))
591 hash_public_key( md, pk );
592 hash_public_key( md, snode->pkt->pkt.public_key );
593 rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
594 cache_sig_result ( sig, rc );
600 log_info (_("key %s: no subkey for subkey"
601 " revocation signature\n"),keystr_from_pk(pk));
602 rc = G10ERR_SIG_CLASS;
605 else if( sig->sig_class == 0x18 ) { /* key binding */
606 KBNODE snode = find_prev_kbnode( root, node, PKT_PUBLIC_SUBKEY );
609 if( is_selfsig ) { /* does this make sense????? */
610 u32 keyid[2]; /* it should always be a selfsig */
612 keyid_from_pk( pk, keyid );
613 if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
616 if (gcry_md_open (&md, algo, 0))
618 hash_public_key( md, pk );
619 hash_public_key( md, snode->pkt->pkt.public_key );
620 rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
621 cache_sig_result ( sig, rc );
627 log_info(_("key %s: no subkey for subkey"
628 " binding signature\n"),keystr_from_pk(pk));
629 rc = G10ERR_SIG_CLASS;
632 else if( sig->sig_class == 0x1f ) { /* direct key signature */
633 if (gcry_md_open (&md, algo, 0 ))
635 hash_public_key( md, pk );
636 rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
637 cache_sig_result ( sig, rc );
640 else { /* all other classes */
641 KBNODE unode = find_prev_kbnode( root, node, PKT_USER_ID );
646 keyid_from_pk( pk, keyid );
647 if (gcry_md_open (&md, algo, 0 ))
649 hash_public_key( md, pk );
650 hash_uid_node( unode, md, sig );
651 if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
655 rc = do_check( pk, sig, md, r_expired, NULL, ret_pk );
658 rc=do_check(check_pk,sig,md,r_expired,NULL,ret_pk);
660 rc=signature_check2(sig,md,r_expiredate,r_expired,NULL,ret_pk);
662 cache_sig_result ( sig, rc );
668 log_info ("key %s: no user ID for key signature packet"
669 " of class %02x\n",keystr_from_pk(pk),sig->sig_class);
670 rc = G10ERR_SIG_CLASS;