void arch_gdt_set(word entry, word base, word limit, word type, word privelege,
word flags)
{
arch_gdt_table[entry].a =
(limit & 0x0000FFFF) | (base << 16);
arch_gdt_table[entry].b =
((base & 0x00FF0000) >> 16) | (base & 0xFF000000) | (limit & 0x000F0000)
| type | (privelege << 13) | flags;
logHex("b", arch_gdt_table[entry].b);
}
int main(int argc, char **argv)
{
TSS_RESULT tResult;
TSS_HTPM hTpm;
TSS_HKEY hEk;
TSS_FLAG fEkAttrs;
int iRc = -1;
#ifdef TSS_LIB_IS_12
struct option opts[] = {{"revocable", no_argument, NULL, 'r'},
{"generate-secret", no_argument, NULL, 'g'},
{"infile", required_argument, NULL, 'i'},
{"outfile", required_argument, NULL, 'o'},
};
UINT32 revDataSz;
BYTE revokeData[TPM_SHA1BASED_NONCE_LEN];
BYTE *pRevData;
#endif
initIntlSys();
#ifdef TSS_LIB_IS_12
if (genericOptHandler(argc, argv, "rgi:o:", opts, sizeof(opts) / sizeof(struct option),
parse, help) != 0)
goto out;
//Check commands for command hierarchy
if (isRevocable) {
if (needGenerateSecret) {
if (!outFileSet) {
logError(_("Please specify an output file\n"));
goto out;
}
if (inFileSet) {
logError(_("The option -i, --infile is not valid with -g\n"));
goto out;
}
} else if (!inFileSet) {
logError(_("Please specify -i, --infile or -g, --generate-secret\n"));
goto out;
} else if (outFileSet) {
logError(_("The option -o, --outfile is not valid with -i, --infile"));
goto out;
}
}
logDebug("Input file name: %s\n", in_filename);
logDebug("Output file name: %s\n", out_filename);
if (inFileSet) {
pRevData = revokeData;
revDataSz = sizeof(revokeData);
if (readData(revDataSz, &pRevData))
goto out;
} else if (outFileSet) {
FILE *outfile = fopen(out_filename, "w");
if (!outfile) {
iRc = -1;
logError(_("Unable to open output file: %s\n"), out_filename);
goto out;
}
fclose(outfile);
//TPM should generate the revoke data
revDataSz = 0;
pRevData = NULL;
}
#else
if (genericOptHandler(argc, argv, NULL, NULL, 0, NULL, NULL) != 0){
logError(_("See man pages for details.\n"));
goto out;
}
#endif
if (contextCreate(&hContext) != TSS_SUCCESS)
goto out;
if (contextConnect(hContext) != TSS_SUCCESS)
goto out_close;
if (contextGetTpm(hContext, &hTpm) != TSS_SUCCESS)
goto out_close;
//Initialize EK attributes here
fEkAttrs = TSS_KEY_SIZE_2048 | TSS_KEY_TYPE_LEGACY;
if (contextCreateObject(hContext, TSS_OBJECT_TYPE_RSAKEY, fEkAttrs, &hEk) != TSS_SUCCESS)
goto out_close;
#ifdef TSS_LIB_IS_12
if (isRevocable){
tResult = tpmCreateRevEk(hTpm, hEk, NULL, &revDataSz, &pRevData);
if (tResult != TSS_SUCCESS)
goto out_close;
//Writes the generated secret into the output file
if (outFileSet) {
if (writeData(revDataSz, pRevData)) {
logError(_("Creating revocable EK succeeded, but writing the EK "
"revoke authorization to disk failed.\nPrinting the "
"revoke authorization instead:\n"));
logHex(revDataSz, pRevData);
logError(_("You should record this data, as its the authorization "
"you'll need to revoke your EK!\n"));
goto out_close;
}
}
} else
#endif
tResult = tpmCreateEk(hTpm, hEk, NULL);
if (tResult != TSS_SUCCESS)
goto out_close;
iRc = 0;
logSuccess(argv[0]);
out_close:
contextClose(hContext);
out:
return iRc;
}
void sched_arch_init(void)
{
unsigned i;
ipc_currentthread = 0;
ipc_threadstack[0] = ((unsigned)(task[0].stack + 4096));
ipc_threadstack[1] = ((unsigned)(task[1].stack + 4091));
ipc_threadstack[2] = ((unsigned)(task[2].stack + 4091));
ipc_threadstack[3] = ((unsigned)(task[3].stack + 4091));
ipc_threadstack[4] = ((unsigned)(task[4].stack + 4091));
ipc_threadstack[5] = ((unsigned)(task[5].stack + 4091));
ipc_threadesp0[0] = ((unsigned)(task[0].stack + 4096));
ipc_threadesp0[1] = ((unsigned)(task[1].stack + 4096));
ipc_threadesp0[2] = ((unsigned)(task[2].stack + 4096));
ipc_threadesp0[3] = ((unsigned)(task[3].stack + 4096));
ipc_threadesp0[4] = ((unsigned)(task[4].stack + 4096));
ipc_threadesp0[5] = ((unsigned)(task[5].stack + 4096));
ipc_threadeip[0] = ((unsigned)(0x00800000));
ipc_threadeip[1] = ((unsigned)(0x80000000));
ipc_threadeip[2] = ((unsigned)(0x80000000));
ipc_threadeip[3] = ((unsigned)(0x80000000));
ipc_threadeip[4] = ((unsigned)(0x80000000));
ipc_threadeip[5] = ((unsigned)(0x80000000));
ipc_threadspace[0] = 0x00610000;
ipc_threadspace[1] = 0x00900000;
ipc_threadspace[2] = 0x00906000;
ipc_threadspace[3] = 0x0090C000;
ipc_threadspace[4] = 0x00903000;
ipc_threadspace[5] = 0x00904000;
ipc_threadstate[0] = 1;
ipc_threadstate[1] = 0;
ipc_threadstate[2] = 0;
ipc_threadstate[3] = 0;
ipc_threadstate[4] = 0;
ipc_threadstate[5] = 0;
for (i = 1; i < 4; i++)
{
task[i].stack[4095] = 0x2B; /* SS */
task[i].stack[4094] = 0x80002000; /* ESP */
task[i].stack[4093] = 0x00003202; /* EFLAGS */
task[i].stack[4092] = 0x23; /* CS */
task[i].stack[4091] = 0x80000000; /* EIP */
task[i].stack[4090] = 0xAAAAAAAA; /* EAX */
task[i].stack[4089] = 0xCCCCCCCC; /* ECX */
task[i].stack[4088] = 0xDDDDDDDD; /* EDX */
task[i].stack[4087] = 0xBBBBBBBB; /* EBX */
task[i].stack[4086] = 0x99999999; /* EBP */
task[i].stack[4085] = 0xEEEEEEEE; /* ESI */
task[i].stack[4084] = 0xFFFFFFFF; /* EDI */
}
logStatus(logSuccess);
logHex("Task 0 : Entry Point", ((unsigned)(ipc_threadeip[0])));
logHex("Task 0 : Stack : Start", ((unsigned)(task[0].stack)));
logHex("Task 0 : Stack : End", ((unsigned)(task[0].stack + 4096)));
logHex("Task 0 : Stack : Pointer", ((unsigned)(ipc_threadstack[0])));
logHex("Task 1 : Entry Point", ((unsigned)(ipc_threadeip[1])));
logHex("Task 1 : Stack : Start", ((unsigned)(task[1].stack)));
logHex("Task 1 : Stack : End", ((unsigned)(task[1].stack + 4096)));
logHex("Task 1 : Stack : Pointer", ((unsigned)(ipc_threadstack[1])));
}
int cmdVersion(const char *a_szCmd)
{
TSS_HTPM hTpm;
UINT32 uiSubCap;
BYTE *pSubCap;
UINT32 uiResultLen;
BYTE *pResult;
int iRc = -1;
if (contextCreate(&hContext) != TSS_SUCCESS)
goto out;
if (contextConnect(hContext) != TSS_SUCCESS)
goto out_close;
if (contextGetTpm(hContext, &hTpm) != TSS_SUCCESS)
goto out_close;
#ifdef TSS_LIB_IS_12
{
UINT64 offset;
TSS_RESULT uiResult;
TPM_CAP_VERSION_INFO versionInfo;
int tmpLogLevel = iLogLevel;
/* disable logging during this call. If we're on a 1.1 TPM, it'd throw an error */
iLogLevel = LOG_LEVEL_NONE;
if ((uiResult = getCapability(hTpm, TSS_TPMCAP_VERSION_VAL, 0, NULL, &uiResultLen,
&pResult)) != TSS_SUCCESS) {
iLogLevel = tmpLogLevel;
if (uiResult == TPM_E_BAD_MODE)
goto print_cap_version;
else
goto out_close;
}
iLogLevel = tmpLogLevel;
offset = 0;
if ((uiResult = unloadVersionInfo(&offset, pResult, &versionInfo))) {
goto out_close;
}
logMsg(_(" TPM 1.2 Version Info:\n"));
logMsg(_(" Chip Version: %hhu.%hhu.%hhu.%hhu\n"),
versionInfo.version.major, versionInfo.version.minor,
versionInfo.version.revMajor, versionInfo.version.revMinor);
logMsg(_(" Spec Level: %hu\n"), versionInfo.specLevel);
logMsg(_(" Errata Revision: %hhu\n"), versionInfo.errataRev);
logMsg(_(" TPM Vendor ID: %c%c%c%c\n"),
versionInfo.tpmVendorID[0], versionInfo.tpmVendorID[1],
versionInfo.tpmVendorID[2], versionInfo.tpmVendorID[3]);
if (versionInfo.vendorSpecificSize) {
logMsg(_(" Vendor Specific data: "));
logHex(versionInfo.vendorSpecificSize, versionInfo.vendorSpecific);
free(versionInfo.vendorSpecific);
}
}
print_cap_version:
#endif
if (getCapability(hTpm, TSS_TPMCAP_VERSION, 0, NULL, &uiResultLen,
&pResult) != TSS_SUCCESS)
goto out_close;
logMsg(_(" TPM Version: "));
logHex(uiResultLen, pResult);
uiSubCap = TSS_TPMCAP_PROP_MANUFACTURER;
pSubCap = (BYTE *) & uiSubCap;
if (getCapability(hTpm, TSS_TPMCAP_PROPERTY, sizeof(uiSubCap),
pSubCap, &uiResultLen, &pResult) != TSS_SUCCESS)
goto out_close;
logMsg(_(" Manufacturer Info: "));
logHex(uiResultLen, pResult);
iRc = 0;
logSuccess(a_szCmd);
out_close:
contextClose(hContext);
out:
return iRc;
}
