文件

528 行
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 <vector>
#include <iostream>
#include <iomanip>
#include "Endian.h"
#include "Util.h"
#include "PList.h"
#include "DeviceDMG.h"
#pragma pack(push, 1)
struct KolyHeader
{
char signature[4];
be_uint32_t version;
be_uint32_t headersize;
be_uint32_t flags;
be_uint64_t running_data_fork_offset;
be_uint64_t data_fork_offset;
be_uint64_t data_fork_length;
be_uint64_t rsrc_fork_offset;
be_uint64_t rsrc_fork_length;
be_uint32_t segment_number;
be_uint32_t segment_count;
uint8_t segment_id[0x10];
// 0x50
be_uint32_t data_fork_checksum_type;
be_uint32_t data_fork_unknown;
be_uint32_t data_fork_checksum_data;
uint8_t unk_05C[0x7C];
// 0xD8
be_uint64_t xml_offset;
be_uint64_t xml_length;
// ???
// uint64_t codesign_offset;
// uint64_t codesign_length;
uint8_t unk_0E8[0x78];
// 0x160
be_uint32_t master_checksum_type;
be_uint32_t master_checksum_unknown;
be_uint32_t master_checksum_data;
uint8_t unk_16C[0x7C];
// 0x1E8
be_uint32_t image_variant;
be_uint64_t sector_count;
// 0x1F4
uint8_t unk_1F4[12];
};
static_assert(sizeof(KolyHeader) == 0x200, "Wrong Koly Header Size");
struct MishHeader
{
char signature[4];
be_uint32_t unk;
be_uint64_t sector_start;
be_uint64_t sector_count;
be_uint64_t dmg_offset;
be_uint32_t unk_20;
be_uint32_t part_id;
be_uint8_t unk_28[0x18];
be_uint32_t checksum_type;
be_uint32_t checksum_unk;
be_uint32_t checksum_data;
be_uint8_t unk_4C[0x7C];
be_uint32_t entry_count;
};
static_assert(sizeof(MishHeader) == 0xCC, "Wrong Mish Header Size");
struct MishEntry
{
be_uint32_t method;
be_uint32_t comment;
be_uint64_t sector_start;
be_uint64_t sector_count;
be_uint64_t dmg_offset;
be_uint64_t dmg_length;
};
static_assert(sizeof(MishEntry) == 0x28, "Wrong Mish Entry Size");
#pragma pack(pop)
DeviceDMG::DmgSection::DmgSection()
{
method = 0;
comment = 0;
disk_offset = 0;
disk_length = 0;
dmg_offset = 0;
dmg_length = 0;
cache = nullptr;
}
DeviceDMG::DmgSection::~DmgSection()
{
delete[] cache;
}
DeviceDMG::DeviceDMG() : m_crc(true)
{
m_size = 0;
m_offset = 0;
m_is_raw = false;
#ifdef DMG_CACHE
m_cache_base = 0;
m_cache_size = 0;
m_cache_data = 0;
#endif
}
DeviceDMG::~DeviceDMG()
{
Close();
#ifdef DMG_CACHE
delete[] m_cache_data;
#endif
}
bool DeviceDMG::Open(const char * name)
{
Close();
if (!m_img.Open(name))
return false;
if (!m_img.CheckSetupEncryption())
{
m_img.Close();
return false;
}
KolyHeader koly;
m_img.Read(m_img.GetContentSize() - 0x200, &koly, sizeof(koly));
if (memcmp(koly.signature, "koly", 4))
{
m_is_raw = true;
m_size = m_img.GetContentSize();
return true;
}
#ifdef DMG_DEBUG
m_dbg.open("mish_ev1.txt");
m_dbg.flags(m_dbg.hex | m_dbg.uppercase);
m_dbg.fill('0');
m_dbg << "Signature : " << std::setw(8) << koly.signature << std::endl;
m_dbg << "Version : " << std::setw(8) << koly.version << std::endl;
m_dbg << "Header size : " << std::setw(8) << koly.headersize << std::endl;
m_dbg << "Flags : " << std::setw(8) << koly.flags << std::endl;
m_dbg << "Running DF Off : " << std::setw(16) << koly.running_data_fork_offset << std::endl;
m_dbg << "Data Fork Offs : " << std::setw(16) << koly.data_fork_offset << std::endl;
m_dbg << "Data Fork Len : " << std::setw(16) << koly.data_fork_length << std::endl;
m_dbg << "Rsrc Fork Off : " << std::setw(16) << koly.rsrc_fork_offset << std::endl;
m_dbg << "Rsrc Fork Len : " << std::setw(16) << koly.rsrc_fork_length << std::endl;
m_dbg << "Segment Number : " << std::setw(8) << koly.segment_number << std::endl;
m_dbg << "Segment Count : " << std::setw(8) << koly.segment_count << std::endl;
m_dbg << "..." << std::endl;
m_dbg << "XML Offset : " << std::setw(16) << koly.xml_offset << std::endl;
m_dbg << "XML Length : " << std::setw(16) << koly.xml_length << std::endl;
m_dbg << "..." << std::endl;
DumpHex(m_dbg, reinterpret_cast<const uint8_t *>(&koly), sizeof(koly), 0x20);
m_dbg << std::endl << std::endl;
#endif
m_size = koly.sector_count * 0x200;
m_offset = koly.data_fork_offset;
if (koly.xml_offset != 0)
{
if (g_debug & Dbg_Info)
printf("Loading DMG using XML plist.\n");
if (!ProcessHeaderXML(koly.xml_offset, koly.xml_length))
{
fprintf(stderr, "Error parsing propertiy list.\n");
m_img.Close();
m_img.Reset();
m_size = 0;
return false;
}
}
else if (koly.rsrc_fork_offset != 0)
{
if (g_debug & Dbg_Info)
printf("Loading DMG using RSRC fork.\n");
if (!ProcessHeaderRsrc(koly.rsrc_fork_offset, koly.rsrc_fork_length))
{
fprintf(stderr, "Error processing resource fork.\n");
m_img.Close();
m_img.Reset();
m_size = 0;
return false;
}
}
else
{
m_img.Close();
m_img.Reset();
m_size = 0;
return false;
}
#ifdef DMG_DEBUG
m_dbg.close();
#endif
return true;
}
void DeviceDMG::Close()
{
m_img.Close();
m_size = 0;
m_sections.clear();
m_is_raw = false;
}
bool DeviceDMG::Read(void * data, uint64_t offs, uint64_t len)
{
if (m_is_raw)
{
m_img.Read(offs + m_offset, data, len);
return true;
// TODO: Error handling ...
}
// Binary search start sector in m_sections
// Get data if necessary
// Decompress: cache data
size_t entry_idx = m_sections.size();
size_t rd_offs;
size_t rd_size;
char *bdata = reinterpret_cast<char *>(data);
bool compressed = false;
ptrdiff_t beg = 0;
ptrdiff_t end = m_sections.size() - 1;
ptrdiff_t mid;
while (beg <= end)
{
mid = (beg + end) / 2;
if (offs >= m_sections[mid].disk_offset && offs < (m_sections[mid].disk_offset + m_sections[mid].disk_length))
{
entry_idx = mid;
break;
}
else if (offs < m_sections[mid].disk_offset)
end = mid - 1;
else
beg = mid + 1;
}
if (entry_idx == m_sections.size())
return false;
while (len > 0)
{
if (entry_idx >= m_sections.size())
return false;
DmgSection &sect = m_sections[entry_idx];
rd_offs = offs - sect.disk_offset;
rd_size = len;
if (rd_offs + rd_size > sect.disk_length)
rd_size = sect.disk_length - rd_offs;
compressed = false;
switch (sect.method)
{
case 1: // raw
m_img.Read(rd_offs + sect.dmg_offset + m_offset, bdata, rd_size);
break;
case 0: // unsure ...
case 2: // ignore
memset(bdata, 0, rd_size);
break;
case 0x80000004: // adc
case 0x80000005: // zlib
case 0x80000006: // bzip2
case 0x80000007: // lzfse
compressed = true;
break;
default:
std::cerr << "DMG: unknown compression method " << sect.method << std::endl;
return false;
}
if (compressed)
{
#ifdef DMG_CACHE
if (m_cache_data == 0 || m_cache_base != sect.disk_offset || m_cache_size != sect.disk_length)
{
delete[] m_cache_data;
m_cache_data = 0;
uint8_t *compr_buf = new uint8_t[sect.dmg_length];
m_cache_data = new uint8_t[sect.disk_length];
m_cache_base = sect.disk_offset;
m_cache_size = sect.disk_length;
m_img.Read(sect.dmg_offset + m_offset, compr_buf, sect.dmg_length);
switch (sect.method)
{
case 0x80000004:
DecompressADC(m_cache_data, sect.disk_length, compr_buf, sect.dmg_length);
break;
case 0x80000005:
DecompressZLib(m_cache_data, sect.disk_length, compr_buf, sect.dmg_length);
break;
case 0x80000006:
DecompressBZ2(m_cache_data, sect.disk_length, compr_buf, sect.dmg_length);
break;
case 0x80000007:
DecompressLZFSE(m_cache_data, sect.disk_length, compr_buf, sect.dmg_length);
break;
default:
std::cerr << "DMG: invalid compression method " << sect.method << std::endl;
return false;
break;
}
delete[] compr_buf;
}
memcpy(bdata, m_cache_data + rd_offs, rd_size);
#else
if (sect.cache == nullptr)
{
uint8_t *compr_buf = new uint8_t[sect.dmg_length];
sect.cache = new uint8_t[sect.disk_length];
m_img.Read(sect.dmg_offset + m_offset, compr_buf, sect.dmg_length);
switch (sect.method)
{
case 0x80000004:
DecompressADC(sect.cache, sect.disk_length, compr_buf, sect.dmg_length);
break;
case 0x80000005:
DecompressZLib(sect.cache, sect.disk_length, compr_buf, sect.dmg_length);
break;
case 0x80000006:
DecompressBZ2(sect.cache, sect.disk_length, compr_buf, sect.dmg_length);
break;
case 0x80000007:
DecompressLZFSE(sect.cache, sect.disk_length, compr_buf, sect.dmg_length);
break;
default:
std::cerr << "DMG: invalid compression method " << sect.method << std::endl;
return false;
break;
}
delete[] compr_buf;
memcpy(bdata, sect.cache + rd_offs, rd_size);
#if 1 // TODO: figure out some intelligent cache mechanism ...
delete[] sect.cache;
sect.cache = nullptr;
#endif
}
#endif
}
bdata += rd_size;
offs += rd_size;
len -= rd_size;
entry_idx++;
}
return true;
}
uint64_t DeviceDMG::GetSize() const
{
return m_size;
}
bool DeviceDMG::ProcessHeaderXML(uint64_t off, uint64_t size)
{
std::vector<char> xmldata;
xmldata.resize(size, 0);
m_img.Read(off, xmldata.data(), size);
PListXmlParser parser(xmldata.data(), xmldata.size());
const PLDict *plist = parser.Parse()->toDict();
if (!plist)
return false;
const PLDict *rsrc_fork = plist->get("resource-fork")->toDict();
if (!rsrc_fork)
return false;
const PLArray *blkx = rsrc_fork->get("blkx")->toArray();
if (!blkx)
return false;
const PLDict *entry;
const PLData *mish;
size_t k;
for (k = 0; k < blkx->size(); k++)
{
entry = blkx->get(k)->toDict();
if (!entry)
return false;
mish = entry->get("Data")->toData();
if (!mish)
return false;
ProcessMish(mish->data(), mish->size());
}
return true;
}
bool DeviceDMG::ProcessHeaderRsrc(uint64_t off, uint64_t size)
{
return false;
}
void DeviceDMG::ProcessMish(const uint8_t * data, size_t size)
{
(void)size;
const MishHeader *mish = reinterpret_cast<const MishHeader *>(data);
const MishEntry *entry = reinterpret_cast<const MishEntry *>(data + 0xCC);
DmgSection section;
uint64_t partition_start;
uint32_t cnt;
uint32_t k;
if (memcmp(mish->signature, "mish", 4))
return;
#ifdef DMG_DEBUG
DumpHex(m_dbg, data, 0xCC, 0x20);
m_dbg << std::setw(8) << mish->signature << ' ';
m_dbg << std::setw(8) << mish->unk << ' ';
m_dbg << std::setw(16) << mish->sector_start << ' ';
m_dbg << std::setw(16) << mish->sector_count << ' ';
m_dbg << std::setw(16) << mish->dmg_offset << ' ';
m_dbg << std::setw(8) << mish->unk_20 << ' ';
m_dbg << std::setw(8) << mish->part_id << " - ";
m_dbg << std::setw(8) << mish->checksum_data << std::endl;
#endif
partition_start = mish->sector_start;
cnt = mish->entry_count;
for (k = 0; k < cnt; k++)
{
#ifdef DMG_DEBUG
m_dbg << std::setw(8) << entry[k].method << ' ';
m_dbg << std::setw(8) << entry[k].comment << ' ';
m_dbg << std::setw(16) << entry[k].sector_start << ' ';
m_dbg << std::setw(16) << entry[k].sector_count << ' ';
m_dbg << std::setw(16) << entry[k].dmg_offset << ' ';
m_dbg << std::setw(16) << entry[k].dmg_length << std::endl;
#endif
section.method = entry[k].method;
section.comment = entry[k].comment;
section.disk_offset = (entry[k].sector_start + partition_start) * 0x200;
section.disk_length = entry[k].sector_count * 0x200;
section.dmg_offset = entry[k].dmg_offset + mish->dmg_offset;
section.dmg_length = entry[k].dmg_length;
section.cache = nullptr;
if (section.method != 0xFFFFFFFF && section.method != 0x7FFFFFFE)
m_sections.push_back(section);
}
#ifdef DMG_DEBUG
m_dbg << std::endl;
#endif
}