tpm: only export stand alone version of flush context command
Subsystems (4)
James Bottomley
maintainerPATCH 1/1 tpm: only export stand alone version of flush context command
Remove the currently exported version of flush context, which is designed for tpm core internal use only and substitute a corrected version that does the necessary tpm ops get/put. This fixes a bug with trusted keys in that some TIS TPMs are unable to flush the loaded secret because the status register isn't reading correctly.
--- drivers/char/tpm/tpm.h | 1 + drivers/char/tpm/tpm2-cmd.c | 23 ++++++++++++++++++++++- include/linux/tpm.h | 2 +- security/keys/trusted-keys/trusted_tpm2.c | 2 +- 4 files changed, 25 insertions(+), 3 deletions(-)
drivers/char/tpm/tpm.h +1 -0
@@ -240,6 +240,7 @@ int tpm2_prepare_space(struct tpm_chip *chip, struct tpm_space *space, u8 *cmd, size_t cmdsiz);int tpm2_commit_space (struct tpm_chip *chip,struct tpm_space *space,void *buf,size_t *bufsiz); +void tpm2_flush_context (struct tpm_chip *chip,u32 handle);void tpm_bios_log_setup (struct tpm_chip *chip);void tpm_bios_log_teardown (struct tpm_chip *chip);
drivers/char/tpm/tpm2-cmd.c +22 -1
@@ -362,7 +362,28 @@ void tpm2_flush_context(struct tpm_chip *chip, u32 handle)tpm_transmit_cmd (chip, &buf,0 ,"flushing context" );tpm_buf_destroy (&buf); } -EXPORT_SYMBOL_GPL (tpm2_flush_context); + +/** +* tpm2_flush_context_cmd() - execute a TPM2_FlushContext command +* @chip: TPM chip to use +* @handle: context handle +* +* This version of the command is designed to be used outside the +* TPM core so acquires and releases the tpm ops. +*/ +void tpm2_flush_context_cmd (struct tpm_chip *chip,u32 handle) +{ +int rc; + + rc =tpm_try_get_ops (chip); +if (rc) { +dev_err (&chip->dev,"Failed to acquire tpm ops for flush\n" ); +return ; + } +tpm2_flush_context (chip, handle); +tpm_put_ops (chip); +} +EXPORT_SYMBOL_GPL (tpm2_flush_context_cmd);struct tpm2_get_cap_out {u8 more_data;
include/linux/tpm.h +1 -1
@@ -411,7 +411,7 @@ extern int tpm_pcr_extend(struct tpm_chip *chip, u32 pcr_idx,extern int tpm_send (struct tpm_chip *chip,void *cmd,size_t buflen);extern int tpm_get_random (struct tpm_chip *chip,u8 *data,size_t max);extern struct tpm_chip *tpm_default_chip (void ); -void tpm2_flush_context (struct tpm_chip *chip,u32 handle); +void tpm2_flush_context_cmd (struct tpm_chip *chip,u32 handle);#else static inline int tpm_is_tpm2 (struct tpm_chip *chip) {
security/keys/trusted-keys/trusted_tpm2.c +1 -1
@@ -309,7 +309,7 @@ int tpm2_unseal_trusted(struct tpm_chip *chip,return rc; rc =tpm2_unseal_cmd (chip, payload, options, blob_handle); -tpm2_flush_context (chip, blob_handle); +tpm2_flush_context_cmd (chip, blob_handle);return rc; }
Signature · 1 line
2.26.2
Quoted 48 lines · James Bottomley
Remove the currently exported version of flush context, which is designed for tpm core internal use only and substitute a corrected version that does the necessary tpm ops get/put. This fixes a bug with trusted keys in that some TIS TPMs are unable to flush the loaded secret because the status register isn't reading correctly.
Fixes 45477b3fe3d1 ("security: keys: trusted: fix lost handle flush")Signed-off-by James Bottomley <[email protected]>--- drivers/char/tpm/tpm.h | 1 + drivers/char/tpm/tpm2-cmd.c | 23 ++++++++++++++++++++++- include/linux/tpm.h | 2 +- security/keys/trusted-keys/trusted_tpm2.c | 2 +- 4 files changed, 25 insertions(+), 3 deletions(-)drivers/char/tpm/tpm.h +1
-0@@ -240,6 +240,7 @@ int tpm2_prepare_space(struct tpm_chip *chip, struct tpm_space *space, u8 *cmd, size_t cmdsiz);int tpm2_commit_space (struct tpm_chip *chip,struct tpm_space *space,void *buf,size_t *bufsiz); +void tpm2_flush_context (struct tpm_chip *chip,u32 handle);void tpm_bios_log_setup (struct tpm_chip *chip);void tpm_bios_log_teardown (struct tpm_chip *chip);drivers/char/tpm/tpm2-cmd.c +12
-1@@ -362,7 +362,28 @@ void tpm2_flush_context(struct tpm_chip *chip, u32 handle)tpm_transmit_cmd (chip, &buf,0 ,"flushing context" );tpm_buf_destroy (&buf); } -EXPORT_SYMBOL_GPL (tpm2_flush_context); + +/** +* tpm2_flush_context_cmd() - execute a TPM2_FlushContext command +* @chip: TPM chip to use +* @handle: context handle +* +* This version of the command is designed to be used outside the +* TPM core so acquires and releases the tpm ops. +*/ +void tpm2_flush_context_cmd (struct tpm_chip *chip,u32 handle) +{ +int rc;
drivers/char/tpm/tpm2-cmd.c void tpm2_flush_context(struct tpm_chip *chip, u32 handle) · line 386
Quoted 10 lines
drivers/char/tpm/tpm2-cmd.c +10
-0+ + rc =tpm_try_get_ops (chip); +if (rc) { +dev_err (&chip->dev,"Failed to acquire tpm ops for flush\n" ); +return ; + } +tpm2_flush_context (chip, handle); +tpm_put_ops (chip); +} +EXPORT_SYMBOL_GPL (tpm2_flush_context_cmd);
Otherwise fine but please rename the existing function as __tpm2_flush_context() and exported as tpm2_flush_context().
Quoted 20 lines
drivers/char/tpm/tpm2-cmd.c +0
-0struct tpm2_get_cap_out {u8 more_data;include/linux/tpm.h +1
-1@@ -411,7 +411,7 @@ extern int tpm_pcr_extend(struct tpm_chip *chip, u32 pcr_idx,extern int tpm_send (struct tpm_chip *chip,void *cmd,size_t buflen);extern int tpm_get_random (struct tpm_chip *chip,u8 *data,size_t max);extern struct tpm_chip *tpm_default_chip (void ); -void tpm2_flush_context (struct tpm_chip *chip,u32 handle); +void tpm2_flush_context_cmd (struct tpm_chip *chip,u32 handle);#else static inline int tpm_is_tpm2 (struct tpm_chip *chip) {security/keys/trusted-keys/trusted_tpm2.c +0
-0
security/keys/trusted-keys/trusted_tpm2.c int tpm2_unseal_trusted(struct tpm_chip *chip, · line 314
Quoted 7 lines
security/keys/trusted-keys/trusted_tpm2.c +1
-1@@ -309,7 +309,7 @@ int tpm2_unseal_trusted(struct tpm_chip *chip,return rc; rc =tpm2_unseal_cmd (chip, payload, options, blob_handle); -tpm2_flush_context (chip, blob_handle); +tpm2_flush_context_cmd (chip, blob_handle);return rc;
It will also elimintate this change.
Thank you.
/Jarkko
James Bottomley
maintainerQuoted 62 lines · Jarkko Sakkinen
Quoted 61 lines · James Bottomley
Remove the currently exported version of flush context, which is designed for tpm core internal use only and substitute a corrected version that does the necessary tpm ops get/put. This fixes a bug with trusted keys in that some TIS TPMs are unable to flush the loaded secret because the status register isn't reading correctly.
Fixes 45477b3fe3d1 ("security: keys: trusted: fix lost handleflush")
Signed-off-by: James Bottomley <
[email protected]>--- drivers/char/tpm/tpm.h | 1 + drivers/char/tpm/tpm2-cmd.c | 23 ++++++++++++++++++++++- include/linux/tpm.h | 2 +- security/keys/trusted-keys/trusted_tpm2.c | 2 +- 4 files changed, 25 insertions(+), 3 deletions(-)drivers/char/tpm/tpm.h +1
-0@@ -240,6 +240,7 @@ int tpm2_prepare_space(struct tpm_chip *chip, struct tpm_space *space, u8 *cmd, size_t cmdsiz);int tpm2_commit_space (struct tpm_chip *chip,struct tpm_space *space,void *buf,size_t *bufsiz); +void tpm2_flush_context (struct tpm_chip *chip,u32 handle);void
tpm_bios_log_setup(struct tpm_chip *chip); voidtpm_bios_log_teardown(struct tpm_chip *chip);drivers/char/tpm/tpm2- renamed from drivers/char/tpm/tpm2-cmd.c +0
-0
cmd.c
index9b84158c5a9e..d5aaea72d578100644drivers/char/tpm/tpm2-cmd.c +17
-1@@ -362,7 +362,28 @@ void tpm2_flush_context(struct tpm_chip *chip, u32 handle) tpm_transmit_cmd(chip, &buf, 0, "flushing context"); tpm_buf_destroy(&buf); } -EXPORT_SYMBOL_GPL(tpm2_flush_context); + +/** +* tpm2_flush_context_cmd() - execute a TPM2_FlushContext command +* @chip: TPM chip to use +* @handle: context handle +* +* This version of the command is designed to be used outside the +* TPM core so acquires and releases the tpm ops. +*/ +void tpm2_flush_context_cmd (struct tpm_chip *chip,u32 handle) +{ +int rc; + + rc =tpm_try_get_ops (chip); +if (rc) { +dev_err (&chip->dev,"Failed to acquire tpm ops for flush\n"); +return ;
Quoted 8 lines
drivers/char/tpm/tpm2-cmd.c void tpm2_flush_context(struct tpm_chip *chip, u32 handle) · line 386
Quoted 5 lines
drivers/char/tpm/tpm2-cmd.c +5
-0+ } +tpm2_flush_context (chip, handle); +tpm_put_ops (chip); +} +EXPORT_SYMBOL_GPL (tpm2_flush_context_cmd);Otherwise fine but please rename the existing function as
__tpm2_flush_context()and exported astpm2_flush_context().
If I do this it churns the code base more: we have one external consumer and four internal ones, so now each of the internal ones would have to become __tpm_flush_context(). We also have precedence for the xxx_cmd form with tpm2_unseal_cmd, tpm2_load_cmd.
Quoted 26 lines
Quoted 26 lines
drivers/char/tpm/tpm2-cmd.c +0
-0struct tpm2_get_cap_out {drivers/char/tpm/tpm2-cmd.c +0
-0u8 more_data;include/linux/tpm.h +1
-1@@ -411,7 +411,7 @@ extern int tpm_pcr_extend(struct tpm_chip *chip, u32 pcr_idx, extern int tpm_send(struct tpm_chip *chip, void *cmd, size_t buflen);extern int tpm_get_random (struct tpm_chip *chip,u8 *data,size_t max);extern struct tpm_chip *tpm_default_chip (void ); -void tpm2_flush_context (struct tpm_chip *chip,u32 handle); +void tpm2_flush_context_cmd (struct tpm_chip *chip,u32 handle);#else
static inline inttpm_is_tpm2(struct tpm_chip *chip){security/keys/trusted-keys/trusted_tpm2.c +0
-0@@ -309,7 +309,7 @@ int tpm2_unseal_trusted(struct tpm_chip *chip,return rc;
Quoted 7 lines
security/keys/trusted-keys/trusted_tpm2.c int tpm2_unseal_trusted(struct tpm_chip *chip, · line 314
Quoted 5 lines
security/keys/trusted-keys/trusted_tpm2.c +1
-1rc =tpm2_unseal_cmd (chip, payload, options, blob_handle); -tpm2_flush_context (chip, blob_handle); +tpm2_flush_context_cmd (chip, blob_handle);return rc;It will also elimintate this change.
Well, yes, but it will add four other changes.
James
Quoted 72 lines · James Bottomley
Quoted 62 lines · Jarkko Sakkinen
Quoted 61 lines · James Bottomley
Remove the currently exported version of flush context, which is designed for tpm core internal use only and substitute a corrected version that does the necessary tpm ops get/put. This fixes a bug with trusted keys in that some TIS TPMs are unable to flush the loaded secret because the status register isn't reading correctly.
Fixes 45477b3fe3d1 ("security: keys: trusted: fix lost handleflush")
Signed-off-by: James Bottomley <
[email protected]>--- drivers/char/tpm/tpm.h | 1 + drivers/char/tpm/tpm2-cmd.c | 23 ++++++++++++++++++++++- include/linux/tpm.h | 2 +- security/keys/trusted-keys/trusted_tpm2.c | 2 +- 4 files changed, 25 insertions(+), 3 deletions(-)drivers/char/tpm/tpm.h +1
-0@@ -240,6 +240,7 @@ int tpm2_prepare_space(struct tpm_chip *chip, struct tpm_space *space, u8 *cmd, size_t cmdsiz);int tpm2_commit_space (struct tpm_chip *chip,struct tpm_space *space,void *buf,size_t *bufsiz); +void tpm2_flush_context (struct tpm_chip *chip,u32 handle);void
tpm_bios_log_setup(struct tpm_chip *chip); voidtpm_bios_log_teardown(struct tpm_chip *chip);drivers/char/tpm/tpm2- renamed from drivers/char/tpm/tpm2-cmd.c +0
-0
cmd.c
index9b84158c5a9e..d5aaea72d578100644drivers/char/tpm/tpm2-cmd.c +17
-1@@ -362,7 +362,28 @@ void tpm2_flush_context(struct tpm_chip *chip, u32 handle) tpm_transmit_cmd(chip, &buf, 0, "flushing context"); tpm_buf_destroy(&buf); } -EXPORT_SYMBOL_GPL(tpm2_flush_context); + +/** +* tpm2_flush_context_cmd() - execute a TPM2_FlushContext command +* @chip: TPM chip to use +* @handle: context handle +* +* This version of the command is designed to be used outside the +* TPM core so acquires and releases the tpm ops. +*/ +void tpm2_flush_context_cmd (struct tpm_chip *chip,u32 handle) +{ +int rc; + + rc =tpm_try_get_ops (chip); +if (rc) { +dev_err (&chip->dev,"Failed to acquire tpm ops for flush\n"); +return ;Quoted 8 lines
drivers/char/tpm/tpm2-cmd.c void tpm2_flush_context(struct tpm_chip *chip, u32 handle) · line 386
Quoted 5 lines
drivers/char/tpm/tpm2-cmd.c +5
-0+ } +tpm2_flush_context (chip, handle); +tpm_put_ops (chip); +} +EXPORT_SYMBOL_GPL (tpm2_flush_context_cmd);Otherwise fine but please rename the existing function as
__tpm2_flush_context()and exported astpm2_flush_context().
Quoted 4 lines
If I do this it churns the code base more: we have one external consumer and four internal ones, so now each of the internal ones would have to become
__tpm_flush_context(). We also have precedence for thexxx_cmdform withtpm2_unseal_cmd,tpm2_load_cmd.
There are no internals version of aforementioned functions, but in the sense of common convention for such that encapsulate a single TPM command and nothing more or less, your argument make sense.
But it is somewhat common pattern to prefix internal/unlocked version with two underscores. So summarizing this I think that the best names would be __tpm2_flush_context_cmd() and tpm2_flush_context_cmd().
But now that I looked at your patch, I remembered the reason why the function in question does not take ops, albeit I'm not fully in the page why this was not properly implemented in trusted_tpm2.c.
The principal idea was that the client, e.g. trusted keys would take the ops and execute series of commands and then return ops. Otherwise, there is a probel in atomicity, i.e. someone could race between unseal and flush.
int tpm2_unseal_trusted(struct tpm_chip *chip,
struct trusted_key_payload *payload, struct trusted_key_options *options)
{
u32 blob_handle;
int rc;
rc = tpm_try_get_ops(chip);
if (rc)
goto out;
rc = tpm2_load_cmd(chip, payload, options, &blob_handle);
if (rc)
goto out;
rc = tpm2_unseal_cmd(chip, payload, options, blob_handle);
tpm2_flush_context(chip, blob_handle);out:
tpm_put_ops(chip); return rc; }
In addition to this fix, I think we should put a note to kdoc of each exported function that please grab the ops before using.
/Jarkko
Quoted 113 lines · Jarkko Sakkinen
Quoted 72 lines · James Bottomley
Quoted 62 lines · Jarkko Sakkinen
Quoted 61 lines · James Bottomley
Remove the currently exported version of flush context, which is designed for tpm core internal use only and substitute a corrected version that does the necessary tpm ops get/put. This fixes a bug with trusted keys in that some TIS TPMs are unable to flush the loaded secret because the status register isn't reading correctly.
Fixes 45477b3fe3d1 ("security: keys: trusted: fix lost handleflush")
Signed-off-by: James Bottomley <
[email protected]>--- drivers/char/tpm/tpm.h | 1 + drivers/char/tpm/tpm2-cmd.c | 23 ++++++++++++++++++++++- include/linux/tpm.h | 2 +- security/keys/trusted-keys/trusted_tpm2.c | 2 +- 4 files changed, 25 insertions(+), 3 deletions(-)drivers/char/tpm/tpm.h +1
-0@@ -240,6 +240,7 @@ int tpm2_prepare_space(struct tpm_chip *chip, struct tpm_space *space, u8 *cmd, size_t cmdsiz);int tpm2_commit_space (struct tpm_chip *chip,struct tpm_space *space,void *buf,size_t *bufsiz); +void tpm2_flush_context (struct tpm_chip *chip,u32 handle);void
tpm_bios_log_setup(struct tpm_chip *chip); voidtpm_bios_log_teardown(struct tpm_chip *chip);drivers/char/tpm/tpm2- renamed from drivers/char/tpm/tpm2-cmd.c +0
-0
cmd.c
index9b84158c5a9e..d5aaea72d578100644drivers/char/tpm/tpm2-cmd.c +17
-1@@ -362,7 +362,28 @@ void tpm2_flush_context(struct tpm_chip *chip, u32 handle) tpm_transmit_cmd(chip, &buf, 0, "flushing context"); tpm_buf_destroy(&buf); } -EXPORT_SYMBOL_GPL(tpm2_flush_context); + +/** +* tpm2_flush_context_cmd() - execute a TPM2_FlushContext command +* @chip: TPM chip to use +* @handle: context handle +* +* This version of the command is designed to be used outside the +* TPM core so acquires and releases the tpm ops. +*/ +void tpm2_flush_context_cmd (struct tpm_chip *chip,u32 handle) +{ +int rc; + + rc =tpm_try_get_ops (chip); +if (rc) { +dev_err (&chip->dev,"Failed to acquire tpm ops for flush\n"); +return ;Quoted 8 lines
drivers/char/tpm/tpm2-cmd.c void tpm2_flush_context(struct tpm_chip *chip, u32 handle) · line 386
Quoted 5 lines
drivers/char/tpm/tpm2-cmd.c +5
-0+ } +tpm2_flush_context (chip, handle); +tpm_put_ops (chip); +} +EXPORT_SYMBOL_GPL (tpm2_flush_context_cmd);Otherwise fine but please rename the existing function as
__tpm2_flush_context()and exported astpm2_flush_context().Quoted 4 lines
If I do this it churns the code base more: we have one external consumer and four internal ones, so now each of the internal ones would have to become
__tpm_flush_context(). We also have precedence for thexxx_cmdform withtpm2_unseal_cmd,tpm2_load_cmd.There are no internals version of aforementioned functions, but in the sense of common convention for such that encapsulate a single TPM command and nothing more or less, your argument make sense.
But it is somewhat common pattern to prefix internal/unlocked version with two underscores. So summarizing this I think that the best names would be
__tpm2_flush_context_cmd()andtpm2_flush_context_cmd().But now that I looked at your patch, I remembered the reason why the function in question does not take ops, albeit I'm not fully in the page why this was not properly implemented in
trusted_tpm2.c.The principal idea was that the client, e.g. trusted keys would take the ops and execute series of commands and then return ops. Otherwise, there is a probel in atomicity, i.e. someone could race between unseal and flush.
int tpm2_unseal_trusted(struct
tpm_chip*chip,
structtrusted_key_payload*payload, structtrusted_key_options*options){ u32 blob_handle; int rc; rc = tpm_try_get_ops(chip); if (rc) goto out; rc = tpm2_load_cmd(chip, payload, options, &blob_handle); if (rc) goto out; rc = tpm2_unseal_cmd(chip, payload, options, blob_handle); tpm2_flush_context(chip, blob_handle);
Quoted 7 lines
out:
tpm_put_ops(chip); return rc; }In addition to this fix, I think we should put a note to kdoc of each exported function that please grab the ops before using.
I'll find the correct fixes tag. Your commit that is in the fixes tag did not causue this regression.
/Jarkko
Quoted 119 lines · Jarkko Sakkinen
Quoted 118 lines · Jarkko Sakkinen
Quoted 72 lines · James Bottomley
Quoted 62 lines · Jarkko Sakkinen
Quoted 61 lines · James Bottomley
Remove the currently exported version of flush context, which is designed for tpm core internal use only and substitute a corrected version that does the necessary tpm ops get/put. This fixes a bug with trusted keys in that some TIS TPMs are unable to flush the loaded secret because the status register isn't reading correctly.
Fixes 45477b3fe3d1 ("security: keys: trusted: fix lost handleflush")
Signed-off-by: James Bottomley <
[email protected]>--- drivers/char/tpm/tpm.h | 1 + drivers/char/tpm/tpm2-cmd.c | 23 ++++++++++++++++++++++- include/linux/tpm.h | 2 +- security/keys/trusted-keys/trusted_tpm2.c | 2 +- 4 files changed, 25 insertions(+), 3 deletions(-)drivers/char/tpm/tpm.h +1
-0@@ -240,6 +240,7 @@ int tpm2_prepare_space(struct tpm_chip *chip, struct tpm_space *space, u8 *cmd, size_t cmdsiz);int tpm2_commit_space (struct tpm_chip *chip,struct tpm_space *space,void *buf,size_t *bufsiz); +void tpm2_flush_context (struct tpm_chip *chip,u32 handle);void
tpm_bios_log_setup(struct tpm_chip *chip); voidtpm_bios_log_teardown(struct tpm_chip *chip);drivers/char/tpm/tpm2- renamed from drivers/char/tpm/tpm2-cmd.c +0
-0
cmd.c
index9b84158c5a9e..d5aaea72d578100644drivers/char/tpm/tpm2-cmd.c +17
-1@@ -362,7 +362,28 @@ void tpm2_flush_context(struct tpm_chip *chip, u32 handle) tpm_transmit_cmd(chip, &buf, 0, "flushing context"); tpm_buf_destroy(&buf); } -EXPORT_SYMBOL_GPL(tpm2_flush_context); + +/** +* tpm2_flush_context_cmd() - execute a TPM2_FlushContext command +* @chip: TPM chip to use +* @handle: context handle +* +* This version of the command is designed to be used outside the +* TPM core so acquires and releases the tpm ops. +*/ +void tpm2_flush_context_cmd (struct tpm_chip *chip,u32 handle) +{ +int rc; + + rc =tpm_try_get_ops (chip); +if (rc) { +dev_err (&chip->dev,"Failed to acquire tpm ops for flush\n"); +return ;Quoted 8 lines
drivers/char/tpm/tpm2-cmd.c void tpm2_flush_context(struct tpm_chip *chip, u32 handle) · line 386
Quoted 5 lines
drivers/char/tpm/tpm2-cmd.c +5
-0+ } +tpm2_flush_context (chip, handle); +tpm_put_ops (chip); +} +EXPORT_SYMBOL_GPL (tpm2_flush_context_cmd);Otherwise fine but please rename the existing function as
__tpm2_flush_context()and exported astpm2_flush_context().Quoted 4 lines
If I do this it churns the code base more: we have one external consumer and four internal ones, so now each of the internal ones would have to become
__tpm_flush_context(). We also have precedence for thexxx_cmdform withtpm2_unseal_cmd,tpm2_load_cmd.There are no internals version of aforementioned functions, but in the sense of common convention for such that encapsulate a single TPM command and nothing more or less, your argument make sense.
But it is somewhat common pattern to prefix internal/unlocked version with two underscores. So summarizing this I think that the best names would be
__tpm2_flush_context_cmd()andtpm2_flush_context_cmd().But now that I looked at your patch, I remembered the reason why the function in question does not take ops, albeit I'm not fully in the page why this was not properly implemented in
trusted_tpm2.c.The principal idea was that the client, e.g. trusted keys would take the ops and execute series of commands and then return ops. Otherwise, there is a probel in atomicity, i.e. someone could race between unseal and flush.
int tpm2_unseal_trusted(struct
tpm_chip*chip,
structtrusted_key_payload*payload, structtrusted_key_options*options){ u32 blob_handle; int rc; rc = tpm_try_get_ops(chip); if (rc) goto out; rc = tpm2_load_cmd(chip, payload, options, &blob_handle); if (rc) goto out; rc = tpm2_unseal_cmd(chip, payload, options, blob_handle); tpm2_flush_context(chip, blob_handle);out:
tpm_put_ops(chip); return rc; }
Quoted 5 lines
Quoted 2 lines
In addition to this fix, I think we should put a note to kdoc of each exported function that please grab the ops before using.
I'll find the correct fixes tag. Your commit that is in the fixes tag did not causue this regression.
I'll provide a fix for this. The regression popped up in:
2e19e10131a0 ("KEYS: trusted: Move TPM2 trusted keys code")
While I started to fix this, I also found a regression originating from:
41ab999c80f1 ("tpm: Move tpm_get_random api into the TPM device driver")
I.e. the return value of tpm_get_random() is not handled correctly. That has been there for a while...
/Jarkko
James Bottomley
maintainerQuoted 3 lines · Jarkko Sakkinen
Quoted 2 lines · James Bottomley
Quoted 1 line · Jarkko Sakkinen
On Sun, Sep 27, 2020 at 04:17:40PM -0700, James Bottomley wrote:
[...]
Quoted 11 lines
Quoted 10 lines
Quoted 4 lines
Quoted 1 line
+EXPORT_SYMBOL_GPL(tpm2_flush_context_cmd);
Otherwise fine but please rename the existing function as
__tpm2_flush_context()and exported astpm2_flush_context().If I do this it churns the code base more: we have one external consumer and four internal ones, so now each of the internal ones would have to become
__tpm_flush_context(). We also have precedence for thexxx_cmdform withtpm2_unseal_cmd,tpm2_load_cmd.
Quoted 3 lines
There are no internals version of aforementioned functions, but in the sense of common convention for such that encapsulate a single TPM command and nothing more or less, your argument make sense.
By internal, I mean use within the tpm core that doesn't require get/put ops ... there are four of them.
Quoted 31 lines
But it is somewhat common pattern to prefix internal/unlocked version with two underscores. So summarizing this I think that the best names would be
__tpm2_flush_context_cmd()andtpm2_flush_context_cmd().But now that I looked at your patch, I remembered the reason why the function in question does not take ops, albeit I'm not fully in the page why this was not properly implemented in
trusted_tpm2.c.The principal idea was that the client, e.g. trusted keys would take the ops and execute series of commands and then return ops. Otherwise, there is a probel in atomicity, i.e. someone could race between unseal and flush.
int tpm2_unseal_trusted(struct
tpm_chip*chip,
structtrusted_key_payload*payload, structtrusted_key_options*options){ u32 blob_handle; int rc; rc = tpm_try_get_ops(chip); if (rc) goto out; rc = tpm2_load_cmd(chip, payload, options, &blob_handle); if (rc) goto out; rc = tpm2_unseal_cmd(chip, payload, options, blob_handle); tpm2_flush_context(chip, blob_handle);
Quoted 7 lines
out:
tpm_put_ops(chip); return rc; }In addition to this fix, I think we should put a note to kdoc of each exported function that please grab the ops before using.
Well, um, that's precisely what this function originally did when it was inside drivers/char/tpm. You told the guy who did the move into security/keys/trusted-keys to convert everything to use tpm_send which encapsulates the get/put operation, which is why we now have the flush bug. If you really want it done like this, then I'd recommend moving everything back to drivers/char/tpm so we don't have to do a global exposure of a load of tpm internal functions (i.e. move them from drivers/char/tmp.h to include/linux/tpm.h and do an export on them).
James
Quoted 62 lines · James Bottomley
Quoted 3 lines · Jarkko Sakkinen
Quoted 2 lines · James Bottomley
Quoted 1 line · Jarkko Sakkinen
On Sun, Sep 27, 2020 at 04:17:40PM -0700, James Bottomley wrote:
[...]
Quoted 11 lines
Quoted 10 lines
Quoted 4 lines
Quoted 1 line
+EXPORT_SYMBOL_GPL(tpm2_flush_context_cmd);
Otherwise fine but please rename the existing function as
__tpm2_flush_context()and exported astpm2_flush_context().If I do this it churns the code base more: we have one external consumer and four internal ones, so now each of the internal ones would have to become
__tpm_flush_context(). We also have precedence for thexxx_cmdform withtpm2_unseal_cmd,tpm2_load_cmd.Quoted 3 lines
There are no internals version of aforementioned functions, but in the sense of common convention for such that encapsulate a single TPM command and nothing more or less, your argument make sense.
By internal, I mean use within the tpm core that doesn't require get/put ops ... there are four of them.
Quoted 31 lines
But it is somewhat common pattern to prefix internal/unlocked version with two underscores. So summarizing this I think that the best names would be
__tpm2_flush_context_cmd()andtpm2_flush_context_cmd().But now that I looked at your patch, I remembered the reason why the function in question does not take ops, albeit I'm not fully in the page why this was not properly implemented in
trusted_tpm2.c.The principal idea was that the client, e.g. trusted keys would take the ops and execute series of commands and then return ops. Otherwise, there is a probel in atomicity, i.e. someone could race between unseal and flush.
int tpm2_unseal_trusted(struct
tpm_chip*chip,
structtrusted_key_payload*payload, structtrusted_key_options*options){ u32 blob_handle; int rc; rc = tpm_try_get_ops(chip); if (rc) goto out; rc = tpm2_load_cmd(chip, payload, options, &blob_handle); if (rc) goto out; rc = tpm2_unseal_cmd(chip, payload, options, blob_handle); tpm2_flush_context(chip, blob_handle);Quoted 7 lines
out:
tpm_put_ops(chip); return rc; }In addition to this fix, I think we should put a note to kdoc of each exported function that please grab the ops before using.
Quoted 8 lines
Well, um, that's precisely what this function originally did when it was inside
drivers/char/tpm. You told the guy who did the move intosecurity/keys/trusted-keysto convert everything to usetpm_sendwhich encapsulates the get/put operation, which is why we now have the flush bug. If you really want it done like this, then I'd recommend moving everything back todrivers/char/tpmso we don't have to do a global exposure of a load of tpm internal functions (i.e. move them fromdrivers/char/tmp.htoinclude/linux/tpm.hand do an export on them).
My BuildRoot test image did not include the patch. I was wondering why I did not bump into deadlock with the fix candidate :-/ Forgot export LINUX_OVERRIDE_SRCDIR.
But you are absolutely correct, thanks for recalling. I made a mistake there.
I do disagree though that this should be moved back to drivers/char/tpm, as also TPM 1.x code lives in trusted-keys. It is good to have API for doing sequences TPM commands and keep the core in drivers/char/tpm.
If you look at tpm_send() it is in essence just simply locking TPM and and calling tpm_transmit_cmd(). And tpm_transmit_cmd() is already an exported symbol. It only needs to be declared in include/linux/tpm.h.
I'd suggest that I refine my series to call tpm_transmit_cmd() and we have a fairly clean solution where the load sequence is atomic.
/Jarkko>
Quoted 20 lines · Jarkko Sakkinen
Quoted 8 lines
Well, um, that's precisely what this function originally did when it was inside
drivers/char/tpm. You told the guy who did the move intosecurity/keys/trusted-keysto convert everything to usetpm_sendwhich encapsulates the get/put operation, which is why we now have the flush bug. If you really want it done like this, then I'd recommend moving everything back todrivers/char/tpmso we don't have to do a global exposure of a load of tpm internal functions (i.e. move them fromdrivers/char/tmp.htoinclude/linux/tpm.hand do an export on them).My BuildRoot test image did not include the patch. I was wondering why I did not bump into deadlock with the fix candidate :-/ Forgot export
LINUX_OVERRIDE_SRCDIR.But you are absolutely correct, thanks for recalling. I made a mistake there.
I do disagree though that this should be moved back to
drivers/char/tpm, as also TPM 1.x code lives in trusted-keys. It is good to have API for doing sequences TPM commands and keep the core indrivers/char/tpm.
Quoted 6 lines
If you look at
tpm_send()it is in essence just simply locking TPM and and callingtpm_transmit_cmd(). Andtpm_transmit_cmd()is already an exported symbol. It only needs to be declared ininclude/linux/tpm.h.I'd suggest that I refine my series to call
tpm_transmit_cmd()and we have a fairly clean solution where the load sequence is atomic.
I see that it is perfectly fine to make tpm_transmit_cmd() globally callable. It is already used by tpm_vtpm_proxy and does have clear semantics.
The way you use it is just:
1. tpm_try_get_ops
2. Use tpm_transmit_cmd() N times.
3. tpm_put_ops
If we moved TPM 2.x trusted keys code back to drivers/char/tpm,for the sake of consistency the same would have to be done for TPM 1.2 code. I'd rather fix the regression and be done with it.
Or if reverted like that, also asym_tpm.c code should also live inside the TPM driver directory.
All this work with tpm_buf and the locking functions makes most sense if it gives ability for callers to build their own TPM commands
I'm right now building test image with v3 of my fixes (this time properly included to the kernel image). I also uploaded the (untested) patches over here:
https://git.kernel.org/pub/scm/linux/kernel/git/jarkko/linux-tpmdd.git/log/?h=trusted-fix
/Jarkko
James Bottomley
maintainerQuoted 15 lines · Jarkko Sakkinen
Quoted 14 lines · Jarkko Sakkinen
Quoted 9 lines
Well, um, that's precisely what this function originally did when it was inside
drivers/char/tpm. You told the guy who did the move intosecurity/keys/trusted-keysto convert everything to usetpm_sendwhich encapsulates the get/put operation, which is why we now have the flush bug. If you really want it done like this, then I'd recommend moving everything back todrivers/char/tpmso we don't have to do a global exposure of a load of tpm internal functions (i.e. move them fromdrivers/char/tmp.htoinclude/linux/tpm.hand do an export on them).My BuildRoot test image did not include the patch. I was wondering why I did not bump into deadlock with the fix candidate :-/ Forgot export
LINUX_OVERRIDE_SRCDIR.
Quoted 7 lines
Quoted 7 lines
But you are absolutely correct, thanks for recalling. I made a mistake there.
I do disagree though that this should be moved back to
drivers/char/tpm, as also TPM 1.x code lives in trusted-keys. It is good to have API for doing sequences TPM commands and keep the core indrivers/char/tpm.
I think tpm2_load_cmd is likely going to have to move back anyway just because more things than trusted keys need to use it. I can't really see any other use for the seal/unseal so they can stay in trusted keys until someone finds a use for them.
Quoted 25 lines
Quoted 7 lines
If you look at
tpm_send()it is in essence just simply locking TPM and and callingtpm_transmit_cmd(). Andtpm_transmit_cmd()is already an exported symbol. It only needs to be declared ininclude/linux/tpm.h.I'd suggest that I refine my series to call
tpm_transmit_cmd()and we have a fairly clean solution where the load sequence is atomic.I see that it is perfectly fine to make
tpm_transmit_cmd()globally callable. It is already used bytpm_vtpm_proxyand does have clear semantics.The way you use it is just:
1.
tpm_try_get_ops
2. Usetpm_transmit_cmd()N times.
3.tpm_put_opsIf we moved TPM 2.x trusted keys code back to
drivers/char/tpm,forthe sake of consistency the same would have to be done for TPM 1.2 code. I'd rather fix the regression and be done with it.Or if reverted like that, also
asym_tpm.ccode should also live inside the TPM driver directory.
Quoted 8 lines
All this work with
tpm_bufand the locking functions makes most sense if it gives ability for callers to build their own TPM commandsI'm right now building test image with v3 of my fixes (this time properly included to the kernel image). I also uploaded the (untested) patches over here:
https://git.kernel.org/pub/scm/linux/kernel/git/jarkko/linux-tpmdd.git/log/?h=trusted-fix
I think we can do that ... in which case the fix for the tis interrupt trigger also becomes a get/put ops around the tpm2_get_tpm_pt.
After the transformation is complete, tpm_send() becomes obsolete, doesn't it, so it can be removed?
James
Quoted 24 lines · James Bottomley
Quoted 15 lines · Jarkko Sakkinen
Quoted 14 lines · Jarkko Sakkinen
Quoted 9 lines
Well, um, that's precisely what this function originally did when it was inside
drivers/char/tpm. You told the guy who did the move intosecurity/keys/trusted-keysto convert everything to usetpm_sendwhich encapsulates the get/put operation, which is why we now have the flush bug. If you really want it done like this, then I'd recommend moving everything back todrivers/char/tpmso we don't have to do a global exposure of a load of tpm internal functions (i.e. move them fromdrivers/char/tmp.htoinclude/linux/tpm.hand do an export on them).My BuildRoot test image did not include the patch. I was wondering why I did not bump into deadlock with the fix candidate :-/ Forgot export
LINUX_OVERRIDE_SRCDIR.Quoted 7 lines
Quoted 7 lines
But you are absolutely correct, thanks for recalling. I made a mistake there.
I do disagree though that this should be moved back to
drivers/char/tpm, as also TPM 1.x code lives in trusted-keys. It is good to have API for doing sequences TPM commands and keep the core indrivers/char/tpm.
Quoted 4 lines
I think
tpm2_load_cmdis likely going to have to move back anyway just because more things than trusted keys need to use it. I can't really see any other use for the seal/unseal so they can stay in trusted keys until someone finds a use for them.
We can obviously do that if there are multiple customers for it.
Quoted 32 lines
Quoted 32 lines
Quoted 7 lines
If you look at
tpm_send()it is in essence just simply locking TPM and and callingtpm_transmit_cmd(). Andtpm_transmit_cmd()is already an exported symbol. It only needs to be declared ininclude/linux/tpm.h.I'd suggest that I refine my series to call
tpm_transmit_cmd()and we have a fairly clean solution where the load sequence is atomic.I see that it is perfectly fine to make
tpm_transmit_cmd()globally callable. It is already used bytpm_vtpm_proxyand does have clear semantics.The way you use it is just:
1.
tpm_try_get_ops
2. Usetpm_transmit_cmd()N times.
3.tpm_put_opsIf we moved TPM 2.x trusted keys code back to
drivers/char/tpm,forthe sake of consistency the same would have to be done for TPM 1.2 code. I'd rather fix the regression and be done with it.Or if reverted like that, also
asym_tpm.ccode should also live inside the TPM driver directory.All this work with
tpm_bufand the locking functions makes most sense if it gives ability for callers to build their own TPM commandsI'm right now building test image with v3 of my fixes (this time properly included to the kernel image). I also uploaded the (untested) patches over here:
Quoted 7 lines
Quoted 1 line
https://git.kernel.org/pub/scm/linux/kernel/git/jarkko/linux-tpmdd.git/log/?h=trusted-fix
I think we can do that ... in which case the fix for the tis interrupt trigger also becomes a get/put ops around the
tpm2_get_tpm_pt.After the transformation is complete,
tpm_send()becomes obsolete, doesn't it, so it can be removed?
Yes.
BTW, while doing this I think I noticed what was wrong in my test kernel when I tested your series that introduces ASN.1 keys. I'll test both before sending update to my fix. Hopefully I can give today tested-by tags to that series.
Quoted 1 line
James
/Jarkko
James Bottomley
maintainerQuoted 27 lines · Jarkko Sakkinen
Quoted 26 lines · James Bottomley
Quoted 24 lines · Jarkko Sakkinen
Quoted 23 lines · Jarkko Sakkinen
Quoted 10 lines
Well, um, that's precisely what this function originally did when it was inside
drivers/char/tpm. You told the guy who did the move intosecurity/keys/trusted-keysto convert everything to usetpm_sendwhich encapsulates the get/put operation, which is why we now have the flush bug. If you really want it done like this, then I'd recommend moving everything back todrivers/char/tpmso we don't have to do a global exposure of a load of tpm internal functions (i.e. move them fromdrivers/char/tmp.htoinclude/linux/tpm.hand do an export on them).My BuildRoot test image did not include the patch. I was wondering why I did not bump into deadlock with the fix candidate :-/
Forgot exportLINUX_OVERRIDE_SRCDIR.But you are absolutely correct, thanks for recalling. I made a mistake there.
I do disagree though that this should be moved back to
drivers/char/tpm, as also TPM 1.x code lives in trusted-keys. It is good to have API for doing sequences TPM commands and keep the core indrivers/char/tpm.
Quoted 6 lines
Quoted 4 lines
I think
tpm2_load_cmdis likely going to have to move back anyway just because more things than trusted keys need to use it. I can't really see any other use for the seal/unseal so they can stay in trusted keys until someone finds a use for them.We can obviously do that if there are multiple customers for it.
Yes, let's just leave everything where it is until there's a use case for moving it.
Quoted 44 lines
Quoted 35 lines
Quoted 35 lines
Quoted 8 lines
If you look at
tpm_send()it is in essence just simply locking TPM and and callingtpm_transmit_cmd(). Andtpm_transmit_cmd()is already an exported symbol. It only needs to be declared ininclude/linux/tpm.h.I'd suggest that I refine my series to call
tpm_transmit_cmd()and we have a fairly clean solution where the load sequence is atomic.I see that it is perfectly fine to make
tpm_transmit_cmd()globally callable. It is already used bytpm_vtpm_proxyand does have clear semantics.The way you use it is just:
1.
tpm_try_get_ops
2. Usetpm_transmit_cmd()N times.
3.tpm_put_opsIf we moved TPM 2.x trusted keys code back to
drivers/char/tpm,forthe sake of consistency the same would have to be done for TPM 1.2 code. I'd rather fix the regression and be done with it.Or if reverted like that, also
asym_tpm.ccode should also live inside the TPM driver directory.All this work with
tpm_bufand the locking functions makes most sense if it gives ability for callers to build their own TPM commandsI'm right now building test image with v3 of my fixes (this time properly included to the kernel image). I also uploaded the (untested) patches over here:
Quoted 8 lines
Quoted 1 line
https://git.kernel.org/pub/scm/linux/kernel/git/jarkko/linux-tpmdd.git/log/?h=trusted-fix
I think we can do that ... in which case the fix for the tis interrupt trigger also becomes a get/put ops around the
tpm2_get_tpm_pt.After the transformation is complete,
tpm_send()becomes obsolete, doesn't it, so it can be removed?
Quoted 6 lines
Yes.
BTW, while doing this I think I noticed what was wrong in my test kernel when I tested your series that introduces ASN.1 keys. I'll test both before sending update to my fix. Hopefully I can give today tested-by tags to that series.
Great ... the trusted key code doesn't use tpm_send, but the policy additions do so the latter will need updating (again).
James
Quoted 9 lines · James Bottomley
Quoted 6 lines
Yes.
BTW, while doing this I think I noticed what was wrong in my test kernel when I tested your series that introduces ASN.1 keys. I'll test both before sending update to my fix. Hopefully I can give today tested-by tags to that series.
Great ... the trusted key code doesn't use
tpm_send, but the policy additions do so the latter will need updating (again).
Yes, I know. I can still test both by separately applying them on top of the current master. If you can after that do the update (and after the fixes have been applied), I can still get everything to the same PR.
Sorry for latency because of some SGX discussions (this time retpoline and CET collision), I'll try to get the testing done ASAP.
/Jarkko