static bool VerifyAuthoritySignature(const AuthorityInfo& authorityInfo, const CStdString& appsPublicKeyFile)
{
unsigned char* buffer = (unsigned char*)authorityInfo.publicKey.data();
unsigned int bufferLen = authorityInfo.publicKey.size();
unsigned char* signatureEncoded = (unsigned char*)authorityInfo.signature.c_str();
unsigned int signatureEncodedLen = authorityInfo.signature.size();
return VerifyBuffer(buffer, bufferLen, signatureEncoded, signatureEncodedLen, appsPublicKeyFile);
}
int myPutRxPkt(void * hndl, PktBuf * vaddr, int numpkts, unsigned int privdata)
{
int i, unused=0;
unsigned int flags;
//printk("Reached myPutRxPkt with handle %p, VA %x, size %d, privdata %x\n",
// hndl, (u32)vaddr, size, privdata);
/* Check driver state */
if(DriverState != REGISTERED)
{
printk("Driver does not seem to be ready\n");
return -1;
}
/* Check handle value */
if(hndl != handle[2])
{
log_normal("Came with wrong handle %x\n", (u32)hndl);
return -1;
}
spin_lock_bh(&RawLock);
for(i=0; i<numpkts; i++)
{
flags = vaddr->flags;
//printk("RX pkt flags %x\n", flags);
if(flags & PKT_UNUSED)
{
unused = 1;
break;
}
if(flags & PKT_EOP)
{
#ifdef DATA_VERIFY
VerifyBuffer((unsigned char *)(vaddr->bufInfo), (vaddr->size), (vaddr->userInfo));
#endif
RxSeqNo++;
}
RxBufCnt++;
vaddr++;
}
/* Return packet buffers to free pool */
//printk("PutRxPkt: Freeing %d packets unused %d\n", numpkts, unused);
if(unused)
FreeUnusedBuf(&RxBufs, numpkts);
else
FreeUsedBuf(&RxBufs, numpkts);
spin_unlock_bh(&RawLock);
return 0;
}
//
// TDS 5.3
//
EFI_STATUS
BBTestWriteBlocksFunctionAutoTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_BLOCK_IO_PROTOCOL *BlockIo;
UINT32 MediaId;
BOOLEAN RemovableMedia;
BOOLEAN MediaPresent;
BOOLEAN LogicalPartition;
BOOLEAN ReadOnly;
BOOLEAN WriteCaching;
UINT32 BlockSize;
UINT32 IoAlign;
EFI_LBA LastBlock;
UINTN BufferSize;
UINT8 *Buffer;
UINT8 *Buffer2;
UINT8 *Buffer3;
UINT32 BlockNumber;
UINTN IndexI, IndexJ;
UINTN NewBufferSize;
EFI_LBA NewLba;
UINTN Remainder;
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
CHAR16 *DevicePathStr;
EFI_TEST_ASSERTION AssertionTypeRead1;
EFI_TEST_ASSERTION AssertionTypeRead2;
EFI_TEST_ASSERTION AssertionTypeRead3;
EFI_TEST_ASSERTION AssertionTypeWrite1;
EFI_TEST_ASSERTION AssertionTypeWrite2;
EFI_TEST_ASSERTION AssertionTypeComp1;
EFI_TEST_ASSERTION AssertionTypeComp2;
EFI_STATUS StatusRead1;
EFI_STATUS StatusRead2;
EFI_STATUS StatusRead3;
EFI_STATUS StatusWrite1;
EFI_STATUS StatusWrite2;
UINTN CountComp1;
UINTN CountComp2;
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.HandleProtocol - Handle standard test library",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
BlockIo = (EFI_BLOCK_IO_PROTOCOL *)ClientInterface;
//
// Locate & record DevicePath for further investigation
//
LocateDevicePathFromBlockIo (BlockIo, &DevicePath, StandardLib);
DevicePathStr = DevicePathToStr (DevicePath);
if (DevicePathStr != NULL) {
StandardLib->RecordMessage (
StandardLib,
EFI_VERBOSE_LEVEL_DEFAULT,
L"Current Device: %s",
DevicePathStr
);
Status = gtBS->FreePool (DevicePathStr);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.FreePool - Free device path string",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
DevicePathStr = NULL;
}
//
// Initialize variable
//
MediaId = BlockIo->Media->MediaId;
RemovableMedia = BlockIo->Media->RemovableMedia;
MediaPresent = BlockIo->Media->MediaPresent;
LogicalPartition = BlockIo->Media->LogicalPartition;
ReadOnly = BlockIo->Media->ReadOnly;
WriteCaching = BlockIo->Media->WriteCaching;
BlockSize = BlockIo->Media->BlockSize;
IoAlign = BlockIo->Media->IoAlign;
LastBlock = BlockIo->Media->LastBlock;
BlockNumber = (UINT32) MINIMUM(LastBlock, MAX_NUMBER_OF_READ_BLOCK_BUFFER);
BufferSize = BlockNumber * BlockSize;
if (BufferSize == 0) {
BufferSize = 512;
}
//
// allocate buffer
//
Status = gtBS->AllocatePool (EfiBootServicesData, BufferSize, &Buffer);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.AllocatePool - Allocate buffer for testing",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
Status = gtBS->AllocatePool (EfiBootServicesData, BufferSize, &Buffer2);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.AllocatePool - Allocate buffer for testing",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
gtBS->FreePool (Buffer);
return Status;
}
Status = gtBS->AllocatePool (EfiBootServicesData, BufferSize, &Buffer3);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.AllocatePool - Allocate buffer for testing",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
gtBS->FreePool (Buffer);
gtBS->FreePool (Buffer2);
return Status;
}
//
// Assertion Point 5.3.2.1
// ReadBlocks must succeed to read proper data from device with valid parameter
//
if ((MediaPresent == TRUE) && (ReadOnly == FALSE)) {
for (IndexI = 1; IndexI < MAX_DIFFERENT_BUFFERSIZE_FOR_TEST; IndexI++) {
//
// prepare test data
// BufferSize will range from BlockSize to MAX_DIFFERENT_BUFFERSIZE_FOR_TEST*BlockSize
//
NewBufferSize = IndexI * BlockSize;
//
//parameter verification on NewBufferSize
//
if (NewBufferSize > BufferSize) {
break;
}
for (IndexJ = 0; IndexJ < 3 * MAX_DIFFERENT_LBA_FOR_TEST; IndexJ++) {
//
// prepare test data
//
if (IndexJ < MAX_DIFFERENT_LBA_FOR_TEST) {
// from 1 to MAX_DIFFERENT_LBA_FOR_TEST
NewLba = IndexJ;
} else if (IndexJ < 2 * MAX_DIFFERENT_LBA_FOR_TEST) {
// from (LastBlock - MAX_DIFFERENT_LBA_FOR_TEST - MAX_DIFFERENT_BUFFERSIZE_FOR_TEST) to (LastBlock - MAX_DIFFERENT_BUFFERSIZE_FOR_TEST)
NewLba = IndexJ + LastBlock - 2 * MAX_DIFFERENT_LBA_FOR_TEST - MAX_DIFFERENT_BUFFERSIZE_FOR_TEST;
} else {
// from (LastBlock/2 - MAX_DIFFERENT_LBA_FOR_TEST/2) to (LastBlock/2 + MAX_DIFFERENT_LBA_FOR_TEST/2)
NewLba = IndexJ - 2 * MAX_DIFFERENT_LBA_FOR_TEST + (DivU64x32 (LastBlock, 2, &Remainder) - MAX_DIFFERENT_LBA_FOR_TEST / 2);
}
//
//parameter verification on NewLba
//
if (NewLba + NewBufferSize / BlockSize > LastBlock + 1) {
continue;
}
//
// To avoid the LOG information is destroied, the LOG information will
// be recorded after the original data is written again.
//
//
// Call ReadBlocks with the specified LBA and BufferSize
//
StatusRead1 = BlockIo->ReadBlocks (
BlockIo,
MediaId,
NewLba,
NewBufferSize,
(VOID*)Buffer
);
if (EFI_ERROR(StatusRead1)) {
AssertionTypeRead1 = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionTypeRead1 = EFI_TEST_ASSERTION_PASSED;
}
//
// Write specified buffer2 differ from buffer to the device
//
StatusWrite1 = BlockIo->WriteBlocks (
BlockIo,
MediaId,
NewLba,
NewBufferSize,
(VOID*)Buffer2
);
if (EFI_ERROR(StatusWrite1)) {
AssertionTypeWrite1 = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionTypeWrite1 = EFI_TEST_ASSERTION_PASSED;
}
//
// if write-cached, then flush the data to physical device
//
if (WriteCaching) {
BlockIo->FlushBlocks (BlockIo);
}
//
// Read Block with same LBA and BufferSize again and save data into Buffer3
//
StatusRead2 = BlockIo->ReadBlocks (
BlockIo,
MediaId,
NewLba,
NewBufferSize,
(VOID*)Buffer3
);
if (EFI_ERROR(StatusRead2)) {
AssertionTypeRead2 = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionTypeRead2 = EFI_TEST_ASSERTION_PASSED;
}
//
// verification on Write and Read blocks on valid media
//
CountComp1 = VerifyBuffer (Buffer2, Buffer3, NewBufferSize);
if (CountComp1 > 0) {
AssertionTypeComp1 = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionTypeComp1 = EFI_TEST_ASSERTION_PASSED;
}
//
// Write buffer read in the first call of ReadBlocks back to the device
//
StatusWrite2 = BlockIo->WriteBlocks (
BlockIo,
MediaId,
NewLba,
NewBufferSize,
(VOID*)Buffer
);
if (EFI_ERROR(StatusWrite2)) {
AssertionTypeWrite2 = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionTypeWrite2 = EFI_TEST_ASSERTION_PASSED;
}
//
// if write-cached, then flush the data to physical device
//
if (WriteCaching) {
BlockIo->FlushBlocks (BlockIo);
}
//
// Read Block with same LBA and BufferSize again and save data into Buffer3
//
StatusRead3 = BlockIo->ReadBlocks (
BlockIo,
MediaId,
NewLba,
NewBufferSize,
(VOID*)Buffer3
);
if (EFI_ERROR(StatusRead3)) {
AssertionTypeRead3 = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionTypeRead3 = EFI_TEST_ASSERTION_PASSED;
}
//
// verification on first and last call of ReadBlocks
//
CountComp2 = VerifyBuffer (Buffer, Buffer3, NewBufferSize);
if (CountComp2 > 0) {
AssertionTypeComp2 = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionTypeComp2 = EFI_TEST_ASSERTION_PASSED;
}
//
// Record test results
//
StandardLib->RecordAssertion (
StandardLib,
AssertionTypeRead1,
gTestGenericFailureGuid,
L"EFI_BLOCK_IO_PROTOCOL.ReadBlocks - Read Block with proper parameter from valid media",
L"%a:%d:BufferSize=%d, Lba=0x%lx, Status=%r",
__FILE__,
__LINE__,
NewBufferSize,
NewLba,
StatusRead1
);
StandardLib->RecordAssertion (
StandardLib,
AssertionTypeWrite1,
gBlockIoFunctionTestAssertionGuid009,
L"EFI_BLOCK_IO_PROTOCOL.WriteBlocks - Write Block with proper parameter from valid media",
L"%a:%d:BufferSize=%d, Lba=0x%lx, Status=%r",
__FILE__,
__LINE__,
NewBufferSize,
NewLba,
StatusWrite1
);
StandardLib->RecordAssertion (
StandardLib,
AssertionTypeRead2,
gTestGenericFailureGuid,
L"EFI_BLOCK_IO_PROTOCOL.ReadBlocks - Read Block with proper parameter from valid media",
L"%a:%d:BufferSize=%d, Lba=0x%lx, Status=%r",
__FILE__,
__LINE__,
NewBufferSize,
NewLba,
StatusRead2
);
StandardLib->RecordAssertion (
StandardLib,
AssertionTypeComp1,
gBlockIoFunctionTestAssertionGuid012,
L"EFI_BLOCK_IO_PROTOCOL.WriteBlocks - Verification on Write and Read blocks on valid media",
L"%a:%d:BufferSize=%d, Lba=0x%lx, DiffCount=%d",
__FILE__,
__LINE__,
NewBufferSize,
NewLba,
CountComp1
);
StandardLib->RecordAssertion (
StandardLib,
AssertionTypeWrite2,
gBlockIoFunctionTestAssertionGuid013,
L"EFI_BLOCK_IO_PROTOCOL.WriteBlocks - Write Block with proper parameter back to valid media ",
L"%a:%d:BufferSize=%d, Lba=0x%lx, Status=%r",
__FILE__,
__LINE__,
NewBufferSize,
NewLba,
StatusWrite2
);
StandardLib->RecordAssertion (
StandardLib,
AssertionTypeRead3,
gTestGenericFailureGuid,
L"EFI_BLOCK_IO_PROTOCOL.ReadBlocks - Read Block with proper parameter from valid media",
L"%a:%d:BufferSize=%d, Lba=0x%lx, Status=%r",
__FILE__,
__LINE__,
NewBufferSize,
NewLba,
StatusRead3
);
StandardLib->RecordAssertion (
StandardLib,
AssertionTypeComp2,
gBlockIoFunctionTestAssertionGuid016,
L"EFI_BLOCK_IO_PROTOCOL.WriteBlocks - Verification on Write and Read blocks on valid media",
L"%a:%d:BufferSize=%d, Lba=0x%lx, DiffCount=%d",
__FILE__,
__LINE__,
NewBufferSize,
NewLba,
CountComp2
);
}//end of loop of Lba - IndexJ
}//end of loop of BufferSize - IndexI
}
//
// Free resources
//
Status = gtBS->FreePool (Buffer3);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.FreePool - Free buffer for testing",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
Status = gtBS->FreePool (Buffer2);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.FreePool - Free buffer for testing",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
Status = gtBS->FreePool (Buffer);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.FreePool - Free buffer for testing",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
return EFI_SUCCESS;
}
static bool VerifyDeviceSignature(const AppInfo& securityInfo, const CStdString& appsPublicKeyFile)
{
DeviceInfo deviceInfo;
if(!GetDeviceInfo(&deviceInfo))
{
CLog::Log(LOGERROR, "CAppSecurity::%s - failed to build device descriptor", __func__);
return false;
}
CStdString deviceDescriptor;
deviceDescriptor = deviceInfo.type;
deviceDescriptor += "&";
deviceDescriptor += deviceInfo.serial;
deviceDescriptor += "&";
deviceDescriptor += deviceInfo.mac;
deviceDescriptor += "\n";
unsigned char* buffer = (unsigned char*)deviceDescriptor.c_str();
unsigned int bufferLen = deviceDescriptor.size();
unsigned char* signature = (unsigned char*)securityInfo.signature.c_str();
unsigned int signatureLen = securityInfo.signature.size();
bool bVerified = VerifyBuffer(buffer, bufferLen, signature, signatureLen, appsPublicKeyFile);
if(!bVerified)
{
CLog::Log(LOGERROR, "CAppSecurity::%s - FAILED to verify device signature", __func__);
return false;
}
// now verify the device with server
CStdString deviceInfoRequest = SERVER_URL;
deviceInfoRequest += "getdeviceinfo/?";
deviceInfoRequest += "type=" + deviceInfo.type;
deviceInfoRequest += "&";
deviceInfoRequest += "sn=" + deviceInfo.serial;
deviceInfoRequest += "&";
deviceInfoRequest += "mac=" + deviceInfo.mac;
BOXEE::BXCurl curl;
std::string strResp = curl.HttpGetString(deviceInfoRequest, false);
TiXmlDocument xmlDoc;
BOXEE::BXXMLDocument reader;
if (strResp.empty())
{
CLog::Log(LOGERROR,"CAppSecurity::%s - Not handling server response to [deviceInfoRequest=%s] because it is empty", __func__, deviceInfoRequest.c_str());
return false;
}
if(!reader.LoadFromString(strResp))
{
CLog::Log(LOGERROR,"CAppSecurity::%s - Not handling server response to [authorityManifestURL=%s] because failed to load it to BXXMLDocument", __func__, deviceInfoRequest.c_str());
return false;
}
TiXmlElement* root = reader.GetRoot();
if(!root)
{
CLog::Log(LOGERROR,"CAppSecurity::%s - Failed to get root from BXXMLDocument of %s", __func__, deviceInfoRequest.c_str());
return false;
}
CStdString type, serial, mac, status;
while (root)
{
if(strcmp(root->Value(),"device") == 0)
{
type = root->Attribute("type");
serial = root->Attribute("sn");
mac = root->Attribute("mac");
root = root->FirstChildElement();
continue;
}
else if(strcmp(root->Value(),"status") == 0)
{
status = root->FirstChild()->Value();
}
root = root->NextSiblingElement();
}
bVerified = false;
do
{
if(type != deviceInfo.type)
{
CLog::Log(LOGERROR,"CAppSecurity::%s - Device type doesn't match [%s]![%s]", __func__, type.c_str(), deviceInfo.type.c_str());
break;
}
if(serial != deviceInfo.serial)
{
CLog::Log(LOGERROR,"CAppSecurity::%s - Device serial doesn't match [%s]![%s]", __func__, serial.c_str(), deviceInfo.serial.c_str());
break;
}
if(mac != deviceInfo.mac)
{
CLog::Log(LOGERROR,"CAppSecurity::%s - Device mac doesn't match [%s]![%s]", __func__, mac.c_str(), deviceInfo.mac.c_str());
break;
}
if(status != "open")
{
CLog::Log(LOGERROR,"CAppSecurity::%s - Device %s is locked", __func__, deviceInfo.serial.c_str());
break;
}
bVerified = true;
} while(false);
return bVerified;
}
