KEYS, integrity: Link .platform keyring to .secondary_trusted_keys
Subsystems (8)
cover KEYS, integrity: Link .platform keyring to .secondary_trusted_keys
Hi, as the subject, this is a patch that links the new introduced .platform keyring into .secondary_trusted_keys keyring. This is mainly for the kexec_file_load, make kexec_file_load be able to verify the kernel image agains keys provided by platform or firmware. kexec_file_load already could verify the image agains secondary_trusted_keys if secondary_trusted_keys exits, so this will make kexec_file_load be ware of platform keys as well.
This may also useful for things like module sign verify that are using secondary_trusted_keys. I'm not sure if it will be better to move the INTEGRITY_PLATFORM_KEYRING to certs/ and let integrity subsystem use the keyring there, so just linked the .platform keyring into kernel's .secondary_trusted_keys keyring.
It workd for my case, tested in a VM, I signed the kernel image locally with pesign and imported the cert to EFI's MokList variable.
Kairui Song (1):
KEYS, integrity: Link .platform keyring to .secondary_trusted_keys
certs/system_keyring.c | 30 ++++++++++++++++++++++++++++++ include/keys/platform_keyring.h | 12 ++++++++++++ security/integrity/digsig.c | 7 +++++++ 3 files changed, 49 insertions(+) create mode 100644 include/keys/platform_keyring.h
Signature · 1 line
2.20.1
RFC PATCH 1/1 KEYS, integrity: Link .platform keyring to .secondary_trusted_keys
Currently kexec may need to verify the kerne image, and the kernel image could be signed with third part keys which are provided by paltform or firmware (eg. stored in MokListRT EFI variable). And the same time, kexec_file_load will only verify the image agains .builtin_trusted_keys or .secondary_trusted_keys according to configuration, but there is no way for kexec_file_load to verify the image against any third part keys mentioned above.
In ea93102f3224 ('integrity: Define a trusted platform keyring') a .platform keyring is introduced to store the keys provided by platform or firmware. And with a few following commits including 15ea0e1e3e185 ('efi: Import certificates from UEFI Secure Boot'), now keys required to verify the image is being imported to .paltform keyring, and later IMA-appraisal could access the keyring and verify the image.
This patch links the .platform keyring to .secondary_trusted_keys so kexec_file_load could also leverage the .platform keyring to verify the kernel image.
--- certs/system_keyring.c | 30 ++++++++++++++++++++++++++++++ include/keys/platform_keyring.h | 12 ++++++++++++ security/integrity/digsig.c | 7 +++++++ 3 files changed, 49 insertions(+) create mode 100644 include/keys/platform_keyring.h
certs/system_keyring.c +30 -0
@@ -18,12 +18,14 @@#include <linux/verification.h> #include <keys/asymmetric-type.h> #include <keys/system_keyring.h> +#include <keys/platform_keyring.h> #include <crypto/pkcs7.h> static struct key *builtin_trusted_keys;#ifdef CONFIG_SECONDARY_TRUSTED_KEYRING static struct key *secondary_trusted_keys;#endif +static struct key *platform_keys =NULL ;extern __initconst const u8 system_certificate_list[];extern __initconst const unsigned long system_certificate_list_size;
@@ -67,6 +69,12 @@ int restrict_link_by_builtin_and_secondary_trusted(/* Allow the builtin keyring to be added to the secondary */ return 0 ; +if (type = &key_type_keyring && + dest_keyring = secondary_trusted_keys && + payload = &platform_keys->payload) +/* Allow the platform keyring to be added to the secondary */ +return 0 ; +return restrict_link_by_signature (dest_keyring, type, payload, secondary_trusted_keys); }
@@ -188,6 +196,28 @@ static __init int load_system_certificate_list(void) }late_initcall (load_system_certificate_list); +#if defined(CONFIG_INTEGRITY_PLATFORM_KEYRING ) && defined(CONFIG_SECONDARY_TRUSTED_KEYRING ) + +/* +* Link .platform keyring to .secondary_trusted_key keyring +*/ +static __init int load_platform_certificate_list (void ) +{ +int ret =0 ; + platform_keys =integrity_get_platform_keyring (); +if (!platform_keys) { +return 0 ; + } + ret =key_link (secondary_trusted_keys, platform_keys); +if (ret <0 ) { +pr_err ("Failed to link platform keyring: %d" , ret); + } +return 0 ; +} +late_initcall (load_platform_certificate_list); + +#endif +#ifdef CONFIG_SYSTEM_DATA_VERIFICATION /**
include/keys/platform_keyring.h new file +12 -0
@@ -0,0 +1,12 @@ +#ifndef _KEYS_PLATFORM_KEYRING_H +#define _KEYS_PLATFORM_KEYRING_H + +#include <linux/key.h> + +#ifdef CONFIG_INTEGRITY_PLATFORM_KEYRING + +extern const struct key *__init integrity_get_platform_keyring (void ); + +#endif /* CONFIG_INTEGRITY_PLATFORM_KEYRING */ + +#endif /* _KEYS_SYSTEM_KEYRING_H */
security/integrity/digsig.c +7 -0
@@ -176,3 +176,10 @@ int __init integrity_load_cert(const unsigned int id, const char *source,pr_info ("Loading X.509 certificate: %s\n" , source);return integrity_add_key (id, data, len, perm); } + +#ifdef CONFIG_INTEGRITY_PLATFORM_KEYRING +struct key *__init integrity_get_platform_keyring (void ) +{ +return keyring[INTEGRITY_KEYRING_PLATFORM ]; +} +#endif
Signature · 1 line
2.20.1
Mimi Zohar
maintainer[Cc'ing the LSM and integrity mailing lists]
Repeating my comment on PATCH 0/1 here with the expanded set of mailing lists.
The builtin and secondary keyrings have a signature change of trust rooted in the signed kernel image. Adding the pre-boot keys to the secondary keyring breaks that signature chain of trust.
Please do NOT add the pre-boot "platform" keys to the secondary keyring.
Mimi
Quoted 121 lines · Kairui Song
Currently kexec may need to verify the kerne image, and the kernel image could be signed with third part keys which are provided by paltform or firmware (eg. stored in MokListRT EFI variable). And the same time,
kexec_file_loadwill only verify the image agains .builtin_trusted_keys or .secondary_trusted_keys according to configuration, but there is no way forkexec_file_loadto verify the image against any third part keys mentioned above.In
ea93102f3224('integrity: Define a trusted platform keyring') a .platform keyring is introduced to store the keys provided by platform or firmware. And with a few following commits including15ea0e1e3e185('efi: Import certificates from UEFI Secure Boot'), now keys required to verify the image is being imported to .paltform keyring, and later IMA-appraisal could access the keyring and verify the image.This patch links the .platform keyring to .secondary_trusted_keys so
kexec_file_loadcould also leverage the .platform keyring to verify the kernel image.Signed-off-by Kairui Song <[email protected]>--- certs/system_keyring.c | 30 ++++++++++++++++++++++++++++++ include/keys/platform_keyring.h | 12 ++++++++++++ security/integrity/digsig.c | 7 +++++++ 3 files changed, 49 insertions(+) create mode 100644 include/keys/platform_keyring.hcerts/system_keyring.c +30
-0@@ -18,12 +18,14 @@#include <linux/verification.h> #include <keys/asymmetric-type.h> #include <keys/system_keyring.h> +#include <keys/platform_keyring.h> #include <crypto/pkcs7.h> static struct key *builtin_trusted_keys;#ifdef CONFIG_SECONDARY_TRUSTED_KEYRING static struct key *secondary_trusted_keys;#endif +static struct key *platform_keys =NULL ;extern __initconst const u8 system_certificate_list[];extern __initconst const unsigned long system_certificate_list_size;@@ -67,6 +69,12 @@ int restrict_link_by_builtin_and_secondary_trusted(/* Allow the builtin keyring to be added to the secondary */ return 0 ; +if (type = &key_type_keyring && + dest_keyring = secondary_trusted_keys && + payload = &platform_keys->payload) +/* Allow the platform keyring to be added to the secondary */ +return 0 ; +return restrict_link_by_signature (dest_keyring, type, payload, secondary_trusted_keys); }@@ -188,6 +196,28 @@ static __init int load_system_certificate_list(void) }late_initcall (load_system_certificate_list); +#if defined(CONFIG_INTEGRITY_PLATFORM_KEYRING ) && defined(CONFIG_SECONDARY_TRUSTED_KEYRING ) + +/* +* Link .platform keyring to .secondary_trusted_key keyring +*/ +static __init int load_platform_certificate_list (void ) +{ +int ret =0 ; + platform_keys =integrity_get_platform_keyring (); +if (!platform_keys) { +return 0 ; + } + ret =key_link (secondary_trusted_keys, platform_keys); +if (ret <0 ) { +pr_err ("Failed to link platform keyring: %d" , ret); + } +return 0 ; +} +late_initcall (load_platform_certificate_list); + +#endif +#ifdef CONFIG_SYSTEM_DATA_VERIFICATION /** include/keys/platform_keyring.h new file +12
-0@@ -0,0 +1,12 @@ +#ifndef _KEYS_PLATFORM_KEYRING_H +#define _KEYS_PLATFORM_KEYRING_H + +#include <linux/key.h> + +#ifdef CONFIG_INTEGRITY_PLATFORM_KEYRING + +extern const struct key *__init integrity_get_platform_keyring (void ); + +#endif /* CONFIG_INTEGRITY_PLATFORM_KEYRING */ + +#endif /* _KEYS_SYSTEM_KEYRING_H */ security/integrity/digsig.c +7
-0@@ -176,3 +176,10 @@ int __init integrity_load_cert(const unsigned int id, const char *source,pr_info ("Loading X.509 certificate: %s\n" , source);return integrity_add_key (id, data, len, perm); } + +#ifdef CONFIG_INTEGRITY_PLATFORM_KEYRING +struct key *__init integrity_get_platform_keyring (void ) +{ +return keyring[INTEGRITY_KEYRING_PLATFORM ]; +} +#endif
CC kexec list
Quoted 11 lines · Mimi Zohar
[Cc'ing the LSM and integrity mailing lists]
Repeating my comment on PATCH 0/1 here with the expanded set of mailing lists.
The builtin and secondary keyrings have a signature change of trust rooted in the signed kernel image. Adding the pre-boot keys to the secondary keyring breaks that signature chain of trust.
Please do NOT add the pre-boot "platform" keys to the secondary keyring.
If we regard kexec as a bootloader, it sounds natural to use the platform key to verify the signature with kexec_file_load syscall.
It will be hard for user to manually sign a kernel and import the key then to reuse kexec_file_load.
I think we do not care if platform key can be added to secondary or not, any suggestions how can kexec_file to use the platform key?
Quoted 118 lines
Mimi
Quoted 113 lines · Kairui Song
Currently kexec may need to verify the kerne image, and the kernel image could be signed with third part keys which are provided by paltform or firmware (eg. stored in MokListRT EFI variable). And the same time,
kexec_file_loadwill only verify the image agains .builtin_trusted_keys or .secondary_trusted_keys according to configuration, but there is no way forkexec_file_loadto verify the image against any third part keys mentioned above.In
ea93102f3224('integrity: Define a trusted platform keyring') a .platform keyring is introduced to store the keys provided by platform or firmware. And with a few following commits including15ea0e1e3e185('efi: Import certificates from UEFI Secure Boot'), now keys required to verify the image is being imported to .paltform keyring, and later IMA-appraisal could access the keyring and verify the image.This patch links the .platform keyring to .secondary_trusted_keys so
kexec_file_loadcould also leverage the .platform keyring to verify the kernel image.Signed-off-by Kairui Song <[email protected]>--- certs/system_keyring.c | 30 ++++++++++++++++++++++++++++++ include/keys/platform_keyring.h | 12 ++++++++++++ security/integrity/digsig.c | 7 +++++++ 3 files changed, 49 insertions(+) create mode 100644 include/keys/platform_keyring.hcerts/system_keyring.c +30
-0@@ -18,12 +18,14 @@#include <linux/verification.h> #include <keys/asymmetric-type.h> #include <keys/system_keyring.h> +#include <keys/platform_keyring.h> #include <crypto/pkcs7.h> static struct key *builtin_trusted_keys;#ifdef CONFIG_SECONDARY_TRUSTED_KEYRING static struct key *secondary_trusted_keys;#endif +static struct key *platform_keys =NULL ;extern __initconst const u8 system_certificate_list[];extern __initconst const unsigned long system_certificate_list_size;@@ -67,6 +69,12 @@ int restrict_link_by_builtin_and_secondary_trusted(/* Allow the builtin keyring to be added to the secondary */ return 0 ; +if (type = &key_type_keyring && + dest_keyring = secondary_trusted_keys && + payload = &platform_keys->payload) +/* Allow the platform keyring to be added to the secondary */ +return 0 ; +return restrict_link_by_signature (dest_keyring, type, payload, secondary_trusted_keys); }@@ -188,6 +196,28 @@ static __init int load_system_certificate_list(void) }late_initcall (load_system_certificate_list); +#if defined(CONFIG_INTEGRITY_PLATFORM_KEYRING ) && defined(CONFIG_SECONDARY_TRUSTED_KEYRING ) + +/* +* Link .platform keyring to .secondary_trusted_key keyring +*/ +static __init int load_platform_certificate_list (void ) +{ +int ret =0 ; + platform_keys =integrity_get_platform_keyring (); +if (!platform_keys) { +return 0 ; + } + ret =key_link (secondary_trusted_keys, platform_keys); +if (ret <0 ) { +pr_err ("Failed to link platform keyring: %d" , ret); + } +return 0 ; +} +late_initcall (load_platform_certificate_list); + +#endif +#ifdef CONFIG_SYSTEM_DATA_VERIFICATION /** include/keys/platform_keyring.h new file +12
-0@@ -0,0 +1,12 @@ +#ifndef _KEYS_PLATFORM_KEYRING_H +#define _KEYS_PLATFORM_KEYRING_H + +#include <linux/key.h> + +#ifdef CONFIG_INTEGRITY_PLATFORM_KEYRING + +extern const struct key *__init integrity_get_platform_keyring (void ); + +#endif /* CONFIG_INTEGRITY_PLATFORM_KEYRING */ + +#endif /* _KEYS_SYSTEM_KEYRING_H */ security/integrity/digsig.c +0
-0@@ -176,3 +176,10 @@ int __init integrity_load_cert(const unsigned int id, const char *source,pr_info ("Loading X.509 certificate: %s\n" , source);return integrity_add_key (id, data, len, perm);
Quoted 9 lines
security/integrity/digsig.c int __init integrity_load_cert(const unsigned int id, const char *source, · line 185
Quoted 8 lines
security/integrity/digsig.c +7
-0} + +#ifdef CONFIG_INTEGRITY_PLATFORM_KEYRING +struct key *__init integrity_get_platform_keyring (void ) +{ +return keyring[INTEGRITY_KEYRING_PLATFORM ]; +} +#endif
Thanks
Dave
Thanks for the explanation Dave, my second thought is to let kexec use the platform keyring directly, that is let kexec verify the image with secondary/builtin keyring first then try platform keyring. And better to make platform keyring independent of integrity subsystem, so kexec could verify the image and don't depend on integrity. Any thought?
Quoted 154 lines · Dave Young
CC kexec list
Quoted 11 lines · Mimi Zohar
[Cc'ing the LSM and integrity mailing lists]
Repeating my comment on PATCH 0/1 here with the expanded set of mailing lists.
The builtin and secondary keyrings have a signature change of trust rooted in the signed kernel image. Adding the pre-boot keys to the secondary keyring breaks that signature chain of trust.
Please do NOT add the pre-boot "platform" keys to the secondary keyring.
If we regard kexec as a bootloader, it sounds natural to use the platform key to verify the signature with
kexec_file_loadsyscall.It will be hard for user to manually sign a kernel and import the key then to reuse
kexec_file_load.I think we do not care if platform key can be added to secondary or not, any suggestions how can
kexec_fileto use the platform key?Quoted 118 lines
Mimi
Quoted 113 lines · Kairui Song
Currently kexec may need to verify the kerne image, and the kernel image could be signed with third part keys which are provided by paltform or firmware (eg. stored in MokListRT EFI variable). And the same time,
kexec_file_loadwill only verify the image agains .builtin_trusted_keys or .secondary_trusted_keys according to configuration, but there is no way forkexec_file_loadto verify the image against any third part keys mentioned above.In
ea93102f3224('integrity: Define a trusted platform keyring') a .platform keyring is introduced to store the keys provided by platform or firmware. And with a few following commits including15ea0e1e3e185('efi: Import certificates from UEFI Secure Boot'), now keys required to verify the image is being imported to .paltform keyring, and later IMA-appraisal could access the keyring and verify the image.This patch links the .platform keyring to .secondary_trusted_keys so
kexec_file_loadcould also leverage the .platform keyring to verify the kernel image.Signed-off-by Kairui Song <[email protected]>--- certs/system_keyring.c | 30 ++++++++++++++++++++++++++++++ include/keys/platform_keyring.h | 12 ++++++++++++ security/integrity/digsig.c | 7 +++++++ 3 files changed, 49 insertions(+) create mode 100644 include/keys/platform_keyring.hcerts/system_keyring.c +30
-0@@ -18,12 +18,14 @@#include <linux/verification.h> #include <keys/asymmetric-type.h> #include <keys/system_keyring.h> +#include <keys/platform_keyring.h> #include <crypto/pkcs7.h> static struct key *builtin_trusted_keys;#ifdef CONFIG_SECONDARY_TRUSTED_KEYRING static struct key *secondary_trusted_keys;#endif +static struct key *platform_keys =NULL ;extern __initconst const u8 system_certificate_list[];extern __initconst const unsigned long system_certificate_list_size;@@ -67,6 +69,12 @@ int restrict_link_by_builtin_and_secondary_trusted(/* Allow the builtin keyring to be added to the secondary */ return 0 ; +if (type = &key_type_keyring && + dest_keyring = secondary_trusted_keys && + payload = &platform_keys->payload) +/* Allow the platform keyring to be added to the secondary */ +return 0 ; +return restrict_link_by_signature (dest_keyring, type, payload, secondary_trusted_keys); }@@ -188,6 +196,28 @@ static __init int load_system_certificate_list(void) }late_initcall (load_system_certificate_list); +#if defined(CONFIG_INTEGRITY_PLATFORM_KEYRING ) && defined(CONFIG_SECONDARY_TRUSTED_KEYRING ) + +/* +* Link .platform keyring to .secondary_trusted_key keyring +*/ +static __init int load_platform_certificate_list (void ) +{ +int ret =0 ; + platform_keys =integrity_get_platform_keyring (); +if (!platform_keys) { +return 0 ; + } + ret =key_link (secondary_trusted_keys, platform_keys); +if (ret <0 ) { +pr_err ("Failed to link platform keyring: %d" , ret); + } +return 0 ; +} +late_initcall (load_platform_certificate_list); + +#endif +#ifdef CONFIG_SYSTEM_DATA_VERIFICATION /** include/keys/platform_keyring.h new file +12
-0@@ -0,0 +1,12 @@ +#ifndef _KEYS_PLATFORM_KEYRING_H +#define _KEYS_PLATFORM_KEYRING_H + +#include <linux/key.h> + +#ifdef CONFIG_INTEGRITY_PLATFORM_KEYRING + +extern const struct key *__init integrity_get_platform_keyring (void ); + +#endif /* CONFIG_INTEGRITY_PLATFORM_KEYRING */ + +#endif /* _KEYS_SYSTEM_KEYRING_H */ security/integrity/digsig.c +0
-0@@ -176,3 +176,10 @@ int __init integrity_load_cert(const unsigned int id, const char *source,pr_info ("Loading X.509 certificate: %s\n" , source);return integrity_add_key (id, data, len, perm);Quoted 9 lines
security/integrity/digsig.c int __init integrity_load_cert(const unsigned int id, const char *source, · line 185
Quoted 8 lines
security/integrity/digsig.c +7
-0} + +#ifdef CONFIG_INTEGRITY_PLATFORM_KEYRING +struct key *__init integrity_get_platform_keyring (void ) +{ +return keyring[INTEGRITY_KEYRING_PLATFORM ]; +} +#endif Thanks
Dave
Signature · 2 lines
Best Regards, Kairui Song
Mimi Zohar
maintainerQuoted 11 lines · Dave Young
CC kexec list
Quoted 9 lines · Mimi Zohar
[Cc'ing the LSM and integrity mailing lists]
Repeating my comment on PATCH 0/1 here with the expanded set of mailing lists.
The builtin and secondary keyrings have a signature change of trust rooted in the signed kernel image. Adding the pre-boot keys to the secondary keyring breaks that signature chain of trust.
Quoted 8 lines
Quoted 2 lines
Please do NOT add the pre-boot "platform" keys to the secondary keyring.
If we regard kexec as a bootloader, it sounds natural to use the platform key to verify the signature with
kexec_file_loadsyscall.It will be hard for user to manually sign a kernel and import the key then to reuse
kexec_file_load.
This is really a generic topic, not limited to kexec, which should be discussed. Let's defer this discussion for now.
Quoted 3 lines
I think we do not care if platform key can be added to secondary or not, any suggestions how can
kexec_fileto use the platform key?
I assume the problem is accessing the keyring id.
Instead of defining a function to return the keyring id, as below, define a function that sets a variable with the keyring id. platform_keyring_init() would call that function to set the variable.
Similar to builtin_trusted_keys and secondary_trusted_keys, define a variable named platform_trusted_keys.
[snip]
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
security/integrity/digsig.c +0
-0@@ -176,3 +176,10 @@ int __init integrity_load_cert(const unsigned int id, const char *source,pr_info ("Loading X.509 certificate: %s\n" , source);return integrity_add_key (id, data, len, perm);
Quoted 8 lines
Quoted 8 lines
security/integrity/digsig.c int __init integrity_load_cert(const unsigned int id, const char *source, · line 185
Quoted 8 lines
security/integrity/digsig.c +7
-0} + +#ifdef CONFIG_INTEGRITY_PLATFORM_KEYRING +struct key *__init integrity_get_platform_keyring (void ) +{ +return keyring[INTEGRITY_KEYRING_PLATFORM ]; +} +#endif
Mimi
David Howells
maintainerQuoted 1 line · Kairui Song
+extern const struct key*
__initintegrity_get_platform_keyring(void);
This should really be in keys/system_keyring.h and probably shouldn't be exposed directly if it can be avoided.
David
Quoted 9 lines · David Howells
Quoted 1 line · Kairui Song
+extern const struct key*
__initintegrity_get_platform_keyring(void);This should really be in
keys/system_keyring.hand probably shouldn't be exposed directly if it can be avoided.David
Thanks for the review, I've sent V3 of this patch series, the implementation changed a bit, would you mind take a look of that patch instead?
https://lore.kernel.org/lkml/[email protected]/
Signature · 2 lines
Best Regards, Kairui Song
Mimi Zohar
maintainerQuoted 7 lines · Kairui Song
Hi, as the subject, this is a patch that links the new introduced .platform keyring into .secondary_trusted_keys keyring. This is mainly for the
kexec_file_load, makekexec_file_loadbe able to verify the kernel image agains keys provided by platform or firmware.kexec_file_loadalready could verify the image againssecondary_trusted_keysifsecondary_trusted_keysexits, so this will makekexec_file_loadbe ware of platform keys as well.
The builtin and secondary keyrings have a signature change of trust rooted in the signed kernel image. Adding the pre-boot keys to the secondary keyring breaks that signature chain of trust.
Mimi
Quoted 19 lines
This may also useful for things like module sign verify that are using
secondary_trusted_keys. I'm not sure if it will be better to move theINTEGRITY_PLATFORM_KEYRINGtocerts/and let integrity subsystem use the keyring there, so just linked the .platform keyring into kernel's .secondary_trusted_keys keyring.It workd for my case, tested in a VM, I signed the kernel image locally with pesign and imported the cert to EFI's MokList variable.
Kairui Song (1):
KEYS, integrity: Link .platform keyring to .secondary_trusted_keyscerts/system_keyring.c | 30 ++++++++++++++++++++++++++++++ include/keys/platform_keyring.h | 12 ++++++++++++ security/integrity/digsig.c | 7 +++++++ 3 files changed, 49 insertions(+) create mode 100644 include/keys/platform_keyring.h