C++ e i formati di compressione
In C++ la compressione richiede più lavoro che negli altri linguaggi, ma offre in cambio il controllo completo su memoria, buffer e parametri, e l'accesso diretto alle stesse librerie su cui si appoggiano tutti gli altri runtime.
A differenza degli altri linguaggi esaminati in questa serie, il C++ non offre alcun supporto alla compressione nella libreria standard. Il lavoro si svolge quindi con le librerie C di riferimento, che sono le stesse usate internamente da Node.js, Python, PHP e dagli altri runtime: zlib per Gzip e DEFLATE, libzstd per Zstandard, la libreria di Google per Brotli e libarchive per gli archivi ZIP e TAR. In questo articolo vediamo come usarle da C++ moderno, avvolgendo le loro API in classi RAII sicure rispetto alle eccezioni e gestendo correttamente streaming, errori e input malevoli.
Configurare il progetto con CMake
Tutte le librerie citate sono disponibili come pacchetti nelle principali distribuzioni Linux (su Debian e Ubuntu: zlib1g-dev, libzstd-dev, libbrotli-dev e libarchive-dev), tramite Homebrew su macOS e tramite vcpkg o Conan su qualsiasi piattaforma. CMake include moduli di ricerca per zlib e libarchive, mentre per zstd e Brotli si usa pkg-config.
cmake_minimum_required(VERSION 3.25)
project(compression_demo LANGUAGES CXX)
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
find_package(ZLIB REQUIRED)
find_package(LibArchive REQUIRED)
find_package(PkgConfig REQUIRED)
pkg_check_modules(ZSTD REQUIRED IMPORTED_TARGET libzstd)
pkg_check_modules(BROTLI REQUIRED IMPORTED_TARGET libbrotlienc libbrotlidec)
add_executable(compression_demo main.cpp)
target_compile_options(compression_demo PRIVATE -Wall -Wextra -Wpedantic)
target_link_libraries(compression_demo PRIVATE
ZLIB::ZLIB
LibArchive::LibArchive
PkgConfig::ZSTD
PkgConfig::BROTLI
)
Il modello di zlib
L'API di zlib ruota attorno alla struttura z_stream, che contiene puntatori e contatori per il buffer di input (next_in, avail_in) e per quello di output (next_out, avail_out). Si inizializza lo stato con deflateInit2 o inflateInit2, si chiamano ripetutamente deflate o inflate finché tutto l'input è consumato e l'output emesso, e infine si libera lo stato con deflateEnd o inflateEnd.
Il formato del contenitore si sceglie con il parametro windowBits, esattamente come nel modulo zlib di Python, che ne è un sottile involucro:
- da 8 a 15: formato zlib (RFC 1950);
- da -8 a -15: DEFLATE raw (RFC 1951);
- 16 più la finestra, quindi tipicamente 31: formato Gzip (RFC 1952);
- 32 più la finestra, quindi tipicamente 47, solo in decompressione: rilevamento automatico di zlib e Gzip.
Un wrapper RAII per zlib
Lo stato di zlib alloca memoria che va sempre liberata, anche in presenza di eccezioni. Il modo idiomatico di garantirlo in C++ è una classe che acquisisce la risorsa nel costruttore e la rilascia nel distruttore, disabilitando la copia. L'implementazione seguente offre compressione e decompressione Gzip in memoria, con un limite configurabile sulla dimensione dell'output.
#include <zlib.h>
#include <cstdint>
#include <span>
#include <stdexcept>
#include <string>
#include <vector>
namespace compression {
class ZlibError : public std::runtime_error {
public:
ZlibError(const std::string& what, int code, const char* msg)
: std::runtime_error(what + ": " + (msg ? msg : zError(code))) {}
};
enum class Format : int {
Raw = -15,
Zlib = 15,
Gzip = 15 + 16,
Auto = 15 + 32 // solo in decompressione
};
// Gestisce il ciclo di vita di uno z_stream usato per comprimere
class Deflater {
public:
explicit Deflater(Format format = Format::Gzip, int level = Z_DEFAULT_COMPRESSION) {
int rc = deflateInit2(&stream_, level, Z_DEFLATED, static_cast<int>(format), 8, Z_DEFAULT_STRATEGY);
if (rc != Z_OK) {
throw ZlibError("deflateInit2", rc, stream_.msg);
}
}
~Deflater() { deflateEnd(&stream_); }
Deflater(const Deflater&) = delete;
Deflater& operator=(const Deflater&) = delete;
// Comprime un blocco; finish = true chiude il flusso scrivendo il trailer
void compress(std::span<const std::uint8_t> input, std::vector<std::uint8_t>& output, bool finish) {
stream_.next_in = const_cast<Bytef*>(input.data());
stream_.avail_in = static_cast<uInt>(input.size());
const int flush = finish ? Z_FINISH : Z_NO_FLUSH;
std::uint8_t buffer[64 * 1024];
int rc;
do {
stream_.next_out = buffer;
stream_.avail_out = sizeof(buffer);
rc = deflate(&stream_, flush);
if (rc == Z_STREAM_ERROR) {
throw ZlibError("deflate", rc, stream_.msg);
}
output.insert(output.end(), buffer, buffer + (sizeof(buffer) - stream_.avail_out));
// Continuiamo finché zlib riempie completamente il buffer di output
} while (stream_.avail_out == 0);
if (finish && rc != Z_STREAM_END) {
throw ZlibError("deflate", rc, "flusso non terminato");
}
}
private:
z_stream stream_{};
};
// Gestisce il ciclo di vita di uno z_stream usato per decomprimere
class Inflater {
public:
explicit Inflater(Format format = Format::Auto) {
int rc = inflateInit2(&stream_, static_cast<int>(format));
if (rc != Z_OK) {
throw ZlibError("inflateInit2", rc, stream_.msg);
}
}
~Inflater() { inflateEnd(&stream_); }
Inflater(const Inflater&) = delete;
Inflater& operator=(const Inflater&) = delete;
// Decomprime un blocco; restituisce true quando il flusso è terminato
bool decompress(std::span<const std::uint8_t> input, std::vector<std::uint8_t>& output, std::size_t max_output) {
stream_.next_in = const_cast<Bytef*>(input.data());
stream_.avail_in = static_cast<uInt>(input.size());
std::uint8_t buffer[64 * 1024];
int rc;
do {
stream_.next_out = buffer;
stream_.avail_out = sizeof(buffer);
rc = inflate(&stream_, Z_NO_FLUSH);
if (rc == Z_NEED_DICT || rc == Z_DATA_ERROR || rc == Z_MEM_ERROR || rc == Z_STREAM_ERROR) {
throw ZlibError("inflate", rc, stream_.msg);
}
const std::size_t produced = sizeof(buffer) - stream_.avail_out;
// Limite contro le decompression bomb
if (output.size() + produced > max_output) {
throw std::length_error("output decompresso oltre il limite");
}
output.insert(output.end(), buffer, buffer + produced);
} while (stream_.avail_out == 0 && rc != Z_STREAM_END);
return rc == Z_STREAM_END;
}
private:
z_stream stream_{};
};
inline std::vector<std::uint8_t> gzip(std::span<const std::uint8_t> data, int level = Z_DEFAULT_COMPRESSION) {
std::vector<std::uint8_t> out;
out.reserve(deflateBound(nullptr, static_cast<uLong>(data.size())) + 18);
Deflater(Format::Gzip, level).compress(data, out, true);
return out;
}
inline std::vector<std::uint8_t> gunzip(std::span<const std::uint8_t> data, std::size_t max_output = 64 << 20) {
std::vector<std::uint8_t> out;
if (!Inflater(Format::Auto).decompress(data, out, max_output)) {
throw std::runtime_error("flusso Gzip troncato");
}
return out;
}
} // namespace compression
Il distruttore chiama deflateEnd e inflateEnd anche se il costruttore è andato a buon fine e un'eccezione è stata lanciata più avanti: è questa la garanzia che rende il codice sicuro. Si noti anche che l'interfaccia di zlib usa uInt a 32 bit per le dimensioni dei buffer: per input superiori a 4 GiB bisogna suddividere i dati in blocchi, cosa che la versione in streaming della prossima sezione fa naturalmente.
Streaming di file
Con il wrapper appena scritto, comprimere un file di qualsiasi dimensione si riduce a un ciclo di lettura a blocchi. In alternativa, per i soli file Gzip, zlib offre l'interfaccia semplificata gzopen, gzread e gzwrite, utile quando non serve un controllo fine.
#include "compression.hpp"
#include <zlib.h>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <memory>
#include <string>
#include <string_view>
#include <type_traits>
namespace fs = std::filesystem;
// Comprime un file a blocchi usando il wrapper RAII
void gzip_file(const fs::path& source, const fs::path& destination, int level) {
std::ifstream in(source, std::ios::binary);
std::ofstream out(destination, std::ios::binary);
if (!in || !out) {
throw std::runtime_error("impossibile aprire i file");
}
compression::Deflater deflater(compression::Format::Gzip, level);
std::vector<std::uint8_t> input(1 << 20);
std::vector<std::uint8_t> output;
while (in) {
in.read(reinterpret_cast<char*>(input.data()), static_cast<std::streamsize>(input.size()));
const auto count = static_cast<std::size_t>(in.gcount());
output.clear();
// L'ultimo blocco chiude il flusso e scrive il trailer
deflater.compress({input.data(), count}, output, !in);
out.write(reinterpret_cast<const char*>(output.data()), static_cast<std::streamsize>(output.size()));
}
}
// Deleter per usare gzFile con unique_ptr
struct GzCloser {
void operator()(gzFile file) const { gzclose(file); }
};
using GzFilePtr = std::unique_ptr<std::remove_pointer_t<gzFile>, GzCloser>;
// Conta le righe che contengono un testo usando l'interfaccia gz* di zlib
std::size_t count_matching_lines(const fs::path& path, const std::string& needle) {
GzFilePtr file(gzopen(path.c_str(), "rb"));
if (!file) {
throw std::runtime_error("impossibile aprire " + path.string());
}
gzbuffer(file.get(), 128 * 1024);
std::size_t count = 0;
char line[8192];
while (gzgets(file.get(), line, sizeof(line)) != nullptr) {
if (std::string_view(line).find(needle) != std::string_view::npos) {
++count;
}
}
return count;
}
int main() {
try {
gzip_file("app.log", "app.log.gz", Z_BEST_COMPRESSION);
std::cout << "Errori: " << count_matching_lines("app.log.gz", " ERROR ") << '\n';
} catch (const std::exception& e) {
std::cerr << "Errore: " << e.what() << '\n';
return 1;
}
}
L'uso di std::unique_ptr con un deleter personalizzato è un'alternativa più compatta alla classe dedicata quando la risorsa è un semplice handle, come il gzFile restituito da gzopen.
Zstandard con libzstd
La libreria zstd offre due livelli di API. Le funzioni semplici ZSTD_compress e ZSTD_decompress lavorano in un colpo solo su buffer in memoria; l'API avanzata, basata su un contesto ZSTD_CCtx e sulla funzione ZSTD_compressStream2, permette lo streaming e la configurazione di parametri come il numero di thread o il checksum. Tutte le funzioni che restituiscono una dimensione segnalano gli errori con valori speciali, da verificare con ZSTD_isError.
#include <zstd.h>
#include <cstdint>
#include <fstream>
#include <memory>
#include <span>
#include <stdexcept>
#include <string>
#include <vector>
namespace compression::zstd {
inline std::size_t check(std::size_t result, const char* where) {
if (ZSTD_isError(result)) {
throw std::runtime_error(std::string(where) + ": " + ZSTD_getErrorName(result));
}
return result;
}
struct CCtxDeleter {
void operator()(ZSTD_CCtx* ctx) const { ZSTD_freeCCtx(ctx); }
};
struct DCtxDeleter {
void operator()(ZSTD_DCtx* ctx) const { ZSTD_freeDCtx(ctx); }
};
// Compressione in memoria in un colpo solo
inline std::vector<std::uint8_t> compress(std::span<const std::uint8_t> data, int level = 3) {
std::vector<std::uint8_t> out(ZSTD_compressBound(data.size()));
const std::size_t size = check(ZSTD_compress(out.data(), out.size(), data.data(), data.size(), level), "ZSTD_compress");
out.resize(size);
return out;
}
// Decompressione in memoria con limite: la dimensione dichiarata nel frame non è affidabile
inline std::vector<std::uint8_t> decompress(std::span<const std::uint8_t> data, std::size_t max_output) {
const unsigned long long declared = ZSTD_getFrameContentSize(data.data(), data.size());
if (declared == ZSTD_CONTENTSIZE_ERROR) {
throw std::runtime_error("dati zstd non validi");
}
if (declared != ZSTD_CONTENTSIZE_UNKNOWN && declared > max_output) {
throw std::length_error("dimensione dichiarata oltre il limite");
}
// Il buffer limitato impedisce comunque di superare max_output
const std::size_t capacity = declared == ZSTD_CONTENTSIZE_UNKNOWN ? max_output : static_cast<std::size_t>(declared);
std::vector<std::uint8_t> out(capacity);
const std::size_t size = check(ZSTD_decompress(out.data(), out.size(), data.data(), data.size()), "ZSTD_decompress");
out.resize(size);
return out;
}
// Comprime un file in streaming, con checksum e compressione multithread
inline void compress_file(const std::string& source, const std::string& destination, int level, int workers) {
std::unique_ptr<ZSTD_CCtx, CCtxDeleter> ctx(ZSTD_createCCtx());
if (!ctx) {
throw std::bad_alloc();
}
check(ZSTD_CCtx_setParameter(ctx.get(), ZSTD_c_compressionLevel, level), "compressionLevel");
check(ZSTD_CCtx_setParameter(ctx.get(), ZSTD_c_checksumFlag, 1), "checksumFlag");
// Il multithreading è disponibile solo se libzstd è compilata con il supporto ai thread
if (workers > 0) {
check(ZSTD_CCtx_setParameter(ctx.get(), ZSTD_c_nbWorkers, workers), "nbWorkers");
}
std::ifstream in(source, std::ios::binary);
std::ofstream out(destination, std::ios::binary);
std::vector<char> in_buf(ZSTD_CStreamInSize());
std::vector<char> out_buf(ZSTD_CStreamOutSize());
bool last_chunk = false;
while (!last_chunk) {
in.read(in_buf.data(), static_cast<std::streamsize>(in_buf.size()));
const auto count = static_cast<std::size_t>(in.gcount());
last_chunk = !in;
const ZSTD_EndDirective mode = last_chunk ? ZSTD_e_end : ZSTD_e_continue;
ZSTD_inBuffer input{in_buf.data(), count, 0};
bool finished = false;
do {
ZSTD_outBuffer output{out_buf.data(), out_buf.size(), 0};
const std::size_t remaining = check(ZSTD_compressStream2(ctx.get(), &output, &input, mode), "ZSTD_compressStream2");
out.write(out_buf.data(), static_cast<std::streamsize>(output.pos));
// Con ZSTD_e_end il valore restituito indica i byte ancora da emettere
finished = last_chunk ? remaining == 0 : input.pos == input.size;
} while (!finished);
}
}
} // namespace compression::zstd
Il pattern del ciclo è quello raccomandato dalla documentazione di zstd: con ZSTD_e_continue si chiama la funzione finché tutto l'input è stato consumato; con ZSTD_e_end la si chiama finché il valore restituito non è zero, il che indica che il frame è stato chiuso e tutti i dati sono stati emessi.
Brotli
La libreria Brotli di Google è divisa in encoder e decoder, con header e librerie separate. Come per zstd, esiste un'API in un colpo solo (BrotliEncoderCompress e BrotliDecoderDecompress) e un'API in streaming basata su istanze dell'encoder e del decoder. La funzione BrotliEncoderMaxCompressedSize calcola la dimensione massima dell'output per dimensionare il buffer.
#include <brotli/decode.h>
#include <brotli/encode.h>
#include <cstdint>
#include <memory>
#include <span>
#include <stdexcept>
#include <vector>
namespace compression::brotli {
inline std::vector<std::uint8_t> compress(std::span<const std::uint8_t> data, int quality = BROTLI_DEFAULT_QUALITY,
BrotliEncoderMode mode = BROTLI_MODE_GENERIC) {
std::size_t size = BrotliEncoderMaxCompressedSize(data.size());
if (size == 0) {
throw std::length_error("input troppo grande per Brotli in un colpo solo");
}
std::vector<std::uint8_t> out(size);
if (!BrotliEncoderCompress(quality, BROTLI_DEFAULT_WINDOW, mode, data.size(), data.data(), &size, out.data())) {
throw std::runtime_error("compressione Brotli fallita");
}
out.resize(size);
return out;
}
struct DecoderDeleter {
void operator()(BrotliDecoderState* state) const { BrotliDecoderDestroyInstance(state); }
};
// Decompressione in streaming con limite sull'output
inline std::vector<std::uint8_t> decompress(std::span<const std::uint8_t> data, std::size_t max_output) {
std::unique_ptr<BrotliDecoderState, DecoderDeleter> state(BrotliDecoderCreateInstance(nullptr, nullptr, nullptr));
if (!state) {
throw std::bad_alloc();
}
std::vector<std::uint8_t> out;
std::uint8_t buffer[64 * 1024];
std::size_t available_in = data.size();
const std::uint8_t* next_in = data.data();
for (;;) {
std::size_t available_out = sizeof(buffer);
std::uint8_t* next_out = buffer;
const auto result = BrotliDecoderDecompressStream(state.get(), &available_in, &next_in,
&available_out, &next_out, nullptr);
const std::size_t produced = sizeof(buffer) - available_out;
if (out.size() + produced > max_output) {
throw std::length_error("output Brotli oltre il limite");
}
out.insert(out.end(), buffer, buffer + produced);
if (result == BROTLI_DECODER_RESULT_SUCCESS) {
return out;
}
if (result == BROTLI_DECODER_RESULT_ERROR) {
throw std::runtime_error(BrotliDecoderErrorString(BrotliDecoderGetErrorCode(state.get())));
}
if (result == BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT) {
throw std::runtime_error("flusso Brotli troncato");
}
// BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT: continuiamo il ciclo con un nuovo buffer
}
}
} // namespace compression::brotli
La qualità di Brotli va da 0 a 11, con default 11 (BROTLI_DEFAULT_QUALITY), mentre la finestra, espressa come logaritmo in base due, va da 10 a 24 con default 22. Per contenuti testuali come HTML, CSS o JSON, la modalità BROTLI_MODE_TEXT migliora leggermente il risultato.
Un confronto tra i codec
Con i tre wrapper pronti possiamo scrivere un piccolo benchmark che misuri dimensione e tempo di compressione per ciascun codec, usando std::chrono::steady_clock.
#include "brotli.hpp"
#include "compression.hpp"
#include "zstd.hpp"
#include <chrono>
#include <cstdint>
#include <format>
#include <fstream>
#include <functional>
#include <iostream>
#include <iterator>
#include <vector>
using Bytes = std::vector<std::uint8_t>;
void measure(std::string_view label, const Bytes& input, const std::function<Bytes(const Bytes&)>& fn) {
const auto start = std::chrono::steady_clock::now();
const Bytes output = fn(input);
const std::chrono::duration<double, std::milli> elapsed = std::chrono::steady_clock::now() - start;
const double ratio = 100.0 * static_cast<double>(output.size()) / static_cast<double>(input.size());
std::cout << std::format("{:<12} {:>10} byte {:>6.1f}% {:>9.2f} ms\n", label, output.size(), ratio, elapsed.count());
}
int main(int argc, char* argv[]) {
std::ifstream file(argc > 1 ? argv[1] : "data.json", std::ios::binary);
const Bytes input{std::istreambuf_iterator<char>(file), std::istreambuf_iterator<char>()};
if (input.empty()) {
std::cerr << "File vuoto o inesistente\n";
return 1;
}
for (int level : {1, 6, 9}) {
measure(std::format("gzip -{}", level), input, [level](const Bytes& d) { return compression::gzip(d, level); });
}
for (int level : {3, 10, 19}) {
measure(std::format("zstd -{}", level), input, [level](const Bytes& d) { return compression::zstd::compress(d, level); });
}
for (int quality : {4, 6, 11}) {
measure(std::format("brotli q{}", quality), input,
[quality](const Bytes& d) { return compression::brotli::compress(d, quality, BROTLI_MODE_TEXT); });
}
}
Su dati testuali il risultato tipico mostra Zstandard al livello 3 più veloce di Gzip al livello 6 e con un rapporto di compressione migliore, Brotli alla qualità 11 come vincitore in termini di dimensione e, soprattutto, una decompressione di zstd molto più rapida di tutte le alternative. È questo profilo a renderlo la scelta preferita per log, backup e comunicazione tra servizi.
Archivi ZIP e TAR con libarchive
Per gli archivi la libreria di riferimento è libarchive, la stessa che implementa il comando bsdtar su FreeBSD, macOS e Windows. Supporta in lettura e scrittura TAR (in tutte le sue varianti), ZIP, 7z, cpio e ISO 9660, combinati con filtri di compressione come Gzip, bzip2, XZ e Zstandard. L'API separa il formato del contenitore dal filtro di compressione, riflettendo la distinzione tra codec e contenitori vista in tutta questa serie.
#include <archive.h>
#include <archive_entry.h>
#include <filesystem>
#include <fstream>
#include <memory>
#include <stdexcept>
#include <string>
#include <vector>
namespace fs = std::filesystem;
struct WriteDeleter {
void operator()(archive* a) const { archive_write_free(a); }
};
struct EntryDeleter {
void operator()(archive_entry* e) const { archive_entry_free(e); }
};
void check(archive* a, int rc, const char* where) {
if (rc < ARCHIVE_WARN) {
throw std::runtime_error(std::string(where) + ": " + archive_error_string(a));
}
}
// Crea un archivio di una directory; il formato dipende dall'estensione richiesta
void create_archive(const fs::path& source_dir, const fs::path& archive_path) {
std::unique_ptr<archive, WriteDeleter> a(archive_write_new());
const std::string name = archive_path.filename().string();
if (name.ends_with(".zip")) {
check(a.get(), archive_write_set_format_zip(a.get()), "format zip");
// Le opzioni permettono di scegliere il livello di DEFLATE delle voci
check(a.get(), archive_write_set_options(a.get(), "zip:compression-level=9"), "zip options");
} else if (name.ends_with(".tar.zst")) {
check(a.get(), archive_write_add_filter_zstd(a.get()), "filter zstd");
check(a.get(), archive_write_set_format_pax_restricted(a.get()), "format pax");
} else {
check(a.get(), archive_write_add_filter_gzip(a.get()), "filter gzip");
check(a.get(), archive_write_set_format_pax_restricted(a.get()), "format pax");
}
check(a.get(), archive_write_open_filename(a.get(), archive_path.c_str()), "open");
std::vector<char> buffer(64 * 1024);
for (const auto& item : fs::recursive_directory_iterator(source_dir)) {
const auto relative = fs::relative(item.path(), source_dir).generic_string();
std::unique_ptr<archive_entry, EntryDeleter> entry(archive_entry_new());
archive_entry_set_pathname(entry.get(), relative.c_str());
if (item.is_directory()) {
archive_entry_set_filetype(entry.get(), AE_IFDIR);
archive_entry_set_perm(entry.get(), 0755);
check(a.get(), archive_write_header(a.get(), entry.get()), "header");
continue;
}
if (!item.is_regular_file()) {
continue;
}
archive_entry_set_filetype(entry.get(), AE_IFREG);
archive_entry_set_perm(entry.get(), 0644);
archive_entry_set_size(entry.get(), static_cast<la_int64_t>(item.file_size()));
check(a.get(), archive_write_header(a.get(), entry.get()), "header");
std::ifstream in(item.path(), std::ios::binary);
while (in.read(buffer.data(), static_cast<std::streamsize>(buffer.size())) || in.gcount() > 0) {
if (archive_write_data(a.get(), buffer.data(), static_cast<std::size_t>(in.gcount())) < 0) {
throw std::runtime_error(archive_error_string(a.get()));
}
}
}
// archive_write_close scrive i dati finali (central directory o blocchi di chiusura)
check(a.get(), archive_write_close(a.get()), "close");
}
Estrazione sicura con libarchive
libarchive offre un'API di estrazione su disco, archive_write_disk, che accetta una serie di flag di sicurezza. Di default, per compatibilità, quasi tutti sono disattivati: è responsabilità del programmatore abilitarli quando l'archivio non è fidato. I tre principali sono ARCHIVE_EXTRACT_SECURE_NODOTDOT, che rifiuta i percorsi contenenti .., ARCHIVE_EXTRACT_SECURE_NOABSOLUTEPATHS, che rifiuta i percorsi assoluti, e ARCHIVE_EXTRACT_SECURE_SYMLINKS, che impedisce di scrivere attraverso link simbolici. Come difesa contro le decompression bomb conviene inoltre contare i byte estratti e rifiutare i tipi di voce diversi da file e directory.
#include <archive.h>
#include <archive_entry.h>
#include <algorithm>
#include <cstdint>
#include <filesystem>
#include <iostream>
#include <memory>
#include <stdexcept>
#include <string>
namespace fs = std::filesystem;
struct ReadDeleter {
void operator()(archive* a) const { archive_read_free(a); }
};
struct DiskDeleter {
void operator()(archive* a) const { archive_write_free(a); }
};
struct ExtractionLimits {
std::size_t max_entries = 10'000;
std::int64_t max_total_bytes = std::int64_t{1} << 30;
};
void extract_safely(const fs::path& archive_path, const fs::path& destination, ExtractionLimits limits = {}) {
std::unique_ptr<archive, ReadDeleter> reader(archive_read_new());
// Rilevamento automatico di formato e compressione
archive_read_support_filter_all(reader.get());
archive_read_support_format_all(reader.get());
if (archive_read_open_filename(reader.get(), archive_path.c_str(), 64 * 1024) != ARCHIVE_OK) {
throw std::runtime_error(archive_error_string(reader.get()));
}
std::unique_ptr<archive, DiskDeleter> disk(archive_write_disk_new());
// NOABSOLUTEPATHS non si usa perché i percorsi finali saranno assoluti per costruzione
archive_write_disk_set_options(disk.get(),
ARCHIVE_EXTRACT_TIME |
ARCHIVE_EXTRACT_SECURE_NODOTDOT |
ARCHIVE_EXTRACT_SECURE_SYMLINKS |
ARCHIVE_EXTRACT_NO_OVERWRITE);
// Una destinazione assoluta e normalizzata non contiene componenti ..
const fs::path root = fs::absolute(destination).lexically_normal();
fs::create_directories(root);
std::size_t entries = 0;
std::int64_t written = 0;
archive_entry* entry = nullptr;
while (archive_read_next_header(reader.get(), &entry) == ARCHIVE_OK) {
if (++entries > limits.max_entries) {
throw std::runtime_error("troppe voci nell'archivio");
}
const char* name = archive_entry_pathname(entry);
const auto type = archive_entry_filetype(entry);
// Negli archivi TAR gli hard link hanno tipo AE_IFREG ma un target valorizzato
if (name == nullptr || (type != AE_IFREG && type != AE_IFDIR) || archive_entry_hardlink(entry) != nullptr) {
// Link, dispositivi e FIFO vengono saltati
std::cerr << "Voce ignorata: " << (name ? name : "(senza nome)") << '\n';
continue;
}
// Validiamo il percorso originale prima di riscriverlo sotto la destinazione
const fs::path original(name);
const bool escapes = std::ranges::any_of(original, [](const fs::path& part) { return part == ".."; });
if (original.is_absolute() || original.has_root_name() || escapes) {
throw std::runtime_error("percorso non sicuro: " + original.string());
}
const fs::path target = root / original;
archive_entry_set_pathname(entry, target.c_str());
if (archive_write_header(disk.get(), entry) != ARCHIVE_OK) {
throw std::runtime_error(archive_error_string(disk.get()));
}
const void* block = nullptr;
std::size_t size = 0;
la_int64_t offset = 0;
int rc;
while ((rc = archive_read_data_block(reader.get(), &block, &size, &offset)) == ARCHIVE_OK) {
// Contiamo i byte reali, non quelli dichiarati nell'intestazione
written += static_cast<std::int64_t>(size);
if (written > limits.max_total_bytes) {
throw std::runtime_error("dimensione estratta oltre il limite");
}
if (archive_write_data_block(disk.get(), block, size, offset) != ARCHIVE_OK) {
throw std::runtime_error(archive_error_string(disk.get()));
}
}
if (rc != ARCHIVE_EOF) {
throw std::runtime_error(archive_error_string(reader.get()));
}
archive_write_finish_entry(disk.get());
}
archive_write_close(disk.get());
}
int main(int argc, char* argv[]) {
if (argc != 3) {
std::cerr << "Uso: " << argv[0] << " archivio destinazione\n";
return 1;
}
try {
extract_safely(argv[1], argv[2]);
} catch (const std::exception& e) {
std::cerr << "Errore: " << e.what() << '\n';
return 1;
}
}
Riscrivere il percorso anteponendo la destinazione, invece di cambiare la directory di lavoro del processo con chdir, rende la funzione utilizzabile anche in programmi multithread. Proprio perché il percorso finale è assoluto, il flag ARCHIVE_EXTRACT_SECURE_NOABSOLUTEPATHS non è utilizzabile: il controllo sui percorsi assoluti e sui componenti .. viene quindi fatto esplicitamente sul nome originale della voce, mentre ARCHIVE_EXTRACT_SECURE_NODOTDOT resta come seconda linea di difesa sul percorso finale e ARCHIVE_EXTRACT_SECURE_SYMLINKS impedisce di scrivere attraverso link simbolici già presenti su disco.
Conclusioni
In C++ la compressione richiede più lavoro che negli altri linguaggi, ma offre in cambio il controllo completo su memoria, buffer e parametri, e l'accesso diretto alle stesse librerie su cui si appoggiano tutti gli altri runtime. La chiave per un codice robusto sta nel C++ moderno: classi RAII o std::unique_ptr con deleter per ogni risorsa delle librerie C, std::span per passare i buffer in modo sicuro, eccezioni per trasformare i codici di errore in condizioni impossibili da ignorare e, come in tutta la serie, limiti espliciti sull'output e validazione dei percorsi quando si trattano dati provenienti dall'esterno.