hfs_decmpfs.cpp

Go to the documentation of this file.

// hfs_decmpfs.cpp -- decmpfs zlib decoder (resource-fork variant).
 
#include "hfs_decmpfs.hpp"
 
#include <zlib.h>
 
#include <algorithm>
#include <cstring>
#include <sstream>
 
namespace hfs {
 
namespace {
 
// Little-endian readers (decmpfs chunked stream is little-endian)
inline 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);
}
 
// Big-endian readers (resource fork header is big-endian, classic Mac)
inline uint32_t be32(const unsigned char* p) {
    return (static_cast<uint32_t>(p[0]) << 24)
         | (static_cast<uint32_t>(p[1]) << 16)
         | (static_cast<uint32_t>(p[2]) <<  8)
         |  static_cast<uint32_t>(p[3]);
}
 
// Inflate a single zlib chunk into `out_buf`. Returns true if the
// uncompressed result is exactly `out_size` bytes (or less if the
// caller allowed it). The first byte determines whether the chunk is
// raw or compressed:
//   - 0xFF byte at start -> the rest is raw uncompressed data
//   - otherwise -> standard zlib stream
bool inflate_chunk(const unsigned char* in_buf, size_t in_size,
                    unsigned char* out_buf, size_t out_size,
                    size_t& out_produced, std::string& error) {
    if (in_size == 0) {
        error = "empty chunk";
        return false;
    }
    // Check for the 0xFF "raw" marker
    if (in_buf[0] == 0xFF) {
        const size_t raw_len = in_size - 1;
        if (raw_len > out_size) {
            error = "raw chunk larger than output buffer";
            return false;
        }
        std::memcpy(out_buf, in_buf + 1, raw_len);
        out_produced = raw_len;
        return true;
    }
 
    // Standard zlib stream
    z_stream zs{};
    zs.next_in = const_cast<Bytef*>(in_buf);
    zs.avail_in = static_cast<uInt>(in_size);
    zs.next_out = out_buf;
    zs.avail_out = static_cast<uInt>(out_size);
    int ret = inflateInit(&zs);
    if (ret != Z_OK) {
        error = "inflateInit failed";
        return false;
    }
    ret = inflate(&zs, Z_FINISH);
    if (ret != Z_STREAM_END && ret != Z_OK) {
        error = std::string("inflate failed: ") +
                (zs.msg ? zs.msg : "unknown error");
        inflateEnd(&zs);
        return false;
    }
    out_produced = static_cast<size_t>(zs.total_out);
    inflateEnd(&zs);
    return true;
}
 
} // anonymous namespace
 
bool parse_decmpfs_header(const unsigned char* buf, DecmpfsHeader& out) {
    if (buf == nullptr) return false;
    out = {};
    out.magic = le32(buf + 0);
    if (out.magic != DECMPFS_MAGIC) return false;
    out.type  = le32(buf + 4);
    // The size field is little-endian 64-bit
    uint64_t size_lo = le32(buf +  8);
    uint64_t size_hi = le32(buf + 12);
    out.size = size_lo | (size_hi << 32);
    return true;
}
 
const char* decmpfs_type_name(uint32_t type) {
    switch (type) {
        case kCompressionType_None:         return "raw";
        case kCompressionType_ZlibInXattr:  return "zlib-xattr";
        case kCompressionType_ZlibInRsrc:   return "zlib-rsrc";
        case kCompressionType_LzvnInXattr:  return "lzvn-xattr";
        case kCompressionType_LzvnInRsrc:   return "lzvn-rsrc";
        case kCompressionType_LzfseInXattr: return "lzfse-xattr";
        case kCompressionType_LzfseInRsrc:  return "lzfse-rsrc";
        default:                            return "unknown";
    }
}
 
bool decmpfs_supported(uint32_t type) {
    return type == kCompressionType_ZlibInRsrc ||
           type == kCompressionType_ZlibInXattr;
}
 
// =========================================================================
// Decmpfs type 3 (zlib in xattr) decoder
// =========================================================================
//
// When the file is small enough (typically < ~3.6 KB on HFS+), decmpfs
// stores both the header AND the compressed payload directly in the
// "com.apple.decmpfs" extended attribute. The xattr layout is:
//
//   offset  0: decmpfs header (16 bytes: magic + type + uncompressed_size)
//   offset 16: payload, EITHER
//                - a single zlib deflate stream (most common), OR
//                - 0xFF byte followed by raw uncompressed data
//                  (= "no compression" marker, used when the file is
//                   incompressible or already smaller raw)
//
// Note that this is DIFFERENT from the resource-fork variant (type 4)
// which uses a chunked stream with little-endian framing. Type 3 is
// just a plain zlib stream OR a raw byte after the 0xFF marker.
 
