kexec_load(2) bypasses signature verification
Subsystems (4)
Quoted 1 line
From experimentation and from looking at the sources, it appears that
the signature checking is only done in the kexec_file_load(2) system all, and not in the kexec_load(2) system call. And I understand why -- the signature is not sent from userspace to the kernel in the older kexec_load(2) system call.
The problem is that if you use an old version of kexec, it will use the old kexec_load(2) system call, and even though CONFIG_KEXEC_VERIFY_SIG is enabled, kexec_load(2) will happily load an unsigned kernel, and then "kexec -e" will happily boot into it.
Correct me if I am wrong, but this appears to be a hole in Secure Boot you could drive a Mack Truck through.
(I noticed this because Debian is still using a kexec-tools from the stone ages, version 2.0.7, and I was wondering **why** I was able to kexec boot completely unsigned kernels.)
It would appear to me that if CONFIG_KEXEC_VERIFY_SIG is enabled, the old kexec_load(2) system call should be disabled (and a warning be placed in the Kconfig help that the user should have at least verision 2.X of kexec-tools if they enable this kernel option).
Am I missing something?
- Ted
Quoted 14 lines · Theodore Ts'o
From experimentation and from looking at the sources, it appears that the signature checking is only done in the
kexec_file_load(2)system all, and not in thekexec_load(2)system call. And I understand why -- the signature is not sent from userspace to the kernel in the olderkexec_load(2)system call.The problem is that if you use an old version of kexec, it will use the old
kexec_load(2)system call, and even thoughCONFIG_KEXEC_VERIFY_SIGis enabled,kexec_load(2)will happily load an unsigned kernel, and then "kexec -e" will happily boot into it.Correct me if I am wrong, but this appears to be a hole in Secure Boot you could drive a Mack Truck through.
Quoted 8 lines
(I noticed this because Debian is still using a kexec-tools from the stone ages, version 2.0.7, and I was wondering **why** I was able to kexec boot completely unsigned kernels.)
It would appear to me that if
CONFIG_KEXEC_VERIFY_SIGis enabled, the oldkexec_load(2)system call should be disabled (and a warning be placed in theKconfighelp that the user should have at least verision 2.X of kexec-tools if they enable this kernel option).
IMO it is fine to disable old syscall incase CONFIG_KEXEC_VERIFY=y
Add Vivek to the loop.
Thanks
Dave
_______________________________________________
kexec mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/kexec
Quoted 19 lines · On Mon, 15 Jun 2015 17:11:00 +0800 Dave Young <[email protected]> wrote:
Quoted 18 lines · Theodore Ts'o
From experimentation and from looking at the sources, it appears that the signature checking is only done in the
kexec_file_load(2)system all, and not in thekexec_load(2)system call. And I understand why -- the signature is not sent from userspace to the kernel in the olderkexec_load(2)system call.The problem is that if you use an old version of kexec, it will use the old
kexec_load(2)system call, and even thoughCONFIG_KEXEC_VERIFY_SIGis enabled,kexec_load(2)will happily load an unsigned kernel, and then "kexec -e" will happily boot into it.Correct me if I am wrong, but this appears to be a hole in Secure Boot you could drive a Mack Truck through.
(I noticed this because Debian is still using a kexec-tools from the stone ages, version 2.0.7, and I was wondering **why** I was able to kexec boot completely unsigned kernels.)
Quoted 6 lines
Quoted 4 lines
It would appear to me that if
CONFIG_KEXEC_VERIFY_SIGis enabled, the oldkexec_load(2)system call should be disabled (and a warning be placed in theKconfighelp that the user should have at least verision 2.X of kexec-tools if they enable this kernel option).IMO it is fine to disable old syscall incase
CONFIG_KEXEC_VERIFY=y
Definitely. It is not possible to to sign all code passed through kexec_load(2), at least not without giving kexec-tools the private part of the key (which would effectively destroy the goal of Secure Boot).
Whenever signature verification is required, kexec_load(2) must be disabled.
Petr Tesarik
_______________________________________________
kexec mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/kexec
Quoted 6 lines · Theodore Ts'o
From experimentation and from looking at the sources, it appears that the signature checking is only done in the
kexec_file_load(2)system all, and not in thekexec_load(2)system call. And I understand why -- the signature is not sent from userspace to the kernel in the olderkexec_load(2)system call.
Quoted 7 lines
The problem is that if you use an old version of kexec, it will use the old
kexec_load(2)system call, and even thoughCONFIG_KEXEC_VERIFY_SIGis enabled,kexec_load(2)will happily load an unsigned kernel, and then "kexec -e" will happily boot into it.Correct me if I am wrong, but this appears to be a hole in Secure Boot you could drive a Mack Truck through.
Yes, which is why most of the distro vendors carry an out-of-tree patch that disables the old kexec in an SB setup. It would be nice if we could merge said patches. However, they depend on Matthew's secure_modules/trusted_kernel/<whatever name that works> patchset which has gotten little movement since we came up with a tentative agreement at LPC 2013.
Quoted 10 lines
(I noticed this because Debian is still using a kexec-tools from the stone ages, version 2.0.7, and I was wondering **why** I was able to kexec boot completely unsigned kernels.)
It would appear to me that if
CONFIG_KEXEC_VERIFY_SIGis enabled, the oldkexec_load(2)system call should be disabled (and a warning be placed in theKconfighelp that the user should have at least verision 2.X of kexec-tools if they enable this kernel option).Am I missing something?
Those sound like fine suggestions to me.
josh
Quoted 6 lines · Josh Boyer
Yes, which is why most of the distro vendors carry an out-of-tree patch that disables the old kexec in an SB setup. It would be nice if we could merge said patches. However, they depend on Matthew's secure_modules/trusted_kernel/<whatever name that works> patchset which has gotten little movement since we came up with a tentative agreement at LPC 2013.
Signed modules is in, though, right? And the fact that we have CONFIG_SIGNED_PE_FILE_VERIFICATION means we're doing unatural file signatures w/o using ELF, which I thought was the basis of Linus's accusation that Red Hat was performing intimate/physical acts with Microsoft. :-)
I would have thought those were the nasty bits to get in; out of curiosity, what's still missing?
Regards,
- Ted
Quoted 9 lines · Theodore Ts'o
Quoted 6 lines · Josh Boyer
Yes, which is why most of the distro vendors carry an out-of-tree patch that disables the old kexec in an SB setup. It would be nice if we could merge said patches. However, they depend on Matthew's secure_modules/trusted_kernel/<whatever name that works> patchset which has gotten little movement since we came up with a tentative agreement at LPC 2013.
Signed modules is in, though, right? And the fact that we have
Yes.
Quoted 7 lines
CONFIG_SIGNED_PE_FILE_VERIFICATIONmeans we're doing unatural file signatures w/o using ELF, which I thought was the basis of Linus's accusation that Red Hat was performing intimate/physical acts with Microsoft. :-)I would have thought those were the nasty bits to get in; out of curiosity, what's still missing?
The bits that actually read Secure Boot state out of the UEFI variables, and apply protections to the machine to avoid compromise under the SB threat model. Things like disabling the old kexec, enforcing module signatures at runtime, restricting various access (like /dev/mem, /dev/kmem), adding certs in UEFI db to the system keyring, and enforcing the UEFI dbx blacklist. So most of the patches in Matthew's set relate to enforcement using the bits of functionality already merged. They aren't even strictly tied to UEFI or SB, but some of the other patches distos carry are. We had tentative agreement even from Linus on much of this (his words were along the lines of "create a flag and use the flag"), but it's failed to actually get carried in any tree for a few reasons.
josh
Quoted 3 lines · Josh Boyer
The bits that actually read Secure Boot state out of the UEFI variables, and apply protections to the machine to avoid compromise under the SB threat model. Things like disabling the old kexec...
I don't have any real interest in using Secure Boot, but I *am* interested in using CONFIG_KEXEC_VERIFY_SIG[1]. So perhaps we need to have something similar to what we have with signed modules in terms of CONFIG_MODULE_SIG_FORCE and module/sig_enforce, but for KEXEC_VERIFY_SIG. This would mean creating a separate flag independent of the one Linus suggested for Secure Boot, but since we have one for signed modules, we do have precedent for this sort of thing.
- Ted
[1] Yes, it doesn't buy all that much, since if the system is rooted the adversary can just replace the kernel in /boot and force a normal, slower reboot, but the same could be said for signed modules --- the adversary could just replace all of /boot/vmlinux-<kver> and /lib/modules/<kver>. But both measures make it a tad more bit difficult, especially for the adversary to do this replacement without being noticed (for example linode will send me e-mail if the system reboots normally, but not with a kexec-mediated reboot), and for cloud systems where we don't have secure boot anyway, it's about the best we can do.
Adding Vivek as he is the one who implemented kexec_file_load. I was hoping he would respond to this thread, and it looks like he simply has not ever been Cc'd.
Quoted 5 lines · Theodore Ts'o
Quoted 3 lines · Josh Boyer
The bits that actually read Secure Boot state out of the UEFI variables, and apply protections to the machine to avoid compromise under the SB threat model. Things like disabling the old kexec...
Quoted 8 lines
I don't have any real interest in using Secure Boot, but I *am* interested in using CONFIG_KEXEC_VERIFY_SIG[1]. So perhaps we need to have something similar to what we have with signed modules in terms of
CONFIG_MODULE_SIG_FORCEand module/sig_enforce, but forKEXEC_VERIFY_SIG. This would mean creating a separate flag independent of the one Linus suggested for Secure Boot, but since we have one for signed modules, we do have precedent for this sort of thing.
My overall request with respect to kexec has been that we implement things that make sense outside of the bizarre threat model of the Linux folks who were talking about secure boot.
nI have not navigated the labyrinth of config options but having a way to only boot signed things with kexec seems a completely sensible way to operate in the context of signed images.
I don't know how much that will help given that actors with sufficient resources have demonstrated the ability to steal private keys, but assuming binary signing is an effective technique (or why else do it) then having an option to limit kexec to only loading signed images seems sensible.
Eric
Quoted 29 lines · Eric W. Biederman
Adding Vivek as he is the one who implemented
kexec_file_load. I was hoping he would respond to this thread, and it looks like he simply has not ever been Cc'd.Quoted 5 lines · Theodore Ts'o
Quoted 3 lines · Josh Boyer
The bits that actually read Secure Boot state out of the UEFI variables, and apply protections to the machine to avoid compromise under the SB threat model. Things like disabling the old kexec...
Quoted 8 lines
I don't have any real interest in using Secure Boot, but I *am* interested in using CONFIG_KEXEC_VERIFY_SIG[1]. So perhaps we need to have something similar to what we have with signed modules in terms of
CONFIG_MODULE_SIG_FORCEand module/sig_enforce, but forKEXEC_VERIFY_SIG. This would mean creating a separate flag independent of the one Linus suggested for Secure Boot, but since we have one for signed modules, we do have precedent for this sort of thing.My overall request with respect to kexec has been that we implement things that make sense outside of the bizarre threat model of the Linux folks who were talking about secure boot.
nI have not navigated the labyrinth of config options but having a way to only boot signed things with kexec seems a completely sensible way to operate in the context of signed images.
Quoted 5 lines
I don't know how much that will help given that actors with sufficient resources have demonstrated the ability to steal private keys, but assuming binary signing is an effective technique (or why else do it) then having an option to limit kexec to only loading signed images seems sensible.
I went through the mail chain on web and here are my thoughts.
- So yes, upstream does not have the logic which automatically disables the old syscall (kexec_load()) on secureboot systems. Distributions carry those patches.
- This KEXEC_VERIFY_SIG option only cotrols the behavior for kexec_file_load() syscall and is not meant to directly affect any behavior of old syscall (kexec_load()). I think I should have named it KEXEC_FILE_VERIFY_SIG. Though help text makes it clear. "Verify kernel signature during kexec_file_load() syscall".
- I think disabling old system call if KEXEC_VERIFY_SIG() is set will break existing setup which use old system call by default, except the case of secureboot system. And old syscall path is well tested and new syscall might not be in a position to support all the corner cases, atleast as of now.
Ted,
So looks like you are looking for a system/option where you just want to always make use of kexec_file_load() and disable kexec_load(). This sounds like you want a kernel where kexec_load() is compiled out and you want only kexec_file_load() in.
Right now one can't do that becase kexec_file_load() depends on CONFIG_KEXEC option.
I am wondering that how about making CONFIG_KEXEC_FILE_LOAD independent of CONFIG_KEXEC. That way one can set CONFIG_KEXEC_VERIFY_SIG=y, and only signed kernel can be kexeced on that system.
This should gel well with long term strategy of deprecating kexec_load() at some point of time when kexec_file_load() is ready to completely replace it.
Thanks
Vivek
Quoted 64 lines · Vivek Goyal
Quoted 29 lines · Eric W. Biederman
Adding Vivek as he is the one who implemented
kexec_file_load. I was hoping he would respond to this thread, and it looks like he simply has not ever been Cc'd.Quoted 5 lines · Theodore Ts'o
Quoted 3 lines · Josh Boyer
The bits that actually read Secure Boot state out of the UEFI variables, and apply protections to the machine to avoid compromise under the SB threat model. Things like disabling the old kexec...
Quoted 8 lines
I don't have any real interest in using Secure Boot, but I *am* interested in using CONFIG_KEXEC_VERIFY_SIG[1]. So perhaps we need to have something similar to what we have with signed modules in terms of
CONFIG_MODULE_SIG_FORCEand module/sig_enforce, but forKEXEC_VERIFY_SIG. This would mean creating a separate flag independent of the one Linus suggested for Secure Boot, but since we have one for signed modules, we do have precedent for this sort of thing.My overall request with respect to kexec has been that we implement things that make sense outside of the bizarre threat model of the Linux folks who were talking about secure boot.
nI have not navigated the labyrinth of config options but having a way to only boot signed things with kexec seems a completely sensible way to operate in the context of signed images.
Quoted 5 lines
I don't know how much that will help given that actors with sufficient resources have demonstrated the ability to steal private keys, but assuming binary signing is an effective technique (or why else do it) then having an option to limit kexec to only loading signed images seems sensible.
I went through the mail chain on web and here are my thoughts.
- So yes, upstream does not have the logic which automatically disables the old syscall (
kexec_load()) on secureboot systems. Distributions carry those patches.- This
KEXEC_VERIFY_SIGoption only cotrols the behavior forkexec_file_load()syscall and is not meant to directly affect any behavior of old syscall (kexec_load()). I think I should have named itKEXEC_FILE_VERIFY_SIG. Though help text makes it clear. "Verify kernel signature duringkexec_file_load()syscall".- I think disabling old system call if
KEXEC_VERIFY_SIG()is set will break existing setup which use old system call by default, except the case of secureboot system. And old syscall path is well tested and new syscall might not be in a position to support all the corner cases, atleast as of now.Ted,
So looks like you are looking for a system/option where you just want to always make use of
kexec_file_load()and disablekexec_load(). This sounds like you want a kernel wherekexec_load()is compiled out and you want onlykexec_file_load()in.Right now one can't do that becase
kexec_file_load()depends onCONFIG_KEXECoption.
Quoted 7 lines
I am wondering that how about making
CONFIG_KEXEC_FILE_LOADindependent ofCONFIG_KEXEC. That way one can setCONFIG_KEXEC_VERIFY_SIG=y, and only signed kernel can be kexeced on that system.This should gel well with long term strategy of deprecating
kexec_load()at some point of time whenkexec_file_load()is ready to completely replace it.
Interesting.
I suspect that what we want is to have CONFIG_KEXEC for the core and additional CONFIG_KEXEC_LOAD option that covers that kexec_load call.
That should make it trivially easy to disable the kexec_load system call in cases where people care.
Eric
Quoted 74 lines · Eric W. Biederman
Quoted 64 lines · Vivek Goyal
Quoted 29 lines · Eric W. Biederman
Adding Vivek as he is the one who implemented
kexec_file_load. I was hoping he would respond to this thread, and it looks like he simply has not ever been Cc'd.Quoted 5 lines · Theodore Ts'o
Quoted 3 lines · Josh Boyer
The bits that actually read Secure Boot state out of the UEFI variables, and apply protections to the machine to avoid compromise under the SB threat model. Things like disabling the old kexec...
Quoted 8 lines
I don't have any real interest in using Secure Boot, but I *am* interested in using CONFIG_KEXEC_VERIFY_SIG[1]. So perhaps we need to have something similar to what we have with signed modules in terms of
CONFIG_MODULE_SIG_FORCEand module/sig_enforce, but forKEXEC_VERIFY_SIG. This would mean creating a separate flag independent of the one Linus suggested for Secure Boot, but since we have one for signed modules, we do have precedent for this sort of thing.My overall request with respect to kexec has been that we implement things that make sense outside of the bizarre threat model of the Linux folks who were talking about secure boot.
nI have not navigated the labyrinth of config options but having a way to only boot signed things with kexec seems a completely sensible way to operate in the context of signed images.
Quoted 5 lines
I don't know how much that will help given that actors with sufficient resources have demonstrated the ability to steal private keys, but assuming binary signing is an effective technique (or why else do it) then having an option to limit kexec to only loading signed images seems sensible.
I went through the mail chain on web and here are my thoughts.
- So yes, upstream does not have the logic which automatically disables the old syscall (
kexec_load()) on secureboot systems. Distributions carry those patches.- This
KEXEC_VERIFY_SIGoption only cotrols the behavior forkexec_file_load()syscall and is not meant to directly affect any behavior of old syscall (kexec_load()). I think I should have named itKEXEC_FILE_VERIFY_SIG. Though help text makes it clear. "Verify kernel signature duringkexec_file_load()syscall".- I think disabling old system call if
KEXEC_VERIFY_SIG()is set will break existing setup which use old system call by default, except the case of secureboot system. And old syscall path is well tested and new syscall might not be in a position to support all the corner cases, atleast as of now.Ted,
So looks like you are looking for a system/option where you just want to always make use of
kexec_file_load()and disablekexec_load(). This sounds like you want a kernel wherekexec_load()is compiled out and you want onlykexec_file_load()in.Right now one can't do that becase
kexec_file_load()depends onCONFIG_KEXECoption.Quoted 7 lines
I am wondering that how about making
CONFIG_KEXEC_FILE_LOADindependent ofCONFIG_KEXEC. That way one can setCONFIG_KEXEC_VERIFY_SIG=y, and only signed kernel can be kexeced on that system.This should gel well with long term strategy of deprecating
kexec_load()at some point of time whenkexec_file_load()is ready to completely replace it.
Quoted 7 lines
Interesting.
I suspect that what we want is to have
CONFIG_KEXECfor the core and additionalCONFIG_KEXEC_LOADoption that covers thatkexec_loadcall.That should make it trivially easy to disable the
kexec_loadsystem call in cases where people care.
Or, we could create another option CONFIG_KEXEC_CORE/CONFIG_KEXEC_COMMON which will be automatically selected when either CONFIG_KEXEC or CONIG_KEXEC_FILE are selected.
All common code can go under this option and rest can go under respective config options.
That way, those who have CONFIG_KEXEC=y in old config files will not be broken. They don't have to learn about new options at all.
Thanks
Vivek
Quoted 87 lines · Vivek Goyal
Quoted 74 lines · Eric W. Biederman
Quoted 64 lines · Vivek Goyal
Quoted 29 lines · Eric W. Biederman
Adding Vivek as he is the one who implemented
kexec_file_load. I was hoping he would respond to this thread, and it looks like he simply has not ever been Cc'd.Quoted 5 lines · Theodore Ts'o
Quoted 3 lines · Josh Boyer
The bits that actually read Secure Boot state out of the UEFI variables, and apply protections to the machine to avoid compromise under the SB threat model. Things like disabling the old kexec...
Quoted 8 lines
I don't have any real interest in using Secure Boot, but I *am* interested in using CONFIG_KEXEC_VERIFY_SIG[1]. So perhaps we need to have something similar to what we have with signed modules in terms of
CONFIG_MODULE_SIG_FORCEand module/sig_enforce, but forKEXEC_VERIFY_SIG. This would mean creating a separate flag independent of the one Linus suggested for Secure Boot, but since we have one for signed modules, we do have precedent for this sort of thing.My overall request with respect to kexec has been that we implement things that make sense outside of the bizarre threat model of the Linux folks who were talking about secure boot.
nI have not navigated the labyrinth of config options but having a way to only boot signed things with kexec seems a completely sensible way to operate in the context of signed images.
Quoted 5 lines
I don't know how much that will help given that actors with sufficient resources have demonstrated the ability to steal private keys, but assuming binary signing is an effective technique (or why else do it) then having an option to limit kexec to only loading signed images seems sensible.
I went through the mail chain on web and here are my thoughts.
- So yes, upstream does not have the logic which automatically disables the old syscall (
kexec_load()) on secureboot systems. Distributions carry those patches.- This
KEXEC_VERIFY_SIGoption only cotrols the behavior forkexec_file_load()syscall and is not meant to directly affect any behavior of old syscall (kexec_load()). I think I should have named itKEXEC_FILE_VERIFY_SIG. Though help text makes it clear. "Verify kernel signature duringkexec_file_load()syscall".- I think disabling old system call if
KEXEC_VERIFY_SIG()is set will break existing setup which use old system call by default, except the case of secureboot system. And old syscall path is well tested and new syscall might not be in a position to support all the corner cases, atleast as of now.Ted,
So looks like you are looking for a system/option where you just want to always make use of
kexec_file_load()and disablekexec_load(). This sounds like you want a kernel wherekexec_load()is compiled out and you want onlykexec_file_load()in.Right now one can't do that becase
kexec_file_load()depends onCONFIG_KEXECoption.Quoted 7 lines
I am wondering that how about making
CONFIG_KEXEC_FILE_LOADindependent ofCONFIG_KEXEC. That way one can setCONFIG_KEXEC_VERIFY_SIG=y, and only signed kernel can be kexeced on that system.This should gel well with long term strategy of deprecating
kexec_load()at some point of time whenkexec_file_load()is ready to completely replace it.Quoted 7 lines
Interesting.
I suspect that what we want is to have
CONFIG_KEXECfor the core and additionalCONFIG_KEXEC_LOADoption that covers thatkexec_loadcall.That should make it trivially easy to disable the
kexec_loadsystem call in cases where people care.Or, we could create another option CONFIG_KEXEC_CORE/CONFIG_KEXEC_COMMON which will be automatically selected when either
CONFIG_KEXECorCONIG_KEXEC_FILEare selected.
Quoted 5 lines
All common code can go under this option and rest can go under respective config options.
That way, those who have
CONFIG_KEXEC=yin old config files will not be broken. They don't have to learn about new options at all.
Or simply add a new config option KEXEC_VERIFY_SIG_FORCE, so we can return error in kexec_load and print some error message.
Thanks
Dave
Quoted 88 lines · Dave Young
Quoted 87 lines · Vivek Goyal
Quoted 74 lines · Eric W. Biederman
Quoted 64 lines · Vivek Goyal
Quoted 29 lines · Eric W. Biederman
Adding Vivek as he is the one who implemented
kexec_file_load. I was hoping he would respond to this thread, and it looks like he simply has not ever been Cc'd.Quoted 5 lines · Theodore Ts'o
Quoted 3 lines · Josh Boyer
The bits that actually read Secure Boot state out of the UEFI variables, and apply protections to the machine to avoid compromise under the SB threat model. Things like disabling the old kexec...
Quoted 8 lines
I don't have any real interest in using Secure Boot, but I *am* interested in using CONFIG_KEXEC_VERIFY_SIG[1]. So perhaps we need to have something similar to what we have with signed modules in terms of
CONFIG_MODULE_SIG_FORCEand module/sig_enforce, but forKEXEC_VERIFY_SIG. This would mean creating a separate flag independent of the one Linus suggested for Secure Boot, but since we have one for signed modules, we do have precedent for this sort of thing.My overall request with respect to kexec has been that we implement things that make sense outside of the bizarre threat model of the Linux folks who were talking about secure boot.
nI have not navigated the labyrinth of config options but having a way to only boot signed things with kexec seems a completely sensible way to operate in the context of signed images.
Quoted 5 lines
I don't know how much that will help given that actors with sufficient resources have demonstrated the ability to steal private keys, but assuming binary signing is an effective technique (or why else do it) then having an option to limit kexec to only loading signed images seems sensible.
I went through the mail chain on web and here are my thoughts.
- So yes, upstream does not have the logic which automatically disables the old syscall (
kexec_load()) on secureboot systems. Distributions carry those patches.- This
KEXEC_VERIFY_SIGoption only cotrols the behavior forkexec_file_load()syscall and is not meant to directly affect any behavior of old syscall (kexec_load()). I think I should have named itKEXEC_FILE_VERIFY_SIG. Though help text makes it clear. "Verify kernel signature duringkexec_file_load()syscall".- I think disabling old system call if
KEXEC_VERIFY_SIG()is set will break existing setup which use old system call by default, except the case of secureboot system. And old syscall path is well tested and new syscall might not be in a position to support all the corner cases, atleast as of now.Ted,
So looks like you are looking for a system/option where you just want to always make use of
kexec_file_load()and disablekexec_load(). This sounds like you want a kernel wherekexec_load()is compiled out and you want onlykexec_file_load()in.Right now one can't do that becase
kexec_file_load()depends onCONFIG_KEXECoption.Quoted 7 lines
I am wondering that how about making
CONFIG_KEXEC_FILE_LOADindependent ofCONFIG_KEXEC. That way one can setCONFIG_KEXEC_VERIFY_SIG=y, and only signed kernel can be kexeced on that system.This should gel well with long term strategy of deprecating
kexec_load()at some point of time whenkexec_file_load()is ready to completely replace it.Quoted 7 lines
Interesting.
I suspect that what we want is to have
CONFIG_KEXECfor the core and additionalCONFIG_KEXEC_LOADoption that covers thatkexec_loadcall.That should make it trivially easy to disable the
kexec_loadsystem call in cases where people care.Or, we could create another option CONFIG_KEXEC_CORE/CONFIG_KEXEC_COMMON which will be automatically selected when either
CONFIG_KEXECorCONIG_KEXEC_FILEare selected.
Quoted 8 lines
Quoted 5 lines
All common code can go under this option and rest can go under respective config options.
That way, those who have
CONFIG_KEXEC=yin old config files will not be broken. They don't have to learn about new options at all.Or simply add a new config option
KEXEC_VERIFY_SIG_FORCE, so we can return error inkexec_loadand print some error message.
Just like below, does this work for you, Ted?
--- arch/x86/Kconfig | 7 +++++++ kernel/kexec.c | 9 ++++++++- 2 files changed, 15 insertions(+), 1 deletion(-)
arch/x86/Kconfig +7 -0
@@ -1755,6 +1755,13 @@ config KEXEC_VERIFY_SIG verification for the corresponding kernel image type being loaded in order for this to work. +config KEXEC_VERIFY_SIG_FORCE + bool "Enforce kexec signature verifying" + depends on KEXEC_VERIFY_SIG + ---help--- + This option disable kexec_load() syscall, only kexec_file_load + can be used. + config KEXEC_BZIMAGE_VERIFY_SIG bool "Enable bzImage signature verification support" depends on KEXEC_VERIFY_SIG
kernel/kexec.c +8 -1
@@ -45,6 +45,12 @@#include <crypto/hash.h> #include <crypto/sha.h> +#ifdef CONFIG_KEXEC_VERIFY_SIG_FORCE +static bool kexec_verify_sig_force = true; +#else +static bool kexec_verify_sig_force; +#endif +/* Per cpu memory for storing cpu states in case of system crash. */ note_buf_t __percpu *crash_notes;
@@ -1243,7 +1249,8 @@ SYSCALL_DEFINE4(kexec_load, unsigned lonint result;/* We only trust the superuser with rebooting the system. */ -if (!capable (CAP_SYS_BOOT ) || kexec_load_disabled) +if (!capable (CAP_SYS_BOOT ) || kexec_load_disabled + || kexec_verify_sig_force)return -EPERM ;/*
On Thu, Jun 18, 2015 at 10:02:09AM +0800, Dave Young wrote:
[..]
Quoted 13 lines
Quoted 2 lines
Or simply add a new config option
KEXEC_VERIFY_SIG_FORCE, so we can return error inkexec_loadand print some error message.Just like below, does this work for you, Ted?
--- arch/x86/Kconfig | 7 +++++++ kernel/kexec.c | 9 ++++++++- 2 files changed, 15 insertions(+), 1 deletion(-)
arch/x86/Kconfig config KEXEC_VERIFY_SIG · line 1764
Quoted 10 lines
arch/x86/Kconfig +7
-0@@ -1755,6 +1755,13 @@ config KEXEC_VERIFY_SIG verification for the corresponding kernel image type being loaded in order for this to work. +config KEXEC_VERIFY_SIG_FORCE + bool "Enforce kexec signature verifying" + depends on KEXEC_VERIFY_SIG + ---help--- + This option disable kexec_load() syscall, only kexec_file_load + can be used. +
Hi Dave,
I think we might not need a new config option. A new config option makes it little confusing. KEXEC_VERIFY_SIG already implies KEXEC_VERIFY_SIG_FORCE (for new syscall). Now extending it to also mean that it should disable old syscall is confusing.
We already have a sysctl knob to disable kexec kernel loading. But that knob disables it on both the syscalls.
May be we can just introduce another command line option say "kexec_verify_sig_force" and this will work across both the syscalls and will deny loading a unsigned kernel in following two cases.
- Using old syscall
- Using new syscall if kernel was compiled with KEXEC_VERIFY_SIG=n.
This should be simple and get us going in short term.
If we want to disable unsigned kernel loading at compile time, then we really need to work on decoupling CONFIG_KEXEC and CONFIG_FILE_KEXEC. Introducing another config option is not the way forward, IMHO.
Thanks
Vivek
Quoted 28 lines
arch/x86/Kconfig +0
-0config KEXEC_BZIMAGE_VERIFY_SIG bool "Enable bzImage signature verification support" depends on KEXEC_VERIFY_SIGkernel/kexec.c +8
-1@@ -45,6 +45,12 @@#include <crypto/hash.h> #include <crypto/sha.h> +#ifdef CONFIG_KEXEC_VERIFY_SIG_FORCE +static bool kexec_verify_sig_force = true; +#else +static bool kexec_verify_sig_force; +#endif +/* Per cpu memory for storing cpu states in case of system crash. */ note_buf_t __percpu *crash_notes;@@ -1243,7 +1249,8 @@ SYSCALL_DEFINE4(kexec_load, unsigned lonint result;/* We only trust the superuser with rebooting the system. */ -if (!capable (CAP_SYS_BOOT ) || kexec_load_disabled) +if (!capable (CAP_SYS_BOOT ) || kexec_load_disabled + || kexec_verify_sig_force)return -EPERM ;/*
Quoted 30 lines · Vivek Goyal
On Thu, Jun 18, 2015 at 10:02:09AM +0800, Dave Young wrote:
[..]
Quoted 13 lines
Quoted 2 lines
Or simply add a new config option
KEXEC_VERIFY_SIG_FORCE, so we can return error inkexec_loadand print some error message.Just like below, does this work for you, Ted?
--- arch/x86/Kconfig | 7 +++++++ kernel/kexec.c | 9 ++++++++- 2 files changed, 15 insertions(+), 1 deletion(-)arch/x86/Kconfig config KEXEC_VERIFY_SIG · line 1764
Quoted 10 lines
arch/x86/Kconfig +7
-0@@ -1755,6 +1755,13 @@ config KEXEC_VERIFY_SIG verification for the corresponding kernel image type being loaded in order for this to work. +config KEXEC_VERIFY_SIG_FORCE + bool "Enforce kexec signature verifying" + depends on KEXEC_VERIFY_SIG + ---help--- + This option disable kexec_load() syscall, only kexec_file_load + can be used. +Hi Dave,
Quoted 4 lines
I think we might not need a new config option. A new config option makes it little confusing.
KEXEC_VERIFY_SIGalready impliesKEXEC_VERIFY_SIG_FORCE(for new syscall). Now extending it to also mean that it should disable old syscall is confusing.
Agreed.
Quoted 7 lines
We already have a sysctl knob to disable kexec kernel loading. But that knob disables it on both the syscalls.
May be we can just introduce another command line option say "
kexec_verify_sig_force" and this will work across both the syscalls and will deny loading a unsigned kernel in following two cases.
Quoted 8 lines
- Using old syscall
- Using new syscall if kernel was compiled with KEXEC_VERIFY_SIG=n.This should be simple and get us going in short term.
If we want to disable unsigned kernel loading at compile time, then we really need to work on decoupling
CONFIG_KEXECandCONFIG_FILE_KEXEC. Introducing another config option is not the way forward, IMHO.
Agreed.
I think disabling kexec_load at compile time can be easily justified.
Anything at runtime is additional complexity, additional bugs, additional documentation and additional maintenance and needs to justify itself.
I currently do not see the case for a magic one time runtime disable of the kexec_load system call. Maybe there is some valid distro case for wanting one kernel to do everything and serve every possible need, but I have not seen that case presented yet.
Eric
Quoted 30 lines · Vivek Goyal
On Thu, Jun 18, 2015 at 10:02:09AM +0800, Dave Young wrote:
[..]
Quoted 13 lines
Quoted 2 lines
Or simply add a new config option
KEXEC_VERIFY_SIG_FORCE, so we can return error inkexec_loadand print some error message.Just like below, does this work for you, Ted?
--- arch/x86/Kconfig | 7 +++++++ kernel/kexec.c | 9 ++++++++- 2 files changed, 15 insertions(+), 1 deletion(-)arch/x86/Kconfig config KEXEC_VERIFY_SIG · line 1764
Quoted 10 lines
arch/x86/Kconfig +7
-0@@ -1755,6 +1755,13 @@ config KEXEC_VERIFY_SIG verification for the corresponding kernel image type being loaded in order for this to work. +config KEXEC_VERIFY_SIG_FORCE + bool "Enforce kexec signature verifying" + depends on KEXEC_VERIFY_SIG + ---help--- + This option disable kexec_load() syscall, only kexec_file_load + can be used. +Hi Dave,
Quoted 4 lines
I think we might not need a new config option. A new config option makes it little confusing.
KEXEC_VERIFY_SIGalready impliesKEXEC_VERIFY_SIG_FORCE(for new syscall). Now extending it to also mean that it should disable old syscall is confusing.
Hmm, it is only reasonable when kexec_file_load can support bypassing sig verifying even when CONFIG_KEXEC_VERIFY_SIG=y.
So agree it is confusing to add a _FORCE new option now.
Quoted 10 lines
We already have a sysctl knob to disable kexec kernel loading. But that knob disables it on both the syscalls.
May be we can just introduce another command line option say "
kexec_verify_sig_force" and this will work across both the syscalls and will deny loading a unsigned kernel in following two cases.- Using old syscall
- Using new syscall if kernel was compiled with KEXEC_VERIFY_SIG=n.
As you said KEXEC_VERIFY_SIG implies KEXEC_VERIFY_SIG_FORCE now so if one disable it in .config, we have no reason to disable kernel loading without signature verifying?
Quoted 6 lines
This should be simple and get us going in short term.
If we want to disable unsigned kernel loading at compile time, then we really need to work on decoupling
CONFIG_KEXECandCONFIG_FILE_KEXEC. Introducing another config option is not the way forward, IMHO.
Yes, let's do it in this way since everyone is fine with it.
Thanks
Dave
Quoted 5 lines
Quoted 3 lines
If we want to disable unsigned kernel loading at compile time, then we really need to work on decoupling
CONFIG_KEXECandCONFIG_FILE_KEXEC. Introducing another config option is not the way forward, IMHO.Yes, let's do it in this way since everyone is fine with it.
I will work on a patch if nobody else have interest or no time on it.
Thanks
Dave
Quoted 7 lines · Dave Young
Quoted 5 lines
Quoted 3 lines
If we want to disable unsigned kernel loading at compile time, then we really need to work on decoupling
CONFIG_KEXECandCONFIG_FILE_KEXEC. Introducing another config option is not the way forward, IMHO.Yes, let's do it in this way since everyone is fine with it.
I will work on a patch if nobody else have interest or no time on it.
Thanks Dave. Will be good if you can get this done.
Thanks
Vivek
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in Please read the FAQ at http://www.tux.org/lkml/
Quoted 10 lines · Vivek Goyal
Quoted 7 lines · Dave Young
Quoted 5 lines
Quoted 3 lines
If we want to disable unsigned kernel loading at compile time, then we really need to work on decoupling
CONFIG_KEXECandCONFIG_FILE_KEXEC. Introducing another config option is not the way forward, IMHO.Yes, let's do it in this way since everyone is fine with it.
I will work on a patch if nobody else have interest or no time on it.
Thanks Dave. Will be good if you can get this done.
Vivek, I worked out some draft patches here:
https://github.com/daveyoung/linux/commits/kexec-syscall-cleanup
Basiclly I split kexec_file first, then add CONFIG_KEXEC_CORE kconfig option then split kexec_load code from general code.
There's a lot of #ifdef CONFIG_KEXEC in kernel source, because CONFIG_KEXEC can be disabled so I changed all kernel general and x86 #ifdef to use CONFIG_KEXEC_CORE if necessary. For other arches dependent code with #ifdef I did not change anything other than the new Kconfig option. It will works because only x86 support KEXEC_FILE.
Please take a look if you have time, if this is not what you want please let me know.
I will have no time this week, only did building test, will do more test next week, if everything is ok I can send out the patches to list for review.
Thanks
Dave
Quoted 24 lines · Dave Young
Quoted 10 lines · Vivek Goyal
Quoted 7 lines · Dave Young
Quoted 5 lines
Quoted 3 lines
If we want to disable unsigned kernel loading at compile time, then we really need to work on decoupling
CONFIG_KEXECandCONFIG_FILE_KEXEC. Introducing another config option is not the way forward, IMHO.Yes, let's do it in this way since everyone is fine with it.
I will work on a patch if nobody else have interest or no time on it.
Thanks Dave. Will be good if you can get this done.
Vivek, I worked out some draft patches here:
https://github.com/daveyoung/linux/commits/kexec-syscall-cleanupBasiclly I split
kexec_filefirst, then addCONFIG_KEXEC_COREkconfig option then splitkexec_loadcode from general code.There's a lot of #ifdef
CONFIG_KEXECin kernel source, becauseCONFIG_KEXECcan be disabled so I changed all kernel general and x86 #ifdef to useCONFIG_KEXEC_COREif necessary. For other arches dependent code with #ifdef I did not change anything other than the newKconfigoption. It will works because only x86 supportKEXEC_FILE.
Quoted 5 lines
Please take a look if you have time, if this is not what you want please let me know.
I will have no time this week, only did building test, will do more test next week, if everything is ok I can send out the patches to list for review.
Hi Dave,
I have put few comments in github. Please have a look. Once you have another version of patches, I will have another look.
Thanks
Vivek
Quoted 28 lines · Vivek Goyal
Quoted 27 lines · Dave Young
Quoted 10 lines · Vivek Goyal
Quoted 7 lines · Dave Young
Quoted 5 lines
Quoted 3 lines
If we want to disable unsigned kernel loading at compile time, then we really need to work on decoupling
CONFIG_KEXECandCONFIG_FILE_KEXEC. Introducing another config option is not the way forward, IMHO.Yes, let's do it in this way since everyone is fine with it.
I will work on a patch if nobody else have interest or no time on it.
Thanks Dave. Will be good if you can get this done.
Vivek, I worked out some draft patches here:
https://github.com/daveyoung/linux/commits/kexec-syscall-cleanupBasiclly I split
kexec_filefirst, then addCONFIG_KEXEC_COREkconfig option then splitkexec_loadcode from general code.There's a lot of #ifdef
CONFIG_KEXECin kernel source, becauseCONFIG_KEXECcan be disabled so I changed all kernel general and x86 #ifdef to useCONFIG_KEXEC_COREif necessary. For other arches dependent code with #ifdef I did not change anything other than the newKconfigoption. It will works because only x86 supportKEXEC_FILE.Please take a look if you have time, if this is not what you want please let me know.
Quoted 7 lines
Quoted 2 lines
I will have no time this week, only did building test, will do more test next week, if everything is ok I can send out the patches to list for review.
Hi Dave,
I have put few comments in github. Please have a look. Once you have another version of patches, I will have another look.
Vivek, thanks a lot. Will have a look.
Dave
Quoted 87 lines · Vivek Goyal
Quoted 74 lines · Eric W. Biederman
Quoted 64 lines · Vivek Goyal
Quoted 29 lines · Eric W. Biederman
Adding Vivek as he is the one who implemented
kexec_file_load. I was hoping he would respond to this thread, and it looks like he simply has not ever been Cc'd.Quoted 5 lines · Theodore Ts'o
Quoted 3 lines · Josh Boyer
The bits that actually read Secure Boot state out of the UEFI variables, and apply protections to the machine to avoid compromise under the SB threat model. Things like disabling the old kexec...
Quoted 8 lines
I don't have any real interest in using Secure Boot, but I *am* interested in using CONFIG_KEXEC_VERIFY_SIG[1]. So perhaps we need to have something similar to what we have with signed modules in terms of
CONFIG_MODULE_SIG_FORCEand module/sig_enforce, but forKEXEC_VERIFY_SIG. This would mean creating a separate flag independent of the one Linus suggested for Secure Boot, but since we have one for signed modules, we do have precedent for this sort of thing.My overall request with respect to kexec has been that we implement things that make sense outside of the bizarre threat model of the Linux folks who were talking about secure boot.
nI have not navigated the labyrinth of config options but having a way to only boot signed things with kexec seems a completely sensible way to operate in the context of signed images.
Quoted 5 lines
I don't know how much that will help given that actors with sufficient resources have demonstrated the ability to steal private keys, but assuming binary signing is an effective technique (or why else do it) then having an option to limit kexec to only loading signed images seems sensible.
I went through the mail chain on web and here are my thoughts.
- So yes, upstream does not have the logic which automatically disables the old syscall (
kexec_load()) on secureboot systems. Distributions carry those patches.- This
KEXEC_VERIFY_SIGoption only cotrols the behavior forkexec_file_load()syscall and is not meant to directly affect any behavior of old syscall (kexec_load()). I think I should have named itKEXEC_FILE_VERIFY_SIG. Though help text makes it clear. "Verify kernel signature duringkexec_file_load()syscall".- I think disabling old system call if
KEXEC_VERIFY_SIG()is set will break existing setup which use old system call by default, except the case of secureboot system. And old syscall path is well tested and new syscall might not be in a position to support all the corner cases, atleast as of now.Ted,
So looks like you are looking for a system/option where you just want to always make use of
kexec_file_load()and disablekexec_load(). This sounds like you want a kernel wherekexec_load()is compiled out and you want onlykexec_file_load()in.Right now one can't do that becase
kexec_file_load()depends onCONFIG_KEXECoption.Quoted 7 lines
I am wondering that how about making
CONFIG_KEXEC_FILE_LOADindependent ofCONFIG_KEXEC. That way one can setCONFIG_KEXEC_VERIFY_SIG=y, and only signed kernel can be kexeced on that system.This should gel well with long term strategy of deprecating
kexec_load()at some point of time whenkexec_file_load()is ready to completely replace it.Quoted 7 lines
Interesting.
I suspect that what we want is to have
CONFIG_KEXECfor the core and additionalCONFIG_KEXEC_LOADoption that covers thatkexec_loadcall.That should make it trivially easy to disable the
kexec_loadsystem call in cases where people care.Or, we could create another option CONFIG_KEXEC_CORE/CONFIG_KEXEC_COMMON which will be automatically selected when either
CONFIG_KEXECorCONIG_KEXEC_FILEare selected.
Quoted 5 lines
All common code can go under this option and rest can go under respective config options.
That way, those who have
CONFIG_KEXEC=yin old config files will not be broken. They don't have to learn about new options at all.
Vivek, It is slight better for reusing old config file, but CONFIG_KEXEC_LOAD sounds better. Do we have to maintain the compability for kconfig?
KEXEC_COMMON/KEXEC/KEXEC_FILE_LOAD is a little confusing. CONFIG_KEXEC should be the common kexec stuff naturally, it is strange to use CONFIG_KEXEC for only kexec_load syscall.
Thanks
Dave
Quoted 94 lines · Dave Young
Quoted 87 lines · Vivek Goyal
Quoted 74 lines · Eric W. Biederman
Quoted 64 lines · Vivek Goyal
Quoted 29 lines · Eric W. Biederman
Adding Vivek as he is the one who implemented
kexec_file_load. I was hoping he would respond to this thread, and it looks like he simply has not ever been Cc'd.Quoted 5 lines · Theodore Ts'o
Quoted 3 lines · Josh Boyer
The bits that actually read Secure Boot state out of the UEFI variables, and apply protections to the machine to avoid compromise under the SB threat model. Things like disabling the old kexec...
Quoted 8 lines
I don't have any real interest in using Secure Boot, but I *am* interested in using CONFIG_KEXEC_VERIFY_SIG[1]. So perhaps we need to have something similar to what we have with signed modules in terms of
CONFIG_MODULE_SIG_FORCEand module/sig_enforce, but forKEXEC_VERIFY_SIG. This would mean creating a separate flag independent of the one Linus suggested for Secure Boot, but since we have one for signed modules, we do have precedent for this sort of thing.My overall request with respect to kexec has been that we implement things that make sense outside of the bizarre threat model of the Linux folks who were talking about secure boot.
nI have not navigated the labyrinth of config options but having a way to only boot signed things with kexec seems a completely sensible way to operate in the context of signed images.
Quoted 5 lines
I don't know how much that will help given that actors with sufficient resources have demonstrated the ability to steal private keys, but assuming binary signing is an effective technique (or why else do it) then having an option to limit kexec to only loading signed images seems sensible.
I went through the mail chain on web and here are my thoughts.
- So yes, upstream does not have the logic which automatically disables the old syscall (
kexec_load()) on secureboot systems. Distributions carry those patches.- This
KEXEC_VERIFY_SIGoption only cotrols the behavior forkexec_file_load()syscall and is not meant to directly affect any behavior of old syscall (kexec_load()). I think I should have named itKEXEC_FILE_VERIFY_SIG. Though help text makes it clear. "Verify kernel signature duringkexec_file_load()syscall".- I think disabling old system call if
KEXEC_VERIFY_SIG()is set will break existing setup which use old system call by default, except the case of secureboot system. And old syscall path is well tested and new syscall might not be in a position to support all the corner cases, atleast as of now.Ted,
So looks like you are looking for a system/option where you just want to always make use of
kexec_file_load()and disablekexec_load(). This sounds like you want a kernel wherekexec_load()is compiled out and you want onlykexec_file_load()in.Right now one can't do that becase
kexec_file_load()depends onCONFIG_KEXECoption.Quoted 7 lines
I am wondering that how about making
CONFIG_KEXEC_FILE_LOADindependent ofCONFIG_KEXEC. That way one can setCONFIG_KEXEC_VERIFY_SIG=y, and only signed kernel can be kexeced on that system.This should gel well with long term strategy of deprecating
kexec_load()at some point of time whenkexec_file_load()is ready to completely replace it.Quoted 7 lines
Interesting.
I suspect that what we want is to have
CONFIG_KEXECfor the core and additionalCONFIG_KEXEC_LOADoption that covers thatkexec_loadcall.That should make it trivially easy to disable the
kexec_loadsystem call in cases where people care.Or, we could create another option CONFIG_KEXEC_CORE/CONFIG_KEXEC_COMMON which will be automatically selected when either
CONFIG_KEXECorCONIG_KEXEC_FILEare selected.Quoted 5 lines
All common code can go under this option and rest can go under respective config options.
That way, those who have
CONFIG_KEXEC=yin old config files will not be broken. They don't have to learn about new options at all.
Quoted 6 lines
Vivek, It is slight better for reusing old config file, but
CONFIG_KEXEC_LOADsounds better. Do we have to maintain the compability for kconfig?KEXEC_COMMON/KEXEC/KEXEC_FILE_LOAD is a little confusing.
CONFIG_KEXECshould be the common kexec stuff naturally, it is strange to useCONFIG_KEXECfor onlykexec_loadsyscall.
Hi Dave,
I think as a user I would like my old config file to work with new kernel. It is a good idea to keep old config options until and unless we have a very good reason.
To me following should be reasonable.
CONFIG_KEXEC --> Enable old syscallCONFIG_FILE_KEXEC --> Enable new syscall
In fact we might not have to introduce CONFIG_KEXEC_COMMON. We can just use
#ifdef (CONFIG_KEXEC) | ifdef (CONFIG_FILE_KEXEC
/* Common code between two syscalls */
#endif
That way we don't introduce any new config options and stick to existing ones.
Thanks
Vivek
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in Please read the FAQ at http://www.tux.org/lkml/
Quoted 5 lines · Vivek Goyal
So looks like you are looking for a system/option where you just want to always make use of
kexec_file_load()and disablekexec_load(). This sounds like you want a kernel wherekexec_load()is compiled out and you want onlykexec_file_load()in.
Either compiled out or disabled via some flag (similar to how signed moduled verification can be required via a flag that can be set, but not unset once it is set), yes.
Quoted 6 lines
Right now one can't do that becase
kexec_file_load()depends onCONFIG_KEXECoption.I am wondering that how about making
CONFIG_KEXEC_FILE_LOADindependent ofCONFIG_KEXEC. That way one can setCONFIG_KEXEC_VERIFY_SIG=y, and only signed kernel can be kexeced on that system.
That would certianly also be a workable strategy.
Quoted 3 lines
This should gel well with long term strategy of deprecating
kexec_load()at some point of time whenkexec_file_load()is ready to completely replace it.
Well, note that Debian and Ubuntu are still using kexec-tools 2.0.7 (even in their latest development/unstable releases), which doesn't have support for kexec_file_load(). So we need to get Debian to upgrade its kexec-tools as part of this. I'll try to file a nag-o-gram to the Debian BTS.
- Ted
Quoted 10 lines
[1] Yes, it doesn't buy all that much, since if the system is rooted the adversary can just replace the kernel in /boot and force a normal, slower reboot, but the same could be said for signed modules --- the adversary could just replace all of /boot/vmlinux-<kver> and /lib/modules/<kver>. But both measures make it a tad more bit difficult, especially for the adversary to do this replacement without being noticed (for example linode will send me e-mail if the system reboots normally, but not with a kexec-mediated reboot), and for cloud systems where we don't have secure boot anyway, it's about the best we can do.
It's about the same as the protection offered by the "secure" boot patches I've seen because they don't block all kernel boot parameters except a whitelist and because there are a pile of other fairly fundamental problems that probably require you also sign the root file system, which is itself a world of pain.
Alan
_______________________________________________
kexec mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/kexec
Quoted 5 lines · Theodore Ts'o
Quoted 3 lines · Josh Boyer
The bits that actually read Secure Boot state out of the UEFI variables, and apply protections to the machine to avoid compromise under the SB threat model. Things like disabling the old kexec...
Quoted 8 lines
I don't have any real interest in using Secure Boot, but I *am* interested in using CONFIG_KEXEC_VERIFY_SIG[1]. So perhaps we need to have something similar to what we have with signed modules in terms of
CONFIG_MODULE_SIG_FORCEand module/sig_enforce, but forKEXEC_VERIFY_SIG. This would mean creating a separate flag independent of the one Linus suggested for Secure Boot, but since we have one for signed modules, we do have precedent for this sort of thing.
Agree and vote for this way as I replied in another email about CONFIG_KEXEC_VERIFY_SIG_FORCE.
Thanks
Dave