Storing SRK on the TPM with Trousers - tpm

Question

I am using Trousers to interact with TPM for a project. I have ran into an issue with the storage of SRK (Storage Root Key).
My understanding is that the SRK key pair is generated at the time of taking TPM ownership & is stored inside the TPM. But looks like some part of it is being stored in the system persistent storage (defined by system_ps_file config). And in case the system persistent storage gets deleted, it is not possible to load the SRK anymore.
Code to create the SRK
TSS_FLAG srk_flags = TSS_KEY_TSP_SRK|TSS_KEY_AUTHORIZATION;
int result = Tspi_Context_CreateObject(hContext, TSS_OBJECT_TYPE_RSAKEY, srk_flags, srk_handle);
Code to load the SRK
TSS_UUID srk_uuid = TSS_UUID_SRK;
int result = Tspi_Context_LoadKeyByUUID(hContext, TSS_PS_TYPE_SYSTEM, srk_uuid, srk_handle);
Above code works properly untill system persistent storage data file is present. But once it is deleted, I get:
ERROR: Tspi Context LoadKeyByUUID (SRK ) failed rc =0 x2020
Is there a way to recover the deleted storage file ? or to avoid using it for SRK ?

Answer 1

You are pretty much correct in your assessment of what's going on. The requirement to store the keys in persistent storage comes straight from the TSS spec:
All keys, which should be internally managed by the Key Management
Services of TSS must be registered in the persistent storage database
of TCS (System Persistent Storage) or TSP (User Persistent Storage).
Each key registered in one of these databases will be referenced by
its UUID and called a persistent key from this specification’s point
of view.
That being said, what's stored in place of the SRK is a zeroed-out "fake SRK", so theoretically you could run the same code to replace it:
BYTE *save;
/* Once the key file is created, it stays forever. There could be
* migratable keys in the hierarchy that are still useful to someone.
*/
result = ps_remove_key(&SRK_UUID);
if (result != TSS_SUCCESS && result != TCSERR(TSS_E_PS_KEY_NOTFOUND)) {
destroy_key_refs(&srkKeyContainer);
LogError("Error removing SRK from key file.");
*srkKeySize = 0;
free(*srkKey);
goto done;
}
/* Set the SRK pubkey to all 0's before writing the SRK to disk, this is for
* privacy reasons as outlined in the TSS spec */
save = srkKeyContainer.pubKey.key;
srkKeyContainer.pubKey.key = fake_pubkey;
offset = 0;
LoadBlob_TSS_KEY(&offset, fake_srk, &srkKeyContainer);
if ((result = ps_write_key(&SRK_UUID, &NULL_UUID, NULL, 0, fake_srk,
offset))) {
destroy_key_refs(&srkKeyContainer);
LogError("Error writing SRK to disk");
*srkKeySize = 0;
free(*srkKey);
goto done;
}
srkKeyContainer.pubKey.key = save;
But what you're supposed to do instead is back up your persistent storage. If you lose it you lose all the other keys (that are not the SRK) that you created.