342 行
8.4 KiB
C++
342 行
8.4 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 <iomanip>
|
|
#include <iostream>
|
|
#include <cstring>
|
|
#include <cassert>
|
|
|
|
#include "Decmpfs.h"
|
|
#include "Endian.h"
|
|
|
|
#include "Global.h"
|
|
#include "Util.h"
|
|
|
|
|
|
struct RsrcForkHeader
|
|
{
|
|
be_uint32_t data_offset;
|
|
be_uint32_t mgmt_offset;
|
|
be_uint32_t data_size;
|
|
be_uint32_t mgmt_size;
|
|
};
|
|
|
|
struct CmpfRsrcEntry
|
|
{
|
|
// 1 64K-Block
|
|
le_uint32_t off;
|
|
le_uint32_t size;
|
|
};
|
|
|
|
struct CmpfRsrc
|
|
{
|
|
le_uint32_t entries;
|
|
CmpfRsrcEntry entry[32];
|
|
};
|
|
|
|
bool IsDecompAlgoSupported(uint16_t algo)
|
|
{
|
|
switch (algo)
|
|
{
|
|
case 3:
|
|
case 4:
|
|
case 7:
|
|
case 8:
|
|
case 9:
|
|
case 10:
|
|
case 11:
|
|
case 12:
|
|
case 13:
|
|
case 14:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool IsDecompAlgoInRsrc(uint16_t algo)
|
|
{
|
|
switch (algo)
|
|
{
|
|
case 4:
|
|
case 8:
|
|
case 10:
|
|
case 12:
|
|
case 14:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool DecompressFile(ApfsDir &dir, uint64_t ino, std::vector<uint8_t> &decompressed, const std::vector<uint8_t> &compressed)
|
|
{
|
|
if (compressed.size() < sizeof(CompressionHeader))
|
|
return false;
|
|
|
|
const CompressionHeader *hdr = reinterpret_cast<const CompressionHeader *>(compressed.data());
|
|
const uint8_t *cdata = compressed.data() + sizeof(CompressionHeader);
|
|
size_t csize = compressed.size() - sizeof(CompressionHeader);
|
|
size_t decoded_bytes = 0;
|
|
|
|
#if 1 // Disable to get compressed data
|
|
if (g_debug & Dbg_Cmpfs)
|
|
{
|
|
std::cout << "DecompressFile " << compressed.size() << " => " << hdr->size << ", algo = " << hdr->algo;
|
|
|
|
switch (hdr->algo)
|
|
{
|
|
case 3: std::cout << " (Zlib, Attr)"; break;
|
|
case 4: std::cout << " (Zlib, Rsrc)"; break;
|
|
case 7: std::cout << " (LZVN, Attr)"; break;
|
|
case 8: std::cout << " (LZVN, Rsrc)"; break;
|
|
case 9: std::cout << " (Uncompressed, Attr)"; break;
|
|
case 10: std::cout << " (Uncompressed, Rsrc)"; break;
|
|
case 11: std::cout << " (LZFSE, Attr)"; break;
|
|
case 12: std::cout << " (LZFSE, Rsrc)"; break;
|
|
case 13: std::cout << " (LZBITMAP, Attr)"; break;
|
|
case 14: std::cout << " (LZBITMAP, Rsrc)"; break;
|
|
default: std::cout << " (Unknown)"; break;
|
|
}
|
|
|
|
std::cout << std::endl;
|
|
}
|
|
|
|
if (!IsDecompAlgoSupported(hdr->algo))
|
|
{
|
|
if (g_debug & Dbg_Errors) {
|
|
std::cout << "Unsupported decompression algorithm." << std::endl;
|
|
DumpHex(std::cout, compressed.data(), compressed.size());
|
|
}
|
|
return false;
|
|
}
|
|
|
|
if (IsDecompAlgoInRsrc(hdr->algo))
|
|
{
|
|
std::vector<uint8_t> rsrc;
|
|
size_t k;
|
|
|
|
bool rc = dir.GetAttribute(rsrc, ino, "com.apple.ResourceFork");
|
|
|
|
if (!rc)
|
|
{
|
|
if (g_debug & Dbg_Errors)
|
|
std::cout << "Decmpfs: Could not find resource fork " << ino << std::endl;
|
|
decompressed.clear();
|
|
return false;
|
|
}
|
|
|
|
if (hdr->algo == 4) // Zlib, rsrc
|
|
{
|
|
RsrcForkHeader rsrc_hdr;
|
|
|
|
memcpy(&rsrc_hdr, rsrc.data(), sizeof(rsrc_hdr));
|
|
|
|
if (rsrc_hdr.data_offset > rsrc.size())
|
|
{
|
|
if (g_debug & Dbg_Errors)
|
|
std::cout << "Decmpfs: Invalid data offset in rsrc header." << std::endl;
|
|
return false;
|
|
}
|
|
|
|
const uint8_t *cmpf_rsrc_base = rsrc.data() + rsrc_hdr.data_offset + sizeof(uint32_t);
|
|
const CmpfRsrc *cmpf_rsrc = reinterpret_cast<const CmpfRsrc *>(cmpf_rsrc_base);
|
|
|
|
decompressed.resize((hdr->size + 0xFFFF) & 0xFFFF0000);
|
|
|
|
for (k = 0; k < cmpf_rsrc->entries; k++)
|
|
{
|
|
size_t src_offset = cmpf_rsrc->entry[k].off;
|
|
const uint8_t *src = cmpf_rsrc_base + src_offset;
|
|
size_t src_len = cmpf_rsrc->entry[k].size;
|
|
uint8_t *dst = decompressed.data() + 0x10000 * k;
|
|
size_t expected_len = hdr->size - (0x10000 * k);
|
|
if (expected_len > 0x10000)
|
|
expected_len = 0x10000;
|
|
|
|
if (src_len > 0x10001)
|
|
{
|
|
if (g_debug & Dbg_Errors)
|
|
std::cout << "Decmpfs: In rsrc, src_len too big (" << src_len << ")" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
if (src[0] == 0x78)
|
|
{
|
|
decoded_bytes = DecompressZLib(dst, 0x10000, src, src_len);
|
|
}
|
|
else if ((src[0] & 0x0F) == 0x0F)
|
|
{
|
|
memcpy(dst, src + 1, src_len - 1);
|
|
decoded_bytes = src_len - 1;
|
|
}
|
|
else
|
|
{
|
|
if (g_debug & Dbg_Errors)
|
|
std::cout << "Decmpfs: Something wrong with zlib data." << std::endl;
|
|
decompressed.clear();
|
|
return false;
|
|
}
|
|
|
|
if (expected_len != decoded_bytes)
|
|
{
|
|
if (g_debug & Dbg_Errors)
|
|
std::cout << "Decmpfs: Expected len != decompressed len: " << expected_len << " != " << decoded_bytes << std::endl;
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
const uint32_t *off_list = reinterpret_cast<const uint32_t *>(rsrc.data());
|
|
|
|
decompressed.resize((hdr->size + 0xFFFF) & 0xFFFF0000);
|
|
|
|
for (k = 0; (k << 16) < decompressed.size(); k++) {
|
|
size_t expected_len = hdr->size - (0x10000 * k);
|
|
if (expected_len > 0x10000)
|
|
expected_len = 0x10000;
|
|
const uint8_t *src = rsrc.data() + off_list[k];
|
|
size_t src_len = off_list[k + 1] - off_list[k];
|
|
|
|
if (src_len > 0x10001) {
|
|
if (g_debug & Dbg_Errors)
|
|
std::cout << "Decmpfs: In rsrc, src_len too big (" << src_len << ")" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
switch (hdr->algo) {
|
|
case 8:
|
|
if (src[0] == 0x06) {
|
|
memcpy(decompressed.data() + (k << 16), src + 1, src_len - 1);
|
|
decoded_bytes = src_len - 1;
|
|
}
|
|
else
|
|
decoded_bytes = DecompressLZVN(decompressed.data() + (k << 16), expected_len, src, src_len);
|
|
break;
|
|
case 10:
|
|
// Assuming ...
|
|
memcpy(decompressed.data() + (k << 16), src + 1, src_len - 1);
|
|
decoded_bytes = src_len - 1;
|
|
break;
|
|
case 12:
|
|
// Assuming ...
|
|
decoded_bytes = DecompressLZFSE(decompressed.data() + (k << 16), expected_len, src, src_len);
|
|
// TODO is there also an uncompressed variant?
|
|
break;
|
|
case 14:
|
|
if (src[0] == 0xFF) {
|
|
memcpy(decompressed.data() + (k << 16), src + 1, src_len - 1);
|
|
decoded_bytes = src_len - 1;
|
|
}
|
|
else
|
|
decoded_bytes = DecompressLZBITMAP(decompressed.data() + (k << 16), expected_len, src, src_len);
|
|
break;
|
|
default:
|
|
decoded_bytes = 0;
|
|
break;
|
|
}
|
|
|
|
if (decoded_bytes != expected_len) {
|
|
if (g_debug & Dbg_Errors)
|
|
std::cout << "Decmpfs: Expected length != decompressed length: " << expected_len << " != " << decoded_bytes << " [k = " << k << "]" << std::endl;
|
|
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
decompressed.resize(hdr->size);
|
|
}
|
|
else
|
|
{
|
|
decompressed.resize(hdr->size);
|
|
|
|
switch (hdr->algo) {
|
|
case 3:
|
|
if (cdata[0] == 0x78)
|
|
decoded_bytes = DecompressZLib(decompressed.data(), decompressed.size(), cdata, csize);
|
|
else if (cdata[0] == 0xFF) {
|
|
assert(hdr->size == csize - 1);
|
|
decompressed.assign(cdata + 1, cdata + csize);
|
|
decoded_bytes = decompressed.size();
|
|
}
|
|
else
|
|
return false;
|
|
break;
|
|
|
|
case 7:
|
|
if (cdata[0] == 0x06) {
|
|
assert(hdr->size == csize - 1);
|
|
decompressed.assign(cdata + 1, cdata + csize);
|
|
decoded_bytes = decompressed.size();
|
|
}
|
|
else
|
|
decoded_bytes = DecompressLZVN(decompressed.data(), decompressed.size(), cdata, csize);
|
|
break;
|
|
|
|
case 9:
|
|
assert(cdata[0] == 0xCC);
|
|
assert(hdr->size == csize - 1);
|
|
decompressed.assign(cdata + 1, cdata + csize);
|
|
decoded_bytes = decompressed.size();
|
|
break;
|
|
|
|
case 11:
|
|
// TODO uncompressed variant?
|
|
decoded_bytes = DecompressLZFSE(decompressed.data(), decompressed.size(), cdata, csize);
|
|
break;
|
|
|
|
case 13:
|
|
if (cdata[0] == 0xFF) {
|
|
assert(hdr->size == csize - 1);
|
|
decompressed.assign(cdata + 1, cdata + csize);
|
|
decoded_bytes = decompressed.size();
|
|
}
|
|
else
|
|
decoded_bytes = DecompressLZBITMAP(decompressed.data(), decompressed.size(), cdata, csize);
|
|
break;
|
|
|
|
default:
|
|
decoded_bytes = 0;
|
|
break;
|
|
}
|
|
|
|
if (decoded_bytes != hdr->size)
|
|
{
|
|
if (g_debug & Dbg_Errors)
|
|
std::cout << "Decmpfs: In attr, expected len != decoded len: " << hdr->size << " != " << decoded_bytes << std::endl;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
#else
|
|
if (IsDecompAlgoInRsrc(hdr->algo))
|
|
{
|
|
dir.GetAttribute(decompressed, ino, "com.apple.ResourceFork");
|
|
}
|
|
else
|
|
{
|
|
decompressed = compressed;
|
|
}
|
|
#endif
|
|
|
|
return true;
|
|
}
|