395 行
10 KiB
C++
395 行
10 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 <vector>
|
|
#include <iostream>
|
|
|
|
#include "Global.h"
|
|
|
|
#include "ApfsContainer.h"
|
|
#include "ApfsVolume.h"
|
|
#include "BlockDumper.h"
|
|
#include "Util.h"
|
|
|
|
ApfsVolume::ApfsVolume(ApfsContainer &container) :
|
|
m_container(container),
|
|
m_omap(container),
|
|
m_fs_tree(container, this),
|
|
m_extentref_tree(container, this),
|
|
m_snap_meta_tree(container, this),
|
|
m_fext_tree(container, this)
|
|
{
|
|
m_apsb_paddr = 0;
|
|
m_is_encrypted = false;
|
|
}
|
|
|
|
ApfsVolume::~ApfsVolume()
|
|
{
|
|
}
|
|
|
|
bool ApfsVolume::Init(paddr_t apsb_paddr)
|
|
{
|
|
std::vector<uint8_t> blk;
|
|
|
|
m_apsb_paddr = apsb_paddr;
|
|
|
|
blk.resize(m_container.GetBlocksize());
|
|
|
|
if (!ReadBlocks(blk.data(), apsb_paddr, 1, 0))
|
|
return false;
|
|
|
|
if (!VerifyBlock(blk.data(), blk.size()))
|
|
return false;
|
|
|
|
memcpy(&m_sb, blk.data(), sizeof(m_sb));
|
|
|
|
if (m_sb.apfs_magic != APFS_MAGIC)
|
|
return false;
|
|
|
|
if (!m_omap.Init(m_sb.apfs_omap_oid, m_sb.apfs_o.o_xid)) {
|
|
std::cerr << "WARNING: Volume omap tree init failed." << std::endl;
|
|
return false;
|
|
}
|
|
|
|
if ((m_sb.apfs_fs_flags & 3) != APFS_FS_UNENCRYPTED && !m_container.IsUnencrypted())
|
|
{
|
|
uint8_t vek[0x20];
|
|
std::string str;
|
|
|
|
std::cout << "Volume " << m_sb.apfs_volname << " is encrypted." << std::endl;
|
|
|
|
if (!m_container.GetVolumeKey(vek, m_sb.apfs_vol_uuid))
|
|
{
|
|
if (m_container.GetPasswordHint(str, m_sb.apfs_vol_uuid))
|
|
std::cout << "Hint: " << str << std::endl;
|
|
|
|
std::cout << "Enter Password: ";
|
|
GetPassword(str);
|
|
|
|
if (!m_container.GetVolumeKey(vek, m_sb.apfs_vol_uuid, str.c_str()))
|
|
{
|
|
std::cout << "Wrong password!" << std::endl;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
m_aes.SetKey(vek, vek + 0x10);
|
|
m_is_encrypted = true;
|
|
}
|
|
|
|
if (!m_fs_tree.Init(m_sb.apfs_root_tree_oid, m_sb.apfs_o.o_xid, &m_omap))
|
|
std::cerr << "ERROR: root tree init failed" << std::endl;
|
|
|
|
if (!m_extentref_tree.Init(m_sb.apfs_extentref_tree_oid, m_sb.apfs_o.o_xid))
|
|
std::cerr << "WARNING: extentref tree init failed" << std::endl;
|
|
|
|
if (!m_snap_meta_tree.Init(m_sb.apfs_snap_meta_tree_oid, m_sb.apfs_o.o_xid))
|
|
std::cerr << "WARNING: snap meta tree init failed" << std::endl;
|
|
|
|
if (m_sb.apfs_incompatible_features & APFS_INCOMPAT_SEALED_VOLUME)
|
|
{
|
|
if (!m_fext_tree.Init(m_sb.apfs_fext_tree_oid, m_sb.apfs_o.o_xid))
|
|
std::cerr << "ERROR: fext tree init failed" << std::endl;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ApfsVolume::MountSnapshot(paddr_t apsb_paddr, xid_t snap_xid)
|
|
{
|
|
BTree snap_btree(m_container);
|
|
BTreeEntry snap_entry;
|
|
j_snap_metadata_key_t snap_key;
|
|
const j_snap_metadata_val_t *snap_val = nullptr;
|
|
std::vector<uint8_t> blk;
|
|
|
|
m_apsb_paddr = apsb_paddr;
|
|
|
|
blk.resize(m_container.GetBlocksize());
|
|
|
|
if (!ReadBlocks(blk.data(), apsb_paddr, 1, 0))
|
|
return false;
|
|
|
|
if (!VerifyBlock(blk.data(), blk.size()))
|
|
return false;
|
|
|
|
memcpy(&m_sb, blk.data(), sizeof(m_sb));
|
|
|
|
if (m_sb.apfs_magic != APFS_MAGIC)
|
|
return false;
|
|
|
|
if (m_sb.apfs_snap_meta_tree_oid == 0)
|
|
return false;
|
|
|
|
if (!snap_btree.Init(m_sb.apfs_snap_meta_tree_oid, m_sb.apfs_o.o_xid)) {
|
|
std::cerr << "snap meta tree init failed" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
snap_key.hdr.obj_id_and_type = APFS_TYPE_ID(APFS_TYPE_SNAP_METADATA, snap_xid);
|
|
if (!snap_btree.Lookup(snap_entry, &snap_key, sizeof(snap_key), CompareSnapMetaKey, nullptr, true)) {
|
|
std::cerr << "snap xid not found" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
snap_val = reinterpret_cast<const j_snap_metadata_val_t *>(snap_entry.val);
|
|
|
|
if (!m_omap.Init(m_sb.apfs_omap_oid, m_sb.apfs_o.o_xid)) {
|
|
std::cerr << "WARNING: Volume omap tree init failed." << std::endl;
|
|
return false;
|
|
}
|
|
|
|
if (!ReadBlocks(blk.data(), snap_val->sblock_oid, 1, 0)) {
|
|
std::cerr << "failed to read snapshot superblock" << std::endl;
|
|
return false;
|
|
}
|
|
if (!VerifyBlock(blk.data(), blk.size())) {
|
|
std::cerr << "snap superblock checksum error" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
memcpy(&m_sb, blk.data(), sizeof(m_sb));
|
|
|
|
if (m_sb.apfs_magic != APFS_MAGIC)
|
|
return false;
|
|
|
|
if ((m_sb.apfs_fs_flags & 3) != APFS_FS_UNENCRYPTED)
|
|
{
|
|
uint8_t vek[0x20];
|
|
std::string str;
|
|
|
|
std::cout << "Volume " << m_sb.apfs_volname << " is encrypted." << std::endl;
|
|
|
|
if (!m_container.GetVolumeKey(vek, m_sb.apfs_vol_uuid))
|
|
{
|
|
if (m_container.GetPasswordHint(str, m_sb.apfs_vol_uuid))
|
|
std::cout << "Hint: " << str << std::endl;
|
|
|
|
std::cout << "Enter Password: ";
|
|
GetPassword(str);
|
|
|
|
if (!m_container.GetVolumeKey(vek, m_sb.apfs_vol_uuid, str.c_str()))
|
|
{
|
|
std::cout << "Wrong password!" << std::endl;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
m_aes.SetKey(vek, vek + 0x10);
|
|
m_is_encrypted = true;
|
|
}
|
|
|
|
if (!m_fs_tree.Init(m_sb.apfs_root_tree_oid, m_sb.apfs_o.o_xid, &m_omap))
|
|
std::cerr << "WARNING: root tree init failed" << std::endl;
|
|
|
|
if (!m_extentref_tree.Init(m_sb.apfs_extentref_tree_oid, m_sb.apfs_o.o_xid))
|
|
std::cerr << "WARNING: extentref tree init failed" << std::endl;
|
|
|
|
if (!m_snap_meta_tree.Init(m_sb.apfs_snap_meta_tree_oid, m_sb.apfs_o.o_xid))
|
|
std::cerr << "WARNING: snap meta tree init failed" << std::endl;
|
|
|
|
if (m_sb.apfs_incompatible_features & APFS_INCOMPAT_SEALED_VOLUME)
|
|
{
|
|
if (!m_fext_tree.Init(m_sb.apfs_fext_tree_oid, m_sb.apfs_o.o_xid))
|
|
std::cerr << "ERROR: fext tree init failed" << std::endl;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void ApfsVolume::dump(BlockDumper& bd)
|
|
{
|
|
std::vector<uint8_t> blk;
|
|
omap_res_t om;
|
|
oid_t omap_snapshot_tree_oid = 0;
|
|
|
|
blk.resize(m_container.GetBlocksize());
|
|
|
|
if (!ReadBlocks(blk.data(), m_apsb_paddr, 1, 0))
|
|
return;
|
|
|
|
if (!VerifyBlock(blk.data(), blk.size()))
|
|
return;
|
|
|
|
bd.SetTextFlags(m_sb.apfs_incompatible_features & 0xFF);
|
|
|
|
bd.DumpNode(blk.data(), m_apsb_paddr);
|
|
|
|
ReadBlocks(blk.data(), m_sb.apfs_omap_oid, 1, 0);
|
|
bd.DumpNode(blk.data(), m_sb.apfs_omap_oid);
|
|
|
|
{
|
|
const omap_phys_t *om = reinterpret_cast<const omap_phys_t*>(blk.data());
|
|
omap_snapshot_tree_oid = om->om_snapshot_tree_oid;
|
|
|
|
ReadBlocks(blk.data(), omap_snapshot_tree_oid, 1, 0);
|
|
bd.DumpNode(blk.data(), omap_snapshot_tree_oid);
|
|
}
|
|
|
|
if (m_sb.apfs_er_state_oid) {
|
|
ReadBlocks(blk.data(), m_sb.apfs_er_state_oid, 1, 0);
|
|
bd.DumpNode(blk.data(), m_sb.apfs_er_state_oid);
|
|
}
|
|
|
|
m_omap.dump(bd);
|
|
m_fs_tree.dump(bd);
|
|
// m_extentref_tree.dump(bd);
|
|
m_snap_meta_tree.dump(bd);
|
|
|
|
if (m_sb.apfs_integrity_meta_oid != 0) {
|
|
if (m_omap.Lookup(om, m_sb.apfs_integrity_meta_oid, m_sb.apfs_o.o_xid))
|
|
{
|
|
ReadBlocks(blk.data(), om.paddr, 1, 0);
|
|
bd.DumpNode(blk.data(), om.paddr);
|
|
}
|
|
}
|
|
|
|
if (m_sb.apfs_snap_meta_ext_oid != 0) {
|
|
if (m_omap.Lookup(om, m_sb.apfs_snap_meta_ext_oid, m_sb.apfs_o.o_xid))
|
|
{
|
|
ReadBlocks(blk.data(), om.paddr, 1, 0);
|
|
bd.DumpNode(blk.data(), om.paddr);
|
|
}
|
|
}
|
|
|
|
#if 1
|
|
if (m_sb.apfs_fext_tree_oid != 0) {
|
|
BTree fxtree(m_container, this);
|
|
fxtree.Init(m_sb.apfs_fext_tree_oid, m_sb.apfs_o.o_xid);
|
|
fxtree.dump(bd);
|
|
}
|
|
#endif
|
|
|
|
BTreeEntry bte;
|
|
#if 0
|
|
BTreeIterator it;
|
|
const j_snap_metadata_key_t *sm_key;
|
|
const j_snap_metadata_val_t *sm_val;
|
|
|
|
if (m_snap_meta_tree.GetIteratorBegin(it)) {
|
|
for (;;) {
|
|
if (!it.GetEntry(bte)) break;
|
|
|
|
sm_key = reinterpret_cast<const j_snap_metadata_key_t *>(bte.key);
|
|
sm_val = reinterpret_cast<const j_snap_metadata_val_t *>(bte.val);
|
|
|
|
if ((sm_key->hdr.obj_id_and_type >> OBJ_TYPE_SHIFT) != APFS_TYPE_SNAP_METADATA) break;
|
|
|
|
ReadBlocks(blk.data(), sm_val->sblock_oid, 1, 0);
|
|
bd.DumpNode(blk.data(), sm_val->sblock_oid);
|
|
|
|
apfs_superblock_t apsb;
|
|
memcpy(&apsb, blk.data(), sizeof(apfs_superblock_t));
|
|
|
|
if (apsb.apfs_omap_oid) {
|
|
ReadBlocks(blk.data(), apsb.apfs_omap_oid, 1, 0);
|
|
bd.DumpNode(blk.data(), apsb.apfs_omap_oid);
|
|
}
|
|
|
|
if (!it.next()) break;
|
|
}
|
|
}
|
|
|
|
bte.clear();
|
|
#endif
|
|
|
|
#if 0
|
|
{
|
|
BTree omap_tree(m_container, this);
|
|
BTreeIterator oit;
|
|
omap_phys_t om;
|
|
|
|
ReadBlocks(blk.data(), m_sb.apfs_omap_oid, 1, 0);
|
|
memcpy(&om, blk.data(), sizeof(om));
|
|
|
|
omap_tree.Init(om.om_tree_oid, om.om_o.o_xid);
|
|
if (omap_tree.GetIteratorBegin(oit)) {
|
|
const omap_key_t *ok;
|
|
const omap_val_t *ov;
|
|
for (;;) {
|
|
if (!oit.GetEntry(bte)) break;
|
|
ok = reinterpret_cast<const omap_key_t*>(bte.key);
|
|
ov = reinterpret_cast<const omap_val_t*>(bte.val);
|
|
|
|
bd.st() << "omap: " << ok->ok_oid << " " << ok->ok_xid << " => " << ov->ov_flags << " " << ov->ov_size << " " << ov->ov_paddr << std::endl;
|
|
if (ov->ov_flags & OMAP_VAL_NOHEADER) {
|
|
ReadBlocks(blk.data(), ov->ov_paddr, 1, 0);
|
|
bd.DumpNode(blk.data(), ov->ov_paddr);
|
|
}
|
|
|
|
if (!oit.next()) break;
|
|
}
|
|
} else {
|
|
bd.st() << "Failed getting omap iterator" << std::endl;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
bool ApfsVolume::ReadBlocks(uint8_t * data, paddr_t paddr, uint64_t blkcnt, uint64_t xts_tweak)
|
|
{
|
|
constexpr int encryption_block_size = 0x200;
|
|
|
|
if (!m_container.ReadBlocks(data, paddr, blkcnt))
|
|
return false;
|
|
|
|
if (!m_is_encrypted || (xts_tweak == 0))
|
|
return true;
|
|
|
|
uint64_t cs_factor = m_container.GetBlocksize() / encryption_block_size;
|
|
uint64_t uno = xts_tweak * cs_factor;
|
|
size_t size = blkcnt * m_container.GetBlocksize();
|
|
size_t k;
|
|
|
|
for (k = 0; k < size; k += encryption_block_size)
|
|
{
|
|
m_aes.Decrypt(data + k, data + k, encryption_block_size, uno);
|
|
uno++;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
int ApfsVolume::CompareSnapMetaKey(const void* skey, size_t skey_len, const void* ekey, size_t ekey_len, void* context)
|
|
{
|
|
const j_key_t *ks = reinterpret_cast<const j_key_t*>(skey);
|
|
const j_key_t *ke = reinterpret_cast<const j_key_t*>(ekey);
|
|
const j_snap_name_key_t *sks;
|
|
const j_snap_name_key_t *ske;
|
|
|
|
if (ke->obj_id_and_type < ks->obj_id_and_type)
|
|
return -1;
|
|
if (ke->obj_id_and_type > ks->obj_id_and_type)
|
|
return 1;
|
|
|
|
switch (ks->obj_id_and_type >> OBJ_TYPE_SHIFT)
|
|
{
|
|
case APFS_TYPE_SNAP_METADATA:
|
|
break;
|
|
case APFS_TYPE_SNAP_NAME:
|
|
sks = reinterpret_cast<const j_snap_name_key_t*>(skey);
|
|
ske = reinterpret_cast<const j_snap_name_key_t*>(ekey);
|
|
return apfs_strncmp(ske->name, ske->name_len, sks->name, sks->name_len);
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|