/*
* Logs that the testharness was unable to read or parse the testinfo.dat for
* a test case.
*/
void LogTestDatError(FILE* ResultsFile, char* Path)
{
LogResult(ResultsFile, SZ_BLANKDATA, SZ_BLANKDATA,
SZ_BLANKDATA, UNKNOWN_TYPE, Path,
TSTPHASE_BUILD, TSTRESULT_NOINFO, 0);
LogResult(ResultsFile, SZ_BLANKDATA, SZ_BLANKDATA,
SZ_BLANKDATA, UNKNOWN_TYPE, Path,
TSTPHASE_EXEC, TSTRESULT_NOINFO, 0);
}
/*
* Logs a result the testharness was unable to change to the test case dir.
*/
void LogDirectoryError(FILE* ResultsFile, char* Path)
{
LogResult(ResultsFile, SZ_BLANKDATA, SZ_BLANKDATA,
SZ_BLANKDATA, UNKNOWN_TYPE, Path,
TSTPHASE_BUILD, TSTRESULT_DIRERR,
"HARNESS: Could not change to test case directory.");
LogResult(ResultsFile, SZ_BLANKDATA, SZ_BLANKDATA,
SZ_BLANKDATA, UNKNOWN_TYPE, Path,
TSTPHASE_EXEC, TSTRESULT_DIRERR,
"HARNESS: Could not change to test case directory.");
}
TSS_RESULT
TCSP_GetCapability_Internal(TCS_CONTEXT_HANDLE hContext, /* in */
TCPA_CAPABILITY_AREA capArea, /* in */
UINT32 subCapSize, /* in */
BYTE * subCap, /* in */
UINT32 * respSize, /* out */
BYTE ** resp) /* out */
{
UINT64 offset = 0;
UINT32 paramSize;
TSS_RESULT result;
BYTE txBlob[TSS_TPM_TXBLOB_SIZE];
LogDebug("Entering Get Cap");
if ((result = tpm_rqu_build(TPM_ORD_GetCapability, &offset, txBlob, capArea, subCapSize,
subCap, NULL)))
return result;
if ((result = req_mgr_submit_req(txBlob)))
return result;
result = UnloadBlob_Header(txBlob, ¶mSize);
if (!result) {
result = tpm_rsp_parse(TPM_ORD_GetCapability, txBlob, paramSize, respSize, resp,
NULL, NULL);
}
LogResult("Get Cap", result);
return result;
}
TSS_RESULT
TCSP_SetOperatorAuth_Internal(TCS_CONTEXT_HANDLE hContext, /* in */
TCPA_SECRET *operatorAuth) /* in */
{
TSS_RESULT result;
UINT64 offset = 0;
UINT32 paramSize;
BYTE txBlob[TSS_TPM_TXBLOB_SIZE];
LogDebugFn("Enter");
if ((result = ctx_verify_context(hContext)))
return result;
if ((result = tpm_rqu_build(TPM_ORD_SetOperatorAuth, &offset, txBlob, TPM_AUTHDATA_SIZE,
operatorAuth->authdata)))
return result;
if ((result = req_mgr_submit_req(txBlob)))
goto done;
result = UnloadBlob_Header(txBlob, ¶mSize);
LogResult("SetOperatorAuth", result);
done:
return result;
}
///////////////////////////////////////////////////////////////
//
// CDatabaseJobQueueImpl::ProcessQuery
//
//
//
///////////////////////////////////////////////////////////////
void CDatabaseJobQueueImpl::ProcessQuery ( CDbJobData* pJobData )
{
// CDatabaseConnection* from handle
CDatabaseConnection* pConnection = GetConnectionFromHandle ( pJobData->command.connectionHandle );
if ( !pConnection )
{
pJobData->result.status = EJobResult::FAIL;
pJobData->result.strReason = "Invalid connection";
return;
}
// And query
if ( !pConnection->Query ( pJobData->command.strData, pJobData->result.registryResult ) )
{
pJobData->result.status = EJobResult::FAIL;
pJobData->result.strReason = pConnection->GetLastErrorMessage ();
pJobData->result.uiErrorCode = pConnection->GetLastErrorCode ();
pJobData->result.bErrorSuppressed = MapContains ( pConnection->m_SuppressedErrorCodes, pConnection->GetLastErrorCode () );
}
else
{
pJobData->result.status = EJobResult::SUCCESS;
}
// And log if required
LogResult ( pJobData );
}
TSS_RESULT
TCSP_OwnerClear_Internal(TCS_CONTEXT_HANDLE hContext, /* in */
TPM_AUTH * ownerAuth) /* in, out */
{
UINT64 offset = 0;
UINT32 paramSize;
TSS_RESULT result;
BYTE txBlob[TSS_TPM_TXBLOB_SIZE];
LogDebug("Entering OwnerClear");
if ((result = ctx_verify_context(hContext)))
goto done;
if ((result = auth_mgr_check(hContext, &ownerAuth->AuthHandle)))
goto done;
if ((result = tpm_rqu_build(TPM_ORD_OwnerClear, &offset, txBlob, ownerAuth)))
goto done;
if ((result = req_mgr_submit_req(txBlob)))
goto done;
result = UnloadBlob_Header(txBlob, ¶mSize);
if (!result) {
result = tpm_rsp_parse(TPM_ORD_OwnerClear, txBlob, paramSize, ownerAuth);
}
LogResult("Ownerclear", result);
done:
auth_mgr_release_auth(ownerAuth, NULL, hContext);
return result;
}
TSS_RESULT
TCSP_CMK_CreateKey_Internal(TCS_CONTEXT_HANDLE hContext, /* in */
TCS_KEY_HANDLE hWrappingKey, /* in */
TPM_ENCAUTH KeyUsageAuth, /* in */
TPM_HMAC MigAuthApproval, /* in */
TPM_DIGEST MigAuthorityDigest, /* in */
UINT32* keyDataSize, /* in, out */
BYTE** prgbKeyData, /* in, out */
TPM_AUTH* pAuth) /* in, out */
{
TSS_RESULT result;
UINT64 offset = 0;
UINT32 paramSize;
UINT32 parentSlot;
BYTE txBlob[TSS_TPM_TXBLOB_SIZE];
LogDebugFn("Enter");
if ((result = ctx_verify_context(hContext))) {
free(*prgbKeyData);
return result;
}
if ((result = get_slot(hContext, hWrappingKey, &parentSlot))) {
free(*prgbKeyData);
return result;
}
if (pAuth) {
if ((result = auth_mgr_check(hContext, &pAuth->AuthHandle))) {
free(*prgbKeyData);
return result;
}
}
if ((result = tpm_rqu_build(TPM_ORD_CMK_CreateKey, &offset, txBlob,
parentSlot, &KeyUsageAuth, *keyDataSize, *prgbKeyData,
&MigAuthApproval, &MigAuthorityDigest, pAuth))) {
free(*prgbKeyData);
goto done;
}
free(*prgbKeyData);
if ((result = req_mgr_submit_req(txBlob)))
goto done;
result = UnloadBlob_Header(txBlob, ¶mSize);
if (!result) {
result = tpm_rsp_parse(TPM_ORD_CMK_CreateKey, txBlob, paramSize,
keyDataSize, prgbKeyData, pAuth);
}
LogResult("CMK_SetRestrictions", result);
done:
auth_mgr_release_auth(pAuth, NULL, hContext);
return result;
}
void CBenchMarker::RunL()
{
iTest.Printf(_L("Starting CntModel benchmarks...\n")); // This forces the console to get loaded under WINS - would otherwise scew profiles.
for (TInt i=0;i<ENumTests;++i)
{
StartProfile();
TInt timeMinorNumber=0;
TRAPD(err,timeMinorNumber=DoTestL(TTest(i)));
if (err)
{
iLog->LogLine(_L("Test %d left with %d"),i,err);
break;
}
LogResult(i,timeMinorNumber,KTimeProfileFormat,EndProfile());
User::CompressAllHeaps();
TMemoryInfoV1Buf memoryBuf;
UserHal::MemoryInfo(memoryBuf);
TMemoryInfoV1 memory(memoryBuf());
const TInt totalK=memory.iTotalRamInBytes>>10;
const TInt freeK=memory.iFreeRamInBytes>>10;
const TInt usedK=totalK-freeK;
LogResult(i,timeMinorNumber+1,KSystemMemoryFormat,usedK);
TInt allocSize;
User::Heap().AllocSize(allocSize);;
allocSize>>=10;
LogResult(i,timeMinorNumber+2,KThreadMemoryFormat,allocSize);
}
iTest.Printf(_L("Dump log to comm port? (y/n) "));
TKeyCode key=iTest.Getch();
if (key=='y' || key=='Y')
{
writelog:
iLog->WriteLogToCommPortL();
}
iTest.Printf(_L("\nAgain? (y/n)"));
key=iTest.Getch();
if (key=='y' || key=='Y')
{
goto writelog;
}
}
TSS_RESULT
TCSP_Seal_Internal(UINT32 sealOrdinal, /* in */
TCS_CONTEXT_HANDLE hContext, /* in */
TCS_KEY_HANDLE keyHandle, /* in */
TCPA_ENCAUTH encAuth, /* in */
UINT32 pcrInfoSize, /* in */
BYTE * PcrInfo, /* in */
UINT32 inDataSize, /* in */
BYTE * inData, /* in */
TPM_AUTH * pubAuth, /* in, out */
UINT32 * SealedDataSize, /* out */
BYTE ** SealedData) /* out */
{
UINT64 offset = 0;
TSS_RESULT result;
UINT32 paramSize;
TCPA_KEY_HANDLE keySlot;
BYTE txBlob[TSS_TPM_TXBLOB_SIZE];
LogDebug("Entering Seal");
if (!pubAuth)
return TCSERR(TSS_E_BAD_PARAMETER);
if ((result = ctx_verify_context(hContext)))
goto done;
if ((result = auth_mgr_check(hContext, &pubAuth->AuthHandle)))
goto done;
if ((result = ensureKeyIsLoaded(hContext, keyHandle, &keySlot)))
goto done;
/* XXX What's this check for? */
if (keySlot == 0) {
result = TCSERR(TSS_E_FAIL);
goto done;
}
if ((result = tpm_rqu_build(sealOrdinal, &offset, txBlob, keySlot, encAuth.authdata,
pcrInfoSize, PcrInfo, inDataSize, inData, pubAuth)))
return result;
if ((result = req_mgr_submit_req(txBlob)))
goto done;
offset = 10;
result = UnloadBlob_Header(txBlob, ¶mSize);
if (!result) {
result = tpm_rsp_parse(sealOrdinal, txBlob, paramSize, SealedDataSize,
SealedData, pubAuth);
}
LogResult("Seal", result);
done:
auth_mgr_release_auth(pubAuth, NULL, hContext);
return result;
}
TSS_RESULT
TCSP_CMK_ConvertMigration_Internal(TCS_CONTEXT_HANDLE hContext, /* in */
TCS_KEY_HANDLE parentHandle, /* in */
TPM_CMK_AUTH restrictTicket, /* in */
TPM_HMAC sigTicket, /* in */
UINT32 keyDataSize, /* in */
BYTE* prgbKeyData, /* in */
UINT32 msaListSize, /* in */
BYTE* msaList, /* in */
UINT32 randomSize, /* in */
BYTE* random, /* in */
TPM_AUTH* parentAuth, /* in, out */
UINT32* outDataSize, /* out */
BYTE** outData) /* out */
{
TSS_RESULT result;
UINT64 offset = 0;
UINT32 paramSize;
UINT32 parentSlot;
BYTE txBlob[TSS_TPM_TXBLOB_SIZE];
LogDebugFn("Enter");
if ((result = ctx_verify_context(hContext)))
return result;
if ((result = get_slot(hContext, parentHandle, &parentSlot)))
return result;
if (parentAuth) {
if ((result = auth_mgr_check(hContext, &parentAuth->AuthHandle)))
return result;
}
if ((result = tpm_rqu_build(TPM_ORD_CMK_ConvertMigration, &offset, txBlob,
parentSlot, &restrictTicket, &sigTicket,
keyDataSize, prgbKeyData, msaListSize, msaList,
randomSize, random, parentAuth)))
goto done;
if ((result = req_mgr_submit_req(txBlob)))
goto done;
result = UnloadBlob_Header(txBlob, ¶mSize);
if (!result) {
result = tpm_rsp_parse(TPM_ORD_CMK_ConvertMigration, txBlob, paramSize,
outDataSize, outData, parentAuth, NULL);
}
LogResult("CMK_SetRestrictions", result);
done:
auth_mgr_release_auth(parentAuth, NULL, hContext);
return result;
}
TSS_RESULT
TCSP_Quote2_Internal(TCS_CONTEXT_HANDLE hContext, /* in */
TCS_KEY_HANDLE keyHandle, /* in */
TCPA_NONCE antiReplay, /* in */
UINT32 pcrDataSizeIn, /* in */
BYTE * pcrDataIn, /* in */
TSS_BOOL addVersion, /* in */
TPM_AUTH * privAuth, /* in, out */
UINT32 * pcrDataSizeOut, /* out */
BYTE ** pcrDataOut, /* out */
UINT32 * versionInfoSize, /* out */
BYTE ** versionInfo, /* out */
UINT32 * sigSize, /* out */
BYTE ** sig) /* out */
{
UINT64 offset = 0;
UINT32 paramSize;
TSS_RESULT result;
UINT32 keySlot;
/* Command packet to be sent to the TPM */
BYTE txBlob[TSS_TPM_TXBLOB_SIZE];
LogDebug("Entering quote2");
if ((result = ctx_verify_context(hContext)))
goto done;
if (privAuth != NULL) {
LogDebug("Auth Used");
if ((result = auth_mgr_check(hContext, &privAuth->AuthHandle)))
goto done;
} else {
LogDebug("No Auth");
}
if ((result = ensureKeyIsLoaded(hContext, keyHandle, &keySlot)))
goto done;
if ((result = tpm_rqu_build(TPM_ORD_Quote2, &offset, txBlob, keySlot, antiReplay.nonce,
pcrDataSizeIn, pcrDataIn, &addVersion, privAuth)))
goto done;
if ((result = req_mgr_submit_req(txBlob)))
goto done;
result = UnloadBlob_Header(txBlob, ¶mSize);
if (!result) {
result = tpm_rsp_parse(TPM_ORD_Quote2, txBlob, paramSize, pcrDataSizeOut,
pcrDataOut, &addVersion, versionInfoSize, versionInfo,
sigSize, sig, privAuth);
}
LogResult("Quote2", result);
done:
auth_mgr_release_auth(privAuth, NULL, hContext);
return result;
}
GUID Str2GUID( __in const std::wstring& source )
{
GUID dest;
static_assert( sizeof( GUID ) == sizeof( CLSID ), "GUID is not the samesize as a CLSID" );
HRESULT hr = CLSIDFromString(source.c_str(), (LPCLSID)&dest);
if ( FAILED( hr ) ) {
LogResult(hr, "CLSIDFromString(%ls) Failed.", source );
throw hr;
}
return dest;
}
int main()
{
// Case #0
int case_zero_result = FindPath(0, 0, 3, 2, gCaseZeroMap, 4, 3, gCaseZeroBuffer, gCaseZeroBufferSize);
LogResult(4 * 0 + 0, case_zero_result, gCaseZeroBuffer);
// Case #1
int case_one_result = FindPath(2, 0, 0, 2, gCaseOneMap, 3, 3, gCaseOneBuffer, gCaseOneBufferSize);
LogResult(3 * 0 + 2, case_one_result, gCaseOneBuffer);
// Case #2 - test with a larger map
int result = FindPath(0, 0, 4, 5, gLargerMap, 5, 6, gLargerBuffer, gLargerBufferSize);
LogResult(0, result, gLargerBuffer);
// Case #3 - map with only one available path, but we can't move diagonally so it is invalid
int one_available_result = FindPath(0, 0, 1, 1, gOneAvailableMap, 2, 2, gOneAvialableBuffer, gOneAvailableBufferSize);
LogResult(0, one_available_result, gOneAvialableBuffer);
// Case #4 - output buffer is too small to hold the output buffer
int small_buffer_result = FindPath(0, 0, 3, 3, gSmallBufferMap, 4, 4, gSmallBufferBuffer, gSmallBufferBufferSize);
LogResult(0, small_buffer_result, gSmallBufferBuffer);
// Case #5 - huge map
int huge_map_result = FindPath(0, 0, 0, 19, gHugeMap, 20, 20, gHugeBuffer, gHugeBufferSize);
LogResult(0, huge_map_result, gHugeBuffer);
return 0;
}
GUID Inf2ClassGUID( __inout std::wstring& pathName, __out std::wstring& classStr ) {
GUID ClassGUID;
wchar_t ClassName[1+MAX_CLASS_NAME_LEN];
std::vector< wchar_t > InfPath( 0 );
DWORD pathSize = MAX_PATH;
ClassName[MAX_CLASS_NAME_LEN] = L'\0';
while ( pathSize > InfPath.size() ) {
InfPath.resize( 1 + pathSize );
pathSize = GetFullPathName(pathName.c_str(), static_cast<DWORD>(InfPath.size()) ,&InfPath[0], NULL);
if ( 0 == pathSize ) {
HRESULT hr = HRESULT_FROM_WIN32( GetLastError() );
LogResult( hr, "GetFullPathName('%ls') Failed", pathName.c_str() );
throw hr;
}
}
//
// Use the INF File to extract the Class GUID.
//
if (!SetupDiGetINFClassW(&InfPath[0],&ClassGUID,ClassName,sizeof(ClassName)/sizeof(ClassName[0]),0))
{
HRESULT hr = HRESULT_FROM_WIN32( GetLastError() );
LogResult( hr, "SetupDiGetINFClass('%ls') Failed", &InfPath[0] );
throw hr;
}
pathName = &InfPath[0];
classStr = ClassName;
return ClassGUID;
} //GUID Inf2ClassGUID( __in const std::wstring& pathName )
TSS_RESULT
TCSP_Sign_Internal(TCS_CONTEXT_HANDLE hContext, /* in */
TCS_KEY_HANDLE keyHandle, /* in */
UINT32 areaToSignSize, /* in */
BYTE * areaToSign, /* in */
TPM_AUTH * privAuth, /* in, out */
UINT32 * sigSize, /* out */
BYTE ** sig /* out */
)
{
UINT64 offset = 0;
UINT32 paramSize;
TSS_RESULT result;
TCPA_KEY_HANDLE keySlot;
BYTE txBlob[TSS_TPM_TXBLOB_SIZE];
LogDebug("Entering Sign");
if ((result = ctx_verify_context(hContext)))
return result;
if (privAuth != NULL) {
LogDebug("Auth Used");
if ((result = auth_mgr_check(hContext, &privAuth->AuthHandle)))
goto done;
} else {
LogDebug("No Auth");
}
if ((result = ensureKeyIsLoaded(hContext, keyHandle, &keySlot)))
goto done;
if ((result = tpm_rqu_build(TPM_ORD_Sign, &offset, txBlob, keySlot, areaToSignSize,
areaToSign, privAuth)))
return result;
if ((result = req_mgr_submit_req(txBlob)))
goto done;
result = UnloadBlob_Header(txBlob, ¶mSize);
if (!result) {
result = tpm_rsp_parse(TPM_ORD_Sign, txBlob, paramSize, sigSize, sig, privAuth,
NULL);
}
LogResult("sign", result);
done:
auth_mgr_release_auth(privAuth, NULL, hContext);
return result;
}
TSS_RESULT
TCSP_CMK_CreateTicket_Internal(TCS_CONTEXT_HANDLE hContext, /* in */
UINT32 PublicVerifyKeySize, /* in */
BYTE* PublicVerifyKey, /* in */
TPM_DIGEST SignedData, /* in */
UINT32 SigValueSize, /* in */
BYTE* SigValue, /* in */
TPM_AUTH* pOwnerAuth, /* in, out */
TPM_HMAC* SigTicket) /* out */
{
TSS_RESULT result;
UINT64 offset = 0;
UINT32 paramSize;
BYTE txBlob[TSS_TPM_TXBLOB_SIZE];
LogDebugFn("Enter");
if ((result = ctx_verify_context(hContext)))
return result;
if ((result = auth_mgr_check(hContext, &pOwnerAuth->AuthHandle)))
return result;
if ((result = tpm_rqu_build(TPM_ORD_CMK_CreateTicket, &offset, txBlob,
PublicVerifyKeySize, PublicVerifyKey, &SignedData,
SigValueSize, SigValue, pOwnerAuth)))
goto done;
if ((result = req_mgr_submit_req(txBlob)))
goto done;
result = UnloadBlob_Header(txBlob, ¶mSize);
if (!result) {
result = tpm_rsp_parse(TPM_ORD_CMK_CreateTicket, txBlob, paramSize,
SigTicket, pOwnerAuth);
}
LogResult("CMK_SetRestrictions", result);
done:
auth_mgr_release_auth(pOwnerAuth, NULL, hContext);
return result;
}
TSS_RESULT
TCSP_CMK_ApproveMA_Internal(TCS_CONTEXT_HANDLE hContext, /* in */
TPM_DIGEST migAuthorityDigest, /* in */
TPM_AUTH* ownerAuth, /* in, out */
TPM_HMAC* HmacMigAuthDigest) /* out */
{
TSS_RESULT result;
UINT64 offset = 0;
UINT32 paramSize;
BYTE txBlob[TSS_TPM_TXBLOB_SIZE];
LogDebugFn("Enter");
if ((result = ctx_verify_context(hContext)))
return result;
if ((result = auth_mgr_check(hContext, &ownerAuth->AuthHandle)))
return result;
if ((result = tpm_rqu_build(TPM_ORD_CMK_ApproveMA, &offset, txBlob,
&migAuthorityDigest, ownerAuth)))
goto done;
if ((result = req_mgr_submit_req(txBlob)))
goto done;
result = UnloadBlob_Header(txBlob, ¶mSize);
if (!result) {
result = tpm_rsp_parse(TPM_ORD_CMK_ApproveMA, txBlob, paramSize,
HmacMigAuthDigest, ownerAuth);
}
LogResult("CMK_SetRestrictions", result);
done:
auth_mgr_release_auth(ownerAuth, NULL, hContext);
return result;
}
TSS_RESULT
TCSP_GetCapabilityOwner_Internal(TCS_CONTEXT_HANDLE hContext, /* in */
TPM_AUTH * pOwnerAuth, /* in / out */
TCPA_VERSION * pVersion, /* out */
UINT32 * pNonVolatileFlags, /* out */
UINT32 * pVolatileFlags) /* out */
{
UINT64 offset = 0;
TSS_RESULT result;
UINT32 paramSize;
BYTE txBlob[TSS_TPM_TXBLOB_SIZE];
LogDebug("Entering Getcap owner");
if ((result = ctx_verify_context(hContext)))
goto done;
if ((result = auth_mgr_check(hContext, &pOwnerAuth->AuthHandle)))
goto done;
if ((result = tpm_rqu_build(TPM_ORD_GetCapabilityOwner, &offset, txBlob, pOwnerAuth)))
goto done;
if ((result = req_mgr_submit_req(txBlob)))
goto done;
result = UnloadBlob_Header(txBlob, ¶mSize);
if (!result) {
result = tpm_rsp_parse(TPM_ORD_GetCapabilityOwner, txBlob, paramSize, pVersion,
pNonVolatileFlags, pVolatileFlags, pOwnerAuth);
}
LogResult("GetCapowner", result);
done:
auth_mgr_release_auth(pOwnerAuth, NULL, hContext);
return result;
}
TSS_RESULT
TCSP_TakeOwnership_Internal(TCS_CONTEXT_HANDLE hContext, /* in */
UINT16 protocolID, /* in */
UINT32 encOwnerAuthSize, /* in */
BYTE * encOwnerAuth, /* in */
UINT32 encSrkAuthSize, /* in */
BYTE * encSrkAuth, /* in */
UINT32 srkInfoSize, /*in */
BYTE * srkInfo, /*in */
TPM_AUTH * ownerAuth, /* in, out */
UINT32 * srkKeySize, /*out */
BYTE ** srkKey) /*out */
{
UINT64 offset;
UINT32 paramSize;
TSS_RESULT result;
TSS_KEY srkKeyContainer;
BYTE fake_pubkey[256] = { 0, }, fake_srk[2048] = { 0, };
BYTE oldAuthDataUsage;
BYTE txBlob[TSS_TPM_TXBLOB_SIZE];
if ((result = ctx_verify_context(hContext)))
goto done;
if ((result = auth_mgr_check(hContext, &ownerAuth->AuthHandle)))
goto done;
/* Check on the Atmel Bug Patch */
offset = 0;
UnloadBlob_TSS_KEY(&offset, srkInfo, &srkKeyContainer);
oldAuthDataUsage = srkKeyContainer.authDataUsage;
LogDebug("auth data usage is %.2X", oldAuthDataUsage);
offset = 0;
if ((result = tpm_rqu_build(TPM_ORD_TakeOwnership, &offset, txBlob, protocolID,
encOwnerAuthSize, encOwnerAuth, encSrkAuthSize, encSrkAuth,
srkInfoSize, srkInfo, ownerAuth)))
return result;
if ((result = req_mgr_submit_req(txBlob)))
goto done;
result = UnloadBlob_Header(txBlob, ¶mSize);
if (!result) {
if ((result = tpm_rsp_parse(TPM_ORD_TakeOwnership, txBlob, paramSize, srkKeySize,
srkKey, ownerAuth)))
goto done;
offset = 0;
if ((result = UnloadBlob_TSS_KEY(&offset, *srkKey, &srkKeyContainer))) {
*srkKeySize = 0;
free(*srkKey);
goto done;
}
if (srkKeyContainer.authDataUsage != oldAuthDataUsage) {
LogDebug("AuthDataUsage was changed by TPM. Atmel Bug. Fixing it in PS");
srkKeyContainer.authDataUsage = oldAuthDataUsage;
}
#ifdef TSS_BUILD_PS
{
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;
}
#endif
if ((result = mc_add_entry_init(SRK_TPM_HANDLE, SRK_TPM_HANDLE, &srkKeyContainer,
&SRK_UUID))) {
destroy_key_refs(&srkKeyContainer);
LogError("Error creating SRK mem cache entry");
*srkKeySize = 0;
free(*srkKey);
}
destroy_key_refs(&srkKeyContainer);
}
LogResult("TakeOwnership", result);
done:
auth_mgr_release_auth(ownerAuth, NULL, hContext);
return result;
}
GUID ClassName2GUID( __in const std::wstring& ClassName ) {
GUID ClassGUID;
HRESULT hr = E_FAIL;
if ( ClassName.empty() ) {
throw std::runtime_error( "Unable to convert empty string from class name to GUID" );
}
AutoCloseHKey hKeyClass, hKey;
LONG lResult = RegOpenKeyEx( HKEY_LOCAL_MACHINE, TEXT("SYSTEM\\CurrentControlSet\\Control\\Class"),
0, KEY_ENUMERATE_SUB_KEYS, hKeyClass );
if ( ERROR_SUCCESS != lResult ) {
// Couldn't open the Class key to find key names underneath.
hr = HRESULT_FROM_WIN32( lResult );
LogResult( hr, "Unable to open Registry Key HKLM\\SYSTEM\\CurrentControlSet\\Control\\Class" );
throw hr;
}
BOOL found = FALSE;
wchar_t buffer[MAX_PATH];
DWORD bufferSize = 0;
for ( DWORD i = 0; FAILED(hr); ++i ) {
bufferSize = MAX_PATH; // size of subkeyName in characters (not bytes)
lResult = RegEnumKeyExW( hKeyClass, i, buffer, &bufferSize, NULL, NULL, NULL, NULL );
if ( ERROR_SUCCESS != lResult ) {
hr = HRESULT_FROM_WIN32( lResult );
if ( ERROR_NO_MORE_ITEMS == lResult ) {
LogResult( hr, "Class name not found in registry." );
throw hr;
} else {
LogResult( hr, "RegEnumKeyEx() Failed." );
throw hr;
}
}
lResult = RegOpenKeyExW( hKeyClass, buffer, 0, KEY_QUERY_VALUE, hKey );
if ( ERROR_SUCCESS != lResult ) {
hr = HRESULT_FROM_WIN32( lResult );
LogResult( hr, "Registry key '%ls' could not be opened.", buffer );
} else {
wchar_t classBuffer[MAX_PATH];
DWORD classSize = sizeof(classBuffer); // size in bytes (not characters)
DWORD dataType = REG_SZ;
lResult = RegQueryValueExW( hKey, L"Class", NULL, &dataType,
(LPBYTE)classBuffer, &classSize );
if ( ERROR_SUCCESS == lResult
&& REG_SZ == dataType
&& 0 == _wcsicmp( classBuffer, ClassName.c_str() )
) {
try
{
ClassGUID = Str2GUID( buffer );
hr = S_OK;
}
catch( HRESULT err)
{
hr = err;
}
}
hKey.Close();
}
} // FOR loop incrementing i.
if ( FAILED( hr ) ) {
LogResult( hr, "Unable to find class GUID by name" );
}
return ClassGUID;
} // ClassName2GUID
TInt CBenchMarker::DoTestL(TTest aTest)
{
TInt timeMinorNumber=0;
iLog->Log(_L("Test #%d "),aTest);
TPtrC match;
switch (aTest)
{
case EOpenNewDb:
iLog->LogLine(_L("Open new database"));
if (iNoDataGenerationTests)
{
iDb=CContactDatabase::OpenL(iDbFileName);
}
else
{
iDb=CContactDatabase::ReplaceL(iDbFileName);
LogResult(aTest,0,KFileSizeText,DbFileSize());
timeMinorNumber=1;
}
iGenerator->SetDbL(*iDb);
break;
case ECreateSecondaryClients:
iLog->LogLine(_L("Create %d secondary client threads"),KNumSecondaryClients);
CreateSecondaryClients();
break;
case EAddContacts:
iLog->LogLine(_L("Add %d typical and %d atypical contacts"),iNumTypicalContacts,iNumAtypicalContacts);
if (!iNoDataGenerationTests)
{
LogResult(aTest,0,KAverageTimeText,AddContactsL());
LogResult(aTest,1,KFileSizeText,DbFileSize());
timeMinorNumber=2;
}
break;
case ECompactDb:
iLog->LogLine(_L("Compact database"));
if (!iNoDataGenerationTests)
{
iDb->CompactL();
LogResult(aTest,0,KFileSizeText,DbFileSize());
timeMinorNumber=1;
}
break;
case EAddAndCompact:
iLog->LogLine(_L("Add %d typical and %d atypical contacts (compact after each)"),iNumTypicalContactsCompact,iNumAtypicalContactsCompact);
if (!iNoDataGenerationTests)
{
LogResult(aTest,0,KAverageTimeText,AddContactsCompactL());
LogResult(aTest,1,KFileSizeText,DbFileSize());
timeMinorNumber=2;
}
break;
case EGetSortedItems:
iLog->LogLine(_L("Get sorted id array by firstname, lastname, company name"));
DoSortL();
break;
case ELogContactSummary:
iLog->LogLine(_L("Log contact summary"));
LogContactSummaryL(EFalse);
break;
case ELogContactSummaryFast:
iLog->LogLine(_L("Log contact summary using TContactTextDefItem"));
LogContactSummaryL(ETrue);
break;
case EOpenRContactView:
iLog->LogLine(_L("Open RContactView"));
OpenRContactViewL();
break;
case ESetSortOrderOfRContactView:
iLog->LogLine(_L("Set order of RContactView"));
SetSortOrderOfRContactViewL();
break;
case EGetSortOrderOfRContactView:
iLog->LogLine(_L("Get order of RContactView"));
GetSortOrderOfRContactViewL();
break;
case ELogContactSummaryWithRContactView:
iLog->LogLine(_L("Log contact summary using RContactView"));
LogContactSummaryFromRContactViewL(EFalse);
break;
case ELogContactSummaryFastWithRContactView:
iLog->LogLine(_L("Log contact summary using RContactView and TContactTextDefItem"));
LogContactSummaryFromRContactViewL(ETrue);
break;
case EFindWithRContactView:
iLog->LogLine(_L("Find TContactItemId from RContactView"));
FindInRContactViewL();
break;
case ECloseRContactView:
iLog->LogLine(_L("Close RContactView"));
#ifdef __USE_NEW_INTERFACES
iSortedIdList.Close();
#endif
break;
case EFindFromLargeFieldSetSuceed:
match.Set(iGenerator->NameMatch());
iLog->LogLine(_L("FindLC %S using large field set (will suceed)"),&match);
FindFromLargeFieldSetL(match);
break;
case EFindFromLargeFieldSetFail:
iLog->LogLine(_L("FindLC %S using large field set (will fail)"),&KNameMatchFail);
FindFromLargeFieldSetL(KNameMatchFail);
break;
case EFindFromSmallFieldSetSuceed:
match.Set(iGenerator->NameMatch());
iLog->LogLine(_L("FindLC %S using small field set (will suceed)"),&match);
FindFromSmallFieldSetL(match);
break;
case EFindFromSmallFieldSetFail:
iLog->LogLine(_L("FindLC %S using small field set (will fail)"),&KNameMatchFail);
FindFromSmallFieldSetL(KNameMatchFail);
break;
case EFindPhoneNumberSuceed:
match.Set(iGenerator->PhoneMatch());
iLog->LogLine(_L("FindLC %S using just phone field (will suceed)"),&match);
FindPhoneNumberL(match);
break;
case EFindPhoneNumberFail:
iLog->LogLine(_L("FindLC %S using just phone field (will fail)"),&KPhoneMatchFail);
FindPhoneNumberL(KPhoneMatchFail);
break;
case EFindEmailAddressSuceed:
match.Set(iGenerator->EmailMatch());
iLog->LogLine(_L("FindLC %S using just email field (will suceed)"),&match);
FindEmailAddressL(match);
break;
case EFindEmailAddressFail:
iLog->LogLine(_L("FindLC %S using just email field (will fail)"),&KNameMatchFail);
FindEmailAddressL(KNameMatchFail);
break;
case EFindAsyncFromLargeFieldSet:
iLog->LogLine(_L("FindAsyncL %S using large field set"),&KAsyncFindMatch);
FindAsyncFromLargeFieldSetL(KAsyncFindMatch);
break;
case EFindAsyncFromSmallFieldSet:
iLog->LogLine(_L("FindAsyncL %S using small field set"),&KAsyncFindMatch);
FindAsyncFromSmallFieldSetL(KAsyncFindMatch);
break;
case ECloseDb:
iLog->LogLine(_L("Close database"));
delete iDb;
iDb=NULL;
break;
case ECloseSecondaryClients:
iLog->LogLine(_L("Close secondary clients"));
CloseSecondaryClients();
break;
case EOpenExistingDb:
iLog->LogLine(_L("Open existing database"));
iDb=CContactDatabase::OpenL(iDbFileName);
break;
case EMultiClientSort:
iLog->LogLine(_L("%d client simultaneous sort"),KNumSortClients);
CreateSortClients();
break;
case ENumTests:
ASSERT(EFalse);
break;
}
return timeMinorNumber;
}
TSS_RESULT
TCSP_CMK_CreateBlob_Internal(TCS_CONTEXT_HANDLE hContext, /* in */
TCS_KEY_HANDLE parentHandle, /* in */
TSS_MIGRATE_SCHEME migrationType, /* in */
UINT32 MigrationKeyAuthSize, /* in */
BYTE* MigrationKeyAuth, /* in */
TPM_DIGEST PubSourceKeyDigest, /* in */
UINT32 msaListSize, /* in */
BYTE* msaList, /* in */
UINT32 restrictTicketSize, /* in */
BYTE* restrictTicket, /* in */
UINT32 sigTicketSize, /* in */
BYTE* sigTicket, /* in */
UINT32 encDataSize, /* in */
BYTE* encData, /* in */
TPM_AUTH* parentAuth, /* in, out */
UINT32* randomSize, /* out */
BYTE** random, /* out */
UINT32* outDataSize, /* out */
BYTE** outData) /* out */
{
TSS_RESULT result;
UINT64 offset = 0;
UINT32 paramSize;
UINT32 parentSlot;
BYTE txBlob[TSS_TPM_TXBLOB_SIZE];
LogDebugFn("Enter");
if ((result = ctx_verify_context(hContext)))
return result;
if ((result = get_slot(hContext, parentHandle, &parentSlot)))
return result;
if (parentAuth) {
if ((result = auth_mgr_check(hContext, &parentAuth->AuthHandle)))
return result;
}
if ((result = tpm_rqu_build(TPM_ORD_CMK_CreateBlob, &offset, txBlob,
parentSlot, migrationType, MigrationKeyAuthSize,
MigrationKeyAuth, &PubSourceKeyDigest, msaListSize, msaList,
restrictTicketSize, restrictTicket, sigTicketSize, sigTicket,
encDataSize, encData, parentAuth)))
goto done;
if ((result = req_mgr_submit_req(txBlob)))
goto done;
result = UnloadBlob_Header(txBlob, ¶mSize);
if (!result) {
result = tpm_rsp_parse(TPM_ORD_CMK_CreateBlob, txBlob, paramSize,
randomSize, random, outDataSize, outData, parentAuth, NULL);
}
LogResult("CMK_SetRestrictions", result);
done:
auth_mgr_release_auth(parentAuth, NULL, hContext);
return result;
}
TSS_RESULT
TCSP_CertifyKey_Internal(TCS_CONTEXT_HANDLE hContext, /* in */
TCS_KEY_HANDLE certHandle, /* in */
TCS_KEY_HANDLE keyHandle, /* in */
TCPA_NONCE antiReplay, /* in */
TPM_AUTH * certAuth, /* in, out */
TPM_AUTH * keyAuth, /* in, out */
UINT32 * CertifyInfoSize, /* out */
BYTE ** CertifyInfo, /* out */
UINT32 * outDataSize, /* out */
BYTE ** outData) /* out */
{
UINT64 offset = 0;
UINT32 paramSize;
TSS_RESULT result;
TCPA_KEY_HANDLE certKeySlot, keySlot;
BYTE txBlob[TSS_TPM_TXBLOB_SIZE];
LogDebug("Entering Certify Key");
if ((result = ctx_verify_context(hContext)))
goto done;
if (certAuth != NULL) {
LogDebug("Auth Used for Cert signing key");
if ((result = auth_mgr_check(hContext, &certAuth->AuthHandle)))
goto done;
} else {
LogDebug("No Auth used for Cert signing key");
}
if (keyAuth != NULL) {
LogDebug("Auth Used for Key being signed");
if ((result = auth_mgr_check(hContext, &keyAuth->AuthHandle)))
goto done;
} else {
LogDebug("No Auth used for Key being signed");
}
if ((result = ensureKeyIsLoaded(hContext, certHandle, &certKeySlot)))
goto done;
if ((result = ensureKeyIsLoaded(hContext, keyHandle, &keySlot)))
goto done;
if ((result = tpm_rqu_build(TPM_ORD_CertifyKey, &offset, txBlob, certKeySlot, keySlot,
antiReplay.nonce, certAuth, keyAuth)))
goto done;
if ((result = req_mgr_submit_req(txBlob)))
goto done;
result = UnloadBlob_Header(txBlob, ¶mSize);
if (!result) {
result = tpm_rsp_parse(TPM_ORD_CertifyKey, txBlob, paramSize, CertifyInfoSize,
CertifyInfo, outDataSize, outData, certAuth, keyAuth);
}
LogResult("Certify Key", result);
done:
auth_mgr_release_auth(certAuth, keyAuth, hContext);
return result;
}
TSS_RESULT
TCSP_Unseal_Internal(TCS_CONTEXT_HANDLE hContext, /* in */
TCS_KEY_HANDLE parentHandle, /* in */
UINT32 SealedDataSize, /* in */
BYTE * SealedData, /* in */
TPM_AUTH * parentAuth, /* in, out */
TPM_AUTH * dataAuth, /* in, out */
UINT32 * DataSize, /* out */
BYTE ** Data) /* out */
{
UINT64 offset = 0;
UINT32 paramSize;
TSS_RESULT result;
TCPA_KEY_HANDLE keySlot;
BYTE txBlob[TSS_TPM_TXBLOB_SIZE];
LogDebug("Entering Unseal");
if (dataAuth == NULL)
return TCSERR(TSS_E_BAD_PARAMETER);
if ((result = ctx_verify_context(hContext)))
goto done;
if (parentAuth != NULL) {
LogDebug("Auth used");
if ((result = auth_mgr_check(hContext, &parentAuth->AuthHandle)))
goto done;
} else {
LogDebug("No Auth");
}
if ((result = auth_mgr_check(hContext, &dataAuth->AuthHandle)))
goto done;
if ((result = ensureKeyIsLoaded(hContext, parentHandle, &keySlot)))
goto done;
/* XXX What's this check for? */
if (keySlot == 0) {
result = TCSERR(TSS_E_FAIL);
goto done;
}
if ((result = tpm_rqu_build(TPM_ORD_Unseal, &offset, txBlob, keySlot, SealedDataSize,
SealedData, parentAuth, dataAuth)))
return result;
if ((result = req_mgr_submit_req(txBlob)))
goto done;
offset = 10;
result = UnloadBlob_Header(txBlob, ¶mSize);
if (!result) {
result = tpm_rsp_parse(TPM_ORD_Unseal, txBlob, paramSize, DataSize, Data,
parentAuth, dataAuth);
}
LogResult("Unseal", result);
done:
auth_mgr_release_auth(parentAuth, dataAuth, hContext);
return result;
}
/*
* Logs that the testharness was unable to read or parse the testconfig.dat
*/
void LogConfigFileError(FILE* ResultsFile, char* path)
{
LogResult(ResultsFile, SZ_BLANKDATA, SZ_BLANKDATA,
SZ_BLANKDATA, UNKNOWN_TYPE, path,
"CONFIG", "HARNESS: Error in the testconfig.dat file.", 0);
}
BOOL roadmap_thread_run ( RMThreadFunc func, void* context, RMThreadPriority priority, const char* name, BOOL separate_thread )
{
pthread_t thread_id;
if ( separate_thread )
{
struct sched_param params;
pthread_attr_t attr;
int retVal;
RMThreadContext* thread_context;
/*
int min_priority;
int cur_priority;
int cur_policy;
retVal = pthread_getschedparam( pthread_self(), &cur_policy, &cur_param );
LogResult( retVal, "pthread_getschedparam. ", ROADMAP_ERROR );
min_priority = sched_get_priority_min( cur_policy );
LogResult( retVal, "sched_get_priority_min. ", ROADMAP_ERROR );
cur_priority = cur_param.sched_priority;
cur_param.sched_priority = min_priority;
pthread_attr_init ( &attr );
LogResult( retVal, "pthread_attr_init. ", ROADMAP_ERROR );
pthread_attr_setschedparam( &attr, &cur_param );
LogResult( retVal, "pthread_attr_setschedparam. ", ROADMAP_ERROR );
*/
/*
* Set the thread attributes to match the requested priority
*/
retVal = pthread_attr_init ( &attr );
LogResult( retVal, "pthread_attr_init. ", ROADMAP_ERROR );
params.sched_priority = android_thread_priority( priority );
retVal = pthread_attr_setschedparam( &attr, ¶ms );
LogResult( retVal, "pthread_attr_setschedparam. ", ROADMAP_ERROR );
/*
* Preparing the thread context
*/
thread_context = malloc( sizeof( RMThreadContext ) );
roadmap_check_allocated( thread_context );
thread_context->func = func;
thread_context->context = context;
/*
* Starting the thread
*/
retVal = pthread_create( &thread_id, &attr, ( void *(*)(void *) ) roadmap_thread_func_wrapper, thread_context );
LogResult( retVal, "pthread_create. ", ROADMAP_ERROR );
}
else
{
/*
* There is no async implementation meanwhile just execute synchronously
*/
func( context );
}
return TRUE;
}
/*
* Log that the testharness was unable to build the command to execute the
* test.
*/
void LogCommandLineError(FILE* ResultsFile, char* Path)
{
LogResult(ResultsFile, SZ_BLANKDATA, SZ_BLANKDATA,
SZ_BLANKDATA, UNKNOWN_TYPE, Path,
TSTPHASE_EXEC, "HARNESS: Unable to build command line", 0);
}
