forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
188 lines
4.6 KiB
188 lines
4.6 KiB
// SPDX-License-Identifier: GPL-2.0-or-later |
|
/* Validate the trust chain of a PKCS#7 message. |
|
* |
|
* Copyright (C) 2012 Red Hat, Inc. All Rights Reserved. |
|
* Written by David Howells ([email protected]) |
|
*/ |
|
|
|
#define pr_fmt(fmt) "PKCS7: "fmt |
|
#include <linux/kernel.h> |
|
#include <linux/export.h> |
|
#include <linux/slab.h> |
|
#include <linux/err.h> |
|
#include <linux/asn1.h> |
|
#include <linux/key.h> |
|
#include <keys/asymmetric-type.h> |
|
#include <crypto/public_key.h> |
|
#include "pkcs7_parser.h" |
|
|
|
/* |
|
* Check the trust on one PKCS#7 SignedInfo block. |
|
*/ |
|
static int pkcs7_validate_trust_one(struct pkcs7_message *pkcs7, |
|
struct pkcs7_signed_info *sinfo, |
|
struct key *trust_keyring) |
|
{ |
|
struct public_key_signature *sig = sinfo->sig; |
|
struct x509_certificate *x509, *last = NULL, *p; |
|
struct key *key; |
|
int ret; |
|
|
|
kenter(",%u,", sinfo->index); |
|
|
|
if (sinfo->unsupported_crypto) { |
|
kleave(" = -ENOPKG [cached]"); |
|
return -ENOPKG; |
|
} |
|
|
|
for (x509 = sinfo->signer; x509; x509 = x509->signer) { |
|
if (x509->seen) { |
|
if (x509->verified) |
|
goto verified; |
|
kleave(" = -ENOKEY [cached]"); |
|
return -ENOKEY; |
|
} |
|
x509->seen = true; |
|
|
|
/* Look to see if this certificate is present in the trusted |
|
* keys. |
|
*/ |
|
key = find_asymmetric_key(trust_keyring, |
|
x509->id, x509->skid, NULL, false); |
|
if (!IS_ERR(key)) { |
|
/* One of the X.509 certificates in the PKCS#7 message |
|
* is apparently the same as one we already trust. |
|
* Verify that the trusted variant can also validate |
|
* the signature on the descendant. |
|
*/ |
|
pr_devel("sinfo %u: Cert %u as key %x\n", |
|
sinfo->index, x509->index, key_serial(key)); |
|
goto matched; |
|
} |
|
if (key == ERR_PTR(-ENOMEM)) |
|
return -ENOMEM; |
|
|
|
/* Self-signed certificates form roots of their own, and if we |
|
* don't know them, then we can't accept them. |
|
*/ |
|
if (x509->signer == x509) { |
|
kleave(" = -ENOKEY [unknown self-signed]"); |
|
return -ENOKEY; |
|
} |
|
|
|
might_sleep(); |
|
last = x509; |
|
sig = last->sig; |
|
} |
|
|
|
/* No match - see if the root certificate has a signer amongst the |
|
* trusted keys. |
|
*/ |
|
if (last && (last->sig->auth_ids[0] || last->sig->auth_ids[1])) { |
|
key = find_asymmetric_key(trust_keyring, |
|
last->sig->auth_ids[0], |
|
last->sig->auth_ids[1], |
|
NULL, false); |
|
if (!IS_ERR(key)) { |
|
x509 = last; |
|
pr_devel("sinfo %u: Root cert %u signer is key %x\n", |
|
sinfo->index, x509->index, key_serial(key)); |
|
goto matched; |
|
} |
|
if (PTR_ERR(key) != -ENOKEY) |
|
return PTR_ERR(key); |
|
} |
|
|
|
/* As a last resort, see if we have a trusted public key that matches |
|
* the signed info directly. |
|
*/ |
|
key = find_asymmetric_key(trust_keyring, |
|
sinfo->sig->auth_ids[0], NULL, NULL, false); |
|
if (!IS_ERR(key)) { |
|
pr_devel("sinfo %u: Direct signer is key %x\n", |
|
sinfo->index, key_serial(key)); |
|
x509 = NULL; |
|
sig = sinfo->sig; |
|
goto matched; |
|
} |
|
if (PTR_ERR(key) != -ENOKEY) |
|
return PTR_ERR(key); |
|
|
|
kleave(" = -ENOKEY [no backref]"); |
|
return -ENOKEY; |
|
|
|
matched: |
|
ret = verify_signature(key, sig); |
|
key_put(key); |
|
if (ret < 0) { |
|
if (ret == -ENOMEM) |
|
return ret; |
|
kleave(" = -EKEYREJECTED [verify %d]", ret); |
|
return -EKEYREJECTED; |
|
} |
|
|
|
verified: |
|
if (x509) { |
|
x509->verified = true; |
|
for (p = sinfo->signer; p != x509; p = p->signer) |
|
p->verified = true; |
|
} |
|
kleave(" = 0"); |
|
return 0; |
|
} |
|
|
|
/** |
|
* pkcs7_validate_trust - Validate PKCS#7 trust chain |
|
* @pkcs7: The PKCS#7 certificate to validate |
|
* @trust_keyring: Signing certificates to use as starting points |
|
* |
|
* Validate that the certificate chain inside the PKCS#7 message intersects |
|
* keys we already know and trust. |
|
* |
|
* Returns, in order of descending priority: |
|
* |
|
* (*) -EKEYREJECTED if a signature failed to match for which we have a valid |
|
* key, or: |
|
* |
|
* (*) 0 if at least one signature chain intersects with the keys in the trust |
|
* keyring, or: |
|
* |
|
* (*) -ENOPKG if a suitable crypto module couldn't be found for a check on a |
|
* chain. |
|
* |
|
* (*) -ENOKEY if we couldn't find a match for any of the signature chains in |
|
* the message. |
|
* |
|
* May also return -ENOMEM. |
|
*/ |
|
int pkcs7_validate_trust(struct pkcs7_message *pkcs7, |
|
struct key *trust_keyring) |
|
{ |
|
struct pkcs7_signed_info *sinfo; |
|
struct x509_certificate *p; |
|
int cached_ret = -ENOKEY; |
|
int ret; |
|
|
|
for (p = pkcs7->certs; p; p = p->next) |
|
p->seen = false; |
|
|
|
for (sinfo = pkcs7->signed_infos; sinfo; sinfo = sinfo->next) { |
|
ret = pkcs7_validate_trust_one(pkcs7, sinfo, trust_keyring); |
|
switch (ret) { |
|
case -ENOKEY: |
|
continue; |
|
case -ENOPKG: |
|
if (cached_ret == -ENOKEY) |
|
cached_ret = -ENOPKG; |
|
continue; |
|
case 0: |
|
cached_ret = 0; |
|
continue; |
|
default: |
|
return ret; |
|
} |
|
} |
|
|
|
return cached_ret; |
|
} |
|
EXPORT_SYMBOL_GPL(pkcs7_validate_trust);
|
|
|