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; }