mirror of
https://github.com/LongSoft/UEFITool.git
synced 2024-11-22 16:08:23 +08:00
1170 lines
61 KiB
C++
1170 lines
61 KiB
C++
|
/* meparser.cpp
|
||
|
|
|
||
|
|
Copyright (c) 2016, Nikolaj Schlej. All rights reserved.
|
||
|
|
|
||
|
|
This program and the accompanying materials
|
||
|
|
are licensed and made available under the terms and conditions of the BSD License
|
||
|
|
which accompanies this distribution. The full text of the license may be found at
|
||
|
|
http://opensource.org/licenses/bsd-license.php.
|
||
|
|
|
||
|
|
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||
|
|
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||
|
|
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include <inttypes.h>
|
||
|
|
#include <map>
|
||
|
|
|
||
|
|
#include "meparser.h"
|
||
|
|
#include "parsingdata.h"
|
||
|
|
#include "utility.h"
|
||
|
|
|
||
|
|
#ifdef U_ENABLE_ME_PARSING_SUPPORT
|
||
|
|
|
||
|
|
UString meBpdtEntryTypeToUString(UINT16 type) {
|
||
|
|
switch (type) {
|
||
|
|
case 0: return UString("OEM SMIP");
|
||
|
|
case 1: return UString("CSE RBE");
|
||
|
|
case 2: return UString("CSE BUP");
|
||
|
|
case 3: return UString("uCode");
|
||
|
|
case 4: return UString("IBB");
|
||
|
|
case 5: return UString("S-BPDT");
|
||
|
|
case 6: return UString("OBB");
|
||
|
|
case 7: return UString("CSE Main");
|
||
|
|
case 8: return UString("ISH");
|
||
|
|
case 9: return UString("CSE IDLM");
|
||
|
|
case 10: return UString("IFP Override");
|
||
|
|
case 11: return UString("Debug Tokens");
|
||
|
|
case 12: return UString("USF Phy Config");
|
||
|
|
case 13: return UString("USF GPP LUN ID");
|
||
|
|
case 14: return UString("PMC");
|
||
|
|
case 15: return UString("iUnit");
|
||
|
|
case 16: return UString("NVM Config");
|
||
|
|
case 17: return UString("UEP");
|
||
|
|
case 18: return UString("WLAN uCode");
|
||
|
|
case 19: return UString("LOCL Sprites");
|
||
|
|
case 20: return UString("OEM Key Manifest");
|
||
|
|
case 21: return UString("Defaults/FITC.cfg");
|
||
|
|
case 22: return UString("PAVP");
|
||
|
|
case 23: return UString("TCSS FW IOM");
|
||
|
|
case 24: return UString("TCSS FW PHY");
|
||
|
|
case 25: return UString("TCSS TBT");
|
||
|
|
default: return usprintf("Unknown %u", type);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
UString meExtensionTypeToUstring(UINT32 type) {
|
||
|
|
switch (type) {
|
||
|
|
case 0: return UString("System Info");
|
||
|
|
case 1: return UString("Init Script");
|
||
|
|
case 2: return UString("Feature Permissions");
|
||
|
|
case 3: return UString("Partition Info");
|
||
|
|
case 4: return UString("Shared Lib Attributes");
|
||
|
|
case 5: return UString("Process Attributes");
|
||
|
|
case 6: return UString("Thread Attributes");
|
||
|
|
case 7: return UString("Device Type");
|
||
|
|
case 8: return UString("MMIO Range");
|
||
|
|
case 9: return UString("Spec File Producer");
|
||
|
|
case 10: return UString("Module Attributes");
|
||
|
|
case 11: return UString("Locked Ranges");
|
||
|
|
case 12: return UString("Client System Info");
|
||
|
|
case 13: return UString("User Info");
|
||
|
|
case 14: return UString("Key Manifest");
|
||
|
|
case 15: return UString("Signed Package Info");
|
||
|
|
case 16: return UString("Anto-cloning SKU ID");
|
||
|
|
case 18: return UString("Intel IMR Info");
|
||
|
|
case 20: return UString("RCIP Info");
|
||
|
|
case 21: return UString("Secure Token");
|
||
|
|
case 22: return UString("IFWI Partition Manifest");
|
||
|
|
default: return usprintf("Unknown %u", type);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
struct ME_FPT_PARTITION_INFO {
|
||
|
|
ME_FPT_ENTRY ptEntry;
|
||
|
|
UINT8 type;
|
||
|
|
UModelIndex index;
|
||
|
|
friend bool operator< (const ME_FPT_PARTITION_INFO & lhs, const ME_FPT_PARTITION_INFO & rhs){ return lhs.ptEntry.Offset < rhs.ptEntry.Offset; }
|
||
|
|
};
|
||
|
|
|
||
|
|
struct ME_BPDT_PARTITION_INFO {
|
||
|
|
ME_BPDT_ENTRY ptEntry;
|
||
|
|
UINT8 type;
|
||
|
|
UModelIndex index;
|
||
|
|
friend bool operator< (const ME_BPDT_PARTITION_INFO & lhs, const ME_BPDT_PARTITION_INFO & rhs){ return lhs.ptEntry.Offset < rhs.ptEntry.Offset; }
|
||
|
|
};
|
||
|
|
|
||
|
|
struct ME_CPD_PARTITION_INFO {
|
||
|
|
ME_BPDT_CPD_ENTRY ptEntry;
|
||
|
|
UINT8 type;
|
||
|
|
UModelIndex index;
|
||
|
|
friend bool operator< (const ME_CPD_PARTITION_INFO & lhs, const ME_CPD_PARTITION_INFO & rhs){ return lhs.ptEntry.Offset.Offset < rhs.ptEntry.Offset.Offset; }
|
||
|
|
};
|
||
|
|
|
||
|
|
USTATUS MeParser::parseMeRegionBody(const UModelIndex & index)
|
||
|
|
{
|
||
|
|
// Sanity check
|
||
|
|
if (!index.isValid())
|
||
|
|
return U_INVALID_PARAMETER;
|
||
|
|
|
||
|
|
// Obtain ME region
|
||
|
|
UByteArray meRegion = model->body(index);
|
||
|
|
|
||
|
|
// Check region size
|
||
|
|
if ((UINT32)meRegion.size() < ME_ROM_BYPASS_VECTOR_SIZE + sizeof(UINT32)) {
|
||
|
|
msg(usprintf("%s: ME region too small to fit ROM bypass vector", __FUNCTION__), index);
|
||
|
|
return U_INVALID_ME_PARTITION_TABLE;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Check ME signature to determine it's version
|
||
|
|
// ME v11 and older layout
|
||
|
|
if (meRegion.left(sizeof(UINT32)) == ME_FPT_HEADER_SIGNATURE || meRegion.mid(ME_ROM_BYPASS_VECTOR_SIZE, sizeof(UINT32)) == ME_FPT_HEADER_SIGNATURE) {
|
||
|
|
UModelIndex ptIndex;
|
||
|
|
return parseFptRegion(meRegion, index, ptIndex);
|
||
|
|
}
|
||
|
|
|
||
|
|
// CannonLake 1.6+ layout (IFWI)
|
||
|
|
// Check region size
|
||
|
|
if ((UINT32)meRegion.size() < sizeof(ME_IFWI_LAYOUT_HEADER)) {
|
||
|
|
msg(usprintf("%s: ME region too small to fit IFWI layout header", __FUNCTION__), index);
|
||
|
|
return U_INVALID_ME_PARTITION_TABLE;
|
||
|
|
}
|
||
|
|
|
||
|
|
const ME_IFWI_LAYOUT_HEADER* regionHeader = (const ME_IFWI_LAYOUT_HEADER*)meRegion.constData();
|
||
|
|
// Check region size
|
||
|
|
if ((UINT32)meRegion.size() < regionHeader->DataPartitionOffset + sizeof(UINT32)) {
|
||
|
|
msg(usprintf("%s: ME region too small to fit IFWI layout header", __FUNCTION__), index);
|
||
|
|
return U_INVALID_ME_PARTITION_TABLE;
|
||
|
|
}
|
||
|
|
// Data partition always points to FPT header
|
||
|
|
if (meRegion.mid(regionHeader->DataPartitionOffset, sizeof(UINT32)) == ME_FPT_HEADER_SIGNATURE) {
|
||
|
|
UModelIndex ptIndex;
|
||
|
|
return parseIfwiRegion(meRegion, index, ptIndex);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Something else entirely
|
||
|
|
msg(usprintf("%s: unknown ME region format", __FUNCTION__), index);
|
||
|
|
return U_INVALID_ME_PARTITION_TABLE;
|
||
|
|
}
|
||
|
|
|
||
|
|
USTATUS MeParser::parseIfwiRegion(const UByteArray & region, const UModelIndex & parent, UModelIndex & index)
|
||
|
|
{
|
||
|
|
// Add header
|
||
|
|
UByteArray header = region.left(sizeof(ME_IFWI_LAYOUT_HEADER));
|
||
|
|
const ME_IFWI_LAYOUT_HEADER* ifwiHeader = (const ME_IFWI_LAYOUT_HEADER*)region.constData();
|
||
|
|
|
||
|
|
UString name = UString("IFWI header");
|
||
|
|
UString info = usprintf("Full size: %Xh (%u)\n"
|
||
|
|
"Data partition offset: %Xh\nData partition length: %Xh\n"
|
||
|
|
"Boot1 partition offset: %Xh\nBoot1 partition length: %Xh\n"
|
||
|
|
"Boot2 partition offset: %Xh\nBoot2 partition length: %Xh\n"
|
||
|
|
"Boot3 partition offset: %Xh\nBoot3 partition length: %Xh",
|
||
|
|
header.size(), header.size(),
|
||
|
|
ifwiHeader->DataPartitionOffset, ifwiHeader->DataPartitionSize,
|
||
|
|
ifwiHeader->Boot1Offset, ifwiHeader->Boot1Size,
|
||
|
|
ifwiHeader->Boot2Offset, ifwiHeader->Boot2Size,
|
||
|
|
ifwiHeader->Boot3Offset, ifwiHeader->Boot3Size);
|
||
|
|
// Add tree item
|
||
|
|
index = model->addItem(0, Types::IfwiHeader, 0, name, UString(), info, UByteArray(), header, UByteArray(), Fixed, parent);
|
||
|
|
|
||
|
|
// TODO: this requires better parsing using a similar approach as in other things: get all, sort, check for paddings/intersections
|
||
|
|
|
||
|
|
// Add padding after header
|
||
|
|
if (ifwiHeader->DataPartitionOffset > sizeof(ME_IFWI_LAYOUT_HEADER)) {
|
||
|
|
UByteArray padding = region.mid(sizeof(ME_IFWI_LAYOUT_HEADER), ifwiHeader->DataPartitionOffset - sizeof(ME_IFWI_LAYOUT_HEADER));
|
||
|
|
name = UString("Padding");
|
||
|
|
info = usprintf("Full size: %Xh (%u)", padding.size(), padding.size());
|
||
|
|
// Add tree item
|
||
|
|
model->addItem(sizeof(ME_IFWI_LAYOUT_HEADER), Types::Padding, getPaddingType(padding), name, UString(), info, UByteArray(), padding, UByteArray(), Fixed, parent);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Add data partition
|
||
|
|
UByteArray dataPartition = region.mid(ifwiHeader->DataPartitionOffset, ifwiHeader->DataPartitionSize);
|
||
|
|
name = UString("Data partition");
|
||
|
|
info = usprintf("Full size: %Xh (%u)", dataPartition.size(), dataPartition.size());
|
||
|
|
UModelIndex dataPartitionIndex = model->addItem(ifwiHeader->DataPartitionOffset, Types::IfwiPartition, Subtypes::DataIfwiPartition, name, UString(), info, UByteArray(), dataPartition, UByteArray(), Fixed, parent);
|
||
|
|
UModelIndex dataPartitionFptRegionIndex;
|
||
|
|
parseFptRegion(dataPartition, dataPartitionIndex, dataPartitionFptRegionIndex);
|
||
|
|
|
||
|
|
// Add padding after data partition
|
||
|
|
if (ifwiHeader->Boot1Offset > ifwiHeader->DataPartitionOffset + ifwiHeader->DataPartitionSize) {
|
||
|
|
UByteArray padding = region.mid(ifwiHeader->DataPartitionOffset + ifwiHeader->DataPartitionSize, ifwiHeader->Boot1Offset - ifwiHeader->DataPartitionOffset + ifwiHeader->DataPartitionSize);
|
||
|
|
name = UString("Padding");
|
||
|
|
info = usprintf("Full size: %Xh (%u)", padding.size(), padding.size());
|
||
|
|
// Add tree item
|
||
|
|
model->addItem(ifwiHeader->DataPartitionOffset + ifwiHeader->DataPartitionSize, Types::Padding, getPaddingType(padding), name, UString(), info, UByteArray(), padding, UByteArray(), Fixed, parent);
|
||
|
|
}
|
||
|
|
else if (ifwiHeader->Boot1Offset < ifwiHeader->DataPartitionOffset + ifwiHeader->DataPartitionSize) {
|
||
|
|
msg(usprintf("%s: invalid Boot1 partition offset", __FUNCTION__), parent);
|
||
|
|
return U_INVALID_ME_PARTITION_TABLE;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Add Boot1 partition
|
||
|
|
UByteArray bpdt1Partition = region.mid(ifwiHeader->Boot1Offset, ifwiHeader->Boot1Size);
|
||
|
|
name = UString("Boot1 partition");
|
||
|
|
info = usprintf("Full size: %Xh (%u)", bpdt1Partition.size(), bpdt1Partition.size());
|
||
|
|
UModelIndex bpdt1PartitionIndex = model->addItem(ifwiHeader->Boot1Offset, Types::IfwiPartition, Subtypes::BootIfwiPartition, name, UString(), info, UByteArray(), bpdt1Partition, UByteArray(), Fixed, parent);
|
||
|
|
UModelIndex bpdt1PartitionBpdtRegionIndex;
|
||
|
|
parseBpdtRegion(bpdt1Partition, bpdt1PartitionIndex, bpdt1PartitionBpdtRegionIndex);
|
||
|
|
|
||
|
|
// Add padding after Boot1 partition
|
||
|
|
if (ifwiHeader->Boot2Offset > ifwiHeader->Boot1Offset + ifwiHeader->Boot1Size) {
|
||
|
|
UByteArray padding = region.mid(ifwiHeader->Boot1Offset + ifwiHeader->Boot1Size, ifwiHeader->Boot2Offset - ifwiHeader->Boot1Offset + ifwiHeader->Boot1Size);
|
||
|
|
name = UString("Padding");
|
||
|
|
info = usprintf("Full size: %Xh (%u)", padding.size(), padding.size());
|
||
|
|
// Add tree item
|
||
|
|
model->addItem(ifwiHeader->Boot1Offset + ifwiHeader->Boot1Size, Types::Padding, getPaddingType(padding), name, UString(), info, UByteArray(), padding, UByteArray(), Fixed, parent);
|
||
|
|
}
|
||
|
|
else if (ifwiHeader->Boot2Offset < ifwiHeader->Boot1Offset + ifwiHeader->Boot1Size) {
|
||
|
|
msg(usprintf("%s: invalid Boot2 partition offset", __FUNCTION__), parent);
|
||
|
|
return U_INVALID_ME_PARTITION_TABLE;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Add Boot2 partition
|
||
|
|
UByteArray bpdt2Partition = region.mid(ifwiHeader->Boot2Offset, ifwiHeader->Boot2Size);
|
||
|
|
name = UString("Boot2 partition");
|
||
|
|
info = usprintf("Full size: %Xh (%u)", bpdt2Partition.size(), bpdt2Partition.size());
|
||
|
|
UModelIndex bpdt2PartitionIndex = model->addItem(ifwiHeader->Boot2Offset, Types::IfwiPartition, Subtypes::BootIfwiPartition, name, UString(), info, UByteArray(), bpdt2Partition, UByteArray(), Fixed, parent);
|
||
|
|
UModelIndex bpdt2PartitionBpdtRegionIndex;
|
||
|
|
parseBpdtRegion(bpdt2Partition, bpdt2PartitionIndex, bpdt2PartitionBpdtRegionIndex);
|
||
|
|
|
||
|
|
// TODO: add Boot3 if needed
|
||
|
|
// Add padding at the end
|
||
|
|
if ((UINT32)region.size() > ifwiHeader->Boot2Offset + ifwiHeader->Boot2Size) {
|
||
|
|
UByteArray padding = region.mid(ifwiHeader->Boot2Offset + ifwiHeader->Boot2Size, (UINT32)region.size() - ifwiHeader->Boot2Offset + ifwiHeader->Boot2Size);
|
||
|
|
name = UString("Padding");
|
||
|
|
info = usprintf("Full size: %Xh (%u)", padding.size(), padding.size());
|
||
|
|
// Add tree item
|
||
|
|
model->addItem(ifwiHeader->Boot2Offset + ifwiHeader->Boot2Size, Types::Padding, getPaddingType(padding), name, UString(), info, UByteArray(), padding, UByteArray(), Fixed, parent);
|
||
|
|
}
|
||
|
|
else if ((UINT32)region.size() < ifwiHeader->Boot2Offset + ifwiHeader->Boot2Size) {
|
||
|
|
msg(usprintf("%s: Boot2 partition is located outside of the region", __FUNCTION__), parent);
|
||
|
|
return U_INVALID_ME_PARTITION_TABLE;
|
||
|
|
}
|
||
|
|
|
||
|
|
return U_SUCCESS;
|
||
|
|
}
|
||
|
|
|
||
|
|
USTATUS MeParser::parseFptRegion(const UByteArray & region, const UModelIndex & parent, UModelIndex & index)
|
||
|
|
{
|
||
|
|
// Check region size
|
||
|
|
if ((UINT32)region.size() < sizeof(ME_FPT_HEADER)) {
|
||
|
|
msg(usprintf("%s: region too small to fit FPT header", __FUNCTION__), parent);
|
||
|
|
return U_INVALID_ME_PARTITION_TABLE;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Populate partition table header
|
||
|
|
const ME_FPT_HEADER* ptHeader = (const ME_FPT_HEADER*)region.constData();
|
||
|
|
UINT32 romBypassVectorSize = 0;
|
||
|
|
if (region.left(sizeof(UINT32)) != ME_FPT_HEADER_SIGNATURE) {
|
||
|
|
// Adjust the header to skip ROM bypass vector
|
||
|
|
romBypassVectorSize = ME_ROM_BYPASS_VECTOR_SIZE;
|
||
|
|
ptHeader = (const ME_FPT_HEADER*)(region.constData() + romBypassVectorSize);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Check region size again
|
||
|
|
UINT32 ptBodySize = ptHeader->NumEntries * sizeof(ME_FPT_ENTRY);
|
||
|
|
UINT32 ptSize = romBypassVectorSize + sizeof(ME_FPT_HEADER) + ptBodySize;
|
||
|
|
if ((UINT32)region.size() < ptSize) {
|
||
|
|
msg(usprintf("%s: ME region too small to fit partition table", __FUNCTION__), parent);
|
||
|
|
return U_INVALID_ME_PARTITION_TABLE;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Recalculate checksum
|
||
|
|
UByteArray tempHeader = UByteArray((const char*)ptHeader, sizeof(ME_FPT_HEADER));
|
||
|
|
ME_FPT_HEADER* tempPtHeader = (ME_FPT_HEADER*)tempHeader.data();
|
||
|
|
tempPtHeader->Checksum = 0;
|
||
|
|
UINT8 calculated = calculateChecksum8((const UINT8*)tempPtHeader, sizeof(ME_FPT_HEADER));
|
||
|
|
bool msgInvalidPtHeaderChecksum = (calculated != ptHeader->Checksum);
|
||
|
|
|
||
|
|
// Get info
|
||
|
|
UByteArray header = region.left(romBypassVectorSize + sizeof(ME_FPT_HEADER));
|
||
|
|
UByteArray body = region.mid(header.size(), ptBodySize);
|
||
|
|
|
||
|
|
UString name = UString("FPT partition table");
|
||
|
|
UString info = usprintf("Full size: %Xh (%u)\nHeader size: %Xh (%u)\nBody size: %Xh (%u)\nNumber of entries: %u\nHeader version: %02Xh\nEntry version: %02Xh\n"
|
||
|
|
"Header length: %02Xh\nTicks to add: %04Xh\nTokens to add: %04Xh\nUMA size: %Xh\nFlash layout: %Xh\nFITC version: %u.%u.%u.%u\nChecksum: %02Xh, ",
|
||
|
|
ptSize, ptSize,
|
||
|
|
header.size(), header.size(),
|
||
|
|
ptBodySize, ptBodySize,
|
||
|
|
ptHeader->NumEntries,
|
||
|
|
ptHeader->HeaderVersion,
|
||
|
|
ptHeader->EntryVersion,
|
||
|
|
ptHeader->HeaderLength,
|
||
|
|
ptHeader->TicksToAdd,
|
||
|
|
ptHeader->TokensToAdd,
|
||
|
|
ptHeader->UmaSize,
|
||
|
|
ptHeader->FlashLayout,
|
||
|
|
ptHeader->FitcMajor, ptHeader->FitcMinor, ptHeader->FitcHotfix, ptHeader->FitcBuild,
|
||
|
|
ptHeader->Checksum) + (ptHeader->Checksum == calculated ? UString("valid") : usprintf("invalid, should be %02Xh", calculated));
|
||
|
|
|
||
|
|
// Add tree item
|
||
|
|
index = model->addItem(0, Types::FptStore, 0, name, UString(), info, header, body, UByteArray(), Fixed, parent);
|
||
|
|
|
||
|
|
// Show messages
|
||
|
|
if (msgInvalidPtHeaderChecksum) {
|
||
|
|
msg(usprintf("%s: FPT partition table header checksum is invalid", __FUNCTION__), index);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Add partition table entries
|
||
|
|
std::vector<ME_FPT_PARTITION_INFO> partitions;
|
||
|
|
UINT32 offset = header.size();
|
||
|
|
const ME_FPT_ENTRY* firstPtEntry = (const ME_FPT_ENTRY*)(region.constData() + offset);
|
||
|
|
for (UINT8 i = 0; i < ptHeader->NumEntries; i++) {
|
||
|
|
// Populate entry header
|
||
|
|
const ME_FPT_ENTRY* ptEntry = firstPtEntry + i;
|
||
|
|
|
||
|
|
// Get info
|
||
|
|
name = usprintf("%c%c%c%c", ptEntry->PartitionName[0], ptEntry->PartitionName[1], ptEntry->PartitionName[2], ptEntry->PartitionName[3]);
|
||
|
|
info = usprintf("Full size: %Xh (%u)\nPartition offset: %Xh\nPartition length: %Xh\nPartition type: %02Xh",
|
||
|
|
sizeof(ME_FPT_ENTRY), sizeof(ME_FPT_ENTRY),
|
||
|
|
ptEntry->Offset,
|
||
|
|
ptEntry->Length,
|
||
|
|
ptEntry->PartitionType);
|
||
|
|
|
||
|
|
// Add tree item
|
||
|
|
const UINT8 type = (ptEntry->Offset != 0 && ptEntry->Offset != 0xFFFFFFFF && ptEntry->Length != 0 && ptEntry->EntryValid != 0xFF) ? Subtypes::ValidFptEntry : Subtypes::InvalidFptEntry;
|
||
|
|
UModelIndex entryIndex = model->addItem(offset, Types::FptEntry, type, name, UString(), info, UByteArray(), UByteArray((const char*)ptEntry, sizeof(ME_FPT_ENTRY)), UByteArray(), Fixed, index);
|
||
|
|
|
||
|
|
// Adjust offset
|
||
|
|
offset += sizeof(ME_FPT_ENTRY);
|
||
|
|
|
||
|
|
// Add valid partitions
|
||
|
|
if (type == Subtypes::ValidFptEntry) { // Skip absent and invalid partitions
|
||
|
|
// Add to partitions vector
|
||
|
|
ME_FPT_PARTITION_INFO partition;
|
||
|
|
partition.type = Types::FptPartition;
|
||
|
|
partition.ptEntry = *ptEntry;
|
||
|
|
partition.index = entryIndex;
|
||
|
|
partitions.push_back(partition);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
make_partition_table_consistent:
|
||
|
|
// Sort partitions by offset
|
||
|
|
std::sort(partitions.begin(), partitions.end());
|
||
|
|
|
||
|
|
// Check for intersections and paddings between partitions
|
||
|
|
ME_FPT_PARTITION_INFO padding;
|
||
|
|
|
||
|
|
// Check intersection with the partition table header
|
||
|
|
if (partitions.front().ptEntry.Offset < ptSize) {
|
||
|
|
msg(usprintf("%s: ME partition has intersection with ME partition table, skipped", __FUNCTION__),
|
||
|
|
partitions.front().index);
|
||
|
|
partitions.erase(partitions.begin());
|
||
|
|
goto make_partition_table_consistent;
|
||
|
|
}
|
||
|
|
// Check for padding between partition table and the first partition
|
||
|
|
else if (partitions.front().ptEntry.Offset > ptSize) {
|
||
|
|
padding.ptEntry.Offset = ptSize;
|
||
|
|
padding.ptEntry.Length = partitions.front().ptEntry.Offset - ptSize;
|
||
|
|
padding.type = Types::Padding;
|
||
|
|
partitions.insert(partitions.begin(), padding);
|
||
|
|
}
|
||
|
|
// Check for intersections/paddings between partitions
|
||
|
|
for (size_t i = 1; i < partitions.size(); i++) {
|
||
|
|
UINT32 previousPartitionEnd = partitions[i - 1].ptEntry.Offset + partitions[i - 1].ptEntry.Length;
|
||
|
|
|
||
|
|
// Check that current region is fully present in the image
|
||
|
|
if ((UINT32)partitions[i].ptEntry.Offset + (UINT32)partitions[i].ptEntry.Length > (UINT32)region.size()) {
|
||
|
|
if ((UINT32)partitions[i].ptEntry.Offset >= (UINT32)region.size()) {
|
||
|
|
msg(usprintf("%s: FPT partition is located outside of the opened image, skipped", __FUNCTION__), partitions[i].index);
|
||
|
|
partitions.erase(partitions.begin() + i);
|
||
|
|
goto make_partition_table_consistent;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
msg(usprintf("%s: FPT partition can't fit into the region, truncated", __FUNCTION__), partitions[i].index);
|
||
|
|
partitions[i].ptEntry.Length = (UINT32)region.size() - (UINT32)partitions[i].ptEntry.Offset;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Check for intersection with previous partition
|
||
|
|
if (partitions[i].ptEntry.Offset < previousPartitionEnd) {
|
||
|
|
// Check if current partition is located inside previous one
|
||
|
|
if (partitions[i].ptEntry.Offset + partitions[i].ptEntry.Length <= previousPartitionEnd) {
|
||
|
|
msg(usprintf("%s: FPT partition is located inside another FPT partition, skipped", __FUNCTION__),
|
||
|
|
partitions[i].index);
|
||
|
|
partitions.erase(partitions.begin() + i);
|
||
|
|
goto make_partition_table_consistent;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
msg(usprintf("%s: FPT partition intersects with prevous one, skipped", __FUNCTION__),
|
||
|
|
partitions[i].index);
|
||
|
|
partitions.erase(partitions.begin() + i);
|
||
|
|
goto make_partition_table_consistent;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Check for padding between current and previous partitions
|
||
|
|
else if (partitions[i].ptEntry.Offset > previousPartitionEnd) {
|
||
|
|
padding.ptEntry.Offset = previousPartitionEnd;
|
||
|
|
padding.ptEntry.Length = partitions[i].ptEntry.Offset - previousPartitionEnd;
|
||
|
|
padding.type = Types::Padding;
|
||
|
|
std::vector<ME_FPT_PARTITION_INFO>::iterator iter = partitions.begin();
|
||
|
|
std::advance(iter, i);
|
||
|
|
partitions.insert(iter, padding);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// Check for padding after the last region
|
||
|
|
if ((UINT32)partitions.back().ptEntry.Offset + (UINT32)partitions.back().ptEntry.Length < (UINT32)region.size()) {
|
||
|
|
padding.ptEntry.Offset = partitions.back().ptEntry.Offset + partitions.back().ptEntry.Length;
|
||
|
|
padding.ptEntry.Length = region.size() - padding.ptEntry.Offset;
|
||
|
|
padding.type = Types::Padding;
|
||
|
|
partitions.push_back(padding);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Partition map is consistent
|
||
|
|
for (size_t i = 0; i < partitions.size(); i++) {
|
||
|
|
UByteArray partition = region.mid(partitions[i].ptEntry.Offset, partitions[i].ptEntry.Length);
|
||
|
|
if (partitions[i].type == Types::FptPartition) {
|
||
|
|
UModelIndex partitionIndex;
|
||
|
|
// Get info
|
||
|
|
name = usprintf("%c%c%c%c", partitions[i].ptEntry.PartitionName[0], partitions[i].ptEntry.PartitionName[1], partitions[i].ptEntry.PartitionName[2], partitions[i].ptEntry.PartitionName[3]);
|
||
|
|
info = usprintf("Full size: %Xh (%u)\nPartition type: %02Xh\n",
|
||
|
|
partition.size(), partition.size(),
|
||
|
|
partitions[i].ptEntry.PartitionType);
|
||
|
|
|
||
|
|
// Add tree item
|
||
|
|
UINT8 type = Subtypes::CodeFptPartition + partitions[i].ptEntry.PartitionType;
|
||
|
|
partitionIndex = model->addItem(partitions[i].ptEntry.Offset, Types::FptPartition, type, name, UString(), info, UByteArray(), partition, UByteArray(), Fixed, parent);
|
||
|
|
if (type == Subtypes::CodeFptPartition && partition.left(sizeof(UINT32)) == ME_CPD_SIGNATURE) {
|
||
|
|
// Parse conde partition contents
|
||
|
|
UModelIndex ptIndex;
|
||
|
|
parseCodePartitionDirectory(partition, partitions[i].ptEntry.Offset, partitionIndex, ptIndex);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if (partitions[i].type == Types::Padding) {
|
||
|
|
// Get info
|
||
|
|
name = UString("Padding");
|
||
|
|
info = usprintf("Full size: %Xh (%u)", partition.size(), partition.size());
|
||
|
|
|
||
|
|
// Add tree item
|
||
|
|
model->addItem(partitions[i].ptEntry.Offset, Types::Padding, getPaddingType(partition), name, UString(), info, UByteArray(), partition, UByteArray(), Fixed, parent);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return U_SUCCESS;
|
||
|
|
}
|
||
|
|
|
||
|
|
USTATUS MeParser::parseBpdtRegion(const UByteArray & region, const UModelIndex & parent, UModelIndex & index)
|
||
|
|
{
|
||
|
|
// Check region size
|
||
|
|
if ((UINT32)region.size() < sizeof(ME_BPDT_HEADER)) {
|
||
|
|
msg(usprintf("%s: BPDT region too small to fit partition table header", __FUNCTION__), parent);
|
||
|
|
return U_INVALID_ME_PARTITION_TABLE;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Populate partition table header
|
||
|
|
const ME_BPDT_HEADER* ptHeader = (const ME_BPDT_HEADER*)region.constData();
|
||
|
|
|
||
|
|
// Check region size again
|
||
|
|
UINT32 ptBodySize = ptHeader->NumEntries * sizeof(ME_BPDT_ENTRY);
|
||
|
|
UINT32 ptSize = sizeof(ME_BPDT_HEADER) + ptBodySize;
|
||
|
|
if ((UINT32)region.size() < ptSize) {
|
||
|
|
msg(usprintf("%s: BPDT region too small to fit BPDT partition table", __FUNCTION__), parent);
|
||
|
|
return U_INVALID_ME_PARTITION_TABLE;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Get info
|
||
|
|
UByteArray header = region.left(sizeof(ME_BPDT_HEADER));
|
||
|
|
UByteArray body = region.mid(sizeof(ME_BPDT_HEADER), ptBodySize);
|
||
|
|
|
||
|
|
UString name = UString("BPDT partition table");
|
||
|
|
UString info = usprintf("Full size: %Xh (%u)\nHeader size: %Xh (%u)\nBody size: %Xh (%u)\nNumber of entries: %u\nVersion: %Xh\n"
|
||
|
|
"IFWI version: %Xh\nFITC version: %u.%u.%u.%u",
|
||
|
|
ptSize, ptSize,
|
||
|
|
header.size(), header.size(),
|
||
|
|
ptBodySize, ptBodySize,
|
||
|
|
ptHeader->NumEntries,
|
||
|
|
ptHeader->Version,
|
||
|
|
ptHeader->IfwiVersion,
|
||
|
|
ptHeader->FitcMajor, ptHeader->FitcMinor, ptHeader->FitcHotfix, ptHeader->FitcBuild);
|
||
|
|
|
||
|
|
// Add tree item
|
||
|
|
index = model->addItem(0, Types::BpdtStore, 0, name, UString(), info, header, body, UByteArray(), Fixed, parent);
|
||
|
|
|
||
|
|
// Adjust offset
|
||
|
|
UINT32 offset = sizeof(ME_FPT_HEADER);
|
||
|
|
|
||
|
|
// Add partition table entries
|
||
|
|
std::vector<ME_BPDT_PARTITION_INFO> partitions;
|
||
|
|
const ME_BPDT_ENTRY* firstPtEntry = (const ME_BPDT_ENTRY*)(region.constData() + sizeof(ME_BPDT_HEADER));
|
||
|
|
for (UINT8 i = 0; i < ptHeader->NumEntries; i++) {
|
||
|
|
// Populate entry header
|
||
|
|
const ME_BPDT_ENTRY* ptEntry = firstPtEntry + i;
|
||
|
|
|
||
|
|
// Get info
|
||
|
|
name = meBpdtEntryTypeToUString(ptEntry->Type);
|
||
|
|
info = usprintf("Full size: %Xh (%u)\nType: %Xh\nPartition offset: %Xh\nPartition length: %Xh",
|
||
|
|
sizeof(ME_BPDT_ENTRY), sizeof(ME_BPDT_ENTRY),
|
||
|
|
ptEntry->Type,
|
||
|
|
ptEntry->Offset,
|
||
|
|
ptEntry->Length) +
|
||
|
|
UString("\nSplit sub-partition first part: ") + (ptEntry->SplitSubPartitionFirstPart ? "Yes" : "No") +
|
||
|
|
UString("\nSplit sub-partition second part: ") + (ptEntry->SplitSubPartitionSecondPart ? "Yes" : "No") +
|
||
|
|
UString("\nCode sub-partition: ") + (ptEntry->CodeSubPartition ? "Yes" : "No") +
|
||
|
|
UString("\nUMA cachable: ") + (ptEntry->UmaCachable ? "Yes" : "No");
|
||
|
|
|
||
|
|
// Add tree item
|
||
|
|
UModelIndex entryIndex = model->addItem(offset, Types::BpdtEntry, 0, name, UString(), info, UByteArray(), UByteArray((const char*)ptEntry, sizeof(ME_BPDT_ENTRY)), UByteArray(), Fixed, index);
|
||
|
|
|
||
|
|
// Adjust offset
|
||
|
|
offset += sizeof(ME_BPDT_ENTRY);
|
||
|
|
|
||
|
|
if (ptEntry->Offset != 0 && ptEntry->Offset != 0xFFFFFFFF && ptEntry->Length != 0) {
|
||
|
|
// Add to partitions vector
|
||
|
|
ME_BPDT_PARTITION_INFO partition;
|
||
|
|
partition.type = Types::FptPartition;
|
||
|
|
partition.ptEntry = *ptEntry;
|
||
|
|
partition.index = entryIndex;
|
||
|
|
partitions.push_back(partition);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Add padding if there's no partions to add
|
||
|
|
if (partitions.size() == 0) {
|
||
|
|
UByteArray partition = region.mid(ptSize);
|
||
|
|
|
||
|
|
// Get info
|
||
|
|
name = UString("Padding");
|
||
|
|
info = usprintf("Full size: %Xh (%u)",
|
||
|
|
partition.size(), partition.size());
|
||
|
|
|
||
|
|
// Add tree item
|
||
|
|
model->addItem(ptSize, Types::Padding, getPaddingType(partition), name, UString(), info, UByteArray(), partition, UByteArray(), Fixed, parent);
|
||
|
|
|
||
|
|
return U_SUCCESS;
|
||
|
|
}
|
||
|
|
|
||
|
|
make_partition_table_consistent:
|
||
|
|
// Sort partitions by offset
|
||
|
|
std::sort(partitions.begin(), partitions.end());
|
||
|
|
|
||
|
|
// Check for intersections and paddings between partitions
|
||
|
|
ME_BPDT_PARTITION_INFO padding;
|
||
|
|
|
||
|
|
// Check intersection with the partition table header
|
||
|
|
if (partitions.front().ptEntry.Offset < ptSize) {
|
||
|
|
msg(usprintf("%s: BPDT partition has intersection with BPDT partition table, skipped", __FUNCTION__),
|
||
|
|
partitions.front().index);
|
||
|
|
partitions.erase(partitions.begin());
|
||
|
|
goto make_partition_table_consistent;
|
||
|
|
}
|
||
|
|
// Check for padding between partition table and the first partition
|
||
|
|
else if (partitions.front().ptEntry.Offset > ptSize) {
|
||
|
|
padding.ptEntry.Offset = ptSize;
|
||
|
|
padding.ptEntry.Length = partitions.front().ptEntry.Offset - padding.ptEntry.Offset;
|
||
|
|
padding.type = Types::Padding;
|
||
|
|
partitions.insert(partitions.begin(), padding);
|
||
|
|
}
|
||
|
|
// Check for intersections/paddings between partitions
|
||
|
|
for (size_t i = 1; i < partitions.size(); i++) {
|
||
|
|
UINT32 previousPartitionEnd = partitions[i - 1].ptEntry.Offset + partitions[i - 1].ptEntry.Length;
|
||
|
|
|
||
|
|
// Check that partition is fully present in the image
|
||
|
|
if ((UINT64)partitions[i].ptEntry.Offset + (UINT64)partitions[i].ptEntry.Length > (UINT64)region.size()) {
|
||
|
|
if ((UINT64)partitions[i].ptEntry.Offset >= (UINT64)region.size()) {
|
||
|
|
msg(usprintf("%s: BPDT partition is located outside of the opened image, skipped", __FUNCTION__), partitions[i].index);
|
||
|
|
partitions.erase(partitions.begin() + i);
|
||
|
|
goto make_partition_table_consistent;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
msg(usprintf("%s: BPDT partition can't fit into it's region, truncated", __FUNCTION__), partitions[i].index);
|
||
|
|
partitions[i].ptEntry.Length = (UINT32)region.size() - (UINT32)partitions[i].ptEntry.Offset;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Check for intersection with previous partition
|
||
|
|
if (partitions[i].ptEntry.Offset < previousPartitionEnd) {
|
||
|
|
// Check if current partition is located inside previous one
|
||
|
|
if (partitions[i].ptEntry.Offset + partitions[i].ptEntry.Length <= previousPartitionEnd) {
|
||
|
|
msg(usprintf("%s: BPDT partition is located inside another BPDT partition, skipped", __FUNCTION__),
|
||
|
|
partitions[i].index);
|
||
|
|
partitions.erase(partitions.begin() + i);
|
||
|
|
goto make_partition_table_consistent;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
msg(usprintf("%s: BPDT partition intersects with prevous one, skipped", __FUNCTION__),
|
||
|
|
partitions[i].index);
|
||
|
|
partitions.erase(partitions.begin() + i);
|
||
|
|
goto make_partition_table_consistent;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Check for padding between current and previous partitions
|
||
|
|
else if (partitions[i].ptEntry.Offset > previousPartitionEnd) {
|
||
|
|
padding.ptEntry.Offset = previousPartitionEnd;
|
||
|
|
padding.ptEntry.Length = partitions[i].ptEntry.Offset - previousPartitionEnd;
|
||
|
|
padding.type = Types::Padding;
|
||
|
|
std::vector<ME_BPDT_PARTITION_INFO>::iterator iter = partitions.begin();
|
||
|
|
std::advance(iter, i);
|
||
|
|
partitions.insert(iter, padding);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Check for padding after the last region
|
||
|
|
if ((UINT64)partitions.back().ptEntry.Offset + (UINT64)partitions.back().ptEntry.Length < (UINT64)region.size()) {
|
||
|
|
padding.ptEntry.Offset = partitions.back().ptEntry.Offset + partitions.back().ptEntry.Length;
|
||
|
|
padding.ptEntry.Length = region.size() - padding.ptEntry.Offset;
|
||
|
|
padding.type = Types::Padding;
|
||
|
|
partitions.push_back(padding);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Partition map is consistent
|
||
|
|
for (size_t i = 0; i < partitions.size(); i++) {
|
||
|
|
if (partitions[i].type == Types::FptPartition) {
|
||
|
|
// Get info
|
||
|
|
UString name = meBpdtEntryTypeToUString(partitions[i].ptEntry.Type);
|
||
|
|
UByteArray partition = region.mid(partitions[i].ptEntry.Offset, partitions[i].ptEntry.Length);
|
||
|
|
UByteArray signature = partition.left(sizeof(UINT32));
|
||
|
|
|
||
|
|
UString info = usprintf("Full size: %Xh (%u)\nType: %Xh",
|
||
|
|
partition.size(), partition.size(),
|
||
|
|
partitions[i].ptEntry.Type) +
|
||
|
|
UString("\nSplit sub-partition first part: ") + (partitions[i].ptEntry.SplitSubPartitionFirstPart ? "Yes" : "No") +
|
||
|
|
UString("\nSplit sub-partition second part: ") + (partitions[i].ptEntry.SplitSubPartitionSecondPart ? "Yes" : "No") +
|
||
|
|
UString("\nCode sub-partition: ") + (partitions[i].ptEntry.CodeSubPartition ? "Yes" : "No") +
|
||
|
|
UString("\nUMA cachable: ") + (partitions[i].ptEntry.UmaCachable ? "Yes" : "No");
|
||
|
|
|
||
|
|
if (signature == ME_CPD_SIGNATURE) {
|
||
|
|
const ME_CPD_HEADER* cpdHeader = (const ME_CPD_HEADER*)partition.constData();
|
||
|
|
name = usprintf("%c%c%c%c", cpdHeader->ShortName[0], cpdHeader->ShortName[1], cpdHeader->ShortName[2], cpdHeader->ShortName[3]);
|
||
|
|
UString text = meBpdtEntryTypeToUString(partitions[i].ptEntry.Type);
|
||
|
|
|
||
|
|
// Add tree item
|
||
|
|
UModelIndex ptIndex = model->addItem(partitions[i].ptEntry.Offset, Types::BpdtPartition, 0, name, text, info, UByteArray(), partition, UByteArray(), Fixed, parent);
|
||
|
|
|
||
|
|
// Parse contents
|
||
|
|
UModelIndex cpdIndex;
|
||
|
|
parseCodePartitionDirectory(partition, partitions[i].ptEntry.Offset, ptIndex, cpdIndex);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
// Add tree item
|
||
|
|
model->addItem(partitions[i].ptEntry.Offset, Types::BpdtEntry, 0, name, UString(), info, UByteArray(), partition, UByteArray(), Fixed, parent);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if (partitions[i].type == Types::Padding) {
|
||
|
|
UByteArray partition = region.mid(partitions[i].ptEntry.Offset, partitions[i].ptEntry.Length);
|
||
|
|
|
||
|
|
// Get info
|
||
|
|
name = UString("Padding");
|
||
|
|
info = usprintf("Full size: %Xh (%u)",
|
||
|
|
partition.size(), partition.size());
|
||
|
|
|
||
|
|
// Add tree item
|
||
|
|
model->addItem(partitions[i].ptEntry.Offset, Types::Padding, getPaddingType(partition), name, UString(), info, UByteArray(), partition, UByteArray(), Fixed, parent);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return U_SUCCESS;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
USTATUS MeParser::parseCodePartitionDirectory(const UByteArray & directory, const UINT32 localOffset, const UModelIndex & parent, UModelIndex & index)
|
||
|
|
{
|
||
|
|
// Check directory size
|
||
|
|
if ((UINT32)directory.size() < sizeof(ME_CPD_HEADER)) {
|
||
|
|
msg(usprintf("%s: CPD too small to fit partition table header", __FUNCTION__), parent);
|
||
|
|
return U_INVALID_ME_PARTITION_TABLE;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Populate partition table header
|
||
|
|
const ME_CPD_HEADER* cpdHeader = (const ME_CPD_HEADER*)directory.constData();
|
||
|
|
|
||
|
|
// Check directory size again
|
||
|
|
UINT32 ptBodySize = cpdHeader->NumEntries * sizeof(ME_BPDT_CPD_ENTRY);
|
||
|
|
UINT32 ptSize = sizeof(ME_CPD_HEADER) + ptBodySize;
|
||
|
|
if ((UINT32)directory.size() < ptSize) {
|
||
|
|
msg(usprintf("%s: CPD too small to fit partition table", __FUNCTION__), parent);
|
||
|
|
return U_INVALID_ME_PARTITION_TABLE;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Get info
|
||
|
|
UByteArray header = directory.left(sizeof(ME_CPD_HEADER));
|
||
|
|
UByteArray body = directory.mid(sizeof(ME_CPD_HEADER));
|
||
|
|
UString name = usprintf("CPD partition table");
|
||
|
|
UString info = usprintf("Full size: %Xh (%u)\nHeader size: %Xh (%u)\nBody size: %Xh (%u)\nNumber of entries: %u\n"
|
||
|
|
"Header version: %u\nEntry version: %u\nHeader checksum: %02Xh",
|
||
|
|
directory.size(), directory.size(),
|
||
|
|
header.size(), header.size(),
|
||
|
|
body.size(), body.size(),
|
||
|
|
cpdHeader->NumEntries,
|
||
|
|
cpdHeader->HeaderVersion,
|
||
|
|
cpdHeader->EntryVersion,
|
||
|
|
cpdHeader->HeaderChecksum);
|
||
|
|
|
||
|
|
// Add tree item
|
||
|
|
index = model->addItem(localOffset, Types::CpdStore, 0, name, UString(), info, header, body, UByteArray(), Fixed, parent);
|
||
|
|
|
||
|
|
// Add partition table entries
|
||
|
|
std::vector<ME_CPD_PARTITION_INFO> partitions;
|
||
|
|
UINT32 offset = sizeof(ME_CPD_HEADER);
|
||
|
|
const ME_BPDT_CPD_ENTRY* firstCpdEntry = (const ME_BPDT_CPD_ENTRY*)(body.constData());
|
||
|
|
for (UINT32 i = 0; i < cpdHeader->NumEntries; i++) {
|
||
|
|
// Populate entry header
|
||
|
|
const ME_BPDT_CPD_ENTRY* cpdEntry = firstCpdEntry + i;
|
||
|
|
UByteArray entry((const char*)cpdEntry, sizeof(ME_BPDT_CPD_ENTRY));
|
||
|
|
|
||
|
|
// Get info
|
||
|
|
name = usprintf("%c%c%c%c%c%c%c%c%c%c%c%c",
|
||
|
|
cpdEntry->EntryName[0], cpdEntry->EntryName[1], cpdEntry->EntryName[2], cpdEntry->EntryName[3],
|
||
|
|
cpdEntry->EntryName[4], cpdEntry->EntryName[5], cpdEntry->EntryName[6], cpdEntry->EntryName[7],
|
||
|
|
cpdEntry->EntryName[8], cpdEntry->EntryName[9], cpdEntry->EntryName[10], cpdEntry->EntryName[11]);
|
||
|
|
info = usprintf("Full size: %Xh (%u)\nEntry offset: %Xh\nEntry length: %Xh\nHuffman compressed: ",
|
||
|
|
entry.size(), entry.size(),
|
||
|
|
cpdEntry->Offset.Offset,
|
||
|
|
cpdEntry->Length)
|
||
|
|
+ (cpdEntry->Offset.HuffmanCompressed ? "Yes" : "No");
|
||
|
|
|
||
|
|
// Add tree item
|
||
|
|
UModelIndex entryIndex = model->addItem(offset, Types::CpdEntry, 0, name, UString(), info, UByteArray(), entry, UByteArray(), Fixed, index);
|
||
|
|
|
||
|
|
// Adjust offset
|
||
|
|
offset += sizeof(ME_BPDT_CPD_ENTRY);
|
||
|
|
|
||
|
|
if (cpdEntry->Offset.Offset != 0 && cpdEntry->Length != 0) {
|
||
|
|
// Add to partitions vector
|
||
|
|
ME_CPD_PARTITION_INFO partition;
|
||
|
|
partition.type = Types::CpdPartition;
|
||
|
|
partition.ptEntry = *cpdEntry;
|
||
|
|
partition.index = entryIndex;
|
||
|
|
partitions.push_back(partition);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Add padding if there's no partions to add
|
||
|
|
if (partitions.size() == 0) {
|
||
|
|
UByteArray partition = directory.mid(ptSize);
|
||
|
|
|
||
|
|
// Get info
|
||
|
|
name = UString("Padding");
|
||
|
|
info = usprintf("Full size: %Xh (%u)",
|
||
|
|
partition.size(), partition.size());
|
||
|
|
|
||
|
|
// Add tree item
|
||
|
|
model->addItem(localOffset + ptSize, Types::Padding, getPaddingType(partition), name, UString(), info, UByteArray(), partition, UByteArray(), Fixed, parent);
|
||
|
|
|
||
|
|
return U_SUCCESS;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Sort partitions by offset
|
||
|
|
std::sort(partitions.begin(), partitions.end());
|
||
|
|
|
||
|
|
// Because lenghts for all Huffmann-compressed partitions mean nothing at all, we need to split all partitions into 2 classes:
|
||
|
|
// 1. CPD manifest (should be the first)
|
||
|
|
// 2. Metadata entries (should begin right after partition manifest and end before any code partition)
|
||
|
|
UINT32 i = 1;
|
||
|
|
while (i < partitions.size()) {
|
||
|
|
name = usprintf("%c%c%c%c%c%c%c%c%c%c%c%c",
|
||
|
|
partitions[i].ptEntry.EntryName[0], partitions[i].ptEntry.EntryName[1], partitions[i].ptEntry.EntryName[2], partitions[i].ptEntry.EntryName[3],
|
||
|
|
partitions[i].ptEntry.EntryName[4], partitions[i].ptEntry.EntryName[5], partitions[i].ptEntry.EntryName[6], partitions[i].ptEntry.EntryName[7],
|
||
|
|
partitions[i].ptEntry.EntryName[8], partitions[i].ptEntry.EntryName[9], partitions[i].ptEntry.EntryName[10], partitions[i].ptEntry.EntryName[11]);
|
||
|
|
|
||
|
|
// Check if the current entry is metadata entry
|
||
|
|
if (!name.contains(".met")) {
|
||
|
|
// No need to parse further, all metadata partitions are parsed
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Parse into data block, find Module Attributes extension, and get compressed size from there
|
||
|
|
UINT32 offset = 0;
|
||
|
|
UINT32 length = 0xFFFFFFFF; // Special guardian value
|
||
|
|
UByteArray partition = directory.mid(partitions[i].ptEntry.Offset.Offset, partitions[i].ptEntry.Length);
|
||
|
|
while (offset < (UINT32)partition.size()) {
|
||
|
|
const ME_CPD_EXTENTION_HEADER* extHeader = (const ME_CPD_EXTENTION_HEADER*) (partition.constData() + offset);
|
||
|
|
if (extHeader->Length <= ((UINT32)partition.size() - offset)) {
|
||
|
|
if (extHeader->Type == 10) { //TODO: replace with defines
|
||
|
|
const ME_CPD_EXT_MODULE_ATTRIBUTES* attrHeader = (const ME_CPD_EXT_MODULE_ATTRIBUTES*)(partition.constData() + offset);
|
||
|
|
length = attrHeader->CompressedSize;
|
||
|
|
}
|
||
|
|
offset += extHeader->Length;
|
||
|
|
}
|
||
|
|
else break;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Search down for corresponding code partition
|
||
|
|
// Construct it's name by replacing last 4 non-zero butes of the name with zeros
|
||
|
|
UINT32 j = 0;
|
||
|
|
for (UINT32 k = 11; k > 0 && j < 4; k--) {
|
||
|
|
if (name[k] != '\x00') {
|
||
|
|
name[k] = '\x00';
|
||
|
|
j++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Search
|
||
|
|
j = i + 1;
|
||
|
|
while (j < partitions.size()) {
|
||
|
|
if (name == usprintf("%c%c%c%c%c%c%c%c%c%c%c%c",
|
||
|
|
partitions[j].ptEntry.EntryName[0], partitions[j].ptEntry.EntryName[1], partitions[j].ptEntry.EntryName[2], partitions[j].ptEntry.EntryName[3],
|
||
|
|
partitions[j].ptEntry.EntryName[4], partitions[j].ptEntry.EntryName[5], partitions[j].ptEntry.EntryName[6], partitions[j].ptEntry.EntryName[7],
|
||
|
|
partitions[j].ptEntry.EntryName[8], partitions[j].ptEntry.EntryName[9], partitions[j].ptEntry.EntryName[10], partitions[j].ptEntry.EntryName[11])) {
|
||
|
|
// Found it, update it's Length if needed
|
||
|
|
if (partitions[j].ptEntry.Offset.HuffmanCompressed) {
|
||
|
|
partitions[j].ptEntry.Length = length;
|
||
|
|
}
|
||
|
|
else if (length != 0xFFFFFFFF && partitions[j].ptEntry.Length != length) {
|
||
|
|
msg(usprintf("%s: partition size mismatch between partition table (%Xh) and partition metadata (%Xh)", __FUNCTION__,
|
||
|
|
partitions[j].ptEntry.Length, length), partitions[j].index);
|
||
|
|
partitions[j].ptEntry.Length = length; // Believe metadata
|
||
|
|
}
|
||
|
|
// No need to search further
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
// Check the next partition
|
||
|
|
j++;
|
||
|
|
}
|
||
|
|
// Check the next partition
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
|
||
|
|
make_partition_table_consistent:
|
||
|
|
// Sort partitions by offset
|
||
|
|
std::sort(partitions.begin(), partitions.end());
|
||
|
|
|
||
|
|
// Check for intersections and paddings between partitions
|
||
|
|
ME_CPD_PARTITION_INFO padding;
|
||
|
|
|
||
|
|
// Check intersection with the partition table header
|
||
|
|
if (partitions.front().ptEntry.Offset.Offset < ptSize) {
|
||
|
|
msg(usprintf("%s: CPD partition has intersection with CPD partition table, skipped", __FUNCTION__),
|
||
|
|
partitions.front().index);
|
||
|
|
partitions.erase(partitions.begin());
|
||
|
|
goto make_partition_table_consistent;
|
||
|
|
}
|
||
|
|
// Check for padding between partition table and the first partition
|
||
|
|
else if (partitions.front().ptEntry.Offset.Offset > ptSize) {
|
||
|
|
padding.ptEntry.Offset.Offset = ptSize;
|
||
|
|
padding.ptEntry.Length = partitions.front().ptEntry.Offset.Offset - padding.ptEntry.Offset.Offset;
|
||
|
|
padding.type = Types::Padding;
|
||
|
|
partitions.insert(partitions.begin(), padding);
|
||
|
|
}
|
||
|
|
// Check for intersections/paddings between partitions
|
||
|
|
for (size_t i = 1; i < partitions.size(); i++) {
|
||
|
|
UINT32 previousPartitionEnd = partitions[i - 1].ptEntry.Offset.Offset + partitions[i - 1].ptEntry.Length;
|
||
|
|
|
||
|
|
// Check that current region is fully present in the image
|
||
|
|
if ((UINT64)partitions[i].ptEntry.Offset.Offset + (UINT64)partitions[i].ptEntry.Length > (UINT64)directory.size()) {
|
||
|
|
if ((UINT64)partitions[i].ptEntry.Offset.Offset >= (UINT64)directory.size()) {
|
||
|
|
msg(usprintf("%s: CPD partition is located outside of the opened image, skipped", __FUNCTION__), partitions[i].index);
|
||
|
|
partitions.erase(partitions.begin() + i);
|
||
|
|
goto make_partition_table_consistent;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
msg(usprintf("%s: CPD partition can't fit into it's region, truncated", __FUNCTION__), partitions[i].index);
|
||
|
|
partitions[i].ptEntry.Length = (UINT32)directory.size() - (UINT32)partitions[i].ptEntry.Offset.Offset;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Check for intersection with previous partition
|
||
|
|
if (partitions[i].ptEntry.Offset.Offset < previousPartitionEnd) {
|
||
|
|
// Check if current partition is located inside previous one
|
||
|
|
if (partitions[i].ptEntry.Offset.Offset + partitions[i].ptEntry.Length <= previousPartitionEnd) {
|
||
|
|
msg(usprintf("%s: CPD partition is located inside another CPD partition, skipped", __FUNCTION__),
|
||
|
|
partitions[i].index);
|
||
|
|
partitions.erase(partitions.begin() + i);
|
||
|
|
goto make_partition_table_consistent;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
msg(usprintf("%s: CPD partition intersects with prevous one, skipped", __FUNCTION__),
|
||
|
|
partitions[i].index);
|
||
|
|
partitions.erase(partitions.begin() + i);
|
||
|
|
goto make_partition_table_consistent;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// Check for padding between current and previous partitions
|
||
|
|
else if (partitions[i].ptEntry.Offset.Offset > previousPartitionEnd) {
|
||
|
|
padding.ptEntry.Offset.Offset = previousPartitionEnd;
|
||
|
|
padding.ptEntry.Length = partitions[i].ptEntry.Offset.Offset - previousPartitionEnd;
|
||
|
|
padding.type = Types::Padding;
|
||
|
|
std::vector<ME_CPD_PARTITION_INFO>::iterator iter = partitions.begin();
|
||
|
|
std::advance(iter, i);
|
||
|
|
partitions.insert(iter, padding);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// Check for padding after the last region
|
||
|
|
if ((UINT64)partitions.back().ptEntry.Offset.Offset + (UINT64)partitions.back().ptEntry.Length < (UINT64)directory.size()) {
|
||
|
|
padding.ptEntry.Offset.Offset = partitions.back().ptEntry.Offset.Offset + partitions.back().ptEntry.Length;
|
||
|
|
padding.ptEntry.Length = (UINT32)directory.size() - padding.ptEntry.Offset.Offset;
|
||
|
|
padding.type = Types::Padding;
|
||
|
|
partitions.push_back(padding);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Partition map is consistent
|
||
|
|
for (size_t i = 0; i < partitions.size(); i++) {
|
||
|
|
if (partitions[i].type == Types::CpdPartition) {
|
||
|
|
UByteArray partition = directory.mid(partitions[i].ptEntry.Offset.Offset, partitions[i].ptEntry.Length);
|
||
|
|
|
||
|
|
// Get info
|
||
|
|
name = usprintf("%c%c%c%c%c%c%c%c%c%c%c%c",
|
||
|
|
partitions[i].ptEntry.EntryName[0], partitions[i].ptEntry.EntryName[1], partitions[i].ptEntry.EntryName[2], partitions[i].ptEntry.EntryName[3],
|
||
|
|
partitions[i].ptEntry.EntryName[4], partitions[i].ptEntry.EntryName[5], partitions[i].ptEntry.EntryName[6], partitions[i].ptEntry.EntryName[7],
|
||
|
|
partitions[i].ptEntry.EntryName[8], partitions[i].ptEntry.EntryName[9], partitions[i].ptEntry.EntryName[10], partitions[i].ptEntry.EntryName[11]);
|
||
|
|
|
||
|
|
// It's a manifest
|
||
|
|
if (name.contains(".man")) {
|
||
|
|
if (!partitions[i].ptEntry.Offset.HuffmanCompressed
|
||
|
|
&& partitions[i].ptEntry.Length >= sizeof(ME_CPD_MANIFEST_HEADER)) {
|
||
|
|
const ME_CPD_MANIFEST_HEADER* manifestHeader = (const ME_CPD_MANIFEST_HEADER*) partition.constData();
|
||
|
|
if (manifestHeader->HeaderId == ME_MANIFEST_HEADER_ID) {
|
||
|
|
UByteArray header = partition.left(manifestHeader->HeaderLength * sizeof(UINT32));
|
||
|
|
UByteArray body = partition.mid(header.size());
|
||
|
|
|
||
|
|
info += usprintf(
|
||
|
|
"\nHeader type: %u\nHeader length: %Xh (%u)\nHeader version: %Xh\nFlags: %08Xh\nVendor: %Xh\n"
|
||
|
|
"Date: %Xh\nSize: %Xh (%u)\nVersion: %u.%u.%u.%u\nSecurity version number: %u\nModulus size: %Xh (%u)\nExponent size: %Xh (%u)",
|
||
|
|
manifestHeader->HeaderType,
|
||
|
|
manifestHeader->HeaderLength * sizeof(UINT32), manifestHeader->HeaderLength * sizeof(UINT32),
|
||
|
|
manifestHeader->HeaderVersion,
|
||
|
|
manifestHeader->Flags,
|
||
|
|
manifestHeader->Vendor,
|
||
|
|
manifestHeader->Date,
|
||
|
|
manifestHeader->Size * sizeof(UINT32), manifestHeader->Size * sizeof(UINT32),
|
||
|
|
manifestHeader->VersionMajor, manifestHeader->VersionMinor, manifestHeader->VersionBugfix, manifestHeader->VersionBuild,
|
||
|
|
manifestHeader->SecurityVersion,
|
||
|
|
manifestHeader->ModulusSize * sizeof(UINT32), manifestHeader->ModulusSize * sizeof(UINT32),
|
||
|
|
manifestHeader->ExponentSize * sizeof(UINT32), manifestHeader->ExponentSize * sizeof(UINT32));
|
||
|
|
|
||
|
|
// Add tree item
|
||
|
|
UModelIndex partitionIndex = model->addItem(localOffset + partitions[i].ptEntry.Offset.Offset, Types::CpdPartition, Subtypes::ManifestCpdPartition, name, UString(), info, header, body, UByteArray(), Fixed, parent);
|
||
|
|
|
||
|
|
// Parse data as extensions area
|
||
|
|
parseExtensionsArea(partitionIndex);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// It's a metadata
|
||
|
|
else if (name.contains(".met")) {
|
||
|
|
info = usprintf("Full size: %Xh (%u)\nEntry offset: %Xh\nEntry length: %Xh\nHuffman compressed: ",
|
||
|
|
partition.size(), partition.size(),
|
||
|
|
partitions[i].ptEntry.Offset.Offset,
|
||
|
|
partitions[i].ptEntry.Length)
|
||
|
|
+ (partitions[i].ptEntry.Offset.HuffmanCompressed ? "Yes" : "No");
|
||
|
|
|
||
|
|
// Calculate SHA256 hash over the metadata and add it to it's info
|
||
|
|
UByteArray hash(SHA256_DIGEST_SIZE, '\x00');
|
||
|
|
sha256(partition.constData(), partition.size(), hash.data());
|
||
|
|
info += UString("\nMetadata hash: ") + UString(hash.toHex().constData());
|
||
|
|
|
||
|
|
// Add three item
|
||
|
|
UModelIndex partitionIndex = model->addItem(localOffset + partitions[i].ptEntry.Offset.Offset, Types::CpdPartition, Subtypes::MetadataCpdPartition, name, UString(), info, UByteArray(), partition, UByteArray(), Fixed, parent);
|
||
|
|
|
||
|
|
// Parse data as extensions area
|
||
|
|
parseExtensionsArea(partitionIndex);
|
||
|
|
}
|
||
|
|
// It's a key
|
||
|
|
else if (name.contains(".key")) {
|
||
|
|
info = usprintf("Full size: %Xh (%u)\nEntry offset: %Xh\nEntry length: %Xh\nHuffman compressed: ",
|
||
|
|
partition.size(), partition.size(),
|
||
|
|
partitions[i].ptEntry.Offset.Offset,
|
||
|
|
partitions[i].ptEntry.Length)
|
||
|
|
+ (partitions[i].ptEntry.Offset.HuffmanCompressed ? "Yes" : "No");
|
||
|
|
|
||
|
|
// Calculate SHA256 hash over the key and add it to it's info
|
||
|
|
UByteArray hash(SHA256_DIGEST_SIZE, '\x00');
|
||
|
|
sha256(partition.constData(), partition.size(), hash.data());
|
||
|
|
info += UString("\nHash: ") + UString(hash.toHex().constData());
|
||
|
|
|
||
|
|
// Add three item
|
||
|
|
UModelIndex partitionIndex = model->addItem(localOffset + partitions[i].ptEntry.Offset.Offset, Types::CpdPartition, Subtypes::KeyCpdPartition, name, UString(), info, UByteArray(), partition, UByteArray(), Fixed, parent);
|
||
|
|
|
||
|
|
// Parse data as extensions area
|
||
|
|
parseExtensionsArea(partitionIndex);
|
||
|
|
}
|
||
|
|
// It's a code
|
||
|
|
else {
|
||
|
|
info = usprintf("Full size: %Xh (%u)\nEntry offset: %Xh\nEntry length: %Xh\nHuffman compressed: ",
|
||
|
|
partition.size(), partition.size(),
|
||
|
|
partitions[i].ptEntry.Offset.Offset,
|
||
|
|
partitions[i].ptEntry.Length)
|
||
|
|
+ (partitions[i].ptEntry.Offset.HuffmanCompressed ? "Yes" : "No");
|
||
|
|
|
||
|
|
// Calculate SHA256 hash over the code and add it to it's info
|
||
|
|
UByteArray hash(SHA256_DIGEST_SIZE, '\x00');
|
||
|
|
sha256(partition.constData(), partition.size(), hash.data());
|
||
|
|
info += UString("\nHash: ") + UString(hash.toHex().constData());
|
||
|
|
|
||
|
|
model->addItem(localOffset + partitions[i].ptEntry.Offset.Offset, Types::CpdPartition, Subtypes::CodeCpdPartition, name, UString(), info, UByteArray(), partition, UByteArray(), Fixed, parent);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if (partitions[i].type == Types::Padding) {
|
||
|
|
UByteArray partition = directory.mid(partitions[i].ptEntry.Offset.Offset, partitions[i].ptEntry.Length);
|
||
|
|
|
||
|
|
// Get info
|
||
|
|
name = UString("Padding");
|
||
|
|
info = usprintf("Full size: %Xh (%u)", partition.size(), partition.size());
|
||
|
|
|
||
|
|
// Add tree item
|
||
|
|
model->addItem(localOffset + partitions[i].ptEntry.Offset.Offset, Types::Padding, getPaddingType(partition), name, UString(), info, UByteArray(), partition, UByteArray(), Fixed, parent);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
msg(usprintf("%s: CPD partition of unknown type found", __FUNCTION__), parent);
|
||
|
|
return U_INVALID_ME_PARTITION_TABLE;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return U_SUCCESS;
|
||
|
|
}
|
||
|
|
|
||
|
|
USTATUS MeParser::parseExtensionsArea(const UModelIndex & index)
|
||
|
|
{
|
||
|
|
if (!index.isValid()) {
|
||
|
|
return U_INVALID_PARAMETER;
|
||
|
|
}
|
||
|
|
|
||
|
|
UByteArray body = model->body(index);
|
||
|
|
UINT32 offset = 0;
|
||
|
|
while (offset < (UINT32)body.size()) {
|
||
|
|
const ME_CPD_EXTENTION_HEADER* extHeader = (const ME_CPD_EXTENTION_HEADER*) (body.constData() + offset);
|
||
|
|
if (extHeader->Length <= ((UINT32)body.size() - offset)) {
|
||
|
|
UByteArray partition = body.mid(offset, extHeader->Length);
|
||
|
|
|
||
|
|
UString name = meExtensionTypeToUstring(extHeader->Type);
|
||
|
|
UString info = usprintf("Full size: %Xh (%u)\nType: %Xh", partition.size(), partition.size(), extHeader->Type);
|
||
|
|
|
||
|
|
// Parse Signed Package Info a bit further
|
||
|
|
bool parsed = false;
|
||
|
|
if (extHeader->Type == 15) {
|
||
|
|
UByteArray header = partition.left(sizeof(ME_CPD_EXT_SIGNED_PACKAGE_INFO));
|
||
|
|
UByteArray data = partition.mid(header.size());
|
||
|
|
|
||
|
|
const ME_CPD_EXT_SIGNED_PACKAGE_INFO* infoHeader = (const ME_CPD_EXT_SIGNED_PACKAGE_INFO*)header.constData();
|
||
|
|
|
||
|
|
info = usprintf("Full size: %Xh (%u)\nHeader size: %Xh (%u)\nBody size: %Xh (%u)\nType: %Xh\n"
|
||
|
|
"Package name: %c%c%c%c\nVersion control number: %Xh\nSecurity version number: %Xh\n"
|
||
|
|
"Usage bitmap: %02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X",
|
||
|
|
partition.size(), partition.size(),
|
||
|
|
header.size(), header.size(),
|
||
|
|
body.size(), body.size(),
|
||
|
|
infoHeader->ExtensionType,
|
||
|
|
infoHeader->PackageName[0], infoHeader->PackageName[1], infoHeader->PackageName[2], infoHeader->PackageName[3],
|
||
|
|
infoHeader->Vcn,
|
||
|
|
infoHeader->Svn,
|
||
|
|
infoHeader->UsageBitmap[0], infoHeader->UsageBitmap[1], infoHeader->UsageBitmap[2], infoHeader->UsageBitmap[3],
|
||
|
|
infoHeader->UsageBitmap[4], infoHeader->UsageBitmap[5], infoHeader->UsageBitmap[6], infoHeader->UsageBitmap[7],
|
||
|
|
infoHeader->UsageBitmap[8], infoHeader->UsageBitmap[9], infoHeader->UsageBitmap[10], infoHeader->UsageBitmap[11],
|
||
|
|
infoHeader->UsageBitmap[12], infoHeader->UsageBitmap[13], infoHeader->UsageBitmap[14], infoHeader->UsageBitmap[15]);
|
||
|
|
|
||
|
|
// Add tree item
|
||
|
|
UModelIndex infoIndex = model->addItem(offset, Types::CpdExtension, 0, name, UString(), info, header, data, UByteArray(), Fixed, index);
|
||
|
|
parseSignedPackageInfoData(infoIndex);
|
||
|
|
parsed = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Parse IFWI Partition Manifest a bit further
|
||
|
|
else if (extHeader->Type == 22) {
|
||
|
|
const ME_CPD_EXT_IFWI_PARTITION_MANIFEST* attrHeader = (const ME_CPD_EXT_IFWI_PARTITION_MANIFEST*)partition.constData();
|
||
|
|
|
||
|
|
// This hash is stored reversed, because why the hell not
|
||
|
|
// Need to reverse it back to normal
|
||
|
|
UByteArray hash((const char*)&attrHeader->CompletePartitionHash, sizeof(attrHeader->CompletePartitionHash));
|
||
|
|
std::reverse(hash.begin(), hash.end());
|
||
|
|
|
||
|
|
info = usprintf("Full size: %Xh (%u)\nType: %Xh\n"
|
||
|
|
"Partition name: %c%c%c%c\nPartition length: %Xh\nPartition version major: %Xh\nPartition version minor: %Xh\n"
|
||
|
|
"Data format version: %Xh\nInstance ID: %Xh\nHash algorithm: %Xh\nHash size: %Xh\nAction on update: %Xh",
|
||
|
|
partition.size(), partition.size(),
|
||
|
|
attrHeader->ExtensionType,
|
||
|
|
attrHeader->PartitionName[0], attrHeader->PartitionName[1], attrHeader->PartitionName[2], attrHeader->PartitionName[3],
|
||
|
|
attrHeader->CompletePartitionLength,
|
||
|
|
attrHeader->PartitionVersionMajor, attrHeader->PartitionVersionMinor,
|
||
|
|
attrHeader->DataFormatVersion,
|
||
|
|
attrHeader->InstanceId,
|
||
|
|
attrHeader->HashAlgorithm,
|
||
|
|
attrHeader->HashSize,
|
||
|
|
attrHeader->ActionOnUpdate)
|
||
|
|
+ UString("\nSupport multiple instances: ") + (attrHeader->SupportMultipleInstances ? "Yes" : "No")
|
||
|
|
+ UString("\nSupport API version based update: ") + (attrHeader->SupportApiVersionBasedUpdate ? "Yes" : "No")
|
||
|
|
+ UString("\nObey full update rules: ") + (attrHeader->ObeyFullUpdateRules ? "Yes" : "No")
|
||
|
|
+ UString("\nIFR enable only: ") + (attrHeader->IfrEnableOnly ? "Yes" : "No")
|
||
|
|
+ UString("\nAllow cross point update: ") + (attrHeader->AllowCrossPointUpdate ? "Yes" : "No")
|
||
|
|
+ UString("\nAllow cross hotfix update: ") + (attrHeader->AllowCrossHotfixUpdate ? "Yes" : "No")
|
||
|
|
+ UString("\nPartial update only: ") + (attrHeader->PartialUpdateOnly ? "Yes" : "No")
|
||
|
|
+ UString("\nPartition hash: ") + UString(hash.toHex().constData());
|
||
|
|
|
||
|
|
// Add tree item
|
||
|
|
model->addItem(offset, Types::CpdExtension, 0, name, UString(), info, UByteArray(), partition, UByteArray(), Fixed, index);
|
||
|
|
parsed = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Parse Module Attributes a bit further
|
||
|
|
else if (extHeader->Type == 10) {
|
||
|
|
const ME_CPD_EXT_MODULE_ATTRIBUTES* attrHeader = (const ME_CPD_EXT_MODULE_ATTRIBUTES*)partition.constData();
|
||
|
|
|
||
|
|
// This hash is stored reversed, because why the hell not
|
||
|
|
// Need to reverse it back to normal
|
||
|
|
UByteArray hash((const char*)&attrHeader->ImageHash, sizeof(attrHeader->ImageHash));
|
||
|
|
std::reverse(hash.begin(), hash.end());
|
||
|
|
|
||
|
|
info = usprintf("Full size: %Xh (%u)\nType: %Xh\n"
|
||
|
|
"Compression type: %Xh\nUncompressed size: %Xh (%u)\nCompressed size: %Xh (%u)\nGlobal module ID: %Xh\nImage hash: ",
|
||
|
|
partition.size(), partition.size(),
|
||
|
|
attrHeader->ExtensionType,
|
||
|
|
attrHeader->CompressionType,
|
||
|
|
attrHeader->UncompressedSize, attrHeader->UncompressedSize,
|
||
|
|
attrHeader->CompressedSize, attrHeader->CompressedSize,
|
||
|
|
attrHeader->GlobalModuleId) + UString(hash.toHex().constData());
|
||
|
|
|
||
|
|
// Add tree item
|
||
|
|
model->addItem(offset, Types::CpdExtension, 0, name, UString(), info, UByteArray(), partition, UByteArray(), Fixed, index);
|
||
|
|
parsed = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!parsed) {
|
||
|
|
// Add tree item, if needed
|
||
|
|
model->addItem(offset, Types::CpdExtension, 0, name, UString(), info, UByteArray(), partition, UByteArray(), Fixed, index);
|
||
|
|
}
|
||
|
|
|
||
|
|
offset += extHeader->Length;
|
||
|
|
}
|
||
|
|
else break;
|
||
|
|
// TODO: add padding at the end
|
||
|
|
}
|
||
|
|
|
||
|
|
return U_SUCCESS;
|
||
|
|
}
|
||
|
|
|
||
|
|
USTATUS MeParser::parseSignedPackageInfoData(const UModelIndex & index)
|
||
|
|
{
|
||
|
|
if (!index.isValid()) {
|
||
|
|
return U_INVALID_PARAMETER;
|
||
|
|
}
|
||
|
|
|
||
|
|
UByteArray body = model->body(index);
|
||
|
|
UINT32 offset = 0;
|
||
|
|
while (offset < (UINT32)body.size()) {
|
||
|
|
const ME_CPD_EXT_SIGNED_PACKAGE_INFO_MODULES* moduleHeader = (const ME_CPD_EXT_SIGNED_PACKAGE_INFO_MODULES*)(body.constData() + offset);
|
||
|
|
if (sizeof(ME_CPD_EXT_SIGNED_PACKAGE_INFO_MODULES) <= ((UINT32)body.size() - offset)) {
|
||
|
|
UByteArray module((const char*)moduleHeader,sizeof(ME_CPD_EXT_SIGNED_PACKAGE_INFO_MODULES));
|
||
|
|
|
||
|
|
UString name = usprintf("%c%c%c%c%c%c%c%c%c%c%c%c",
|
||
|
|
moduleHeader->Name[0], moduleHeader->Name[1], moduleHeader->Name[2], moduleHeader->Name[3],
|
||
|
|
moduleHeader->Name[4], moduleHeader->Name[5], moduleHeader->Name[6], moduleHeader->Name[7],
|
||
|
|
moduleHeader->Name[8], moduleHeader->Name[9], moduleHeader->Name[10],moduleHeader->Name[11]);
|
||
|
|
|
||
|
|
// This hash is stored reversed, because why the hell not
|
||
|
|
// Need to reverse it back to normal
|
||
|
|
UByteArray hash((const char*)&moduleHeader->MetadataHash, sizeof(moduleHeader->MetadataHash));
|
||
|
|
std::reverse(hash.begin(), hash.end());
|
||
|
|
|
||
|
|
UString info = usprintf("Full size: %X (%u)\nType: %Xh\nHash algorithm: %Xh\nHash size: %Xh (%u)\nMetadata size: %Xh (%u)\nMetadata hash: ",
|
||
|
|
module.size(), module.size(),
|
||
|
|
moduleHeader->Type,
|
||
|
|
moduleHeader->HashAlgorithm,
|
||
|
|
moduleHeader->HashSize, moduleHeader->HashSize,
|
||
|
|
moduleHeader->MetadataSize, moduleHeader->MetadataSize) + UString(hash.toHex().constData());
|
||
|
|
// Add tree otem
|
||
|
|
model->addItem(offset, Types::CpdSpiEntry, 0, name, UString(), info, UByteArray(), module, UByteArray(), Fixed, index);
|
||
|
|
|
||
|
|
offset += module.size();
|
||
|
|
}
|
||
|
|
else break;
|
||
|
|
// TODO: add padding at the end
|
||
|
|
}
|
||
|
|
|
||
|
|
return U_SUCCESS;
|
||
|
|
}
|
||
|
|
|
||
|
|
#endif // U_ENABLE_ME_PARSING_SUPPORT
|
||
|
|
|