| /* Copyright (c) 2012 The Chromium OS Authors. All rights reserved. |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| * |
| * TPM command utility. Runs simple TPM commands. Mostly useful when physical |
| * presence has not been locked. |
| * |
| * The exit code is 0 for success, the TPM error code for TPM errors, and 255 |
| * for other errors. |
| */ |
| |
| #include <inttypes.h> |
| #include <stdint.h> |
| #include <stdlib.h> |
| #include <stdio.h> |
| #include <string.h> |
| #include <syslog.h> |
| |
| #include "tlcl.h" |
| #include "tpm_error_messages.h" |
| #include "tss_constants.h" |
| |
| #define OTHER_ERROR 255 /* OTHER_ERROR must be the largest uint8_t value. */ |
| |
| #ifdef TPM2_MODE |
| #define TPM_MODE_SELECT(_, tpm20_ver) tpm20_ver |
| #else |
| #define TPM_MODE_SELECT(tpm12_ver, _) tpm12_ver |
| #endif |
| |
| #define TPM_MODE_STRING TPM_MODE_SELECT("1.2", "2.0") |
| #define TPM12_NEEDS_PP TPM_MODE_SELECT(" (needs PP)", "") |
| #define TPM12_NEEDS_PP_REBOOT TPM_MODE_SELECT(" (needs PP, maybe reboot)", "") |
| |
| #define TPM20_NOT_IMPLEMENTED_DESCR(descr) \ |
| descr TPM_MODE_SELECT("", " [not-implemented for TPM2.0]") |
| #define TPM20_NOT_IMPLEMENTED_HANDLER(handler) \ |
| TPM_MODE_SELECT(handler, HandlerNotImplementedForTPM2) |
| #define TPM20_NOT_IMPLEMENTED(descr, handler) \ |
| TPM20_NOT_IMPLEMENTED_DESCR(descr), \ |
| TPM20_NOT_IMPLEMENTED_HANDLER(handler) |
| |
| #define TPM20_DOES_NOTHING_DESCR(descr) \ |
| descr TPM_MODE_SELECT("", " [no-op for TPM2.0]") |
| #define TPM20_DOES_NOTHING_HANDLER(handler) \ |
| TPM_MODE_SELECT(handler, HandlerDoNothingForTPM2) |
| #define TPM20_DOES_NOTHING(descr, handler) \ |
| TPM20_DOES_NOTHING_DESCR(descr), \ |
| TPM20_DOES_NOTHING_HANDLER(handler) |
| |
| typedef struct command_record { |
| const char* name; |
| const char* abbr; |
| const char* description; |
| uint32_t (*handler)(void); |
| } command_record; |
| |
| /* Set in main, consumed by handler functions below. We use global variables |
| * so we can also choose to call Tlcl*() functions directly; they don't take |
| * argv/argc. |
| */ |
| int nargs; |
| char** args; |
| |
| /* Converts a string in the form 0x[0-9a-f]+ to a 32-bit value. Returns 0 for |
| * success, non-zero for failure. |
| */ |
| static int HexStringToUint32(const char* string, uint32_t* value) { |
| char tail[1]; |
| /* strtoul is not as good because it overflows silently */ |
| const char* format = strncmp(string, "0x", 2) ? "%8x%s" : "0x%8x%s"; |
| int n = sscanf(string, format, value, tail); |
| return n != 1; |
| } |
| |
| /* Converts a string in the form [0-9a-f]+ to an 8-bit value. Returns 0 for |
| * success, non-zero for failure. |
| */ |
| static int HexStringToUint8(const char* string, uint8_t* value) { |
| char* end; |
| uint32_t large_value = strtoul(string, &end, 16); |
| if (*end != '\0' || large_value > 0xff) { |
| return 1; |
| } |
| *value = large_value; |
| return 0; |
| } |
| |
| static int HexStringToArray(const char* string, uint8_t* value, int num_bytes) { |
| int len = strlen(string); |
| if (!strncmp(string, "0x", 2)) { |
| string += 2; |
| len -= 2; |
| } |
| if (len != num_bytes * 2) { |
| return 1; |
| } |
| for (; len > 0; string += 2, len -= 2, value++) { |
| if (sscanf(string, "%2hhx", value) != 1) { |
| return 1; |
| } |
| } |
| return 0; |
| } |
| |
| /* TPM error check and reporting. Returns 0 if |result| is 0 (TPM_SUCCESS). |
| * Otherwise looks up a TPM error in the error table and prints the error if |
| * found. Then returns min(result, OTHER_ERROR) since some error codes, such |
| * as TPM_E_RETRY, do not fit in a byte. |
| */ |
| static uint8_t ErrorCheck(uint32_t result, const char* cmd) { |
| uint8_t exit_code = result > OTHER_ERROR ? OTHER_ERROR : result; |
| if (result == 0) { |
| return 0; |
| } else { |
| int i; |
| int n = sizeof(tpm_error_table) / sizeof(tpm_error_table[0]); |
| fprintf(stderr, "command \"%s\" failed with code %#x\n", cmd, result); |
| for (i = 0; i < n; i++) { |
| if (tpm_error_table[i].code == result) { |
| fprintf(stderr, "%s\n%s\n", tpm_error_table[i].name, |
| tpm_error_table[i].description); |
| return exit_code; |
| } |
| } |
| fprintf(stderr, "the TPM error code is unknown to this program\n"); |
| return exit_code; |
| } |
| } |
| |
| /* Handler functions. These wouldn't exist if C had closures. |
| */ |
| static uint32_t HandlerTpmVersion(void) { |
| puts(TPM_MODE_STRING); |
| return 0; |
| } |
| |
| /* TODO(apronin): stub for selected flags for TPM2 */ |
| #ifdef TPM2_MODE |
| static uint32_t HandlerGetFlags(void) { |
| fprintf(stderr, "getflags not implemented for TPM2\n"); |
| exit(OTHER_ERROR); |
| } |
| #else |
| static uint32_t HandlerGetFlags(void) { |
| uint8_t disabled; |
| uint8_t deactivated; |
| uint8_t nvlocked; |
| uint32_t result = TlclGetFlags(&disabled, &deactivated, &nvlocked); |
| if (result == 0) { |
| printf("disabled: %d\ndeactivated: %d\nnvlocked: %d\n", |
| disabled, deactivated, nvlocked); |
| } |
| return result; |
| } |
| #endif |
| |
| #ifndef TPM2_MODE |
| static uint32_t HandlerActivate(void) { |
| return TlclSetDeactivated(0); |
| } |
| |
| static uint32_t HandlerDeactivate(void) { |
| return TlclSetDeactivated(1); |
| } |
| #endif |
| |
| static uint32_t HandlerDefineSpace(void) { |
| uint32_t index, size, perm; |
| int overwrite = 1; |
| |
| if (nargs != 5 && nargs != 6) { |
| fprintf(stderr, "usage: tpmc def <index> <size> <perm> " |
| "[--no-overwrite])\n"); |
| exit(OTHER_ERROR); |
| } |
| |
| if (HexStringToUint32(args[2], &index) != 0 || |
| HexStringToUint32(args[3], &size) != 0 || |
| HexStringToUint32(args[4], &perm) != 0) { |
| fprintf(stderr, "<index>, <size>, and <perm> must be " |
| "32-bit hex (0x[0-9a-f]+)\n"); |
| exit(OTHER_ERROR); |
| } |
| |
| if (args[5] && strcmp(args[5], "--no-overwrite") == 0) { |
| overwrite = 0; |
| } |
| |
| #ifdef TPM2_MODE |
| // For TPM 2.0, DefineSpace will fail if the space already exists, so to |
| // support the default 'overwrite' mode, need to undefine the space first. |
| if (overwrite) { |
| TlclUndefineSpace(index); |
| } |
| #else /* ifndef TPM2_MODE */ |
| // For TPM 1.2, we have to check the existing before calling DefineSpace(), |
| // since it will automaticly overwrite the existing space by default. |
| // Do nothing for TPM 2.0. We rely on DefineSpace() to return the appropriate |
| // error code. |
| if (!overwrite) { |
| uint32_t result , permissions; |
| result = TlclGetPermissions(index, &permissions); |
| if (!result) { |
| fprintf(stderr, "The space is existing but --no-overwrite is set.\n"); |
| exit(OTHER_ERROR); |
| } |
| } |
| #endif |
| |
| return TlclDefineSpace(index, perm, size); |
| } |
| |
| static uint32_t HandlerUndefineSpace(void) { |
| uint32_t index; |
| if (nargs != 3) { |
| fprintf(stderr, "usage: tpmc undef <index>\n"); |
| exit(OTHER_ERROR); |
| } |
| if (HexStringToUint32(args[2], &index) != 0) { |
| fprintf(stderr, "<index> must be " |
| "32-bit hex (0x[0-9a-f]+)\n"); |
| exit(OTHER_ERROR); |
| } |
| return TlclUndefineSpace(index); |
| } |
| |
| static uint32_t HandlerWrite(void) { |
| uint32_t index, size; |
| uint8_t value[TPM_MAX_COMMAND_SIZE]; |
| char** byteargs; |
| int i; |
| if (nargs < 3) { |
| fprintf(stderr, "usage: tpmc write <index> [<byte0> <byte1> ...]\n"); |
| exit(OTHER_ERROR); |
| } |
| if (HexStringToUint32(args[2], &index) != 0) { |
| fprintf(stderr, "<index> must be 32-bit hex (0x[0-9a-f]+)\n"); |
| exit(OTHER_ERROR); |
| } |
| size = nargs - 3; |
| if (size > sizeof(value)) { |
| fprintf(stderr, "byte array too large\n"); |
| exit(OTHER_ERROR); |
| } |
| |
| byteargs = args + 3; |
| for (i = 0; i < size; i++) { |
| if (HexStringToUint8(byteargs[i], &value[i]) != 0) { |
| fprintf(stderr, "invalid byte %s, should be [0-9a-f][0-9a-f]?\n", |
| byteargs[i]); |
| exit(OTHER_ERROR); |
| } |
| } |
| |
| if (size == 0) { |
| #ifndef TPM2_MODE |
| if (index == TPM_NV_INDEX_LOCK) { |
| fprintf(stderr, "This would set the nvLocked bit. " |
| "Use \"tpmc setnv\" instead.\n"); |
| exit(OTHER_ERROR); |
| } |
| #endif |
| printf("warning: zero-length write\n"); |
| } else { |
| printf("writing %d byte%s\n", size, size > 1 ? "s" : ""); |
| } |
| |
| return TlclWrite(index, value, size); |
| } |
| |
| static uint32_t HandlerPCRRead(void) { |
| uint32_t index; |
| uint8_t value[TPM_PCR_DIGEST]; |
| uint32_t result; |
| int i; |
| if (nargs != 3) { |
| fprintf(stderr, "usage: tpmc pcrread <index>\n"); |
| exit(OTHER_ERROR); |
| } |
| if (HexStringToUint32(args[2], &index) != 0) { |
| fprintf(stderr, "<index> must be 32-bit hex (0x[0-9a-f]+)\n"); |
| exit(OTHER_ERROR); |
| } |
| result = TlclPCRRead(index, value, sizeof(value)); |
| if (result == 0) { |
| for (i = 0; i < TPM_PCR_DIGEST; i++) { |
| printf("%02x", value[i]); |
| } |
| printf("\n"); |
| } |
| return result; |
| } |
| |
| static uint32_t HandlerPCRExtend(void) { |
| uint32_t index; |
| uint8_t value[TPM_PCR_DIGEST]; |
| if (nargs != 4) { |
| fprintf(stderr, "usage: tpmc pcrextend <index> <extend_hash>\n"); |
| exit(OTHER_ERROR); |
| } |
| if (HexStringToUint32(args[2], &index) != 0) { |
| fprintf(stderr, "<index> must be 32-bit hex (0x[0-9a-f]+)\n"); |
| exit(OTHER_ERROR); |
| } |
| if (HexStringToArray(args[3], value, TPM_PCR_DIGEST)) { |
| fprintf(stderr, "<extend_hash> must be a %d-byte hex string\n", |
| TPM_PCR_DIGEST); |
| exit(OTHER_ERROR); |
| } |
| return TlclExtend(index, value, value); |
| } |
| |
| static uint32_t HandlerRead(void) { |
| uint32_t index, size; |
| uint8_t value[4096]; |
| uint32_t result; |
| int i; |
| if (nargs != 4) { |
| fprintf(stderr, "usage: tpmc read <index> <size>\n"); |
| exit(OTHER_ERROR); |
| } |
| if (HexStringToUint32(args[2], &index) != 0 || |
| HexStringToUint32(args[3], &size) != 0) { |
| fprintf(stderr, "<index> and <size> must be 32-bit hex (0x[0-9a-f]+)\n"); |
| exit(OTHER_ERROR); |
| } |
| if (size > sizeof(value)) { |
| fprintf(stderr, "size of read (%#x) is too big\n", size); |
| exit(OTHER_ERROR); |
| } |
| result = TlclRead(index, value, size); |
| if (result == 0 && size > 0) { |
| for (i = 0; i < size - 1; i++) { |
| printf("%x ", value[i]); |
| } |
| printf("%x\n", value[i]); |
| } |
| return result; |
| } |
| |
| static uint32_t HandlerGetPermissions(void) { |
| uint32_t index, permissions, result; |
| if (nargs != 3) { |
| fprintf(stderr, "usage: tpmc getp <index>\n"); |
| exit(OTHER_ERROR); |
| } |
| if (HexStringToUint32(args[2], &index) != 0) { |
| fprintf(stderr, "<index> must be 32-bit hex (0x[0-9a-f]+)\n"); |
| exit(OTHER_ERROR); |
| } |
| result = TlclGetPermissions(index, &permissions); |
| if (result == 0) { |
| printf("space %#x has permissions %#x\n", index, permissions); |
| } |
| return result; |
| } |
| |
| static uint32_t HandlerGetOwnership(void) { |
| uint8_t owned = 0; |
| uint32_t result; |
| if (nargs != 2) { |
| fprintf(stderr, "usage: tpmc getownership\n"); |
| exit(OTHER_ERROR); |
| } |
| result = TlclGetOwnership(&owned); |
| if (result == 0) { |
| printf("Owned: %s\n", owned ? "yes" : "no"); |
| } |
| return result; |
| } |
| |
| static uint32_t HandlerGetRandom(void) { |
| uint32_t length, size = 0; |
| uint8_t* bytes; |
| uint32_t result; |
| int i; |
| if (nargs != 3) { |
| fprintf(stderr, "usage: tpmc getrandom <size>\n"); |
| exit(OTHER_ERROR); |
| } |
| if (HexStringToUint32(args[2], &length) != 0) { |
| fprintf(stderr, "<size> must be 32-bit hex (0x[0-9a-f]+)\n"); |
| exit(OTHER_ERROR); |
| } |
| bytes = calloc(1, length); |
| if (bytes == NULL) { |
| perror("calloc"); |
| exit(OTHER_ERROR); |
| } |
| result = TlclGetRandom(bytes, length, &size); |
| if (result == 0 && size > 0) { |
| for (i = 0; i < size; i++) { |
| printf("%02x", bytes[i]); |
| } |
| printf("\n"); |
| } |
| free(bytes); |
| return result; |
| } |
| |
| static uint32_t HandlerGetPermanentFlags(void) { |
| TPM_PERMANENT_FLAGS pflags; |
| uint32_t result = TlclGetPermanentFlags(&pflags); |
| if (result == 0) { |
| #define P(name) printf("%s %d\n", #name, pflags.name) |
| #ifdef TPM2_MODE |
| P(ownerAuthSet); |
| P(endorsementAuthSet); |
| P(lockoutAuthSet); |
| P(disableClear); |
| P(inLockout); |
| P(tpmGeneratedEPS); |
| #else |
| P(disable); |
| P(ownership); |
| P(deactivated); |
| P(readPubek); |
| P(disableOwnerClear); |
| P(allowMaintenance); |
| P(physicalPresenceLifetimeLock); |
| P(physicalPresenceHWEnable); |
| P(physicalPresenceCMDEnable); |
| P(CEKPUsed); |
| P(TPMpost); |
| P(TPMpostLock); |
| P(FIPS); |
| P(Operator); |
| P(enableRevokeEK); |
| P(nvLocked); |
| P(readSRKPub); |
| P(tpmEstablished); |
| P(maintenanceDone); |
| P(disableFullDALogicInfo); |
| #endif |
| #undef P |
| } |
| return result; |
| } |
| |
| static uint32_t HandlerGetSTClearFlags(void) { |
| TPM_STCLEAR_FLAGS vflags; |
| uint32_t result = TlclGetSTClearFlags(&vflags); |
| if (result == 0) { |
| #define P(name) printf("%s %d\n", #name, vflags.name) |
| #ifdef TPM2_MODE |
| P(phEnable); |
| P(shEnable); |
| P(ehEnable); |
| P(phEnableNV); |
| P(orderly); |
| #else |
| P(deactivated); |
| P(disableForceClear); |
| P(physicalPresence); |
| P(physicalPresenceLock); |
| P(bGlobalLock); |
| #endif |
| #undef P |
| } |
| return result; |
| } |
| |
| static uint32_t HandlerSendRaw(void) { |
| uint8_t request[4096]; |
| uint8_t response[4096]; |
| uint32_t result; |
| int size; |
| int i; |
| if (nargs == 2) { |
| fprintf(stderr, "usage: tpmc sendraw <hex byte 0> ... <hex byte N>\n"); |
| exit(OTHER_ERROR); |
| } |
| for (i = 0; i < nargs - 2 && i < sizeof(request); i++) { |
| if (HexStringToUint8(args[2 + i], &request[i]) != 0) { |
| fprintf(stderr, "bad byte value \"%s\"\n", args[2 + i]); |
| exit(OTHER_ERROR); |
| } |
| } |
| size = TlclPacketSize(request); |
| if (size != i) { |
| fprintf(stderr, "bad request: size field is %d, but packet has %d bytes\n", |
| size, i); |
| exit(OTHER_ERROR); |
| } |
| bzero(response, sizeof(response)); |
| result = TlclSendReceive(request, response, sizeof(response)); |
| if (result != 0) { |
| fprintf(stderr, "request failed with code %d\n", result); |
| } |
| size = TlclPacketSize(response); |
| if (size < 10 || size > sizeof(response)) { |
| fprintf(stderr, "unexpected response size %d\n", size); |
| exit(OTHER_ERROR); |
| } |
| for (i = 0; i < size; i++) { |
| printf("0x%02x ", response[i]); |
| if (i == size - 1 || (i + 1) % 8 == 0) { |
| printf("\n"); |
| } |
| } |
| return result; |
| } |
| |
| static uint32_t HandlerGetVersion(void) { |
| uint32_t vendor; |
| uint64_t firmware_version; |
| uint8_t vendor_specific[32]; |
| size_t vendor_specific_size = sizeof(vendor_specific); |
| uint32_t result = TlclGetVersion(&vendor, &firmware_version, vendor_specific, |
| &vendor_specific_size); |
| if (result == 0) { |
| printf("vendor %08x\nfirmware_version %016" PRIx64 "\nvendor_specific ", |
| vendor, firmware_version); |
| size_t n; |
| for (n = 0; n < vendor_specific_size; ++n) { |
| printf("%02x", vendor_specific[n]); |
| } |
| printf("\n"); |
| } |
| return result; |
| } |
| |
| #ifndef TPM2_MODE |
| static void PrintIFXFirmwarePackage(TPM_IFX_FIRMWAREPACKAGE* firmware_package, |
| const char* prefix) { |
| printf("%s_package_id %08x\n", prefix, |
| firmware_package->FwPackageIdentifier); |
| printf("%s_version %08x\n", prefix, firmware_package->Version); |
| printf("%s_stale_version %08x\n", prefix, firmware_package->StaleVersion); |
| } |
| |
| static uint32_t HandlerIFXFieldUpgradeInfo(void) { |
| TPM_IFX_FIELDUPGRADEINFO info; |
| uint32_t result = TlclIFXFieldUpgradeInfo(&info); |
| if (result == 0) { |
| printf("max_data_size %u\n", info.wMaxDataSize); |
| PrintIFXFirmwarePackage(&info.sBootloaderFirmwarePackage, "bootloader"); |
| PrintIFXFirmwarePackage(&info.sFirmwarePackages[0], "fw0"); |
| PrintIFXFirmwarePackage(&info.sFirmwarePackages[1], "fw1"); |
| printf("status %04x\n", info.wSecurityModuleStatus); |
| PrintIFXFirmwarePackage(&info.sProcessFirmwarePackage, "process_fw"); |
| printf("field_upgrade_counter %u\n", info.wFieldUpgradeCounter); |
| } |
| return result; |
| } |
| |
| static uint32_t HandlerCheckOwnerAuth(void) { |
| /* Attempt to define an NVRAM space using owner auth. We're using |
| * TPM_NV_INDEX_TRIAL, which doesn't actually allocate a space but still |
| * performs the owner authorization checks. Thus the return status indicates |
| * whether owner authorization was successful or not. |
| * |
| * The owner_auth value below is the commonly used well-known secret, i.e. the |
| * SHA1 hash of 20 zero bytes. This is the owner secret that is effective |
| * immediately after taking TPM ownership when we haven't configured a random |
| * owner password yet. |
| */ |
| uint8_t owner_auth[TPM_AUTH_DATA_LEN] = { |
| 0x67, 0x68, 0x03, 0x3e, 0x21, 0x64, 0x68, 0x24, 0x7b, 0xd0, |
| 0x31, 0xa0, 0xa2, 0xd9, 0x87, 0x6d, 0x79, 0x81, 0x8f, 0x8f}; |
| return TlclDefineSpaceEx(owner_auth, sizeof(owner_auth), TPM_NV_INDEX_TRIAL, |
| TPM_NV_PER_OWNERWRITE, 1, NULL, 0); |
| } |
| #endif /* !TPM2_MODE */ |
| |
| #ifdef TPM2_MODE |
| static uint32_t HandlerDoNothingForTPM2(void) { |
| return 0; |
| } |
| |
| static uint32_t HandlerNotImplementedForTPM2(void) { |
| fprintf(stderr, "%s: not implemented for TPM2.0\n", args[1]); |
| exit(OTHER_ERROR); |
| } |
| #endif |
| |
| /* Table of TPM commands. |
| */ |
| command_record command_table[] = { |
| { "tpmversion", "tpmver", "print TPM version: 1.2 or 2.0", |
| HandlerTpmVersion }, |
| { "getflags", "getf", "read and print the value of selected flags", |
| HandlerGetFlags }, |
| { "startup", "sta", "issue a Startup command", TlclStartup }, |
| { "selftestfull", "test", "issue a SelfTestFull command", TlclSelfTestFull }, |
| { "continueselftest", "ctest", "issue a ContinueSelfTest command", |
| TlclContinueSelfTest }, |
| { "assertphysicalpresence", "ppon", |
| TPM20_DOES_NOTHING("assert Physical Presence", |
| TlclAssertPhysicalPresence) }, |
| { "physicalpresencecmdenable", "ppcmd", |
| TPM20_NOT_IMPLEMENTED("turn on software PP", |
| TlclPhysicalPresenceCMDEnable) }, |
| { "enable", "ena", |
| TPM20_DOES_NOTHING("enable the TPM" TPM12_NEEDS_PP, |
| TlclSetEnable) }, |
| { "disable", "dis", |
| TPM20_NOT_IMPLEMENTED("disable the TPM" TPM12_NEEDS_PP, |
| TlclClearEnable) }, |
| { "activate", "act", |
| TPM20_DOES_NOTHING("activate the TPM" TPM12_NEEDS_PP_REBOOT, |
| HandlerActivate) }, |
| { "deactivate", "deact", |
| TPM20_NOT_IMPLEMENTED("deactivate the TPM" TPM12_NEEDS_PP_REBOOT, |
| HandlerDeactivate) }, |
| { "clear", "clr", |
| "clear the TPM owner" TPM12_NEEDS_PP, |
| TlclForceClear }, |
| { "setnvlocked", "setnv", |
| TPM20_NOT_IMPLEMENTED("set the nvLocked flag permanently (IRREVERSIBLE!)", |
| TlclSetNvLocked) }, |
| { "lockphysicalpresence", "pplock", |
| TPM_MODE_SELECT("lock (turn off) PP until reboot", |
| "set rollback protection lock for kernel image until reboot"), |
| TlclLockPhysicalPresence }, |
| { "setbgloballock", "block", |
| TPM_MODE_SELECT("set the bGlobalLock until reboot", |
| "set rollback protection lock for R/W firmware until reboot"), |
| TlclSetGlobalLock }, |
| { "definespace", "def", |
| TPM_MODE_SELECT("define a space (def <index> <size> <perm>). ", |
| "define a space (def <index> <size> <perm> [--no-overwrite]). ") |
| "Default will overwrite if the space is defined.", |
| HandlerDefineSpace }, |
| { "undefinespace", "undef", |
| "undefine a space (undef <index>)" |
| TPM_MODE_SELECT(" only succeeds when NvLocked is not set", ""), |
| HandlerUndefineSpace }, |
| { "write", "write", "write to a space (write <index> [<byte0> <byte1> ...])", |
| HandlerWrite }, |
| { "read", "read", "read from a space (read <index> <size>)", |
| HandlerRead }, |
| { "pcrread", "pcr", "read from a PCR (pcrread <index>)", |
| HandlerPCRRead }, |
| { "pcrextend", "extend", "extend a PCR (extend <index> <extend_hash>)", |
| HandlerPCRExtend }, |
| { "getownership", "geto", "print state of TPM ownership", |
| HandlerGetOwnership }, |
| { "getpermissions", "getp", "print space permissions (getp <index>)", |
| HandlerGetPermissions }, |
| { "getpermanentflags", "getpf", "print all permanent flags", |
| HandlerGetPermanentFlags }, |
| { "getrandom", "rand", "read bytes from RNG (rand <size>)", |
| HandlerGetRandom }, |
| { "getstclearflags", "getvf", "print all volatile (ST_CLEAR) flags", |
| HandlerGetSTClearFlags }, |
| { "resume", "res", "execute TPM_Startup(ST_STATE)", TlclResume }, |
| { "savestate", "save", "execute TPM_SaveState", TlclSaveState }, |
| { "sendraw", "raw", "send a raw request and print raw response", |
| HandlerSendRaw }, |
| { "getversion", "getver", "get TPM vendor and firmware version", |
| HandlerGetVersion }, |
| { "ifxfieldupgradeinfo", "ifxfui", |
| TPM20_NOT_IMPLEMENTED("read and print IFX field upgrade info", |
| HandlerIFXFieldUpgradeInfo) }, |
| { "checkownerauth", "chko", |
| TPM20_NOT_IMPLEMENTED("Check owner authorization with well-known secret", |
| HandlerCheckOwnerAuth) }, |
| }; |
| |
| static int n_commands = sizeof(command_table) / sizeof(command_table[0]); |
| |
| int main(int argc, char* argv[]) { |
| char *progname; |
| uint32_t result; |
| |
| progname = strrchr(argv[0], '/'); |
| if (progname) |
| progname++; |
| else |
| progname = argv[0]; |
| |
| if (argc < 2) { |
| fprintf(stderr, "usage: %s <TPM command> [args]\n or: %s help\n", |
| progname, progname); |
| return OTHER_ERROR; |
| } else { |
| command_record* c; |
| const char* cmd = argv[1]; |
| nargs = argc; |
| args = argv; |
| |
| if (strcmp(cmd, "help") == 0) { |
| printf("tpmc mode: TPM%s\n", TPM_MODE_STRING); |
| printf("%26s %7s %s\n\n", "command", "abbr.", "description"); |
| for (c = command_table; c < command_table + n_commands; c++) { |
| printf("%26s %7s %s\n", c->name, c->abbr, c->description); |
| } |
| return 0; |
| } |
| if (!strcmp(cmd, "tpmversion") || !strcmp(cmd, "tpmver")) { |
| return HandlerTpmVersion(); |
| } |
| |
| result = TlclLibInit(); |
| if (result) { |
| fprintf(stderr, "initialization failed with code %d\n", result); |
| return result > OTHER_ERROR ? OTHER_ERROR : result; |
| } |
| |
| for (c = command_table; c < command_table + n_commands; c++) { |
| if (strcmp(cmd, c->name) == 0 || strcmp(cmd, c->abbr) == 0) { |
| return ErrorCheck(c->handler(), cmd); |
| } |
| } |
| |
| /* No command matched. */ |
| fprintf(stderr, "%s: unknown command: %s\n", progname, cmd); |
| return OTHER_ERROR; |
| } |
| } |