/********************************************************************************/ /* */ /* LibTPM TPM 2 call interface functions */ /* Written by Stefan Berger */ /* IBM Thomas J. Watson Research Center */ /* */ /* (c) Copyright IBM Corporation 2015. */ /* */ /* All rights reserved. */ /* */ /* Redistribution and use in source and binary forms, with or without */ /* modification, are permitted provided that the following conditions are */ /* met: */ /* */ /* Redistributions of source code must retain the above copyright notice, */ /* this list of conditions and the following disclaimer. */ /* */ /* Redistributions in binary form must reproduce the above copyright */ /* notice, this list of conditions and the following disclaimer in the */ /* documentation and/or other materials provided with the distribution. */ /* */ /* Neither the names of the IBM Corporation nor the names of its */ /* contributors may be used to endorse or promote products derived from */ /* this software without specific prior written permission. */ /* */ /* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ /* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ /* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR */ /* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ /* HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ /* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT */ /* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, */ /* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY */ /* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT */ /* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE */ /* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /********************************************************************************/ #include #define _GNU_SOURCE #include #include #include #include #ifndef LIB_EXPORT #define LIB_EXPORT #endif #include "tpm2/Tpm.h" #include "tpm2/Manufacture_fp.h" #include "tpm2/Platform_fp.h" #include "tpm2/ExecCommand_fp.h" #include "tpm2/TpmTcpProtocol.h" #include "tpm2/Simulator_fp.h" #include "tpm2/_TPM_Hash_Data_fp.h" #include "tpm2/_TPM_Init_fp.h" #include "tpm2/StateMarshal.h" #include "tpm2/PlatformACT.h" #include "tpm2/PlatformData.h" #include "tpm2/Volatile.h" #include "tpm2/crypto/openssl/ExpDCache_fp.h" #define TPM_HAVE_TPM2_DECLARATIONS #include "tpm_nvfile.h" // TPM_NVRAM_Loaddata() #include "tpm_error.h" #include "tpm_library_intern.h" #include "tpm_nvfilename.h" extern BOOL g_inFailureMode; static BOOL reportedFailureCommand; /* * Check whether the main NVRAM file exists. Return TRUE if it doesn, FALSE otherwise */ static TPM_BOOL _TPM2_CheckNVRAMFileExists(bool *has_nvram_loaddata_callback) { #ifdef TPM_LIBTPMS_CALLBACKS struct libtpms_callbacks *cbs = TPMLIB_GetCallbacks(); const char *name = TPM_PERMANENT_ALL_NAME; unsigned char *data = NULL; uint32_t length = 0; uint32_t tpm_number = 0; TPM_RESULT ret; *has_nvram_loaddata_callback = cbs->tpm_nvram_loaddata != NULL; if (cbs->tpm_nvram_loaddata) { ret = cbs->tpm_nvram_loaddata(&data, &length, tpm_number, name); free(data); /* a file exists once NOT TPM_RETRY is returned */ if (ret != TPM_RETRY) return TRUE; } #else *has_nvram_loaddata_callback = FALSE; #endif /* TPM_LIBTPMS_CALLBACKS */ return FALSE; } static TPM_RESULT TPM2_MainInit(void) { TPM_RESULT ret = TPM_SUCCESS; bool has_cached_state; bool has_nvram_file; bool has_nvram_loaddata_callback; g_inFailureMode = FALSE; reportedFailureCommand = FALSE; #ifdef TPM_LIBTPMS_CALLBACKS struct libtpms_callbacks *cbs = TPMLIB_GetCallbacks(); if (cbs->tpm_io_init) { ret = cbs->tpm_io_init(); if (ret != TPM_SUCCESS) return ret; } if (cbs->tpm_nvram_init) { ret = cbs->tpm_nvram_init(); if (ret != TPM_SUCCESS) return ret; } #endif /* TPM_LIBTPMS_CALLBACKS */ _rpc__Signal_PowerOff(); has_cached_state = HasCachedState(TPMLIB_STATE_PERMANENT); has_nvram_file = _TPM2_CheckNVRAMFileExists(&has_nvram_loaddata_callback); if (!has_cached_state) { if (!has_nvram_file) { ret = _plat__NVEnable(NULL); if (ret) TPMLIB_LogTPM2Error( "%s: _plat__NVEnable(NULL) failed: %d\n", __func__, ret); if (TPM_Manufacture(TRUE) < 0 || g_inFailureMode) { TPMLIB_LogTPM2Error("%s: TPM_Manufacture(TRUE) failed or TPM in " "failure mode\n", __func__); reportedFailureCommand = TRUE; } } } else if (!has_nvram_loaddata_callback) { ret = _plat__NVEnable_NVChipFile(NULL); if (ret) TPMLIB_LogTPM2Error("%s: _plat__NVEnable_File(NULL) failed: %d\n", __func__, ret); } _rpc__Signal_PowerOn(FALSE); _rpc__Signal_NvOn(); if (ret == TPM_SUCCESS) { if (g_inFailureMode) ret = TPM_RC_FAILURE; } if (ret == TPM_SUCCESS && has_cached_state) { NvCommit(); } return ret; } static void TPM2_Terminate(void) { TPM_TearDown(); _rpc__Signal_PowerOff(); ExpDCacheFree(); } static TPM_RESULT TPM2_Process(unsigned char **respbuffer, uint32_t *resp_size, uint32_t *respbufsize, unsigned char *command, uint32_t command_size) { uint8_t locality = 0; _IN_BUFFER req; _OUT_BUFFER resp; unsigned char *tmp; #ifdef TPM_LIBTPMS_CALLBACKS struct libtpms_callbacks *cbs = TPMLIB_GetCallbacks(); if (cbs->tpm_io_getlocality) { TPM_MODIFIER_INDICATOR locty; locality = cbs->tpm_io_getlocality(&locty, 0); locality = locty; } #endif /* TPM_LIBTPMS_CALLBACKS */ req.BufferSize = command_size; req.Buffer = command; /* have the TPM 2 write directly into the response buffer */ if (*respbufsize < TPM_BUFFER_MAX || !*respbuffer) { tmp = realloc(*respbuffer, TPM_BUFFER_MAX); if (!tmp) { TPMLIB_LogTPM2Error("Could not allocated %u bytes.\n", TPM_BUFFER_MAX); return TPM_SIZE; } *respbuffer = tmp; *respbufsize = TPM_BUFFER_MAX; } resp.BufferSize = *respbufsize; resp.Buffer = *respbuffer; /* * signals for cancellation have to come after we start processing */ _rpc__Signal_CancelOff(); _rpc__Send_Command(locality, req, &resp); /* it may come back with a different buffer, especially in failure mode */ if (resp.Buffer != *respbuffer) { if (resp.BufferSize > *respbufsize) resp.BufferSize = *respbufsize; memcpy(*respbuffer, resp.Buffer, resp.BufferSize); } *resp_size = resp.BufferSize; if (g_inFailureMode && !reportedFailureCommand) { reportedFailureCommand = TRUE; TPMLIB_LogTPM2Error("%s: Entered failure mode through command:\n", __func__); TPMLIB_LogArray(~0, command, command_size); } return TPM_SUCCESS; } TPM_RESULT TPM2_PersistentAllStore(unsigned char **buf, uint32_t *buflen) { BYTE *buffer; INT32 size; unsigned char *nbuffer; TPM_RESULT ret = TPM_SUCCESS; UINT32 written = 0; *buflen = NV_MEMORY_SIZE + 32 * 1024; *buf = NULL; /* the marshal functions do not indicate insufficient buffer; to make sure we didn't run out of buffer, we check that enough room for the biggest type of chunk (64k) is available and try again. */ do { *buflen += 66 * 1024; nbuffer = realloc(*buf, *buflen); if (nbuffer == NULL) { free(*buf); *buf = NULL; ret = TPM_SIZE; written = 0; break; } *buf = buffer = nbuffer; size = *buflen; written = PERSISTENT_ALL_Marshal(&buffer, &size); } while (size < 66 * 1024); *buflen = written; return ret; } static TPM_RESULT TPM2_VolatileAllStore(unsigned char **buffer, uint32_t *buflen) { TPM_RESULT rc = 0; INT32 size = NV_MEMORY_SIZE; UINT16 written; unsigned char *statebuffer = NULL; *buffer = NULL; statebuffer = malloc(size); if (!statebuffer) { TPMLIB_LogTPM2Error("Could not allocate %u bytes.\n", size); return TPM_SIZE; } /* statebuffer will change */ *buffer = statebuffer; written = VolatileSave(&statebuffer, &size); if (written >= size) { free(*buffer); *buffer = NULL; rc = TPM_FAIL; } else { *buflen = written; } return rc; } static TPM_RESULT TPM2_CancelCommand(void) { _rpc__Signal_CancelOn(); return TPM_SUCCESS; } static TPM_RESULT TPM2_GetTPMProperty(enum TPMLIB_TPMProperty prop, int *result) { switch (prop) { case TPMPROP_TPM_RSA_KEY_LENGTH_MAX: *result = MAX_RSA_KEY_BITS; break; case TPMPROP_TPM_KEY_HANDLES: *result = MAX_HANDLE_NUM; break; /* not supported for TPM 2 */ case TPMPROP_TPM_OWNER_EVICT_KEY_HANDLES: case TPMPROP_TPM_MIN_AUTH_SESSIONS: case TPMPROP_TPM_MIN_TRANS_SESSIONS: case TPMPROP_TPM_MIN_DAA_SESSIONS: case TPMPROP_TPM_MIN_SESSION_LIST: case TPMPROP_TPM_MIN_COUNTERS: case TPMPROP_TPM_NUM_FAMILY_TABLE_ENTRY_MIN: case TPMPROP_TPM_NUM_DELEGATE_TABLE_ENTRY_MIN: case TPMPROP_TPM_SPACE_SAFETY_MARGIN: case TPMPROP_TPM_MAX_NV_SPACE: case TPMPROP_TPM_MAX_SAVESTATE_SPACE: case TPMPROP_TPM_MAX_VOLATILESTATE_SPACE: default: return TPM_FAIL; } return TPM_SUCCESS; } /* * TPM2_GetInfo: * * @flags: logical or of flags that query for information * * Return a JSON document with contents queried for by the user's passed flags */ static char *TPM2_GetInfo(enum TPMLIB_InfoFlags flags) { const char *tpmspec = "\"TPMSpecification\":{" "\"family\":\"2.0\"," "\"level\":" STRINGIFY(SPEC_LEVEL_NUM) "," "\"revision\":" STRINGIFY(SPEC_VERSION) "}"; const char *tpmattrs_temp = "\"TPMAttributes\":{" "\"manufacturer\":\"id:00001014\"," "\"version\":\"id:%08X\"," "\"model\":\"swtpm\"" "}"; const char *tpmfeatures_temp = "\"TPMFeatures\":{" "\"RSAKeySizes\":[%s]," "\"CamelliaKeySizes\":[%s]" "}"; char *fmt = NULL, *buffer; bool printed = false; char *tpmattrs = NULL; char *tpmfeatures = NULL; char rsakeys[32]; char camelliakeys[16]; size_t n; if (!(buffer = strdup("{%s%s%s}"))) return NULL; if ((flags & TPMLIB_INFO_TPMSPECIFICATION)) { fmt = buffer; buffer = NULL; if (asprintf(&buffer, fmt, "", tpmspec, "%s%s%s") < 0) goto error; free(fmt); printed = true; } if ((flags & TPMLIB_INFO_TPMATTRIBUTES)) { fmt = buffer; buffer = NULL; if (asprintf(&tpmattrs, tpmattrs_temp, FIRMWARE_V1) < 0) goto error; if (asprintf(&buffer, fmt, printed ? "," : "", tpmattrs, "%s%s%s") < 0) goto error; free(fmt); printed = true; } if ((flags & TPMLIB_INFO_TPMFEATURES)) { fmt = buffer; buffer = NULL; n = snprintf(rsakeys, sizeof(rsakeys), "%s2048%s%s", RSA_1024 ? "1024," : "", RSA_3072 ? ",3072" : "", RSA_4096 ? ",4096" : ""); if (n >= sizeof(rsakeys)) goto error; n = snprintf(camelliakeys, sizeof(camelliakeys), "%s%s%s", CAMELLIA_128 ? "128" : "", CAMELLIA_192 ? ",192" : "", CAMELLIA_256 ? ",256" : ""); if (n >= sizeof(camelliakeys)) goto error; if (asprintf(&tpmfeatures, tpmfeatures_temp, rsakeys, camelliakeys) < 0) goto error; if (asprintf(&buffer, fmt, printed ? "," : "", tpmfeatures, "%s%s%s") < 0) goto error; free(fmt); printed = true; } /* nothing else to add */ fmt = buffer; buffer = NULL; if (asprintf(&buffer, fmt, "", "", "") < 0) goto error; free(fmt); free(tpmattrs); free(tpmfeatures); return buffer; error: free(fmt); free(buffer); free(tpmattrs); free(tpmfeatures); return NULL; } static uint32_t tpm2_buffersize = TPM_BUFFER_MAX; static uint32_t TPM2_SetBufferSize(uint32_t wanted_size, uint32_t *min_size, uint32_t *max_size) { const uint32_t min = MAX_CONTEXT_SIZE + 128; const uint32_t max = TPM_BUFFER_MAX; if (min_size) *min_size = min; if (max_size) *max_size = max; if (wanted_size == 0) return tpm2_buffersize; if (wanted_size > max) wanted_size = max; else if (wanted_size < min) wanted_size = min; tpm2_buffersize = wanted_size; return tpm2_buffersize; } uint32_t TPM2_GetBufferSize(void) { return TPM2_SetBufferSize(0, NULL, NULL); } /* * Validate the state blobs to check whether they can be * successfully used by a TPM_INIT. */ static TPM_RESULT TPM2_ValidateState(enum TPMLIB_StateType st, unsigned int flags) { TPM_RESULT ret = TPM_SUCCESS; TPM_RC rc = TPM_RC_SUCCESS; unsigned char *data = NULL; uint32_t length; unsigned char bak_NV[NV_MEMORY_SIZE]; INT32 size; BYTE *buffer; BOOL restored; /* make backup of current NvChip memory */ memcpy(bak_NV, s_NV, sizeof(bak_NV)); #ifdef TPM_LIBTPMS_CALLBACKS struct libtpms_callbacks *cbs = TPMLIB_GetCallbacks(); if (cbs->tpm_nvram_init) { ret = cbs->tpm_nvram_init(); if (ret != TPM_SUCCESS) return ret; } #endif if ((rc == TPM_RC_SUCCESS) && (st & (TPMLIB_STATE_PERMANENT | TPMLIB_STATE_SAVE_STATE))) { #ifdef TPM_LIBTPMS_CALLBACKS if (cbs->tpm_nvram_loaddata) { ret = cbs->tpm_nvram_loaddata(&data, &length, 0, TPM_PERMANENT_ALL_NAME); if (ret != TPM_SUCCESS) return ret; } #endif if (!data) return TPM_FAIL; buffer = data; size = length; rc = PERSISTENT_ALL_Unmarshal(&buffer, &size); free(data); } if ((rc == TPM_RC_SUCCESS) && (st & TPMLIB_STATE_VOLATILE)) { rc = VolatileLoad(&restored); } ret = rc; return ret; } /* * Get the state blob of the given type. If the TPM is not running, we * get the cached state blobs, if available, otherwise we try to read * it from files. In case the TPM is running, we get it from the running * TPM. */ static TPM_RESULT TPM2_GetState(enum TPMLIB_StateType st, unsigned char **buffer, uint32_t *buflen) { TPM_RESULT ret = TPM_FAIL; if (!_rpc__Signal_IsPowerOn()) { struct libtpms_callbacks *cbs = TPMLIB_GetCallbacks(); bool is_empty_buffer; ret = CopyCachedState(st, buffer, buflen, &is_empty_buffer); if (ret != TPM_SUCCESS || *buffer != NULL || is_empty_buffer) return ret; if (cbs->tpm_nvram_init) { ret = cbs->tpm_nvram_init(); if (ret != TPM_SUCCESS) return ret; /* we can call the TPM 1.2 function here ... */ ret = TPM_NVRAM_LoadData(buffer, buflen, 0, TPMLIB_StateTypeToName(st)); } else { ret = TPM_FAIL; } return ret; } /* from the running TPM */ switch (st) { case TPMLIB_STATE_PERMANENT: ret = TPM2_PersistentAllStore(buffer, buflen); break; case TPMLIB_STATE_VOLATILE: ret = TPM2_VolatileAllStore(buffer, buflen); break; case TPMLIB_STATE_SAVE_STATE: *buffer = NULL; *buflen = 0; ret = 0; break; } return ret; } /* * Set the state the TPM 2 will use upon next TPM_MainInit(). The TPM 2 * must not have been started, yet, or it must have been terminated for this * function to set the state. * * @st: The TPMLIB_StateType describing the type of blob in the buffer * @buffer: pointer to the buffer containing the state blob; NULL pointer clears * previous state * @buflen: length of the buffer */ static TPM_RESULT TPM2_SetState(enum TPMLIB_StateType st, const unsigned char *buffer, uint32_t buflen) { TPM_RESULT ret = TPM_SUCCESS; TPM_RC rc = TPM_RC_SUCCESS; BYTE *stream = NULL, *orig_stream = NULL; INT32 stream_size = buflen; unsigned char *permanent = NULL, *ptr; INT32 permanent_len; if (buffer == NULL) { SetCachedState(st, NULL, 0); return TPM_SUCCESS; } if (_rpc__Signal_IsPowerOn()) return TPM_INVALID_POSTINIT; if (ret == TPM_SUCCESS) { stream = malloc(buflen); if (!stream) ret = TPM_SIZE; } if (ret == TPM_SUCCESS) { orig_stream = stream; memcpy(stream, buffer, buflen); } /* test whether we can accept the blob */ if (ret == TPM_SUCCESS) { switch (st) { case TPMLIB_STATE_PERMANENT: rc = PERSISTENT_ALL_Unmarshal(&stream, &stream_size); break; case TPMLIB_STATE_VOLATILE: /* load permanent state first */ rc = TPM2_GetState(TPMLIB_STATE_PERMANENT, &permanent, (uint32_t *)&permanent_len); if (rc == TPM_RC_SUCCESS) { ptr = permanent; rc = PERSISTENT_ALL_Unmarshal(&ptr, &permanent_len); if (rc == TPM_RC_SUCCESS) rc = VolatileState_Load(&stream, &stream_size); } break; case TPMLIB_STATE_SAVE_STATE: if (buffer != NULL) rc = TPM_BAD_TYPE; break; } ret = rc; if (ret != TPM_SUCCESS) ClearAllCachedState(); } /* cache the blob for the TPM_MainInit() to pick it up */ if (ret == TPM_SUCCESS) { SetCachedState(st, orig_stream, buflen); } else { free(orig_stream); } free(permanent); return ret; } const struct tpm_interface TPM2Interface = { .MainInit = TPM2_MainInit, .Terminate = TPM2_Terminate, .Process = TPM2_Process, .VolatileAllStore = TPM2_VolatileAllStore, .CancelCommand = TPM2_CancelCommand, .GetTPMProperty = TPM2_GetTPMProperty, .GetInfo = TPM2_GetInfo, .TpmEstablishedGet = TPM2_IO_TpmEstablished_Get, .TpmEstablishedReset = TPM2_IO_TpmEstablished_Reset, .HashStart = TPM2_IO_Hash_Start, .HashData = TPM2_IO_Hash_Data, .HashEnd = TPM2_IO_Hash_End, .SetBufferSize = TPM2_SetBufferSize, .ValidateState = TPM2_ValidateState, .SetState = TPM2_SetState, .GetState = TPM2_GetState, };