@@ -7,6 +7,7 @@
#include <linux/random.h>
#include <linux/acpi.h>
#include <linux/delay.h>
+#include <linux/random.h>
#include <asm/cacheflush.h>
#include <asm/fpu/api.h>
@@ -15,27 +16,34 @@
#include <asm/tlbflush.h>
static bool keybackup_available;
+static bool keyhwrand_available;
/* Internal (Wrapping) Key size fits in three 128-bit registers. */
#define KEYSIZE_128BIT 3
static struct _keydata {
bool valid;
+ bool hwrand;
struct reg_128_bit value[KEYSIZE_128BIT];
} keydata;
/**
* make_keylocker_data() - Generate the internal key.
+ * @use_hwrand: True if use hardware randomization; otherwise, false.
*
* Return: Nothing
*/
-static void make_keylocker_data(void)
+static void make_keylocker_data(bool use_hwrand)
{
int i;
for (i = 0; i < KEYSIZE_128BIT; i++)
get_random_bytes(&keydata.value[i], sizeof(struct reg_128_bit));
+ keydata.hwrand = (use_hwrand && keyhwrand_available && keybackup_available);
+ if (use_hwrand && !keydata.hwrand)
+ pr_warn("x86/keylocker: hardware random key is not fully supported\n");
+
keydata.valid = true;
}
@@ -59,6 +67,8 @@ void flush_keylocker_data(void)
}
#define KEYSRC_SWRAND 0
+#define KEYSRC_HWRAND BIT(1)
+#define KEYSRC_HWRAND_RETRY 10
/**
* load_keylocker() - Load the internal key.
@@ -68,8 +78,16 @@ void flush_keylocker_data(void)
static int load_keylocker(void)
{
struct reg_128_bit zeros = { 0 };
- u32 keysrc = KEYSRC_SWRAND;
- int err;
+ int retry, err;
+ u32 keysrc;
+
+ if (keydata.hwrand) {
+ keysrc = KEYSRC_HWRAND;
+ retry = KEYSRC_HWRAND_RETRY;
+ } else {
+ keysrc = KEYSRC_SWRAND;
+ retry = 0;
+ }
kernel_fpu_begin();
@@ -78,13 +96,19 @@ static int load_keylocker(void)
"m"(keydata.value[1]),
"m"(keydata.value[2]));
- err = loadiwkey(keysrc);
+ do {
+ err = loadiwkey(keysrc);
+ retry--;
+ } while (err && retry >= 0);
asm volatile ("movdqu %0, %%xmm0; movdqu %0, %%xmm1; movdqu %0, %%xmm2;"
:: "m"(zeros));
kernel_fpu_end();
+ if (keydata.hwrand)
+ flush_keylocker_data();
+
return err;
}
@@ -138,6 +162,7 @@ void setup_keylocker(struct cpuinfo_x86 *c)
cr4_set_bits(X86_CR4_KEYLOCKER);
if (c == &boot_cpu_data) {
+ bool use_hwrand = check_random_trust_cpu();
u32 eax, ebx, ecx, edx;
cpuid_count(KEYLOCKER_CPUID, 0, &eax, &ebx, &ecx, &edx);
@@ -156,7 +181,9 @@ void setup_keylocker(struct cpuinfo_x86 *c)
goto disable;
}
- make_keylocker_data();
+ keyhwrand_available = (ecx & KEYLOCKER_CPUID_ECX_RAND);
+
+ make_keylocker_data(use_hwrand);
err = load_keylocker();
if (err) {
@@ -771,6 +771,12 @@ static int __init parse_trust_cpu(char *arg)
}
early_param("random.trust_cpu", parse_trust_cpu);
+bool check_random_trust_cpu(void)
+{
+ return trust_cpu;
+}
+EXPORT_SYMBOL(check_random_trust_cpu);
+
static bool crng_init_try_arch(struct crng_state *crng)
{
int i;
@@ -158,4 +158,6 @@ static inline bool __init arch_get_random_long_early(unsigned long *v)
}
#endif
+extern bool check_random_trust_cpu(void);
+
#endif /* _LINUX_RANDOM_H */
Hardware can load the internal key with randomization. The random.trust_cpu parameter determines the use of the CPU's random number generator. Take it to use the CPU's internal key randomization. The feature's backup mechanism is required to distribute an internal key. This is the only way to copy it to other CPUs if using hardware randomization. This option is disabled when hardware does not support the key backup. Signed-off-by: Chang S. Bae <chang.seok.bae@intel.com> Cc: Mark Brown <broonie@kernel.org> Cc: x86@kernel.org Cc: linux-doc@vger.kernel.org Cc: linux-kernel@vger.kernel.org --- arch/x86/kernel/keylocker.c | 37 ++++++++++++++++++++++++++++++++----- drivers/char/random.c | 6 ++++++ include/linux/random.h | 2 ++ 3 files changed, 40 insertions(+), 5 deletions(-)