PartitionParser Class Reference

#include <partition_parser.hpp>

Static Public Member Functions
static std::vector< ScanResult >	parse_mbr (DiskReader &reader, std::vector< std::string > &logs)
static std::vector< ScanResult >	parse_gpt (DiskReader &reader, std::vector< std::string > &logs)

Detailed Description

Definition at line 7 of file partition_parser.hpp.

Member Function Documentation

parse_gpt()

std::vector< ScanResult > PartitionParser::parse_gpt ( DiskReader & reader, std::vector< std::string > & logs )

static

Definition at line 153 of file partition_parser.cpp.

                                                                                               {
    std::vector<ScanResult> out;
    // Bug #8 fix: dynamic sector size (4Kn drives need 4096, not 512)
    const uint32_t sector_size = reader.logical_sector_size() != 0
                                  ? reader.logical_sector_size() : 512u;
 
    // Primary GPT header is at LBA 1
    const bool primary_ok = parse_gpt_table(reader, 1, sector_size, out, logs, false);
    if (primary_ok && !out.empty()) {
        logs.push_back(trs("GPT: valid header found."));
        return out;
    }
 
    // Bug #9 fix: fall back to backup GPT header at the last sector of the disk.
    // The backup header itself sits at the very last LBA; the entry table sits
    // BEFORE it. We just read the header and trust its table_lba field.
    const uint64_t disk_size = reader.size();
    if (disk_size < static_cast<uint64_t>(sector_size) * 2) {
        return out;
    }
    const uint64_t backup_header_lba = (disk_size / sector_size) - 1;
    logs.push_back(trs("GPT: trying backup header at LBA ") + std::to_string(backup_header_lba));
 
    std::vector<ScanResult> backup_out;
    const bool backup_ok = parse_gpt_table(reader, backup_header_lba, sector_size,
                                           backup_out, logs, true);
    if (backup_ok && !backup_out.empty()) {
        logs.push_back(trs("GPT: recovered partitions from backup header."));
        return backup_out;
    }
 
    return out;
}

References DiskReader::logical_sector_size(), DiskReader::size(), and trs().

Referenced by ScannerEngine::run_scan().

parse_mbr()

std::vector< ScanResult > PartitionParser::parse_mbr ( DiskReader & reader, std::vector< std::string > & logs )

static

Definition at line 112 of file partition_parser.cpp.

                                                                                               {
    std::vector<ScanResult> out;
    // Bug #8 fix: use the disk's logical sector size for partition LBA scaling
    const uint32_t sector_size = reader.logical_sector_size() != 0
                                  ? reader.logical_sector_size() : 512u;
 
    std::vector<unsigned char> sector(sector_size);
    if (!reader.read_at(0, sector.data(), sector.size())) {
        logs.push_back(trs("MBR: read failed."));
        return out;
    }
 
    if (sector.size() < 512 || !(sector[510] == 0x55 && sector[511] == 0xAA)) {
        logs.push_back(trs("MBR: 0x55AA signature not found."));
        return out;
    }
 
    logs.push_back(trs("MBR: valid signature found."));
 
    for (int i = 0; i < 4; ++i) {
        const size_t off = 446 + static_cast<size_t>(i) * 16;
        const auto* entry = sector.data() + off;
        const unsigned char ptype = entry[4];
        const uint32_t start_lba = le32(entry + 8);
        const uint32_t num_sectors = le32(entry + 12);
        if (ptype == 0 || num_sectors == 0) {
            continue;
        }
        ScanResult r;
        r.kind = ResultKind::Partition;
        r.offset_bytes = static_cast<uint64_t>(start_lba) * sector_size;
        r.size_bytes = static_cast<uint64_t>(num_sectors) * sector_size;
        r.type = trs("MBR ") + hex2(ptype);
        r.source = trs("MBR");
        r.detail = trs("MBR partition table entry");
        r.confidence = 0.95;
        out.push_back(r);
    }
    return out;
}

References DiskReader::logical_sector_size(), Partition, DiskReader::read_at(), and trs().

Referenced by ScannerEngine::run_scan().

---

The documentation for this class was generated from the following files:

• BastionGuard/thirdparty/bastionguard-recovery-data/src/partition_parser.hpp
• BastionGuard/thirdparty/bastionguard-recovery-data/src/partition_parser.cpp