anonymous_namespace{archive_worker.cpp} Namespace Reference

Classes
struct	ZipEntryInfo

Functions
uint16_t	read_u16_le (std::ifstream &f)
uint32_t	read_u32_le (std::ifstream &f)
bool	read_exact (std::ifstream &f, char *buf, std::size_t len)
std::string	read_string (std::ifstream &f, std::size_t len)
bool	contains_dotdot_path (const std::string &name)
bool	is_absolute_or_weird_path (const std::string &name)
bool	looks_like_nested_archive_name (const std::string &name)
void	print_json_bool (const char *key, bool value, bool comma=true)
void	print_json_int (const char *key, int value, bool comma=true)
void	print_json_str (const char *key, const std::string &value, bool comma=true)
bool	find_eocd (std::ifstream &f, std::uint64_t file_size, std::uint64_t &eocd_offset)
bool	parse_zip64_extra (const std::vector< unsigned char > &extra, bool uncomp_is_sentinel, bool comp_is_sentinel, bool offset_is_sentinel, std::uint64_t *out_uncomp, std::uint64_t *out_comp, std::uint64_t *out_offset)
bool	read_local_entry (std::ifstream &f, std::uint64_t file_size, std::uint64_t local_offset, uint16_t &method, uint32_t &compressed_size, uint32_t &uncompressed_size, uint16_t &gp_flags_out, std::string &filename, std::uint64_t &data_offset, std::uint64_t &data_end, std::uint64_t &zip64_comp_size, std::uint64_t &zip64_uncomp_size, bool &has_zip64_extra)

Variables
constexpr uint32_t	SIG_LOCAL_FILE_HEADER = 0x04034b50
constexpr uint32_t	SIG_CENTRAL_DIR_HEADER = 0x02014b50
constexpr uint32_t	SIG_END_OF_CENTRAL_DIR = 0x06054b50

Function Documentation

contains_dotdot_path()

bool anonymous_namespace{archive_worker.cpp}::contains_dotdot_path

(

const std::string &

name

)

Definition at line 82 of file archive_worker.cpp.

                                                 {
    if (name.find("..") == std::string::npos) {
        return false;
    }
    return name.find("../") != std::string::npos ||
           name.find("..\\") != std::string::npos ||
           name == "..";
}

References contains_dotdot_path().

Referenced by contains_dotdot_path(), and main().

find_eocd()

bool anonymous_namespace{archive_worker.cpp}::find_eocd	(	std::ifstream &	f,
		std::uint64_t	file_size,
		std::uint64_t &	eocd_offset )

Definition at line 147 of file archive_worker.cpp.

                                                                                {
    if (file_size < 22) {
        return false;
    }
 
    const std::uint64_t max_comment = 65535;
    const std::uint64_t window = std::min<std::uint64_t>(file_size, 22 + max_comment);
    const std::uint64_t start = file_size - window;
 
    f.seekg(static_cast<std::streamoff>(start), std::ios::beg);
    std::vector<char> buf(static_cast<std::size_t>(window));
    if (!buf.empty()) {
        f.read(buf.data(), static_cast<std::streamsize>(buf.size()));
        if (static_cast<std::size_t>(f.gcount()) != buf.size()) {
            return false;
        }
    }
 
    for (std::int64_t i = static_cast<std::int64_t>(buf.size()) - 4; i >= 0; --i) {
        const unsigned char* p =
            reinterpret_cast<const unsigned char*>(buf.data() + i);
        const uint32_t sig =
            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);
 
        if (sig == SIG_END_OF_CENTRAL_DIR) {
            eocd_offset = start + static_cast<std::uint64_t>(i);
            return true;
        }
    }
 
    return false;
}

References find_eocd(), and SIG_END_OF_CENTRAL_DIR.

Referenced by find_eocd(), and main().

is_absolute_or_weird_path()

bool anonymous_namespace{archive_worker.cpp}::is_absolute_or_weird_path

(

const std::string &

name

)

Definition at line 91 of file archive_worker.cpp.

                                                      {
    if (name.empty()) {
        return false;
    }
    if (name[0] == '/' || name[0] == '\\') {
        return true;
    }
    if (name.size() >= 2 && std::isalpha(static_cast<unsigned char>(name[0])) && name[1] == ':') {
        return true;
    }
    return false;
}

References is_absolute_or_weird_path().

Referenced by is_absolute_or_weird_path(), and main().

looks_like_nested_archive_name()

bool anonymous_namespace{archive_worker.cpp}::looks_like_nested_archive_name

(

const std::string &

name

)

