partition_parser.cpp

Go to the documentation of this file.

#include "partition_parser.hpp"
#include "i18n.hpp"
 
#include <array>
#include <iomanip>
#include <sstream>
#include <string>
#include <vector>
 
namespace {
 
uint32_t le32(const unsigned char* p) {
    return static_cast<uint32_t>(p[0]) |
           (static_cast<uint32_t>(p[1]) << 8) |
           (static_cast<uint32_t>(p[2]) << 16) |
           (static_cast<uint32_t>(p[3]) << 24);
}
 
uint64_t le64(const unsigned char* p) {
    return static_cast<uint64_t>(p[0]) |
           (static_cast<uint64_t>(p[1]) << 8) |
           (static_cast<uint64_t>(p[2]) << 16) |
           (static_cast<uint64_t>(p[3]) << 24) |
           (static_cast<uint64_t>(p[4]) << 32) |
           (static_cast<uint64_t>(p[5]) << 40) |
           (static_cast<uint64_t>(p[6]) << 48) |
           (static_cast<uint64_t>(p[7]) << 56);
}
 
std::string hex2(unsigned v) {
    std::ostringstream oss;
    oss << "0x" << std::hex << std::uppercase << std::setw(2) << std::setfill('0') << v;
    return oss.str();
}
 
// Bug #8 fix: read GPT entries from a given header offset using the disk's
// actual logical sector size, not a hardcoded 512.
bool parse_gpt_table(DiskReader& reader,
                     uint64_t header_lba,
                     uint32_t sector_size,
                     std::vector<ScanResult>& out,
                     std::vector<std::string>& logs,
                     bool is_backup) {
    std::array<unsigned char, 92> hdr{};
    const uint64_t header_offset = header_lba * sector_size;
 
    if (!reader.read_at(header_offset, hdr.data(), hdr.size())) {
        logs.push_back(std::string("GPT: header read failed at offset ") + std::to_string(header_offset));
        return false;
    }
 
    if (std::string(reinterpret_cast<const char*>(hdr.data()), 8) != "EFI PART") {
        if (is_backup) {
            logs.push_back(trs("GPT: backup EFI PART signature not found."));
        } else {
            logs.push_back(trs("GPT: EFI PART header not found."));
        }
        return false;
    }
 
    const uint64_t table_lba = le64(hdr.data() + 72);
    const uint32_t num_entries = le32(hdr.data() + 80);
    const uint32_t entry_size = le32(hdr.data() + 84);
 
    if (num_entries == 0 || entry_size < 128 || entry_size > 4096) {
        logs.push_back(trs("GPT: invalid partition table."));
        return false;
    }
 
    const uint64_t table_offset = table_lba * sector_size;
 
    for (uint32_t i = 0; i < num_entries; ++i) {
        std::vector<unsigned char> entry(entry_size);
        if (!reader.read_at(table_offset + static_cast<uint64_t>(i) * entry_size,
                            entry.data(), entry.size())) {
            break;
        }
 
        // Bug #21 fix: check both type GUID AND first/last LBA for empty entry
        bool type_guid_zero = true;
        for (size_t k = 0; k < 16; ++k) {
            if (entry[k] != 0) { type_guid_zero = false; break; }
        }
        const uint64_t first_lba = le64(entry.data() + 32);
        const uint64_t last_lba = le64(entry.data() + 40);
 
        if (type_guid_zero && first_lba == 0 && last_lba == 0) {
            continue;
        }
        if (last_lba < first_lba || first_lba == 0) {
            continue;
        }
 
        ScanResult r;
        r.kind = ResultKind::Partition;
        r.offset_bytes = first_lba * sector_size;
        r.size_bytes = (last_lba - first_lba + 1) * sector_size;
        r.type = is_backup ? trs("GPT partition (backup)") : trs("GPT partition");
        r.source = is_backup ? trs("GPT backup") : trs("GPT");
        r.detail = is_backup
            ? trs("GPT partition table entry (recovered from backup header)")
            : trs("GPT partition table entry");
        r.confidence = is_backup ? 0.92 : 0.98;
        out.push_back(r);
    }
 
    return true;
}
 
} // namespace
 
std::vector<ScanResult> PartitionParser::parse_mbr(DiskReader& reader, std::vector<std::string>& logs) {
    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;
}
 
std::vector<ScanResult> PartitionParser::parse_gpt(DiskReader& reader, std::vector<std::string>& logs) {
    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;
}