From: Evan Green <evgreen@chromium.org>
To: linux-kernel@vger.kernel.org
Cc: Matthew Garrett <mgarrett@aurora.tech>,
dlunev@google.com, zohar@linux.ibm.com, jejb@linux.ibm.com,
linux-integrity@vger.kernel.org, corbet@lwn.net,
rjw@rjwysocki.net, gwendal@chromium.org, jarkko@kernel.org,
linux-pm@vger.kernel.org, Evan Green <evgreen@chromium.org>,
Len Brown <len.brown@intel.com>, Pavel Machek <pavel@ucw.cz>,
"Rafael J. Wysocki" <rafael@kernel.org>
Subject: [PATCH 07/10] PM: hibernate: Use TPM-backed keys to encrypt image
Date: Wed, 4 May 2022 16:20:59 -0700 [thread overview]
Message-ID: <20220504161439.7.Ibd067e73916b9fae268a5824c2dd037416426af8@changeid> (raw)
In-Reply-To: <20220504232102.469959-1-evgreen@chromium.org>
When using encrypted hibernate images, have the TPM create a key for us
and seal it. By handing back a sealed blob instead of the raw key, we
prevent usermode from being able to decrypt and tamper with the
hibernate image on a different machine.
We'll also go through the motions of having PCR23 set to a known value at
the time of key creation and unsealing. Currently there's nothing that
enforces the contents of PCR23 as a condition to unseal the key blob,
that will come in a later change.
Sourced-from: Matthew Garrett <mjg59@google.com>
Signed-off-by: Evan Green <evgreen@chromium.org>
---
Matthew's incarnation of this patch is at:
https://patchwork.kernel.org/project/linux-pm/patch/20210220013255.1083202-9-matthewgarrett@google.com/
kernel/power/Kconfig | 2 +
kernel/power/snapenc.c | 195 +++++++++++++++++++++++++++++++++++++++--
kernel/power/user.h | 1 +
3 files changed, 189 insertions(+), 9 deletions(-)
diff --git a/kernel/power/Kconfig b/kernel/power/Kconfig
index 8249968962bcd5..d8077391feb290 100644
--- a/kernel/power/Kconfig
+++ b/kernel/power/Kconfig
@@ -96,6 +96,8 @@ config ENCRYPTED_HIBERNATION
bool "Encryption support for userspace snapshots"
depends on HIBERNATION_SNAPSHOT_DEV
depends on CRYPTO_AEAD2=y
+ depends on KEYS
+ depends on TRUSTED_KEYS
default n
help
Enable support for kernel-based encryption of hibernation snapshots
diff --git a/kernel/power/snapenc.c b/kernel/power/snapenc.c
index cb90692d6ab83a..2bd5fe05a321e7 100644
--- a/kernel/power/snapenc.c
+++ b/kernel/power/snapenc.c
@@ -4,13 +4,23 @@
#include <linux/crypto.h>
#include <crypto/aead.h>
#include <crypto/gcm.h>
+#include <keys/trusted-type.h>
+#include <linux/key-type.h>
#include <linux/random.h>
#include <linux/mm.h>
+#include <linux/tpm.h>
#include <linux/uaccess.h>
#include "power.h"
#include "user.h"
+/* sha256("To sleep, perchance to dream") */
+static struct tpm_digest known_digest = { .alg_id = TPM_ALG_SHA256,
+ .digest = {0x92, 0x78, 0x3d, 0x79, 0x2d, 0x00, 0x31, 0xb0, 0x55, 0xf9,
+ 0x1e, 0x0d, 0xce, 0x83, 0xde, 0x1d, 0xc4, 0xc5, 0x8e, 0x8c,
+ 0xf1, 0x22, 0x38, 0x6c, 0x33, 0xb1, 0x14, 0xb7, 0xec, 0x05,
+ 0x5f, 0x49}};
+
/* Encrypt more data from the snapshot into the staging area. */
static int snapshot_encrypt_refill(struct snapshot_data *data)
{
@@ -313,6 +323,12 @@ void snapshot_teardown_encryption(struct snapshot_data *data)
{
int i;
+ if (data->key) {
+ key_revoke(data->key);
+ key_put(data->key);
+ data->key = NULL;
+ }
+
if (data->aead_req) {
aead_request_free(data->aead_req);
data->aead_req = NULL;
@@ -381,11 +397,77 @@ static int snapshot_setup_encryption_common(struct snapshot_data *data)
return rc;
}
+static int snapshot_create_kernel_key(struct snapshot_data *data)
+{
+ const struct cred *cred = current_cred();
+ struct tpm_digest *digests = NULL;
+ struct tpm_chip *chip;
+ struct key *key;
+ int ret, i;
+ /* Create a key sealed by the SRK. */
+ char *keyinfo = "new\t32\tkeyhandle=0x81000000";
+
+ chip = tpm_default_chip();
+ if (!chip)
+ return -ENODEV;
+
+ if (!(tpm_is_tpm2(chip)))
+ return -ENODEV;
+
+ ret = tpm_pcr_reset(chip, 23);
+ if (ret != 0)
+ return ret;
+
+ digests = kcalloc(chip->nr_allocated_banks, sizeof(struct tpm_digest),
+ GFP_KERNEL);
+ if (!digests) {
+ ret = -ENOMEM;
+ goto reset;
+ }
+
+ for (i = 0; i <= chip->nr_allocated_banks; i++) {
+ digests[i].alg_id = chip->allocated_banks[i].alg_id;
+ if (digests[i].alg_id == known_digest.alg_id)
+ memcpy(&digests[i], &known_digest, sizeof(known_digest));
+ }
+
+ ret = tpm_pcr_extend(chip, 23, digests);
+ if (ret != 0)
+ goto reset;
+
+ key = key_alloc(&key_type_trusted, "swsusp", GLOBAL_ROOT_UID,
+ GLOBAL_ROOT_GID, cred, 0, KEY_ALLOC_NOT_IN_QUOTA,
+ NULL);
+
+ if (IS_ERR(key)) {
+ ret = PTR_ERR(key);
+ goto reset;
+ }
+
+ ret = key_instantiate_and_link(key, keyinfo, strlen(keyinfo) + 1, NULL,
+ NULL);
+ if (ret < 0)
+ goto out;
+
+ data->key = key;
+ key = NULL;
+
+out:
+ if (key) {
+ key_revoke(key);
+ key_put(key);
+ }
+reset:
+ kfree(digests);
+ tpm_pcr_reset(chip, 23);
+ return ret;
+}
+
int snapshot_get_encryption_key(struct snapshot_data *data,
struct uswsusp_key_blob __user *key)
{
- u8 aead_key[SNAPSHOT_ENCRYPTION_KEY_SIZE];
u8 nonce[USWSUSP_KEY_NONCE_SIZE];
+ struct trusted_key_payload *payload;
int rc;
/* Don't pull a random key from a world that can be reset. */
if (data->ready)
@@ -399,21 +481,28 @@ int snapshot_get_encryption_key(struct snapshot_data *data,
get_random_bytes(nonce, sizeof(nonce));
memcpy(&data->nonce_low, &nonce[0], sizeof(data->nonce_low));
memcpy(&data->nonce_high, &nonce[8], sizeof(data->nonce_high));
- /* Build a random key */
- get_random_bytes(aead_key, sizeof(aead_key));
- rc = crypto_aead_setkey(data->aead_tfm, aead_key, sizeof(aead_key));
+
+ /* Create a kernel key, and set it. */
+ rc = snapshot_create_kernel_key(data);
+ if (rc)
+ goto fail;
+
+ payload = data->key->payload.data[0];
+ /* Install the key */
+ rc = crypto_aead_setkey(data->aead_tfm, payload->key, SNAPSHOT_ENCRYPTION_KEY_SIZE);
if (rc)
goto fail;
- /* Hand the key back to user mode (to be changed!) */
- rc = put_user(sizeof(struct uswsusp_key_blob), &key->blob_len);
+ /* Hand the key back to user mode in sealed form. */
+ rc = put_user(payload->blob_len, &key->blob_len);
if (rc)
goto fail;
- rc = copy_to_user(&key->blob, &aead_key, sizeof(aead_key));
+ rc = copy_to_user(&key->blob, &payload->blob, payload->blob_len);
if (rc)
goto fail;
+ /* The nonce just gets handed back in the clear. */
rc = copy_to_user(&key->nonce, &nonce, sizeof(nonce));
if (rc)
goto fail;
@@ -425,10 +514,93 @@ int snapshot_get_encryption_key(struct snapshot_data *data,
return rc;
}
+static int snapshot_load_kernel_key(struct snapshot_data *data,
+ struct uswsusp_key_blob *blob)
+{
+
+ const struct cred *cred = current_cred();
+ char *keytemplate = "load\t%s\tkeyhandle=0x81000000";
+ struct tpm_digest *digests = NULL;
+ char *blobstring = NULL;
+ char *keyinfo = NULL;
+ struct tpm_chip *chip;
+ struct key *key;
+ int i, ret;
+
+ chip = tpm_default_chip();
+ if (!chip)
+ return -ENODEV;
+
+ if (!(tpm_is_tpm2(chip)))
+ return -ENODEV;
+
+ ret = tpm_pcr_reset(chip, 23);
+ if (ret != 0)
+ return ret;
+
+ digests = kcalloc(chip->nr_allocated_banks, sizeof(struct tpm_digest),
+ GFP_KERNEL);
+ if (!digests)
+ goto reset;
+
+ for (i = 0; i <= chip->nr_allocated_banks; i++) {
+ digests[i].alg_id = chip->allocated_banks[i].alg_id;
+ if (digests[i].alg_id == known_digest.alg_id)
+ memcpy(&digests[i], &known_digest, sizeof(known_digest));
+ }
+
+ ret = tpm_pcr_extend(chip, 23, digests);
+ if (ret != 0)
+ goto reset;
+
+ blobstring = kmalloc(blob->blob_len * 2, GFP_KERNEL);
+ if (!blobstring) {
+ ret = -ENOMEM;
+ goto reset;
+ }
+
+ bin2hex(blobstring, blob->blob, blob->blob_len);
+ keyinfo = kasprintf(GFP_KERNEL, keytemplate, blobstring);
+ if (!keyinfo) {
+ ret = -ENOMEM;
+ goto reset;
+ }
+
+ key = key_alloc(&key_type_trusted, "swsusp", GLOBAL_ROOT_UID,
+ GLOBAL_ROOT_GID, cred, 0, KEY_ALLOC_NOT_IN_QUOTA,
+ NULL);
+
+ if (IS_ERR(key)) {
+ ret = PTR_ERR(key);
+ goto out;
+ }
+
+ ret = key_instantiate_and_link(key, keyinfo, strlen(keyinfo) + 1, NULL,
+ NULL);
+ if (ret < 0)
+ goto out;
+
+ data->key = key;
+ key = NULL;
+
+out:
+ if (key) {
+ key_revoke(key);
+ key_put(key);
+ }
+reset:
+ kfree(keyinfo);
+ kfree(blobstring);
+ kfree(digests);
+ tpm_pcr_reset(chip, 23);
+ return ret;
+}
+
int snapshot_set_encryption_key(struct snapshot_data *data,
struct uswsusp_key_blob __user *key)
{
struct uswsusp_key_blob blob;
+ struct trusted_key_payload *payload;
int rc;
/* It's too late if data's been pushed in. */
@@ -444,13 +616,18 @@ int snapshot_set_encryption_key(struct snapshot_data *data,
if (rc)
goto crypto_setup_fail;
- if (blob.blob_len != sizeof(struct uswsusp_key_blob)) {
+ if (blob.blob_len > sizeof(key->blob)) {
rc = -EINVAL;
goto crypto_setup_fail;
}
+ rc = snapshot_load_kernel_key(data, &blob);
+ if (rc)
+ goto crypto_setup_fail;
+
+ payload = data->key->payload.data[0];
rc = crypto_aead_setkey(data->aead_tfm,
- blob.blob,
+ payload->key,
SNAPSHOT_ENCRYPTION_KEY_SIZE);
if (rc)
diff --git a/kernel/power/user.h b/kernel/power/user.h
index 6823e2eba7ec53..591b30bb213349 100644
--- a/kernel/power/user.h
+++ b/kernel/power/user.h
@@ -31,6 +31,7 @@ struct snapshot_data {
uint64_t crypt_total;
uint64_t nonce_low;
uint64_t nonce_high;
+ struct key *key;
#endif
};
--
2.31.0
next prev parent reply other threads:[~2022-05-04 23:48 UTC|newest]
Thread overview: 42+ messages / expand[flat|nested] mbox.gz Atom feed top
2022-05-04 23:20 [PATCH 00/10] Encrypted Hibernation Evan Green
2022-05-04 23:20 ` [PATCH 01/10] tpm: Add support for in-kernel resetting of PCRs Evan Green
2022-05-04 23:20 ` [PATCH 02/10] tpm: Allow PCR 23 to be restricted to kernel-only use Evan Green
2022-05-04 23:20 ` [PATCH 03/10] security: keys: trusted: Parse out individual components of the key blob Evan Green
2022-05-04 23:20 ` [PATCH 04/10] security: keys: trusted: Allow storage of PCR values in creation data Evan Green
2022-08-02 23:00 ` Eric Biggers
2022-08-03 20:48 ` Evan Green
2022-05-04 23:20 ` [PATCH 05/10] security: keys: trusted: Verify " Evan Green
2022-05-04 23:20 ` [PATCH 06/10] PM: hibernate: Add kernel-based encryption Evan Green
2022-08-29 21:45 ` TPM: hibernate with IMA PCR 10 Ken Goldman
2022-08-29 21:51 ` Matthew Garrett
2022-08-31 2:48 ` Jarkko Sakkinen
2022-09-07 20:47 ` Evan Green
2022-09-07 23:57 ` Mimi Zohar
2022-09-08 5:25 ` Jarkko Sakkinen
2022-09-11 2:40 ` Mimi Zohar
2022-09-20 4:36 ` Jarkko Sakkinen
2022-09-21 20:15 ` Mimi Zohar
2022-09-23 13:30 ` Jarkko Sakkinen
2022-09-27 16:03 ` Evan Green
2022-09-28 9:42 ` Jonathan McDowell
2022-05-04 23:20 ` Evan Green [this message]
2022-05-04 23:21 ` [PATCH 08/10] PM: hibernate: Mix user key in encrypted hibernate Evan Green
2022-05-06 16:08 ` Pavel Machek
2022-05-09 16:44 ` Evan Green
2022-05-10 12:29 ` Pavel Machek
2022-05-10 16:02 ` Evan Green
2022-08-02 22:48 ` Eric Biggers
2022-08-03 20:48 ` Evan Green
2022-05-04 23:21 ` [PATCH 09/10] PM: hibernate: Verify the digest encryption key Evan Green
2022-08-02 22:51 ` Eric Biggers
2022-05-04 23:21 ` [PATCH 10/10] PM: hibernate: seal the encryption key with a PCR policy Evan Green
2022-05-06 16:08 ` [PATCH 00/10] Encrypted Hibernation Pavel Machek
2022-05-09 16:43 ` Evan Green
2022-05-17 16:06 ` Rafael J. Wysocki
2022-05-17 17:34 ` Evan Green
2022-06-16 15:42 ` Evan Green
2022-08-01 22:32 ` Evan Green
2022-08-02 18:36 ` Matthew Garrett
2022-08-04 0:59 ` Jarkko Sakkinen
2022-08-04 21:55 ` Evan Green
2022-08-06 18:21 ` Jarkko Sakkinen
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20220504161439.7.Ibd067e73916b9fae268a5824c2dd037416426af8@changeid \
--to=evgreen@chromium.org \
--cc=corbet@lwn.net \
--cc=dlunev@google.com \
--cc=gwendal@chromium.org \
--cc=jarkko@kernel.org \
--cc=jejb@linux.ibm.com \
--cc=len.brown@intel.com \
--cc=linux-integrity@vger.kernel.org \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-pm@vger.kernel.org \
--cc=mgarrett@aurora.tech \
--cc=pavel@ucw.cz \
--cc=rafael@kernel.org \
--cc=rjw@rjwysocki.net \
--cc=zohar@linux.ibm.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).