483 行
12 KiB
C++
483 行
12 KiB
C++
/*
|
|
This file is part of apfs-fuse, a read-only implementation of APFS
|
|
(Apple File System) for FUSE.
|
|
Copyright (C) 2017 Simon Gander
|
|
|
|
Apfs-fuse is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Apfs-fuse is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with apfs-fuse. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <cstring>
|
|
#include <iostream>
|
|
#include <fstream>
|
|
|
|
#include "ApfsContainer.h"
|
|
#include "ApfsVolume.h"
|
|
#include "Util.h"
|
|
#include "BlockDumper.h"
|
|
#include "Global.h"
|
|
|
|
int g_debug = 0;
|
|
bool g_lax = false;
|
|
|
|
ApfsContainer::ApfsContainer(Device *disk_main, uint64_t main_start, uint64_t main_len, Device *disk_tier2, uint64_t tier2_start, uint64_t tier2_len) :
|
|
m_main_disk(disk_main),
|
|
m_main_part_start(main_start),
|
|
m_main_part_len(main_len),
|
|
m_tier2_disk(disk_tier2),
|
|
m_tier2_part_start(tier2_start),
|
|
m_tier2_part_len(tier2_len),
|
|
m_cpm(*this),
|
|
m_omap(*this),
|
|
// m_omap_tree(*this),
|
|
m_fq_tree_mgr(*this),
|
|
m_fq_tree_vol(*this),
|
|
m_keymgr(*this)
|
|
{
|
|
m_sm = nullptr;
|
|
}
|
|
|
|
ApfsContainer::~ApfsContainer()
|
|
{
|
|
}
|
|
|
|
bool ApfsContainer::Init(xid_t req_xid)
|
|
{
|
|
std::vector<uint8_t> blk;
|
|
|
|
blk.resize(0x1000);
|
|
|
|
if (!m_main_disk->Read(blk.data(), m_main_part_start, 0x1000))
|
|
{
|
|
std::cerr << "Reading block 0 from main device failed." << std::endl;
|
|
return false;
|
|
}
|
|
|
|
memcpy(&m_nx, blk.data(), sizeof(nx_superblock_t));
|
|
|
|
if (m_nx.nx_magic != NX_MAGIC)
|
|
{
|
|
std::cerr << "This doesn't seem to be an apfs volume (invalid superblock)." << std::endl;
|
|
return false;
|
|
}
|
|
|
|
if (m_nx.nx_block_size != 0x1000)
|
|
{
|
|
blk.resize(m_nx.nx_block_size);
|
|
m_main_disk->Read(blk.data(), m_main_part_start, blk.size());
|
|
}
|
|
|
|
if (!VerifyBlock(blk.data(), blk.size()))
|
|
return false;
|
|
|
|
memcpy(&m_nx, blk.data(), sizeof(nx_superblock_t));
|
|
|
|
// Scan container for most recent superblock (might fix segfaults)
|
|
uint64_t max_xid = 0;
|
|
paddr_t max_paddr = 0;
|
|
paddr_t paddr;
|
|
std::vector<uint8_t> tmp;
|
|
|
|
tmp.resize(m_nx.nx_block_size);
|
|
|
|
for (paddr = m_nx.nx_xp_desc_base; paddr < (m_nx.nx_xp_desc_base + m_nx.nx_xp_desc_blocks); paddr++)
|
|
{
|
|
if (!ReadBlocks(tmp.data(), paddr, 1))
|
|
return false;
|
|
|
|
if (!VerifyBlock(tmp.data(), tmp.size()))
|
|
continue;
|
|
|
|
const nx_superblock_t *sb = reinterpret_cast<const nx_superblock_t *>(tmp.data());
|
|
if ((sb->nx_o.o_type & OBJECT_TYPE_MASK) != OBJECT_TYPE_NX_SUPERBLOCK)
|
|
continue;
|
|
|
|
if (req_xid) {
|
|
if (req_xid == sb->nx_o.o_xid) {
|
|
max_xid = req_xid;
|
|
max_paddr = paddr;
|
|
break;
|
|
}
|
|
} else {
|
|
if (sb->nx_o.o_xid > max_xid)
|
|
{
|
|
max_xid = sb->nx_o.o_xid;
|
|
max_paddr = paddr;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (max_paddr)
|
|
{
|
|
// if (g_debug & Dbg_Errors)
|
|
// std::cout << "Found more recent xid " << max_xid << " than superblock 0 contained (" << m_nx.nx_o.o_xid << ")." << std::endl;
|
|
if (g_debug & Dbg_Info)
|
|
std::cout << "Mounting xid different from NXSB at 0 (xid = " << m_nx.nx_o.o_xid << "). xid = " << max_xid << std::endl;
|
|
|
|
ReadBlocks(tmp.data(), max_paddr, 1);
|
|
|
|
memcpy(&m_nx, tmp.data(), sizeof(nx_superblock_t));
|
|
}
|
|
|
|
if (g_debug & Dbg_Info)
|
|
std::cout << "Mounting xid " << m_nx.nx_o.o_xid << std::endl;
|
|
|
|
if ((m_nx.nx_incompatible_features & NX_INCOMPAT_FUSION) && !m_tier2_disk)
|
|
{
|
|
std::cerr << "Need to specify two devices for a fusion drive." << std::endl;
|
|
return false;
|
|
}
|
|
|
|
if (!m_cpm.Init(m_nx.nx_xp_desc_base + m_nx.nx_xp_desc_index, m_nx.nx_xp_desc_len - 1))
|
|
{
|
|
std::cerr << "Failed to load checkpoint map" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
if (!m_omap.Init(m_nx.nx_omap_oid, m_nx.nx_o.o_xid))
|
|
{
|
|
std::cerr << "Failed to load nx omap" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
omap_res_t omr;
|
|
if (!m_cpm.Lookup(omr, m_nx.nx_spaceman_oid, m_nx.nx_o.o_xid))
|
|
{
|
|
std::cerr << "Failed to map spaceman oid" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
m_sm_data.resize(omr.size);
|
|
ReadBlocks(m_sm_data.data(), omr.paddr, omr.size / GetBlocksize());
|
|
m_sm = reinterpret_cast<const spaceman_phys_t *>(m_sm_data.data());
|
|
|
|
if (!VerifyBlock(m_sm_data.data(), m_sm_data.size())) {
|
|
std::cerr << "Checksum error in spaceman" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
if ((m_sm->sm_o.o_type & OBJECT_TYPE_MASK) != OBJECT_TYPE_SPACEMAN)
|
|
{
|
|
std::cerr << "Spaceman has wrong type " << m_sm->sm_o.o_type << std::endl;
|
|
return false;
|
|
}
|
|
|
|
if (m_sm->sm_fq[SFQ_IP].sfq_tree_oid != 0)
|
|
m_fq_tree_mgr.Init(m_sm->sm_fq[SFQ_IP].sfq_tree_oid, m_sm->sm_o.o_xid, &m_cpm);
|
|
|
|
if (m_sm->sm_fq[SFQ_MAIN].sfq_tree_oid != 0)
|
|
m_fq_tree_vol.Init(m_sm->sm_fq[SFQ_MAIN].sfq_tree_oid, m_sm->sm_o.o_xid, &m_cpm);
|
|
|
|
// m_omap_tree.Init(m_nx.nx_omap_oid, m_nx.hdr.o_xid, nullptr);
|
|
|
|
// m_sb.nx_spaceman_oid
|
|
|
|
if ((m_nx.nx_keylocker.pr_start_addr != 0) && (m_nx.nx_keylocker.pr_block_count != 0))
|
|
{
|
|
if (!m_keymgr.Init(m_nx.nx_keylocker.pr_start_addr, m_nx.nx_keylocker.pr_block_count, m_nx.nx_uuid))
|
|
{
|
|
std::cerr << "Initialization of KeyManager failed." << std::endl;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
ApfsVolume *ApfsContainer::GetVolume(unsigned int fsid, const std::string &passphrase, xid_t snap_xid)
|
|
{
|
|
ApfsVolume *vol = nullptr;
|
|
oid_t oid;
|
|
omap_res_t omr;
|
|
bool rc;
|
|
|
|
if (fsid >= 100)
|
|
return nullptr;
|
|
|
|
m_passphrase = passphrase;
|
|
|
|
oid = m_nx.nx_fs_oid[fsid];
|
|
|
|
if (oid == 0)
|
|
return nullptr;
|
|
|
|
if (!m_omap.Lookup(omr, oid, m_nx.nx_o.o_xid))
|
|
return nullptr;
|
|
|
|
// std::cout << std::hex << "Loading Volume " << index << ", nodeid = " << nodeid << ", version = " << m_sb.hdr.version << ", blkid = " << blkid << std::endl;
|
|
|
|
if (omr.paddr == 0)
|
|
return nullptr;
|
|
|
|
vol = new ApfsVolume(*this);
|
|
if (snap_xid != 0)
|
|
rc = vol->MountSnapshot(omr.paddr, snap_xid);
|
|
else
|
|
rc = vol->Init(omr.paddr);
|
|
|
|
if (rc == false)
|
|
{
|
|
delete vol;
|
|
vol = nullptr;
|
|
}
|
|
|
|
return vol;
|
|
}
|
|
|
|
bool ApfsContainer::GetVolumeInfo(unsigned int fsid, apfs_superblock_t& apsb)
|
|
{
|
|
oid_t oid;
|
|
omap_res_t omr;
|
|
std::vector<uint8_t> apsb_raw;
|
|
|
|
if (fsid >= NX_MAX_FILE_SYSTEMS)
|
|
return false;
|
|
|
|
oid = m_nx.nx_fs_oid[fsid];
|
|
|
|
if (oid == 0)
|
|
return false;
|
|
|
|
if (!m_omap.Lookup(omr, oid, m_nx.nx_o.o_xid))
|
|
return false;
|
|
|
|
if (omr.paddr == 0)
|
|
return false;
|
|
|
|
apsb_raw.resize(GetBlocksize());
|
|
|
|
if (!ReadAndVerifyHeaderBlock(apsb_raw.data(), omr.paddr))
|
|
return false;
|
|
|
|
memcpy(&apsb, apsb_raw.data(), sizeof(apfs_superblock_t));
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool ApfsContainer::ReadBlocks(uint8_t * data, paddr_t paddr, uint64_t blkcnt) const
|
|
{
|
|
uint64_t offs;
|
|
uint64_t size;
|
|
|
|
//if ((paddr + blkcnt) > m_nx.nx_block_count)
|
|
// return false;
|
|
|
|
offs = m_nx.nx_block_size * paddr;
|
|
size = m_nx.nx_block_size * blkcnt;
|
|
|
|
if (offs & FUSION_TIER2_DEVICE_BYTE_ADDR)
|
|
{
|
|
if (!m_tier2_disk)
|
|
return false;
|
|
|
|
offs = offs - FUSION_TIER2_DEVICE_BYTE_ADDR + m_tier2_part_start;
|
|
return m_tier2_disk->Read(data, offs, size);
|
|
}
|
|
else
|
|
{
|
|
if (!m_main_disk)
|
|
return false;
|
|
|
|
offs = offs + m_main_part_start;
|
|
return m_main_disk->Read(data, offs, size);
|
|
}
|
|
}
|
|
|
|
bool ApfsContainer::ReadAndVerifyHeaderBlock(uint8_t * data, paddr_t paddr) const
|
|
{
|
|
if (!ReadBlocks(data, paddr))
|
|
return false;
|
|
|
|
if (!VerifyBlock(data, m_nx.nx_block_size)) {
|
|
if (g_debug & Dbg_Errors) {
|
|
std::cerr << "ReadAndVerifyHeaderBlock checksum error." << std::endl;
|
|
DumpHex(std::cerr, data, m_nx.nx_block_size);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ApfsContainer::GetVolumeKey(uint8_t *key, const apfs_uuid_t & vol_uuid, const char *password)
|
|
{
|
|
if (!m_keymgr.IsValid())
|
|
return false;
|
|
|
|
if (password)
|
|
{
|
|
return m_keymgr.GetVolumeKey(key, vol_uuid, password);
|
|
}
|
|
else
|
|
{
|
|
if (m_passphrase.empty())
|
|
return false;
|
|
|
|
return m_keymgr.GetVolumeKey(key, vol_uuid, m_passphrase.c_str());
|
|
}
|
|
}
|
|
|
|
bool ApfsContainer::GetPasswordHint(std::string & hint, const apfs_uuid_t & vol_uuid)
|
|
{
|
|
return m_keymgr.GetPasswordHint(hint, vol_uuid);
|
|
}
|
|
|
|
void ApfsContainer::dump(BlockDumper& bd)
|
|
{
|
|
std::vector<uint8_t> blk;
|
|
paddr_t paddr;
|
|
uint32_t index;
|
|
uint32_t last_index;
|
|
|
|
bd.st() << "Dumping Container" << std::endl;
|
|
bd.st() << "-----------------" << std::endl;
|
|
bd.st() << std::endl;
|
|
bd.st() << std::endl;
|
|
|
|
blk.resize(GetBlocksize());
|
|
ReadAndVerifyHeaderBlock(blk.data(), 0);
|
|
|
|
bd.DumpNode(blk.data(), 0);
|
|
|
|
#if 1
|
|
if (m_keymgr.IsValid())
|
|
m_keymgr.dump(bd.st());
|
|
#endif
|
|
|
|
/*
|
|
if (m_keybag.size())
|
|
bd.DumpNode(m_keybag.data(), m_sb.keybag_blk_start);
|
|
*/
|
|
|
|
#if 0
|
|
for (paddr = m_nx.nx_xp_desc_base; paddr < (m_nx.nx_xp_desc_base + m_nx.nx_xp_desc_blocks); paddr++)
|
|
{
|
|
ReadAndVerifyHeaderBlock(blk.data(), paddr);
|
|
bd.DumpNode(blk.data(), paddr);
|
|
}
|
|
#endif
|
|
#if 0
|
|
for (paddr = m_nx.nx_xp_data_base; paddr < (m_nx.nx_xp_data_base + m_nx.nx_xp_data_blocks); paddr++)
|
|
{
|
|
ReadAndVerifyHeaderBlock(blk.data(), paddr);
|
|
bd.DumpNode(blk.data(), paddr);
|
|
}
|
|
#endif
|
|
|
|
#if 1
|
|
bd.st() << std::endl << "Dumping XP desc area (current SB):" << std::endl;
|
|
paddr = m_nx.nx_xp_desc_base;
|
|
last_index = m_nx.nx_xp_desc_index + m_nx.nx_xp_desc_len;
|
|
if (last_index >= m_nx.nx_xp_desc_blocks)
|
|
last_index -= m_nx.nx_xp_desc_blocks;
|
|
|
|
for (index = m_nx.nx_xp_desc_index; index != last_index;)
|
|
{
|
|
ReadAndVerifyHeaderBlock(blk.data(), paddr + index);
|
|
bd.DumpNode(blk.data(), paddr + index);
|
|
index++;
|
|
if (index >= m_nx.nx_xp_desc_blocks)
|
|
index -= m_nx.nx_xp_desc_blocks;
|
|
}
|
|
|
|
bd.st() << std::endl << "Dumping XP data area (current SB):" << std::endl;
|
|
paddr = m_nx.nx_xp_data_base;
|
|
last_index = m_nx.nx_xp_data_index + m_nx.nx_xp_data_len;
|
|
if (last_index >= m_nx.nx_xp_data_blocks)
|
|
last_index -= m_nx.nx_xp_data_blocks;
|
|
|
|
for (index = m_nx.nx_xp_data_index; index != last_index;)
|
|
{
|
|
ReadAndVerifyHeaderBlock(blk.data(), paddr + index);
|
|
bd.DumpNode(blk.data(), paddr + index);
|
|
index++;
|
|
if (index >= m_nx.nx_xp_data_blocks)
|
|
index -= m_nx.nx_xp_data_blocks;
|
|
}
|
|
#endif
|
|
|
|
if (m_nx.nx_efi_jumpstart)
|
|
{
|
|
ReadAndVerifyHeaderBlock(blk.data(), m_nx.nx_efi_jumpstart);
|
|
bd.DumpNode(blk.data(), m_nx.nx_efi_jumpstart);
|
|
}
|
|
|
|
ReadAndVerifyHeaderBlock(blk.data(), m_nx.nx_omap_oid);
|
|
bd.DumpNode(blk.data(), m_nx.nx_omap_oid);
|
|
|
|
{
|
|
size_t bs = bd.GetBlockSize();
|
|
bd.SetBlockSize(m_sm_data.size());
|
|
bd.DumpNode(m_sm_data.data(), m_nx.nx_spaceman_oid);
|
|
bd.SetBlockSize(bs);
|
|
}
|
|
|
|
uint64_t oid;
|
|
size_t k;
|
|
|
|
for (k = 0; k < m_sm->sm_ip_bm_block_count; k++)
|
|
{
|
|
oid = m_sm->sm_ip_bm_base + k;
|
|
|
|
bd.st() << "Dumping IP Bitmap block " << k << std::endl;
|
|
|
|
ReadBlocks(blk.data(), oid);
|
|
bd.DumpNode(blk.data(), oid);
|
|
|
|
bd.st() << std::endl;
|
|
}
|
|
|
|
m_omap.dump(bd);
|
|
// m_omap_tree.dump(bd);
|
|
m_fq_tree_mgr.dump(bd);
|
|
m_fq_tree_vol.dump(bd);
|
|
|
|
const le_uint64_t *cxb_oid = reinterpret_cast<const le_uint64_t *>(m_sm_data.data() + m_sm->sm_dev[SD_MAIN].sm_addr_offset);
|
|
uint32_t cib_cnt = m_sm->sm_dev[SD_MAIN].sm_cib_count;
|
|
uint32_t cab_cnt = m_sm->sm_dev[SD_MAIN].sm_cab_count;
|
|
|
|
uint32_t cib_id;
|
|
uint32_t cab_id;
|
|
|
|
std::vector<uint64_t> cib_oid_list;
|
|
std::vector<uint8_t> cib_data(GetBlocksize());
|
|
|
|
cib_oid_list.reserve(cib_cnt);
|
|
|
|
if (cab_cnt != 0)
|
|
{
|
|
for (cab_id = 0; cab_id < cab_cnt; cab_id++)
|
|
{
|
|
ReadAndVerifyHeaderBlock(blk.data(), cxb_oid[cab_id]);
|
|
bd.DumpNode(blk.data(), cxb_oid[cab_id]);
|
|
|
|
const cib_addr_block_t *cab = reinterpret_cast<cib_addr_block_t *>(blk.data());
|
|
|
|
for (cib_id = 0; cib_id < cab->cab_cib_count; cib_id++)
|
|
cib_oid_list.push_back(cab->cab_cib_addr[cib_id]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (cib_id = 0; cib_id < cib_cnt; cib_id++)
|
|
cib_oid_list.push_back(cxb_oid[cib_id]);
|
|
}
|
|
|
|
for (cib_id = 0; cib_id < cib_cnt; cib_id++)
|
|
{
|
|
ReadAndVerifyHeaderBlock(blk.data(), cib_oid_list[cib_id]);
|
|
bd.DumpNode(blk.data(), cib_oid_list[cib_id]);
|
|
}
|
|
}
|