bool decompress_xattr_zlib(const unsigned char* xattr_buf,
                            size_t xattr_len,
                            uint64_t expected_uncompressed_size,
                            std::vector<unsigned char>& out,
                            std::string& error) {
    out.clear();
    if (xattr_len < DECMPFS_HEADER_SIZE) {
        error = "xattr too small for decmpfs header";
        return false;
    }
    DecmpfsHeader h;
    if (!parse_decmpfs_header(xattr_buf, h)) {
        error = "decmpfs header magic mismatch";
        return false;
    }
    if (h.type != kCompressionType_ZlibInXattr) {
        error = "compression type is not zlib-xattr";
        return false;
    }
    if (h.size != expected_uncompressed_size) {
        // The catalog logical_size and the decmpfs header should agree.
        // We tolerate a mismatch (use the header value).
    }
    const unsigned char* payload = xattr_buf + DECMPFS_HEADER_SIZE;
    const size_t payload_len = xattr_len - DECMPFS_HEADER_SIZE;
    if (payload_len == 0) {
        error = "decmpfs xattr has no payload";
        return false;
    }
 
    // The 0xFF marker means "raw uncompressed data follows"
    if (payload[0] == 0xFF) {
        const size_t raw_len = payload_len - 1;
        if (raw_len < h.size) {
            // Tolerate: maybe the size declared is wrong; use what we
            // have.
            out.assign(payload + 1, payload + 1 + raw_len);
        } else {
            out.assign(payload + 1, payload + 1 + h.size);
        }
        return true;
    }
 
    // Standard zlib stream
    out.resize(static_cast<size_t>(h.size));
    z_stream zs{};
    zs.next_in = const_cast<Bytef*>(payload);
    zs.avail_in = static_cast<uInt>(payload_len);
    zs.next_out = out.data();
    zs.avail_out = static_cast<uInt>(out.size());
    int ret = inflateInit(&zs);
    if (ret != Z_OK) {
        error = "inflateInit failed";
        return false;
    }
    ret = inflate(&zs, Z_FINISH);
    if (ret != Z_STREAM_END && ret != Z_OK) {
        error = std::string("inflate failed: ") +
                (zs.msg ? zs.msg : "unknown error");
        inflateEnd(&zs);
        return false;
    }
    out.resize(static_cast<size_t>(zs.total_out));
    inflateEnd(&zs);
    return true;
}
 
bool decompress_resource_fork_zlib(const unsigned char* rsrc_buf,
                                    size_t rsrc_len,
                                    uint64_t expected_uncompressed_size,
                                    std::vector<unsigned char>& out,
                                    std::string& error) {
    out.clear();
    if (rsrc_len < 16) {
        error = "resource fork too small for header";
        return false;
    }
    // Resource fork header (big-endian):
    //   __be32 dataOffset
    //   __be32 mapOffset
    //   __be32 dataLength
    //   __be32 mapLength
    const uint32_t dataOffset = be32(rsrc_buf + 0);
    // const uint32_t mapOffset  = be32(rsrc_buf + 4);
    const uint32_t dataLength = be32(rsrc_buf + 8);
    // const uint32_t mapLength  = be32(rsrc_buf + 12);
 
    if (static_cast<uint64_t>(dataOffset) + dataLength > rsrc_len) {
        error = "resource fork data section out of range";
        return false;
    }
 
    const unsigned char* data = rsrc_buf + dataOffset;
    if (dataLength < 4) {
        error = "resource fork data section too small";
        return false;
    }
 
    // First 4 bytes of the data section: __be32 stream length
    // (= dataLength - 4)
    const uint32_t streamLen = be32(data + 0);
    if (streamLen + 4u > dataLength) {
        error = "resource fork stream length inconsistent";
        return false;
    }
    const unsigned char* stream = data + 4;
 
    // Chunked stream layout (little-endian!):
    //   __le32 numChunks
    //   struct { __le32 offset; __le32 size; } chunks[numChunks]
    //   chunk bytes
    if (streamLen < 4) {
        error = "stream too small for chunk count";
        return false;
    }
    const uint32_t numChunks = le32(stream + 0);
    if (numChunks == 0 || numChunks > 1'000'000) {
        std::ostringstream m;
        m << "implausible chunk count: " << numChunks;
        error = m.str();
        return false;
    }
    // Chunk index table starts at offset 4 within stream
    const size_t chunk_table_size = static_cast<size_t>(numChunks) * 8;
    if (4u + chunk_table_size > streamLen) {
        error = "chunk table overruns stream";
        return false;
    }
    const unsigned char* chunk_table = stream + 4;
 
    // Pre-allocate output
    out.reserve(static_cast<size_t>(expected_uncompressed_size));
 
    // Decompress each chunk
    for (uint32_t i = 0; i < numChunks; ++i) {
        const uint32_t c_off  = le32(chunk_table + i * 8 + 0);
        const uint32_t c_size = le32(chunk_table + i * 8 + 4);
        if (c_off + c_size > streamLen) {
            std::ostringstream m;
            m << "chunk " << i << " out of stream bounds";
            error = m.str();
            return false;
        }
        const unsigned char* c_data = stream + c_off;
 
        // Each chunk decompresses to up to kDecmpfsBlockSize bytes
        std::vector<unsigned char> chunk_out(kDecmpfsBlockSize);
        size_t produced = 0;
        std::string ce;
        if (!inflate_chunk(c_data, c_size, chunk_out.data(),
                           chunk_out.size(), produced, ce)) {
            std::ostringstream m;
            m << "chunk " << i << ": " << ce;
            error = m.str();
            return false;
        }
        out.insert(out.end(), chunk_out.begin(), chunk_out.begin() + produced);
        if (out.size() > expected_uncompressed_size) {
            // Some files report a smaller logical size than the chunks
            // produce -- truncate.
            out.resize(static_cast<size_t>(expected_uncompressed_size));
            break;
        }
    }
 
    if (out.size() != expected_uncompressed_size) {
        std::ostringstream m;
        m << "decompressed size " << out.size()
          << " differs from expected " << expected_uncompressed_size;
        // This is a soft warning, not a fatal error: some volumes have
        // size accounting that doesn't include trailing zeros, etc.
        // We DO accept the buffer as long as it's non-empty, but log.
        error = m.str();
        // Still return true if we have nonzero bytes (caller checks
        // error and decides). Return false only on truly empty output.
        if (out.empty()) return false;
    }
    return true;
}
 
} // namespace hfs