Enable root to update the blacklist keyring
Subsystems (9)
v8 cover Enable root to update the blacklist keyring
Hi,
This new patch series is a rebase on v5.14-rc1 . David or Jarkko, if it's still OK with you, could you please push this to linux-next?
I successfully tested this patch series with the 211 entries from
https://uefi.org/sites/default/files/resources/dbxupdate_x64.bin
The goal of these patches is to add a new configuration option to enable the root user to load signed keys in the blacklist keyring. This keyring is useful to "untrust" certificates or files. Enabling to safely update this keyring without recompiling the kernel makes it more usable.
Previous patch series:
https://lore.kernel.org/lkml/[email protected]/
Regards,
Mickaël Salaün (5):
tools/certs: Add print-cert-tbs-hash.sh
certs: Check that builtin blacklist hashes are valid
certs: Make blacklist_vet_description() more strict
certs: Factor out the blacklist hash creation
certs: Allow root user to append signed hashes to the blacklist
keyring
MAINTAINERS | 2 + certs/.gitignore | 1 + certs/Kconfig | 17 +- certs/Makefile | 17 +- certs/blacklist.c | 218 ++++++++++++++---- crypto/asymmetric_keys/x509_public_key.c | 3 +- include/keys/system_keyring.h | 14 +- scripts/check-blacklist-hashes.awk | 37 +++ .../platform_certs/keyring_handler.c | 26 +-- tools/certs/print-cert-tbs-hash.sh | 91 ++++++++ 10 files changed, 346 insertions(+), 80 deletions(-) create mode 100755 scripts/check-blacklist-hashes.awk create mode 100755 tools/certs/print-cert-tbs-hash.sh
base-commit: e73f0f0ee7541171d89f2e2491130c7771ba58d3
Signature · 1 line
2.32.0
PATCH v8 1/5 tools/certs: Add print-cert-tbs-hash.sh
From: Mickaël Salaün <[email protected]>
Add a new helper print-cert-tbs-hash.sh to generate a TBSCertificate hash from a given certificate. This is useful to generate a blacklist key description used to forbid loading a specific certificate in a keyring, or to invalidate a certificate provided by a PKCS#7 file.
This kind of hash formatting is required to populate the file pointed out by CONFIG_SYSTEM_BLACKLIST_HASH_LIST, but only the kernel code was available to understand how to effectively create such hash.
---
Changes since v5:
* Add Reviewed-by Jarkko.
Changes since v3:
* Explain in the commit message that this kind of formating is not new but it wasn't documented.
Changes since v1:
* Fix typo.
* Use "if" block instead of "||" .
--- MAINTAINERS | 1 + tools/certs/print-cert-tbs-hash.sh | 91 ++++++++++++++++++++++++++++++ 2 files changed, 92 insertions(+) create mode 100755 tools/certs/print-cert-tbs-hash.sh
MAINTAINERS +1 -0
@@ -4301,6 +4301,7 @@ F: Documentation/admin-guide/module-signing.rst F: certs/ F: scripts/extract-cert.c F: scripts/sign-file.c +F: tools/certs/ CFAG12864B LCD DRIVER M: Miguel Ojeda <[email protected]>
tools/certs/print-cert-tbs-hash.sh new file +91 -0
91 lines not on this page · raw message
Signature · 1 line
2.32.0
PATCH v8 2/5 certs: Check that builtin blacklist hashes are valid
In reply to Mickaël SalaünFrom: Mickaël Salaün <[email protected]>
Add and use a check-blacklist-hashes.awk script to make sure that the builtin blacklist hashes set with CONFIG_SYSTEM_BLACKLIST_HASH_LIST will effectively be taken into account as blacklisted hashes. This is useful to debug invalid hash formats, and it make sure that previous hashes which could have been loaded in the kernel, but silently ignored, are now noticed and deal with by the user at kernel build time.
This also prevent stricter blacklist key description checking (provided by following commits) to failed for builtin hashes.
Update CONFIG_SYSTEM_BLACKLIST_HASH_LIST help to explain the content of a hash string and how to generate certificate ones.
---
Changes since v7:
* Rebase and fix trivial .gitignore conflict.
Changes since v5:
* Rebase on keys-next and fix conflict as previously done by David Howells.
* Enable to use a file path relative to the kernel source directory. This align with the handling of CONFIG_SYSTEM_TRUSTED_KEYS, CONFIG_MODULE_SIG_KEY and CONFIG_SYSTEM_REVOCATION_KEYS.
Changes since v3:
* Improve commit description.
* Update CONFIG_SYSTEM_BLACKLIST_HASH_LIST help.
* Remove Acked-by Jarkko Sakkinen because of the above changes.
Changes since v2:
* Add Jarkko's Acked-by.
Changes since v1:
* Prefix script path with $(scrtree)/ (suggested by David Howells).
* Fix hexadecimal number check.
--- MAINTAINERS | 1 + certs/.gitignore | 1 + certs/Kconfig | 7 ++++-- certs/Makefile | 17 +++++++++++++- scripts/check-blacklist-hashes.awk | 37 ++++++++++++++++++++++++++++++ 5 files changed, 60 insertions(+), 3 deletions(-) create mode 100755 scripts/check-blacklist-hashes.awk
MAINTAINERS +1 -0
@@ -4299,6 +4299,7 @@ L: [email protected] S: Maintained F: Documentation/admin-guide/module-signing.rst F: certs/ +F: scripts/check-blacklist-hashes.awk F: scripts/extract-cert.c F: scripts/sign-file.c F: tools/certs/
certs/.gitignore +1 -0
@@ -1,3 +1,4 @@ # SPDX-License-Identifier: GPL-2.0-only +/blacklist_hashes_checked /x509_certificate_list /x509_revocation_list
certs/Kconfig +5 -2
@@ -80,8 +80,11 @@ config SYSTEM_BLACKLIST_HASH_LIST help If set, this option should be the filename of a list of hashes in the form "<hash>", "<hash>", ... . This will be included into a C - wrapper to incorporate the list into the kernel. Each <hash> should - be a string of hex digits. + wrapper to incorporate the list into the kernel. Each <hash> must be a + string starting with a prefix ("tbs" or "bin"), then a colon (":"), and + finally an even number of hexadecimal lowercase characters (up to 128). + Certificate hashes can be generated with + tools/certs/print-cert-tbs-hash.sh . config SYSTEM_REVOCATION_LIST bool "Provide system-wide ring of revocation certificates"
certs/Makefile +16 -1
@@ -7,7 +7,22 @@ obj-$(CONFIG_SYSTEM_TRUSTED_KEYRING) += system_keyring.o system_certificates.o c obj-$(CONFIG_SYSTEM_BLACKLIST_KEYRING) += blacklist.o common.o obj-$(CONFIG_SYSTEM_REVOCATION_LIST) += revocation_certificates.o ifneq ($(CONFIG_SYSTEM_BLACKLIST_HASH_LIST),"") + +quiet_cmd_check_blacklist_hashes = CHECK $(patsubst "%",%,$(2)) + cmd_check_blacklist_hashes = $(AWK) -f $(srctree)/scripts/check-blacklist-hashes.awk $(2); touch $@ + +$(eval $(call config_filename,SYSTEM_BLACKLIST_HASH_LIST)) + +$(obj)/blacklist_hashes.o: $(obj)/blacklist_hashes_checked + +CFLAGS_blacklist_hashes.o += -I$(srctree) + +targets += blacklist_hashes_checked +$(obj)/blacklist_hashes_checked: $(SYSTEM_BLACKLIST_HASH_LIST_SRCPREFIX)$(SYSTEM_BLACKLIST_HASH_LIST_FILENAME) scripts/check-blacklist-hashes.awk FORCE + $(call if_changed,check_blacklist_hashes,$(SYSTEM_BLACKLIST_HASH_LIST_SRCPREFIX)$(CONFIG_SYSTEM_BLACKLIST_HASH_LIST)) + obj-$(CONFIG_SYSTEM_BLACKLIST_KEYRING) += blacklist_hashes.o + else obj-$(CONFIG_SYSTEM_BLACKLIST_KEYRING) += blacklist_nohashes.o endif
@@ -30,7 +45,7 @@ $(obj)/x509_certificate_list: scripts/extract-cert $(SYSTEM_TRUSTED_KEYS_SRCPREF $(call if_changed,extract_certs,$(SYSTEM_TRUSTED_KEYS_SRCPREFIX)$(CONFIG_SYSTEM_TRUSTED_KEYS)) endif # CONFIG_SYSTEM_TRUSTED_KEYRING -clean-files := x509_certificate_list .x509.list x509_revocation_list +clean-files := x509_certificate_list .x509.list x509_revocation_list blacklist_hashes_checked ifeq ($(CONFIG_MODULE_SIG),y) SIGN_KEY = y
scripts/check-blacklist-hashes.awk new file +37 -0
@@ -0,0 +1,37 @@ +#!/usr/bin/awk -f +# SPDX-License-Identifier: GPL-2.0 +# +# Copyright © 2020, Microsoft Corporation. All rights reserved. +# +# Author: Mickaël Salaün <[email protected]> +# +# Check that a CONFIG_SYSTEM_BLACKLIST_HASH_LIST file contains a valid array of +# hash strings. Such string must start with a prefix ("tbs" or "bin"), then a +# colon (":"), and finally an even number of hexadecimal lowercase characters +# (up to 128). + +BEGIN { + RS = "," +} +{ + if (!match($0, "^[ \t\n\r]*\"([^\"]*)\"[ \t\n\r]*$", part1)) { + print "Not a string (item " NR "):", $0; + exit 1; + } + if (!match(part1[1], "^(tbs|bin):(.*)$", part2)) { + print "Unknown prefix (item " NR "):", part1[1]; + exit 1; + } + if (!match(part2[2], "^([0-9a-f]+)$", part3)) { + print "Not a lowercase hexadecimal string (item " NR "):", part2[2]; + exit 1; + } + if (length(part3[1]) > 128) { + print "Hash string too long (item " NR "):", part3[1]; + exit 1; + } + if (length(part3[1]) % 2 == 1) { + print "Not an even number of hexadecimal characters (item " NR "):", part3[1]; + exit 1; + } +}
Signature · 1 line
2.32.0
PATCH v8 3/5 certs: Make blacklist_vet_description() more strict
In reply to Mickaël SalaünFrom: Mickaël Salaün <[email protected]>
Before exposing this new key type to user space, make sure that only meaningful blacklisted hashes are accepted. This is also checked for builtin blacklisted hashes, but a following commit make sure that the user will notice (at built time) and will fix the configuration if it already included errors.
Check that a blacklist key description starts with a valid prefix and then a valid hexadecimal string.
---
Changes since v5:
* Add Reviewed-by Jarkko.
Changes since v2:
* Fix typo in blacklist_vet_description() comment, spotted by Tyler Hicks.
* Add Jarkko's Acked-by.
Changes since v1:
* Return ENOPKG (instead of EINVAL) when a hash is greater than the maximum currently known hash (suggested by David Howells).
--- certs/blacklist.c | 46 ++++++++++++++++++++++++++++++++++++---------- 1 file changed, 36 insertions(+), 10 deletions(-)
certs/blacklist.c +36 -10
@@ -19,6 +19,16 @@#include "blacklist.h" #include "common.h" +/* +* According to crypto/asymmetric_keys/x509_cert_parser.c:x509_note_pkey_algo(), +* the size of the currently longest supported hash algorithm is 512 bits, +* which translates into 128 hex characters. +*/ +#define MAX_HASH_LEN 128 + +static const char tbs_prefix[] ="tbs" ; +static const char bin_prefix[] ="bin" ; +static struct key *blacklist_keyring;#ifdef CONFIG_SYSTEM_REVOCATION_LIST
@@ -32,24 +42,40 @@ extern __initconst const unsigned long revocation_certificate_list_size;*/ static int blacklist_vet_description (const char *desc) { -int n =0 ; - -if (*desc ==':' ) -return -EINVAL ; -for (; *desc; desc++) -if (*desc ==':' ) - goto found_colon; +int i, prefix_len, tbs_step =0 , bin_step =0 ; + +/* The following algorithm only works if prefix lengths match. */ +BUILD_BUG_ON (sizeof (tbs_prefix) !=sizeof (bin_prefix)); + prefix_len =sizeof (tbs_prefix) -1 ; +for (i =0 ; *desc; desc++, i++) { +if (*desc ==':' ) { +if (tbs_step == prefix_len) + goto found_colon; +if (bin_step == prefix_len) + goto found_colon; +return -EINVAL ; + } +if (i >= prefix_len) +return -EINVAL ; +if (*desc == tbs_prefix[i]) + tbs_step++; +if (*desc == bin_prefix[i]) + bin_step++; + }return -EINVAL ; found_colon: desc++; -for (; *desc; desc++) { +for (i =0 ; *desc && i <MAX_HASH_LEN ; desc++, i++) {if (!isxdigit (*desc) ||isupper (*desc))return -EINVAL ; - n++; } +if (*desc) +/* The hash is greater than MAX_HASH_LEN. */ +return -ENOPKG ; -if (n ==0 || n &1 ) +/* Checks for an even number of hexadecimal characters. */ +if (i ==0 || i &1 )return -EINVAL ;return 0 ; }
Signature · 1 line
2.32.0
PATCH v8 4/5 certs: Factor out the blacklist hash creation
In reply to Mickaël SalaünFrom: Mickaël Salaün <[email protected]>
Factor out the blacklist hash creation with the get_raw_hash() helper. This also centralize the "tbs" and "bin" prefixes and make them private, which help to manage them consistently.
---
Changes since v6:
* Rebase on keys-cve-2020-26541-v3: commit ebd9c2ae369a ("integrity:
Load mokx variables into the blacklist keyring").
Changes since v5:
* Rebase on keys-next and fix conflict as previously done by David Howells.
* Fix missing part to effectively handle UEFI DBX blacklisting.
* Remove Jarkko's Acked-by because of the above changes.
Changes since v2:
* Add Jarkko's Acked-by.
--- certs/blacklist.c | 76 ++++++++++++++----- crypto/asymmetric_keys/x509_public_key.c | 3 +- include/keys/system_keyring.h | 14 +++- .../platform_certs/keyring_handler.c | 26 +------ 4 files changed, 73 insertions(+), 46 deletions(-)
certs/blacklist.c +58 -18
@@ -109,11 +109,43 @@ static struct key_type key_type_blacklist = { .describe = blacklist_describe, }; +static char *get_raw_hash (const u8 *hash,size_t hash_len, +enum blacklist_hash_type hash_type) +{ +size_t type_len; +const char *type_prefix; +char *buffer, *p; + +switch (hash_type) { +case BLACKLIST_HASH_X509_TBS : + type_len =sizeof (tbs_prefix) -1 ; + type_prefix = tbs_prefix; +break ; +case BLACKLIST_HASH_BINARY : + type_len =sizeof (bin_prefix) -1 ; + type_prefix = bin_prefix; +break ; +default : +WARN_ON_ONCE (1 ); +return ERR_PTR (-EINVAL ); + } + buffer =kmalloc (type_len +1 + hash_len *2 +1 ,GFP_KERNEL ); +if (!buffer) +return ERR_PTR (-ENOMEM ); + p =memcpy (buffer, type_prefix, type_len); + p += type_len; + *p++ =':' ; +bin2hex (p, hash, hash_len); + p += hash_len *2 ; + *p ='\0' ; +return buffer; +} +/** -* mark_hash_blacklisted - Add a hash to the system blacklist +* mark_raw_hash_blacklisted - Add a hash to the system blacklist * @hash: The hash as a hex string with a type prefix (eg. "tbs:23aa429783") */ -int mark_hash_blacklisted (const char *hash) +static int mark_raw_hash_blacklisted (const char *hash) {key_ref_t key;
@@ -133,29 +165,36 @@ int mark_hash_blacklisted(const char *hash)return 0 ; } +int mark_hash_blacklisted (const u8 *hash,size_t hash_len, +enum blacklist_hash_type hash_type) +{ +const char *buffer; +int err; + + buffer =get_raw_hash (hash, hash_len, hash_type); +if (IS_ERR (buffer)) +return PTR_ERR (buffer); + err =mark_raw_hash_blacklisted (buffer); +kfree (buffer); +return err; +} +/** * is_hash_blacklisted - Determine if a hash is blacklisted * @hash: The hash to be checked as a binary blob * @hash_len: The length of the binary hash -* @type: Type of hash +* @hash_type: Type of hash */ -int is_hash_blacklisted (const u8 *hash,size_t hash_len,const char *type) +int is_hash_blacklisted (const u8 *hash,size_t hash_len, +enum blacklist_hash_type hash_type) {key_ref_t kref; -size_t type_len =strlen (type); -char *buffer, *p; +const char *buffer;int ret =0 ; - buffer =kmalloc (type_len +1 + hash_len *2 +1 ,GFP_KERNEL ); -if (!buffer) -return -ENOMEM ; - p =memcpy (buffer, type, type_len); - p += type_len; - *p++ =':' ; -bin2hex (p, hash, hash_len); - p += hash_len *2 ; - *p =0 ; - + buffer =get_raw_hash (hash, hash_len, hash_type); +if (IS_ERR (buffer)) +return PTR_ERR (buffer); kref =keyring_search (make_key_ref (blacklist_keyring, true), &key_type_blacklist, buffer, false);if (!IS_ERR (kref)) {
@@ -170,7 +209,8 @@ EXPORT_SYMBOL_GPL(is_hash_blacklisted);int is_binary_blacklisted (const u8 *hash,size_t hash_len) { -if (is_hash_blacklisted (hash, hash_len,"bin" ) == -EKEYREJECTED ) +if (is_hash_blacklisted (hash, hash_len,BLACKLIST_HASH_BINARY ) == + -EKEYREJECTED )return -EPERM ;return 0 ;
@@ -243,7 +283,7 @@ static int __init blacklist_init(void)panic ("Can't allocate system blacklist keyring\n" );for (bl = blacklist_hashes; *bl; bl++) -if (mark_hash_blacklisted (*bl) <0 ) +if (mark_raw_hash_blacklisted (*bl) <0 )pr_err ("- blacklisting failed\n" );return 0 ; }
crypto/asymmetric_keys/x509_public_key.c +2 -1
@@ -81,7 +81,8 @@ int x509_get_sig_params(struct x509_certificate *cert)if (ret <0 ) goto error_2; - ret =is_hash_blacklisted (sig->digest, sig->digest_size,"tbs" ); + ret =is_hash_blacklisted (sig->digest, sig->digest_size, +BLACKLIST_HASH_X509_TBS );if (ret == -EKEYREJECTED ) {pr_err ("Cert %*phN is blacklisted\n" , sig->digest_size, sig->digest);
include/keys/system_keyring.h +11 -3
@@ -10,6 +10,13 @@#include <linux/key.h> +enum blacklist_hash_type { +/* TBSCertificate hash */ +BLACKLIST_HASH_X509_TBS =1 , +/* Raw data hash */ +BLACKLIST_HASH_BINARY =2 , +}; +#ifdef CONFIG_SYSTEM_TRUSTED_KEYRING extern int restrict_link_by_builtin_trusted(struct key *keyring,
@@ -40,13 +47,14 @@ extern int restrict_link_by_builtin_and_secondary_trusted(extern struct pkcs7_message *pkcs7;#ifdef CONFIG_SYSTEM_BLACKLIST_KEYRING -extern int mark_hash_blacklisted (const char *hash); +extern int mark_hash_blacklisted (const u8 *hash,size_t hash_len, +enum blacklist_hash_type hash_type);extern int is_hash_blacklisted (const u8 *hash,size_t hash_len, -const char *type); +enum blacklist_hash_type hash_type);extern int is_binary_blacklisted (const u8 *hash,size_t hash_len);#else static inline int is_hash_blacklisted (const u8 *hash,size_t hash_len, -const char *type) +enum blacklist_hash_type hash_type) {return 0 ; }
security/integrity/platform_certs/keyring_handler.c +2 -24
@@ -15,35 +15,13 @@ static efi_guid_t efi_cert_x509_sha256_guid __initdata =EFI_CERT_X509_SHA256_GUID ;static efi_guid_t efi_cert_sha256_guid__initdata =EFI_CERT_SHA256_GUID ; -/* -* Blacklist a hash. -*/ -static __init void uefi_blacklist_hash (const char *source,const void *data, -size_t len,const char *type, -size_t type_len) -{ -char *hash, *p; - - hash =kmalloc (type_len + len *2 +1 ,GFP_KERNEL ); -if (!hash) -return ; - p =memcpy (hash, type, type_len); - p += type_len; -bin2hex (p, data, len); - p += len *2 ; - *p =0 ; - -mark_hash_blacklisted (hash); -kfree (hash); -} -/* * Blacklist an X509 TBS hash. */ static __init void uefi_blacklist_x509_tbs (const char *source,const void *data,size_t len) { -uefi_blacklist_hash (source, data, len,"tbs:" ,4 ); +mark_hash_blacklisted (data, len,BLACKLIST_HASH_X509_TBS ); }/*
@@ -52,7 +30,7 @@ static __init void uefi_blacklist_x509_tbs(const char *source,static __init void uefi_blacklist_binary (const char *source,const void *data,size_t len) { -uefi_blacklist_hash (source, data, len,"bin:" ,4 ); +mark_hash_blacklisted (data, len,BLACKLIST_HASH_BINARY ); }/*
Signature · 1 line
2.32.0
PATCH v8 5/5 certs: Allow root user to append signed hashes to the blacklist keyring
In reply to Mickaël SalaünFrom: Mickaël Salaün <[email protected]>
Add a kernel option SYSTEM_BLACKLIST_AUTH_UPDATE to enable the root user to dynamically add new keys to the blacklist keyring. This enables to invalidate new certificates, either from being loaded in a keyring, or from being trusted in a PKCS#7 certificate chain. This also enables to add new file hashes to be denied by the integrity infrastructure.
Being able to untrust a certificate which could have normaly been trusted is a sensitive operation. This is why adding new hashes to the blacklist keyring is only allowed when these hashes are signed and vouched by the builtin trusted keyring. A blacklist hash is stored as a key description. The PKCS#7 signature of this description must be provided as the key payload.
Marking a certificate as untrusted should be enforced while the system is running. It is then forbiden to remove such blacklist keys.
Update blacklist keyring, blacklist key and revoked certificate access rights:
* allows the root user to search for a specific blacklisted hash, which make sense because the descriptions are already viewable;
* forbids key update (blacklist and asymmetric ones);
* restricts kernel rights on the blacklist keyring to align with the root user rights.
See help in tools/certs/print-cert-tbs-hash.sh .
---
Changes since v6:
* Rebase on keys-cve-2020-26541-v3: commit ebd9c2ae369a ("integrity:
Load mokx variables into the blacklist keyring").
Changes since v5:
* Rebase on keys-next, fix Kconfig conflict, and update the asymmetric key rights added to the blacklist keyring by the new add_key_to_revocation_list(): align with blacklist key rights by removing KEY_POS_WRITE as a safeguard, and add KEY_ALLOC_BYPASS_RESTRICTION to not be subject to restrict_link_for_blacklist() that only allows blacklist key types to be added to the keyring.
* Change the return code for restrict_link_for_blacklist() from -EPERM to -EOPNOTSUPP to align with asymmetric key keyrings.
Changes since v3:
* Update commit message for print-cert-tbs-hash.sh .
Changes since v2:
* Add comment for blacklist_key_instantiate().
--- certs/Kconfig | 10 +++++ certs/blacklist.c | 96 ++++++++++++++++++++++++++++++++++++----------- 2 files changed, 85 insertions(+), 21 deletions(-)
certs/Kconfig +10 -0
@@ -103,4 +103,14 @@ config SYSTEM_REVOCATION_KEYS containing X.509 certificates to be included in the default blacklist keyring. +config SYSTEM_BLACKLIST_AUTH_UPDATE + bool "Allow root to add signed blacklist keys" + depends on SYSTEM_BLACKLIST_KEYRING + depends on SYSTEM_DATA_VERIFICATION + help + If set, provide the ability to load new blacklist keys at run time if + they are signed and vouched by a certificate from the builtin trusted + keyring. The PKCS#7 signature of the description is set in the key + payload. Blacklist keys cannot be removed. + endmenu
certs/blacklist.c +75 -21
156 lines not on this page · raw message
Signature · 1 line
2.32.0
Jarkko Sakkinen
maintainerRe: [PATCH v8 5/5] certs: Allow root user to append signed hashes to the blacklist keyring
Quoted 214 lines · Mickaël Salaün
From: Mickaël Salaün <[email protected]>
Add a kernel option
SYSTEM_BLACKLIST_AUTH_UPDATEto enable the root user to dynamically add new keys to the blacklist keyring. This enables to invalidate new certificates, either from being loaded in a keyring, or from being trusted in a PKCS#7 certificate chain. This also enables to add new file hashes to be denied by the integrity infrastructure.Being able to untrust a certificate which could have normaly been trusted is a sensitive operation. This is why adding new hashes to the blacklist keyring is only allowed when these hashes are signed and vouched by the builtin trusted keyring. A blacklist hash is stored as a key description. The PKCS#7 signature of this description must be provided as the key payload.
Marking a certificate as untrusted should be enforced while the system is running. It is then forbiden to remove such blacklist keys.
Update blacklist keyring, blacklist key and revoked certificate access rights:
* allows the root user to search for a specific blacklisted hash, which make sense because the descriptions are already viewable;
* forbids key update (blacklist and asymmetric ones);
* restricts kernel rights on the blacklist keyring to align with the root user rights.See help in
tools/certs/print-cert-tbs-hash.sh.Cc David Howells <[email protected]>Cc David Woodhouse <[email protected]>Cc Eric Snowberg <[email protected]>Cc Jarkko Sakkinen <[email protected]>Signed-off-by Mickaël Salaün <[email protected]>---
Changes since v6:
* Rebase on keys-cve-2020-26541-v3: commitebd9c2ae369a("integrity:
Load mokx variables into the blacklist keyring").Changes since v5:
* Rebase on keys-next, fixKconfigconflict, and update the asymmetric key rights added to the blacklist keyring by the newadd_key_to_revocation_list(): align with blacklist key rights by removingKEY_POS_WRITEas a safeguard, and addKEY_ALLOC_BYPASS_RESTRICTIONto not be subject torestrict_link_for_blacklist()that only allows blacklist key types to be added to the keyring.
* Change the return code forrestrict_link_for_blacklist()from-EPERMto-EOPNOTSUPPto align with asymmetric key keyrings.Changes since v3:
* Update commit message forprint-cert-tbs-hash.sh.Changes since v2:
* Add comment forblacklist_key_instantiate().--- certs/Kconfig | 10 +++++ certs/blacklist.c | 96 ++++++++++++++++++++++++++++++++++++----------- 2 files changed, 85 insertions(+), 21 deletions(-)certs/Kconfig +10
-0@@ -103,4 +103,14 @@ config SYSTEM_REVOCATION_KEYS containing X.509 certificates to be included in the default blacklist keyring. +config SYSTEM_BLACKLIST_AUTH_UPDATE + bool "Allow root to add signed blacklist keys" + depends on SYSTEM_BLACKLIST_KEYRING + depends on SYSTEM_DATA_VERIFICATION + help + If set, provide the ability to load new blacklist keys at run time if + they are signed and vouched by a certificate from the builtin trusted + keyring. The PKCS#7 signature of the description is set in the key + payload. Blacklist keys cannot be removed. + endmenucerts/blacklist.c +61
-16@@ -15,6 +15,7 @@#include <linux/err.h> #include <linux/seq_file.h> #include <linux/uidgid.h> +#include <linux/verification.h> #include <keys/system_keyring.h> #include "blacklist.h" #include "common.h" @@ -26,6 +27,9 @@*/ #define MAX_HASH_LEN 128 +#define BLACKLIST_KEY_PERM (KEY_POS_SEARCH | KEY_POS_VIEW | \ + KEY_USR_SEARCH | KEY_USR_VIEW) +static const char tbs_prefix[] ="tbs" ;static const char bin_prefix[] ="bin" ;@@ -80,19 +84,51 @@ static int blacklist_vet_description(const char *desc)return 0 ; } -/* -* The hash to be blacklisted is expected to be in the description. There will -* be no payload. -*/ -static int blacklist_preparse (struct key_preparsed_payload *prep) +static int blacklist_key_instantiate (struct key *key, +struct key_preparsed_payload *prep) { -if (prep->datalen >0 ) -return -EINVAL ; -return 0 ; +#ifdef CONFIG_SYSTEM_BLACKLIST_AUTH_UPDATE +int err; +#endif + +/* Sets safe default permissions for keys loaded by user space. */ + key->perm =BLACKLIST_KEY_PERM ; + +/* +* Skips the authentication step for builtin hashes, they are not +* signed but still trusted. +*/ +if (key->flags & (1 <<KEY_FLAG_BUILTIN )) + goto out; + +#ifdef CONFIG_SYSTEM_BLACKLIST_AUTH_UPDATE +/* +* Verifies the description's PKCS#7 signature against the builtin +* trusted keyring. +*/ + err =verify_pkcs7_signature (key->description, +strlen (key->description), prep->data, prep->datalen, +NULL ,VERIFYING_UNSPECIFIED_SIGNATURE ,NULL ,NULL ); +if (err) +return err; +#else +/* +* It should not be possible to come here because the keyring doesn't +* have KEY_USR_WRITE and the only other way to call this function is +* for builtin hashes. +*/ +WARN_ON_ONCE (1 ); +return -EPERM ; +#endif + +out: +return generic_key_instantiate (key, prep); } -static void blacklist_free_preparse (struct key_preparsed_payload *prep) +static int blacklist_key_update (struct key *key, +struct key_preparsed_payload *prep) { +return -EPERM ; }static void blacklist_describe (const struct key *key,struct seq_file *m)@@ -103,9 +139,8 @@ static void blacklist_describe(const struct key *key, struct seq_file *m)static struct key_type key_type_blacklist = { .name ="blacklist" , .vet_description = blacklist_vet_description, - .preparse = blacklist_preparse, - .free_preparse = blacklist_free_preparse, - .instantiate = generic_key_instantiate, + .instantiate = blacklist_key_instantiate, + .update = blacklist_key_update, .describe = blacklist_describe, };@@ -154,8 +189,7 @@ static int mark_raw_hash_blacklisted(const char *hash) hash,NULL ,0 , - ((KEY_POS_ALL & ~KEY_POS_SETATTR ) | -KEY_USR_VIEW ), +BLACKLIST_KEY_PERM ,KEY_ALLOC_NOT_IN_QUOTA | KEY_ALLOC_BUILT_IN);if (IS_ERR (key)) {@@ -232,8 +266,10 @@ int add_key_to_revocation_list(const char *data, size_t size)NULL , data, size, - ((KEY_POS_ALL & ~KEY_POS_SETATTR ) |KEY_USR_VIEW ), - KEY_ALLOC_NOT_IN_QUOTA | KEY_ALLOC_BUILT_IN); +KEY_POS_VIEW |KEY_POS_READ |KEY_POS_SEARCH + |KEY_USR_VIEW , +KEY_ALLOC_NOT_IN_QUOTA |KEY_ALLOC_BUILT_IN + | KEY_ALLOC_BYPASS_RESTRICTION);if (IS_ERR (key)) {pr_err ("Problem with revocation key (%ld)\n" ,PTR_ERR (key));@@ -260,25 +296,43 @@ int is_key_on_revocation_list(struct pkcs7_message *pkcs7) }#endif +static int restrict_link_for_blacklist (struct key *dest_keyring, +const struct key_type *type,const union key_payload *payload, +struct key *restrict_key) +{ +if (type == &key_type_blacklist) +return 0 ; +return -EOPNOTSUPP ; +} +/* * Initialise the blacklist */ static int __init blacklist_init (void )
certs/blacklist.c int is_key_on_revocation_list(struct pkcs7_message *pkcs7) · line 321
Quoted 10 lines
certs/blacklist.c +4
-0{const char *const *bl; +struct key_restriction *restriction;if (register_key_type (&key_type_blacklist) <0 )panic ("Can't allocate system blacklist key type\n" ); + restriction =kzalloc (sizeof (*restriction),GFP_KERNEL ); +if (!restriction) +panic ("Can't allocate blacklist keyring restriction\n" );
This prevents me from taking this to my pull request. In moderns standards, no new BUG_ON(), panic() etc. should never added to the kernel.
I missed this in my review.
This should rather be e.g.
restriction = kzalloc(sizeof(*restriction), GFP_KERNEL);
if (!restriction) {
pr_err("Can't allocate blacklist keyring restriction\n");
return 0;
}Unfortunately I need to drop this patch set, because adding new panic() is simply a no-go.
BR, Jarkko
Re: [PATCH v8 5/5] certs: Allow root user to append signed hashes to the blacklist keyring
Quoted 234 lines · Jarkko Sakkinen
Quoted 214 lines · Mickaël Salaün
From: Mickaël Salaün <[email protected]>
Add a kernel option
SYSTEM_BLACKLIST_AUTH_UPDATEto enable the root user to dynamically add new keys to the blacklist keyring. This enables to invalidate new certificates, either from being loaded in a keyring, or from being trusted in a PKCS#7 certificate chain. This also enables to add new file hashes to be denied by the integrity infrastructure.Being able to untrust a certificate which could have normaly been trusted is a sensitive operation. This is why adding new hashes to the blacklist keyring is only allowed when these hashes are signed and vouched by the builtin trusted keyring. A blacklist hash is stored as a key description. The PKCS#7 signature of this description must be provided as the key payload.
Marking a certificate as untrusted should be enforced while the system is running. It is then forbiden to remove such blacklist keys.
Update blacklist keyring, blacklist key and revoked certificate access rights:
* allows the root user to search for a specific blacklisted hash, which make sense because the descriptions are already viewable;
* forbids key update (blacklist and asymmetric ones);
* restricts kernel rights on the blacklist keyring to align with the root user rights.See help in
tools/certs/print-cert-tbs-hash.sh.Cc David Howells <[email protected]>Cc David Woodhouse <[email protected]>Cc Eric Snowberg <[email protected]>Cc Jarkko Sakkinen <[email protected]>Signed-off-by Mickaël Salaün <[email protected]>---
Changes since v6:
* Rebase on keys-cve-2020-26541-v3: commitebd9c2ae369a("integrity:
Load mokx variables into the blacklist keyring").Changes since v5:
* Rebase on keys-next, fixKconfigconflict, and update the asymmetric key rights added to the blacklist keyring by the newadd_key_to_revocation_list(): align with blacklist key rights by removingKEY_POS_WRITEas a safeguard, and addKEY_ALLOC_BYPASS_RESTRICTIONto not be subject torestrict_link_for_blacklist()that only allows blacklist key types to be added to the keyring.
* Change the return code forrestrict_link_for_blacklist()from-EPERMto-EOPNOTSUPPto align with asymmetric key keyrings.Changes since v3:
* Update commit message forprint-cert-tbs-hash.sh.Changes since v2:
* Add comment forblacklist_key_instantiate().--- certs/Kconfig | 10 +++++ certs/blacklist.c | 96 ++++++++++++++++++++++++++++++++++++----------- 2 files changed, 85 insertions(+), 21 deletions(-)certs/Kconfig +10
-0@@ -103,4 +103,14 @@ config SYSTEM_REVOCATION_KEYS containing X.509 certificates to be included in the default blacklist keyring. +config SYSTEM_BLACKLIST_AUTH_UPDATE + bool "Allow root to add signed blacklist keys" + depends on SYSTEM_BLACKLIST_KEYRING + depends on SYSTEM_DATA_VERIFICATION + help + If set, provide the ability to load new blacklist keys at run time if + they are signed and vouched by a certificate from the builtin trusted + keyring. The PKCS#7 signature of the description is set in the key + payload. Blacklist keys cannot be removed. + endmenucerts/blacklist.c +61
-16@@ -15,6 +15,7 @@#include <linux/err.h> #include <linux/seq_file.h> #include <linux/uidgid.h> +#include <linux/verification.h> #include <keys/system_keyring.h> #include "blacklist.h" #include "common.h" @@ -26,6 +27,9 @@*/ #define MAX_HASH_LEN 128 +#define BLACKLIST_KEY_PERM (KEY_POS_SEARCH | KEY_POS_VIEW | \ + KEY_USR_SEARCH | KEY_USR_VIEW) +static const char tbs_prefix[] ="tbs" ;static const char bin_prefix[] ="bin" ;@@ -80,19 +84,51 @@ static int blacklist_vet_description(const char *desc)return 0 ; } -/* -* The hash to be blacklisted is expected to be in the description. There will -* be no payload. -*/ -static int blacklist_preparse (struct key_preparsed_payload *prep) +static int blacklist_key_instantiate (struct key *key, +struct key_preparsed_payload *prep) { -if (prep->datalen >0 ) -return -EINVAL ; -return 0 ; +#ifdef CONFIG_SYSTEM_BLACKLIST_AUTH_UPDATE +int err; +#endif + +/* Sets safe default permissions for keys loaded by user space. */ + key->perm =BLACKLIST_KEY_PERM ; + +/* +* Skips the authentication step for builtin hashes, they are not +* signed but still trusted. +*/ +if (key->flags & (1 <<KEY_FLAG_BUILTIN )) + goto out; + +#ifdef CONFIG_SYSTEM_BLACKLIST_AUTH_UPDATE +/* +* Verifies the description's PKCS#7 signature against the builtin +* trusted keyring. +*/ + err =verify_pkcs7_signature (key->description, +strlen (key->description), prep->data, prep->datalen, +NULL ,VERIFYING_UNSPECIFIED_SIGNATURE ,NULL ,NULL ); +if (err) +return err; +#else +/* +* It should not be possible to come here because the keyring doesn't +* have KEY_USR_WRITE and the only other way to call this function is +* for builtin hashes. +*/ +WARN_ON_ONCE (1 ); +return -EPERM ; +#endif + +out: +return generic_key_instantiate (key, prep); } -static void blacklist_free_preparse (struct key_preparsed_payload *prep) +static int blacklist_key_update (struct key *key, +struct key_preparsed_payload *prep) { +return -EPERM ; }static void blacklist_describe (const struct key *key,struct seq_file *m)@@ -103,9 +139,8 @@ static void blacklist_describe(const struct key *key, struct seq_file *m)static struct key_type key_type_blacklist = { .name ="blacklist" , .vet_description = blacklist_vet_description, - .preparse = blacklist_preparse, - .free_preparse = blacklist_free_preparse, - .instantiate = generic_key_instantiate, + .instantiate = blacklist_key_instantiate, + .update = blacklist_key_update, .describe = blacklist_describe, };@@ -154,8 +189,7 @@ static int mark_raw_hash_blacklisted(const char *hash) hash,NULL ,0 , - ((KEY_POS_ALL & ~KEY_POS_SETATTR ) | -KEY_USR_VIEW ), +BLACKLIST_KEY_PERM ,KEY_ALLOC_NOT_IN_QUOTA | KEY_ALLOC_BUILT_IN);if (IS_ERR (key)) {@@ -232,8 +266,10 @@ int add_key_to_revocation_list(const char *data, size_t size)NULL , data, size, - ((KEY_POS_ALL & ~KEY_POS_SETATTR ) |KEY_USR_VIEW ), - KEY_ALLOC_NOT_IN_QUOTA | KEY_ALLOC_BUILT_IN); +KEY_POS_VIEW |KEY_POS_READ |KEY_POS_SEARCH + |KEY_USR_VIEW , +KEY_ALLOC_NOT_IN_QUOTA |KEY_ALLOC_BUILT_IN + | KEY_ALLOC_BYPASS_RESTRICTION);if (IS_ERR (key)) {pr_err ("Problem with revocation key (%ld)\n" ,PTR_ERR (key));@@ -260,25 +296,43 @@ int is_key_on_revocation_list(struct pkcs7_message *pkcs7) }#endif +static int restrict_link_for_blacklist (struct key *dest_keyring, +const struct key_type *type,const union key_payload *payload, +struct key *restrict_key) +{ +if (type == &key_type_blacklist) +return 0 ; +return -EOPNOTSUPP ; +} +/* * Initialise the blacklist */ static int __init blacklist_init (void )certs/blacklist.c int is_key_on_revocation_list(struct pkcs7_message *pkcs7) · line 321
Quoted 10 lines
certs/blacklist.c +4
-0{const char *const *bl; +struct key_restriction *restriction;if (register_key_type (&key_type_blacklist) <0 )panic ("Can't allocate system blacklist key type\n" ); + restriction =kzalloc (sizeof (*restriction),GFP_KERNEL ); +if (!restriction) +panic ("Can't allocate blacklist keyring restriction\n" );This prevents me from taking this to my pull request. In moderns standards, no new
BUG_ON(),panic()etc. should never added to the kernel.I missed this in my review.
This should rather be e.g.
Quoted 8 lines
restriction = kzalloc(sizeof(*restriction), GFP_KERNEL); if (!restriction) { pr_err("Can't allocate blacklist keyring restriction\n"); return 0; }Unfortunately I need to drop this patch set, because adding new
panic()is simply a no-go.
I agree that panic() is not great in general, but I followed the other part of the code (just above) that do the same. This part of the kernel should failed if critical memory allocation failed at boot time (only). It doesn't impact the kernel once it is running. I don't think that just ignoring this error with return 0 is fine, after all it's a critical error right?
Calling panic() seems OK here. Is there a better way to stop the kernel for such critical error? If the kernel cannot allocate memory at this time, it would be useless to try continuing booting.
Jarkko Sakkinen
maintainerRe: [PATCH v8 5/5] certs: Allow root user to append signed hashes to the blacklist keyring
Quoted 231 lines · Mickaël Salaün
Quoted 229 lines · Jarkko Sakkinen
Quoted 203 lines · Mickaël Salaün
From: Mickaël Salaün <[email protected]>
Add a kernel option
SYSTEM_BLACKLIST_AUTH_UPDATEto enable the root user to dynamically add new keys to the blacklist keyring. This enables to invalidate new certificates, either from being loaded in a keyring, or from being trusted in a PKCS#7 certificate chain. This also enables to add new file hashes to be denied by the integrity infrastructure.Being able to untrust a certificate which could have normaly been trusted is a sensitive operation. This is why adding new hashes to the blacklist keyring is only allowed when these hashes are signed and vouched by the builtin trusted keyring. A blacklist hash is stored as a key description. The PKCS#7 signature of this description must be provided as the key payload.
Marking a certificate as untrusted should be enforced while the system is running. It is then forbiden to remove such blacklist keys.
Update blacklist keyring, blacklist key and revoked certificate access rights:
* allows the root user to search for a specific blacklisted hash, which make sense because the descriptions are already viewable;
* forbids key update (blacklist and asymmetric ones);
* restricts kernel rights on the blacklist keyring to align with the root user rights.See help in
tools/certs/print-cert-tbs-hash.sh.Cc David Howells <[email protected]>Cc David Woodhouse <[email protected]>Cc Eric Snowberg <[email protected]>Cc Jarkko Sakkinen <[email protected]>Signed-off-by Mickaël Salaün <[email protected]>---
Changes since v6:
* Rebase on keys-cve-2020-26541-v3: commitebd9c2ae369a("integrity:
Load mokx variables into the blacklist keyring").Changes since v5:
* Rebase on keys-next, fixKconfigconflict, and update the asymmetric key rights added to the blacklist keyring by the newadd_key_to_revocation_list(): align with blacklist key rights by removingKEY_POS_WRITEas a safeguard, and addKEY_ALLOC_BYPASS_RESTRICTIONto not be subject torestrict_link_for_blacklist()that only allows blacklist key types to be added to the keyring.
* Change the return code forrestrict_link_for_blacklist()from-EPERMto-EOPNOTSUPPto align with asymmetric key keyrings.Changes since v3:
* Update commit message forprint-cert-tbs-hash.sh.Changes since v2:
* Add comment forblacklist_key_instantiate().--- certs/Kconfig | 10 +++++ certs/blacklist.c | 96 ++++++++++++++++++++++++++++++++++++----------- 2 files changed, 85 insertions(+), 21 deletions(-)certs/Kconfig +10
-0@@ -103,4 +103,14 @@ config SYSTEM_REVOCATION_KEYS containing X.509 certificates to be included in the default blacklist keyring. +config SYSTEM_BLACKLIST_AUTH_UPDATE + bool "Allow root to add signed blacklist keys" + depends on SYSTEM_BLACKLIST_KEYRING + depends on SYSTEM_DATA_VERIFICATION + help + If set, provide the ability to load new blacklist keys at run time if + they are signed and vouched by a certificate from the builtin trusted + keyring. The PKCS#7 signature of the description is set in the key + payload. Blacklist keys cannot be removed. + endmenucerts/blacklist.c +61
-16@@ -15,6 +15,7 @@#include <linux/err.h> #include <linux/seq_file.h> #include <linux/uidgid.h> +#include <linux/verification.h> #include <keys/system_keyring.h> #include "blacklist.h" #include "common.h" @@ -26,6 +27,9 @@*/ #define MAX_HASH_LEN 128 +#define BLACKLIST_KEY_PERM (KEY_POS_SEARCH | KEY_POS_VIEW | \ + KEY_USR_SEARCH | KEY_USR_VIEW) +static const char tbs_prefix[] ="tbs" ;static const char bin_prefix[] ="bin" ;@@ -80,19 +84,51 @@ static int blacklist_vet_description(const char *desc)return 0 ; } -/* -* The hash to be blacklisted is expected to be in the description. There will -* be no payload. -*/ -static int blacklist_preparse (struct key_preparsed_payload *prep) +static int blacklist_key_instantiate (struct key *key, +struct key_preparsed_payload *prep) { -if (prep->datalen >0 ) -return -EINVAL ; -return 0 ; +#ifdef CONFIG_SYSTEM_BLACKLIST_AUTH_UPDATE +int err; +#endif + +/* Sets safe default permissions for keys loaded by user space. */ + key->perm =BLACKLIST_KEY_PERM ; + +/* +* Skips the authentication step for builtin hashes, they are not +* signed but still trusted. +*/ +if (key->flags & (1 <<KEY_FLAG_BUILTIN )) + goto out; + +#ifdef CONFIG_SYSTEM_BLACKLIST_AUTH_UPDATE +/* +* Verifies the description's PKCS#7 signature against the builtin +* trusted keyring. +*/ + err =verify_pkcs7_signature (key->description, +strlen (key->description), prep->data, prep->datalen, +NULL ,VERIFYING_UNSPECIFIED_SIGNATURE ,NULL ,NULL ); +if (err) +return err; +#else +/* +* It should not be possible to come here because the keyring doesn't +* have KEY_USR_WRITE and the only other way to call this function is +* for builtin hashes. +*/ +WARN_ON_ONCE (1 ); +return -EPERM ; +#endif + +out: +return generic_key_instantiate (key, prep); } -static void blacklist_free_preparse (struct key_preparsed_payload *prep) +static int blacklist_key_update (struct key *key, +struct key_preparsed_payload *prep) { +return -EPERM ; }static void blacklist_describe (const struct key *key,struct seq_file *m)@@ -103,9 +139,8 @@ static void blacklist_describe(const struct key *key, struct seq_file *m)static struct key_type key_type_blacklist = { .name ="blacklist" , .vet_description = blacklist_vet_description, - .preparse = blacklist_preparse, - .free_preparse = blacklist_free_preparse, - .instantiate = generic_key_instantiate, + .instantiate = blacklist_key_instantiate, + .update = blacklist_key_update, .describe = blacklist_describe, };@@ -154,8 +189,7 @@ static int mark_raw_hash_blacklisted(const char *hash) hash,NULL ,0 , - ((KEY_POS_ALL & ~KEY_POS_SETATTR ) | -KEY_USR_VIEW ), +BLACKLIST_KEY_PERM ,KEY_ALLOC_NOT_IN_QUOTA | KEY_ALLOC_BUILT_IN);if (IS_ERR (key)) {@@ -232,8 +266,10 @@ int add_key_to_revocation_list(const char *data, size_t size)NULL , data, size, - ((KEY_POS_ALL & ~KEY_POS_SETATTR ) |KEY_USR_VIEW ), - KEY_ALLOC_NOT_IN_QUOTA | KEY_ALLOC_BUILT_IN); +KEY_POS_VIEW |KEY_POS_READ |KEY_POS_SEARCH + |KEY_USR_VIEW , +KEY_ALLOC_NOT_IN_QUOTA |KEY_ALLOC_BUILT_IN + | KEY_ALLOC_BYPASS_RESTRICTION);if (IS_ERR (key)) {pr_err ("Problem with revocation key (%ld)\n" ,PTR_ERR (key));@@ -260,25 +296,43 @@ int is_key_on_revocation_list(struct pkcs7_message *pkcs7) }#endif +static int restrict_link_for_blacklist (struct key *dest_keyring, +const struct key_type *type,const union key_payload *payload, +struct key *restrict_key) +{ +if (type == &key_type_blacklist) +return 0 ; +return -EOPNOTSUPP ; +} +/* * Initialise the blacklist certs/blacklist.c int is_key_on_revocation_list(struct pkcs7_message *pkcs7) · line 318
Quoted 10 lines
certs/blacklist.c +4
-0*/ static int __init blacklist_init (void ) {const char *const *bl; +struct key_restriction *restriction;if (register_key_type (&key_type_blacklist) <0 )panic ("Can't allocate system blacklist key type\n" ); + restriction =kzalloc (sizeof (*restriction),GFP_KERNEL ); +if (!restriction) +panic ("Can't allocate blacklist keyring restriction\n" );This prevents me from taking this to my pull request. In moderns standards, no new
BUG_ON(),panic()etc. should never added to the kernel.I missed this in my review.
This should rather be e.g.
restriction = kzalloc(sizeof(*restriction), GFP_KERNEL); if (!restriction) { pr_err("Can't allocate blacklist keyring restriction\n"); return 0; }
Quoted 8 lines
Quoted 2 lines
Unfortunately I need to drop this patch set, because adding new
panic()is simply a no-go.I agree that
panic()is not great in general, but I followed the other part of the code (just above) that do the same. This part of the kernel should failed if critical memory allocation failed at boot time (only). It doesn't impact the kernel once it is running. I don't think that just ignoring this error with return 0 is fine, after all it's a critical error right?
It's not good reason enough to crash the whole kernel, even if it is a critical error (e.g. run-time foresincs). Even WARN() is not recommended these days [*].
For the existing panic()-statements: I'm happy to review patches that render them out.
Not sure tho, if this fails should it be then "everything blacklisted". Just one thing to consider.
Quoted 3 lines
Calling
panic()seems OK here. Is there a better way to stop the kernel for such critical error? If the kernel cannot allocate memory at this time, it would be useless to try continuing booting.
[*] https://lore.kernel.org/linux-sgx/YA0tvOGp%[email protected]/
BR, Jarkko
Re: [PATCH v8 5/5] certs: Allow root user to append signed hashes to the blacklist keyring
Quoted 241 lines · Jarkko Sakkinen
Quoted 231 lines · Mickaël Salaün
Quoted 229 lines · Jarkko Sakkinen
Quoted 203 lines · Mickaël Salaün
From: Mickaël Salaün <[email protected]>
Add a kernel option
SYSTEM_BLACKLIST_AUTH_UPDATEto enable the root user to dynamically add new keys to the blacklist keyring. This enables to invalidate new certificates, either from being loaded in a keyring, or from being trusted in a PKCS#7 certificate chain. This also enables to add new file hashes to be denied by the integrity infrastructure.Being able to untrust a certificate which could have normaly been trusted is a sensitive operation. This is why adding new hashes to the blacklist keyring is only allowed when these hashes are signed and vouched by the builtin trusted keyring. A blacklist hash is stored as a key description. The PKCS#7 signature of this description must be provided as the key payload.
Marking a certificate as untrusted should be enforced while the system is running. It is then forbiden to remove such blacklist keys.
Update blacklist keyring, blacklist key and revoked certificate access rights:
* allows the root user to search for a specific blacklisted hash, whichmake sense because the descriptions are already viewable;* forbids key update (blacklist and asymmetric ones);
* restricts kernel rights on the blacklist keyring to align with the root user rights.See help in
tools/certs/print-cert-tbs-hash.sh.Cc David Howells <[email protected]>Cc David Woodhouse <[email protected]>Cc Eric Snowberg <[email protected]>Cc Jarkko Sakkinen <[email protected]>Signed-off-by Mickaël Salaün <[email protected]>---
Changes since v6:
* Rebase on keys-cve-2020-26541-v3: commitebd9c2ae369a("integrity:
Load mokx variables into the blacklist keyring").Changes since v5:
* Rebase on keys-next, fixKconfigconflict, and update the asymmetric key rights added to the blacklist keyring by the newadd_key_to_revocation_list(): align with blacklist key rights by removingKEY_POS_WRITEas a safeguard, and addKEY_ALLOC_BYPASS_RESTRICTIONto not be subject torestrict_link_for_blacklist()that only allows blacklist key types to be added to the keyring.
* Change the return code forrestrict_link_for_blacklist()from-EPERMto-EOPNOTSUPPto align with asymmetric key keyrings.Changes since v3:
* Update commit message forprint-cert-tbs-hash.sh.Changes since v2:
* Add comment forblacklist_key_instantiate().--- certs/Kconfig | 10 +++++ certs/blacklist.c | 96 ++++++++++++++++++++++++++++++++++++----------- 2 files changed, 85 insertions(+), 21 deletions(-)certs/Kconfig +10
-0@@ -103,4 +103,14 @@ config SYSTEM_REVOCATION_KEYS containing X.509 certificates to be included in the default blacklist keyring. +config SYSTEM_BLACKLIST_AUTH_UPDATE + bool "Allow root to add signed blacklist keys" + depends on SYSTEM_BLACKLIST_KEYRING + depends on SYSTEM_DATA_VERIFICATION + help + If set, provide the ability to load new blacklist keys at run time if + they are signed and vouched by a certificate from the builtin trusted + keyring. The PKCS#7 signature of the description is set in the key + payload. Blacklist keys cannot be removed. + endmenucerts/blacklist.c +61
-16@@ -15,6 +15,7 @@#include <linux/err.h> #include <linux/seq_file.h> #include <linux/uidgid.h> +#include <linux/verification.h> #include <keys/system_keyring.h> #include "blacklist.h" #include "common.h" @@ -26,6 +27,9 @@*/ #define MAX_HASH_LEN 128 +#define BLACKLIST_KEY_PERM (KEY_POS_SEARCH | KEY_POS_VIEW | \ + KEY_USR_SEARCH | KEY_USR_VIEW) +static const char tbs_prefix[] ="tbs" ;static const char bin_prefix[] ="bin" ;@@ -80,19 +84,51 @@ static int blacklist_vet_description(const char *desc)return 0 ; } -/* -* The hash to be blacklisted is expected to be in the description. There will -* be no payload. -*/ -static int blacklist_preparse (struct key_preparsed_payload *prep) +static int blacklist_key_instantiate (struct key *key, +struct key_preparsed_payload *prep) { -if (prep->datalen >0 ) -return -EINVAL ; -return 0 ; +#ifdef CONFIG_SYSTEM_BLACKLIST_AUTH_UPDATE +int err; +#endif + +/* Sets safe default permissions for keys loaded by user space. */ + key->perm =BLACKLIST_KEY_PERM ; + +/* +* Skips the authentication step for builtin hashes, they are not +* signed but still trusted. +*/ +if (key->flags & (1 <<KEY_FLAG_BUILTIN )) + goto out; + +#ifdef CONFIG_SYSTEM_BLACKLIST_AUTH_UPDATE +/* +* Verifies the description's PKCS#7 signature against the builtin +* trusted keyring. +*/ + err =verify_pkcs7_signature (key->description, +strlen (key->description), prep->data, prep->datalen, +NULL ,VERIFYING_UNSPECIFIED_SIGNATURE ,NULL ,NULL ); +if (err) +return err; +#else +/* +* It should not be possible to come here because the keyring doesn't +* have KEY_USR_WRITE and the only other way to call this function is +* for builtin hashes. +*/ +WARN_ON_ONCE (1 ); +return -EPERM ; +#endif + +out: +return generic_key_instantiate (key, prep); } -static void blacklist_free_preparse (struct key_preparsed_payload *prep) +static int blacklist_key_update (struct key *key, +struct key_preparsed_payload *prep) { +return -EPERM ; }static void blacklist_describe (const struct key *key,struct seq_file *m)@@ -103,9 +139,8 @@ static void blacklist_describe(const struct key *key, struct seq_file *m)static struct key_type key_type_blacklist = { .name ="blacklist" , .vet_description = blacklist_vet_description, - .preparse = blacklist_preparse, - .free_preparse = blacklist_free_preparse, - .instantiate = generic_key_instantiate, + .instantiate = blacklist_key_instantiate, + .update = blacklist_key_update, .describe = blacklist_describe, };@@ -154,8 +189,7 @@ static int mark_raw_hash_blacklisted(const char *hash) hash,NULL ,0 , - ((KEY_POS_ALL & ~KEY_POS_SETATTR ) | -KEY_USR_VIEW ), +BLACKLIST_KEY_PERM ,KEY_ALLOC_NOT_IN_QUOTA | KEY_ALLOC_BUILT_IN);if (IS_ERR (key)) {@@ -232,8 +266,10 @@ int add_key_to_revocation_list(const char *data, size_t size)NULL , data, size, - ((KEY_POS_ALL & ~KEY_POS_SETATTR ) |KEY_USR_VIEW ), - KEY_ALLOC_NOT_IN_QUOTA | KEY_ALLOC_BUILT_IN); +KEY_POS_VIEW |KEY_POS_READ |KEY_POS_SEARCH + |KEY_USR_VIEW , +KEY_ALLOC_NOT_IN_QUOTA |KEY_ALLOC_BUILT_IN + | KEY_ALLOC_BYPASS_RESTRICTION);if (IS_ERR (key)) {pr_err ("Problem with revocation key (%ld)\n" ,PTR_ERR (key));@@ -260,25 +296,43 @@ int is_key_on_revocation_list(struct pkcs7_message *pkcs7) }#endif +static int restrict_link_for_blacklist (struct key *dest_keyring, +const struct key_type *type,const union key_payload *payload, +struct key *restrict_key) +{ +if (type == &key_type_blacklist) +return 0 ; +return -EOPNOTSUPP ; +} +/* * Initialise the blacklist certs/blacklist.c int is_key_on_revocation_list(struct pkcs7_message *pkcs7) · line 318
Quoted 10 lines
certs/blacklist.c +4
-0*/ static int __init blacklist_init (void ) {const char *const *bl; +struct key_restriction *restriction;if (register_key_type (&key_type_blacklist) <0 )panic ("Can't allocate system blacklist key type\n" ); + restriction =kzalloc (sizeof (*restriction),GFP_KERNEL ); +if (!restriction) +panic ("Can't allocate blacklist keyring restriction\n" );This prevents me from taking this to my pull request. In moderns standards, no new
BUG_ON(),panic()etc. should never added to the kernel.I missed this in my review.
This should rather be e.g.
restriction = kzalloc(sizeof(*restriction), GFP_KERNEL); if (!restriction) { pr_err("Can't allocate blacklist keyring restriction\n"); return 0; }Quoted 8 lines
Quoted 2 lines
Unfortunately I need to drop this patch set, because adding new
panic()is simply a no-go.I agree that
panic()is not great in general, but I followed the other part of the code (just above) that do the same. This part of the kernel should failed if critical memory allocation failed at boot time (only). It doesn't impact the kernel once it is running. I don't think that just ignoring this error with return 0 is fine, after all it's a critical error right?
Quoted 3 lines
It's not good reason enough to crash the whole kernel, even if it is a critical error (e.g. run-time foresincs). Even
WARN()is not recommended these days [*].
I think that what Greg said in this email is that WARN*() should only be used for cases that should never happen, it is definitely not deprecated, but WARN_ON_ONCE() may be a better idea though. WARN*() helps detect such thought-to-be-impossible cases, that can happen e.g. with code refactoring.
A lot of initialization/boot code (e.g. without user space nor external interactions, mostly __init functions) do panic if there is unexpected and unrecoverable errors like failed memory allocations. I think handling such errors otherwise would be more complex for no benefit. Moreover, delegating such error handling to user space could create new (silent) issues.
Quoted 5 lines
For the existing panic()-statements: I'm happy to review patches that render them out. >
Not sure tho, if this fails should it be then "everything blacklisted". Just one thing to consider.
Well, if it fail it will be "nothing will work afterwards". Do you have a working and useful scenario for this kind of error?
Quoted 6 lines
Quoted 4 lines
Calling
panic()seems OK here. Is there a better way to stop the kernel for such critical error? If the kernel cannot allocate memory at this time, it would be useless to try continuing booting.[*] https://lore.kernel.org/linux-sgx/YA0tvOGp%[email protected]/
Jarkko Sakkinen
maintainerRe: [PATCH v8 5/5] certs: Allow root user to append signed hashes to the blacklist keyring
Quoted 252 lines · Mickaël Salaün
Quoted 241 lines · Jarkko Sakkinen
Quoted 231 lines · Mickaël Salaün
Quoted 229 lines · Jarkko Sakkinen
Quoted 203 lines · Mickaël Salaün
From: Mickaël Salaün <[email protected]>
Add a kernel option
SYSTEM_BLACKLIST_AUTH_UPDATEto enable the root user to dynamically add new keys to the blacklist keyring. This enables to invalidate new certificates, either from being loaded in a keyring, or from being trusted in a PKCS#7 certificate chain. This also enables to add new file hashes to be denied by the integrity infrastructure.Being able to untrust a certificate which could have normaly been trusted is a sensitive operation. This is why adding new hashes to the blacklist keyring is only allowed when these hashes are signed and vouched by the builtin trusted keyring. A blacklist hash is stored as a key description. The PKCS#7 signature of this description must be provided as the key payload.
Marking a certificate as untrusted should be enforced while the system is running. It is then forbiden to remove such blacklist keys.
Update blacklist keyring, blacklist key and revoked certificate access rights:
* allows the root user to search for a specific blacklisted hash, whichmake sense because the descriptions are already viewable;* forbids key update (blacklist and asymmetric ones);
* restricts kernel rights on the blacklist keyring to align with the root user rights.See help in
tools/certs/print-cert-tbs-hash.sh.Cc David Howells <[email protected]>Cc David Woodhouse <[email protected]>Cc Eric Snowberg <[email protected]>Cc Jarkko Sakkinen <[email protected]>Signed-off-by Mickaël Salaün <[email protected]>---
Changes since v6:
* Rebase on keys-cve-2020-26541-v3: commitebd9c2ae369a("integrity:
Load mokx variables into the blacklist keyring").Changes since v5:
* Rebase on keys-next, fixKconfigconflict, and update the asymmetric key rights added to the blacklist keyring by the newadd_key_to_revocation_list(): align with blacklist key rights by removingKEY_POS_WRITEas a safeguard, and addKEY_ALLOC_BYPASS_RESTRICTIONto not be subject torestrict_link_for_blacklist()that only allows blacklist key types to be added to the keyring.
* Change the return code forrestrict_link_for_blacklist()from-EPERMto-EOPNOTSUPPto align with asymmetric key keyrings.Changes since v3:
* Update commit message forprint-cert-tbs-hash.sh.Changes since v2:
* Add comment forblacklist_key_instantiate().--- certs/Kconfig | 10 +++++ certs/blacklist.c | 96 ++++++++++++++++++++++++++++++++++++----------- 2 files changed, 85 insertions(+), 21 deletions(-)certs/Kconfig +10
-0@@ -103,4 +103,14 @@ config SYSTEM_REVOCATION_KEYS containing X.509 certificates to be included in the default blacklist keyring. +config SYSTEM_BLACKLIST_AUTH_UPDATE + bool "Allow root to add signed blacklist keys" + depends on SYSTEM_BLACKLIST_KEYRING + depends on SYSTEM_DATA_VERIFICATION + help + If set, provide the ability to load new blacklist keys at run time if + they are signed and vouched by a certificate from the builtin trusted + keyring. The PKCS#7 signature of the description is set in the key + payload. Blacklist keys cannot be removed. + endmenucerts/blacklist.c +61
-16@@ -15,6 +15,7 @@#include <linux/err.h> #include <linux/seq_file.h> #include <linux/uidgid.h> +#include <linux/verification.h> #include <keys/system_keyring.h> #include "blacklist.h" #include "common.h" @@ -26,6 +27,9 @@*/ #define MAX_HASH_LEN 128 +#define BLACKLIST_KEY_PERM (KEY_POS_SEARCH | KEY_POS_VIEW | \ + KEY_USR_SEARCH | KEY_USR_VIEW) +static const char tbs_prefix[] ="tbs" ;static const char bin_prefix[] ="bin" ;@@ -80,19 +84,51 @@ static int blacklist_vet_description(const char *desc)return 0 ; } -/* -* The hash to be blacklisted is expected to be in the description. There will -* be no payload. -*/ -static int blacklist_preparse (struct key_preparsed_payload *prep) +static int blacklist_key_instantiate (struct key *key, +struct key_preparsed_payload *prep) { -if (prep->datalen >0 ) -return -EINVAL ; -return 0 ; +#ifdef CONFIG_SYSTEM_BLACKLIST_AUTH_UPDATE +int err; +#endif + +/* Sets safe default permissions for keys loaded by user space. */ + key->perm =BLACKLIST_KEY_PERM ; + +/* +* Skips the authentication step for builtin hashes, they are not +* signed but still trusted. +*/ +if (key->flags & (1 <<KEY_FLAG_BUILTIN )) + goto out; + +#ifdef CONFIG_SYSTEM_BLACKLIST_AUTH_UPDATE +/* +* Verifies the description's PKCS#7 signature against the builtin +* trusted keyring. +*/ + err =verify_pkcs7_signature (key->description, +strlen (key->description), prep->data, prep->datalen, +NULL ,VERIFYING_UNSPECIFIED_SIGNATURE ,NULL ,NULL ); +if (err) +return err; +#else +/* +* It should not be possible to come here because the keyring doesn't +* have KEY_USR_WRITE and the only other way to call this function is +* for builtin hashes. +*/ +WARN_ON_ONCE (1 ); +return -EPERM ; +#endif + +out: +return generic_key_instantiate (key, prep); } -static void blacklist_free_preparse (struct key_preparsed_payload *prep) +static int blacklist_key_update (struct key *key, +struct key_preparsed_payload *prep) { +return -EPERM ; }static void blacklist_describe (const struct key *key,struct seq_file *m)@@ -103,9 +139,8 @@ static void blacklist_describe(const struct key *key, struct seq_file *m)static struct key_type key_type_blacklist = { .name ="blacklist" , .vet_description = blacklist_vet_description, - .preparse = blacklist_preparse, - .free_preparse = blacklist_free_preparse, - .instantiate = generic_key_instantiate, + .instantiate = blacklist_key_instantiate, + .update = blacklist_key_update, .describe = blacklist_describe, };@@ -154,8 +189,7 @@ static int mark_raw_hash_blacklisted(const char *hash) hash,NULL ,0 , - ((KEY_POS_ALL & ~KEY_POS_SETATTR ) | -KEY_USR_VIEW ), +BLACKLIST_KEY_PERM ,KEY_ALLOC_NOT_IN_QUOTA | KEY_ALLOC_BUILT_IN);if (IS_ERR (key)) {@@ -232,8 +266,10 @@ int add_key_to_revocation_list(const char *data, size_t size)NULL , data, size, - ((KEY_POS_ALL & ~KEY_POS_SETATTR ) |KEY_USR_VIEW ), - KEY_ALLOC_NOT_IN_QUOTA | KEY_ALLOC_BUILT_IN); +KEY_POS_VIEW |KEY_POS_READ |KEY_POS_SEARCH + |KEY_USR_VIEW , +KEY_ALLOC_NOT_IN_QUOTA |KEY_ALLOC_BUILT_IN + | KEY_ALLOC_BYPASS_RESTRICTION);if (IS_ERR (key)) {pr_err ("Problem with revocation key (%ld)\n" ,PTR_ERR (key));@@ -260,25 +296,43 @@ int is_key_on_revocation_list(struct pkcs7_message *pkcs7) }#endif +static int restrict_link_for_blacklist (struct key *dest_keyring, +const struct key_type *type,const union key_payload *payload, +struct key *restrict_key) +{ +if (type == &key_type_blacklist) +return 0 ; +return -EOPNOTSUPP ; +} +/* * Initialise the blacklist certs/blacklist.c int is_key_on_revocation_list(struct pkcs7_message *pkcs7) · line 318
Quoted 10 lines
certs/blacklist.c +4
-0*/ static int __init blacklist_init (void ) {const char *const *bl; +struct key_restriction *restriction;if (register_key_type (&key_type_blacklist) <0 )panic ("Can't allocate system blacklist key type\n" ); + restriction =kzalloc (sizeof (*restriction),GFP_KERNEL ); +if (!restriction) +panic ("Can't allocate blacklist keyring restriction\n" );This prevents me from taking this to my pull request. In moderns standards, no new
BUG_ON(),panic()etc. should never added to the kernel.I missed this in my review.
This should rather be e.g.
restriction = kzalloc(sizeof(*restriction), GFP_KERNEL); if (!restriction) { pr_err("Can't allocate blacklist keyring restriction\n"); return 0; }Quoted 8 lines
Quoted 2 lines
Unfortunately I need to drop this patch set, because adding new
panic()is simply a no-go.I agree that
panic()is not great in general, but I followed the other part of the code (just above) that do the same. This part of the kernel should failed if critical memory allocation failed at boot time (only). It doesn't impact the kernel once it is running. I don't think that just ignoring this error with return 0 is fine, after all it's a critical error right?Quoted 3 lines
It's not good reason enough to crash the whole kernel, even if it is a critical error (e.g. run-time foresincs). Even
WARN()is not recommended these days [*].I think that what Greg said in this email is that WARN*() should only be used for cases that should never happen, it is definitely not deprecated, but
WARN_ON_ONCE()may be a better idea though. WARN*() helps detect such thought-to-be-impossible cases, that can happen e.g. with code refactoring.
Quoted 5 lines
A lot of initialization/boot code (e.g. without user space nor external interactions, mostly
__initfunctions) do panic if there is unexpected and unrecoverable errors like failed memory allocations. I think handling such errors otherwise would be more complex for no benefit. Moreover, delegating such error handling to user space could create new (silent) issues.
To crash the whole kernel, you should be able to clearly explain why it makes sense in the situation.
Quoted 8 lines
Quoted 5 lines
For the existing panic()-statements: I'm happy to review patches that render them out. >
Not sure tho, if this fails should it be then "everything blacklisted". Just one thing to consider.Well, if it fail it will be "nothing will work afterwards". Do you have a working and useful scenario for this kind of error?
So you have zero chances to get a shell without blacklist just to do kernel forensics?
BR, Jarkko
Re: [PATCH v8 5/5] certs: Allow root user to append signed hashes to the blacklist keyring
Quoted 253 lines · Jarkko Sakkinen
Quoted 252 lines · Mickaël Salaün
Quoted 241 lines · Jarkko Sakkinen
Quoted 231 lines · Mickaël Salaün
Quoted 229 lines · Jarkko Sakkinen
Quoted 203 lines · Mickaël Salaün
From: Mickaël Salaün <[email protected]>
Add a kernel option
SYSTEM_BLACKLIST_AUTH_UPDATEto enable the root user to dynamically add new keys to the blacklist keyring. This enables to invalidate new certificates, either from being loaded in a keyring, or from being trusted in a PKCS#7 certificate chain. This also enables to add new file hashes to be denied by the integrity infrastructure.Being able to untrust a certificate which could have normaly been trusted is a sensitive operation. This is why adding new hashes to the blacklist keyring is only allowed when these hashes are signed and vouched by the builtin trusted keyring. A blacklist hash is stored as a key description. The PKCS#7 signature of this description must be provided as the key payload.
Marking a certificate as untrusted should be enforced while the system is running. It is then forbiden to remove such blacklist keys.
Update blacklist keyring, blacklist key and revoked certificate access rights:
* allows the root user to search for a specific blacklisted hash, whichmake sense because the descriptions are already viewable;* forbids key update (blacklist and asymmetric ones);
* restricts kernel rights on the blacklist keyring to align with the root user rights.See help in
tools/certs/print-cert-tbs-hash.sh.Cc David Howells <[email protected]>Cc David Woodhouse <[email protected]>Cc Eric Snowberg <[email protected]>Cc Jarkko Sakkinen <[email protected]>Signed-off-by Mickaël Salaün <[email protected]>---
Changes since v6:
* Rebase on keys-cve-2020-26541-v3: commitebd9c2ae369a("integrity:
Load mokx variables into the blacklist keyring").Changes since v5:
* Rebase on keys-next, fixKconfigconflict, and update the asymmetric key rights added to the blacklist keyring by the newadd_key_to_revocation_list(): align with blacklist key rights by removingKEY_POS_WRITEas a safeguard, and addKEY_ALLOC_BYPASS_RESTRICTIONto not be subject torestrict_link_for_blacklist()that only allows blacklist key types to be added to the keyring.
* Change the return code forrestrict_link_for_blacklist()from-EPERMto-EOPNOTSUPPto align with asymmetric key keyrings.Changes since v3:
* Update commit message forprint-cert-tbs-hash.sh.Changes since v2:
* Add comment forblacklist_key_instantiate().--- certs/Kconfig | 10 +++++ certs/blacklist.c | 96 ++++++++++++++++++++++++++++++++++++----------- 2 files changed, 85 insertions(+), 21 deletions(-)certs/Kconfig +10
-0@@ -103,4 +103,14 @@ config SYSTEM_REVOCATION_KEYS containing X.509 certificates to be included in the default blacklist keyring. +config SYSTEM_BLACKLIST_AUTH_UPDATE + bool "Allow root to add signed blacklist keys" + depends on SYSTEM_BLACKLIST_KEYRING + depends on SYSTEM_DATA_VERIFICATION + help + If set, provide the ability to load new blacklist keys at run time if + they are signed and vouched by a certificate from the builtin trusted + keyring. The PKCS#7 signature of the description is set in the key + payload. Blacklist keys cannot be removed. + endmenucerts/blacklist.c +61
-16@@ -15,6 +15,7 @@#include <linux/err.h> #include <linux/seq_file.h> #include <linux/uidgid.h> +#include <linux/verification.h> #include <keys/system_keyring.h> #include "blacklist.h" #include "common.h" @@ -26,6 +27,9 @@*/ #define MAX_HASH_LEN 128 +#define BLACKLIST_KEY_PERM (KEY_POS_SEARCH | KEY_POS_VIEW | \ + KEY_USR_SEARCH | KEY_USR_VIEW) +static const char tbs_prefix[] ="tbs" ;static const char bin_prefix[] ="bin" ;@@ -80,19 +84,51 @@ static int blacklist_vet_description(const char *desc)return 0 ; } -/* -* The hash to be blacklisted is expected to be in the description. There will -* be no payload. -*/ -static int blacklist_preparse (struct key_preparsed_payload *prep) +static int blacklist_key_instantiate (struct key *key, +struct key_preparsed_payload *prep) { -if (prep->datalen >0 ) -return -EINVAL ; -return 0 ; +#ifdef CONFIG_SYSTEM_BLACKLIST_AUTH_UPDATE +int err; +#endif + +/* Sets safe default permissions for keys loaded by user space. */ + key->perm =BLACKLIST_KEY_PERM ; + +/* +* Skips the authentication step for builtin hashes, they are not +* signed but still trusted. +*/ +if (key->flags & (1 <<KEY_FLAG_BUILTIN )) + goto out; + +#ifdef CONFIG_SYSTEM_BLACKLIST_AUTH_UPDATE +/* +* Verifies the description's PKCS#7 signature against the builtin +* trusted keyring. +*/ + err =verify_pkcs7_signature (key->description, +strlen (key->description), prep->data, prep->datalen, +NULL ,VERIFYING_UNSPECIFIED_SIGNATURE ,NULL ,NULL ); +if (err) +return err; +#else +/* +* It should not be possible to come here because the keyring doesn't +* have KEY_USR_WRITE and the only other way to call this function is +* for builtin hashes. +*/ +WARN_ON_ONCE (1 ); +return -EPERM ; +#endif + +out: +return generic_key_instantiate (key, prep); } -static void blacklist_free_preparse (struct key_preparsed_payload *prep) +static int blacklist_key_update (struct key *key, +struct key_preparsed_payload *prep) { +return -EPERM ; }static void blacklist_describe (const struct key *key,struct seq_file *m)@@ -103,9 +139,8 @@ static void blacklist_describe(const struct key *key, struct seq_file *m)static struct key_type key_type_blacklist = { .name ="blacklist" , .vet_description = blacklist_vet_description, - .preparse = blacklist_preparse, - .free_preparse = blacklist_free_preparse, - .instantiate = generic_key_instantiate, + .instantiate = blacklist_key_instantiate, + .update = blacklist_key_update, .describe = blacklist_describe, };@@ -154,8 +189,7 @@ static int mark_raw_hash_blacklisted(const char *hash) hash,NULL ,0 , - ((KEY_POS_ALL & ~KEY_POS_SETATTR ) | -KEY_USR_VIEW ), +BLACKLIST_KEY_PERM ,KEY_ALLOC_NOT_IN_QUOTA | KEY_ALLOC_BUILT_IN);if (IS_ERR (key)) {@@ -232,8 +266,10 @@ int add_key_to_revocation_list(const char *data, size_t size)NULL , data, size, - ((KEY_POS_ALL & ~KEY_POS_SETATTR ) |KEY_USR_VIEW ), - KEY_ALLOC_NOT_IN_QUOTA | KEY_ALLOC_BUILT_IN); +KEY_POS_VIEW |KEY_POS_READ |KEY_POS_SEARCH + |KEY_USR_VIEW , +KEY_ALLOC_NOT_IN_QUOTA |KEY_ALLOC_BUILT_IN + | KEY_ALLOC_BYPASS_RESTRICTION);if (IS_ERR (key)) {pr_err ("Problem with revocation key (%ld)\n" ,PTR_ERR (key));@@ -260,25 +296,43 @@ int is_key_on_revocation_list(struct pkcs7_message *pkcs7) }#endif +static int restrict_link_for_blacklist (struct key *dest_keyring, +const struct key_type *type,const union key_payload *payload, +struct key *restrict_key) +{ +if (type == &key_type_blacklist) +return 0 ; +return -EOPNOTSUPP ; +} +/* * Initialise the blacklist certs/blacklist.c int is_key_on_revocation_list(struct pkcs7_message *pkcs7) · line 318
Quoted 10 lines
certs/blacklist.c +4
-0*/ static int __init blacklist_init (void ) {const char *const *bl; +struct key_restriction *restriction;if (register_key_type (&key_type_blacklist) <0 )panic ("Can't allocate system blacklist key type\n" ); + restriction =kzalloc (sizeof (*restriction),GFP_KERNEL ); +if (!restriction) +panic ("Can't allocate blacklist keyring restriction\n" );This prevents me from taking this to my pull request. In moderns standards, no new
BUG_ON(),panic()etc. should never added to the kernel.I missed this in my review.
This should rather be e.g.
restriction = kzalloc(sizeof(*restriction), GFP_KERNEL); if (!restriction) { pr_err("Can't allocate blacklist keyring restriction\n"); return 0; }Quoted 8 lines
Quoted 2 lines
Unfortunately I need to drop this patch set, because adding new
panic()is simply a no-go.I agree that
panic()is not great in general, but I followed the other part of the code (just above) that do the same. This part of the kernel should failed if critical memory allocation failed at boot time (only). It doesn't impact the kernel once it is running. I don't think that just ignoring this error with return 0 is fine, after all it's a critical error right?Quoted 3 lines
It's not good reason enough to crash the whole kernel, even if it is a critical error (e.g. run-time foresincs). Even
WARN()is not recommended these days [*].I think that what Greg said in this email is that WARN*() should only be used for cases that should never happen, it is definitely not deprecated, but
WARN_ON_ONCE()may be a better idea though. WARN*() helps detect such thought-to-be-impossible cases, that can happen e.g. with code refactoring.
Quoted 8 lines
Quoted 5 lines
A lot of initialization/boot code (e.g. without user space nor external interactions, mostly
__initfunctions) do panic if there is unexpected and unrecoverable errors like failed memory allocations. I think handling such errors otherwise would be more complex for no benefit. Moreover, delegating such error handling to user space could create new (silent) issues.To crash the whole kernel, you should be able to clearly explain why it makes sense in the situation.
If there is no enough memory to allocate 24 bytes (struct key_restriction) during early boot, I really doubt the kernel can do much.
Quoted 7 lines
Quoted 7 lines
Quoted 6 lines
For the existing panic()-statements: I'm happy to review patches that render them out. >
Not sure tho, if this fails should it be then "everything blacklisted". Just one thing to consider.
Quoted 5 lines
Quoted 2 lines
Well, if it fail it will be "nothing will work afterwards". Do you have a working and useful scenario for this kind of error?
So you have zero chances to get a shell without blacklist just to do kernel forensics?
Right, I don't think the kernel can launch any process (nor continue early boot) if it cannot allocate 24 bytes.
Jarkko Sakkinen
maintainerRe: [PATCH v8 5/5] certs: Allow root user to append signed hashes to the blacklist keyring
Quoted 274 lines · Mickaël Salaün
Quoted 253 lines · Jarkko Sakkinen
Quoted 252 lines · Mickaël Salaün
Quoted 241 lines · Jarkko Sakkinen
Quoted 231 lines · Mickaël Salaün
Quoted 229 lines · Jarkko Sakkinen
Quoted 203 lines · Mickaël Salaün
From: Mickaël Salaün <[email protected]>
Add a kernel option
SYSTEM_BLACKLIST_AUTH_UPDATEto enable the root user to dynamically add new keys to the blacklist keyring. This enables to invalidate new certificates, either from being loaded in a keyring, or from being trusted in a PKCS#7 certificate chain. This also enables to add new file hashes to be denied by the integrity infrastructure.Being able to untrust a certificate which could have normaly been trusted is a sensitive operation. This is why adding new hashes to the blacklist keyring is only allowed when these hashes are signed and vouched by the builtin trusted keyring. A blacklist hash is stored as a key description. The PKCS#7 signature of this description must be provided as the key payload.
Marking a certificate as untrusted should be enforced while the system is running. It is then forbiden to remove such blacklist keys.
Update blacklist keyring, blacklist key and revoked certificate access rights:
* allows the root user to search for a specific blacklisted hash, whichmake sense because the descriptions are already viewable;* forbids key update (blacklist and asymmetric ones);
* restricts kernel rights on the blacklist keyring to align with the root user rights.See help in
tools/certs/print-cert-tbs-hash.sh.Cc David Howells <[email protected]>Cc David Woodhouse <[email protected]>Cc Eric Snowberg <[email protected]>Cc Jarkko Sakkinen <[email protected]>Signed-off-by Mickaël Salaün <[email protected]>---
Changes since v6:
* Rebase on keys-cve-2020-26541-v3: commitebd9c2ae369a("integrity:
Load mokx variables into the blacklist keyring").Changes since v5:
* Rebase on keys-next, fixKconfigconflict, and update the asymmetric key rights added to the blacklist keyring by the newadd_key_to_revocation_list(): align with blacklist key rights by removingKEY_POS_WRITEas a safeguard, and addKEY_ALLOC_BYPASS_RESTRICTIONto not be subject torestrict_link_for_blacklist()that only allows blacklist key types to be added to the keyring.
* Change the return code forrestrict_link_for_blacklist()from-EPERMto-EOPNOTSUPPto align with asymmetric key keyrings.Changes since v3:
* Update commit message forprint-cert-tbs-hash.sh.Changes since v2:
* Add comment forblacklist_key_instantiate().--- certs/Kconfig | 10 +++++ certs/blacklist.c | 96 ++++++++++++++++++++++++++++++++++++----------- 2 files changed, 85 insertions(+), 21 deletions(-)certs/Kconfig +10
-0@@ -103,4 +103,14 @@ config SYSTEM_REVOCATION_KEYS containing X.509 certificates to be included in the default blacklist keyring. +config SYSTEM_BLACKLIST_AUTH_UPDATE + bool "Allow root to add signed blacklist keys" + depends on SYSTEM_BLACKLIST_KEYRING + depends on SYSTEM_DATA_VERIFICATION + help + If set, provide the ability to load new blacklist keys at run time if + they are signed and vouched by a certificate from the builtin trusted + keyring. The PKCS#7 signature of the description is set in the key + payload. Blacklist keys cannot be removed. + endmenucerts/blacklist.c +61
-16@@ -15,6 +15,7 @@#include <linux/err.h> #include <linux/seq_file.h> #include <linux/uidgid.h> +#include <linux/verification.h> #include <keys/system_keyring.h> #include "blacklist.h" #include "common.h" @@ -26,6 +27,9 @@*/ #define MAX_HASH_LEN 128 +#define BLACKLIST_KEY_PERM (KEY_POS_SEARCH | KEY_POS_VIEW | \ + KEY_USR_SEARCH | KEY_USR_VIEW) +static const char tbs_prefix[] ="tbs" ;static const char bin_prefix[] ="bin" ;@@ -80,19 +84,51 @@ static int blacklist_vet_description(const char *desc)return 0 ; } -/* -* The hash to be blacklisted is expected to be in the description. There will -* be no payload. -*/ -static int blacklist_preparse (struct key_preparsed_payload *prep) +static int blacklist_key_instantiate (struct key *key, +struct key_preparsed_payload *prep) { -if (prep->datalen >0 ) -return -EINVAL ; -return 0 ; +#ifdef CONFIG_SYSTEM_BLACKLIST_AUTH_UPDATE +int err; +#endif + +/* Sets safe default permissions for keys loaded by user space. */ + key->perm =BLACKLIST_KEY_PERM ; + +/* +* Skips the authentication step for builtin hashes, they are not +* signed but still trusted. +*/ +if (key->flags & (1 <<KEY_FLAG_BUILTIN )) + goto out; + +#ifdef CONFIG_SYSTEM_BLACKLIST_AUTH_UPDATE +/* +* Verifies the description's PKCS#7 signature against the builtin +* trusted keyring. +*/ + err =verify_pkcs7_signature (key->description, +strlen (key->description), prep->data, prep->datalen, +NULL ,VERIFYING_UNSPECIFIED_SIGNATURE ,NULL ,NULL ); +if (err) +return err; +#else +/* +* It should not be possible to come here because the keyring doesn't +* have KEY_USR_WRITE and the only other way to call this function is +* for builtin hashes. +*/ +WARN_ON_ONCE (1 ); +return -EPERM ; +#endif + +out: +return generic_key_instantiate (key, prep); } -static void blacklist_free_preparse (struct key_preparsed_payload *prep) +static int blacklist_key_update (struct key *key, +struct key_preparsed_payload *prep) { +return -EPERM ; }static void blacklist_describe (const struct key *key,struct seq_file *m)@@ -103,9 +139,8 @@ static void blacklist_describe(const struct key *key, struct seq_file *m)static struct key_type key_type_blacklist = { .name ="blacklist" , .vet_description = blacklist_vet_description, - .preparse = blacklist_preparse, - .free_preparse = blacklist_free_preparse, - .instantiate = generic_key_instantiate, + .instantiate = blacklist_key_instantiate, + .update = blacklist_key_update, .describe = blacklist_describe, };@@ -154,8 +189,7 @@ static int mark_raw_hash_blacklisted(const char *hash) hash,NULL ,0 , - ((KEY_POS_ALL & ~KEY_POS_SETATTR ) | -KEY_USR_VIEW ), +BLACKLIST_KEY_PERM ,KEY_ALLOC_NOT_IN_QUOTA | KEY_ALLOC_BUILT_IN);if (IS_ERR (key)) {@@ -232,8 +266,10 @@ int add_key_to_revocation_list(const char *data, size_t size)NULL , data, size, - ((KEY_POS_ALL & ~KEY_POS_SETATTR ) |KEY_USR_VIEW ), - KEY_ALLOC_NOT_IN_QUOTA | KEY_ALLOC_BUILT_IN); +KEY_POS_VIEW |KEY_POS_READ |KEY_POS_SEARCH + |KEY_USR_VIEW , +KEY_ALLOC_NOT_IN_QUOTA |KEY_ALLOC_BUILT_IN + | KEY_ALLOC_BYPASS_RESTRICTION);if (IS_ERR (key)) {pr_err ("Problem with revocation key (%ld)\n" ,PTR_ERR (key));@@ -260,25 +296,43 @@ int is_key_on_revocation_list(struct pkcs7_message *pkcs7) }#endif +static int restrict_link_for_blacklist (struct key *dest_keyring, +const struct key_type *type,const union key_payload *payload, +struct key *restrict_key) +{ +if (type == &key_type_blacklist) +return 0 ; +return -EOPNOTSUPP ; +} +/* * Initialise the blacklist certs/blacklist.c int is_key_on_revocation_list(struct pkcs7_message *pkcs7) · line 318
Quoted 10 lines
certs/blacklist.c +4
-0*/ static int __init blacklist_init (void ) {const char *const *bl; +struct key_restriction *restriction;if (register_key_type (&key_type_blacklist) <0 )panic ("Can't allocate system blacklist key type\n" ); + restriction =kzalloc (sizeof (*restriction),GFP_KERNEL ); +if (!restriction) +panic ("Can't allocate blacklist keyring restriction\n" );This prevents me from taking this to my pull request. In moderns standards, no new
BUG_ON(),panic()etc. should never added to the kernel.I missed this in my review.
This should rather be e.g.
restriction = kzalloc(sizeof(*restriction), GFP_KERNEL); if (!restriction) { pr_err("Can't allocate blacklist keyring restriction\n"); return 0; }Quoted 8 lines
Quoted 2 lines
Unfortunately I need to drop this patch set, because adding new
panic()is simply a no-go.I agree that
panic()is not great in general, but I followed the other part of the code (just above) that do the same. This part of the kernel should failed if critical memory allocation failed at boot time (only). It doesn't impact the kernel once it is running. I don't think that just ignoring this error with return 0 is fine, after all it's a critical error right?Quoted 3 lines
It's not good reason enough to crash the whole kernel, even if it is a critical error (e.g. run-time foresincs). Even
WARN()is not recommended these days [*].I think that what Greg said in this email is that WARN*() should only be used for cases that should never happen, it is definitely not deprecated, but
WARN_ON_ONCE()may be a better idea though. WARN*() helps detect such thought-to-be-impossible cases, that can happen e.g. with code refactoring.Quoted 8 lines
Quoted 5 lines
A lot of initialization/boot code (e.g. without user space nor external interactions, mostly
__initfunctions) do panic if there is unexpected and unrecoverable errors like failed memory allocations. I think handling such errors otherwise would be more complex for no benefit. Moreover, delegating such error handling to user space could create new (silent) issues.To crash the whole kernel, you should be able to clearly explain why it makes sense in the situation.
If there is no enough memory to allocate 24 bytes (struct
key_restriction) during early boot, I really doubt the kernel can do much.Quoted 7 lines
Quoted 7 lines
Quoted 6 lines
For the existing panic()-statements: I'm happy to review patches that render them out. >
Not sure tho, if this fails should it be then "everything blacklisted". Just one thing to consider.
Quoted 8 lines
Quoted 5 lines
Quoted 2 lines
Well, if it fail it will be "nothing will work afterwards". Do you have a working and useful scenario for this kind of error?
So you have zero chances to get a shell without blacklist just to do kernel forensics?
Right, I don't think the kernel can launch any process (nor continue early boot) if it cannot allocate 24 bytes.
initcall is just wrong layer to choose to crash the kernel. It should be either do_initcall_level() or do_one_initcall() that should care about this (or not care). You can print error message and return -ENODEV;
BR, Jarkko
Re: [PATCH v8 5/5] certs: Allow root user to append signed hashes to the blacklist keyring
Quoted 281 lines · Jarkko Sakkinen
Quoted 280 lines · Mickaël Salaün
Quoted 253 lines · Jarkko Sakkinen
Quoted 252 lines · Mickaël Salaün
Quoted 241 lines · Jarkko Sakkinen
Quoted 231 lines · Mickaël Salaün
Quoted 229 lines · Jarkko Sakkinen
Quoted 203 lines · Mickaël Salaün
From: Mickaël Salaün <[email protected]>
Add a kernel option
SYSTEM_BLACKLIST_AUTH_UPDATEto enable the root user to dynamically add new keys to the blacklist keyring. This enables to invalidate new certificates, either from being loaded in a keyring, or from being trusted in a PKCS#7 certificate chain. This also enables to add new file hashes to be denied by the integrity infrastructure.Being able to untrust a certificate which could have normaly been trusted is a sensitive operation. This is why adding new hashes to the blacklist keyring is only allowed when these hashes are signed and vouched by the builtin trusted keyring. A blacklist hash is stored as a key description. The PKCS#7 signature of this description must be provided as the key payload.
Marking a certificate as untrusted should be enforced while the system is running. It is then forbiden to remove such blacklist keys.
Update blacklist keyring, blacklist key and revoked certificate access rights:
* allows the root user to search for a specific blacklisted hash, whichmake sense because the descriptions are already viewable;* forbids key update (blacklist and asymmetric ones);
* restricts kernel rights on the blacklist keyring to align with the root user rights.See help in
tools/certs/print-cert-tbs-hash.sh.Cc David Howells <[email protected]>Cc David Woodhouse <[email protected]>Cc Eric Snowberg <[email protected]>Cc Jarkko Sakkinen <[email protected]>Signed-off-by Mickaël Salaün <[email protected]>---
Changes since v6:
* Rebase on keys-cve-2020-26541-v3: commitebd9c2ae369a("integrity:
Load mokx variables into the blacklist keyring").Changes since v5:
* Rebase on keys-next, fixKconfigconflict, and update the asymmetric key rights added to the blacklist keyring by the newadd_key_to_revocation_list(): align with blacklist key rights by removingKEY_POS_WRITEas a safeguard, and addKEY_ALLOC_BYPASS_RESTRICTIONto not be subject torestrict_link_for_blacklist()that only allows blacklist key types to be added to the keyring.
* Change the return code forrestrict_link_for_blacklist()from-EPERMto-EOPNOTSUPPto align with asymmetric key keyrings.Changes since v3:
* Update commit message forprint-cert-tbs-hash.sh.Changes since v2:
* Add comment forblacklist_key_instantiate().--- certs/Kconfig | 10 +++++ certs/blacklist.c | 96 ++++++++++++++++++++++++++++++++++++----------- 2 files changed, 85 insertions(+), 21 deletions(-)certs/Kconfig +10
-0@@ -103,4 +103,14 @@ config SYSTEM_REVOCATION_KEYS containing X.509 certificates to be included in the default blacklist keyring. +config SYSTEM_BLACKLIST_AUTH_UPDATE + bool "Allow root to add signed blacklist keys" + depends on SYSTEM_BLACKLIST_KEYRING + depends on SYSTEM_DATA_VERIFICATION + help + If set, provide the ability to load new blacklist keys at run time if + they are signed and vouched by a certificate from the builtin trusted + keyring. The PKCS#7 signature of the description is set in the key + payload. Blacklist keys cannot be removed. + endmenucerts/blacklist.c +61
-16@@ -15,6 +15,7 @@#include <linux/err.h> #include <linux/seq_file.h> #include <linux/uidgid.h> +#include <linux/verification.h> #include <keys/system_keyring.h> #include "blacklist.h" #include "common.h" @@ -26,6 +27,9 @@*/ #define MAX_HASH_LEN 128 +#define BLACKLIST_KEY_PERM (KEY_POS_SEARCH | KEY_POS_VIEW | \ + KEY_USR_SEARCH | KEY_USR_VIEW) +static const char tbs_prefix[] ="tbs" ;static const char bin_prefix[] ="bin" ;@@ -80,19 +84,51 @@ static int blacklist_vet_description(const char *desc)return 0 ; } -/* -* The hash to be blacklisted is expected to be in the description. There will -* be no payload. -*/ -static int blacklist_preparse (struct key_preparsed_payload *prep) +static int blacklist_key_instantiate (struct key *key, +struct key_preparsed_payload *prep) { -if (prep->datalen >0 ) -return -EINVAL ; -return 0 ; +#ifdef CONFIG_SYSTEM_BLACKLIST_AUTH_UPDATE +int err; +#endif + +/* Sets safe default permissions for keys loaded by user space. */ + key->perm =BLACKLIST_KEY_PERM ; + +/* +* Skips the authentication step for builtin hashes, they are not +* signed but still trusted. +*/ +if (key->flags & (1 <<KEY_FLAG_BUILTIN )) + goto out; + +#ifdef CONFIG_SYSTEM_BLACKLIST_AUTH_UPDATE +/* +* Verifies the description's PKCS#7 signature against the builtin +* trusted keyring. +*/ + err =verify_pkcs7_signature (key->description, +strlen (key->description), prep->data, prep->datalen, +NULL ,VERIFYING_UNSPECIFIED_SIGNATURE ,NULL ,NULL ); +if (err) +return err; +#else +/* +* It should not be possible to come here because the keyring doesn't +* have KEY_USR_WRITE and the only other way to call this function is +* for builtin hashes. +*/ +WARN_ON_ONCE (1 ); +return -EPERM ; +#endif + +out: +return generic_key_instantiate (key, prep); } -static void blacklist_free_preparse (struct key_preparsed_payload *prep) +static int blacklist_key_update (struct key *key, +struct key_preparsed_payload *prep) { +return -EPERM ; }static void blacklist_describe (const struct key *key,struct seq_file *m)@@ -103,9 +139,8 @@ static void blacklist_describe(const struct key *key, struct seq_file *m)static struct key_type key_type_blacklist = { .name ="blacklist" , .vet_description = blacklist_vet_description, - .preparse = blacklist_preparse, - .free_preparse = blacklist_free_preparse, - .instantiate = generic_key_instantiate, + .instantiate = blacklist_key_instantiate, + .update = blacklist_key_update, .describe = blacklist_describe, };@@ -154,8 +189,7 @@ static int mark_raw_hash_blacklisted(const char *hash) hash,NULL ,0 , - ((KEY_POS_ALL & ~KEY_POS_SETATTR ) | -KEY_USR_VIEW ), +BLACKLIST_KEY_PERM ,KEY_ALLOC_NOT_IN_QUOTA | KEY_ALLOC_BUILT_IN);if (IS_ERR (key)) {@@ -232,8 +266,10 @@ int add_key_to_revocation_list(const char *data, size_t size)NULL , data, size, - ((KEY_POS_ALL & ~KEY_POS_SETATTR ) |KEY_USR_VIEW ), - KEY_ALLOC_NOT_IN_QUOTA | KEY_ALLOC_BUILT_IN); +KEY_POS_VIEW |KEY_POS_READ |KEY_POS_SEARCH + |KEY_USR_VIEW , +KEY_ALLOC_NOT_IN_QUOTA |KEY_ALLOC_BUILT_IN + | KEY_ALLOC_BYPASS_RESTRICTION);if (IS_ERR (key)) {pr_err ("Problem with revocation key (%ld)\n" ,PTR_ERR (key));@@ -260,25 +296,43 @@ int is_key_on_revocation_list(struct pkcs7_message *pkcs7) }#endif +static int restrict_link_for_blacklist (struct key *dest_keyring, +const struct key_type *type,const union key_payload *payload, +struct key *restrict_key) +{ +if (type == &key_type_blacklist) +return 0 ; +return -EOPNOTSUPP ; +} +/* * Initialise the blacklist certs/blacklist.c int is_key_on_revocation_list(struct pkcs7_message *pkcs7) · line 318
Quoted 10 lines
certs/blacklist.c +4
-0*/ static int __init blacklist_init (void ) {const char *const *bl; +struct key_restriction *restriction;if (register_key_type (&key_type_blacklist) <0 )panic ("Can't allocate system blacklist key type\n" ); + restriction =kzalloc (sizeof (*restriction),GFP_KERNEL ); +if (!restriction) +panic ("Can't allocate blacklist keyring restriction\n" );This prevents me from taking this to my pull request. In moderns standards, no new
BUG_ON(),panic()etc. should never added to the kernel.I missed this in my review.
This should rather be e.g.
restriction = kzalloc(sizeof(*restriction), GFP_KERNEL); if (!restriction) { pr_err("Can't allocate blacklist keyring restriction\n"); return 0; }Quoted 8 lines
Quoted 2 lines
Unfortunately I need to drop this patch set, because adding new
panic()is simply a no-go.I agree that
panic()is not great in general, but I followed the other part of the code (just above) that do the same. This part of the kernel should failed if critical memory allocation failed at boot time (only). It doesn't impact the kernel once it is running. I don't think that just ignoring this error with return 0 is fine, after all it's a critical error right?Quoted 3 lines
It's not good reason enough to crash the whole kernel, even if it is a critical error (e.g. run-time foresincs). Even
WARN()is not recommended these days [*].I think that what Greg said in this email is that WARN*() should only be used for cases that should never happen, it is definitely not deprecated, but
WARN_ON_ONCE()may be a better idea though. WARN*() helps detect such thought-to-be-impossible cases, that can happen e.g. with code refactoring.Quoted 8 lines
Quoted 5 lines
A lot of initialization/boot code (e.g. without user space nor external interactions, mostly
__initfunctions) do panic if there is unexpected and unrecoverable errors like failed memory allocations. I think handling such errors otherwise would be more complex for no benefit. Moreover, delegating such error handling to user space could create new (silent) issues.To crash the whole kernel, you should be able to clearly explain why it makes sense in the situation.
If there is no enough memory to allocate 24 bytes (struct
key_restriction) during early boot, I really doubt the kernel can do much.Quoted 12 lines
Quoted 9 lines
Quoted 6 lines
For the existing panic()-statements: I'm happy to review patches that render them out. >
Not sure tho, if this fails should it be then "everything blacklisted". Just one thing to consider.Well, if it fail it will be "nothing will work afterwards". Do you have a working and useful scenario for this kind of error?
So you have zero chances to get a shell without blacklist just to do kernel forensics?
Quoted 6 lines
Quoted 2 lines
Right, I don't think the kernel can launch any process (nor continue early boot) if it cannot allocate 24 bytes.
initcall is just wrong layer to choose to crash the kernel. It should be either
do_initcall_level()ordo_one_initcall()that should care about this (or not care). You can print error message and return-ENODEV;
Ok, I'll do that. Is it OK if I send you a patch fixing all panic calls from blacklist_init() and system_trusted_keyring_init() to apply after this series (with the panic call)?
Jarkko Sakkinen
maintainerRe: [PATCH v8 5/5] certs: Allow root user to append signed hashes to the blacklist keyring
Quoted 286 lines · Mickaël Salaün
Quoted 284 lines · Jarkko Sakkinen
Quoted 282 lines · Mickaël Salaün
Quoted 253 lines · Jarkko Sakkinen
Quoted 252 lines · Mickaël Salaün
Quoted 241 lines · Jarkko Sakkinen
Quoted 231 lines · Mickaël Salaün
Quoted 229 lines · Jarkko Sakkinen
Quoted 203 lines · Mickaël Salaün
From: Mickaël Salaün <[email protected]>
Add a kernel option
SYSTEM_BLACKLIST_AUTH_UPDATEto enable the root user to dynamically add new keys to the blacklist keyring. This enables to invalidate new certificates, either from being loaded in a keyring, or from being trusted in a PKCS#7 certificate chain. This also enables to add new file hashes to be denied by the integrity infrastructure.Being able to untrust a certificate which could have normaly been trusted is a sensitive operation. This is why adding new hashes to the blacklist keyring is only allowed when these hashes are signed and vouched by the builtin trusted keyring. A blacklist hash is stored as a key description. The PKCS#7 signature of this description must be provided as the key payload.
Marking a certificate as untrusted should be enforced while the system is running. It is then forbiden to remove such blacklist keys.
Update blacklist keyring, blacklist key and revoked certificate access rights:
* allows the root user to search for a specific blacklisted hash, which make sense because the descriptions are already viewable;
* forbids key update (blacklist and asymmetric ones);
* restricts kernel rights on the blacklist keyring to align with the root user rights.See help in
tools/certs/print-cert-tbs-hash.sh.Cc David Howells <[email protected]>Cc David Woodhouse <[email protected]>Cc Eric Snowberg <[email protected]>Cc Jarkko Sakkinen <[email protected]>Signed-off-by Mickaël Salaün <[email protected]>---
Changes since v6:
* Rebase on keys-cve-2020-26541-v3: commitebd9c2ae369a("integrity:
Load mokx variables into the blacklist keyring").Changes since v5:
* Rebase on keys-next, fixKconfigconflict, and update the asymmetric key rights added to the blacklist keyring by the newadd_key_to_revocation_list(): align with blacklist key rights by removingKEY_POS_WRITEas a safeguard, and addKEY_ALLOC_BYPASS_RESTRICTIONto not be subject torestrict_link_for_blacklist()that only allows blacklist key types to be added to the keyring.
* Change the return code forrestrict_link_for_blacklist()from-EPERMto-EOPNOTSUPPto align with asymmetric key keyrings.Changes since v3:
* Update commit message forprint-cert-tbs-hash.sh.Changes since v2:
* Add comment forblacklist_key_instantiate().
---
certs/Kconfig | 10 +++++
certs/blacklist.c| 96 ++++++++++++++++++++++++++++++++++++-----------2 files changed, 85 insertions(+), 21 deletions(-)certs/Kconfig +0
-0@@ -103,4 +103,14 @@ config SYSTEM_REVOCATION_KEYScontaining X.509 certificates to be included in the default blacklist keyring.
certs/Kconfig +10
-0+config SYSTEM_BLACKLIST_AUTH_UPDATE + bool "Allow root to add signed blacklist keys" + depends on SYSTEM_BLACKLIST_KEYRING + depends on SYSTEM_DATA_VERIFICATION + help + If set, provide the ability to load new blacklist keys at run time if + they are signed and vouched by a certificate from the builtin trusted + keyring. The PKCS#7 signature of the description is set in the key + payload. Blacklist keys cannot be removed. +endmenu
certs/blacklist.c +48
-14@@ -15,6 +15,7 @@ #include <linux/err.h> #include <linux/seq_file.h> #include <linux/uidgid.h> +#include <linux/verification.h> #include <keys/system_keyring.h> #include "blacklist.h" #include "common.h"@@ -26,6 +27,9 @@*/ #define MAX_HASH_LEN 128 +#define BLACKLIST_KEY_PERM (KEY_POS_SEARCH | KEY_POS_VIEW | \ + KEY_USR_SEARCH | KEY_USR_VIEW) + static const char tbs_prefix[] = "tbs"; static const char bin_prefix[] = "bin";@@ -80,19 +84,51 @@ static int blacklist_vet_description(const char *desc) return 0; } -/* -* The hash to be blacklisted is expected to be in the description. There will -* be no payload. -*/ -static int blacklist_preparse (struct key_preparsed_payload *prep) +static int blacklist_key_instantiate (struct key *key, + struct key_preparsed_payload *prep) { - if (prep->datalen > 0) - return -EINVAL; - return 0; +#ifdef CONFIG_SYSTEM_BLACKLIST_AUTH_UPDATE + int err; +#endif + + /* Sets safe default permissions for keys loaded by user space. */ + key->perm = BLACKLIST_KEY_PERM; + + /* + * Skips the authentication step for builtin hashes, they are not + * signed but still trusted. + */ + if (key->flags & (1 << KEY_FLAG_BUILTIN)) + goto out; + +#ifdef CONFIG_SYSTEM_BLACKLIST_AUTH_UPDATE + /* + * Verifies the description's PKCS#7 signature against the builtin + * trusted keyring. + */ + err = verify_pkcs7_signature(key->description, + strlen(key->description), prep->data, prep->datalen, + NULL, VERIFYING_UNSPECIFIED_SIGNATURE, NULL, NULL); + if (err) + return err; +#else + /* + * It should not be possible to come here because the keyring doesn't + * have KEY_USR_WRITE and the only other way to call this function is + * for builtin hashes. + */ + WARN_ON_ONCE(1); + return -EPERM; +#endif + +out: + return generic_key_instantiate(key, prep); } -static void blacklist_free_preparse (struct key_preparsed_payload *prep) +static int blacklist_key_update (struct key *key, + struct key_preparsed_payload *prep) { + return -EPERM; } static void blacklist_describe(const struct key *key, struct seq_file *m)@@ -103,9 +139,8 @@ static void blacklist_describe(const struct key *key, struct seq_file *m) static struct key_type key_type_blacklist = { .name = "blacklist", .vet_description = blacklist_vet_description, - .preparse = blacklist_preparse, - .free_preparse = blacklist_free_preparse, - .instantiate = generic_key_instantiate, + .instantiate = blacklist_key_instantiate, + .update = blacklist_key_update, .describe = blacklist_describe, };@@ -154,8 +189,7 @@ static int mark_raw_hash_blacklisted(const char *hash) hash, NULL, 0, - ((KEY_POS_ALL & ~KEY_POS_SETATTR) | - KEY_USR_VIEW), + BLACKLIST_KEY_PERM,
KEY_ALLOC_NOT_IN_QUOTA|KEY_ALLOC_BUILT_IN); if (IS_ERR(key)) {certs/blacklist.c +13
-2@@ -232,8 +266,10 @@ int add_key_to_revocation_list(const char *data, size_t size) NULL, data, size, - ((KEY_POS_ALL & ~KEY_POS_SETATTR) | KEY_USR_VIEW), - KEY_ALLOC_NOT_IN_QUOTA | KEY_ALLOC_BUILT_IN); + KEY_POS_VIEW | KEY_POS_READ | KEY_POS_SEARCH + | KEY_USR_VIEW, + KEY_ALLOC_NOT_IN_QUOTA | KEY_ALLOC_BUILT_IN + | KEY_ALLOC_BYPASS_RESTRICTION); if (IS_ERR(key)) { pr_err("Problem with revocation key (%ld)\n", PTR_ERR(key));@@ -260,25 +296,43 @@ int is_key_on_revocation_list(struct pkcs7_message *pkcs7) } #endif +static int restrict_link_for_blacklist (struct key *dest_keyring, + const struct key_type *type, const union key_payload *payload, + struct key *restrict_key) +{ + if (type == &key_type_blacklist) + return 0; + return -EOPNOTSUPP; +} + /** Initialise the blacklist certs/blacklist.c int is_key_on_revocation_list(struct pkcs7_message *pkcs7) · line 318
Quoted 10 lines
certs/blacklist.c +4
-0*/ static int __init blacklist_init(void) { const char *const *bl; + struct key_restriction *restriction; if (register_key_type(&key_type_blacklist) < 0) panic("Can't allocate system blacklist key type\n"); + restriction = kzalloc(sizeof(*restriction), GFP_KERNEL); + if (!restriction) + panic("Can't allocate blacklist keyring restriction\n");This prevents me from taking this to my pull request. In moderns standards, no new
BUG_ON(),panic()etc. should never added to the kernel.I missed this in my review.
This should rather be e.g.
restriction =
kzalloc(sizeof(*restriction), GFP_KERNEL); if (!restriction) {
pr_err("Can't allocate blacklist keyring restriction\n"); return 0;
}Quoted 8 lines
Quoted 2 lines
Unfortunately I need to drop this patch set, because adding new
panic()is simply a no-go.I agree that
panic()is not great in general, but I followed the other part of the code (just above) that do the same. This part of the kernel should failed if critical memory allocation failed at boot time (only). It doesn't impact the kernel once it is running. I don't think that just ignoring this error with return 0 is fine, after all it's a critical error right?Quoted 3 lines
It's not good reason enough to crash the whole kernel, even if it is a critical error (e.g. run-time foresincs). Even
WARN()is not recommended these days [*].I think that what Greg said in this email is that WARN*() should only be used for cases that should never happen, it is definitely not deprecated, but
WARN_ON_ONCE()may be a better idea though. WARN*() helps detect such thought-to-be-impossible cases, that can happen e.g. with code refactoring.Quoted 8 lines
Quoted 5 lines
A lot of initialization/boot code (e.g. without user space nor external interactions, mostly
__initfunctions) do panic if there is unexpected and unrecoverable errors like failed memory allocations. I think handling such errors otherwise would be more complex for no benefit. Moreover, delegating such error handling to user space could create new (silent) issues.To crash the whole kernel, you should be able to clearly explain why it makes sense in the situation.
If there is no enough memory to allocate 24 bytes (struct
key_restriction) during early boot, I really doubt the kernel can do much.Quoted 7 lines
Quoted 7 lines
Quoted 6 lines
For the existing panic()-statements: I'm happy to review patches that render them out. >
Not sure tho, if this fails should it be then "everything blacklisted". Just one thing to consider.Quoted 5 lines
Quoted 2 lines
Well, if it fail it will be "nothing will work afterwards". Do you have a working and useful scenario for this kind of error?
So you have zero chances to get a shell without blacklist just to do kernel forensics?
Right, I don't think the kernel can launch any process (nor continue early boot) if it cannot allocate 24 bytes.
Quoted 7 lines
Quoted 3 lines
initcall is just wrong layer to choose to crash the kernel. It should be either
do_initcall_level()ordo_one_initcall()that should care about this (or not care). You can print error message and return-ENODEV;Ok, I'll do that. Is it OK if I send you a patch fixing all panic calls from
blacklist_init()andsystem_trusted_keyring_init()to apply after this series (with the panic call)?
Yes, and I still have not sent my PR, i.e. can include this if you can provide me patches soonish (include that to the same series).
In the end of the day it comes to this: it's not a void function. ATM the framework above does not do much at all but it is IMHO going beyond the abstraction, which we should not do.
BR, Jarkko
David Howells
maintainerRe: [PATCH v8 5/5] certs: Allow root user to append signed hashes to the blacklist keyring
In reply to Jarkko SakkinenQuoted 11 lines · Jarkko Sakkinen
Quoted 11 lines
/*
* Initialise the blacklist
*/
static int__initblacklist_init(void)
{certs/blacklist.c +1
-0const char *const *bl; +struct key_restriction *restriction;if (register_key_type (&key_type_blacklist) <0 )panic ("Can't allocate system blacklist key type\n" );
Quoted 7 lines
certs/blacklist.c int is_key_on_revocation_list(struct pkcs7_message *pkcs7) · line 321
Quoted 3 lines
certs/blacklist.c +3
-0+ restriction =kzalloc (sizeof (*restriction),GFP_KERNEL ); +if (!restriction) +panic ("Can't allocate blacklist keyring restriction\n" );This prevents me from taking this to my pull request. In moderns standards, no new
BUG_ON(),panic()etc. should never added to the kernel.
I would argue that in this case, though, it is reasonable. This should only be called during kernel initialisation and, as Mickaël points out, if you can't allocate that small amount of memory, the kernel isn't going to boot much further.
Quoted 9 lines
I missed this in my review.
This should rather be e.g.
restriction = kzalloc(sizeof(*restriction), GFP_KERNEL); if (!restriction) { pr_err("Can't allocate blacklist keyring restriction\n"); return 0; }
You can't just return 0. That indicates success - but if by some miracle, the kernel actually gets to a point where userspace can happen, it could mean that we're missing the security restrictions of the blacklist.
Now, we could defer the panic to add_key_to_revocation_list(), but if you can't set in place the required security restrictions, I think it's arguable that the kernel either needs to panic or it needs to blacklist everything.
David
Hi Jarkko,
Since everyone seems OK with this and had plenty of time to complain, could you please take this patch series in your tree? It still applies on v5.16-rc5 and it is really important to us. Please let me know if you need something more.
Regards,
Mickaël
Quoted 43 lines · Mickaël Salaün
Hi,
This new patch series is a rebase on v5.14-rc1 . David or Jarkko, if it's still OK with you, could you please push this to linux-next?
I successfully tested this patch series with the 211 entries from
https://uefi.org/sites/default/files/resources/dbxupdate_x64.binThe goal of these patches is to add a new configuration option to enable the root user to load signed keys in the blacklist keyring. This keyring is useful to "untrust" certificates or files. Enabling to safely update this keyring without recompiling the kernel makes it more usable.
Previous patch series:
https://lore.kernel.org/lkml/[email protected]/Regards,
Mickaël Salaün (5):
tools/certs: Addprint-cert-tbs-hash.sh
certs: Check that builtin blacklist hashes are valid
certs: Makeblacklist_vet_description()more strict
certs: Factor out the blacklist hash creation
certs: Allow root user to append signed hashes to the blacklist
keyringMAINTAINERS | 2 + certs/.gitignore | 1 + certs/Kconfig | 17 +- certs/Makefile | 17 +- certs/blacklist.c | 218 ++++++++++++++---- crypto/asymmetric_keys/x509_public_key.c | 3 +- include/keys/system_keyring.h | 14 +- scripts/check-blacklist-hashes.awk | 37 +++ .../platform_certs/keyring_handler.c | 26 +-- tools/certs/print-cert-tbs-hash.sh | 91 ++++++++ 10 files changed, 346 insertions(+), 80 deletions(-)create mode 100755
scripts/check-blacklist-hashes.awkcreate mode 100755tools/certs/print-cert-tbs-hash.shbase-commit:
e73f0f0ee7541171d89f2e2491130c7771ba58d3
Quoted 9 lines · Mickaël Salaün
Hi Jarkko,
Since everyone seems OK with this and had plenty of time to complain, could you please take this patch series in your tree? It still applies on v5.16-rc5 and it is really important to us. Please let me know if you need something more.
Regards,
Mickaël
I'm off-work up until end of the year, i.e. I will address only important bug fixes and v5.16 up until that.
If any of the patches is yet missing my ack, feel free to
/Jarkko
Quoted 11 lines · Jarkko Sakkinen
Quoted 9 lines · Mickaël Salaün
Hi Jarkko,
Since everyone seems OK with this and had plenty of time to complain, could you please take this patch series in your tree? It still applies on v5.16-rc5 and it is really important to us. Please let me know if you need something more.
Regards,
Mickaël
Quoted 6 lines
I'm off-work up until end of the year, i.e. I will address only important bug fixes and v5.16 up until that.
If any of the patches is yet missing my ack, feel free to
Acked-by Jarkko Sakkinen <[email protected]>
Thanks Jarkko. Can you please take it into your tree?
Regards,
Mickaël
Jarkko Sakkinen
maintainerQuoted 13 lines · Mickaël Salaün
Quoted 11 lines · Jarkko Sakkinen
Quoted 9 lines · Mickaël Salaün
Hi Jarkko,
Since everyone seems OK with this and had plenty of time to complain, could you please take this patch series in your tree? It still applies on v5.16-rc5 and it is really important to us. Please let me know if you need something more.
Regards,
Mickaël
Quoted 8 lines
Quoted 6 lines
I'm off-work up until end of the year, i.e. I will address only important bug fixes and v5.16 up until that.
If any of the patches is yet missing my ack, feel free to
Acked-by Jarkko Sakkinen <[email protected]>Thanks Jarkko. Can you please take it into your tree?
I can yes, as I need to anyway do a revised PR for v5.17, as one commit in my first trial had a truncated fixes tag.
/Jarkko
Jarkko Sakkinen
maintainerQuoted 17 lines · Jarkko Sakkinen
Quoted 16 lines · Mickaël Salaün
Quoted 14 lines · Jarkko Sakkinen
Quoted 9 lines · Mickaël Salaün
Hi Jarkko,
Since everyone seems OK with this and had plenty of time to complain, could you please take this patch series in your tree? It still applies on v5.16-rc5 and it is really important to us. Please let me know if you need something more.
Regards,
MickaëlI'm off-work up until end of the year, i.e. I will address only important bug fixes and v5.16 up until that.
Quoted 8 lines
Quoted 5 lines
Quoted 3 lines
If any of the patches is yet missing my ack, feel free to
Acked-by Jarkko Sakkinen <[email protected]>Thanks Jarkko. Can you please take it into your tree?
I can yes, as I need to anyway do a revised PR for v5.17, as one commit in my first trial had a truncated fixes tag.
Please check:
git://git.kernel.org/pub/scm/linux/kernel/git/jarkko/linux-tpmdd.git
/Jarkko
Quoted 24 lines · Jarkko Sakkinen
Quoted 23 lines · Jarkko Sakkinen
Quoted 21 lines · Mickaël Salaün
Quoted 11 lines · Jarkko Sakkinen
Quoted 9 lines · Mickaël Salaün
Hi Jarkko,
Since everyone seems OK with this and had plenty of time to complain, could you please take this patch series in your tree? It still applies on v5.16-rc5 and it is really important to us. Please let me know if you need something more.
Regards,
MickaëlQuoted 6 lines
I'm off-work up until end of the year, i.e. I will address only important bug fixes and v5.16 up until that.
If any of the patches is yet missing my ack, feel free to
Acked-by Jarkko Sakkinen <[email protected]>Thanks Jarkko. Can you please take it into your tree?
Quoted 8 lines
Quoted 2 lines
I can yes, as I need to anyway do a revised PR for v5.17, as one commit in my first trial had a truncated fixes tag.
Please check:
git://git.kernel.org/pub/scm/linux/kernel/git/jarkko/linux-tpmdd.git/Jarkko
Great, thanks!
Quoted 29 lines · Mickaël Salaün
Quoted 27 lines · Jarkko Sakkinen
Quoted 25 lines · Jarkko Sakkinen
Quoted 13 lines · Mickaël Salaün
Quoted 11 lines · Jarkko Sakkinen
Quoted 9 lines · Mickaël Salaün
Hi Jarkko,
Since everyone seems OK with this and had plenty of time to complain, could you please take this patch series in your tree? It still applies on v5.16-rc5 and it is really important to us. Please let me know if you need something more.
Regards,
MickaëlQuoted 8 lines
Quoted 6 lines
I'm off-work up until end of the year, i.e. I will address only important bug fixes and v5.16 up until that.
If any of the patches is yet missing my ack, feel free to
Acked-by Jarkko Sakkinen <[email protected]>Thanks Jarkko. Can you please take it into your tree?
I can yes, as I need to anyway do a revised PR for v5.17, as one commit in my first trial had a truncated fixes tag.
Quoted 7 lines
Quoted 5 lines
Please check:
git://git.kernel.org/pub/scm/linux/kernel/git/jarkko/linux-tpmdd.git/Jarkko
Great, thanks!
Hi Jarkko,
I noticed your commits https://git.kernel.org/pub/scm/linux/kernel/git/jarkko/linux-tpmdd.git/commit/?id=3ec9c3a0531ac868422be3b12fc17310ed8c07dc are no more referenced in your tree. Is there an issue?
Regards,
Mickaël
Jarkko Sakkinen
maintainerQuoted 38 lines · Mickaël Salaün
Quoted 36 lines · Mickaël Salaün
Quoted 34 lines · Jarkko Sakkinen
Quoted 20 lines · Jarkko Sakkinen
Quoted 19 lines · Mickaël Salaün
Quoted 17 lines · Jarkko Sakkinen
Quoted 11 lines · Mickaël Salaün
Hi Jarkko,
Since everyone seems OK with this and had plenty of
time to complain, could
you please take this patch series in your tree? It still applies on v5.16-rc5 and it is really important to us. Please
let me know if you need
something more.Regards,
MickaëlI'm off-work up until end of the year, i.e. I will address only important
bug fixes and v5.16 up until that.Quoted 8 lines
Quoted 5 lines
Quoted 3 lines
If any of the patches is yet missing my ack, feel free to
Acked-by Jarkko Sakkinen <[email protected]>Thanks Jarkko. Can you please take it into your tree?
I can yes, as I need to anyway do a revised PR for v5.17, as one commit in my first trial had a truncated fixes tag.
Please check:
git://git.kernel.org/pub/scm/linux/kernel/git/jarkko/linux-tpmdd.git
Quoted 8 lines
Quoted 3 lines
Quoted 1 line
/Jarkko
Great, thanks!
Hi Jarkko,
I noticed your commits https://git.kernel.org/pub/scm/linux/kernel/git/jarkko/linux-tpmdd.git/commit/?id=3ec9c3a0531ac868422be3b12fc17310ed8c07dc
are no more referenced in your tree. Is there an issue?
This must be some sort of mistake I've made. I'll re-apply the patches. Sorry about this.
BR, Jarkko
Jarkko Sakkinen
maintainerQuoted 43 lines · Jarkko Sakkinen
Quoted 42 lines · Mickaël Salaün
Quoted 39 lines · Mickaël Salaün
Quoted 27 lines · Jarkko Sakkinen
Quoted 26 lines · Jarkko Sakkinen
Quoted 24 lines · Mickaël Salaün
Quoted 13 lines · Jarkko Sakkinen
Quoted 11 lines · Mickaël Salaün
Hi Jarkko,
Since everyone seems OK with this and had plenty of
time to complain, could
you please take this patch series in your tree? It still applies on v5.16-rc5 and it is really important to us. Please
let me know if you need
something more.Regards,
MickaëlQuoted 7 lines
I'm off-work up until end of the year, i.e. I will address only important
bug fixes and v5.16 up until that.If any of the patches is yet missing my ack, feel free to
Acked-by Jarkko Sakkinen <[email protected]>Thanks Jarkko. Can you please take it into your tree?
Quoted 8 lines
Quoted 2 lines
I can yes, as I need to anyway do a revised PR for v5.17, as one commit in my first trial had a truncated fixes tag.
Please check:
git://git.kernel.org/pub/scm/linux/kernel/git/jarkko/linux-tpmdd.git/Jarkko
Great, thanks!
Quoted 7 lines
Quoted 4 lines
Hi Jarkko,
I noticed your commits https://git.kernel.org/pub/scm/linux/kernel/git/jarkko/linux-tpmdd.git/commit/?id=3ec9c3a0531ac868422be3b12fc17310ed8c07dc
are no more referenced in your tree. Is there an issue?This must be some sort of mistake I've made. I'll re-apply the patches. Sorry about this.
OK now the patches are in and will be included to the next PR. I fixed merge conflicts caused by 5cca36069d4c ("certs: refactor file cleaning") in "certs: Check that builtin blacklist hashes are valid" so please sanity check that it is good.
BR, Jarkko