TPM 2.0 trusted keys with attached policy
Subsystems (7)
James Bottomley
maintainerv5 cover TPM 2.0 trusted keys with attached policy
This is mainly a respin to add more spacing as Jarkko requested. However, I also added the seal/unseal operations to the openssl_tpm2_engine (next branch):
https://git.kernel.org/pub/scm/linux/kernel/git/jejb/openssl_tpm2_engine.git/
With the result that the kernel code completely failed the interoperability checks because the ASN.1 format requires the TPM2B length prepended to the public and private blobs. I corrected this in patch 4 and now all the interoperability tests are passing.
General cover letter:
This patch updates the trusted key code to export keys in the ASN.1 format used by current TPM key tools (openssl_tpm2_engine and openconnect). It also simplifies the use of policy with keys because the ASN.1 format is designed to carry a description of how to construct the policy, with the result that simple policies (like authorization and PCR locking) can now be constructed and used in the kernel, bringing the TPM 2.0 policy use into line with how TPM 1.2 works.
James
---
James Bottomley (6):
lib: add ASN.1 encoder
oid_registry: Add TCG defined OIDS for TPM keys
security: keys: trusted fix tpm2 authorizations
security: keys: trusted: use ASN.1 TPM2 key format for the blobs
security: keys: trusted: add ability to specify arbitrary policy
security: keys: trusted: implement counter/timer policy
Documentation/security/keys/trusted-encrypted.rst | 64 ++- include/keys/trusted-type.h | 7 +- include/linux/asn1_encoder.h | 32 ++ include/linux/oid_registry.h | 5 + include/linux/tpm.h | 8 + lib/Makefile | 2 +- lib/asn1_encoder.c | 431 ++++++++++++++++++++ security/keys/Kconfig | 2 + security/keys/trusted-keys/Makefile | 2 +- security/keys/trusted-keys/tpm2-policy.c | 463 ++++++++++++++++++++++ security/keys/trusted-keys/tpm2-policy.h | 31 ++ security/keys/trusted-keys/tpm2key.asn1 | 23 ++ security/keys/trusted-keys/trusted_tpm1.c | 50 ++- security/keys/trusted-keys/trusted_tpm2.c | 370 +++++++++++++++-- 14 files changed, 1454 insertions(+), 36 deletions(-) create mode 100644 include/linux/asn1_encoder.h create mode 100644 lib/asn1_encoder.c create mode 100644 security/keys/trusted-keys/tpm2-policy.c create mode 100644 security/keys/trusted-keys/tpm2-policy.h create mode 100644 security/keys/trusted-keys/tpm2key.asn1
Signature · 1 line
2.16.4
James Bottomley
maintainerPATCH v5 1/6 lib: add ASN.1 encoder
We have a need in the TPM2 trusted keys to return the ASN.1 form of the TPM key blob so it can be operated on by tools outside of the kernel. The specific tools are the openssl_tpm2_engine, openconnect and the Intel tpm2-tss-engine. To do that, we have to be able to read and write the same binary key format the tools use. The current ASN.1 decoder does fine for reading, but we need pieces of an ASN.1 encoder to write the key blob in binary compatible form.
For backwards compatibility, the trusted key reader code will still accept the two TPM2B quantities that it uses today, but the writer will only output the ASN.1 form.
The current implementation only encodes the ASN.1 bits we actually need.
---
v2: updated API to use indefinite length, and made symbol exports gpl
v3: add data length error handling
v4: use end_data instead of data_len pointer
v5: mention tools and space out code
--- include/linux/asn1_encoder.h | 32 ++++ lib/Makefile | 2 +- lib/asn1_encoder.c | 431 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 464 insertions(+), 1 deletion(-) create mode 100644 include/linux/asn1_encoder.h create mode 100644 lib/asn1_encoder.c
include/linux/asn1_encoder.h new file +32 -0
@@ -0,0 +1,32 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ + +#ifndef _LINUX_ASN1_ENCODER_H +#define _LINUX_ASN1_ENCODER_H + +#include <linux/types.h> +#include <linux/asn1.h> +#include <linux/asn1_ber_bytecode.h> +#include <linux/bug.h> + +#define asn1_oid_len (oid) (sizeof(oid)/sizeof(u32)) +unsigned char * +asn1_encode_integer (unsigned char *data,const unsigned char *end_data, +s64 integer); +unsigned char * +asn1_encode_oid (unsigned char *data,const unsigned char *end_data, +u32 oid[],int oid_len); +unsigned char * +asn1_encode_tag (unsigned char *data,const unsigned char *end_data, +u32 tag,const unsigned char *string,int len); +unsigned char * +asn1_encode_octet_string (unsigned char *data, +const unsigned char *end_data, +const unsigned char *string,u32 len); +unsigned char * +asn1_encode_sequence (unsigned char *data,const unsigned char *end_data, +const unsigned char *seq,int len); +unsigned char * +asn1_encode_boolean (unsigned char *data,const unsigned char *end_data, +bool val); + +#endif
lib/Makefile +1 -1
@@ -233,7 +233,7 @@ obj-$(CONFIG_INTERVAL_TREE_TEST) += interval_tree_test.o obj-$(CONFIG_PERCPU_TEST) += percpu_test.o -obj-$(CONFIG_ASN1) += asn1_decoder.o +obj-$(CONFIG_ASN1) += asn1_decoder.o asn1_encoder.o obj-$(CONFIG_FONT_SUPPORT) += fonts/
lib/asn1_encoder.c new file +431 -0
431 lines not on this page · raw message
Signature · 1 line
2.16.4
James Bottomley
maintainerPATCH v5 2/6 oid_registry: Add TCG defined OIDS for TPM keys
In reply to James BottomleyThe TCG has defined an OID prefix "2.23.133.10.1" for the various TPM key uses. We've defined three of the available numbers:
2.23.133.10.1.3 TPM Loadable key. This is an asymmetric key (Usually
RSA2048 or Elliptic Curve) which can be imported by a TPM2_Load() operation.
2.23.133.10.1.4 TPM Importable Key. This is an asymmetric key (Usually
RSA2048 or Elliptic Curve) which can be imported by a TPM2_Import() operation.
Both loadable and importable keys are specific to a given TPM, the difference is that a loadable key is wrapped with the symmetric secret, so must have been created by the TPM itself. An importable key is wrapped with a DH shared secret, and may be created without access to the TPM provided you know the public part of the parent key.
2.23.133.10.1.5 TPM Sealed Data. This is a set of data (up to 128
bytes) which is sealed by the TPM. It usually represents a symmetric key and must be unsealed before use.
The ASN.1 binary key form starts of with this OID as the first element of a sequence, giving the binary form a unique recognizable identity marker regardless of encoding.
---
v3: correct OID_TPMImportableKey name
--- include/linux/oid_registry.h | 5 +++++ 1 file changed, 5 insertions(+)
include/linux/oid_registry.h +5 -0
@@ -107,6 +107,11 @@ enum OID { OID_gostTC26Sign512B,/* 1.2.643.7.1.2.1.2.2 */ OID_gostTC26Sign512C,/* 1.2.643.7.1.2.1.2.3 */ +/* TCG defined OIDS for TPM based keys */ + OID_TPMLoadableKey,/* 2.23.133.10.1.3 */ + OID_TPMImportableKey,/* 2.23.133.10.1.4 */ + OID_TPMSealedData,/* 2.23.133.10.1.5 */ + OID__NR };
Signature · 1 line
2.16.4
James Bottomley
maintainerPATCH v5 3/6 security: keys: trusted fix tpm2 authorizations
In reply to James BottomleyIn TPM 1.2 an authorization was a 20 byte number. The spec actually recommended you to hash variable length passwords and use the sha1 hash as the authorization. Because the spec doesn't require this hashing, the current authorization for trusted keys is a 40 digit hex number. For TPM 2.0 the spec allows the passing in of variable length passwords and passphrases directly, so we should allow that in trusted keys for ease of use. Update the 'blobauth' parameter to take this into account, so we can now use plain text passwords for the keys.
so before
keyctl add trusted kmk "new 32 blobauthõ72d396fae9206628714fb2ce00f72e94f2258f"
after we will accept both the old hex sha1 form as well as a new directly supplied password:
keyctl add trusted kmk "new 32 blobauth=hello keyhandle�000001"
Since a sha1 hex code must be exactly 40 bytes long and a direct password must be 20 or less, we use the length as the discriminator for which form is input.
Note this is both and enhancement and a potential bug fix. The TPM 2.0 spec requires us to strip leading zeros, meaning empyty authorization is a zero length HMAC whereas we're currently passing in 20 bytes of zeros. A lot of TPMs simply accept this as OK, but the Microsoft TPM emulator rejects it with TPM_RC_BAD_AUTH, so this patch makes the Microsoft TPM emulator work with trusted keys.
--- include/keys/trusted-type.h | 1 + security/keys/trusted-keys/trusted_tpm1.c | 26 +++++++++++++++++++++----- security/keys/trusted-keys/trusted_tpm2.c | 10 ++++++---- 3 files changed, 28 insertions(+), 9 deletions(-)
include/keys/trusted-type.h +1 -0
@@ -30,6 +30,7 @@ struct trusted_key_options {uint16_t keytype;uint32_t keyhandle;unsigned char keyauth[TPM_DIGEST_SIZE ]; +uint32_t blobauth_len;unsigned char blobauth[TPM_DIGEST_SIZE ];uint32_t pcrinfo_len;unsigned char pcrinfo[MAX_PCRINFO_SIZE ];
security/keys/trusted-keys/trusted_tpm1.c +21 -5
@@ -781,12 +781,28 @@ static int getoptions(char *c, struct trusted_key_payload *pay,return -EINVAL ;break ;case Opt_blobauth: -if (strlen (args[0 ].from) !=2 *SHA1_DIGEST_SIZE ) -return -EINVAL ; - res =hex2bin (opt->blobauth, args[0 ].from, -SHA1_DIGEST_SIZE ); -if (res <0 ) +/* +* TPM 1.2 authorizations are sha1 hashes +* passed in as hex strings. TPM 2.0 +* authorizations are simple passwords +* (although it can take a hash as well) +*/ + opt->blobauth_len =strlen (args[0 ].from); +if (opt->blobauth_len =2 *TPM_DIGEST_SIZE ) { + res =hex2bin (opt->blobauth, args[0 ].from, +TPM_DIGEST_SIZE ); +if (res <0 ) +return -EINVAL ; + + opt->blobauth_len =TPM_DIGEST_SIZE ; + }else if (tpm2 && + opt->blobauth_len <=sizeof (opt->blobauth)) { +memcpy (opt->blobauth, args[0 ].from, + opt->blobauth_len); + }else {return -EINVAL ; + } +break ;case Opt_migratable:if (*args[0 ].from ='0' )
security/keys/trusted-keys/trusted_tpm2.c +6 -4
@@ -91,10 +91,12 @@ int tpm2_seal_trusted(struct tpm_chip *chip, TPM_DIGEST_SIZE);/* sensitive */ -tpm_buf_append_u16 (&buf,4 +TPM_DIGEST_SIZE + payload->key_len +1 ); +tpm_buf_append_u16 (&buf,4 + options->blobauth_len + payload->key_len +1 ); + +tpm_buf_append_u16 (&buf, options->blobauth_len); +if (options->blobauth_len) +tpm_buf_append (&buf, options->blobauth, options->blobauth_len); -tpm_buf_append_u16 (&buf,TPM_DIGEST_SIZE ); -tpm_buf_append (&buf, options->blobauth,TPM_DIGEST_SIZE );tpm_buf_append_u16 (&buf, payload->key_len +1 );tpm_buf_append (&buf, payload->key, payload->key_len);tpm_buf_append_u8 (&buf, payload->migratable);
@@ -258,7 +260,7 @@ static int tpm2_unseal_cmd(struct tpm_chip *chip,NULL /* nonce */ ,0 ,TPM2_SA_CONTINUE_SESSION , options->blobauth/* hmac */ , - TPM_DIGEST_SIZE); + options->blobauth_len); rc =tpm_send (chip, buf.data,tpm_buf_length (&buf));if (rc >0 )
Signature · 1 line
2.16.4
Re: [PATCH v5 3/6] security: keys: trusted fix tpm2 authorizations
Quoted 22 lines · James Bottomley
In TPM 1.2 an authorization was a 20 byte number. The spec actually recommended you to hash variable length passwords and use the sha1 hash as the authorization. Because the spec doesn't require this hashing, the current authorization for trusted keys is a 40 digit hex number. For TPM 2.0 the spec allows the passing in of variable length passwords and passphrases directly, so we should allow that in trusted keys for ease of use. Update the 'blobauth' parameter to take this into account, so we can now use plain text passwords for the keys.
so before
keyctl add trusted kmk "new 32 blobauthõ72d396fae9206628714fb2ce00f72e94f2258f"
after we will accept both the old hex sha1 form as well as a new directly supplied password:
keyctl add trusted kmk "new 32 blobauth=hello keyhandle�000001"
Since a sha1 hex code must be exactly 40 bytes long and a direct password must be 20 or less, we use the length as the discriminator for which form is input.
Quoted 8 lines
Note this is both and enhancement and a potential bug fix. The TPM 2.0 spec requires us to strip leading zeros, meaning empyty authorization is a zero length HMAC whereas we're currently passing in 20 bytes of zeros. A lot of TPMs simply accept this as OK, but the Microsoft TPM emulator rejects it with
TPM_RC_BAD_AUTH, so this patch makes the Microsoft TPM emulator work with trusted keys.Signed-off-by James Bottomley <[email protected]>
Should have a fixes tag.
Quoted 26 lines
--- include/keys/trusted-type.h | 1 + security/keys/trusted-keys/trusted_tpm1.c | 26 +++++++++++++++++++++----- security/keys/trusted-keys/trusted_tpm2.c | 10 ++++++---- 3 files changed, 28 insertions(+), 9 deletions(-)include/keys/trusted-type.h +1
-0@@ -30,6 +30,7 @@ struct trusted_key_options {uint16_t keytype;uint32_t keyhandle;unsigned char keyauth[TPM_DIGEST_SIZE ]; +uint32_t blobauth_len;unsigned char blobauth[TPM_DIGEST_SIZE ];uint32_t pcrinfo_len;unsigned char pcrinfo[MAX_PCRINFO_SIZE ];security/keys/trusted-keys/trusted_tpm1.c +0
-0@@ -781,12 +781,28 @@ static int getoptions(char *c, struct trusted_key_payload *pay,return -EINVAL ;break ;case Opt_blobauth:
security/keys/trusted-keys/trusted_tpm1.c static int getoptions(char *c, struct trusted_key_payload *pay, · line 788
Quoted 10 lines
security/keys/trusted-keys/trusted_tpm1.c +5
-5-if (strlen (args[0 ].from) !=2 *SHA1_DIGEST_SIZE ) -return -EINVAL ; - res =hex2bin (opt->blobauth, args[0 ].from, -SHA1_DIGEST_SIZE ); -if (res <0 ) +/* +* TPM 1.2 authorizations are sha1 hashes +* passed in as hex strings. TPM 2.0 +* authorizations are simple passwords +* (although it can take a hash as well)
Justify to the 80 character line length.
Quoted 6 lines
security/keys/trusted-keys/trusted_tpm1.c +6
-0+*/ + opt->blobauth_len =strlen (args[0 ].from); +if (opt->blobauth_len =2 *TPM_DIGEST_SIZE ) { + res =hex2bin (opt->blobauth, args[0 ].from, +TPM_DIGEST_SIZE ); +if (res <0 )
security/keys/trusted-keys/trusted_tpm1.c static int getoptions(char *c, struct trusted_key_payload *pay, · line 804
Quoted 10 lines
security/keys/trusted-keys/trusted_tpm1.c +9
-0+return -EINVAL ; + + opt->blobauth_len =TPM_DIGEST_SIZE ; + }else if (tpm2 && + opt->blobauth_len <=sizeof (opt->blobauth)) { +memcpy (opt->blobauth, args[0 ].from, + opt->blobauth_len); + }else {return -EINVAL ; + }
This starts to be unnecessarily complicated.
This is what I would suggest:
opt->blobauth_len = strlen(args[0].from);
if (opt->blobauth_len = 2 * TPM_DIGEST_SIZE) {
res = hex2bin(opt->blobauth, args[0].from,
TPM_DIGEST_SIZE);
if (res < 0)
return -EINVAL;
opt->blobauth_len = TPM_DIGEST_SIZE;
return 0;
}if (tpm2 && opt->blobauth_len <= sizeof(opt->blobauth)) {
memcpy(opt->blobauth, args[0].from,
opt->blobauth_len);
return 0;
}return -EINVAL;
Easier to see quickly "when happens what".
/Jarkko
Re: [PATCH v5 3/6] security: keys: trusted fix tpm2 authorizations
Quoted 111 lines · Jarkko Sakkinen
Quoted 22 lines · James Bottomley
In TPM 1.2 an authorization was a 20 byte number. The spec actually recommended you to hash variable length passwords and use the sha1 hash as the authorization. Because the spec doesn't require this hashing, the current authorization for trusted keys is a 40 digit hex number. For TPM 2.0 the spec allows the passing in of variable length passwords and passphrases directly, so we should allow that in trusted keys for ease of use. Update the 'blobauth' parameter to take this into account, so we can now use plain text passwords for the keys.
so before
keyctl add trusted kmk "new 32 blobauthõ72d396fae9206628714fb2ce00f72e94f2258f"
after we will accept both the old hex sha1 form as well as a new directly supplied password:
keyctl add trusted kmk "new 32 blobauth=hello keyhandle�000001"
Since a sha1 hex code must be exactly 40 bytes long and a direct password must be 20 or less, we use the length as the discriminator for which form is input.
Quoted 8 lines
Note this is both and enhancement and a potential bug fix. The TPM 2.0 spec requires us to strip leading zeros, meaning empyty authorization is a zero length HMAC whereas we're currently passing in 20 bytes of zeros. A lot of TPMs simply accept this as OK, but the Microsoft TPM emulator rejects it with
TPM_RC_BAD_AUTH, so this patch makes the Microsoft TPM emulator work with trusted keys.Signed-off-by James Bottomley <[email protected]>Should have a fixes tag.
Quoted 26 lines
--- include/keys/trusted-type.h | 1 + security/keys/trusted-keys/trusted_tpm1.c | 26 +++++++++++++++++++++----- security/keys/trusted-keys/trusted_tpm2.c | 10 ++++++---- 3 files changed, 28 insertions(+), 9 deletions(-)include/keys/trusted-type.h +1
-0@@ -30,6 +30,7 @@ struct trusted_key_options {uint16_t keytype;uint32_t keyhandle;unsigned char keyauth[TPM_DIGEST_SIZE ]; +uint32_t blobauth_len;unsigned char blobauth[TPM_DIGEST_SIZE ];uint32_t pcrinfo_len;unsigned char pcrinfo[MAX_PCRINFO_SIZE ];security/keys/trusted-keys/trusted_tpm1.c +0
-0@@ -781,12 +781,28 @@ static int getoptions(char *c, struct trusted_key_payload *pay,return -EINVAL ;break ;case Opt_blobauth:security/keys/trusted-keys/trusted_tpm1.c static int getoptions(char *c, struct trusted_key_payload *pay, · line 788
Quoted 10 lines
security/keys/trusted-keys/trusted_tpm1.c +5
-5-if (strlen (args[0 ].from) !=2 *SHA1_DIGEST_SIZE ) -return -EINVAL ; - res =hex2bin (opt->blobauth, args[0 ].from, -SHA1_DIGEST_SIZE ); -if (res <0 ) +/* +* TPM 1.2 authorizations are sha1 hashes +* passed in as hex strings. TPM 2.0 +* authorizations are simple passwords +* (although it can take a hash as well) Justify to the 80 character line length.
Quoted 6 lines
security/keys/trusted-keys/trusted_tpm1.c +6
-0+*/ + opt->blobauth_len =strlen (args[0 ].from); +if (opt->blobauth_len =2 *TPM_DIGEST_SIZE ) { + res =hex2bin (opt->blobauth, args[0 ].from, +TPM_DIGEST_SIZE ); +if (res <0 )security/keys/trusted-keys/trusted_tpm1.c static int getoptions(char *c, struct trusted_key_payload *pay, · line 804
Quoted 10 lines
security/keys/trusted-keys/trusted_tpm1.c +9
-0+return -EINVAL ; + + opt->blobauth_len =TPM_DIGEST_SIZE ; + }else if (tpm2 && + opt->blobauth_len <=sizeof (opt->blobauth)) { +memcpy (opt->blobauth, args[0 ].from, + opt->blobauth_len); + }else {return -EINVAL ; + }This starts to be unnecessarily complicated.
This is what I would suggest:
opt->blobauth_len=strlen(args[0].from);if (opt->blobauth_len = 2 * TPM_DIGEST_SIZE) { res = hex2bin(opt->blobauth, args[0].from, TPM_DIGEST_SIZE); if (res < 0) return -EINVAL; opt->blobauth_len = TPM_DIGEST_SIZE; return 0; }if (tpm2 && opt->blobauth_len <= sizeof(opt->blobauth)) { memcpy(opt->blobauth, args[0].from, opt->blobauth_len); return 0; }
Quoted 5 lines
return
-EINVAL;Easier to see quickly "when happens what".
/Jarkko
And in short summary "TPM2" instead of tpm2.
/Jarkko
James Bottomley
maintainerRe: [PATCH v5 3/6] security: keys: trusted fix tpm2 authorizations
In reply to Jarkko SakkinenQuoted 34 lines · Jarkko Sakkinen
Quoted 33 lines · James Bottomley
In TPM 1.2 an authorization was a 20 byte number. The spec actually recommended you to hash variable length passwords and use the sha1 hash as the authorization. Because the spec doesn't require this hashing, the current authorization for trusted keys is a 40 digit hex number. For TPM 2.0 the spec allows the passing in of variable length passwords and passphrases directly, so we should allow that in trusted keys for ease of use. Update the 'blobauth' parameter to take this into account, so we can now use plain text passwords for the keys.
so before
keyctl add trusted kmk "new 32
blobauthõ72d396fae9206628714fb2ce00f72e94f2258f"after we will accept both the old hex sha1 form as well as a new directly supplied password:
keyctl add trusted kmk "new 32 blobauth=hello keyhandle�000001"
Since a sha1 hex code must be exactly 40 bytes long and a direct password must be 20 or less, we use the length as the discriminator for which form is input.
Note this is both and enhancement and a potential bug fix. The TPM 2.0 spec requires us to strip leading zeros, meaning empyty authorization is a zero length HMAC whereas we're currently passing in
20 bytes of zeros. A lot of TPMs simply accept this as OK, but the Microsoft TPM emulator rejects it withTPM_RC_BAD_AUTH, so this patch
makes the Microsoft TPM emulator work with trusted keys.
Quoted 4 lines
Quoted 2 lines
Signed-off-by James Bottomley <[email protected]om>
Should have a fixes tag.
I made all the other changes, but I'm not sure what to identify in the fixes tag. The problem is the code I updated was simply carried over unaltered from TPM 1.2
You could certainly argue that commit
commit 0fe5480303a1657b328a0a389f8d99249d9961f5
Author: Jarkko Sakkinen <[email protected]> Date: Fri Jun 26 22:28:26 2015 +0300
keys, trusted: seal/unseal with TPM 2.0 chips
Should have updated the blobauth handling ... is that the one you'd like fixes: to identify?
James
Re: [PATCH v5 3/6] security: keys: trusted fix tpm2 authorizations
Quoted 46 lines · James Bottomley
Quoted 34 lines · Jarkko Sakkinen
Quoted 33 lines · James Bottomley
In TPM 1.2 an authorization was a 20 byte number. The spec actually recommended you to hash variable length passwords and use the sha1 hash as the authorization. Because the spec doesn't require this hashing, the current authorization for trusted keys is a 40 digit hex number. For TPM 2.0 the spec allows the passing in of variable length passwords and passphrases directly, so we should allow that in trusted keys for ease of use. Update the 'blobauth' parameter to take this into account, so we can now use plain text passwords for the keys.
so before
keyctl add trusted kmk "new 32
blobauthõ72d396fae9206628714fb2ce00f72e94f2258f"after we will accept both the old hex sha1 form as well as a new directly supplied password:
keyctl add trusted kmk "new 32 blobauth=hello keyhandle�000001"
Since a sha1 hex code must be exactly 40 bytes long and a direct password must be 20 or less, we use the length as the discriminator for which form is input.
Note this is both and enhancement and a potential bug fix. The TPM 2.0 spec requires us to strip leading zeros, meaning empyty authorization is a zero length HMAC whereas we're currently passing in
20 bytes of zeros. A lot of TPMs simply accept this as OK, but the Microsoft TPM emulator rejects it withTPM_RC_BAD_AUTH, so this patch
makes the Microsoft TPM emulator work with trusted keys.Quoted 4 lines
Quoted 2 lines
Signed-off-by James Bottomley <[email protected]om>
Should have a fixes tag.
I made all the other changes, but I'm not sure what to identify in the fixes tag. The problem is the code I updated was simply carried over unaltered from TPM 1.2
You could certainly argue that commit
Quoted 8 lines
commit
0fe5480303a1657b328a0a389f8d99249d9961f5Author: Jarkko Sakkinen <[email protected]> Date: Fri Jun 26 22:28:26 2015 +0300keys, trusted: seal/unseal with TPM 2.0 chips
Should have updated the blobauth handling ... is that the one you'd like fixes: to identify?
What I'm thinking is to have fixes tag w/o cc to stable. I'm not sure at this point whether we want to backport this but it still makes sense to tag it.
/Jarkko
James Bottomley
maintainerRe: [PATCH v5 3/6] security: keys: trusted fix tpm2 authorizations
Quoted 67 lines · Jarkko Sakkinen
Quoted 66 lines · James Bottomley
Quoted 47 lines · Jarkko Sakkinen
Quoted 46 lines · James Bottomley
In TPM 1.2 an authorization was a 20 byte number. The spec actually recommended you to hash variable length passwords and use
the sha1 hash as the authorization. Because the spec doesn't require this hashing, the current authorization for trusted keys is
a 40 digit hex number. For TPM 2.0 the spec allows the passing in
of variable length passwords and passphrases directly, so we should
allow that in trusted keys for ease of use. Update the 'blobauth'
parameter to take this into account, so we can now use plain text
passwords for the keys.so before
keyctl add trusted kmk "new 32
blobauthõ72d396fae9206628714fb2ce00f72e94f2258f"after we will accept both the old hex sha1 form as well as a new
directly supplied password:keyctl add trusted kmk "new 32 blobauth=hello
keyhandle�000001"Since a sha1 hex code must be exactly 40 bytes long and a direct
password must be 20 or less, we use the length as the discriminator
for which form is input.Note this is both and enhancement and a potential bug fix. The TPM
2.0 spec requires us to strip leading zeros, meaning empyty authorization is a zero length HMAC whereas we're currently passing
in
20 bytes of zeros. A lot of TPMs simply accept this as OK, but the
Microsoft TPM emulator rejects it withTPM_RC_BAD_AUTH, so this patch
makes the Microsoft TPM emulator work with trusted keys.Quoted 5 lines
Quoted 3 lines
Signed-off-by James Bottomley <James.Bottomley@HansenPartnersh
ip.c
om>Should have a fixes tag.
I made all the other changes, but I'm not sure what to identify in the
fixes tag. The problem is the code I updated was simply carried over
unaltered from TPM 1.2You could certainly argue that commit
commit
0fe5480303a1657b328a0a389f8d99249d9961f5Author: Jarkko Sakkinen <[email protected]> Date: Fri Jun 26 22:28:26 2015 +0300
Quoted 8 lines
Quoted 4 lines
keys, trusted: seal/unseal with TPM 2.0 chips
Should have updated the blobauth handling ... is that the one you'd like fixes: to identify?
What I'm thinking is to have fixes tag w/o cc to stable. I'm not sure at this point whether we want to backport this but it still makes sense to tag it.
Ok, I'll add that commit as the fixes; it certainly makes no sense to backport this change before the above commit.
James
James Bottomley
maintainerRe: [PATCH v5 3/6] security: keys: trusted fix tpm2 authorizations
Quoted 1 line · James Bottomley
On Thu, 2020-02-27 at 18:19 +0200, Jarkko Sakkinen wrote:
[...]
Quoted 2 lines
Ok, I'll add that commit as the fixes; it certainly makes no sense to backport this change before the above commit.
This is what I currently have. Do you want me to resend the whole series?
James
----8>8>8>-----
From: James Bottomley <[email protected]>
Subject: [PATCH v6 3/6] security: keys: trusted: fix TPM2 authorizations
In TPM 1.2 an authorization was a 20 byte number. The spec actually recommended you to hash variable length passwords and use the sha1 hash as the authorization. Because the spec doesn't require this hashing, the current authorization for trusted keys is a 40 digit hex number. For TPM 2.0 the spec allows the passing in of variable length passwords and passphrases directly, so we should allow that in trusted keys for ease of use. Update the 'blobauth' parameter to take this into account, so we can now use plain text passwords for the keys.
so before
keyctl add trusted kmk "new 32 blobauthõ72d396fae9206628714fb2ce00f72e94f2258f"
after we will accept both the old hex sha1 form as well as a new directly supplied password:
keyctl add trusted kmk "new 32 blobauth=hello keyhandle�000001"
Since a sha1 hex code must be exactly 40 bytes long and a direct password must be 20 or less, we use the length as the discriminator for which form is input.
Note this is both and enhancement and a potential bug fix. The TPM 2.0 spec requires us to strip leading zeros, meaning empyty authorization is a zero length HMAC whereas we're currently passing in 20 bytes of zeros. A lot of TPMs simply accept this as OK, but the Microsoft TPM emulator rejects it with TPM_RC_BAD_AUTH, so this patch makes the Microsoft TPM emulator work with trusted keys.
---
v6: change comment, eliminate else clauses and add fixes tag
include/keys/trusted-type.h +1 -0
@@ -30,6 +30,7 @@ struct trusted_key_options {uint16_t keytype;uint32_t keyhandle;unsigned char keyauth[TPM_DIGEST_SIZE ]; +uint32_t blobauth_len;unsigned char blobauth[TPM_DIGEST_SIZE ];uint32_t pcrinfo_len;unsigned char pcrinfo[MAX_PCRINFO_SIZE ];
security/keys/trusted-keys/trusted_tpm1.c +26 -6
@@ -781,13 +781,33 @@ static int getoptions(char *c, struct trusted_key_payload *pay,return -EINVAL ;break ;case Opt_blobauth: -if (strlen (args[0 ].from) !=2 *SHA1_DIGEST_SIZE ) -return -EINVAL ; - res =hex2bin (opt->blobauth, args[0 ].from, -SHA1_DIGEST_SIZE ); -if (res <0 ) -return -EINVAL ; +/* +* TPM 1.2 authorizations are sha1 hashes passed in as +* hex strings. TPM 2.0 authorizations are simple +* passwords (although it can take a hash as well) +*/ + opt->blobauth_len =strlen (args[0 ].from); + +if (opt->blobauth_len =2 *TPM_DIGEST_SIZE ) { + res =hex2bin (opt->blobauth, args[0 ].from, +TPM_DIGEST_SIZE ); +if (res <0 ) +return -EINVAL ; + + opt->blobauth_len =TPM_DIGEST_SIZE ; +return 0 ; + } + +if (tpm2 && opt->blobauth_len <=sizeof (opt->blobauth)) { +memcpy (opt->blobauth, args[0 ].from, + opt->blobauth_len); +return 0 ; + } + +return -EINVAL ; +break ; +case Opt_migratable:if (*args[0 ].from ='0' ) pay->migratable =0 ;
security/keys/trusted-keys/trusted_tpm2.c +6 -4
@@ -91,10 +91,12 @@ int tpm2_seal_trusted(struct tpm_chip *chip, TPM_DIGEST_SIZE);/* sensitive */ -tpm_buf_append_u16 (&buf,4 +TPM_DIGEST_SIZE + payload->key_len +1 ); +tpm_buf_append_u16 (&buf,4 + options->blobauth_len + payload->key_len +1 ); + +tpm_buf_append_u16 (&buf, options->blobauth_len); +if (options->blobauth_len) +tpm_buf_append (&buf, options->blobauth, options->blobauth_len); -tpm_buf_append_u16 (&buf,TPM_DIGEST_SIZE ); -tpm_buf_append (&buf, options->blobauth,TPM_DIGEST_SIZE );tpm_buf_append_u16 (&buf, payload->key_len +1 );tpm_buf_append (&buf, payload->key, payload->key_len);tpm_buf_append_u8 (&buf, payload->migratable);
@@ -258,7 +260,7 @@ static int tpm2_unseal_cmd(struct tpm_chip *chip,NULL /* nonce */ ,0 ,TPM2_SA_CONTINUE_SESSION , options->blobauth/* hmac */ , - TPM_DIGEST_SIZE); + options->blobauth_len); rc =tpm_send (chip, buf.data,tpm_buf_length (&buf));if (rc >0 )
Re: [PATCH v5 3/6] security: keys: trusted fix tpm2 authorizations
Quoted 8 lines · James Bottomley
Quoted 1 line · James Bottomley
On Thu, 2020-02-27 at 18:19 +0200, Jarkko Sakkinen wrote:
[...]
Quoted 2 lines
Ok, I'll add that commit as the fixes; it certainly makes no sense to backport this change before the above commit.
This is what I currently have. Do you want me to resend the whole series?
I prefer to review full snapshots of the series.
/Jarkko
James Bottomley
maintainerPATCH v5 4/6 security: keys: trusted: use ASN.1 TPM2 key format for the blobs
In reply to James BottomleyModify the TPM2 key format blob output to export and import in the ASN.1 form for TPM2 sealed object keys. For compatibility with prior trusted keys, the importer will also accept two TPM2B quantities representing the public and private parts of the key. However, the export via keyctl pipe will only output the ASN.1 format.
The benefit of the ASN.1 format is that it's a standard and thus the exported key can be used by userspace tools (openssl_tpm2_engine, openconnect and tpm2-tss-engine). The format includes policy specifications, thus it gets us out of having to construct policy handles in userspace and the format includes the parent meaning you don't have to keep passing it in each time.
This patch only implements basic handling for the ASN.1 format, so keys with passwords but no policy.
v2: Updated encode API, added length checks
v5: correct export format after doing interoperability checks
--- Documentation/security/keys/trusted-encrypted.rst | 19 +- include/keys/trusted-type.h | 6 +- include/linux/tpm.h | 7 + security/keys/Kconfig | 2 + security/keys/trusted-keys/Makefile | 2 +- security/keys/trusted-keys/tpm2-policy.c | 372 ++++++++++++++++++++++ security/keys/trusted-keys/tpm2-policy.h | 30 ++ security/keys/trusted-keys/tpm2key.asn1 | 23 ++ security/keys/trusted-keys/trusted_tpm1.c | 9 +- security/keys/trusted-keys/trusted_tpm2.c | 328 +++++++++++++++++-- 10 files changed, 771 insertions(+), 27 deletions(-) create mode 100644 security/keys/trusted-keys/tpm2-policy.c create mode 100644 security/keys/trusted-keys/tpm2-policy.h create mode 100644 security/keys/trusted-keys/tpm2key.asn1
Documentation/security/keys/trusted-encrypted.rst +18 -1
@@ -60,7 +60,10 @@ Usage:: (40 ascii zeros) blobauth= ascii hex auth for sealed data default 0x00... (40 ascii zeros) - pcrinfo= ascii hex of PCR_INFO or PCR_INFO_LONG (no default) + pcrinfo= ascii hex of PCR_INFO or PCR_INFO_LONG (no + default) on TPM 1.2 and a TPMS_PCR_SELECTION + coupled with a hash of all the selected PCRs on + TPM 2.0 using the selected hash. pcrlock= pcr number to be extended to "lock" blob migratable= 0|1 indicating permission to reseal to new PCR values, default 1 (resealing allowed)
@@ -151,6 +154,20 @@ Load a trusted key from the saved blob:: f1f8fff03ad0acb083725535636addb08d73dedb9832da198081e5deae84bfaf0409c22b e4a8aea2b607ec96931e6f4d4fe563ba +Create a trusted key on TPM 2.0 using an all zero value of PCR16 and +using the NV storage root 81000001 as the parent:: + + $ keyctl add trusted kmk "new 32 keyhandle=0x81000001 hash=sha1 pcrinfo0000016768033e216468247bd031a0a2d9876d79818f8f" @u + +Note the TPMS_PCR_SELECT value for PCR 16 is 03000001 because all +current TPMs have 24 PCRs, so the initial 03 says there are three +following bytes of selection and then because the bytes are big +endian, 16 is bit zero of byte 2. the hash is the sha1 sum of all +zeros (the value of PCR 16):: + + $ dd if=/dev/zero bs=1 count 2>/dev/null|sha1sum + 6768033e216468247bd031a0a2d9876d79818f8f + Reseal a trusted key under new pcr values:: $ keyctl update 268728824 "update pcrinfo=`cat pcr.blob`"
include/keys/trusted-type.h +5 -1
@@ -14,16 +14,20 @@#define MIN_KEY_SIZE 32#define MAX_KEY_SIZE 128#define MAX_BLOB_SIZE 512 -#define MAX_PCRINFO_SIZE 64 +#define MAX_PCRINFO_SIZE 128#define MAX_DIGEST_SIZE 64 +#define TPM2_MAX_POLICIES 16 +struct trusted_key_payload {struct rcu_head rcu;unsigned int key_len;unsigned int blob_len;unsigned char migratable; +unsigned char old_format;unsigned char key[MAX_KEY_SIZE +1 ];unsigned char blob[MAX_BLOB_SIZE ]; +struct tpm2_policies *policies; };struct trusted_key_options {
include/linux/tpm.h +7 -0
@@ -222,10 +222,14 @@ enum tpm2_command_codes {TPM2_CC_CONTEXT_LOAD =0x0161 ,TPM2_CC_CONTEXT_SAVE =0x0162 ,TPM2_CC_FLUSH_CONTEXT =0x0165 , +TPM2_CC_POLICY_AUTHVALUE =0x016B , +TPM2_CC_POLICY_COUNTER_TIMER =0x016D , +TPM2_CC_START_AUTH_SESS =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,
@@ -234,6 +238,7 @@ enum tpm2_command_codes { };enum tpm2_permanent_handles { +TPM2_RH_NULL =0x40000007 ,TPM2_RS_PW =0x40000009 , };
@@ -297,6 +302,8 @@ struct tpm_buf { };enum tpm2_object_attributes { +TPM2_OA_FIXED_TPM =BIT (1 ), +TPM2_OA_FIXED_PARENT =BIT (4 ),TPM2_OA_USER_WITH_AUTH =BIT (6 ), };
security/keys/Kconfig +2 -0
@@ -76,6 +76,8 @@ config TRUSTED_KEYS select CRYPTO select CRYPTO_HMAC select CRYPTO_SHA1 + select CRYPTO_SHA256 + select CRYPTO_SHA512 select CRYPTO_HASH_INFO help This option provides support for creating, sealing, and unsealing
security/keys/trusted-keys/Makefile +1 -1
@@ -5,4 +5,4 @@ obj-$(CONFIG_TRUSTED_KEYS) += trusted.o trusted-y += trusted_tpm1.o -trusted-y += trusted_tpm2.o +trusted-y += trusted_tpm2.o tpm2key.asn1.o tpm2-policy.o
security/keys/trusted-keys/tpm2-policy.c new file +372 -0
372 lines not on this page · raw message
security/keys/trusted-keys/tpm2-policy.h new file +30 -0
@@ -0,0 +1,30 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ + +struct tpm2key_context { +u32 parent; +const u8 *pub; +u32 pub_len; +const u8 *priv; +u32 priv_len; +const u8 *policies[TPM2_MAX_POLICIES ]; +u32 policy_code[TPM2_MAX_POLICIES ]; +u16 policy_len[TPM2_MAX_POLICIES ]; +u8 policy_count; +}; + +struct tpm2_policies { +u32 code[TPM2_MAX_POLICIES ]; +u8 *policies[TPM2_MAX_POLICIES ]; +u16 len[TPM2_MAX_POLICIES ]; +u8 count; +u16 hash; +u16 hash_size; +}; + +int tpmkey_policy_process (struct tpm2key_context *ctx, +struct trusted_key_payload *payload); +int tpm2_generate_policy_digest (struct tpm2_policies *pols,u32 hash, +u8 *policydigest,u32 *plen); +int tpm2_encode_policy (struct tpm2_policies *pols,u8 **data,u32 *len); +int tpm2_get_policy_session (struct tpm_chip *chip,struct tpm2_policies *pols, +u32 *handle);
security/keys/trusted-keys/tpm2key.asn1 new file +23 -0
@@ -0,0 +1,23 @@ +--- +--- Note: This isn't quite the definition in the standard +--- However, the Linux asn.1 parser doesn't understand +--- [2] EXPLICIT SEQUENCE OF OPTIONAL +--- So there's an extra intermediate TPMPolicySequence +--- definition to work around this + +TPMKey ::= SEQUENCE { + type OBJECT IDENTIFIER ({tpmkey_type}), + emptyAuth [0] EXPLICIT BOOLEAN OPTIONAL, + policy [1] EXPLICIT TPMPolicySequence OPTIONAL, + secret [2] EXPLICIT OCTET STRING OPTIONAL, + parent INTEGER ({tpmkey_parent}), + pubkey OCTET STRING ({tpmkey_pub}), + privkey OCTET STRING ({tpmkey_priv}) + } + +TPMPolicySequence ::= SEQUENCE OF TPMPolicy + +TPMPolicy ::= SEQUENCE { + commandCode [0] EXPLICIT INTEGER ({tpmkey_code}), + commandPolicy [1] EXPLICIT OCTET STRING ({tpmkey_policy}) + }
security/keys/trusted-keys/trusted_tpm1.c +7 -2
@@ -1007,7 +1007,7 @@ static int trusted_instantiate(struct key *key, goto out; } -if (!options->keyhandle) { +if (!options->keyhandle && !tpm2) { ret = -EINVAL ; goto out; }
@@ -1061,6 +1061,7 @@ static void trusted_rcu_free(struct rcu_head *rcu)struct trusted_key_payload *p; p = container_of(rcu, struct trusted_key_payload, rcu); +kzfree (p->policies);kzfree (p); }
@@ -1180,7 +1181,11 @@ static long trusted_read(const struct key *key, char __user *buffer,*/ static void trusted_destroy (struct key *key) { -kzfree (key->payload.data[0 ]); +struct trusted_key_payload *p; + + p = key->payload.data[0 ]; +kzfree (p->policies); +kzfree (p); }struct key_type key_type_trusted = {
security/keys/trusted-keys/trusted_tpm2.c +305 -22
443 lines not on this page · raw message
Signature · 1 line
2.16.4
Re: [PATCH v5 4/6] security: keys: trusted: use ASN.1 TPM2 key format for the blobs
Hi James,
<snip>
Quoted 30 lines
security/keys/trusted-keys/tpm2key.asn1 new file +22
-0@@ -0,0 +1,23 @@ +--- +--- Note: This isn't quite the definition in the standard +--- However, the Linux asn.1 parser doesn't understand +--- [2] EXPLICIT SEQUENCE OF OPTIONAL +--- So there's an extra intermediate TPMPolicySequence +--- definition to work around this + +TPMKey ::= SEQUENCE { + type OBJECT IDENTIFIER ({tpmkey_type}), + emptyAuth [0] EXPLICIT BOOLEAN OPTIONAL, + policy [1] EXPLICIT TPMPolicySequence OPTIONAL, + secret [2] EXPLICIT OCTET STRING OPTIONAL, + parent INTEGER ({tpmkey_parent}), + pubkey OCTET STRING ({tpmkey_pub}), + privkey OCTET STRING ({tpmkey_priv}) + } + +TPMPolicySequence ::= SEQUENCE OF TPMPolicy + +TPMPolicy ::= SEQUENCE { + commandCode [0] EXPLICIT INTEGER ({tpmkey_code}), + commandPolicy [1] EXPLICIT OCTET STRING({
tpmkey_policy})
security/keys/trusted-keys/tpm2key.asn1
Quoted 1 line
security/keys/trusted-keys/tpm2key.asn1 new file +1
-0+ }
I have been using your set of patches in order to get this ASN.1 parser/definition. I am implementing an asymmetric key parser/type TPM2 keys for enc/dec/sign/verify using keyctl. Note that this implementation goes in crypto/asymmetric_keys/, and your patches sit in security/keys/trusted-keys/.
Currently I am just including "../../security/keys/trusted- keys/{tpm2key.asn1.h,tpm2-policy.h}" in order to use the ASN.1 parser to verify my keys, but this obviously isn't going to fly.
Do you (or anyone) have any ideas as to how both trusted keys and asymmetric keys could share this ASN.1 parser/definition? Some common area that both security and crypto could include? Or maybe there is some common way the kernel does things like this?
Thanks,
James
James Bottomley
maintainerRe: [PATCH v5 4/6] security: keys: trusted: use ASN.1 TPM2 key format for the blobs
Quoted 46 lines · James Prestwood
Hi James,
<snip>
Quoted 32 lines
security/keys/trusted-keys/tpm2key.asn1 new file +11
-0@@ -0,0 +1,23 @@ +--- +--- Note: This isn't quite the definition in the standard +--- However, the Linux asn.1 parser doesn't understand +--- [2] EXPLICIT SEQUENCE OF OPTIONAL +--- So there's an extra intermediate TPMPolicySequence +--- definition to work around this + +TPMKey ::= SEQUENCE { + type OBJECT IDENTIFIER ({tpmkey_type}), + emptyAuth [0] EXPLICIT BOOLEAN OPTIONAL, + policy [1] EXPLICIT TPMPolicySequenceOPTIONAL,
security/keys/trusted-keys/tpm2key.asn1 new file +10
-0+ secret [2] EXPLICIT OCTET STRING OPTIONAL, + parent INTEGER ({tpmkey_parent}), + pubkey OCTET STRING ({tpmkey_pub}), + privkey OCTET STRING ({tpmkey_priv}) + } + +TPMPolicySequence ::= SEQUENCE OF TPMPolicy + +TPMPolicy ::= SEQUENCE { + commandCode [0] EXPLICIT INTEGER({
tpmkey_code}),security/keys/trusted-keys/tpm2key.asn1 new file +1
-0+ commandPolicy [1] EXPLICIT OCTET STRING({
tpmkey_policy})security/keys/trusted-keys/tpm2key.asn1
Quoted 1 line
security/keys/trusted-keys/tpm2key.asn1 new file +1
-0+ }I have been using your set of patches in order to get this ASN.1 parser/definition. I am implementing an asymmetric key parser/type TPM2
keys for enc/dec/sign/verify using keyctl. Note that this implementation goes incrypto/asymmetric_keys/, and your patches sit insecurity/keys/trusted-keys/.
Quoted 8 lines
Currently I am just including "../../security/keys/trusted- keys/{tpm2key.asn1.h,tpm2-policy.h}" in order to use the ASN.1 parser to verify my keys, but this obviously isn't going to fly.
Do you (or anyone) have any ideas as to how both trusted keys and asymmetric keys could share this ASN.1 parser/definition? Some common area that both security and crypto could include? Or maybe there is some common way the kernel does things like this?
Actually TPM2 asymmetric keys was also on my list. I was going to use the existing template and simply move it somewhere everyone could use. I also think you need the policy parser pieces because at least one implementation we'd need to be compatible with supports key policy.
Regards,
James
Re: [PATCH v5 4/6] security: keys: trusted: use ASN.1 TPM2 key format for the blobs
Quoted 20 lines
Quoted 14 lines
I have been using your set of patches in order to get this ASN.1 parser/definition. I am implementing an asymmetric key parser/type TPM2
keys for enc/dec/sign/verify using keyctl. Note that this implementation goes incrypto/asymmetric_keys/, and your patches sit
insecurity/keys/trusted-keys/.Currently I am just including "../../security/keys/trusted- keys/{tpm2key.asn1.h,tpm2-policy.h}" in order to use the ASN.1 parser
to verify my keys, but this obviously isn't going to fly.Quoted 5 lines
Do you (or anyone) have any ideas as to how both trusted keys and asymmetric keys could share this ASN.1 parser/definition? Some common
area that both security and crypto could include? Or maybe there is some common way the kernel does things like this?
Quoted 6 lines
Actually TPM2 asymmetric keys was also on my list. I was going to use
the existing template and simply move it somewhere everyone could use.
I also think you need the policy parser pieces because at least one implementation we'd need to be compatible with supports key policy.
In terms of policy, I haven't looked into that at all for asymmetric keys. I do already have enc/dec/sign/verify asymmetric key operations all working, and used your ASN1 template for parsing (just copied it into asymmetric_keys for now). Since the asymmetric operations use HMAC sessions I didn't see much carry over from your patches (but this could change if policy stuff gets introduced).
This will go in the eventual RFC soon but while I have you here:
I also implemented key wrapping. Exposing this as a keyctl API may take some rework, hopefully with some help from others in this subsystem. As it stand now you have to padd a key pair, then do a (new) pkey_wrap operation on it. This returns a DER with the wrapped TPM2 key. This required modifying the public_key type, which I really did not like since it now depends on TPM. Not sure if the route I went is gonna fly without tweaking, but this is all new to me :) Again, some guidance for how this should be is needed.
Before I send these patches I need to get some testing done on real TPM2 hardware. So far its just been emulation. But these patches should be coming very soon.
Thanks,
James
Quoted 5 lines
Regards,
James
James Bottomley
maintainerRe: [PATCH v5 4/6] security: keys: trusted: use ASN.1 TPM2 key format for the blobs
Quoted 21 lines · James Prestwood
Quoted 15 lines
Quoted 6 lines
I have been using your set of patches in order to get this ASN.1 parser/definition. I am implementing an asymmetric key parser/type TPM2 keys for enc/dec/sign/verify using keyctl. Note that this implementation goes in
crypto/asymmetric_keys/, and your patches sit insecurity/keys/trusted-keys/.Quoted 8 lines
Currently I am just including "../../security/keys/trusted- keys/{tpm2key.asn1.h,tpm2-policy.h}" in order to use the ASN.1 parser to verify my keys, but this obviously isn't going to fly.
Do you (or anyone) have any ideas as to how both trusted keys and asymmetric keys could share this ASN.1 parser/definition? Some common area that both security and crypto could include? Or maybe there is some common way the kernel does things like this?
Quoted 5 lines
Actually TPM2 asymmetric keys was also on my list. I was going to use the existing template and simply move it somewhere everyone could use. I also think you need the policy parser pieces because at least one implementation we'd need to be compatible with supports key policy.
Quoted 6 lines
In terms of policy, I haven't looked into that at all for asymmetric keys. I do already have enc/dec/sign/verify asymmetric key operations all working, and used your ASN1 template for parsing (just copied it into
asymmetric_keysfor now). Since the asymmetric operations use HMAC sessions I didn't see much carry over from your patches (but this could change if policy stuff gets introduced).
There's a related patch that introduces HMAC and encryption sessions for pretty much everything in the TPM:
https://lore.kernel.org/r/[email protected]
I didn't resend this time around because of patch overload, and anyway, the last patch needs updating for the current policy c
Quoted 5 lines
This will go in the eventual RFC soon but while I have you here:
I also implemented key wrapping. Exposing this as a keyctl API may take some rework, hopefully with some help from others in this subsystem.
Wrapping for what? The output privkey in the ASN.1 is wrapped by the TPM using its internal AES key. The ASN.1 also defines ECDH wrapping, that's what the secret element of the sequence is for, but you'd only use that for creating a wrapped key to pass in to the TPM knowing the parent. The way current TPM crypto systems use this is they generate an EC parent from the storage primary seed on the NIST P256 curve.
It's on my todo list to accept bare primary identifiers as parents in the kernel code and create the EC primary on the fly, but it's not in this patch set.
There's also another policy problem in that generating an RSA2048 key can lock the TPM up for ages, so there should likely be some type of block on someone doing this. I was thinking that an unprivileged user should be allowed to create EC keys but not RSA ones.
Quoted 6 lines
As it stand now you have to padd a key pair, then do a (new)
pkey_wrapoperation on it. This returns a DER with the wrapped TPM2 key. This required modifying thepublic_keytype, which I really did not like since it now depends on TPM. Not sure if the route I went is gonna fly without tweaking, but this is all new to me :) Again, some guidance for how this should be is needed.
The way it's defined to be done using the ASN.1 secret parameter is simply the way the TPM2 command manual defines duplication with an outer wrapper. The TPM2 manual even has a coded example in section 4 and the secret is simply a TPM2B_ENCRYPTED_SECRET.
Quoted 3 lines
Before I send these patches I need to get some testing done on real TPM2 hardware. So far its just been emulation. But these patches should be coming very soon.
Sure thing, but you may want to look at some of the existing code that this will need to interoperate with. The most complete is the openssl engine, but there's also the intel version of that and openconnect which all use the same key format:
https://git.kernel.org/pub/scm/linux/kernel/git/jejb/openssl_tpm2_engine.git/
Regards,
James
Re: [PATCH v5 4/6] security: keys: trusted: use ASN.1 TPM2 key format for the blobs
Quoted 39 lines · James Bottomley
Quoted 28 lines · James Prestwood
Quoted 20 lines
Quoted 13 lines
I have been using your set of patches in order to get this ASN.1
parser/definition. I am implementing an asymmetric key parser/type TPM2 keys for enc/dec/sign/verify using keyctl. Note
that this implementation goes incrypto/asymmetric_keys/, and your patches sit insecurity/keys/trusted-keys/.Currently I am just including "../../security/keys/trusted- keys/{tpm2key.asn1.h,tpm2-policy.h}" in order to use the ASN.1 parser to verify my keys, but this obviously isn't going to fly.
Quoted 6 lines
Do you (or anyone) have any ideas as to how both trusted keys and
asymmetric keys could share this ASN.1 parser/definition? Some common area that both security and crypto could include? Or maybe
there is some common way the kernel does things like this?Quoted 7 lines
Actually TPM2 asymmetric keys was also on my list. I was going to
use the existing template and simply move it somewhere everyone could use. I also think you need the policy parser pieces because
at least one implementation we'd need to be compatible with supports key policy.Quoted 9 lines
In terms of policy, I haven't looked into that at all for asymmetric
keys. I do already have enc/dec/sign/verify asymmetric key operations
all working, and used your ASN1 template for parsing (just copied it
intoasymmetric_keysfor now). Since the asymmetric operations use HMAC sessions I didn't see much carry over from your patches (but this could change if policy stuff gets introduced).
Quoted 4 lines
There's a related patch that introduces HMAC and encryption sessions for pretty much everything in the TPM:
https://lore.kernel.org/r/[email protected]
Quoted 4 lines
I didn't resend this time around because of patch overload, and anyway,
the last patch needs updating for the current policy c
Well... I sure duplicated a lot of work. I haven't been on these lists long enough to see that come through. I am still reading through these patches, but noticed some differences already with how the session is started. I use the parent key handle for "salt key handle" rather than the null key. Also I used RSA/OAEP for encrypting the salt value rather than ECC. I hadn't read into the null key thing, but I will now. I would be more than happy to rip out the OAEP code though. I was just modeling everything how libtpms did it, which used OAEP.
Obviously we don't want a bunch of duplicated code, but I am somewhat concerned about going right in and using these patches as they have been sitting around quite a while (plus you said they will need updating). Seems like the best route is get these merged, then update/send my patches.
Quoted 7 lines
Quoted 6 lines
This will go in the eventual RFC soon but while I have you here:
I also implemented key wrapping. Exposing this as a keyctl API may take some rework, hopefully with some help from others in this subsystem.
Quoted 7 lines
Wrapping for what? The output privkey in the ASN.1 is wrapped by the TPM using its internal AES key. The ASN.1 also defines ECDH wrapping,
that's what the secret element of the sequence is for, but you'd only use that for creating a wrapped key to pass in to the TPM knowing the parent. The way current TPM crypto systems use this is they generate an EC parent from the storage primary seed on the NIST P256 curve.
I implemented CC_Import(). You generate the private key yourself (openssl or however) and import it into the TPM. Then the result of that is the TPM wrapped key that can be loaded later on. And yes this depends on knowing the parent handle.
I basically just implemented:
create_tpm2_key -w privkey.pem -p <handle> privkey.tpm
My reasoning for this was because I had issues with the openssl_tpm2_engine, and just the whole TPM2 on Linux support as it stands now. I was able to get everything working on Debian, but then I went to test on real TPM hardware, which happened to be a Fedora box. This was a complete disaster; openssl_tpm2_engine did not compile due to (I think) a library versioning issue and build warnings. I ignored warnings, and manually built my own version of libtpms but this just resulted in create_tpm2_key to segfault. At this point I just thought it would be more worth my time to implement Import() myself.
I think this was all a result of bad packaging on Fedora's part, but still, the experience didn't sit well with me and I felt it would be worth while to add support for this in keyctl.
Quoted 10 lines
It's on my todo list to accept bare primary identifiers as parents in the kernel code and create the EC primary on the fly, but it's not in this patch set.
There's also another policy problem in that generating an RSA2048 key can lock the TPM up for ages, so there should likely be some type of block on someone doing this. I was thinking that an unprivileged user
should be allowed to create EC keys but not RSA ones.
I didn't have any plans for RSA key generation inside the TPM itself, just wrapping/asym operations.
Quoted 11 lines
Quoted 10 lines
As it stand now you have to padd a key pair, then do a (new)
pkey_wrapoperation on it. This returns a DER with the wrapped TPM2 key. This required modifying thepublic_keytype, which I really did
not like since it now depends on TPM. Not sure if the route I went is
gonna fly without tweaking, but this is all new to me :) Again, some
guidance for how this should be is needed.
Quoted 4 lines
The way it's defined to be done using the ASN.1 secret parameter is simply the way the TPM2 command manual defines duplication with an outer wrapper. The TPM2 manual even has a coded example in section 4 and the secret is simply a
TPM2B_ENCRYPTED_SECRET.
I actually didn't do any inner/outer encryption when sending the key to the TPM (if this isn't what your talking about disregard). I just sent the private key over plainly. Maybe bus snooping is a concern, but as a first pass I just punted on this.
Quoted 5 lines
Quoted 4 lines
Before I send these patches I need to get some testing done on real TPM2 hardware. So far its just been emulation. But these patches should be coming very soon.
Quoted 8 lines
Sure thing, but you may want to look at some of the existing code that
this will need to interoperate with. The most complete is the openssl
engine, but there's also the intel version of that and openconnect which all use the same key format:
https://git.kernel.org/pub/scm/linux/kernel/git/jejb/openssl_tpm2_engine.git/
Yes, as far as wrapping/enc/dec/sign/verify, these all inter-operate with openssl_tpm2_engine. I have not tried openconnect or the intel tools but I'll check those out to verify.
Thanks,
James
Quoted 5 lines
Regards,
James
James Bottomley
maintainerRe: [PATCH v5 4/6] security: keys: trusted: use ASN.1 TPM2 key format for the blobs
Quoted 42 lines · James Prestwood
Quoted 33 lines · James Bottomley
Quoted 24 lines · James Prestwood
Quoted 18 lines
Quoted 12 lines
I have been using your set of patches in order to get this ASN.1 parser/definition. I am implementing an asymmetric key parser/type TPM2 keys for enc/dec/sign/verify using keyctl. Note that this implementation goes in
crypto/asymmetric_keys/, and your patches sit insecurity/keys/trusted-keys/.Currently I am just including "../../security/keys/trusted- keys/{tpm2key.asn1.h,tpm2-policy.h}" in order to use the ASN.1 parser to verify my keys, but this obviously isn't going to fly.
Quoted 5 lines
Do you (or anyone) have any ideas as to how both trusted keys and asymmetric keys could share this ASN.1 parser/definition? Some common area that both security and crypto could include? Or maybe there is some common way the kernel does things like this?
Quoted 5 lines
Actually TPM2 asymmetric keys was also on my list. I was going to use the existing template and simply move it somewhere everyone could use. I also think you need the policy parser pieces because at least one implementation we'd need to be compatible with supports key policy.
Quoted 7 lines
In terms of policy, I haven't looked into that at all for asymmetric keys. I do already have enc/dec/sign/verify asymmetric key operations all working, and used your ASN1 template for parsing (just copied it into
asymmetric_keysfor now). Since the asymmetric operations use HMAC sessions I didn't see much carry over from your patches (but this could change if policy stuff gets introduced).Quoted 4 lines
There's a related patch that introduces HMAC and encryption sessions for pretty much everything in the TPM:
https://lore.kernel.org/r/1568031408.6613.29.camel@HansenPartnership.
comQuoted 1 line
Quoted 8 lines
Quoted 2 lines
I didn't resend this time around because of patch overload, and anyway, the last patch needs updating for the current policy c
Well... I sure duplicated a lot of work. I haven't been on these lists long enough to see that come through. I am still reading through these patches, but noticed some differences already with how the session is started. I use the parent key handle for "salt key handle" ratherthan the null key.
That's a minor detail. The routines could be updated to use anything for the parent. The null seed is just convenient and has nice security properties.
Quoted 4 lines
Also I used RSA/OAEP for encrypting the salt value rather than ECC.
I hadn't read into the null key thing, but I will now. I would be more than happy to rip out the OAEP code though. I was just modeling everything how libtpms did it, which used OAEP.
There's not much the IBM and Intel TSS teams agree on, but we do agree that RSA is a bad choice for parents and that EC keys are much better. The main reason is that most TPM 2's are much worse at RSA operations than EC ones ... you're looking at factors of 10x to 100x simply because of the huge bignum complexity of RSA, which really slows everything down when you use RSA parents for crypto operations. Then, as you found, no-one really does the padding with OAEP either.
Quoted 5 lines
Obviously we don't want a bunch of duplicated code, but I am somewhat concerned about going right in and using these patches as they have been sitting around quite a while (plus you said they will need updating). Seems like the best route is get these merged, then update/send my patches.
So we figure out the correct precursor patches and have a couple of sets ... Jarkko likes stuff done this way anyway.
Quoted 13 lines
Quoted 5 lines
Quoted 4 lines
This will go in the eventual RFC soon but while I have you here:
I also implemented key wrapping. Exposing this as a keyctl API
may take some rework, hopefully with some help from others in this subsystem.Quoted 7 lines
Wrapping for what? The output privkey in the ASN.1 is wrapped by the TPM using its internal AES key. The ASN.1 also defines ECDH wrapping, that's what the secret element of the sequence is for, but you'd only use that for creating a wrapped key to pass in to the TPM knowing the parent. The way current TPM crypto systems use this is they generate an EC parent from the storage primary seed on the NIST P256 curve.
Quoted 4 lines
I implemented
CC_Import(). You generate the private key yourself (openssl or however) and import it into the TPM. Then the result of that is the TPM wrapped key that can be loaded later on. And yes this depends on knowing the parent handle.
Right, that's what the key wrapping code of the engine does as well, except that we use EC parents and ECDH wrapping.
Quoted 15 lines
I basically just implemented:
create_tpm2_key-w privkey.pem -p <handle> privkey.tpmMy reasoning for this was because I had issues with the
openssl_tpm2_engine, and just the whole TPM2 on Linux support as it stands now. I was able to get everything working on Debian, but then I went to test on real TPM hardware, which happened to be a Fedora box. This was a complete disaster;openssl_tpm2_enginedid not compile due to (I think) a library versioning issue and build warnings. I ignored warnings, and manually built my own version ofopenssl libtpms but this just resulted increate_tpm2_keyto segfault. At this point I just thought it would be more worth my time to implementImport()myself.
Quoted 3 lines
I think this was all a result of bad packaging on Fedora's part, but still, the experience didn't sit well with me and I felt it would be worth while to add support for this in keyctl.
Well there's a list you can report problems to and get help:
I've got to confess I develop on openSUSE and debian, so Fedora doesn't get much testing.
Quoted 4 lines
Quoted 4 lines
It's on my todo list to accept bare primary identifiers as parents in the kernel code and create the EC primary on the fly, but it's not in this patch set.
Quoted 8 lines
Quoted 5 lines
There's also another policy problem in that generating an RSA2048 key can lock the TPM up for ages, so there should likely be some type of block on someone doing this. I was thinking that an unprivileged user should be allowed to create EC keys but not RSA ones.
I didn't have any plans for RSA key generation inside the TPM itself, just wrapping/asym operations.
Well as long as we're interoperable with create_tpm2_key, the consumer can generate a TPM resident key outside the kernel if they want and then simply pass it in.
Quoted 12 lines
Quoted 11 lines
Quoted 6 lines
As it stand now you have to padd a key pair, then do a (new)
pkey_wrapoperation on it. This returns a DER with the wrapped TPM2 key. This required modifying thepublic_keytype, which I really did not like since it now depends on TPM. Not sure if the route I went is gonna fly without tweaking, but this is all new to me :) Again, some guidance for how this should be is needed.The way it's defined to be done using the ASN.1 secret parameter is simply the way the TPM2 command manual defines duplication with an outer wrapper. The TPM2 manual even has a coded example in section 4 and the secret is simply a
TPM2B_ENCRYPTED_SECRET.
Quoted 4 lines
I actually didn't do any inner/outer encryption when sending the key to the TPM (if this isn't what your talking about disregard). I just sent the private key over plainly. Maybe bus snooping is a concern, but as a first pass I just punted on this.
Well to get TPM2_Import to work with an encrypted secret *is* what the manuals call outer wrapping, you just used an RSA encrypted secret instead of an ECDH protected one. It's the same sequence of operations as for duplication.
Regards,
James
Quoted 18 lines
Quoted 8 lines
Quoted 3 lines
Before I send these patches I need to get some testing done on real TPM2 hardware. So far its just been emulation. But these patches should be coming very soon.
Sure thing, but you may want to look at some of the existing code that this will need to interoperate with. The most complete is the openssl engine, but there's also the intel version of that and openconnect which all use the same key format:
https://git.kernel.org/pub/scm/linux/kernel/git/jejb/openssl_tpm2_eng
ine.git/Yes, as far as wrapping/enc/dec/sign/verify, these all inter-operate with
openssl_tpm2_engine. I have not tried openconnect or the intel tools but I'll check those out to verify.Thanks,
James
James Bottomley
maintainerRe: [PATCH v5 4/6] security: keys: trusted: use ASN.1 TPM2 key format for the blobs
Quoted 1 line · James Bottomley
On Thu, 2020-02-27 at 09:19 -0800, James Prestwood wrote:
[...]
Quoted 10 lines
Quoted 3 lines
I think this was all a result of bad packaging on Fedora's part, but still, the experience didn't sit well with me and I felt it would be worth while to add support for this in keyctl.
Well there's a list you can report problems to and get help:
I've got to confess I develop on openSUSE and debian, so Fedora doesn't get much testing.
I should add that even though I don't test on fedora, the opensuse build service does in my TPM build environment:
https://build.opensuse.org/package/show/home:jejb1:TPM/openssl_tpm2_engine
It says the builds for Fedora 26, 29 and Rawhide all succeeded. The build service does both building and testing with the swtpm, so the engine on fedora gets a pretty extensive workout.
James
Re: [PATCH v5 4/6] security: keys: trusted: use ASN.1 TPM2 key format for the blobs
Quoted 10 lines · James Bottomley
Quoted 1 line · James Bottomley
On Thu, 2020-02-27 at 09:19 -0800, James Prestwood wrote:
[...]
Quoted 6 lines
Quoted 3 lines
I think this was all a result of bad packaging on Fedora's part, but still, the experience didn't sit well with me and I felt it would be worth while to add support for this in keyctl.
Well there's a list you can report problems to and get help:
Quoted 9 lines
Quoted 4 lines
I've got to confess I develop on openSUSE and debian, so Fedora doesn't get much testing.
I should add that even though I don't test on fedora, the opensuse build service does in my TPM build environment:
https://build.opensuse.org/package/show/home:jejb1:TPM/openssl_tpm2_engine
Quoted 4 lines
It says the builds for Fedora 26, 29 and Rawhide all succeeded. The build service does both building and testing with the swtpm, so the engine on fedora gets a pretty extensive workout.
Hmm, ok I will be trying this again then. Thanks.
Quoted 3 lines
James
Re: [PATCH v5 4/6] security: keys: trusted: use ASN.1 TPM2 key format for the blobs
In reply to James BottomleyQuoted 43 lines · James Bottomley
Quoted 42 lines · James Prestwood
Quoted 41 lines · James Bottomley
Quoted 39 lines · James Prestwood
Quoted 23 lines
Quoted 13 lines
I have been using your set of patches in order to get this ASN.1 parser/definition. I am implementing an asymmetric key
parser/type TPM2 keys for enc/dec/sign/verify using keyctl. Note that this implementation goes incrypto/asymmetric_keys/, and your patches sit insecurity/keys/trusted-keys/.Currently I am just including "../../security/keys/trusted- keys/{tpm2key.asn1.h,tpm2-policy.h}" in order to use the ASN.1 parser to verify my keys, but this obviously isn't going to fly.
Quoted 9 lines
Do you (or anyone) have any ideas as to how both trusted keys
and asymmetric keys could share this ASN.1 parser/definition?
Some common area that both security and crypto could include?
Or maybe there is some common way the kernel does things like
this?Quoted 6 lines
Actually TPM2 asymmetric keys was also on my list. I was going
to use the existing template and simply move it somewhere everyone could use. I also think you need the policy parser pieces because at least one implementation we'd need to be compatible with supports key policy.In terms of policy, I haven't looked into that at all for asymmetric keys. I do already have enc/dec/sign/verify asymmetric
key operations all working, and used your ASN1 template for parsing (just copied it intoasymmetric_keysfor now). Since the
asymmetric operations use HMAC sessions I didn't see much carry over from your patches (but this could change if policy stuff gets introduced).
Quoted 6 lines
Quoted 6 lines
Quoted 4 lines
There's a related patch that introduces HMAC and encryption sessions for pretty much everything in the TPM:
https://lore.kernel.org/r/1568031408.6613.29.camel@HansenPartnership
Quoted 25 lines
Quoted 6 lines
.
comQuoted 3 lines
I didn't resend this time around because of patch overload, and anyway, the last patch needs updating for the current policy c
Quoted 6 lines
Well... I sure duplicated a lot of work. I haven't been on these lists long enough to see that come through. I am still reading through these patches, but noticed some differences already with how
the session is started. I use the parent key handle for "salt key handle" ratherthan the null key.That's a minor detail. The routines could be updated to use anything for the parent. The null seed is just convenient and has nice security
properties.Quoted 6 lines
Also I used RSA/OAEP for encrypting the salt value rather than
ECC.
I hadn't read into the null key thing, but I will now. I would be more than happy to rip out the OAEP code though. I was just modeling
everything how libtpms did it, which used OAEP.
Quoted 10 lines
There's not much the IBM and Intel TSS teams agree on, but we do agree
that RSA is a bad choice for parents and that EC keys are much better.
The main reason is that most TPM 2's are much worse at RSA operations than EC ones ... you're looking at factors of 10x to 100x simply because of the huge bignum complexity of RSA, which really slows everything down when you use RSA parents for crypto operations. Then,
as you found, no-one really does the padding with OAEP either.
I am learning lots from this discussion, so thank you. I had assumed that the parent key crypto had to match the child key, RSA vs EC, but sounds like that is not the case. And yes, this sounds like a much better way to go now that I have a bit more info on it.
Quoted 10 lines
Quoted 7 lines
Obviously we don't want a bunch of duplicated code, but I am somewhat
concerned about going right in and using these patches as they have been sitting around quite a while (plus you said they will need updating). Seems like the best route is get these merged, then update/send my patches.So we figure out the correct precursor patches and have a couple of sets ... Jarkko likes stuff done this way anyway.
Ok, I'll figure out exactly what I need. Its looking like the only duplication is starting the session and all the HMAC helpers.
Quoted 100 lines
Quoted 17 lines
Quoted 7 lines
Quoted 6 lines
This will go in the eventual RFC soon but while I have you here:
I also implemented key wrapping. Exposing this as a keyctl API
may take some rework, hopefully with some help from others in this subsystem.Quoted 9 lines
Wrapping for what? The output privkey in the ASN.1 is wrapped by the TPM using its internal AES key. The ASN.1 also defines ECDH wrapping, that's what the secret element of the sequence is for, but you'd only use that for creating a wrapped key to pass in to the TPM knowing the parent. The way current TPM crypto systems use
this is they generate an EC parent from the storage primary seed on
the NIST P256 curve.Quoted 5 lines
I implemented
CC_Import(). You generate the private key yourself (openssl or however) and import it into the TPM. Then the result of that is the TPM wrapped key that can be loaded later on. And yes this
depends on knowing the parent handle.Right, that's what the key wrapping code of the engine does as well, except that we use EC parents and ECDH wrapping.
Quoted 17 lines
I basically just implemented:
create_tpm2_key-w privkey.pem -p <handle> privkey.tpmMy reasoning for this was because I had issues with the
openssl_tpm2_engine, and just the whole TPM2 on Linux support as it stands now. I was able to get everything working on Debian, but then
I went to test on real TPM hardware, which happened to be a Fedora box. This was a complete disaster;openssl_tpm2_enginedid not compile due to (I think) a library versioning issue and build warnings. I ignored warnings, and manually built my own version ofopenssl libtpms but this just resulted increate_tpm2_keyto segfault. At this point I just thought it would be more worth my time
to implementImport()myself.Quoted 5 lines
I think this was all a result of bad packaging on Fedora's part, but
still, the experience didn't sit well with me and I felt it would be
worth while to add support for this in keyctl.Well there's a list you can report problems to and get help:
I've got to confess I develop on openSUSE and debian, so Fedora doesn't
get much testing.Quoted 11 lines
Quoted 10 lines
It's on my todo list to accept bare primary identifiers as parents
in the kernel code and create the EC primary on the fly, but it's not in this patch set.There's also another policy problem in that generating an RSA2048 key can lock the TPM up for ages, so there should likely be some type of block on someone doing this. I was thinking that an unprivileged user should be allowed to create EC keys but not RSA ones.
Quoted 3 lines
I didn't have any plans for RSA key generation inside the TPM itself,
just wrapping/asym operations.Well as long as we're interoperable with
create_tpm2_key, the consumer
can generate a TPM resident key outside the kernel if they want and then simply pass it in.Quoted 16 lines
Quoted 8 lines
Quoted 7 lines
As it stand now you have to padd a key pair, then do a (new)
pkey_wrapoperation on it. This returns a DER with the wrapped TPM2 key. This required modifying thepublic_keytype, which I really did not like since it now depends on TPM. Not sure if the
route I went is gonna fly without tweaking, but this is all new to me :) Again, some guidance for how this should be is needed.Quoted 7 lines
The way it's defined to be done using the ASN.1 secret parameter is
simply the way the TPM2 command manual defines duplication with an
outer wrapper. The TPM2 manual even has a coded example in section
4 and the secret is simply aTPM2B_ENCRYPTED_SECRET.Quoted 6 lines
I actually didn't do any inner/outer encryption when sending the key
to the TPM (if this isn't what your talking about disregard). I just
sent the private key over plainly. Maybe bus snooping is a concern, but as a first pass I just punted on this.
Quoted 6 lines
Well to get
TPM2_Importto work with an encrypted secret *is* what the
manuals call outer wrapping, you just used an RSA encrypted secret instead of an ECDH protected one. It's the same sequence of operations
as for duplication.
Ok this makes more sense now.
Thanks,
James
Re: [PATCH v5 4/6] security: keys: trusted: use ASN.1 TPM2 key format for the blobs
Quoted 4 lines · James Prestwood
I am learning lots from this discussion, so thank you. I had assumed that the parent key crypto had to match the child key, RSA vs EC, but sounds like that is not the case. And yes, this sounds like a much better way to go now that I have a bit more info on it.
I know this old. Just FYI:
The TPM WG debated this for a while, but decided that the TPM should not enforce parent / child algorithm matching. It's for the application to decide.
I also note that parent keys wrap their child keys using a symmetric key, typically AES, not an RSA or ECC key. The load time would be the same for an ECC or RSA parent, because it's not using the asymmetric key.
This different from TPM 1.2, which always uses parent RSA wrapping.
The asymmetric key is used for:
1 - import (key backup, using externally generated keys) 2 - Salted sessions
While both are useful, they're not typically used in a critical path.
James Bottomley
maintainerRe: [PATCH v5 4/6] security: keys: trusted: use ASN.1 TPM2 key format for the blobs
Quoted 11 lines · Ken Goldman
Quoted 4 lines · James Prestwood
I am learning lots from this discussion, so thank you. I had assumed that the parent key crypto had to match the child key, RSA vs EC, but sounds like that is not the case. And yes, this sounds like a much better way to go now that I have a bit more info on it.
I know this old. Just FYI:
The TPM WG debated this for a while, but decided that the TPM should not enforce parent / child algorithm matching. It's for the application to decide.
Heh, they're lucky they made that decision otherwise we'd likely have been deprecating RSA keys (see below).
Quoted 4 lines
I also note that parent keys wrap their child keys using a symmetric key, typically AES, not an RSA or ECC key. The load time would be the same for an ECC or RSA parent, because it's not using the asymmetric key.
But that's not actually the problem. The problem is that if the primary parent doesn't exist, it has to be created. The TCG PC provisioning guide did require that the RSA storage parent be provisioned at 81000001 but that seems largely to be ignored, leading to most TPM2 key using applications, like the TPM2 engines, having to run TPM2_CreatePrimary themselves. The time taken to run TPM2_CreatePrimary for an RSA key is prohibitive, which is why we always use EC parent keys. If you look at both my engine and the Intel one, there's simply no provision for creating RSA parents, although you may use the NV version if it exists.
I also note that if we're using loadable, not importable keys which, again, is the majority use case, we actually don't care about the asymmetric part of the parent, so it would have been nice to have some type of partial create primary where it only derived the symmetric key and thus would save a huge amount of time for the RSA key and even a bit of time for the EC one.
Quoted 9 lines
This different from TPM 1.2, which always uses parent RSA wrapping.
The asymmetric key is used for:
1 - import (key backup, using externally generated keys) 2 - Salted sessions
While both are useful, they're not typically used in a critical path.
There's a third critical advantage: because TPM 1.2 isn't crypto agile, the parent is actually present in the TPM and doesn't have to be created on the fly.
James
Re: [PATCH v5 4/6] security: keys: trusted: use ASN.1 TPM2 key format for the blobs
In reply to James BottomleyHi James,
Quoted 7 lines
Quoted 7 lines
Quoted 5 lines
There's a related patch that introduces HMAC and encryption sessions for pretty much everything in the TPM:
https://lore.kernel.org/r/1568031408.6613.29.camel@HansenPartnership
Quoted 6 lines
Quoted 6 lines
.
comQuoted 3 lines
I didn't resend this time around because of patch overload, and anyway, the last patch needs updating for the current policy c
You had mentioned the need for updating, but these (or at least patch
1) failed to apply to v5.5. Looks like some headers had been shifted around since then. Could you rebase these when you get a chance? That way I can refactor my patches to use your session stuff.
Its hard to to be completely certain but I think all I need is patch 6/12. If that could be made to be a standalone patch and not depend on the previous sets that could work too.
Thanks,
James
James Bottomley
maintainerPATCH v5 5/6 security: keys: trusted: add ability to specify arbitrary policy
In reply to James BottomleyThis patch adds a policy= argument to key creation. The policy is the standard tss policymaker format and each separate policy line must have a newline after it.
Thus to construct a policy requiring authorized value and pcr 16 locking using a sha256 hash, the policy (policy.txt) file would be two lines:
0000017F00000001000B03000001303095B49BE85E381E5B20E557E46363EF55B0F43B132C2D8E3DE9AC436656F2 0000016b
This can be inserted into the key with
keyctl add trusted kmk "new 32 policy=cat policy.txt keyhandle=0x81000001 hash=sha256" @u
Note that although a few policies work like this, most require special handling which must be added to the kernel policy construction routine.
--- Documentation/security/keys/trusted-encrypted.rst | 16 +++++++ security/keys/trusted-keys/tpm2-policy.c | 53 +++++++++++++++++++++++ security/keys/trusted-keys/tpm2-policy.h | 1 + security/keys/trusted-keys/trusted_tpm1.c | 15 +++++++ 4 files changed, 85 insertions(+)
Documentation/security/keys/trusted-encrypted.rst +16 -0
@@ -76,6 +76,9 @@ Usage:: policyhandle= handle to an authorization policy session that defines the same policy and with the same hash algorithm as was used to seal the key. + policy= specify an arbitrary set of policies. These must + be in policymaker format with each separate + policy line newline terminated. "keyctl print" returns an ascii hex copy of the sealed key, which is in standard TPM_STORED_DATA format. The key length for new keys are always in bytes.
@@ -168,6 +171,19 @@ zeros (the value of PCR 16):: $ dd if=/dev/zero bs=1 count 2>/dev/null|sha1sum 6768033e216468247bd031a0a2d9876d79818f8f +You can also specify arbitrary policy in policymaker format, so a two +value policy (the pcr example above and authvalue) would look like +this in policymaker format:: + + 0000017F000000010004030000016768033e216468247bd031a0a2d9876d79818f8f + 0000016b + +This can be placed in a file (say policy.txt) and then added to the key as:: + + $ keyctl add trusted kmk "new 32 keyhandle=0x81000001 hash=sha1 policy=`cat policy.txt`" @u + +The newlines in the file policy.txt will be automatically processed. + Reseal a trusted key under new pcr values:: $ keyctl update 268728824 "update pcrinfo=`cat pcr.blob`"
security/keys/trusted-keys/tpm2-policy.c +53 -0
56 lines not on this page · raw message
security/keys/trusted-keys/tpm2-policy.h +1 -0
@@ -28,3 +28,4 @@ int tpm2_generate_policy_digest(struct tpm2_policies *pols, u32 hash,int tpm2_encode_policy (struct tpm2_policies *pols,u8 **data,u32 *len);int tpm2_get_policy_session (struct tpm_chip *chip,struct tpm2_policies *pols,u32 *handle); +int tpm2_parse_policies (struct tpm2_policies **ppols,char *str);
security/keys/trusted-keys/trusted_tpm1.c +15 -0
@@ -29,6 +29,8 @@#include <keys/trusted_tpm.h> +#include "tpm2-policy.h" +static const char hmac_alg[] ="hmac(sha1)" ;static const char hash_alg[] ="sha1" ;static struct tpm_chip *chip;
@@ -709,6 +711,7 @@ enum { Opt_hash, Opt_policydigest, Opt_policyhandle, + Opt_policy, }; static const match_table_t key_tokens = {
@@ -724,6 +727,7 @@ static const match_table_t key_tokens = { {Opt_hash, "hash=%s"}, {Opt_policydigest, "policydigest=%s"}, {Opt_policyhandle, "policyhandle=%s"}, + {Opt_policy, "policy=%s"}, {Opt_err, NULL} };
@@ -850,6 +854,17 @@ static int getoptions(char *c, struct trusted_key_payload *pay,return -EINVAL ; opt->policyhandle = handle;break ; + +case Opt_policy: +if (pay->policies) +return -EINVAL ; +if (!tpm2) +return -EINVAL ; + res =tpm2_parse_policies (&pay->policies, args[0 ].from); +if (res) +return res; +break ; +default :return -EINVAL ; }
Signature · 1 line
2.16.4
James Bottomley
maintainerPATCH v5 6/6 security: keys: trusted: implement counter/timer policy
In reply to James BottomleyThis is actually a generic policy allowing a range of comparisons against any value set in the TPM Clock, which includes things like the reset count, a monotonic millisecond count and the restart count. The most useful comparison is against the millisecond count for expiring keys. However, you have to remember that currently Linux doesn't try to sync the epoch timer with the TPM, so the expiration is actually measured in how long the TPM itself has been powered on ... the TPM timer doesn't count while the system is powered down. The millisecond counter is a u64 quantity found at offset 8 in the timer structure, and the <= comparision operand is 9, so a policy set to expire after the TPM has been up for 100 seconds would look like
0000016d00000000000f424000080009
Where 0x16d is the counter timer policy code and 0xf4240 is 100 000 in hex.
--- Documentation/security/keys/trusted-encrypted.rst | 29 ++++++++++++++++ include/linux/tpm.h | 1 + security/keys/trusted-keys/tpm2-policy.c | 40 ++++++++++++++++++++++- security/keys/trusted-keys/trusted_tpm2.c | 36 +++++++++++++++++++- 4 files changed, 104 insertions(+), 2 deletions(-)
Documentation/security/keys/trusted-encrypted.rst +29 -0
@@ -241,3 +241,32 @@ about the usage can be found in the file Another new format 'enc32' has been defined in order to support encrypted keys with payload size of 32 bytes. This will initially be used for nvdimm security but may expand to other usages that require 32 bytes payload. + +Appendix +-------- + +TPM 2.0 Policies +---------------- + +The current TPM supports PCR lock policies as documented above and +CounterTimer policies which can be used to create expiring keys. One +caveat with expiring keys is that the TPM millisecond counter does not +update while a system is powered off and Linux does not sync the TPM +millisecond count with its internal clock, so the best you can expire +in is in terms of how long any given TPM has been powered on. (FIXME: +Linux should simply update the millisecond clock to the current number +of seconds past the epoch on boot). + +A CounterTimer policy is expressed in terms of length and offset +against the TPM clock structure (TPMS_TIME_INFO), which looks like the +packed structure:: + + struct tpms_time_info { + u64 uptime; /* time in ms since last start or reset */ + u64 clock; /* cumulative uptime in ms */ + u32 resetcount; /* numer of times the TPM has been reset */ + u32 restartcount; /* number of times the TPM has been restarted */ + u8 safe /* time was safely loaded from NVRam */ + }; + +The usual comparison for expiring keys is against clock, at offset 8.
include/linux/tpm.h +1 -0
@@ -233,6 +233,7 @@ enum tpm2_command_codes {TPM2_CC_PCR_EXTEND =0x0182 ,TPM2_CC_EVENT_SEQUENCE_COMPLETE =0x0185 ,TPM2_CC_HASH_SEQUENCE_START =0x0186 , +TPM2_CC_POLICY_PASSWORD =0x018c ,TPM2_CC_CREATE_LOADED =0x0191 , TPM2_CC_LAST = 0x0193, /* Spec 1.36 */ };
security/keys/trusted-keys/tpm2-policy.c +39 -1
@@ -197,7 +197,8 @@ int tpm2_generate_policy_digest(struct tpm2_policies *pols, len = *plen; } -crypto_shash_update (sdesc, policy, len); +if (len) +crypto_shash_update (sdesc, policy, len);/* now output the intermediate to the policydigest */ crypto_shash_final (sdesc, policydigest);
@@ -332,6 +333,16 @@ int tpm2_get_policy_session(struct tpm_chip *chip, struct tpm2_policies *pols,u32 cmd = pols->code[i];struct tpm_buf buf; +if (cmd =TPM2_CC_POLICY_AUTHVALUE ) +/* +* both PolicyAuthValue and PolicyPassword +* hash to the same thing, but one triggers +* HMAC authentication and the other simple +* authentication. Since we have no HMAC +* code, we're choosing the simple +*/ + cmd =TPM2_CC_POLICY_PASSWORD ; + rc =tpm_buf_init (&buf,TPM2_ST_NO_SESSIONS , cmd);if (rc)return rc;
@@ -352,8 +363,35 @@ int tpm2_get_policy_session(struct tpm_chip *chip, struct tpm2_policies *pols,tpm_buf_append (&buf, pols->policies[i], pols->len[i] - pols->hash_size);break ; + +case TPM2_CC_POLICY_COUNTER_TIMER : { +/* +* the format of this is the last two u16 +* quantities are the offset and operation +* respectively. The rest is operandB which +* must be zero padded in a hash digest +*/ +u16 opb_len = pols->len[i] -4 ; + +if (opb_len > pols->hash_size) +return -EINVAL ; + +tpm_buf_append_u16 (&buf, opb_len); +tpm_buf_append (&buf, pols->policies[i], opb_len); + +/* offset and operand*/ +tpm_buf_append (&buf, pols->policies[i] + opb_len,4 ); + failure ="Counter Timer" ; + +break ; + } +default : failure ="unknown policy" ; +if (pols->len[i]) +tpm_buf_append (&buf, pols->policies[i], + pols->len[i]); +break ; }
security/keys/trusted-keys/trusted_tpm2.c +35 -1
@@ -248,6 +248,7 @@ int tpm2_seal_trusted(struct tpm_chip *chip,u32 flags;int i;int rc; +static const int POLICY_SIZE =2 *PAGE_SIZE ;for (i =0 ; i <ARRAY_SIZE (tpm2_hash_map); i++) {if (options->hash = tpm2_hash_map[i].crypto_id) {
@@ -268,7 +269,7 @@ int tpm2_seal_trusted(struct tpm_chip *chip,/* 4 array len, 2 hash alg */ const int len =4 +2 + options->pcrinfo_len; - pols =kmalloc (sizeof (*pols) + len,GFP_KERNEL ); + pols =kmalloc (POLICY_SIZE ,GFP_KERNEL );if (!pols)return -ENOMEM ;
@@ -289,6 +290,39 @@ int tpm2_seal_trusted(struct tpm_chip *chip,return -EINVAL ; } +/* +* if we already have a policy, we have to add authorization +* to it. If we don't, we can simply follow the usual +* non-policy route. +*/ +if (options->blobauth_len !=0 && payload->policies) { +struct tpm2_policies *pols; +static u8 *scratch; +int i; +bool found = false; + + pols = payload->policies; + +/* make sure it's not already in policy */ +for (i =0 ; i < pols->count; i++) { +if (pols->code[i] =TPM2_CC_POLICY_AUTHVALUE ) { + found = true; + +break ; + } + } + +if (!found) { + i = pols->count++; + scratch = pols->policies[i -1 ] + pols->len[i -1 ]; + +/* the TPM2_PolicyPassword command has no payload */ + pols->policies[i] = scratch; + pols->len[i] =0 ; + pols->code[i] =TPM2_CC_POLICY_AUTHVALUE ; + } + } +if (payload->policies) { rc = tpm2_generate_policy_digest(payload->policies, options->hash,
Signature · 1 line
2.16.4
Quoted 46 lines · James Bottomley
This is mainly a respin to add more spacing as Jarkko requested. However, I also added the seal/unseal operations to the
openssl_tpm2_engine(next branch):https://git.kernel.org/pub/scm/linux/kernel/git/jejb/openssl_tpm2_engine.git/
With the result that the kernel code completely failed the interoperability checks because the ASN.1 format requires the TPM2B length prepended to the public and private blobs. I corrected this in patch 4 and now all the interoperability tests are passing.
General cover letter:
This patch updates the trusted key code to export keys in the ASN.1 format used by current TPM key tools (
openssl_tpm2_engineand openconnect). It also simplifies the use of policy with keys because the ASN.1 format is designed to carry a description of how to construct the policy, with the result that simple policies (like authorization and PCR locking) can now be constructed and used in the kernel, bringing the TPM 2.0 policy use into line with how TPM 1.2 works.James
---
James Bottomley (6):
lib: add ASN.1 encoder
oid_registry: Add TCG defined OIDS for TPM keys
security: keys: trusted fix tpm2 authorizations
security: keys: trusted: use ASN.1 TPM2 key format for the blobs
security: keys: trusted: add ability to specify arbitrary policy
security: keys: trusted: implement counter/timer policyDocumentation/security/keys/trusted-encrypted.rst | 64 ++- include/keys/trusted-type.h | 7 +- include/linux/asn1_encoder.h | 32 ++ include/linux/oid_registry.h | 5 + include/linux/tpm.h | 8 + lib/Makefile | 2 +- lib/asn1_encoder.c | 431 ++++++++++++++++++++ security/keys/Kconfig | 2 + security/keys/trusted-keys/Makefile | 2 +- security/keys/trusted-keys/tpm2-policy.c | 463 ++++++++++++++++++++++ security/keys/trusted-keys/tpm2-policy.h | 31 ++ security/keys/trusted-keys/tpm2key.asn1 | 23 ++
Quoted 11 lines
security/keys/trusted-keys/trusted_tpm1.c | 50 ++- security/keys/trusted-keys/trusted_tpm2.c | 370 +++++++++++++++-- 14 files changed, 1454 insertions(+), 36 deletions(-) create mode 100644 include/linux/asn1_encoder.h create mode 100644 lib/asn1_encoder.c create mode 100644 security/keys/trusted-keys/tpm2-policy.c create mode 100644 security/keys/trusted-keys/tpm2-policy.h create mode 100644 security/keys/trusted-keys/tpm2key.asn1Signature · 1 line
2.16.4
Somehow managed to drown this to my emails. Looking into next week.
/Jarkko