1caf54c4fSMartin Matuska /*-
2caf54c4fSMartin Matuska * Copyright (c) 2008 Anselm Strauss
3caf54c4fSMartin Matuska * Copyright (c) 2009 Joerg Sonnenberger
4cdf63a70SMartin Matuska * Copyright (c) 2011-2012,2014 Michihiro NAKAJIMA
5caf54c4fSMartin Matuska * All rights reserved.
6caf54c4fSMartin Matuska *
7caf54c4fSMartin Matuska * Redistribution and use in source and binary forms, with or without
8caf54c4fSMartin Matuska * modification, are permitted provided that the following conditions
9caf54c4fSMartin Matuska * are met:
10caf54c4fSMartin Matuska * 1. Redistributions of source code must retain the above copyright
11caf54c4fSMartin Matuska * notice, this list of conditions and the following disclaimer.
12caf54c4fSMartin Matuska * 2. Redistributions in binary form must reproduce the above copyright
13caf54c4fSMartin Matuska * notice, this list of conditions and the following disclaimer in the
14caf54c4fSMartin Matuska * documentation and/or other materials provided with the distribution.
15caf54c4fSMartin Matuska *
16caf54c4fSMartin Matuska * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
17caf54c4fSMartin Matuska * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18caf54c4fSMartin Matuska * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19caf54c4fSMartin Matuska * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
20caf54c4fSMartin Matuska * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21caf54c4fSMartin Matuska * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22caf54c4fSMartin Matuska * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23caf54c4fSMartin Matuska * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24caf54c4fSMartin Matuska * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25caf54c4fSMartin Matuska * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26caf54c4fSMartin Matuska */
27caf54c4fSMartin Matuska
28caf54c4fSMartin Matuska /*
29caf54c4fSMartin Matuska * Development supported by Google Summer of Code 2008.
30caf54c4fSMartin Matuska */
31caf54c4fSMartin Matuska
32caf54c4fSMartin Matuska #include "archive_platform.h"
33caf54c4fSMartin Matuska
34caf54c4fSMartin Matuska #ifdef HAVE_ERRNO_H
35caf54c4fSMartin Matuska #include <errno.h>
36caf54c4fSMartin Matuska #endif
376c95142eSMartin Matuska #ifdef HAVE_LANGINFO_H
386c95142eSMartin Matuska #include <langinfo.h>
396c95142eSMartin Matuska #endif
40caf54c4fSMartin Matuska #ifdef HAVE_STDLIB_H
41caf54c4fSMartin Matuska #include <stdlib.h>
42caf54c4fSMartin Matuska #endif
43caf54c4fSMartin Matuska #ifdef HAVE_STRING_H
44caf54c4fSMartin Matuska #include <string.h>
45caf54c4fSMartin Matuska #endif
46caf54c4fSMartin Matuska #ifdef HAVE_ZLIB_H
47caf54c4fSMartin Matuska #include <zlib.h>
48caf54c4fSMartin Matuska #endif
49caf54c4fSMartin Matuska
50caf54c4fSMartin Matuska #include "archive.h"
51cdf63a70SMartin Matuska #include "archive_cryptor_private.h"
52caf54c4fSMartin Matuska #include "archive_endian.h"
53caf54c4fSMartin Matuska #include "archive_entry.h"
546c95142eSMartin Matuska #include "archive_entry_locale.h"
55cdf63a70SMartin Matuska #include "archive_hmac_private.h"
56caf54c4fSMartin Matuska #include "archive_private.h"
57cdf63a70SMartin Matuska #include "archive_random_private.h"
58caf54c4fSMartin Matuska #include "archive_write_private.h"
59f9762417SMartin Matuska #include "archive_write_set_format_private.h"
60caf54c4fSMartin Matuska
61caf54c4fSMartin Matuska #ifndef HAVE_ZLIB_H
62caf54c4fSMartin Matuska #include "archive_crc32.h"
63caf54c4fSMartin Matuska #endif
64caf54c4fSMartin Matuska
65cdf63a70SMartin Matuska #define ZIP_ENTRY_FLAG_ENCRYPTED (1<<0)
66cdf63a70SMartin Matuska #define ZIP_ENTRY_FLAG_LENGTH_AT_END (1<<3)
67cdf63a70SMartin Matuska #define ZIP_ENTRY_FLAG_UTF8_NAME (1 << 11)
68cdf63a70SMartin Matuska
69cdf63a70SMartin Matuska #define ZIP_4GB_MAX ARCHIVE_LITERAL_LL(0xffffffff)
70cdf63a70SMartin Matuska #define ZIP_4GB_MAX_UNCOMPRESSED ARCHIVE_LITERAL_LL(0xff000000)
71caf54c4fSMartin Matuska
72caf54c4fSMartin Matuska enum compression {
73cdf63a70SMartin Matuska COMPRESSION_UNSPECIFIED = -1,
74cdf63a70SMartin Matuska COMPRESSION_STORE = 0,
75caf54c4fSMartin Matuska COMPRESSION_DEFLATE = 8
76caf54c4fSMartin Matuska };
77caf54c4fSMartin Matuska
78cdf63a70SMartin Matuska #ifdef HAVE_ZLIB_H
79cdf63a70SMartin Matuska #define COMPRESSION_DEFAULT COMPRESSION_DEFLATE
80cdf63a70SMartin Matuska #else
81cdf63a70SMartin Matuska #define COMPRESSION_DEFAULT COMPRESSION_STORE
82cdf63a70SMartin Matuska #endif
83cdf63a70SMartin Matuska
84cdf63a70SMartin Matuska enum encryption {
85cdf63a70SMartin Matuska ENCRYPTION_NONE = 0,
86cdf63a70SMartin Matuska ENCRYPTION_TRADITIONAL, /* Traditional PKWARE encryption. */
87cdf63a70SMartin Matuska ENCRYPTION_WINZIP_AES128, /* WinZIP AES-128 encryption. */
88cdf63a70SMartin Matuska ENCRYPTION_WINZIP_AES256, /* WinZIP AES-256 encryption. */
89cdf63a70SMartin Matuska };
90cdf63a70SMartin Matuska
91cdf63a70SMartin Matuska #define TRAD_HEADER_SIZE 12
92cdf63a70SMartin Matuska /*
93cdf63a70SMartin Matuska * See "WinZip - AES Encryption Information"
94cdf63a70SMartin Matuska * http://www.winzip.com/aes_info.htm
95cdf63a70SMartin Matuska */
96cdf63a70SMartin Matuska /* Value used in compression method. */
97cdf63a70SMartin Matuska #define WINZIP_AES_ENCRYPTION 99
98cdf63a70SMartin Matuska /* A WinZip AES header size which is stored at the beginning of
99cdf63a70SMartin Matuska * file contents. */
100cdf63a70SMartin Matuska #define WINZIP_AES128_HEADER_SIZE (8 + 2)
101cdf63a70SMartin Matuska #define WINZIP_AES256_HEADER_SIZE (16 + 2)
102cdf63a70SMartin Matuska /* AES vendor version. */
103cdf63a70SMartin Matuska #define AES_VENDOR_AE_1 0x0001
104cdf63a70SMartin Matuska #define AES_VENDOR_AE_2 0x0002
105cdf63a70SMartin Matuska /* Authentication code size. */
106cdf63a70SMartin Matuska #define AUTH_CODE_SIZE 10
107cdf63a70SMartin Matuska /**/
108cdf63a70SMartin Matuska #define MAX_DERIVED_KEY_BUF_SIZE (AES_MAX_KEY_SIZE * 2 + 2)
109cdf63a70SMartin Matuska
110cdf63a70SMartin Matuska struct cd_segment {
111cdf63a70SMartin Matuska struct cd_segment *next;
112cdf63a70SMartin Matuska size_t buff_size;
113cdf63a70SMartin Matuska unsigned char *buff;
114cdf63a70SMartin Matuska unsigned char *p;
115cdf63a70SMartin Matuska };
116cdf63a70SMartin Matuska
117cdf63a70SMartin Matuska struct trad_enc_ctx {
118cdf63a70SMartin Matuska uint32_t keys[3];
119cdf63a70SMartin Matuska };
120cdf63a70SMartin Matuska
121cdf63a70SMartin Matuska struct zip {
122cdf63a70SMartin Matuska
123cdf63a70SMartin Matuska int64_t entry_offset;
124cdf63a70SMartin Matuska int64_t entry_compressed_size;
125cdf63a70SMartin Matuska int64_t entry_uncompressed_size;
126cdf63a70SMartin Matuska int64_t entry_compressed_written;
127cdf63a70SMartin Matuska int64_t entry_uncompressed_written;
128cdf63a70SMartin Matuska int64_t entry_uncompressed_limit;
129cdf63a70SMartin Matuska struct archive_entry *entry;
130cdf63a70SMartin Matuska uint32_t entry_crc32;
131cdf63a70SMartin Matuska enum compression entry_compression;
132cdf63a70SMartin Matuska enum encryption entry_encryption;
133cdf63a70SMartin Matuska int entry_flags;
134cdf63a70SMartin Matuska int experiments;
135cdf63a70SMartin Matuska struct trad_enc_ctx tctx;
136cdf63a70SMartin Matuska char tctx_valid;
137cdf63a70SMartin Matuska unsigned char trad_chkdat;
138cdf63a70SMartin Matuska unsigned aes_vendor;
139cdf63a70SMartin Matuska archive_crypto_ctx cctx;
140cdf63a70SMartin Matuska char cctx_valid;
141cdf63a70SMartin Matuska archive_hmac_sha1_ctx hctx;
142cdf63a70SMartin Matuska char hctx_valid;
143cdf63a70SMartin Matuska
144cdf63a70SMartin Matuska unsigned char *file_header;
145cdf63a70SMartin Matuska size_t file_header_extra_offset;
146cdf63a70SMartin Matuska unsigned long (*crc32func)(unsigned long crc, const void *buff, size_t len);
147cdf63a70SMartin Matuska
148cdf63a70SMartin Matuska struct cd_segment *central_directory;
149cdf63a70SMartin Matuska struct cd_segment *central_directory_last;
150cdf63a70SMartin Matuska size_t central_directory_bytes;
151cdf63a70SMartin Matuska size_t central_directory_entries;
152cdf63a70SMartin Matuska
153cdf63a70SMartin Matuska int64_t written_bytes; /* Overall position in file. */
154cdf63a70SMartin Matuska
155cdf63a70SMartin Matuska struct archive_string_conv *opt_sconv;
156cdf63a70SMartin Matuska struct archive_string_conv *sconv_default;
157cdf63a70SMartin Matuska enum compression requested_compression;
158cdf63a70SMartin Matuska int deflate_compression_level;
159cdf63a70SMartin Matuska int init_default_conversion;
160cdf63a70SMartin Matuska enum encryption encryption_type;
161cdf63a70SMartin Matuska
162cdf63a70SMartin Matuska #define ZIP_FLAG_AVOID_ZIP64 1
163cdf63a70SMartin Matuska #define ZIP_FLAG_FORCE_ZIP64 2
164cdf63a70SMartin Matuska #define ZIP_FLAG_EXPERIMENT_xl 4
165cdf63a70SMartin Matuska int flags;
166cdf63a70SMartin Matuska
167cdf63a70SMartin Matuska #ifdef HAVE_ZLIB_H
168cdf63a70SMartin Matuska z_stream stream;
169cdf63a70SMartin Matuska #endif
170cdf63a70SMartin Matuska size_t len_buf;
171cdf63a70SMartin Matuska unsigned char *buf;
172cdf63a70SMartin Matuska };
173cdf63a70SMartin Matuska
174cdf63a70SMartin Matuska /* Don't call this min or MIN, since those are already defined
175cdf63a70SMartin Matuska on lots of platforms (but not all). */
176cdf63a70SMartin Matuska #define zipmin(a, b) ((a) > (b) ? (b) : (a))
177cdf63a70SMartin Matuska
1786c95142eSMartin Matuska static ssize_t archive_write_zip_data(struct archive_write *,
1796c95142eSMartin Matuska const void *buff, size_t s);
1806c95142eSMartin Matuska static int archive_write_zip_close(struct archive_write *);
1816c95142eSMartin Matuska static int archive_write_zip_free(struct archive_write *);
182caf54c4fSMartin Matuska static int archive_write_zip_finish_entry(struct archive_write *);
1836c95142eSMartin Matuska static int archive_write_zip_header(struct archive_write *,
1846c95142eSMartin Matuska struct archive_entry *);
1856c95142eSMartin Matuska static int archive_write_zip_options(struct archive_write *,
1866c95142eSMartin Matuska const char *, const char *);
187caf54c4fSMartin Matuska static unsigned int dos_time(const time_t);
188caf54c4fSMartin Matuska static size_t path_length(struct archive_entry *);
189caf54c4fSMartin Matuska static int write_path(struct archive_entry *, struct archive_write *);
190cdf63a70SMartin Matuska static void copy_path(struct archive_entry *, unsigned char *);
191cdf63a70SMartin Matuska static struct archive_string_conv *get_sconv(struct archive_write *, struct zip *);
192cdf63a70SMartin Matuska static int trad_enc_init(struct trad_enc_ctx *, const char *, size_t);
193cdf63a70SMartin Matuska static unsigned trad_enc_encrypt_update(struct trad_enc_ctx *, const uint8_t *,
194cdf63a70SMartin Matuska size_t, uint8_t *, size_t);
195cdf63a70SMartin Matuska static int init_traditional_pkware_encryption(struct archive_write *);
196cdf63a70SMartin Matuska static int is_traditional_pkware_encryption_supported(void);
197cdf63a70SMartin Matuska static int init_winzip_aes_encryption(struct archive_write *);
198cdf63a70SMartin Matuska static int is_winzip_aes_encryption_supported(int encryption);
199caf54c4fSMartin Matuska
200cdf63a70SMartin Matuska static unsigned char *
cd_alloc(struct zip * zip,size_t length)201cdf63a70SMartin Matuska cd_alloc(struct zip *zip, size_t length)
202cdf63a70SMartin Matuska {
203cdf63a70SMartin Matuska unsigned char *p;
204caf54c4fSMartin Matuska
205cdf63a70SMartin Matuska if (zip->central_directory == NULL
206cdf63a70SMartin Matuska || (zip->central_directory_last->p + length
207cdf63a70SMartin Matuska > zip->central_directory_last->buff + zip->central_directory_last->buff_size)) {
208cdf63a70SMartin Matuska struct cd_segment *segment = calloc(1, sizeof(*segment));
209cdf63a70SMartin Matuska if (segment == NULL)
210cdf63a70SMartin Matuska return NULL;
211cdf63a70SMartin Matuska segment->buff_size = 64 * 1024;
212cdf63a70SMartin Matuska segment->buff = malloc(segment->buff_size);
213cdf63a70SMartin Matuska if (segment->buff == NULL) {
214cdf63a70SMartin Matuska free(segment);
215cdf63a70SMartin Matuska return NULL;
216cdf63a70SMartin Matuska }
217cdf63a70SMartin Matuska segment->p = segment->buff;
218caf54c4fSMartin Matuska
219cdf63a70SMartin Matuska if (zip->central_directory == NULL) {
220cdf63a70SMartin Matuska zip->central_directory
221cdf63a70SMartin Matuska = zip->central_directory_last
222cdf63a70SMartin Matuska = segment;
223cdf63a70SMartin Matuska } else {
224cdf63a70SMartin Matuska zip->central_directory_last->next = segment;
225cdf63a70SMartin Matuska zip->central_directory_last = segment;
226cdf63a70SMartin Matuska }
227cdf63a70SMartin Matuska }
228caf54c4fSMartin Matuska
229cdf63a70SMartin Matuska p = zip->central_directory_last->p;
230cdf63a70SMartin Matuska zip->central_directory_last->p += length;
231cdf63a70SMartin Matuska zip->central_directory_bytes += length;
232cdf63a70SMartin Matuska return (p);
233cdf63a70SMartin Matuska }
234caf54c4fSMartin Matuska
235cdf63a70SMartin Matuska static unsigned long
real_crc32(unsigned long crc,const void * buff,size_t len)236cdf63a70SMartin Matuska real_crc32(unsigned long crc, const void *buff, size_t len)
237cdf63a70SMartin Matuska {
238cdf63a70SMartin Matuska return crc32(crc, buff, (unsigned int)len);
239cdf63a70SMartin Matuska }
240fd082e96SMartin Matuska
241cdf63a70SMartin Matuska static unsigned long
fake_crc32(unsigned long crc,const void * buff,size_t len)242cdf63a70SMartin Matuska fake_crc32(unsigned long crc, const void *buff, size_t len)
243cdf63a70SMartin Matuska {
244cdf63a70SMartin Matuska (void)crc; /* UNUSED */
245cdf63a70SMartin Matuska (void)buff; /* UNUSED */
246cdf63a70SMartin Matuska (void)len; /* UNUSED */
247cdf63a70SMartin Matuska return 0;
248cdf63a70SMartin Matuska }
249caf54c4fSMartin Matuska
250caf54c4fSMartin Matuska static int
archive_write_zip_options(struct archive_write * a,const char * key,const char * val)251caf54c4fSMartin Matuska archive_write_zip_options(struct archive_write *a, const char *key,
2526c95142eSMartin Matuska const char *val)
253caf54c4fSMartin Matuska {
254caf54c4fSMartin Matuska struct zip *zip = a->format_data;
2556c95142eSMartin Matuska int ret = ARCHIVE_FAILED;
256caf54c4fSMartin Matuska
257caf54c4fSMartin Matuska if (strcmp(key, "compression") == 0) {
258cdf63a70SMartin Matuska /*
259cdf63a70SMartin Matuska * Set compression to use on all future entries.
260cdf63a70SMartin Matuska * This only affects regular files.
261cdf63a70SMartin Matuska */
2626c95142eSMartin Matuska if (val == NULL || val[0] == 0) {
2636c95142eSMartin Matuska archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
2646c95142eSMartin Matuska "%s: compression option needs a compression name",
2656c95142eSMartin Matuska a->format_name);
2666c95142eSMartin Matuska } else if (strcmp(val, "deflate") == 0) {
267caf54c4fSMartin Matuska #ifdef HAVE_ZLIB_H
268cdf63a70SMartin Matuska zip->requested_compression = COMPRESSION_DEFLATE;
2696c95142eSMartin Matuska ret = ARCHIVE_OK;
270caf54c4fSMartin Matuska #else
271caf54c4fSMartin Matuska archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
272caf54c4fSMartin Matuska "deflate compression not supported");
273caf54c4fSMartin Matuska #endif
2746c95142eSMartin Matuska } else if (strcmp(val, "store") == 0) {
275cdf63a70SMartin Matuska zip->requested_compression = COMPRESSION_STORE;
2766c95142eSMartin Matuska ret = ARCHIVE_OK;
277caf54c4fSMartin Matuska }
2786c95142eSMartin Matuska return (ret);
279cdf63a70SMartin Matuska } else if (strcmp(key, "compression-level") == 0) {
280cdf63a70SMartin Matuska if (val == NULL || !(val[0] >= '0' && val[0] <= '9') || val[1] != '\0') {
281cdf63a70SMartin Matuska return ARCHIVE_WARN;
282cdf63a70SMartin Matuska }
283cdf63a70SMartin Matuska
284cdf63a70SMartin Matuska if (val[0] == '0') {
285cdf63a70SMartin Matuska zip->requested_compression = COMPRESSION_STORE;
286cdf63a70SMartin Matuska return ARCHIVE_OK;
287cdf63a70SMartin Matuska } else {
288cdf63a70SMartin Matuska #ifdef HAVE_ZLIB_H
289cdf63a70SMartin Matuska zip->requested_compression = COMPRESSION_DEFLATE;
290cdf63a70SMartin Matuska zip->deflate_compression_level = val[0] - '0';
291cdf63a70SMartin Matuska return ARCHIVE_OK;
292cdf63a70SMartin Matuska #else
293cdf63a70SMartin Matuska archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
294cdf63a70SMartin Matuska "deflate compression not supported");
295cdf63a70SMartin Matuska #endif
296cdf63a70SMartin Matuska }
297cdf63a70SMartin Matuska } else if (strcmp(key, "encryption") == 0) {
298cdf63a70SMartin Matuska if (val == NULL) {
299cdf63a70SMartin Matuska zip->encryption_type = ENCRYPTION_NONE;
300cdf63a70SMartin Matuska ret = ARCHIVE_OK;
301cdf63a70SMartin Matuska } else if (val[0] == '1' || strcmp(val, "traditional") == 0
302cdf63a70SMartin Matuska || strcmp(val, "zipcrypt") == 0
303cdf63a70SMartin Matuska || strcmp(val, "ZipCrypt") == 0) {
304cdf63a70SMartin Matuska if (is_traditional_pkware_encryption_supported()) {
305cdf63a70SMartin Matuska zip->encryption_type = ENCRYPTION_TRADITIONAL;
306cdf63a70SMartin Matuska ret = ARCHIVE_OK;
307cdf63a70SMartin Matuska } else {
308cdf63a70SMartin Matuska archive_set_error(&a->archive,
309cdf63a70SMartin Matuska ARCHIVE_ERRNO_MISC,
310cdf63a70SMartin Matuska "encryption not supported");
311cdf63a70SMartin Matuska }
312cdf63a70SMartin Matuska } else if (strcmp(val, "aes128") == 0) {
313cdf63a70SMartin Matuska if (is_winzip_aes_encryption_supported(
314cdf63a70SMartin Matuska ENCRYPTION_WINZIP_AES128)) {
315cdf63a70SMartin Matuska zip->encryption_type = ENCRYPTION_WINZIP_AES128;
316cdf63a70SMartin Matuska ret = ARCHIVE_OK;
317cdf63a70SMartin Matuska } else {
318cdf63a70SMartin Matuska archive_set_error(&a->archive,
319cdf63a70SMartin Matuska ARCHIVE_ERRNO_MISC,
320cdf63a70SMartin Matuska "encryption not supported");
321cdf63a70SMartin Matuska }
322cdf63a70SMartin Matuska } else if (strcmp(val, "aes256") == 0) {
323cdf63a70SMartin Matuska if (is_winzip_aes_encryption_supported(
324cdf63a70SMartin Matuska ENCRYPTION_WINZIP_AES256)) {
325cdf63a70SMartin Matuska zip->encryption_type = ENCRYPTION_WINZIP_AES256;
326cdf63a70SMartin Matuska ret = ARCHIVE_OK;
327cdf63a70SMartin Matuska } else {
328cdf63a70SMartin Matuska archive_set_error(&a->archive,
329cdf63a70SMartin Matuska ARCHIVE_ERRNO_MISC,
330cdf63a70SMartin Matuska "encryption not supported");
331cdf63a70SMartin Matuska }
332cdf63a70SMartin Matuska } else {
333cdf63a70SMartin Matuska archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
334cdf63a70SMartin Matuska "%s: unknown encryption '%s'",
335cdf63a70SMartin Matuska a->format_name, val);
336cdf63a70SMartin Matuska }
337cdf63a70SMartin Matuska return (ret);
338cdf63a70SMartin Matuska } else if (strcmp(key, "experimental") == 0) {
339cdf63a70SMartin Matuska if (val == NULL || val[0] == 0) {
340cdf63a70SMartin Matuska zip->flags &= ~ ZIP_FLAG_EXPERIMENT_xl;
341cdf63a70SMartin Matuska } else {
342cdf63a70SMartin Matuska zip->flags |= ZIP_FLAG_EXPERIMENT_xl;
343cdf63a70SMartin Matuska }
344cdf63a70SMartin Matuska return (ARCHIVE_OK);
345cdf63a70SMartin Matuska } else if (strcmp(key, "fakecrc32") == 0) {
346cdf63a70SMartin Matuska /*
347cdf63a70SMartin Matuska * FOR TESTING ONLY: disable CRC calculation to speed up
348cdf63a70SMartin Matuska * certain complex tests.
349cdf63a70SMartin Matuska */
350cdf63a70SMartin Matuska if (val == NULL || val[0] == 0) {
351cdf63a70SMartin Matuska zip->crc32func = real_crc32;
352cdf63a70SMartin Matuska } else {
353cdf63a70SMartin Matuska zip->crc32func = fake_crc32;
354cdf63a70SMartin Matuska }
355cdf63a70SMartin Matuska return (ARCHIVE_OK);
3566c95142eSMartin Matuska } else if (strcmp(key, "hdrcharset") == 0) {
357cdf63a70SMartin Matuska /*
358cdf63a70SMartin Matuska * Set the character set used in translating filenames.
359cdf63a70SMartin Matuska */
3606c95142eSMartin Matuska if (val == NULL || val[0] == 0) {
3616c95142eSMartin Matuska archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
3626c95142eSMartin Matuska "%s: hdrcharset option needs a character-set name",
3636c95142eSMartin Matuska a->format_name);
3646c95142eSMartin Matuska } else {
3656c95142eSMartin Matuska zip->opt_sconv = archive_string_conversion_to_charset(
3666c95142eSMartin Matuska &a->archive, val, 0);
3676c95142eSMartin Matuska if (zip->opt_sconv != NULL)
3686c95142eSMartin Matuska ret = ARCHIVE_OK;
3696c95142eSMartin Matuska else
3706c95142eSMartin Matuska ret = ARCHIVE_FATAL;
3716c95142eSMartin Matuska }
3726c95142eSMartin Matuska return (ret);
373cdf63a70SMartin Matuska } else if (strcmp(key, "zip64") == 0) {
374cdf63a70SMartin Matuska /*
375cdf63a70SMartin Matuska * Bias decisions about Zip64: force them to be
376cdf63a70SMartin Matuska * generated in certain cases where they are not
377cdf63a70SMartin Matuska * forbidden or avoid them in certain cases where they
378cdf63a70SMartin Matuska * are not strictly required.
379cdf63a70SMartin Matuska */
380cdf63a70SMartin Matuska if (val != NULL && *val != '\0') {
381cdf63a70SMartin Matuska zip->flags |= ZIP_FLAG_FORCE_ZIP64;
382cdf63a70SMartin Matuska zip->flags &= ~ZIP_FLAG_AVOID_ZIP64;
383cdf63a70SMartin Matuska } else {
384cdf63a70SMartin Matuska zip->flags &= ~ZIP_FLAG_FORCE_ZIP64;
385cdf63a70SMartin Matuska zip->flags |= ZIP_FLAG_AVOID_ZIP64;
386cdf63a70SMartin Matuska }
387cdf63a70SMartin Matuska return (ARCHIVE_OK);
3886c95142eSMartin Matuska }
3896c95142eSMartin Matuska
3906c95142eSMartin Matuska /* Note: The "warn" return is just to inform the options
3916c95142eSMartin Matuska * supervisor that we didn't handle it. It will generate
3926c95142eSMartin Matuska * a suitable error if no one used this option. */
393caf54c4fSMartin Matuska return (ARCHIVE_WARN);
394caf54c4fSMartin Matuska }
395caf54c4fSMartin Matuska
396caf54c4fSMartin Matuska int
archive_write_zip_set_compression_deflate(struct archive * _a)397acc60b03SMartin Matuska archive_write_zip_set_compression_deflate(struct archive *_a)
398acc60b03SMartin Matuska {
399acc60b03SMartin Matuska struct archive_write *a = (struct archive_write *)_a;
400acc60b03SMartin Matuska int ret = ARCHIVE_FAILED;
401acc60b03SMartin Matuska
402acc60b03SMartin Matuska archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
403cdf63a70SMartin Matuska ARCHIVE_STATE_NEW | ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA,
404acc60b03SMartin Matuska "archive_write_zip_set_compression_deflate");
405acc60b03SMartin Matuska if (a->archive.archive_format != ARCHIVE_FORMAT_ZIP) {
406acc60b03SMartin Matuska archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
407acc60b03SMartin Matuska "Can only use archive_write_zip_set_compression_deflate"
408acc60b03SMartin Matuska " with zip format");
409acc60b03SMartin Matuska ret = ARCHIVE_FATAL;
410acc60b03SMartin Matuska } else {
411acc60b03SMartin Matuska #ifdef HAVE_ZLIB_H
412acc60b03SMartin Matuska struct zip *zip = a->format_data;
413cdf63a70SMartin Matuska zip->requested_compression = COMPRESSION_DEFLATE;
414acc60b03SMartin Matuska ret = ARCHIVE_OK;
415acc60b03SMartin Matuska #else
416acc60b03SMartin Matuska archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
417acc60b03SMartin Matuska "deflate compression not supported");
418cdf63a70SMartin Matuska ret = ARCHIVE_FAILED;
419acc60b03SMartin Matuska #endif
420acc60b03SMartin Matuska }
421acc60b03SMartin Matuska return (ret);
422acc60b03SMartin Matuska }
423acc60b03SMartin Matuska
424acc60b03SMartin Matuska int
archive_write_zip_set_compression_store(struct archive * _a)425acc60b03SMartin Matuska archive_write_zip_set_compression_store(struct archive *_a)
426acc60b03SMartin Matuska {
427acc60b03SMartin Matuska struct archive_write *a = (struct archive_write *)_a;
428acc60b03SMartin Matuska struct zip *zip = a->format_data;
429acc60b03SMartin Matuska int ret = ARCHIVE_FAILED;
430acc60b03SMartin Matuska
431acc60b03SMartin Matuska archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
432cdf63a70SMartin Matuska ARCHIVE_STATE_NEW | ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA,
433acc60b03SMartin Matuska "archive_write_zip_set_compression_deflate");
434acc60b03SMartin Matuska if (a->archive.archive_format != ARCHIVE_FORMAT_ZIP) {
435acc60b03SMartin Matuska archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
436acc60b03SMartin Matuska "Can only use archive_write_zip_set_compression_store"
437acc60b03SMartin Matuska " with zip format");
438acc60b03SMartin Matuska ret = ARCHIVE_FATAL;
439acc60b03SMartin Matuska } else {
440cdf63a70SMartin Matuska zip->requested_compression = COMPRESSION_STORE;
441acc60b03SMartin Matuska ret = ARCHIVE_OK;
442acc60b03SMartin Matuska }
443acc60b03SMartin Matuska return (ret);
444acc60b03SMartin Matuska }
445acc60b03SMartin Matuska
446acc60b03SMartin Matuska int
archive_write_set_format_zip(struct archive * _a)447caf54c4fSMartin Matuska archive_write_set_format_zip(struct archive *_a)
448caf54c4fSMartin Matuska {
449caf54c4fSMartin Matuska struct archive_write *a = (struct archive_write *)_a;
450caf54c4fSMartin Matuska struct zip *zip;
451caf54c4fSMartin Matuska
4526c95142eSMartin Matuska archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
4536c95142eSMartin Matuska ARCHIVE_STATE_NEW, "archive_write_set_format_zip");
4546c95142eSMartin Matuska
455caf54c4fSMartin Matuska /* If another format was already registered, unregister it. */
4566c95142eSMartin Matuska if (a->format_free != NULL)
4576c95142eSMartin Matuska (a->format_free)(a);
458caf54c4fSMartin Matuska
459caf54c4fSMartin Matuska zip = (struct zip *) calloc(1, sizeof(*zip));
460caf54c4fSMartin Matuska if (zip == NULL) {
4616c95142eSMartin Matuska archive_set_error(&a->archive, ENOMEM,
4626c95142eSMartin Matuska "Can't allocate zip data");
463caf54c4fSMartin Matuska return (ARCHIVE_FATAL);
464caf54c4fSMartin Matuska }
465caf54c4fSMartin Matuska
466cdf63a70SMartin Matuska /* "Unspecified" lets us choose the appropriate compression. */
467cdf63a70SMartin Matuska zip->requested_compression = COMPRESSION_UNSPECIFIED;
468caf54c4fSMartin Matuska #ifdef HAVE_ZLIB_H
469cdf63a70SMartin Matuska zip->deflate_compression_level = Z_DEFAULT_COMPRESSION;
470cdf63a70SMartin Matuska #endif
471cdf63a70SMartin Matuska zip->crc32func = real_crc32;
472cdf63a70SMartin Matuska
473cdf63a70SMartin Matuska /* A buffer used for both compression and encryption. */
474caf54c4fSMartin Matuska zip->len_buf = 65536;
475caf54c4fSMartin Matuska zip->buf = malloc(zip->len_buf);
476caf54c4fSMartin Matuska if (zip->buf == NULL) {
477fd082e96SMartin Matuska free(zip);
4786c95142eSMartin Matuska archive_set_error(&a->archive, ENOMEM,
4796c95142eSMartin Matuska "Can't allocate compression buffer");
480caf54c4fSMartin Matuska return (ARCHIVE_FATAL);
481caf54c4fSMartin Matuska }
482caf54c4fSMartin Matuska
483caf54c4fSMartin Matuska a->format_data = zip;
484caf54c4fSMartin Matuska a->format_name = "zip";
485caf54c4fSMartin Matuska a->format_options = archive_write_zip_options;
486caf54c4fSMartin Matuska a->format_write_header = archive_write_zip_header;
487caf54c4fSMartin Matuska a->format_write_data = archive_write_zip_data;
488caf54c4fSMartin Matuska a->format_finish_entry = archive_write_zip_finish_entry;
4896c95142eSMartin Matuska a->format_close = archive_write_zip_close;
4906c95142eSMartin Matuska a->format_free = archive_write_zip_free;
491caf54c4fSMartin Matuska a->archive.archive_format = ARCHIVE_FORMAT_ZIP;
492caf54c4fSMartin Matuska a->archive.archive_format_name = "ZIP";
493caf54c4fSMartin Matuska
494caf54c4fSMartin Matuska return (ARCHIVE_OK);
495caf54c4fSMartin Matuska }
496caf54c4fSMartin Matuska
497caf54c4fSMartin Matuska static int
is_all_ascii(const char * p)4986c95142eSMartin Matuska is_all_ascii(const char *p)
4996c95142eSMartin Matuska {
5006c95142eSMartin Matuska const unsigned char *pp = (const unsigned char *)p;
5016c95142eSMartin Matuska
5026c95142eSMartin Matuska while (*pp) {
5036c95142eSMartin Matuska if (*pp++ > 127)
5046c95142eSMartin Matuska return (0);
5056c95142eSMartin Matuska }
5066c95142eSMartin Matuska return (1);
5076c95142eSMartin Matuska }
5086c95142eSMartin Matuska
5096c95142eSMartin Matuska static int
archive_write_zip_header(struct archive_write * a,struct archive_entry * entry)510caf54c4fSMartin Matuska archive_write_zip_header(struct archive_write *a, struct archive_entry *entry)
511caf54c4fSMartin Matuska {
512cdf63a70SMartin Matuska unsigned char local_header[32];
513cdf63a70SMartin Matuska unsigned char local_extra[144];
514cdf63a70SMartin Matuska struct zip *zip = a->format_data;
515cdf63a70SMartin Matuska unsigned char *e;
516cdf63a70SMartin Matuska unsigned char *cd_extra;
517cdf63a70SMartin Matuska size_t filename_length;
518cdf63a70SMartin Matuska const char *slink = NULL;
519cdf63a70SMartin Matuska size_t slink_size = 0;
520cdf63a70SMartin Matuska struct archive_string_conv *sconv = get_sconv(a, zip);
5216c95142eSMartin Matuska int ret, ret2 = ARCHIVE_OK;
522caf54c4fSMartin Matuska mode_t type;
523cdf63a70SMartin Matuska int version_needed = 10;
524b9128a37SMartin Matuska #define MIN_VERSION_NEEDED(x) do { if (version_needed < x) { version_needed = x; } } while (0)
525caf54c4fSMartin Matuska
526cdf63a70SMartin Matuska /* Ignore types of entries that we don't support. */
527caf54c4fSMartin Matuska type = archive_entry_filetype(entry);
5286c95142eSMartin Matuska if (type != AE_IFREG && type != AE_IFDIR && type != AE_IFLNK) {
529f9762417SMartin Matuska __archive_write_entry_filetype_unsupported(
530f9762417SMartin Matuska &a->archive, entry, "zip");
531caf54c4fSMartin Matuska return ARCHIVE_FAILED;
532caf54c4fSMartin Matuska };
533caf54c4fSMartin Matuska
534cdf63a70SMartin Matuska /* If we're not using Zip64, reject large files. */
535cdf63a70SMartin Matuska if (zip->flags & ZIP_FLAG_AVOID_ZIP64) {
536cdf63a70SMartin Matuska /* Reject entries over 4GB. */
537cdf63a70SMartin Matuska if (archive_entry_size_is_set(entry)
538cdf63a70SMartin Matuska && (archive_entry_size(entry) > ZIP_4GB_MAX)) {
539cdf63a70SMartin Matuska archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
540cdf63a70SMartin Matuska "Files > 4GB require Zip64 extensions");
541cdf63a70SMartin Matuska return ARCHIVE_FAILED;
542cdf63a70SMartin Matuska }
543cdf63a70SMartin Matuska /* Reject entries if archive is > 4GB. */
544cdf63a70SMartin Matuska if (zip->written_bytes > ZIP_4GB_MAX) {
545cdf63a70SMartin Matuska archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
546cdf63a70SMartin Matuska "Archives > 4GB require Zip64 extensions");
547cdf63a70SMartin Matuska return ARCHIVE_FAILED;
548cdf63a70SMartin Matuska }
549cdf63a70SMartin Matuska }
550cdf63a70SMartin Matuska
551cdf63a70SMartin Matuska /* Only regular files can have size > 0. */
552cdf63a70SMartin Matuska if (type != AE_IFREG)
553caf54c4fSMartin Matuska archive_entry_set_size(entry, 0);
554caf54c4fSMartin Matuska
555cdf63a70SMartin Matuska
556cdf63a70SMartin Matuska /* Reset information from last entry. */
557cdf63a70SMartin Matuska zip->entry_offset = zip->written_bytes;
558cdf63a70SMartin Matuska zip->entry_uncompressed_limit = INT64_MAX;
559b9128a37SMartin Matuska /* Zero size values implies that we're using a trailing data descriptor */
560cdf63a70SMartin Matuska zip->entry_compressed_size = 0;
561cdf63a70SMartin Matuska zip->entry_uncompressed_size = 0;
562cdf63a70SMartin Matuska zip->entry_compressed_written = 0;
563cdf63a70SMartin Matuska zip->entry_uncompressed_written = 0;
564cdf63a70SMartin Matuska zip->entry_flags = 0;
565cdf63a70SMartin Matuska zip->entry_crc32 = zip->crc32func(0, NULL, 0);
566cdf63a70SMartin Matuska zip->entry_encryption = 0;
567cdf63a70SMartin Matuska archive_entry_free(zip->entry);
568cdf63a70SMartin Matuska zip->entry = NULL;
5696c95142eSMartin Matuska
570cdf63a70SMartin Matuska if (zip->cctx_valid)
571cdf63a70SMartin Matuska archive_encrypto_aes_ctr_release(&zip->cctx);
572cdf63a70SMartin Matuska if (zip->hctx_valid)
573cdf63a70SMartin Matuska archive_hmac_sha1_cleanup(&zip->hctx);
574cdf63a70SMartin Matuska zip->tctx_valid = zip->cctx_valid = zip->hctx_valid = 0;
575caf54c4fSMartin Matuska
576cdf63a70SMartin Matuska if (type == AE_IFREG
577cdf63a70SMartin Matuska &&(!archive_entry_size_is_set(entry)
578cdf63a70SMartin Matuska || archive_entry_size(entry) > 0)) {
579cdf63a70SMartin Matuska switch (zip->encryption_type) {
580cdf63a70SMartin Matuska case ENCRYPTION_TRADITIONAL:
581cdf63a70SMartin Matuska case ENCRYPTION_WINZIP_AES128:
582cdf63a70SMartin Matuska case ENCRYPTION_WINZIP_AES256:
583cdf63a70SMartin Matuska zip->entry_flags |= ZIP_ENTRY_FLAG_ENCRYPTED;
584cdf63a70SMartin Matuska zip->entry_encryption = zip->encryption_type;
585cdf63a70SMartin Matuska break;
586c3afd20fSMartin Matuska case ENCRYPTION_NONE:
587cdf63a70SMartin Matuska default:
588cdf63a70SMartin Matuska break;
589caf54c4fSMartin Matuska }
590cdf63a70SMartin Matuska }
591cdf63a70SMartin Matuska
592cdf63a70SMartin Matuska
5936c95142eSMartin Matuska #if defined(_WIN32) && !defined(__CYGWIN__)
594a2e802b7SMartin Matuska /* Make sure the path separators in pathname, hardlink and symlink
5956c95142eSMartin Matuska * are all slash '/', not the Windows path separator '\'. */
596cdf63a70SMartin Matuska zip->entry = __la_win_entry_in_posix_pathseparator(entry);
597cdf63a70SMartin Matuska if (zip->entry == entry)
598cdf63a70SMartin Matuska zip->entry = archive_entry_clone(entry);
5996c95142eSMartin Matuska #else
600cdf63a70SMartin Matuska zip->entry = archive_entry_clone(entry);
6016c95142eSMartin Matuska #endif
602cdf63a70SMartin Matuska if (zip->entry == NULL) {
6036c95142eSMartin Matuska archive_set_error(&a->archive, ENOMEM,
6046c95142eSMartin Matuska "Can't allocate zip header data");
6056c95142eSMartin Matuska return (ARCHIVE_FATAL);
6066c95142eSMartin Matuska }
607cdf63a70SMartin Matuska
6086c95142eSMartin Matuska if (sconv != NULL) {
6096c95142eSMartin Matuska const char *p;
6106c95142eSMartin Matuska size_t len;
6116c95142eSMartin Matuska
6126c95142eSMartin Matuska if (archive_entry_pathname_l(entry, &p, &len, sconv) != 0) {
6136c95142eSMartin Matuska if (errno == ENOMEM) {
6146c95142eSMartin Matuska archive_set_error(&a->archive, ENOMEM,
6156c95142eSMartin Matuska "Can't allocate memory for Pathname");
6166c95142eSMartin Matuska return (ARCHIVE_FATAL);
6176c95142eSMartin Matuska }
6186c95142eSMartin Matuska archive_set_error(&a->archive,
6196c95142eSMartin Matuska ARCHIVE_ERRNO_FILE_FORMAT,
620fd082e96SMartin Matuska "Can't translate Pathname '%s' to %s",
6216c95142eSMartin Matuska archive_entry_pathname(entry),
6226c95142eSMartin Matuska archive_string_conversion_charset_name(sconv));
6236c95142eSMartin Matuska ret2 = ARCHIVE_WARN;
6246c95142eSMartin Matuska }
6256c95142eSMartin Matuska if (len > 0)
626cdf63a70SMartin Matuska archive_entry_set_pathname(zip->entry, p);
627fd082e96SMartin Matuska
628fd082e96SMartin Matuska /*
629cdf63a70SMartin Matuska * There is no standard for symlink handling; we convert
630cdf63a70SMartin Matuska * it using the same character-set translation that we use
631cdf63a70SMartin Matuska * for filename.
632fd082e96SMartin Matuska */
633fd082e96SMartin Matuska if (type == AE_IFLNK) {
634fd082e96SMartin Matuska if (archive_entry_symlink_l(entry, &p, &len, sconv)) {
635fd082e96SMartin Matuska if (errno == ENOMEM) {
636fd082e96SMartin Matuska archive_set_error(&a->archive, ENOMEM,
637fd082e96SMartin Matuska "Can't allocate memory "
638fd082e96SMartin Matuska " for Symlink");
639fd082e96SMartin Matuska return (ARCHIVE_FATAL);
6406c95142eSMartin Matuska }
641cdf63a70SMartin Matuska /* No error if we can't convert. */
642fd082e96SMartin Matuska } else if (len > 0)
643cdf63a70SMartin Matuska archive_entry_set_symlink(zip->entry, p);
644fd082e96SMartin Matuska }
645fd082e96SMartin Matuska }
6466c95142eSMartin Matuska
647cdf63a70SMartin Matuska /* If filename isn't ASCII and we can use UTF-8, set the UTF-8 flag. */
648cdf63a70SMartin Matuska if (!is_all_ascii(archive_entry_pathname(zip->entry))) {
649cdf63a70SMartin Matuska if (zip->opt_sconv != NULL) {
650cdf63a70SMartin Matuska if (strcmp(archive_string_conversion_charset_name(
651cdf63a70SMartin Matuska zip->opt_sconv), "UTF-8") == 0)
652cdf63a70SMartin Matuska zip->entry_flags |= ZIP_ENTRY_FLAG_UTF8_NAME;
653cdf63a70SMartin Matuska #if HAVE_NL_LANGINFO
654cdf63a70SMartin Matuska } else if (strcmp(nl_langinfo(CODESET), "UTF-8") == 0) {
655cdf63a70SMartin Matuska zip->entry_flags |= ZIP_ENTRY_FLAG_UTF8_NAME;
656cdf63a70SMartin Matuska #endif
657cdf63a70SMartin Matuska }
658cdf63a70SMartin Matuska }
659cdf63a70SMartin Matuska filename_length = path_length(zip->entry);
660cdf63a70SMartin Matuska
661cdf63a70SMartin Matuska /* Determine appropriate compression and size for this entry. */
6626c95142eSMartin Matuska if (type == AE_IFLNK) {
663cdf63a70SMartin Matuska slink = archive_entry_symlink(zip->entry);
664cdf63a70SMartin Matuska if (slink != NULL)
665cdf63a70SMartin Matuska slink_size = strlen(slink);
6666c95142eSMartin Matuska else
667cdf63a70SMartin Matuska slink_size = 0;
668cdf63a70SMartin Matuska zip->entry_uncompressed_limit = slink_size;
669cdf63a70SMartin Matuska zip->entry_compressed_size = slink_size;
670cdf63a70SMartin Matuska zip->entry_uncompressed_size = slink_size;
671cdf63a70SMartin Matuska zip->entry_crc32 = zip->crc32func(zip->entry_crc32,
672cdf63a70SMartin Matuska (const unsigned char *)slink, slink_size);
673cdf63a70SMartin Matuska zip->entry_compression = COMPRESSION_STORE;
674b9128a37SMartin Matuska MIN_VERSION_NEEDED(20);
675cdf63a70SMartin Matuska } else if (type != AE_IFREG) {
676cdf63a70SMartin Matuska zip->entry_compression = COMPRESSION_STORE;
677cdf63a70SMartin Matuska zip->entry_uncompressed_limit = 0;
678b9128a37SMartin Matuska MIN_VERSION_NEEDED(20);
679cdf63a70SMartin Matuska } else if (archive_entry_size_is_set(zip->entry)) {
680cdf63a70SMartin Matuska int64_t size = archive_entry_size(zip->entry);
681cdf63a70SMartin Matuska int64_t additional_size = 0;
682cdf63a70SMartin Matuska
683cdf63a70SMartin Matuska zip->entry_uncompressed_limit = size;
684cdf63a70SMartin Matuska zip->entry_compression = zip->requested_compression;
685cdf63a70SMartin Matuska if (zip->entry_compression == COMPRESSION_UNSPECIFIED) {
686cdf63a70SMartin Matuska zip->entry_compression = COMPRESSION_DEFAULT;
6876c95142eSMartin Matuska }
688cdf63a70SMartin Matuska if (zip->entry_compression == COMPRESSION_STORE) {
689cdf63a70SMartin Matuska zip->entry_compressed_size = size;
690cdf63a70SMartin Matuska zip->entry_uncompressed_size = size;
691b9128a37SMartin Matuska MIN_VERSION_NEEDED(10);
692caf54c4fSMartin Matuska } else {
693cdf63a70SMartin Matuska zip->entry_uncompressed_size = size;
694b9128a37SMartin Matuska MIN_VERSION_NEEDED(20);
695caf54c4fSMartin Matuska }
696caf54c4fSMartin Matuska
697cdf63a70SMartin Matuska if (zip->entry_flags & ZIP_ENTRY_FLAG_ENCRYPTED) {
698cdf63a70SMartin Matuska switch (zip->entry_encryption) {
699cdf63a70SMartin Matuska case ENCRYPTION_TRADITIONAL:
700cdf63a70SMartin Matuska additional_size = TRAD_HEADER_SIZE;
701b9128a37SMartin Matuska MIN_VERSION_NEEDED(20);
702caf54c4fSMartin Matuska break;
703cdf63a70SMartin Matuska case ENCRYPTION_WINZIP_AES128:
704cdf63a70SMartin Matuska additional_size = WINZIP_AES128_HEADER_SIZE
705cdf63a70SMartin Matuska + AUTH_CODE_SIZE;
706b9128a37SMartin Matuska MIN_VERSION_NEEDED(20);
707cdf63a70SMartin Matuska break;
708cdf63a70SMartin Matuska case ENCRYPTION_WINZIP_AES256:
709cdf63a70SMartin Matuska additional_size = WINZIP_AES256_HEADER_SIZE
710cdf63a70SMartin Matuska + AUTH_CODE_SIZE;
711b9128a37SMartin Matuska MIN_VERSION_NEEDED(20);
712cdf63a70SMartin Matuska break;
713c3afd20fSMartin Matuska case ENCRYPTION_NONE:
714cdf63a70SMartin Matuska default:
715cdf63a70SMartin Matuska break;
716cdf63a70SMartin Matuska }
717cdf63a70SMartin Matuska if (zip->entry_compression == COMPRESSION_STORE)
718cdf63a70SMartin Matuska zip->entry_compressed_size += additional_size;
719cdf63a70SMartin Matuska }
720caf54c4fSMartin Matuska
721cdf63a70SMartin Matuska /*
722cdf63a70SMartin Matuska * Set Zip64 extension in any of the following cases
723cdf63a70SMartin Matuska * (this was suggested by discussion on info-zip-dev
724cdf63a70SMartin Matuska * mailing list):
725cdf63a70SMartin Matuska * = Zip64 is being forced by user
726cdf63a70SMartin Matuska * = File is over 4GiB uncompressed
727cdf63a70SMartin Matuska * (including encryption header, if any)
728cdf63a70SMartin Matuska * = File is close to 4GiB and is being compressed
729cdf63a70SMartin Matuska * (compression might make file larger)
730cdf63a70SMartin Matuska */
731cdf63a70SMartin Matuska if ((zip->flags & ZIP_FLAG_FORCE_ZIP64)
732cdf63a70SMartin Matuska || (zip->entry_uncompressed_size + additional_size > ZIP_4GB_MAX)
733cdf63a70SMartin Matuska || (zip->entry_uncompressed_size > ZIP_4GB_MAX_UNCOMPRESSED
734cdf63a70SMartin Matuska && zip->entry_compression != COMPRESSION_STORE)) {
735b9128a37SMartin Matuska MIN_VERSION_NEEDED(45);
736cdf63a70SMartin Matuska }
737cdf63a70SMartin Matuska
738cdf63a70SMartin Matuska /* We may know the size, but never the CRC. */
739cdf63a70SMartin Matuska zip->entry_flags |= ZIP_ENTRY_FLAG_LENGTH_AT_END;
740cdf63a70SMartin Matuska } else {
741833a452eSMartin Matuska /* We don't know the size. Use the default
742833a452eSMartin Matuska * compression unless specified otherwise.
743cdf63a70SMartin Matuska */
744833a452eSMartin Matuska
745833a452eSMartin Matuska zip->entry_compression = zip->requested_compression;
746833a452eSMartin Matuska if(zip->entry_compression == COMPRESSION_UNSPECIFIED){
747cdf63a70SMartin Matuska zip->entry_compression = COMPRESSION_DEFAULT;
748833a452eSMartin Matuska }
749833a452eSMartin Matuska
750cdf63a70SMartin Matuska zip->entry_flags |= ZIP_ENTRY_FLAG_LENGTH_AT_END;
751cdf63a70SMartin Matuska if ((zip->flags & ZIP_FLAG_AVOID_ZIP64) == 0) {
752b9128a37SMartin Matuska /* We might use zip64 extensions, so require 4.5 */
753b9128a37SMartin Matuska MIN_VERSION_NEEDED(45);
754cdf63a70SMartin Matuska } else if (zip->entry_compression == COMPRESSION_STORE) {
755b9128a37SMartin Matuska MIN_VERSION_NEEDED(10);
756cdf63a70SMartin Matuska } else {
757b9128a37SMartin Matuska MIN_VERSION_NEEDED(20);
758cdf63a70SMartin Matuska }
759cdf63a70SMartin Matuska
760cdf63a70SMartin Matuska if (zip->entry_flags & ZIP_ENTRY_FLAG_ENCRYPTED) {
761cdf63a70SMartin Matuska switch (zip->entry_encryption) {
762cdf63a70SMartin Matuska case ENCRYPTION_TRADITIONAL:
763cdf63a70SMartin Matuska case ENCRYPTION_WINZIP_AES128:
764cdf63a70SMartin Matuska case ENCRYPTION_WINZIP_AES256:
765b9128a37SMartin Matuska MIN_VERSION_NEEDED(20);
766cdf63a70SMartin Matuska break;
767c3afd20fSMartin Matuska case ENCRYPTION_NONE:
768cdf63a70SMartin Matuska default:
769cdf63a70SMartin Matuska break;
770cdf63a70SMartin Matuska }
771cdf63a70SMartin Matuska }
772cdf63a70SMartin Matuska }
773cdf63a70SMartin Matuska
774cdf63a70SMartin Matuska /* Format the local header. */
775cdf63a70SMartin Matuska memset(local_header, 0, sizeof(local_header));
776cdf63a70SMartin Matuska memcpy(local_header, "PK\003\004", 4);
777cdf63a70SMartin Matuska archive_le16enc(local_header + 4, version_needed);
778cdf63a70SMartin Matuska archive_le16enc(local_header + 6, zip->entry_flags);
779cdf63a70SMartin Matuska if (zip->entry_encryption == ENCRYPTION_WINZIP_AES128
780cdf63a70SMartin Matuska || zip->entry_encryption == ENCRYPTION_WINZIP_AES256)
781cdf63a70SMartin Matuska archive_le16enc(local_header + 8, WINZIP_AES_ENCRYPTION);
782cdf63a70SMartin Matuska else
783cdf63a70SMartin Matuska archive_le16enc(local_header + 8, zip->entry_compression);
784cdf63a70SMartin Matuska archive_le32enc(local_header + 10,
785cdf63a70SMartin Matuska dos_time(archive_entry_mtime(zip->entry)));
786b9128a37SMartin Matuska if ((zip->entry_flags & ZIP_ENTRY_FLAG_LENGTH_AT_END) == 0) {
787cdf63a70SMartin Matuska archive_le32enc(local_header + 14, zip->entry_crc32);
788cdf63a70SMartin Matuska archive_le32enc(local_header + 18, (uint32_t)zip->entry_compressed_size);
789cdf63a70SMartin Matuska archive_le32enc(local_header + 22, (uint32_t)zip->entry_uncompressed_size);
790cdf63a70SMartin Matuska }
791cdf63a70SMartin Matuska archive_le16enc(local_header + 26, (uint16_t)filename_length);
792cdf63a70SMartin Matuska
793cdf63a70SMartin Matuska if (zip->entry_encryption == ENCRYPTION_TRADITIONAL) {
794cdf63a70SMartin Matuska if (zip->entry_flags & ZIP_ENTRY_FLAG_LENGTH_AT_END)
795cdf63a70SMartin Matuska zip->trad_chkdat = local_header[11];
796cdf63a70SMartin Matuska else
797cdf63a70SMartin Matuska zip->trad_chkdat = local_header[17];
798cdf63a70SMartin Matuska }
799cdf63a70SMartin Matuska
800cdf63a70SMartin Matuska /* Format as much of central directory file header as we can: */
801cdf63a70SMartin Matuska zip->file_header = cd_alloc(zip, 46);
802cdf63a70SMartin Matuska /* If (zip->file_header == NULL) XXXX */
803cdf63a70SMartin Matuska ++zip->central_directory_entries;
804cdf63a70SMartin Matuska memset(zip->file_header, 0, 46);
805cdf63a70SMartin Matuska memcpy(zip->file_header, "PK\001\002", 4);
806cdf63a70SMartin Matuska /* "Made by PKZip 2.0 on Unix." */
807cdf63a70SMartin Matuska archive_le16enc(zip->file_header + 4, 3 * 256 + version_needed);
808cdf63a70SMartin Matuska archive_le16enc(zip->file_header + 6, version_needed);
809cdf63a70SMartin Matuska archive_le16enc(zip->file_header + 8, zip->entry_flags);
810cdf63a70SMartin Matuska if (zip->entry_encryption == ENCRYPTION_WINZIP_AES128
811cdf63a70SMartin Matuska || zip->entry_encryption == ENCRYPTION_WINZIP_AES256)
812cdf63a70SMartin Matuska archive_le16enc(zip->file_header + 10, WINZIP_AES_ENCRYPTION);
813cdf63a70SMartin Matuska else
814cdf63a70SMartin Matuska archive_le16enc(zip->file_header + 10, zip->entry_compression);
815cdf63a70SMartin Matuska archive_le32enc(zip->file_header + 12,
816cdf63a70SMartin Matuska dos_time(archive_entry_mtime(zip->entry)));
817cdf63a70SMartin Matuska archive_le16enc(zip->file_header + 28, (uint16_t)filename_length);
818cdf63a70SMartin Matuska /* Following Info-Zip, store mode in the "external attributes" field. */
819cdf63a70SMartin Matuska archive_le32enc(zip->file_header + 38,
820cdf63a70SMartin Matuska ((uint32_t)archive_entry_mode(zip->entry)) << 16);
821cdf63a70SMartin Matuska e = cd_alloc(zip, filename_length);
822cdf63a70SMartin Matuska /* If (e == NULL) XXXX */
823cdf63a70SMartin Matuska copy_path(zip->entry, e);
824cdf63a70SMartin Matuska
825cdf63a70SMartin Matuska /* Format extra data. */
826cdf63a70SMartin Matuska memset(local_extra, 0, sizeof(local_extra));
827cdf63a70SMartin Matuska e = local_extra;
828cdf63a70SMartin Matuska
829cdf63a70SMartin Matuska /* First, extra blocks that are the same between
830cdf63a70SMartin Matuska * the local file header and the central directory.
831cdf63a70SMartin Matuska * We format them once and then duplicate them. */
832cdf63a70SMartin Matuska
833cdf63a70SMartin Matuska /* ux Unix extra data, length 11, version 1 */
834b9128a37SMartin Matuska if (archive_entry_uid_is_set(entry) || archive_entry_gid_is_set(entry)) {
835cdf63a70SMartin Matuska /* TODO: If uid < 64k, use 2 bytes, ditto for gid. */
836cdf63a70SMartin Matuska memcpy(e, "ux\013\000\001", 5);
837cdf63a70SMartin Matuska e += 5;
838cdf63a70SMartin Matuska *e++ = 4; /* Length of following UID */
839cdf63a70SMartin Matuska archive_le32enc(e, (uint32_t)archive_entry_uid(entry));
840cdf63a70SMartin Matuska e += 4;
841cdf63a70SMartin Matuska *e++ = 4; /* Length of following GID */
842cdf63a70SMartin Matuska archive_le32enc(e, (uint32_t)archive_entry_gid(entry));
843cdf63a70SMartin Matuska e += 4;
844b9128a37SMartin Matuska }
845cdf63a70SMartin Matuska
846cdf63a70SMartin Matuska /* AES extra data field: WinZIP AES information, ID=0x9901 */
847cdf63a70SMartin Matuska if ((zip->entry_flags & ZIP_ENTRY_FLAG_ENCRYPTED)
848cdf63a70SMartin Matuska && (zip->entry_encryption == ENCRYPTION_WINZIP_AES128
849cdf63a70SMartin Matuska || zip->entry_encryption == ENCRYPTION_WINZIP_AES256)) {
850cdf63a70SMartin Matuska
851cdf63a70SMartin Matuska memcpy(e, "\001\231\007\000\001\000AE", 8);
8522dbf8c4aSMartin Matuska /* AES vendor version AE-2 does not store a CRC.
853cdf63a70SMartin Matuska * WinZip 11 uses AE-1, which does store the CRC,
854cdf63a70SMartin Matuska * but it does not store the CRC when the file size
855cdf63a70SMartin Matuska * is less than 20 bytes. So we simulate what
856cdf63a70SMartin Matuska * WinZip 11 does.
857cdf63a70SMartin Matuska * NOTE: WinZip 9.0 and 10.0 uses AE-2 by default. */
858cdf63a70SMartin Matuska if (archive_entry_size_is_set(zip->entry)
859cdf63a70SMartin Matuska && archive_entry_size(zip->entry) < 20) {
860cdf63a70SMartin Matuska archive_le16enc(e+4, AES_VENDOR_AE_2);
861cdf63a70SMartin Matuska zip->aes_vendor = AES_VENDOR_AE_2;/* no CRC. */
862cdf63a70SMartin Matuska } else
863cdf63a70SMartin Matuska zip->aes_vendor = AES_VENDOR_AE_1;
864cdf63a70SMartin Matuska e += 8;
865cdf63a70SMartin Matuska /* AES encryption strength. */
866cdf63a70SMartin Matuska *e++ = (zip->entry_encryption == ENCRYPTION_WINZIP_AES128)?1:3;
867cdf63a70SMartin Matuska /* Actual compression method. */
868cdf63a70SMartin Matuska archive_le16enc(e, zip->entry_compression);
869cdf63a70SMartin Matuska e += 2;
870cdf63a70SMartin Matuska }
871cdf63a70SMartin Matuska
872b9128a37SMartin Matuska /* Copy ux, AES-extra into central directory as well. */
873cdf63a70SMartin Matuska zip->file_header_extra_offset = zip->central_directory_bytes;
874cdf63a70SMartin Matuska cd_extra = cd_alloc(zip, e - local_extra);
875cdf63a70SMartin Matuska memcpy(cd_extra, local_extra, e - local_extra);
876cdf63a70SMartin Matuska
877cdf63a70SMartin Matuska /*
878cdf63a70SMartin Matuska * Following extra blocks vary between local header and
879cdf63a70SMartin Matuska * central directory. These are the local header versions.
880cdf63a70SMartin Matuska * Central directory versions get formatted in
881cdf63a70SMartin Matuska * archive_write_zip_finish_entry() below.
882cdf63a70SMartin Matuska */
883cdf63a70SMartin Matuska
884b9128a37SMartin Matuska /* UT timestamp: length depends on what timestamps are set.
885b9128a37SMartin Matuska * This header appears in the Central Directory also, but
886b9128a37SMartin Matuska * according to Info-Zip specification, the CD form
887b9128a37SMartin Matuska * only holds mtime, so we format it separately. */
888b9128a37SMartin Matuska if (archive_entry_mtime_is_set(entry)
889b9128a37SMartin Matuska || archive_entry_atime_is_set(entry)
890b9128a37SMartin Matuska || archive_entry_ctime_is_set(entry)) {
891b9128a37SMartin Matuska unsigned char *ut = e;
892b9128a37SMartin Matuska memcpy(e, "UT\000\000", 4);
893cdf63a70SMartin Matuska e += 4;
894b9128a37SMartin Matuska *e++ = (archive_entry_mtime_is_set(entry) ? 1 : 0)
895b9128a37SMartin Matuska | (archive_entry_atime_is_set(entry) ? 2 : 0)
896b9128a37SMartin Matuska | (archive_entry_ctime_is_set(entry) ? 4 : 0);
897b9128a37SMartin Matuska if (archive_entry_mtime_is_set(entry)) {
898b9128a37SMartin Matuska archive_le32enc(e, (uint32_t)archive_entry_mtime(entry));
899b9128a37SMartin Matuska e += 4;
900b9128a37SMartin Matuska }
901b9128a37SMartin Matuska if (archive_entry_atime_is_set(entry)) {
902b9128a37SMartin Matuska archive_le32enc(e, (uint32_t)archive_entry_atime(entry));
903b9128a37SMartin Matuska e += 4;
904b9128a37SMartin Matuska }
905b9128a37SMartin Matuska if (archive_entry_ctime_is_set(entry)) {
906b9128a37SMartin Matuska archive_le32enc(e, (uint32_t)archive_entry_ctime(entry));
907b9128a37SMartin Matuska e += 4;
908b9128a37SMartin Matuska }
909b9128a37SMartin Matuska archive_le16enc(ut + 2, e - ut - 4);
910b9128a37SMartin Matuska }
911b9128a37SMartin Matuska
912b9128a37SMartin Matuska /*
913b9128a37SMartin Matuska * Note about Zip64 Extended Information Extra Field:
914b9128a37SMartin Matuska * Because libarchive always writes in a streaming
915b9128a37SMartin Matuska * fashion, we never know the CRC when we're writing
916b9128a37SMartin Matuska * the local header. So we have to use length-at-end, which
917b9128a37SMartin Matuska * prevents us from putting size information into a Zip64
918b9128a37SMartin Matuska * extra field. However, apparently some readers find it
919b9128a37SMartin Matuska * a helpful clue to have an empty such field so they
920b9128a37SMartin Matuska * can expect a 64-bit length-at-end marker.
921b9128a37SMartin Matuska */
922b9128a37SMartin Matuska if (archive_entry_size_is_set(zip->entry)
923b9128a37SMartin Matuska && (zip->entry_uncompressed_size > ZIP_4GB_MAX
924b9128a37SMartin Matuska || zip->entry_compressed_size > ZIP_4GB_MAX)) {
925b9128a37SMartin Matuska /* Header ID 0x0001, size 0 */
926b9128a37SMartin Matuska memcpy(e, "\001\000\000\000", 4);
927b9128a37SMartin Matuska e += 4;
928cdf63a70SMartin Matuska }
929cdf63a70SMartin Matuska
930cdf63a70SMartin Matuska if (zip->flags & ZIP_FLAG_EXPERIMENT_xl) {
931cdf63a70SMartin Matuska /* Experimental 'xl' extension to improve streaming. */
932cdf63a70SMartin Matuska unsigned char *external_info = e;
933cdf63a70SMartin Matuska int included = 7;
934cdf63a70SMartin Matuska memcpy(e, "xl\000\000", 4); // 0x6c65 + 2-byte length
935cdf63a70SMartin Matuska e += 4;
936cdf63a70SMartin Matuska e[0] = included; /* bitmap of included fields */
937cdf63a70SMartin Matuska e += 1;
938cdf63a70SMartin Matuska if (included & 1) {
939cdf63a70SMartin Matuska archive_le16enc(e, /* "Version created by" */
940cdf63a70SMartin Matuska 3 * 256 + version_needed);
941cdf63a70SMartin Matuska e += 2;
942cdf63a70SMartin Matuska }
943cdf63a70SMartin Matuska if (included & 2) {
944cdf63a70SMartin Matuska archive_le16enc(e, 0); /* internal file attributes */
945cdf63a70SMartin Matuska e += 2;
946cdf63a70SMartin Matuska }
947cdf63a70SMartin Matuska if (included & 4) {
948cdf63a70SMartin Matuska archive_le32enc(e, /* external file attributes */
949cdf63a70SMartin Matuska ((uint32_t)archive_entry_mode(zip->entry)) << 16);
950cdf63a70SMartin Matuska e += 4;
951cdf63a70SMartin Matuska }
952cdf63a70SMartin Matuska if (included & 8) {
953cdf63a70SMartin Matuska // Libarchive does not currently support file comments.
954cdf63a70SMartin Matuska }
955cdf63a70SMartin Matuska archive_le16enc(external_info + 2, (uint16_t)(e - (external_info + 4)));
956cdf63a70SMartin Matuska }
957cdf63a70SMartin Matuska
958cdf63a70SMartin Matuska /* Update local header with size of extra data and write it all out: */
959cdf63a70SMartin Matuska archive_le16enc(local_header + 28, (uint16_t)(e - local_extra));
960cdf63a70SMartin Matuska
961cdf63a70SMartin Matuska ret = __archive_write_output(a, local_header, 30);
962cdf63a70SMartin Matuska if (ret != ARCHIVE_OK)
963cdf63a70SMartin Matuska return (ARCHIVE_FATAL);
964cdf63a70SMartin Matuska zip->written_bytes += 30;
965cdf63a70SMartin Matuska
966cdf63a70SMartin Matuska ret = write_path(zip->entry, a);
967cdf63a70SMartin Matuska if (ret <= ARCHIVE_OK)
968cdf63a70SMartin Matuska return (ARCHIVE_FATAL);
969cdf63a70SMartin Matuska zip->written_bytes += ret;
970cdf63a70SMartin Matuska
971cdf63a70SMartin Matuska ret = __archive_write_output(a, local_extra, e - local_extra);
972cdf63a70SMartin Matuska if (ret != ARCHIVE_OK)
973cdf63a70SMartin Matuska return (ARCHIVE_FATAL);
974cdf63a70SMartin Matuska zip->written_bytes += e - local_extra;
975cdf63a70SMartin Matuska
976cdf63a70SMartin Matuska /* For symlinks, write the body now. */
977cdf63a70SMartin Matuska if (slink != NULL) {
978cdf63a70SMartin Matuska ret = __archive_write_output(a, slink, slink_size);
979cdf63a70SMartin Matuska if (ret != ARCHIVE_OK)
980cdf63a70SMartin Matuska return (ARCHIVE_FATAL);
981cdf63a70SMartin Matuska zip->entry_compressed_written += slink_size;
982cdf63a70SMartin Matuska zip->entry_uncompressed_written += slink_size;
983cdf63a70SMartin Matuska zip->written_bytes += slink_size;
984cdf63a70SMartin Matuska }
985cdf63a70SMartin Matuska
986cdf63a70SMartin Matuska #ifdef HAVE_ZLIB_H
987cdf63a70SMartin Matuska if (zip->entry_compression == COMPRESSION_DEFLATE) {
988caf54c4fSMartin Matuska zip->stream.zalloc = Z_NULL;
989caf54c4fSMartin Matuska zip->stream.zfree = Z_NULL;
990caf54c4fSMartin Matuska zip->stream.opaque = Z_NULL;
991caf54c4fSMartin Matuska zip->stream.next_out = zip->buf;
992acc60b03SMartin Matuska zip->stream.avail_out = (uInt)zip->len_buf;
993cdf63a70SMartin Matuska if (deflateInit2(&zip->stream, zip->deflate_compression_level,
9946c95142eSMartin Matuska Z_DEFLATED, -15, 8, Z_DEFAULT_STRATEGY) != Z_OK) {
9956c95142eSMartin Matuska archive_set_error(&a->archive, ENOMEM,
9966c95142eSMartin Matuska "Can't init deflate compressor");
997caf54c4fSMartin Matuska return (ARCHIVE_FATAL);
998caf54c4fSMartin Matuska }
999cdf63a70SMartin Matuska }
1000caf54c4fSMartin Matuska #endif
1001caf54c4fSMartin Matuska
10026c95142eSMartin Matuska return (ret2);
1003caf54c4fSMartin Matuska }
1004caf54c4fSMartin Matuska
1005caf54c4fSMartin Matuska static ssize_t
archive_write_zip_data(struct archive_write * a,const void * buff,size_t s)1006caf54c4fSMartin Matuska archive_write_zip_data(struct archive_write *a, const void *buff, size_t s)
1007caf54c4fSMartin Matuska {
1008caf54c4fSMartin Matuska int ret;
1009caf54c4fSMartin Matuska struct zip *zip = a->format_data;
1010caf54c4fSMartin Matuska
1011cdf63a70SMartin Matuska if ((int64_t)s > zip->entry_uncompressed_limit)
1012cdf63a70SMartin Matuska s = (size_t)zip->entry_uncompressed_limit;
1013cdf63a70SMartin Matuska zip->entry_uncompressed_written += s;
1014caf54c4fSMartin Matuska
1015caf54c4fSMartin Matuska if (s == 0) return 0;
1016caf54c4fSMartin Matuska
1017cdf63a70SMartin Matuska if (zip->entry_flags & ZIP_ENTRY_FLAG_ENCRYPTED) {
1018cdf63a70SMartin Matuska switch (zip->entry_encryption) {
1019cdf63a70SMartin Matuska case ENCRYPTION_TRADITIONAL:
10202dbf8c4aSMartin Matuska /* Initialize traditional PKWARE encryption context. */
1021cdf63a70SMartin Matuska if (!zip->tctx_valid) {
1022cdf63a70SMartin Matuska ret = init_traditional_pkware_encryption(a);
1023cdf63a70SMartin Matuska if (ret != ARCHIVE_OK)
1024cdf63a70SMartin Matuska return (ret);
1025cdf63a70SMartin Matuska zip->tctx_valid = 1;
1026cdf63a70SMartin Matuska }
1027cdf63a70SMartin Matuska break;
1028cdf63a70SMartin Matuska case ENCRYPTION_WINZIP_AES128:
1029cdf63a70SMartin Matuska case ENCRYPTION_WINZIP_AES256:
1030cdf63a70SMartin Matuska if (!zip->cctx_valid) {
1031cdf63a70SMartin Matuska ret = init_winzip_aes_encryption(a);
1032cdf63a70SMartin Matuska if (ret != ARCHIVE_OK)
1033cdf63a70SMartin Matuska return (ret);
1034cdf63a70SMartin Matuska zip->cctx_valid = zip->hctx_valid = 1;
1035cdf63a70SMartin Matuska }
1036cdf63a70SMartin Matuska break;
1037c3afd20fSMartin Matuska case ENCRYPTION_NONE:
1038cdf63a70SMartin Matuska default:
1039cdf63a70SMartin Matuska break;
1040cdf63a70SMartin Matuska }
1041cdf63a70SMartin Matuska }
1042cdf63a70SMartin Matuska
1043cdf63a70SMartin Matuska switch (zip->entry_compression) {
1044caf54c4fSMartin Matuska case COMPRESSION_STORE:
1045cdf63a70SMartin Matuska if (zip->tctx_valid || zip->cctx_valid) {
1046cdf63a70SMartin Matuska const uint8_t *rb = (const uint8_t *)buff;
1047cdf63a70SMartin Matuska const uint8_t * const re = rb + s;
1048cdf63a70SMartin Matuska
1049cdf63a70SMartin Matuska while (rb < re) {
1050cdf63a70SMartin Matuska size_t l;
1051cdf63a70SMartin Matuska
1052cdf63a70SMartin Matuska if (zip->tctx_valid) {
1053cdf63a70SMartin Matuska l = trad_enc_encrypt_update(&zip->tctx,
1054cdf63a70SMartin Matuska rb, re - rb,
1055cdf63a70SMartin Matuska zip->buf, zip->len_buf);
1056cdf63a70SMartin Matuska } else {
1057cdf63a70SMartin Matuska l = zip->len_buf;
1058cdf63a70SMartin Matuska ret = archive_encrypto_aes_ctr_update(
1059cdf63a70SMartin Matuska &zip->cctx,
1060cdf63a70SMartin Matuska rb, re - rb, zip->buf, &l);
1061cdf63a70SMartin Matuska if (ret < 0) {
1062cdf63a70SMartin Matuska archive_set_error(&a->archive,
1063cdf63a70SMartin Matuska ARCHIVE_ERRNO_MISC,
1064cdf63a70SMartin Matuska "Failed to encrypt file");
1065cdf63a70SMartin Matuska return (ARCHIVE_FAILED);
1066cdf63a70SMartin Matuska }
1067cdf63a70SMartin Matuska archive_hmac_sha1_update(&zip->hctx,
1068cdf63a70SMartin Matuska zip->buf, l);
1069cdf63a70SMartin Matuska }
1070cdf63a70SMartin Matuska ret = __archive_write_output(a, zip->buf, l);
1071cdf63a70SMartin Matuska if (ret != ARCHIVE_OK)
1072cdf63a70SMartin Matuska return (ret);
1073cdf63a70SMartin Matuska zip->entry_compressed_written += l;
1074cdf63a70SMartin Matuska zip->written_bytes += l;
1075cdf63a70SMartin Matuska rb += l;
1076cdf63a70SMartin Matuska }
1077cdf63a70SMartin Matuska } else {
10786c95142eSMartin Matuska ret = __archive_write_output(a, buff, s);
1079cdf63a70SMartin Matuska if (ret != ARCHIVE_OK)
1080cdf63a70SMartin Matuska return (ret);
1081caf54c4fSMartin Matuska zip->written_bytes += s;
1082cdf63a70SMartin Matuska zip->entry_compressed_written += s;
1083cdf63a70SMartin Matuska }
1084cdf63a70SMartin Matuska break;
1085caf54c4fSMartin Matuska #if HAVE_ZLIB_H
1086caf54c4fSMartin Matuska case COMPRESSION_DEFLATE:
1087caf54c4fSMartin Matuska zip->stream.next_in = (unsigned char*)(uintptr_t)buff;
1088acc60b03SMartin Matuska zip->stream.avail_in = (uInt)s;
1089caf54c4fSMartin Matuska do {
1090caf54c4fSMartin Matuska ret = deflate(&zip->stream, Z_NO_FLUSH);
1091caf54c4fSMartin Matuska if (ret == Z_STREAM_ERROR)
1092caf54c4fSMartin Matuska return (ARCHIVE_FATAL);
1093caf54c4fSMartin Matuska if (zip->stream.avail_out == 0) {
1094cdf63a70SMartin Matuska if (zip->tctx_valid) {
1095cdf63a70SMartin Matuska trad_enc_encrypt_update(&zip->tctx,
1096cdf63a70SMartin Matuska zip->buf, zip->len_buf,
1097cdf63a70SMartin Matuska zip->buf, zip->len_buf);
1098cdf63a70SMartin Matuska } else if (zip->cctx_valid) {
1099cdf63a70SMartin Matuska size_t outl = zip->len_buf;
1100cdf63a70SMartin Matuska ret = archive_encrypto_aes_ctr_update(
1101cdf63a70SMartin Matuska &zip->cctx,
1102cdf63a70SMartin Matuska zip->buf, zip->len_buf,
1103cdf63a70SMartin Matuska zip->buf, &outl);
1104cdf63a70SMartin Matuska if (ret < 0) {
1105cdf63a70SMartin Matuska archive_set_error(&a->archive,
1106cdf63a70SMartin Matuska ARCHIVE_ERRNO_MISC,
1107cdf63a70SMartin Matuska "Failed to encrypt file");
1108cdf63a70SMartin Matuska return (ARCHIVE_FAILED);
1109cdf63a70SMartin Matuska }
1110cdf63a70SMartin Matuska archive_hmac_sha1_update(&zip->hctx,
1111cdf63a70SMartin Matuska zip->buf, zip->len_buf);
1112cdf63a70SMartin Matuska }
11136c95142eSMartin Matuska ret = __archive_write_output(a, zip->buf,
11146c95142eSMartin Matuska zip->len_buf);
1115caf54c4fSMartin Matuska if (ret != ARCHIVE_OK)
1116caf54c4fSMartin Matuska return (ret);
1117cdf63a70SMartin Matuska zip->entry_compressed_written += zip->len_buf;
1118caf54c4fSMartin Matuska zip->written_bytes += zip->len_buf;
1119caf54c4fSMartin Matuska zip->stream.next_out = zip->buf;
1120acc60b03SMartin Matuska zip->stream.avail_out = (uInt)zip->len_buf;
1121caf54c4fSMartin Matuska }
1122caf54c4fSMartin Matuska } while (zip->stream.avail_in != 0);
1123cdf63a70SMartin Matuska break;
1124caf54c4fSMartin Matuska #endif
1125caf54c4fSMartin Matuska
1126c3afd20fSMartin Matuska case COMPRESSION_UNSPECIFIED:
1127caf54c4fSMartin Matuska default:
1128caf54c4fSMartin Matuska archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1129caf54c4fSMartin Matuska "Invalid ZIP compression type");
1130caf54c4fSMartin Matuska return ARCHIVE_FATAL;
1131caf54c4fSMartin Matuska }
1132cdf63a70SMartin Matuska
1133cdf63a70SMartin Matuska zip->entry_uncompressed_limit -= s;
1134cdf63a70SMartin Matuska if (!zip->cctx_valid || zip->aes_vendor != AES_VENDOR_AE_2)
1135cdf63a70SMartin Matuska zip->entry_crc32 =
1136cdf63a70SMartin Matuska zip->crc32func(zip->entry_crc32, buff, (unsigned)s);
1137cdf63a70SMartin Matuska return (s);
1138cdf63a70SMartin Matuska
1139caf54c4fSMartin Matuska }
1140caf54c4fSMartin Matuska
1141caf54c4fSMartin Matuska static int
archive_write_zip_finish_entry(struct archive_write * a)1142caf54c4fSMartin Matuska archive_write_zip_finish_entry(struct archive_write *a)
1143caf54c4fSMartin Matuska {
1144caf54c4fSMartin Matuska struct zip *zip = a->format_data;
1145cdf63a70SMartin Matuska int ret;
1146caf54c4fSMartin Matuska
1147caf54c4fSMartin Matuska #if HAVE_ZLIB_H
1148cdf63a70SMartin Matuska if (zip->entry_compression == COMPRESSION_DEFLATE) {
1149caf54c4fSMartin Matuska for (;;) {
1150cdf63a70SMartin Matuska size_t remainder;
1151cdf63a70SMartin Matuska
1152caf54c4fSMartin Matuska ret = deflate(&zip->stream, Z_FINISH);
1153caf54c4fSMartin Matuska if (ret == Z_STREAM_ERROR)
1154caf54c4fSMartin Matuska return (ARCHIVE_FATAL);
1155cdf63a70SMartin Matuska remainder = zip->len_buf - zip->stream.avail_out;
1156cdf63a70SMartin Matuska if (zip->tctx_valid) {
1157cdf63a70SMartin Matuska trad_enc_encrypt_update(&zip->tctx,
1158cdf63a70SMartin Matuska zip->buf, remainder, zip->buf, remainder);
1159cdf63a70SMartin Matuska } else if (zip->cctx_valid) {
1160cdf63a70SMartin Matuska size_t outl = remainder;
1161cdf63a70SMartin Matuska ret = archive_encrypto_aes_ctr_update(
1162cdf63a70SMartin Matuska &zip->cctx, zip->buf, remainder,
1163cdf63a70SMartin Matuska zip->buf, &outl);
1164cdf63a70SMartin Matuska if (ret < 0) {
1165cdf63a70SMartin Matuska archive_set_error(&a->archive,
1166cdf63a70SMartin Matuska ARCHIVE_ERRNO_MISC,
1167cdf63a70SMartin Matuska "Failed to encrypt file");
1168cdf63a70SMartin Matuska return (ARCHIVE_FAILED);
1169cdf63a70SMartin Matuska }
1170cdf63a70SMartin Matuska archive_hmac_sha1_update(&zip->hctx,
1171cdf63a70SMartin Matuska zip->buf, remainder);
1172cdf63a70SMartin Matuska }
1173cdf63a70SMartin Matuska ret = __archive_write_output(a, zip->buf, remainder);
1174caf54c4fSMartin Matuska if (ret != ARCHIVE_OK)
1175caf54c4fSMartin Matuska return (ret);
1176cdf63a70SMartin Matuska zip->entry_compressed_written += remainder;
1177cdf63a70SMartin Matuska zip->written_bytes += remainder;
1178caf54c4fSMartin Matuska zip->stream.next_out = zip->buf;
1179caf54c4fSMartin Matuska if (zip->stream.avail_out != 0)
1180caf54c4fSMartin Matuska break;
1181acc60b03SMartin Matuska zip->stream.avail_out = (uInt)zip->len_buf;
1182caf54c4fSMartin Matuska }
1183caf54c4fSMartin Matuska deflateEnd(&zip->stream);
1184cdf63a70SMartin Matuska }
1185caf54c4fSMartin Matuska #endif
1186cdf63a70SMartin Matuska if (zip->hctx_valid) {
1187cdf63a70SMartin Matuska uint8_t hmac[20];
1188cdf63a70SMartin Matuska size_t hmac_len = 20;
1189cdf63a70SMartin Matuska
1190cdf63a70SMartin Matuska archive_hmac_sha1_final(&zip->hctx, hmac, &hmac_len);
1191cdf63a70SMartin Matuska ret = __archive_write_output(a, hmac, AUTH_CODE_SIZE);
1192cdf63a70SMartin Matuska if (ret != ARCHIVE_OK)
1193cdf63a70SMartin Matuska return (ret);
1194cdf63a70SMartin Matuska zip->entry_compressed_written += AUTH_CODE_SIZE;
1195cdf63a70SMartin Matuska zip->written_bytes += AUTH_CODE_SIZE;
1196caf54c4fSMartin Matuska }
1197caf54c4fSMartin Matuska
1198cdf63a70SMartin Matuska /* Write trailing data descriptor. */
1199cdf63a70SMartin Matuska if ((zip->entry_flags & ZIP_ENTRY_FLAG_LENGTH_AT_END) != 0) {
1200cdf63a70SMartin Matuska char d[24];
1201cdf63a70SMartin Matuska memcpy(d, "PK\007\010", 4);
1202cdf63a70SMartin Matuska if (zip->cctx_valid && zip->aes_vendor == AES_VENDOR_AE_2)
1203cdf63a70SMartin Matuska archive_le32enc(d + 4, 0);/* no CRC.*/
1204cdf63a70SMartin Matuska else
1205cdf63a70SMartin Matuska archive_le32enc(d + 4, zip->entry_crc32);
1206b9128a37SMartin Matuska if (zip->entry_compressed_written > ZIP_4GB_MAX
1207b9128a37SMartin Matuska || zip->entry_uncompressed_written > ZIP_4GB_MAX
1208b9128a37SMartin Matuska || zip->flags & ZIP_FLAG_FORCE_ZIP64) {
1209cdf63a70SMartin Matuska archive_le64enc(d + 8,
1210cdf63a70SMartin Matuska (uint64_t)zip->entry_compressed_written);
1211cdf63a70SMartin Matuska archive_le64enc(d + 16,
1212cdf63a70SMartin Matuska (uint64_t)zip->entry_uncompressed_written);
1213cdf63a70SMartin Matuska ret = __archive_write_output(a, d, 24);
1214cdf63a70SMartin Matuska zip->written_bytes += 24;
1215cdf63a70SMartin Matuska } else {
1216cdf63a70SMartin Matuska archive_le32enc(d + 8,
1217cdf63a70SMartin Matuska (uint32_t)zip->entry_compressed_written);
1218cdf63a70SMartin Matuska archive_le32enc(d + 12,
1219cdf63a70SMartin Matuska (uint32_t)zip->entry_uncompressed_written);
1220cdf63a70SMartin Matuska ret = __archive_write_output(a, d, 16);
1221cdf63a70SMartin Matuska zip->written_bytes += 16;
1222cdf63a70SMartin Matuska }
1223caf54c4fSMartin Matuska if (ret != ARCHIVE_OK)
1224caf54c4fSMartin Matuska return (ARCHIVE_FATAL);
1225cdf63a70SMartin Matuska }
1226cdf63a70SMartin Matuska
1227b9128a37SMartin Matuska /* UT timestamp: Info-Zip specifies that _only_ the mtime should
1228b9128a37SMartin Matuska * be recorded here; ctime and atime are also included in the
1229b9128a37SMartin Matuska * local file descriptor. */
1230b9128a37SMartin Matuska if (archive_entry_mtime_is_set(zip->entry)) {
1231b9128a37SMartin Matuska unsigned char ut[9];
1232b9128a37SMartin Matuska unsigned char *u = ut, *ud;
1233b9128a37SMartin Matuska memcpy(u, "UT\005\000\001", 5);
1234b9128a37SMartin Matuska u += 5;
1235b9128a37SMartin Matuska archive_le32enc(u, (uint32_t)archive_entry_mtime(zip->entry));
1236b9128a37SMartin Matuska u += 4;
1237b9128a37SMartin Matuska ud = cd_alloc(zip, u - ut);
1238b9128a37SMartin Matuska if (ud == NULL) {
1239b9128a37SMartin Matuska archive_set_error(&a->archive, ENOMEM,
1240b9128a37SMartin Matuska "Can't allocate zip data");
1241b9128a37SMartin Matuska return (ARCHIVE_FATAL);
1242b9128a37SMartin Matuska }
1243b9128a37SMartin Matuska memcpy(ud, ut, u - ut);
1244b9128a37SMartin Matuska }
1245b9128a37SMartin Matuska
1246b9128a37SMartin Matuska /* Fill in size information in the central directory entry. */
1247b9128a37SMartin Matuska /* Fix up central directory file header. */
1248b9128a37SMartin Matuska if (zip->cctx_valid && zip->aes_vendor == AES_VENDOR_AE_2)
1249b9128a37SMartin Matuska archive_le32enc(zip->file_header + 16, 0);/* no CRC.*/
1250b9128a37SMartin Matuska else
1251b9128a37SMartin Matuska archive_le32enc(zip->file_header + 16, zip->entry_crc32);
1252b9128a37SMartin Matuska /* Truncate to 32 bits; we'll fix up below. */
1253b9128a37SMartin Matuska archive_le32enc(zip->file_header + 20, (uint32_t)zip->entry_compressed_written);
1254b9128a37SMartin Matuska archive_le32enc(zip->file_header + 24, (uint32_t)zip->entry_uncompressed_written);
1255b9128a37SMartin Matuska archive_le16enc(zip->file_header + 30,
1256b9128a37SMartin Matuska (uint16_t)(zip->central_directory_bytes - zip->file_header_extra_offset));
1257b9128a37SMartin Matuska archive_le32enc(zip->file_header + 42, (uint32_t)zip->entry_offset);
1258b9128a37SMartin Matuska
1259b9128a37SMartin Matuska /* If any of the values immediately above are too large, we'll
1260b9128a37SMartin Matuska * need to put the corresponding value in a Zip64 extra field
1261b9128a37SMartin Matuska * and set the central directory value to 0xffffffff as a flag. */
1262b9128a37SMartin Matuska if (zip->entry_compressed_written >= ZIP_4GB_MAX
1263b9128a37SMartin Matuska || zip->entry_uncompressed_written >= ZIP_4GB_MAX
1264cdf63a70SMartin Matuska || zip->entry_offset > ZIP_4GB_MAX) {
1265cdf63a70SMartin Matuska unsigned char zip64[32];
1266cdf63a70SMartin Matuska unsigned char *z = zip64, *zd;
1267cdf63a70SMartin Matuska memcpy(z, "\001\000\000\000", 4);
1268cdf63a70SMartin Matuska z += 4;
1269cdf63a70SMartin Matuska if (zip->entry_uncompressed_written >= ZIP_4GB_MAX) {
1270b9128a37SMartin Matuska archive_le32enc(zip->file_header + 24, ZIP_4GB_MAX);
1271cdf63a70SMartin Matuska archive_le64enc(z, zip->entry_uncompressed_written);
1272cdf63a70SMartin Matuska z += 8;
1273cdf63a70SMartin Matuska }
1274cdf63a70SMartin Matuska if (zip->entry_compressed_written >= ZIP_4GB_MAX) {
1275b9128a37SMartin Matuska archive_le32enc(zip->file_header + 20, ZIP_4GB_MAX);
1276cdf63a70SMartin Matuska archive_le64enc(z, zip->entry_compressed_written);
1277cdf63a70SMartin Matuska z += 8;
1278cdf63a70SMartin Matuska }
1279cdf63a70SMartin Matuska if (zip->entry_offset >= ZIP_4GB_MAX) {
1280b9128a37SMartin Matuska archive_le32enc(zip->file_header + 42, ZIP_4GB_MAX);
1281cdf63a70SMartin Matuska archive_le64enc(z, zip->entry_offset);
1282cdf63a70SMartin Matuska z += 8;
1283cdf63a70SMartin Matuska }
1284cdf63a70SMartin Matuska archive_le16enc(zip64 + 2, (uint16_t)(z - (zip64 + 4)));
1285cdf63a70SMartin Matuska zd = cd_alloc(zip, z - zip64);
1286cdf63a70SMartin Matuska if (zd == NULL) {
1287cdf63a70SMartin Matuska archive_set_error(&a->archive, ENOMEM,
1288cdf63a70SMartin Matuska "Can't allocate zip data");
1289cdf63a70SMartin Matuska return (ARCHIVE_FATAL);
1290cdf63a70SMartin Matuska }
1291cdf63a70SMartin Matuska memcpy(zd, zip64, z - zip64);
1292cdf63a70SMartin Matuska /* Zip64 means version needs to be set to at least 4.5 */
1293cdf63a70SMartin Matuska if (archive_le16dec(zip->file_header + 6) < 45)
1294cdf63a70SMartin Matuska archive_le16enc(zip->file_header + 6, 45);
1295cdf63a70SMartin Matuska }
1296cdf63a70SMartin Matuska
1297cdf63a70SMartin Matuska /* Fix up central directory file header. */
1298cdf63a70SMartin Matuska if (zip->cctx_valid && zip->aes_vendor == AES_VENDOR_AE_2)
1299cdf63a70SMartin Matuska archive_le32enc(zip->file_header + 16, 0);/* no CRC.*/
1300cdf63a70SMartin Matuska else
1301cdf63a70SMartin Matuska archive_le32enc(zip->file_header + 16, zip->entry_crc32);
1302cdf63a70SMartin Matuska archive_le32enc(zip->file_header + 20,
1303cdf63a70SMartin Matuska (uint32_t)zipmin(zip->entry_compressed_written,
1304cdf63a70SMartin Matuska ZIP_4GB_MAX));
1305cdf63a70SMartin Matuska archive_le32enc(zip->file_header + 24,
1306cdf63a70SMartin Matuska (uint32_t)zipmin(zip->entry_uncompressed_written,
1307cdf63a70SMartin Matuska ZIP_4GB_MAX));
1308cdf63a70SMartin Matuska archive_le16enc(zip->file_header + 30,
1309cdf63a70SMartin Matuska (uint16_t)(zip->central_directory_bytes - zip->file_header_extra_offset));
1310cdf63a70SMartin Matuska archive_le32enc(zip->file_header + 42,
1311cdf63a70SMartin Matuska (uint32_t)zipmin(zip->entry_offset,
1312cdf63a70SMartin Matuska ZIP_4GB_MAX));
1313cdf63a70SMartin Matuska
1314caf54c4fSMartin Matuska return (ARCHIVE_OK);
1315caf54c4fSMartin Matuska }
1316caf54c4fSMartin Matuska
1317caf54c4fSMartin Matuska static int
archive_write_zip_close(struct archive_write * a)13186c95142eSMartin Matuska archive_write_zip_close(struct archive_write *a)
1319caf54c4fSMartin Matuska {
1320cdf63a70SMartin Matuska uint8_t buff[64];
13216c95142eSMartin Matuska int64_t offset_start, offset_end;
1322cdf63a70SMartin Matuska struct zip *zip = a->format_data;
1323cdf63a70SMartin Matuska struct cd_segment *segment;
1324caf54c4fSMartin Matuska int ret;
1325caf54c4fSMartin Matuska
1326caf54c4fSMartin Matuska offset_start = zip->written_bytes;
1327cdf63a70SMartin Matuska segment = zip->central_directory;
1328cdf63a70SMartin Matuska while (segment != NULL) {
1329cdf63a70SMartin Matuska ret = __archive_write_output(a,
1330cdf63a70SMartin Matuska segment->buff, segment->p - segment->buff);
1331caf54c4fSMartin Matuska if (ret != ARCHIVE_OK)
1332caf54c4fSMartin Matuska return (ARCHIVE_FATAL);
1333cdf63a70SMartin Matuska zip->written_bytes += segment->p - segment->buff;
1334cdf63a70SMartin Matuska segment = segment->next;
1335caf54c4fSMartin Matuska }
1336caf54c4fSMartin Matuska offset_end = zip->written_bytes;
1337caf54c4fSMartin Matuska
1338cdf63a70SMartin Matuska /* If central dir info is too large, write Zip64 end-of-cd */
1339cdf63a70SMartin Matuska if (offset_end - offset_start > ZIP_4GB_MAX
1340cdf63a70SMartin Matuska || offset_start > ZIP_4GB_MAX
1341cdf63a70SMartin Matuska || zip->central_directory_entries > 0xffffUL
1342cdf63a70SMartin Matuska || (zip->flags & ZIP_FLAG_FORCE_ZIP64)) {
1343cdf63a70SMartin Matuska /* Zip64 end-of-cd record */
1344cdf63a70SMartin Matuska memset(buff, 0, 56);
1345cdf63a70SMartin Matuska memcpy(buff, "PK\006\006", 4);
1346cdf63a70SMartin Matuska archive_le64enc(buff + 4, 44);
1347cdf63a70SMartin Matuska archive_le16enc(buff + 12, 45);
1348cdf63a70SMartin Matuska archive_le16enc(buff + 14, 45);
1349cdf63a70SMartin Matuska /* This is disk 0 of 0. */
1350cdf63a70SMartin Matuska archive_le64enc(buff + 24, zip->central_directory_entries);
1351cdf63a70SMartin Matuska archive_le64enc(buff + 32, zip->central_directory_entries);
1352cdf63a70SMartin Matuska archive_le64enc(buff + 40, offset_end - offset_start);
1353cdf63a70SMartin Matuska archive_le64enc(buff + 48, offset_start);
1354cdf63a70SMartin Matuska ret = __archive_write_output(a, buff, 56);
1355caf54c4fSMartin Matuska if (ret != ARCHIVE_OK)
1356caf54c4fSMartin Matuska return (ARCHIVE_FATAL);
1357cdf63a70SMartin Matuska zip->written_bytes += 56;
1358cdf63a70SMartin Matuska
1359cdf63a70SMartin Matuska /* Zip64 end-of-cd locator record. */
1360cdf63a70SMartin Matuska memset(buff, 0, 20);
1361cdf63a70SMartin Matuska memcpy(buff, "PK\006\007", 4);
1362cdf63a70SMartin Matuska archive_le32enc(buff + 4, 0);
1363cdf63a70SMartin Matuska archive_le64enc(buff + 8, offset_end);
1364cdf63a70SMartin Matuska archive_le32enc(buff + 16, 1);
1365cdf63a70SMartin Matuska ret = __archive_write_output(a, buff, 20);
1366cdf63a70SMartin Matuska if (ret != ARCHIVE_OK)
1367cdf63a70SMartin Matuska return (ARCHIVE_FATAL);
1368cdf63a70SMartin Matuska zip->written_bytes += 20;
1369cdf63a70SMartin Matuska
1370cdf63a70SMartin Matuska }
1371cdf63a70SMartin Matuska
1372cdf63a70SMartin Matuska /* Format and write end of central directory. */
1373cdf63a70SMartin Matuska memset(buff, 0, sizeof(buff));
1374cdf63a70SMartin Matuska memcpy(buff, "PK\005\006", 4);
1375cdf63a70SMartin Matuska archive_le16enc(buff + 8, (uint16_t)zipmin(0xffffU,
1376cdf63a70SMartin Matuska zip->central_directory_entries));
1377cdf63a70SMartin Matuska archive_le16enc(buff + 10, (uint16_t)zipmin(0xffffU,
1378cdf63a70SMartin Matuska zip->central_directory_entries));
1379cdf63a70SMartin Matuska archive_le32enc(buff + 12,
1380cdf63a70SMartin Matuska (uint32_t)zipmin(ZIP_4GB_MAX, (offset_end - offset_start)));
1381cdf63a70SMartin Matuska archive_le32enc(buff + 16,
1382cdf63a70SMartin Matuska (uint32_t)zipmin(ZIP_4GB_MAX, offset_start));
1383cdf63a70SMartin Matuska ret = __archive_write_output(a, buff, 22);
1384cdf63a70SMartin Matuska if (ret != ARCHIVE_OK)
1385cdf63a70SMartin Matuska return (ARCHIVE_FATAL);
1386cdf63a70SMartin Matuska zip->written_bytes += 22;
1387caf54c4fSMartin Matuska return (ARCHIVE_OK);
1388caf54c4fSMartin Matuska }
1389caf54c4fSMartin Matuska
1390caf54c4fSMartin Matuska static int
archive_write_zip_free(struct archive_write * a)13916c95142eSMartin Matuska archive_write_zip_free(struct archive_write *a)
1392caf54c4fSMartin Matuska {
1393caf54c4fSMartin Matuska struct zip *zip;
1394cdf63a70SMartin Matuska struct cd_segment *segment;
1395caf54c4fSMartin Matuska
1396caf54c4fSMartin Matuska zip = a->format_data;
1397caf54c4fSMartin Matuska while (zip->central_directory != NULL) {
1398cdf63a70SMartin Matuska segment = zip->central_directory;
1399cdf63a70SMartin Matuska zip->central_directory = segment->next;
1400cdf63a70SMartin Matuska free(segment->buff);
1401cdf63a70SMartin Matuska free(segment);
1402caf54c4fSMartin Matuska }
1403caf54c4fSMartin Matuska free(zip->buf);
1404cdf63a70SMartin Matuska archive_entry_free(zip->entry);
1405cdf63a70SMartin Matuska if (zip->cctx_valid)
1406cdf63a70SMartin Matuska archive_encrypto_aes_ctr_release(&zip->cctx);
1407cdf63a70SMartin Matuska if (zip->hctx_valid)
1408cdf63a70SMartin Matuska archive_hmac_sha1_cleanup(&zip->hctx);
1409cdf63a70SMartin Matuska /* TODO: Free opt_sconv, sconv_default */
1410cdf63a70SMartin Matuska
1411caf54c4fSMartin Matuska free(zip);
1412caf54c4fSMartin Matuska a->format_data = NULL;
1413caf54c4fSMartin Matuska return (ARCHIVE_OK);
1414caf54c4fSMartin Matuska }
1415caf54c4fSMartin Matuska
1416caf54c4fSMartin Matuska /* Convert into MSDOS-style date/time. */
1417caf54c4fSMartin Matuska static unsigned int
dos_time(const time_t unix_time)1418caf54c4fSMartin Matuska dos_time(const time_t unix_time)
1419caf54c4fSMartin Matuska {
1420caf54c4fSMartin Matuska struct tm *t;
1421caf54c4fSMartin Matuska unsigned int dt;
1422e64fe029SMartin Matuska #if defined(HAVE_LOCALTIME_R) || defined(HAVE_LOCALTIME_S)
1423f9762417SMartin Matuska struct tm tmbuf;
1424f9762417SMartin Matuska #endif
1425caf54c4fSMartin Matuska
1426e64fe029SMartin Matuska #if defined(HAVE_LOCALTIME_S)
1427e64fe029SMartin Matuska t = localtime_s(&tmbuf, &unix_time) ? NULL : &tmbuf;
1428e64fe029SMartin Matuska #elif defined(HAVE_LOCALTIME_R)
1429f9762417SMartin Matuska t = localtime_r(&unix_time, &tmbuf);
1430f9762417SMartin Matuska #else
1431caf54c4fSMartin Matuska t = localtime(&unix_time);
1432f9762417SMartin Matuska #endif
1433caf54c4fSMartin Matuska
14346c95142eSMartin Matuska /* MSDOS-style date/time is only between 1980-01-01 and 2107-12-31 */
14356c95142eSMartin Matuska if (t->tm_year < 1980 - 1900)
14366c95142eSMartin Matuska /* Set minimum date/time '1980-01-01 00:00:00'. */
14376c95142eSMartin Matuska dt = 0x00210000U;
14386c95142eSMartin Matuska else if (t->tm_year > 2107 - 1900)
14396c95142eSMartin Matuska /* Set maximum date/time '2107-12-31 23:59:58'. */
14406c95142eSMartin Matuska dt = 0xff9fbf7dU;
14416c95142eSMartin Matuska else {
1442caf54c4fSMartin Matuska dt = 0;
1443caf54c4fSMartin Matuska dt += ((t->tm_year - 80) & 0x7f) << 9;
1444caf54c4fSMartin Matuska dt += ((t->tm_mon + 1) & 0x0f) << 5;
1445caf54c4fSMartin Matuska dt += (t->tm_mday & 0x1f);
1446caf54c4fSMartin Matuska dt <<= 16;
1447caf54c4fSMartin Matuska dt += (t->tm_hour & 0x1f) << 11;
1448caf54c4fSMartin Matuska dt += (t->tm_min & 0x3f) << 5;
1449caf54c4fSMartin Matuska dt += (t->tm_sec & 0x3e) >> 1; /* Only counting every 2 seconds. */
14506c95142eSMartin Matuska }
1451caf54c4fSMartin Matuska return dt;
1452caf54c4fSMartin Matuska }
1453caf54c4fSMartin Matuska
1454caf54c4fSMartin Matuska static size_t
path_length(struct archive_entry * entry)1455caf54c4fSMartin Matuska path_length(struct archive_entry *entry)
1456caf54c4fSMartin Matuska {
1457caf54c4fSMartin Matuska mode_t type;
1458caf54c4fSMartin Matuska const char *path;
145979085fd3SMartin Matuska size_t len;
1460caf54c4fSMartin Matuska
1461caf54c4fSMartin Matuska type = archive_entry_filetype(entry);
1462caf54c4fSMartin Matuska path = archive_entry_pathname(entry);
1463caf54c4fSMartin Matuska
1464acc60b03SMartin Matuska if (path == NULL)
1465acc60b03SMartin Matuska return (0);
146679085fd3SMartin Matuska len = strlen(path);
146779085fd3SMartin Matuska if (type == AE_IFDIR && (path[0] == '\0' || path[len - 1] != '/'))
146879085fd3SMartin Matuska ++len; /* Space for the trailing / */
146979085fd3SMartin Matuska return len;
1470caf54c4fSMartin Matuska }
1471caf54c4fSMartin Matuska
1472caf54c4fSMartin Matuska static int
write_path(struct archive_entry * entry,struct archive_write * archive)1473caf54c4fSMartin Matuska write_path(struct archive_entry *entry, struct archive_write *archive)
1474caf54c4fSMartin Matuska {
1475caf54c4fSMartin Matuska int ret;
1476caf54c4fSMartin Matuska const char *path;
1477caf54c4fSMartin Matuska mode_t type;
1478caf54c4fSMartin Matuska size_t written_bytes;
1479caf54c4fSMartin Matuska
1480caf54c4fSMartin Matuska path = archive_entry_pathname(entry);
1481caf54c4fSMartin Matuska type = archive_entry_filetype(entry);
1482caf54c4fSMartin Matuska written_bytes = 0;
1483caf54c4fSMartin Matuska
1484a39fc08dSMartin Matuska if (path == NULL)
1485a39fc08dSMartin Matuska return (ARCHIVE_FATAL);
1486a39fc08dSMartin Matuska
14876c95142eSMartin Matuska ret = __archive_write_output(archive, path, strlen(path));
1488caf54c4fSMartin Matuska if (ret != ARCHIVE_OK)
1489caf54c4fSMartin Matuska return (ARCHIVE_FATAL);
1490caf54c4fSMartin Matuska written_bytes += strlen(path);
1491caf54c4fSMartin Matuska
1492cdf63a70SMartin Matuska /* Folders are recognized by a trailing slash. */
1493caf54c4fSMartin Matuska if ((type == AE_IFDIR) & (path[strlen(path) - 1] != '/')) {
14946c95142eSMartin Matuska ret = __archive_write_output(archive, "/", 1);
1495caf54c4fSMartin Matuska if (ret != ARCHIVE_OK)
1496caf54c4fSMartin Matuska return (ARCHIVE_FATAL);
1497caf54c4fSMartin Matuska written_bytes += 1;
1498caf54c4fSMartin Matuska }
1499caf54c4fSMartin Matuska
1500caf54c4fSMartin Matuska return ((int)written_bytes);
1501caf54c4fSMartin Matuska }
1502cdf63a70SMartin Matuska
1503cdf63a70SMartin Matuska static void
copy_path(struct archive_entry * entry,unsigned char * p)1504cdf63a70SMartin Matuska copy_path(struct archive_entry *entry, unsigned char *p)
1505cdf63a70SMartin Matuska {
1506cdf63a70SMartin Matuska const char *path;
1507cdf63a70SMartin Matuska size_t pathlen;
1508cdf63a70SMartin Matuska mode_t type;
1509cdf63a70SMartin Matuska
1510cdf63a70SMartin Matuska path = archive_entry_pathname(entry);
1511cdf63a70SMartin Matuska pathlen = strlen(path);
1512cdf63a70SMartin Matuska type = archive_entry_filetype(entry);
1513cdf63a70SMartin Matuska
1514cdf63a70SMartin Matuska memcpy(p, path, pathlen);
1515cdf63a70SMartin Matuska
1516cdf63a70SMartin Matuska /* Folders are recognized by a trailing slash. */
151779085fd3SMartin Matuska if ((type == AE_IFDIR) && (path[pathlen - 1] != '/'))
1518cdf63a70SMartin Matuska p[pathlen] = '/';
1519cdf63a70SMartin Matuska }
1520cdf63a70SMartin Matuska
1521cdf63a70SMartin Matuska
1522cdf63a70SMartin Matuska static struct archive_string_conv *
get_sconv(struct archive_write * a,struct zip * zip)1523cdf63a70SMartin Matuska get_sconv(struct archive_write *a, struct zip *zip)
1524cdf63a70SMartin Matuska {
1525cdf63a70SMartin Matuska if (zip->opt_sconv != NULL)
1526cdf63a70SMartin Matuska return (zip->opt_sconv);
1527cdf63a70SMartin Matuska
1528cdf63a70SMartin Matuska if (!zip->init_default_conversion) {
1529cdf63a70SMartin Matuska zip->sconv_default =
1530cdf63a70SMartin Matuska archive_string_default_conversion_for_write(&(a->archive));
1531cdf63a70SMartin Matuska zip->init_default_conversion = 1;
1532cdf63a70SMartin Matuska }
1533cdf63a70SMartin Matuska return (zip->sconv_default);
1534cdf63a70SMartin Matuska }
1535cdf63a70SMartin Matuska
1536cdf63a70SMartin Matuska /*
1537cdf63a70SMartin Matuska Traditional PKWARE Decryption functions.
1538cdf63a70SMartin Matuska */
1539cdf63a70SMartin Matuska
1540cdf63a70SMartin Matuska static void
trad_enc_update_keys(struct trad_enc_ctx * ctx,uint8_t c)1541cdf63a70SMartin Matuska trad_enc_update_keys(struct trad_enc_ctx *ctx, uint8_t c)
1542cdf63a70SMartin Matuska {
1543cdf63a70SMartin Matuska uint8_t t;
1544cdf63a70SMartin Matuska #define CRC32(c, b) (crc32(c ^ 0xffffffffUL, &b, 1) ^ 0xffffffffUL)
1545cdf63a70SMartin Matuska
1546cdf63a70SMartin Matuska ctx->keys[0] = CRC32(ctx->keys[0], c);
1547cdf63a70SMartin Matuska ctx->keys[1] = (ctx->keys[1] + (ctx->keys[0] & 0xff)) * 134775813L + 1;
1548cdf63a70SMartin Matuska t = (ctx->keys[1] >> 24) & 0xff;
1549cdf63a70SMartin Matuska ctx->keys[2] = CRC32(ctx->keys[2], t);
1550cdf63a70SMartin Matuska #undef CRC32
1551cdf63a70SMartin Matuska }
1552cdf63a70SMartin Matuska
1553cdf63a70SMartin Matuska static uint8_t
trad_enc_decrypt_byte(struct trad_enc_ctx * ctx)15542dbf8c4aSMartin Matuska trad_enc_decrypt_byte(struct trad_enc_ctx *ctx)
1555cdf63a70SMartin Matuska {
1556cdf63a70SMartin Matuska unsigned temp = ctx->keys[2] | 2;
1557cdf63a70SMartin Matuska return (uint8_t)((temp * (temp ^ 1)) >> 8) & 0xff;
1558cdf63a70SMartin Matuska }
1559cdf63a70SMartin Matuska
1560cdf63a70SMartin Matuska static unsigned
trad_enc_encrypt_update(struct trad_enc_ctx * ctx,const uint8_t * in,size_t in_len,uint8_t * out,size_t out_len)1561cdf63a70SMartin Matuska trad_enc_encrypt_update(struct trad_enc_ctx *ctx, const uint8_t *in,
1562cdf63a70SMartin Matuska size_t in_len, uint8_t *out, size_t out_len)
1563cdf63a70SMartin Matuska {
1564cdf63a70SMartin Matuska unsigned i, max;
1565cdf63a70SMartin Matuska
1566cdf63a70SMartin Matuska max = (unsigned)((in_len < out_len)? in_len: out_len);
1567cdf63a70SMartin Matuska
1568cdf63a70SMartin Matuska for (i = 0; i < max; i++) {
1569cdf63a70SMartin Matuska uint8_t t = in[i];
15702dbf8c4aSMartin Matuska out[i] = t ^ trad_enc_decrypt_byte(ctx);
1571cdf63a70SMartin Matuska trad_enc_update_keys(ctx, t);
1572cdf63a70SMartin Matuska }
1573cdf63a70SMartin Matuska return i;
1574cdf63a70SMartin Matuska }
1575cdf63a70SMartin Matuska
1576cdf63a70SMartin Matuska static int
trad_enc_init(struct trad_enc_ctx * ctx,const char * pw,size_t pw_len)1577cdf63a70SMartin Matuska trad_enc_init(struct trad_enc_ctx *ctx, const char *pw, size_t pw_len)
1578cdf63a70SMartin Matuska {
1579cdf63a70SMartin Matuska
1580cdf63a70SMartin Matuska ctx->keys[0] = 305419896L;
1581cdf63a70SMartin Matuska ctx->keys[1] = 591751049L;
1582cdf63a70SMartin Matuska ctx->keys[2] = 878082192L;
1583cdf63a70SMartin Matuska
1584cdf63a70SMartin Matuska for (;pw_len; --pw_len)
1585cdf63a70SMartin Matuska trad_enc_update_keys(ctx, *pw++);
1586cdf63a70SMartin Matuska return 0;
1587cdf63a70SMartin Matuska }
1588cdf63a70SMartin Matuska
1589cdf63a70SMartin Matuska static int
is_traditional_pkware_encryption_supported(void)1590cdf63a70SMartin Matuska is_traditional_pkware_encryption_supported(void)
1591cdf63a70SMartin Matuska {
1592cdf63a70SMartin Matuska uint8_t key[TRAD_HEADER_SIZE];
1593cdf63a70SMartin Matuska
1594cdf63a70SMartin Matuska if (archive_random(key, sizeof(key)-1) != ARCHIVE_OK)
1595cdf63a70SMartin Matuska return (0);
1596cdf63a70SMartin Matuska return (1);
1597cdf63a70SMartin Matuska }
1598cdf63a70SMartin Matuska
1599cdf63a70SMartin Matuska static int
init_traditional_pkware_encryption(struct archive_write * a)1600cdf63a70SMartin Matuska init_traditional_pkware_encryption(struct archive_write *a)
1601cdf63a70SMartin Matuska {
1602cdf63a70SMartin Matuska struct zip *zip = a->format_data;
1603cdf63a70SMartin Matuska const char *passphrase;
1604cdf63a70SMartin Matuska uint8_t key[TRAD_HEADER_SIZE];
1605cdf63a70SMartin Matuska uint8_t key_encrypted[TRAD_HEADER_SIZE];
1606cdf63a70SMartin Matuska int ret;
1607cdf63a70SMartin Matuska
1608cdf63a70SMartin Matuska passphrase = __archive_write_get_passphrase(a);
1609cdf63a70SMartin Matuska if (passphrase == NULL) {
1610cdf63a70SMartin Matuska archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1611cdf63a70SMartin Matuska "Encryption needs passphrase");
1612cdf63a70SMartin Matuska return ARCHIVE_FAILED;
1613cdf63a70SMartin Matuska }
1614cdf63a70SMartin Matuska if (archive_random(key, sizeof(key)-1) != ARCHIVE_OK) {
1615cdf63a70SMartin Matuska archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1616cdf63a70SMartin Matuska "Can't generate random number for encryption");
1617cdf63a70SMartin Matuska return ARCHIVE_FATAL;
1618cdf63a70SMartin Matuska }
1619cdf63a70SMartin Matuska trad_enc_init(&zip->tctx, passphrase, strlen(passphrase));
1620cdf63a70SMartin Matuska /* Set the last key code which will be used as a check code
1621cdf63a70SMartin Matuska * for verifying passphrase in decryption. */
1622cdf63a70SMartin Matuska key[TRAD_HEADER_SIZE-1] = zip->trad_chkdat;
1623cdf63a70SMartin Matuska trad_enc_encrypt_update(&zip->tctx, key, TRAD_HEADER_SIZE,
1624cdf63a70SMartin Matuska key_encrypted, TRAD_HEADER_SIZE);
1625cdf63a70SMartin Matuska /* Write encrypted keys in the top of the file content. */
1626cdf63a70SMartin Matuska ret = __archive_write_output(a, key_encrypted, TRAD_HEADER_SIZE);
1627cdf63a70SMartin Matuska if (ret != ARCHIVE_OK)
1628cdf63a70SMartin Matuska return (ret);
1629cdf63a70SMartin Matuska zip->written_bytes += TRAD_HEADER_SIZE;
1630cdf63a70SMartin Matuska zip->entry_compressed_written += TRAD_HEADER_SIZE;
1631cdf63a70SMartin Matuska return (ret);
1632cdf63a70SMartin Matuska }
1633cdf63a70SMartin Matuska
1634cdf63a70SMartin Matuska static int
init_winzip_aes_encryption(struct archive_write * a)1635cdf63a70SMartin Matuska init_winzip_aes_encryption(struct archive_write *a)
1636cdf63a70SMartin Matuska {
1637cdf63a70SMartin Matuska struct zip *zip = a->format_data;
1638cdf63a70SMartin Matuska const char *passphrase;
1639cdf63a70SMartin Matuska size_t key_len, salt_len;
1640cdf63a70SMartin Matuska uint8_t salt[16 + 2];
1641cdf63a70SMartin Matuska uint8_t derived_key[MAX_DERIVED_KEY_BUF_SIZE];
1642cdf63a70SMartin Matuska int ret;
1643cdf63a70SMartin Matuska
1644cdf63a70SMartin Matuska passphrase = __archive_write_get_passphrase(a);
1645cdf63a70SMartin Matuska if (passphrase == NULL) {
1646cdf63a70SMartin Matuska archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1647cdf63a70SMartin Matuska "Encryption needs passphrase");
1648cdf63a70SMartin Matuska return (ARCHIVE_FAILED);
1649cdf63a70SMartin Matuska }
1650cdf63a70SMartin Matuska if (zip->entry_encryption == ENCRYPTION_WINZIP_AES128) {
1651cdf63a70SMartin Matuska salt_len = 8;
1652cdf63a70SMartin Matuska key_len = 16;
1653cdf63a70SMartin Matuska } else {
1654cdf63a70SMartin Matuska /* AES 256 */
1655cdf63a70SMartin Matuska salt_len = 16;
1656cdf63a70SMartin Matuska key_len = 32;
1657cdf63a70SMartin Matuska }
1658cdf63a70SMartin Matuska if (archive_random(salt, salt_len) != ARCHIVE_OK) {
1659cdf63a70SMartin Matuska archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1660cdf63a70SMartin Matuska "Can't generate random number for encryption");
1661cdf63a70SMartin Matuska return (ARCHIVE_FATAL);
1662cdf63a70SMartin Matuska }
1663cdf63a70SMartin Matuska archive_pbkdf2_sha1(passphrase, strlen(passphrase),
1664cdf63a70SMartin Matuska salt, salt_len, 1000, derived_key, key_len * 2 + 2);
1665cdf63a70SMartin Matuska
1666cdf63a70SMartin Matuska ret = archive_encrypto_aes_ctr_init(&zip->cctx, derived_key, key_len);
1667cdf63a70SMartin Matuska if (ret != 0) {
1668cdf63a70SMartin Matuska archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1669cdf63a70SMartin Matuska "Decryption is unsupported due to lack of crypto library");
1670cdf63a70SMartin Matuska return (ARCHIVE_FAILED);
1671cdf63a70SMartin Matuska }
1672cdf63a70SMartin Matuska ret = archive_hmac_sha1_init(&zip->hctx, derived_key + key_len,
1673cdf63a70SMartin Matuska key_len);
1674cdf63a70SMartin Matuska if (ret != 0) {
1675cdf63a70SMartin Matuska archive_encrypto_aes_ctr_release(&zip->cctx);
1676cdf63a70SMartin Matuska archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1677cdf63a70SMartin Matuska "Failed to initialize HMAC-SHA1");
1678cdf63a70SMartin Matuska return (ARCHIVE_FAILED);
1679cdf63a70SMartin Matuska }
1680cdf63a70SMartin Matuska
16812dbf8c4aSMartin Matuska /* Set a password verification value after the 'salt'. */
1682cdf63a70SMartin Matuska salt[salt_len] = derived_key[key_len * 2];
1683cdf63a70SMartin Matuska salt[salt_len + 1] = derived_key[key_len * 2 + 1];
1684cdf63a70SMartin Matuska
1685cdf63a70SMartin Matuska /* Write encrypted keys in the top of the file content. */
1686cdf63a70SMartin Matuska ret = __archive_write_output(a, salt, salt_len + 2);
1687cdf63a70SMartin Matuska if (ret != ARCHIVE_OK)
1688cdf63a70SMartin Matuska return (ret);
1689cdf63a70SMartin Matuska zip->written_bytes += salt_len + 2;
1690cdf63a70SMartin Matuska zip->entry_compressed_written += salt_len + 2;
1691cdf63a70SMartin Matuska
1692cdf63a70SMartin Matuska return (ARCHIVE_OK);
1693cdf63a70SMartin Matuska }
1694cdf63a70SMartin Matuska
1695cdf63a70SMartin Matuska static int
is_winzip_aes_encryption_supported(int encryption)1696cdf63a70SMartin Matuska is_winzip_aes_encryption_supported(int encryption)
1697cdf63a70SMartin Matuska {
1698cdf63a70SMartin Matuska size_t key_len, salt_len;
1699cdf63a70SMartin Matuska uint8_t salt[16 + 2];
1700cdf63a70SMartin Matuska uint8_t derived_key[MAX_DERIVED_KEY_BUF_SIZE];
1701cdf63a70SMartin Matuska archive_crypto_ctx cctx;
1702cdf63a70SMartin Matuska archive_hmac_sha1_ctx hctx;
1703cdf63a70SMartin Matuska int ret;
1704cdf63a70SMartin Matuska
1705cdf63a70SMartin Matuska if (encryption == ENCRYPTION_WINZIP_AES128) {
1706cdf63a70SMartin Matuska salt_len = 8;
1707cdf63a70SMartin Matuska key_len = 16;
1708cdf63a70SMartin Matuska } else {
1709cdf63a70SMartin Matuska /* AES 256 */
1710cdf63a70SMartin Matuska salt_len = 16;
1711cdf63a70SMartin Matuska key_len = 32;
1712cdf63a70SMartin Matuska }
1713cdf63a70SMartin Matuska if (archive_random(salt, salt_len) != ARCHIVE_OK)
1714cdf63a70SMartin Matuska return (0);
1715cdf63a70SMartin Matuska ret = archive_pbkdf2_sha1("p", 1, salt, salt_len, 1000,
1716cdf63a70SMartin Matuska derived_key, key_len * 2 + 2);
1717cdf63a70SMartin Matuska if (ret != 0)
1718cdf63a70SMartin Matuska return (0);
1719cdf63a70SMartin Matuska
1720cdf63a70SMartin Matuska ret = archive_encrypto_aes_ctr_init(&cctx, derived_key, key_len);
1721cdf63a70SMartin Matuska if (ret != 0)
1722cdf63a70SMartin Matuska return (0);
1723cdf63a70SMartin Matuska ret = archive_hmac_sha1_init(&hctx, derived_key + key_len,
1724cdf63a70SMartin Matuska key_len);
1725cdf63a70SMartin Matuska archive_encrypto_aes_ctr_release(&cctx);
1726cdf63a70SMartin Matuska if (ret != 0)
1727cdf63a70SMartin Matuska return (0);
1728cdf63a70SMartin Matuska archive_hmac_sha1_cleanup(&hctx);
1729cdf63a70SMartin Matuska return (1);
1730cdf63a70SMartin Matuska }
1731