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>,
Hao Wu <hao.wu@rubrik.com>, Len Brown <len.brown@intel.com>,
Matthew Garrett <matthewgarrett@google.com>,
Pavel Machek <pavel@ucw.cz>,
"Rafael J. Wysocki" <rafael@kernel.org>, axelj <axelj@axis.com>
Subject: [PATCH 10/10] PM: hibernate: seal the encryption key with a PCR policy
Date: Wed, 4 May 2022 16:21:02 -0700 [thread overview]
Message-ID: <20220504161439.10.Ifce072ae1ef1ce39bd681fff55af13a054045d9f@changeid> (raw)
In-Reply-To: <20220504232102.469959-1-evgreen@chromium.org>
The key blob is not secret, and by default the TPM will happily unseal
it regardless of system state. We can protect against that by sealing
the secret with a PCR policy - if the current PCR state doesn't match,
the TPM will refuse to release the secret. For now let's just seal it to
PCR 23. In the long term we may want a more flexible policy around this,
such as including PCR 7 for PCs or 0 for Chrome OS.
Sourced-from: Matthew Garrett <mjg59@google.com>
Signed-off-by: Evan Green <evgreen@chromium.org>
---
The original version of this patch is here:
https://patchwork.kernel.org/project/linux-pm/patch/20210220013255.1083202-10-matthewgarrett@google.com/
include/linux/tpm.h | 4 +
kernel/power/snapenc.c | 163 +++++++++++++++++++++++++++++++++++++++--
2 files changed, 160 insertions(+), 7 deletions(-)
diff --git a/include/linux/tpm.h b/include/linux/tpm.h
index 438f8bc0a50582..cd520efc515bca 100644
--- a/include/linux/tpm.h
+++ b/include/linux/tpm.h
@@ -233,18 +233,22 @@ enum tpm2_command_codes {
TPM2_CC_CONTEXT_LOAD = 0x0161,
TPM2_CC_CONTEXT_SAVE = 0x0162,
TPM2_CC_FLUSH_CONTEXT = 0x0165,
+ TPM2_CC_START_AUTH_SESSION = 0x0176,
TPM2_CC_VERIFY_SIGNATURE = 0x0177,
TPM2_CC_GET_CAPABILITY = 0x017A,
TPM2_CC_GET_RANDOM = 0x017B,
TPM2_CC_PCR_READ = 0x017E,
+ TPM2_CC_POLICY_PCR = 0x017F,
TPM2_CC_PCR_EXTEND = 0x0182,
TPM2_CC_EVENT_SEQUENCE_COMPLETE = 0x0185,
TPM2_CC_HASH_SEQUENCE_START = 0x0186,
+ TPM2_CC_POLICY_GET_DIGEST = 0x0189,
TPM2_CC_CREATE_LOADED = 0x0191,
TPM2_CC_LAST = 0x0193, /* Spec 1.36 */
};
enum tpm2_permanent_handles {
+ TPM2_RH_NULL = 0x40000007,
TPM2_RS_PW = 0x40000009,
};
diff --git a/kernel/power/snapenc.c b/kernel/power/snapenc.c
index 38bc820f780d8b..9d140c62b49db1 100644
--- a/kernel/power/snapenc.c
+++ b/kernel/power/snapenc.c
@@ -495,6 +495,111 @@ void snapshot_teardown_encryption(struct snapshot_data *data)
memset(data->user_key, 0, sizeof(data->user_key));
}
+static int tpm_setup_policy(struct tpm_chip *chip, int *session_handle)
+{
+ struct tpm_header *head;
+ struct tpm_buf buf;
+ char nonce[32] = {0x00};
+ int rc;
+
+ rc = tpm_buf_init(&buf, TPM2_ST_NO_SESSIONS,
+ TPM2_CC_START_AUTH_SESSION);
+ if (rc)
+ return rc;
+
+ /* Decrypt key */
+ tpm_buf_append_u32(&buf, TPM2_RH_NULL);
+
+ /* Auth entity */
+ tpm_buf_append_u32(&buf, TPM2_RH_NULL);
+
+ /* Nonce - blank is fine here */
+ tpm_buf_append_u16(&buf, sizeof(nonce));
+ tpm_buf_append(&buf, nonce, sizeof(nonce));
+
+ /* Encrypted secret - empty */
+ tpm_buf_append_u16(&buf, 0);
+
+ /* Policy type - session */
+ tpm_buf_append_u8(&buf, 0x01);
+
+ /* Encryption type - NULL */
+ tpm_buf_append_u16(&buf, TPM_ALG_NULL);
+
+ /* Hash type - SHA256 */
+ tpm_buf_append_u16(&buf, TPM_ALG_SHA256);
+
+ rc = tpm_send(chip, buf.data, tpm_buf_length(&buf));
+ if (rc)
+ goto out;
+
+ head = (struct tpm_header *)buf.data;
+ if (be32_to_cpu(head->length) != sizeof(struct tpm_header) +
+ sizeof(int) + sizeof(u16) + sizeof(nonce)) {
+ rc = -EINVAL;
+ goto out;
+ }
+
+ *session_handle = be32_to_cpu(*(int *)&buf.data[10]);
+ memcpy(nonce, &buf.data[16], sizeof(nonce));
+ tpm_buf_destroy(&buf);
+ rc = tpm_buf_init(&buf, TPM2_ST_NO_SESSIONS, TPM2_CC_POLICY_PCR);
+ if (rc)
+ return rc;
+
+ tpm_buf_append_u32(&buf, *session_handle);
+
+ /* PCR digest - read from the PCR, we'll verify creation data later */
+ tpm_buf_append_u16(&buf, 0);
+
+ /* One PCR */
+ tpm_buf_append_u32(&buf, 1);
+
+ /* SHA256 banks */
+ tpm_buf_append_u16(&buf, TPM_ALG_SHA256);
+
+ /* Select PCR 23 */
+ tpm_buf_append_u32(&buf, 0x03000080);
+ rc = tpm_send(chip, buf.data, tpm_buf_length(&buf));
+ if (rc)
+ goto out;
+
+out:
+ tpm_buf_destroy(&buf);
+ return rc;
+}
+
+static int tpm_policy_get_digest(struct tpm_chip *chip, int handle,
+ char *digest)
+{
+ struct tpm_header *head;
+ struct tpm_buf buf;
+ int rc;
+
+ rc = tpm_buf_init(&buf, TPM2_ST_NO_SESSIONS, TPM2_CC_POLICY_GET_DIGEST);
+ if (rc)
+ return rc;
+
+ tpm_buf_append_u32(&buf, handle);
+ rc = tpm_send(chip, buf.data, tpm_buf_length(&buf));
+
+ if (rc)
+ goto out;
+
+ head = (struct tpm_header *)buf.data;
+ if (be32_to_cpu(head->length) != sizeof(struct tpm_header) +
+ sizeof(u16) + SHA256_DIGEST_SIZE) {
+ rc = -EINVAL;
+ goto out;
+ }
+
+ memcpy(digest, &buf.data[12], SHA256_DIGEST_SIZE);
+
+out:
+ tpm_buf_destroy(&buf);
+ return rc;
+}
+
static int snapshot_setup_encryption_common(struct snapshot_data *data)
{
int i, rc;
@@ -554,7 +659,11 @@ static int snapshot_create_kernel_key(struct snapshot_data *data)
struct key *key;
int ret, i;
/* Create a key sealed by the SRK. */
- char *keyinfo = "new\t32\tkeyhandle=0x81000000\tcreationpcrs=0x00800000";
+ char *keyinfo = NULL;
+ const char *keytemplate = "new\t32\tkeyhandle=0x81000000\tcreationpcrs=0x00800000\tpolicydigest=%s";
+ char policy[SHA256_DIGEST_SIZE];
+ char *policydigest = NULL;
+ int session_handle = -1;
chip = tpm_default_chip();
if (!chip)
@@ -584,13 +693,35 @@ static int snapshot_create_kernel_key(struct snapshot_data *data)
if (ret != 0)
goto reset;
+ policydigest = kmalloc(SHA256_DIGEST_SIZE * 2 + 1, GFP_KERNEL);
+ if (!policydigest) {
+ ret = -ENOMEM;
+ goto reset;
+ }
+
+ ret = tpm_setup_policy(chip, &session_handle);
+ if (ret != 0)
+ goto reset;
+
+ ret = tpm_policy_get_digest(chip, session_handle, policy);
+ if (ret != 0)
+ goto flush;
+
+ bin2hex(policydigest, policy, SHA256_DIGEST_SIZE);
+ policydigest[SHA256_DIGEST_SIZE * 2] = '\0';
+ keyinfo = kasprintf(GFP_KERNEL, keytemplate, policydigest);
+ if (!keyinfo) {
+ ret = -ENOMEM;
+ goto flush;
+ }
+
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;
+ goto flush;
}
ret = key_instantiate_and_link(key, keyinfo, strlen(keyinfo) + 1, NULL,
@@ -606,8 +737,14 @@ static int snapshot_create_kernel_key(struct snapshot_data *data)
key_revoke(key);
key_put(key);
}
+
+flush:
+ tpm2_flush_context(chip, session_handle);
+
reset:
kfree(digests);
+ kfree(keyinfo);
+ kfree(policydigest);
tpm_pcr_reset(chip, 23);
return ret;
}
@@ -669,13 +806,14 @@ static int snapshot_load_kernel_key(struct snapshot_data *data,
char certhash[SHA256_DIGEST_SIZE];
const struct cred *cred = current_cred();
- char *keytemplate = "load\t%s\tkeyhandle=0x81000000";
+ char *keytemplate = "load\t%s\tkeyhandle=0x81000000\tpolicyhandle=0x%x";
struct tpm_digest *digests = NULL;
char *blobstring = NULL;
char *keyinfo = NULL;
struct tpm_chip *chip;
struct key *key;
struct trusted_key_payload *payload;
+ int session_handle = -1;
int i, ret;
chip = tpm_default_chip();
@@ -706,17 +844,24 @@ static int snapshot_load_kernel_key(struct snapshot_data *data,
if (ret != 0)
goto reset;
- blobstring = kmalloc(blob->blob_len * 2, GFP_KERNEL);
+ ret = tpm_setup_policy(chip, &session_handle);
+ if (ret != 0)
+ goto reset;
+
+ blobstring = kmalloc(blob->blob_len * 2 + 1, GFP_KERNEL);
if (!blobstring) {
ret = -ENOMEM;
- goto reset;
+ goto flush;
}
bin2hex(blobstring, blob->blob, blob->blob_len);
- keyinfo = kasprintf(GFP_KERNEL, keytemplate, blobstring);
+ blobstring[blob->blob_len * 2] = '\0';
+ keyinfo = kasprintf(GFP_KERNEL, keytemplate, blobstring,
+ session_handle);
+
if (!keyinfo) {
ret = -ENOMEM;
- goto reset;
+ goto flush;
}
key = key_alloc(&key_type_trusted, "swsusp", GLOBAL_ROOT_UID,
@@ -790,6 +935,10 @@ static int snapshot_load_kernel_key(struct snapshot_data *data,
key_revoke(key);
key_put(key);
}
+
+flush:
+ tpm2_flush_context(chip, session_handle);
+
reset:
kfree(keyinfo);
kfree(blobstring);
--
2.31.0
next prev parent reply other threads:[~2022-05-04 23:59 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 ` [PATCH 07/10] PM: hibernate: Use TPM-backed keys to encrypt image Evan Green
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 ` Evan Green [this message]
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.10.Ifce072ae1ef1ce39bd681fff55af13a054045d9f@changeid \
--to=evgreen@chromium.org \
--cc=axelj@axis.com \
--cc=corbet@lwn.net \
--cc=dlunev@google.com \
--cc=gwendal@chromium.org \
--cc=hao.wu@rubrik.com \
--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=matthewgarrett@google.com \
--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).