codec.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-or-later
// Copyright 2026 Johnson Ogundeji
#pragma once
 
 
#include "signet/types.hpp"
#include "signet/error.hpp"
 
#include <algorithm>
#include <cstdint>
#include <cstring>
#include <memory>
#include <mutex>
#include <unordered_map>
#include <vector>
 
namespace signet::forge {
 
// ===========================================================================
// CompressionCodec — abstract interface for compression/decompression
// ===========================================================================
 
class CompressionCodec {
public:
    virtual ~CompressionCodec() = default;
 
    [[nodiscard]] virtual expected<std::vector<uint8_t>> compress(
        const uint8_t* data, size_t size) const = 0;
 
    [[nodiscard]] virtual expected<std::vector<uint8_t>> decompress(
        const uint8_t* data, size_t size, size_t uncompressed_size) const = 0;
 
    [[nodiscard]] virtual Compression codec_type() const = 0;
 
    [[nodiscard]] virtual const char* name() const = 0;
};
 
// ===========================================================================
// CodecRegistry — singleton holding all registered compression codecs
// ===========================================================================
 
class CodecRegistry {
public:
    static CodecRegistry& instance() {
        static CodecRegistry registry;
        return registry;
    }
 
    void register_codec(std::unique_ptr<CompressionCodec> codec) {
        if (!codec) return;
        std::lock_guard<std::mutex> lock(mutex_);
        Compression type = codec->codec_type();
        codecs_[type] = std::move(codec);
    }
 
    [[nodiscard]] const CompressionCodec* get(Compression type) const {
        std::lock_guard<std::mutex> lock(mutex_);
        auto it = codecs_.find(type);
        if (it != codecs_.end()) {
            return it->second.get();
        }
        return nullptr;
    }
 
    [[nodiscard]] bool has(Compression type) const {
        if (type == Compression::UNCOMPRESSED) return true;
        std::lock_guard<std::mutex> lock(mutex_);
        return codecs_.find(type) != codecs_.end();
    }
 
    [[nodiscard]] std::vector<Compression> available() const {
        std::lock_guard<std::mutex> lock(mutex_);
        std::vector<Compression> result;
        result.reserve(codecs_.size() + 1);
        result.push_back(Compression::UNCOMPRESSED);
        for (const auto& [type, _] : codecs_) {
            result.push_back(type);
        }
        return result;
    }
 
    CodecRegistry(const CodecRegistry&) = delete;
    CodecRegistry& operator=(const CodecRegistry&) = delete;
    CodecRegistry(CodecRegistry&&) = delete;
    CodecRegistry& operator=(CodecRegistry&&) = delete;
 
private:
    CodecRegistry() = default;
 
    mutable std::mutex mutex_;
    std::unordered_map<Compression, std::unique_ptr<CompressionCodec>> codecs_;
};
 
// ===========================================================================
// Convenience functions — compress / decompress via the registry
// ===========================================================================
 
[[nodiscard]] inline expected<std::vector<uint8_t>> compress(
    Compression codec, const uint8_t* data, size_t size) {
 
    // UNCOMPRESSED: return a copy of the data
    if (codec == Compression::UNCOMPRESSED) {
        return std::vector<uint8_t>(data, data + size);
    }
 
    const CompressionCodec* impl = CodecRegistry::instance().get(codec);
    if (!impl) {
        return Error{ErrorCode::UNSUPPORTED_COMPRESSION,
                     "compression codec not registered"};
    }
 
    return impl->compress(data, size);
}
 
[[nodiscard]] inline expected<std::vector<uint8_t>> decompress(
    Compression codec, const uint8_t* data, size_t size,
    size_t uncompressed_size) {
 
    // UNCOMPRESSED: return a copy of the data
    if (codec == Compression::UNCOMPRESSED) {
        return std::vector<uint8_t>(data, data + size);
    }
 
    // Absolute decompressed size cap (256 MB)
    // CWE-409: Improper Handling of Highly Compressed Data (Decompression Bomb)
    static constexpr size_t MAX_DECOMPRESS_SIZE = 256ULL * 1024 * 1024;
    if (uncompressed_size > MAX_DECOMPRESS_SIZE) {
        return Error{ErrorCode::CORRUPT_PAGE,
                     "Decompressed size exceeds 256 MB limit"};
    }
    // Reject zero-length compressed data claiming non-zero output
    // CWE-20: Improper Input Validation
    if (size == 0 && uncompressed_size > 0) {
        return Error{ErrorCode::CORRUPT_PAGE,
                     "Zero-length compressed data with non-zero uncompressed size"};
    }
    // Decompression bomb guard: ratio > 1024:1 is suspicious
    // CWE-409: Improper Handling of Highly Compressed Data (Decompression Bomb)
    static constexpr size_t MAX_DECOMPRESSION_RATIO = 1024;
    if (size > 0 && uncompressed_size / size >= MAX_DECOMPRESSION_RATIO) {
        return Error{ErrorCode::CORRUPT_PAGE,
                     "Decompression ratio exceeds limit"};
    }
 
    const CompressionCodec* impl = CodecRegistry::instance().get(codec);
    if (!impl) {
        return Error{ErrorCode::UNSUPPORTED_COMPRESSION,
                     "compression codec not registered"};
    }
 
    return impl->decompress(data, size, uncompressed_size);
}
 
// ===========================================================================
// auto_select_compression — heuristic codec selection
// ===========================================================================
 
[[nodiscard]] inline Compression auto_select_compression(
    [[maybe_unused]] const uint8_t* sample_data,
    [[maybe_unused]] size_t sample_size) {
 
    const auto& registry = CodecRegistry::instance();
 
    // Prefer ZSTD for best compression ratio
    if (registry.has(Compression::ZSTD)) {
        return Compression::ZSTD;
    }
 
    // Snappy: fast compression, moderate ratio
    if (registry.has(Compression::SNAPPY)) {
        return Compression::SNAPPY;
    }
 
    // LZ4 (raw): fast, decent ratio
    if (registry.has(Compression::LZ4_RAW)) {
        return Compression::LZ4_RAW;
    }
 
    // LZ4 (framed, legacy enum value)
    if (registry.has(Compression::LZ4)) {
        return Compression::LZ4;
    }
 
    // No compression codecs available
    return Compression::UNCOMPRESSED;
}
 
} // namespace signet::forge