// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause)/* * Routines for dealing with .zip archives. * * Copyright (c) Meta Platforms, Inc. and affiliates. */ #include <errno.h>#include <fcntl.h>#include <stdint.h>#include <stdlib.h>#include <string.h>#include <sys/mman.h>#include <unistd.h> #include "libbpf_internal.h"#include "zip.h" #pragma GCC diagnostic push#pragma GCC diagnostic ignored "-Wpacked"#pragma GCC diagnostic ignored "-Wattributes" /* Specification of ZIP file format can be found here: * https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT * For a high level overview of the structure of a ZIP file see * sections 4.3.1 - 4.3.6. * * Data structures appearing in ZIP files do not contain any * padding and they might be misaligned. To allow us to safely * operate on pointers to such structures and their members, we * declare the types as packed. */ #define END_OF_CD_RECORD_MAGIC 0x06054b50 /* See section 4.3.16 of the spec. */struct end_of_cd_record {	/* Magic value equal to END_OF_CD_RECORD_MAGIC */	__u32 magic; 	/* Number of the file containing this structure or 0xFFFF if ZIP64 archive.	 * Zip archive might span multiple files (disks).	 */	__u16 this_disk; 	/* Number of the file containing the beginning of the central directory or	 * 0xFFFF if ZIP64 archive.	 */	__u16 cd_disk; 	/* Number of central directory records on this disk or 0xFFFF if ZIP64	 * archive.	 */	__u16 cd_records; 	/* Number of central directory records on all disks or 0xFFFF if ZIP64	 * archive.	 */	__u16 cd_records_total; 	/* Size of the central directory record or 0xFFFFFFFF if ZIP64 archive. */	__u32 cd_size; 	/* Offset of the central directory from the beginning of the archive or	 * 0xFFFFFFFF if ZIP64 archive.	 */	__u32 cd_offset; 	/* Length of comment data following end of central directory record. */	__u16 comment_length; 	/* Up to 64k of arbitrary bytes. */	/* uint8_t comment[comment_length] */} __attribute__((packed)); #define CD_FILE_HEADER_MAGIC 0x02014b50#define FLAG_ENCRYPTED (1 << 0)#define FLAG_HAS_DATA_DESCRIPTOR (1 << 3) /* See section 4.3.12 of the spec. */struct cd_file_header {	/* Magic value equal to CD_FILE_HEADER_MAGIC. */	__u32 magic;	__u16 version;	/* Minimum zip version needed to extract the file. */	__u16 min_version;	__u16 flags;	__u16 compression;	__u16 last_modified_time;	__u16 last_modified_date;	__u32 crc;	__u32 compressed_size;	__u32 uncompressed_size;	__u16 file_name_length;	__u16 extra_field_length;	__u16 file_comment_length;	/* Number of the disk where the file starts or 0xFFFF if ZIP64 archive. */	__u16 disk;	__u16 internal_attributes;	__u32 external_attributes;	/* Offset from the start of the disk containing the local file header to the	 * start of the local file header.	 */	__u32 offset;} __attribute__((packed)); #define LOCAL_FILE_HEADER_MAGIC 0x04034b50 /* See section 4.3.7 of the spec. */struct local_file_header {	/* Magic value equal to LOCAL_FILE_HEADER_MAGIC. */	__u32 magic;	/* Minimum zip version needed to extract the file. */	__u16 min_version;	__u16 flags;	__u16 compression;	__u16 last_modified_time;	__u16 last_modified_date;	__u32 crc;	__u32 compressed_size;	__u32 uncompressed_size;	__u16 file_name_length;	__u16 extra_field_length;} __attribute__((packed)); #pragma GCC diagnostic pop struct zip_archive {	void *data;	__u32 size;	__u32 cd_offset;	__u32 cd_records;}; static void *check_access(struct zip_archive *archive, __u32 offset, __u32 size){	if (offset + size > archive->size || offset > offset + size)		return NULL; 	return archive->data + offset;} /* Returns 0 on success, -EINVAL on error and -ENOTSUP if the eocd indicates the * archive uses features which are not supported. */static int try_parse_end_of_cd(struct zip_archive *archive, __u32 offset){	__u16 comment_length, cd_records;	struct end_of_cd_record *eocd;	__u32 cd_offset, cd_size; 	eocd = check_access(archive, offset, sizeof(*eocd));	if (!eocd || eocd->magic != END_OF_CD_RECORD_MAGIC)		return -EINVAL; 	comment_length = eocd->comment_length;	if (offset + sizeof(*eocd) + comment_length != archive->size)		return -EINVAL; 	cd_records = eocd->cd_records;	if (eocd->this_disk != 0 || eocd->cd_disk != 0 || eocd->cd_records_total != cd_records)		/* This is a valid eocd, but we only support single-file non-ZIP64 archives. */		return -ENOTSUP; 	cd_offset = eocd->cd_offset;	cd_size = eocd->cd_size;	if (!check_access(archive, cd_offset, cd_size))		return -EINVAL; 	archive->cd_offset = cd_offset;	archive->cd_records = cd_records;	return 0;} static int find_cd(struct zip_archive *archive){	int64_t limit, offset;	int rc = -EINVAL; 	if (archive->size <= sizeof(struct end_of_cd_record))		return -EINVAL; 	/* Because the end of central directory ends with a variable length array of	 * up to 0xFFFF bytes we can't know exactly where it starts and need to	 * search for it at the end of the file, scanning the (limit, offset] range.	 */	offset = archive->size - sizeof(struct end_of_cd_record);	limit = (int64_t)offset - (1 << 16); 	for (; offset >= 0 && offset > limit && rc != 0; offset--) {		rc = try_parse_end_of_cd(archive, offset);		if (rc == -ENOTSUP)			break;	}	return rc;} struct zip_archive *zip_archive_open(const char *path){	struct zip_archive *archive;	int err, fd;	off_t size;	void *data; 	fd = open(path, O_RDONLY | O_CLOEXEC);	if (fd < 0)		return ERR_PTR(-errno); 	size = lseek(fd, 0, SEEK_END);	if (size == (off_t)-1 || size > UINT32_MAX) {		close(fd);		return ERR_PTR(-EINVAL);	} 	data = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);	err = -errno;	close(fd); 	if (data == MAP_FAILED)		return ERR_PTR(err); 	archive = malloc(sizeof(*archive));	if (!archive) {		munmap(data, size);		return ERR_PTR(-ENOMEM);	} 	archive->data = data;	archive->size = size; 	err = find_cd(archive);	if (err) {		munmap(data, size);		free(archive);		return ERR_PTR(err);	} 	return archive;} void zip_archive_close(struct zip_archive *archive){	munmap(archive->data, archive->size);	free(archive);} static struct local_file_header *local_file_header_at_offset(struct zip_archive *archive,							     __u32 offset){	struct local_file_header *lfh; 	lfh = check_access(archive, offset, sizeof(*lfh));	if (!lfh || lfh->magic != LOCAL_FILE_HEADER_MAGIC)		return NULL; 	return lfh;} static int get_entry_at_offset(struct zip_archive *archive, __u32 offset, struct zip_entry *out){	struct local_file_header *lfh;	__u32 compressed_size;	const char *name;	void *data; 	lfh = local_file_header_at_offset(archive, offset);	if (!lfh)		return -EINVAL; 	offset += sizeof(*lfh);	if ((lfh->flags & FLAG_ENCRYPTED) || (lfh->flags & FLAG_HAS_DATA_DESCRIPTOR))		return -EINVAL; 	name = check_access(archive, offset, lfh->file_name_length);	if (!name)		return -EINVAL; 	offset += lfh->file_name_length;	if (!check_access(archive, offset, lfh->extra_field_length))		return -EINVAL; 	offset += lfh->extra_field_length;	compressed_size = lfh->compressed_size;	data = check_access(archive, offset, compressed_size);	if (!data)		return -EINVAL; 	out->compression = lfh->compression;	out->name_length = lfh->file_name_length;	out->name = name;	out->data = data;	out->data_length = compressed_size;	out->data_offset = offset; 	return 0;} int zip_archive_find_entry(struct zip_archive *archive, const char *file_name,			   struct zip_entry *out){	size_t file_name_length = strlen(file_name);	__u32 i, offset = archive->cd_offset; 	for (i = 0; i < archive->cd_records; ++i) {		__u16 cdfh_name_length, cdfh_flags;		struct cd_file_header *cdfh;		const char *cdfh_name; 		cdfh = check_access(archive, offset, sizeof(*cdfh));		if (!cdfh || cdfh->magic != CD_FILE_HEADER_MAGIC)			return -EINVAL; 		offset += sizeof(*cdfh);		cdfh_name_length = cdfh->file_name_length;		cdfh_name = check_access(archive, offset, cdfh_name_length);		if (!cdfh_name)			return -EINVAL; 		cdfh_flags = cdfh->flags;		if ((cdfh_flags & FLAG_ENCRYPTED) == 0 &&		    (cdfh_flags & FLAG_HAS_DATA_DESCRIPTOR) == 0 &&		    file_name_length == cdfh_name_length &&		    memcmp(file_name, archive->data + offset, file_name_length) == 0) {			return get_entry_at_offset(archive, cdfh->offset, out);		} 		offset += cdfh_name_length;		offset += cdfh->extra_field_length;		offset += cdfh->file_comment_length;	} 	return -ENOENT;}