Definition at line 104 of file archive_worker.cpp.

                                                           {
    std::string lower = name;
    std::transform(lower.begin(), lower.end(), lower.begin(),
        [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
 
    return lower.ends_with(".zip") ||
           lower.ends_with(".7z") ||
           lower.ends_with(".rar") ||
           lower.ends_with(".tar") ||
           lower.ends_with(".gz") ||
           lower.ends_with(".tgz") ||
           lower.ends_with(".bz2") ||
           lower.ends_with(".xz");
}

References looks_like_nested_archive_name().

Referenced by looks_like_nested_archive_name(), and main().

parse_zip64_extra()

bool anonymous_namespace{archive_worker.cpp}::parse_zip64_extra	(	const std::vector< unsigned char > &	extra,
		bool	uncomp_is_sentinel,
		bool	comp_is_sentinel,
		bool	offset_is_sentinel,
		std::uint64_t *	out_uncomp,
		std::uint64_t *	out_comp,
		std::uint64_t *	out_offset )

Definition at line 186 of file archive_worker.cpp.

{
    std::size_t i = 0;
    while (i + 4 <= extra.size()) {
        const uint16_t hid = static_cast<uint16_t>(extra[i] | (extra[i + 1] << 8));
        const uint16_t hlen = static_cast<uint16_t>(extra[i + 2] | (extra[i + 3] << 8));
        i += 4;
        if (i + hlen > extra.size()) {
            return false;
        }
        if (hid == 0x0001) {
            std::size_t j = i;
            auto read_u64 = [&](std::uint64_t& dst) {
                if (j + 8 > i + hlen) return false;
                std::uint64_t v = 0;
                for (int k = 0; k < 8; ++k) {
                    v |= static_cast<std::uint64_t>(extra[j + k]) << (8 * k);
                }
                dst = v;
                j += 8;
                return true;
            };
            // Ordine: Uncompressed, Compressed, LocalHeaderOffset, DiskStart.
            // Solo i campi "sentinella" sono presenti.
            if (uncomp_is_sentinel && out_uncomp) {
                if (!read_u64(*out_uncomp)) return true;
            }
            if (comp_is_sentinel && out_comp) {
                if (!read_u64(*out_comp)) return true;
            }
            if (offset_is_sentinel && out_offset) {
                if (!read_u64(*out_offset)) return true;
            }
            return true;
        }
        i += hlen;
    }
    return false;
}

References parse_zip64_extra().

Referenced by main(), parse_zip64_extra(), and read_local_entry().

print_json_bool()

void anonymous_namespace{archive_worker.cpp}::print_json_bool	(	const char *	key,
		bool	value,
		bool	comma = true )

Definition at line 119 of file archive_worker.cpp.

                                                                   {
    std::cout << "\"" << key << "\":" << (value ? "true" : "false");
    if (comma) {
        std::cout << ",";
    }
}

References print_json_bool().

Referenced by main(), and print_json_bool().

print_json_int()

void anonymous_namespace{archive_worker.cpp}::print_json_int	(	const char *	key,
		int	value,
		bool	comma = true )

Definition at line 126 of file archive_worker.cpp.

                                                                 {
    std::cout << "\"" << key << "\":" << value;
    if (comma) {
        std::cout << ",";
    }
}

References print_json_int().

Referenced by main(), and print_json_int().

print_json_str()

void anonymous_namespace{archive_worker.cpp}::print_json_str	(	const char *	key,
		const std::string &	value,
		bool	comma = true )

Definition at line 133 of file archive_worker.cpp.

                                                                              {
    std::cout << "\"" << key << "\":\"";
    for (const char c : value) {
        if (c == '"' || c == '\\') {
            std::cout << '\\';
        }
        std::cout << c;
    }
    std::cout << "\"";
    if (comma) {
        std::cout << ",";
    }
}

References print_json_str().

Referenced by main(), and print_json_str().

read_exact()

bool anonymous_namespace{archive_worker.cpp}::read_exact	(	std::ifstream &	f,
		char *	buf,
		std::size_t	len )

Definition at line 65 of file archive_worker.cpp.

                                                          {
    f.read(buf, static_cast<std::streamsize>(len));
    return static_cast<std::size_t>(f.gcount()) == len;
}

References read_exact().

Referenced by read_exact().

read_local_entry()

bool anonymous_namespace{archive_worker.cpp}::read_local_entry	(	std::ifstream &	f,
		std::uint64_t	file_size,
		std::uint64_t	local_offset,
		uint16_t &	method,
		uint32_t &	compressed_size,
		uint32_t &	uncompressed_size,
		uint16_t &	gp_flags_out,
		std::string &	filename,
		std::uint64_t &	data_offset,
		std::uint64_t &	data_end,
		std::uint64_t &	zip64_comp_size,
		std::uint64_t &	zip64_uncomp_size,
		bool &	has_zip64_extra )

Definition at line 233 of file archive_worker.cpp.

{
    zip64_comp_size = 0;
    zip64_uncomp_size = 0;
    has_zip64_extra = false;
 
    if (local_offset + 30 > file_size) {
        return false;
    }
 
    f.seekg(static_cast<std::streamoff>(local_offset), std::ios::beg);
    const uint32_t sig = read_u32_le(f);
    if (sig != SIG_LOCAL_FILE_HEADER) {
        return false;
    }
 
    (void)read_u16_le(f);      // version needed
    const uint16_t gp_flags = read_u16_le(f);
    gp_flags_out = gp_flags;
    method = read_u16_le(f);
    (void)read_u16_le(f);      // time
    (void)read_u16_le(f);      // date
    (void)read_u32_le(f);      // crc
    compressed_size = read_u32_le(f);
    uncompressed_size = read_u32_le(f);
    const uint16_t name_len = read_u16_le(f);
    const uint16_t extra_len = read_u16_le(f);
 
    filename = read_string(f, name_len);
    if (filename.size() != name_len) {
        return false;
    }
 
    std::vector<unsigned char> extra(extra_len);
    if (extra_len > 0) {
        f.read(reinterpret_cast<char*>(extra.data()), extra_len);
        if (static_cast<std::size_t>(f.gcount()) != extra_len) {
            return false;
        }
    }
 
    // ZIP64: se comp/uncomp size == 0xFFFFFFFF, i valori veri stanno nell'extra field 0x0001.
    const bool comp_is_sentinel = (compressed_size == 0xFFFFFFFFu);
    const bool uncomp_is_sentinel = (uncompressed_size == 0xFFFFFFFFu);
 
    if (comp_is_sentinel || uncomp_is_sentinel) {
        has_zip64_extra = parse_zip64_extra(
            extra,
            uncomp_is_sentinel,
            comp_is_sentinel,
            /*offset_is_sentinel=*/false,
            &zip64_uncomp_size,
            &zip64_comp_size,
            nullptr);
    }
 
    data_offset = local_offset + 30ULL + name_len + extra_len;
 
    // Dimensione affidabile per controllare se i dati escono dal file:
    //  - ZIP64 con extra valido  → usa zip64_comp_size
    //  - data descriptor (bit 3) → non nota qui: usa 0 (bypassa il check di overflow)
    //  - altrimenti              → compressed_size
    const bool has_data_descriptor = (gp_flags & 0x08) != 0;
    std::uint64_t effective_comp = compressed_size;
    if (comp_is_sentinel && has_zip64_extra) {
        effective_comp = zip64_comp_size;
    } else if (has_data_descriptor && compressed_size == 0) {
        // Dati con data descriptor: la dimensione vera sta dopo i dati, skippiamo il check.
        effective_comp = 0;
    }
 
    data_end = data_offset + effective_comp;
    if (data_offset > file_size || data_end > file_size) {
        return false;
    }
 
    return true;
}

References parse_zip64_extra(), read_local_entry(), read_string(), read_u16_le(), read_u32_le(), and SIG_LOCAL_FILE_HEADER.

Referenced by main(), and read_local_entry().

read_string()

std::string anonymous_namespace{archive_worker.cpp}::read_string	(	std::ifstream &	f,
		std::size_t	len )

Definition at line 70 of file archive_worker.cpp.

                                                     {
    std::string s(len, '\0');
    if (!len) {
        return s;
    }
    f.read(&s[0], static_cast<std::streamsize>(len));
    if (static_cast<std::size_t>(f.gcount()) != len) {
        return {};
    }
    return s;
}

References read_string().

Referenced by main(), read_local_entry(), and read_string().

read_u16_le()

uint16_t anonymous_namespace{archive_worker.cpp}::read_u16_le

(

std::ifstream &

f

)

Definition at line 48 of file archive_worker.cpp.

                                     {
    unsigned char b[2] = {0, 0};
    f.read(reinterpret_cast<char*>(b), 2);
    return static_cast<uint16_t>(b[0] | (b[1] << 8));
}

References read_u16_le().

Referenced by main(), read_local_entry(), and read_u16_le().

read_u32_le()

uint32_t anonymous_namespace{archive_worker.cpp}::read_u32_le

(

std::ifstream &

f

)

Definition at line 54 of file archive_worker.cpp.

                                     {
    unsigned char b[4] = {0, 0, 0, 0};
    f.read(reinterpret_cast<char*>(b), 4);
    return static_cast<uint32_t>(
        static_cast<uint32_t>(b[0]) |
        (static_cast<uint32_t>(b[1]) << 8) |
        (static_cast<uint32_t>(b[2]) << 16) |
        (static_cast<uint32_t>(b[3]) << 24)
    );
}

References read_u32_le().

Referenced by main(), read_local_entry(), and read_u32_le().

Variable Documentation

SIG_CENTRAL_DIR_HEADER

uint32_t anonymous_namespace{archive_worker.cpp}::SIG_CENTRAL_DIR_HEADER = 0x02014b50

constexpr

Definition at line 45 of file archive_worker.cpp.

Referenced by main().

SIG_END_OF_CENTRAL_DIR

uint32_t anonymous_namespace{archive_worker.cpp}::SIG_END_OF_CENTRAL_DIR = 0x06054b50

constexpr

Definition at line 46 of file archive_worker.cpp.

Referenced by find_eocd(), and main().

SIG_LOCAL_FILE_HEADER

uint32_t anonymous_namespace{archive_worker.cpp}::SIG_LOCAL_FILE_HEADER = 0x04034b50

constexpr

Definition at line 44 of file archive_worker.cpp.

Referenced by main(), and read_local_entry().