gzip.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-or-later
// Copyright 2026 Johnson Ogundeji
#pragma once
 
 
#ifdef SIGNET_HAS_GZIP
 
#include "signet/compression/codec.hpp"
 
#include <zlib.h>
 
#include <cstdint>
#include <limits>
#include <string>
#include <vector>
 
namespace signet::forge {
 
class GzipCodec : public CompressionCodec {
public:
    explicit GzipCodec(int compression_level = Z_DEFAULT_COMPRESSION)
        : level_(compression_level) {}
 
    [[nodiscard]] expected<std::vector<uint8_t>> compress(
        const uint8_t* data, size_t size) const override {
 
        // Pessimistic upper bound: deflate worst case is ~0.1% expansion
        // plus gzip header/trailer (~18 bytes). deflateBound gives an
        // accurate upper bound once the stream is initialized, but we
        // need a reasonable initial allocation before that.
        // CWE-190: Integer Overflow (zlib uses uInt for sizes)
        if (size > (std::numeric_limits<uInt>::max)()) {
            return Error{ErrorCode::INTERNAL_ERROR,
                         "GZIP: input exceeds uInt limit"};
        }
 
        z_stream stream{};
        stream.next_in  = const_cast<Bytef*>(data);
        stream.avail_in = static_cast<uInt>(size);
 
        // windowBits = 15 + 16 enables gzip format (not raw deflate).
        int ret = deflateInit2(&stream,
                               level_,
                               Z_DEFLATED,
                               15 + 16,   // gzip framing
                               8,         // default memLevel
                               Z_DEFAULT_STRATEGY);
        if (ret != Z_OK) {
            return Error{ErrorCode::INTERNAL_ERROR,
                         "GZIP: deflateInit2 failed (zlib error " +
                         std::to_string(ret) + ")"};
        }
 
        // Use deflateBound for an accurate output size estimate.
        uLong bound = deflateBound(&stream, static_cast<uLong>(size));
        std::vector<uint8_t> out(bound);
 
        stream.next_out  = out.data();
        stream.avail_out = static_cast<uInt>(out.size());
 
        ret = deflate(&stream, Z_FINISH);
        if (ret != Z_STREAM_END) {
            deflateEnd(&stream);
            return Error{ErrorCode::INTERNAL_ERROR,
                         "GZIP: deflate failed (zlib error " +
                         std::to_string(ret) + ")"};
        }
 
        size_t compressed_size = stream.total_out;
        deflateEnd(&stream);
 
        out.resize(compressed_size);
        return out;
    }
 
    [[nodiscard]] expected<std::vector<uint8_t>> decompress(
        const uint8_t* data, size_t size,
        size_t uncompressed_size) const override {
 
        static constexpr size_t MAX_DECOMPRESS_SIZE = 256 * 1024 * 1024; // 256 MB
        if (uncompressed_size > MAX_DECOMPRESS_SIZE)
            return Error{ErrorCode::INVALID_ARGUMENT, "Decompression size exceeds 256 MB limit"};
 
        if (uncompressed_size == 0) {
            return std::vector<uint8_t>{};
        }
 
        // CWE-190: Integer Overflow (zlib uses uInt for sizes)
        if (size > (std::numeric_limits<uInt>::max)()) {
            return Error{ErrorCode::INTERNAL_ERROR,
                         "GZIP: compressed input exceeds uInt limit"};
        }
        // CWE-190: Integer Overflow (zlib uses uInt for sizes)
        if (uncompressed_size > (std::numeric_limits<uInt>::max)()) {
            return Error{ErrorCode::INTERNAL_ERROR,
                         "GZIP: uncompressed size exceeds uInt limit"};
        }
 
        std::vector<uint8_t> out(uncompressed_size);
 
        z_stream stream{};
        stream.next_in   = const_cast<Bytef*>(data);
        stream.avail_in  = static_cast<uInt>(size);
        stream.next_out  = out.data();
        stream.avail_out = static_cast<uInt>(out.size());
 
        // windowBits = 15 + 16 to accept gzip format.
        int ret = inflateInit2(&stream, 15 + 16);
        if (ret != Z_OK) {
            return Error{ErrorCode::CORRUPT_PAGE,
                         "GZIP: inflateInit2 failed (zlib error " +
                         std::to_string(ret) + ")"};
        }
 
        ret = inflate(&stream, Z_FINISH);
        if (ret != Z_STREAM_END) {
            inflateEnd(&stream);
            return Error{ErrorCode::CORRUPT_PAGE,
                         "GZIP: inflate failed (zlib error " +
                         std::to_string(ret) +
                         (stream.msg ? std::string(", ") + stream.msg
                                     : std::string()) + ")"};
        }
 
        size_t decompressed_size = stream.total_out;
        inflateEnd(&stream);
 
        if (decompressed_size != uncompressed_size) {
            return Error{ErrorCode::CORRUPT_PAGE,
                         "GZIP: decompressed " +
                         std::to_string(decompressed_size) +
                         " bytes but expected " +
                         std::to_string(uncompressed_size)};
        }
 
        return out;
    }
 
 
    [[nodiscard]] Compression codec_type() const override {
        return Compression::GZIP;
    }
 
    [[nodiscard]] const char* name() const override {
        return "gzip";
    }
 
 
private:
    int level_;
};
 
// ===========================================================================
// Auto-registration helper
// ===========================================================================
 
inline void register_gzip_codec(int level = Z_DEFAULT_COMPRESSION) {
    CodecRegistry::instance().register_codec(std::make_unique<GzipCodec>(level));
}
 
} // namespace signet::forge
 
#endif // SIGNET_HAS_GZIP