| Message ID | 20210220013255.1083202-4-matthewgarrett@google.com (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
| Series | Enable hibernation when Lockdown is enabled | expand |
On Sat, Feb 20, 2021 at 01:32:49AM +0000, Matthew Garrett wrote: > Performing any sort of state validation of a sealed TPM blob requires > being able to access the individual members in the response. Parse the > blob sufficiently to be able to stash pointers to each member, along > with the length. > > Signed-off-by: Matthew Garrett <mjg59@google.com> I'll just say LGTM for now. Did not see anything obviously wrong in the code change (and does make sense to nitpick minor things just yet). Need to understand the whole use case just a little bit better. /Jarkko
On Sat, Feb 20, 2021 at 05:05:36AM +0200, Jarkko Sakkinen wrote: > On Sat, Feb 20, 2021 at 01:32:49AM +0000, Matthew Garrett wrote: > > Performing any sort of state validation of a sealed TPM blob requires > > being able to access the individual members in the response. Parse the > > blob sufficiently to be able to stash pointers to each member, along > > with the length. > > > > Signed-off-by: Matthew Garrett <mjg59@google.com> > > I'll just say LGTM for now. Did not see anything obviously wrong in > the code change (and does make sense to nitpick minor things just > yet). > > Need to understand the whole use case just a little bit better. I wrote this up with some more detail at https://mjg59.dreamwidth.org/55845.html - it seemed longer than appropriate for a commit message, but if you'd like more detail somewhere I can certainly add it.
On Mon, Feb 22, 2021 at 07:36:27AM +0000, Matthew Garrett wrote: > On Sat, Feb 20, 2021 at 05:05:36AM +0200, Jarkko Sakkinen wrote: > > On Sat, Feb 20, 2021 at 01:32:49AM +0000, Matthew Garrett wrote: > > > Performing any sort of state validation of a sealed TPM blob requires > > > being able to access the individual members in the response. Parse the > > > blob sufficiently to be able to stash pointers to each member, along > > > with the length. > > > > > > Signed-off-by: Matthew Garrett <mjg59@google.com> > > > > I'll just say LGTM for now. Did not see anything obviously wrong in > > the code change (and does make sense to nitpick minor things just > > yet). > > > > Need to understand the whole use case just a little bit better. > > I wrote this up with some more detail at > https://mjg59.dreamwidth.org/55845.html - it seemed longer than > appropriate for a commit message, but if you'd like more detail > somewhere I can certainly add it. Thanks (bookmarked). I'll read it before reviewing +1 version. Requiring a config flag is something that slows down adoption in the stock kernels. Since we are talking about hibernate the decision whether to have this feature set, does not have to be something that needs to be changed dynamically to a running system. So: maybe the best compromise would be to have it kernel command line option? That way it's easier feature to adapt (e.g. with GRUB configuration) and to enable in the kernel. /Jarkko
diff --git a/include/keys/trusted-type.h b/include/keys/trusted-type.h index a94c03a61d8f..020e01a99ea4 100644 --- a/include/keys/trusted-type.h +++ b/include/keys/trusted-type.h @@ -16,14 +16,22 @@ #define MAX_BLOB_SIZE 512 #define MAX_PCRINFO_SIZE 64 #define MAX_DIGEST_SIZE 64 +#define MAX_CREATION_DATA 412 +#define MAX_TK 76 struct trusted_key_payload { struct rcu_head rcu; unsigned int key_len; unsigned int blob_len; + unsigned int creation_len; + unsigned int creation_hash_len; + unsigned int tk_len; unsigned char migratable; unsigned char key[MAX_KEY_SIZE + 1]; unsigned char blob[MAX_BLOB_SIZE]; + unsigned char *creation; + unsigned char *creation_hash; + unsigned char *tk; }; struct trusted_key_options { diff --git a/security/keys/trusted-keys/trusted_tpm2.c b/security/keys/trusted-keys/trusted_tpm2.c index 08ec7f48f01d..6357a51a24e9 100644 --- a/security/keys/trusted-keys/trusted_tpm2.c +++ b/security/keys/trusted-keys/trusted_tpm2.c @@ -50,6 +50,63 @@ static void tpm2_buf_append_auth(struct tpm_buf *buf, u32 session_handle, tpm_buf_append(buf, hmac, hmac_len); } +static int tpm2_unpack_blob(struct trusted_key_payload *payload) +{ + int tmp, offset; + + /* Find the length of the private data */ + tmp = be16_to_cpup((__be16 *) &payload->blob[0]); + offset = tmp + 2; + if (offset > payload->blob_len) + return -EFAULT; + + /* Find the length of the public data */ + tmp = be16_to_cpup((__be16 *) &payload->blob[offset]); + offset += tmp + 2; + if (offset > payload->blob_len) + return -EFAULT; + + /* Find the length of the creation data and store it */ + tmp = be16_to_cpup((__be16 *) &payload->blob[offset]); + if (tmp > MAX_CREATION_DATA) + return -E2BIG; + + if ((offset + tmp + 2) > payload->blob_len) + return -EFAULT; + + payload->creation = &payload->blob[offset + 2]; + payload->creation_len = tmp; + offset += tmp + 2; + + /* Find the length of the creation hash and store it */ + tmp = be16_to_cpup((__be16 *) &payload->blob[offset]); + if (tmp > MAX_DIGEST_SIZE) + return -E2BIG; + + if ((offset + tmp + 2) > payload->blob_len) + return -EFAULT; + + payload->creation_hash = &payload->blob[offset + 2]; + payload->creation_hash_len = tmp; + offset += tmp + 2; + + /* + * Store the creation ticket. TPMT_TK_CREATION is two bytes of tag, + * four bytes of handle, and then the digest length and digest data + */ + tmp = be16_to_cpup((__be16 *) &payload->blob[offset + 6]); + if (tmp > MAX_TK) + return -E2BIG; + + if ((offset + tmp + 8) > payload->blob_len) + return -EFAULT; + + payload->tk = &payload->blob[offset]; + payload->tk_len = tmp + 8; + + return 0; +} + /** * tpm2_seal_trusted() - seal the payload of a trusted key * @@ -64,6 +121,7 @@ int tpm2_seal_trusted(struct tpm_chip *chip, struct trusted_key_options *options) { unsigned int blob_len; + unsigned int offset; struct tpm_buf buf; u32 hash; int i; @@ -139,14 +197,16 @@ int tpm2_seal_trusted(struct tpm_chip *chip, rc = -E2BIG; goto out; } - if (tpm_buf_length(&buf) < TPM_HEADER_SIZE + 4 + blob_len) { + offset = TPM_HEADER_SIZE + 4; + if (tpm_buf_length(&buf) < offset + blob_len) { rc = -EFAULT; goto out; } - memcpy(payload->blob, &buf.data[TPM_HEADER_SIZE + 4], blob_len); + memcpy(payload->blob, &buf.data[offset], blob_len); payload->blob_len = blob_len; + rc = tpm2_unpack_blob(payload); out: tpm_buf_destroy(&buf); @@ -215,7 +275,10 @@ static int tpm2_load_cmd(struct tpm_chip *chip, if (!rc) *blob_handle = be32_to_cpup( (__be32 *) &buf.data[TPM_HEADER_SIZE]); + else + goto out; + rc = tpm2_unpack_blob(payload); out: tpm_buf_destroy(&buf);
Performing any sort of state validation of a sealed TPM blob requires being able to access the individual members in the response. Parse the blob sufficiently to be able to stash pointers to each member, along with the length. Signed-off-by: Matthew Garrett <mjg59@google.com> --- include/keys/trusted-type.h | 8 +++ security/keys/trusted-keys/trusted_tpm2.c | 67 ++++++++++++++++++++++- 2 files changed, 73 insertions(+), 2 deletions(-)