1 /*-
2 * Copyright (c) 2011 Michihiro NAKAJIMA
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 */
25
26 #include "archive_platform.h"
27 __FBSDID("$FreeBSD$");
28
29 #ifdef HAVE_ERRNO_H
30 #include <errno.h>
31 #endif
32 #ifdef HAVE_STDLIB_H
33 #include <stdlib.h>
34 #endif
35 #ifdef HAVE_BZLIB_H
36 #include <bzlib.h>
37 #endif
38 #ifdef HAVE_LZMA_H
39 #include <lzma.h>
40 #endif
41 #ifdef HAVE_ZLIB_H
42 #include <zlib.h>
43 #endif
44
45 #include "archive.h"
46 #include "archive_entry.h"
47 #include "archive_entry_locale.h"
48 #include "archive_ppmd7_private.h"
49 #include "archive_private.h"
50 #include "archive_read_private.h"
51 #include "archive_endian.h"
52
53 #ifndef HAVE_ZLIB_H
54 #include "archive_crc32.h"
55 #endif
56
57 #define _7ZIP_SIGNATURE "7z\xBC\xAF\x27\x1C"
58 #define SFX_MIN_ADDR 0x27000
59 #define SFX_MAX_ADDR 0x60000
60
61
62 /*
63 * Codec ID
64 */
65 #define _7Z_COPY 0
66 #define _7Z_LZMA 0x030101
67 #define _7Z_LZMA2 0x21
68 #define _7Z_DEFLATE 0x040108
69 #define _7Z_BZ2 0x040202
70 #define _7Z_PPMD 0x030401
71 #define _7Z_DELTA 0x03
72 #define _7Z_CRYPTO_MAIN_ZIP 0x06F10101 /* Main Zip crypto algo */
73 #define _7Z_CRYPTO_RAR_29 0x06F10303 /* Rar29 AES-128 + (modified SHA-1) */
74 #define _7Z_CRYPTO_AES_256_SHA_256 0x06F10701 /* AES-256 + SHA-256 */
75
76
77 #define _7Z_X86 0x03030103
78 #define _7Z_X86_BCJ2 0x0303011B
79 #define _7Z_POWERPC 0x03030205
80 #define _7Z_IA64 0x03030401
81 #define _7Z_ARM 0x03030501
82 #define _7Z_ARMTHUMB 0x03030701
83 #define _7Z_SPARC 0x03030805
84
85 /*
86 * 7-Zip header property IDs.
87 */
88 #define kEnd 0x00
89 #define kHeader 0x01
90 #define kArchiveProperties 0x02
91 #define kAdditionalStreamsInfo 0x03
92 #define kMainStreamsInfo 0x04
93 #define kFilesInfo 0x05
94 #define kPackInfo 0x06
95 #define kUnPackInfo 0x07
96 #define kSubStreamsInfo 0x08
97 #define kSize 0x09
98 #define kCRC 0x0A
99 #define kFolder 0x0B
100 #define kCodersUnPackSize 0x0C
101 #define kNumUnPackStream 0x0D
102 #define kEmptyStream 0x0E
103 #define kEmptyFile 0x0F
104 #define kAnti 0x10
105 #define kName 0x11
106 #define kCTime 0x12
107 #define kATime 0x13
108 #define kMTime 0x14
109 #define kAttributes 0x15
110 #define kEncodedHeader 0x17
111 #define kDummy 0x19
112
113 struct _7z_digests {
114 unsigned char *defineds;
115 uint32_t *digests;
116 };
117
118
119 struct _7z_folder {
120 uint64_t numCoders;
121 struct _7z_coder {
122 unsigned long codec;
123 uint64_t numInStreams;
124 uint64_t numOutStreams;
125 uint64_t propertiesSize;
126 unsigned char *properties;
127 } *coders;
128 uint64_t numBindPairs;
129 struct {
130 uint64_t inIndex;
131 uint64_t outIndex;
132 } *bindPairs;
133 uint64_t numPackedStreams;
134 uint64_t *packedStreams;
135 uint64_t numInStreams;
136 uint64_t numOutStreams;
137 uint64_t *unPackSize;
138 unsigned char digest_defined;
139 uint32_t digest;
140 uint64_t numUnpackStreams;
141 uint32_t packIndex;
142 /* Unoperated bytes. */
143 uint64_t skipped_bytes;
144 };
145
146 struct _7z_coders_info {
147 uint64_t numFolders;
148 struct _7z_folder *folders;
149 uint64_t dataStreamIndex;
150 };
151
152 struct _7z_pack_info {
153 uint64_t pos;
154 uint64_t numPackStreams;
155 uint64_t *sizes;
156 struct _7z_digests digest;
157 /* Calculated from pos and numPackStreams. */
158 uint64_t *positions;
159 };
160
161 struct _7z_substream_info {
162 size_t unpack_streams;
163 uint64_t *unpackSizes;
164 unsigned char *digestsDefined;
165 uint32_t *digests;
166 };
167
168 struct _7z_stream_info {
169 struct _7z_pack_info pi;
170 struct _7z_coders_info ci;
171 struct _7z_substream_info ss;
172 };
173
174 struct _7z_header_info {
175 uint64_t dataIndex;
176
177 unsigned char *emptyStreamBools;
178 unsigned char *emptyFileBools;
179 unsigned char *antiBools;
180 unsigned char *attrBools;
181 };
182
183 struct _7zip_entry {
184 size_t name_len;
185 unsigned char *utf16name;
186 #if defined(_WIN32) && !defined(__CYGWIN__) && defined(_DEBUG)
187 const wchar_t *wname;
188 #endif
189 uint32_t folderIndex;
190 uint32_t ssIndex;
191 unsigned flg;
192 #define MTIME_IS_SET (1<<0)
193 #define ATIME_IS_SET (1<<1)
194 #define CTIME_IS_SET (1<<2)
195 #define CRC32_IS_SET (1<<3)
196 #define HAS_STREAM (1<<4)
197
198 time_t mtime;
199 time_t atime;
200 time_t ctime;
201 long mtime_ns;
202 long atime_ns;
203 long ctime_ns;
204 uint32_t mode;
205 uint32_t attr;
206 };
207
208 struct _7zip {
209 /* Structural information about the archive. */
210 struct _7z_stream_info si;
211
212 int header_is_being_read;
213 int header_is_encoded;
214 uint64_t header_bytes_remaining;
215 unsigned long header_crc32;
216 /* Header offset to check that reading points of the file contents
217 * will not exceed the header. */
218 uint64_t header_offset;
219 /* Base offset of the archive file for a seek in case reading SFX. */
220 uint64_t seek_base;
221
222 /* List of entries */
223 size_t entries_remaining;
224 uint64_t numFiles;
225 struct _7zip_entry *entries;
226 struct _7zip_entry *entry;
227 unsigned char *entry_names;
228
229 /* entry_bytes_remaining is the number of bytes we expect. */
230 int64_t entry_offset;
231 uint64_t entry_bytes_remaining;
232
233 /* Running CRC32 of the decompressed data */
234 unsigned long entry_crc32;
235
236 /* Flags to mark progress of decompression. */
237 char end_of_entry;
238
239 /* Uncompressed buffer control. */
240 #define UBUFF_SIZE (64 * 1024)
241 unsigned char *uncompressed_buffer;
242 unsigned char *uncompressed_buffer_pointer;
243 size_t uncompressed_buffer_size;
244 size_t uncompressed_buffer_bytes_remaining;
245
246 /* Offset of the compressed data. */
247 int64_t stream_offset;
248
249 /*
250 * Decompressing control data.
251 */
252 unsigned folder_index;
253 uint64_t folder_outbytes_remaining;
254 unsigned pack_stream_index;
255 unsigned pack_stream_remaining;
256 uint64_t pack_stream_inbytes_remaining;
257 size_t pack_stream_bytes_unconsumed;
258
259 /* The codec information of a folder. */
260 unsigned long codec;
261 unsigned long codec2;
262
263 /*
264 * Decompressor controllers.
265 */
266 /* Decoding LZMA1 and LZMA2 data. */
267 #ifdef HAVE_LZMA_H
268 lzma_stream lzstream;
269 int lzstream_valid;
270 #endif
271 /* Decoding bzip2 data. */
272 #if defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR)
273 bz_stream bzstream;
274 int bzstream_valid;
275 #endif
276 /* Decoding deflate data. */
277 #ifdef HAVE_ZLIB_H
278 z_stream stream;
279 int stream_valid;
280 #endif
281 /* Decoding PPMd data. */
282 int ppmd7_stat;
283 CPpmd7 ppmd7_context;
284 CPpmd7z_RangeDec range_dec;
285 IByteIn bytein;
286 struct {
287 const unsigned char *next_in;
288 int64_t avail_in;
289 int64_t total_in;
290 unsigned char *next_out;
291 int64_t avail_out;
292 int64_t total_out;
293 int overconsumed;
294 } ppstream;
295 int ppmd7_valid;
296
297 /* Decoding BCJ and BCJ2 data. */
298 uint32_t bcj_state;
299 size_t odd_bcj_size;
300 unsigned char odd_bcj[4];
301 /* Decoding BCJ data. */
302 size_t bcj_prevPosT;
303 uint32_t bcj_prevMask;
304 uint32_t bcj_ip;
305
306 /* Decoding BCJ2 data. */
307 size_t main_stream_bytes_remaining;
308 unsigned char *sub_stream_buff[3];
309 size_t sub_stream_size[3];
310 size_t sub_stream_bytes_remaining[3];
311 unsigned char *tmp_stream_buff;
312 size_t tmp_stream_buff_size;
313 size_t tmp_stream_bytes_avail;
314 size_t tmp_stream_bytes_remaining;
315 #ifdef _LZMA_PROB32
316 #define CProb uint32_t
317 #else
318 #define CProb uint16_t
319 #endif
320 CProb bcj2_p[256 + 2];
321 uint8_t bcj2_prevByte;
322 uint32_t bcj2_range;
323 uint32_t bcj2_code;
324 uint64_t bcj2_outPos;
325
326 /* Filename character-set conversion data. */
327 struct archive_string_conv *sconv;
328
329 char format_name[64];
330
331 /* Custom value that is non-zero if this archive contains encrypted entries. */
332 int has_encrypted_entries;
333 };
334
335 /* Maximum entry size. This limitation prevents reading intentional
336 * corrupted 7-zip files on assuming there are not so many entries in
337 * the files. */
338 #define UMAX_ENTRY ARCHIVE_LITERAL_ULL(100000000)
339
340 static int archive_read_format_7zip_has_encrypted_entries(struct archive_read *);
341 static int archive_read_support_format_7zip_capabilities(struct archive_read *a);
342 static int archive_read_format_7zip_bid(struct archive_read *, int);
343 static int archive_read_format_7zip_cleanup(struct archive_read *);
344 static int archive_read_format_7zip_read_data(struct archive_read *,
345 const void **, size_t *, int64_t *);
346 static int archive_read_format_7zip_read_data_skip(struct archive_read *);
347 static int archive_read_format_7zip_read_header(struct archive_read *,
348 struct archive_entry *);
349 static int check_7zip_header_in_sfx(const char *);
350 static unsigned long decode_codec_id(const unsigned char *, size_t);
351 static int decode_encoded_header_info(struct archive_read *,
352 struct _7z_stream_info *);
353 static int decompress(struct archive_read *, struct _7zip *,
354 void *, size_t *, const void *, size_t *);
355 static ssize_t extract_pack_stream(struct archive_read *, size_t);
356 static void fileTimeToUtc(uint64_t, time_t *, long *);
357 static uint64_t folder_uncompressed_size(struct _7z_folder *);
358 static void free_CodersInfo(struct _7z_coders_info *);
359 static void free_Digest(struct _7z_digests *);
360 static void free_Folder(struct _7z_folder *);
361 static void free_Header(struct _7z_header_info *);
362 static void free_PackInfo(struct _7z_pack_info *);
363 static void free_StreamsInfo(struct _7z_stream_info *);
364 static void free_SubStreamsInfo(struct _7z_substream_info *);
365 static int free_decompression(struct archive_read *, struct _7zip *);
366 static ssize_t get_uncompressed_data(struct archive_read *, const void **,
367 size_t, size_t);
368 static const unsigned char * header_bytes(struct archive_read *, size_t);
369 static int init_decompression(struct archive_read *, struct _7zip *,
370 const struct _7z_coder *, const struct _7z_coder *);
371 static int parse_7zip_uint64(struct archive_read *, uint64_t *);
372 static int read_Bools(struct archive_read *, unsigned char *, size_t);
373 static int read_CodersInfo(struct archive_read *,
374 struct _7z_coders_info *);
375 static int read_Digests(struct archive_read *, struct _7z_digests *,
376 size_t);
377 static int read_Folder(struct archive_read *, struct _7z_folder *);
378 static int read_Header(struct archive_read *, struct _7z_header_info *,
379 int);
380 static int read_PackInfo(struct archive_read *, struct _7z_pack_info *);
381 static int read_StreamsInfo(struct archive_read *,
382 struct _7z_stream_info *);
383 static int read_SubStreamsInfo(struct archive_read *,
384 struct _7z_substream_info *, struct _7z_folder *, size_t);
385 static int read_Times(struct archive_read *, struct _7z_header_info *,
386 int);
387 static void read_consume(struct archive_read *);
388 static ssize_t read_stream(struct archive_read *, const void **, size_t,
389 size_t);
390 static int seek_pack(struct archive_read *);
391 static int64_t skip_stream(struct archive_read *, size_t);
392 static int skip_sfx(struct archive_read *, ssize_t);
393 static int slurp_central_directory(struct archive_read *, struct _7zip *,
394 struct _7z_header_info *);
395 static int setup_decode_folder(struct archive_read *, struct _7z_folder *,
396 int);
397 static void x86_Init(struct _7zip *);
398 static size_t x86_Convert(struct _7zip *, uint8_t *, size_t);
399 static ssize_t Bcj2_Decode(struct _7zip *, uint8_t *, size_t);
400
401
402 int
archive_read_support_format_7zip(struct archive * _a)403 archive_read_support_format_7zip(struct archive *_a)
404 {
405 struct archive_read *a = (struct archive_read *)_a;
406 struct _7zip *zip;
407 int r;
408
409 archive_check_magic(_a, ARCHIVE_READ_MAGIC,
410 ARCHIVE_STATE_NEW, "archive_read_support_format_7zip");
411
412 zip = calloc(1, sizeof(*zip));
413 if (zip == NULL) {
414 archive_set_error(&a->archive, ENOMEM,
415 "Can't allocate 7zip data");
416 return (ARCHIVE_FATAL);
417 }
418
419 /*
420 * Until enough data has been read, we cannot tell about
421 * any encrypted entries yet.
422 */
423 zip->has_encrypted_entries = ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW;
424
425
426 r = __archive_read_register_format(a,
427 zip,
428 "7zip",
429 archive_read_format_7zip_bid,
430 NULL,
431 archive_read_format_7zip_read_header,
432 archive_read_format_7zip_read_data,
433 archive_read_format_7zip_read_data_skip,
434 NULL,
435 archive_read_format_7zip_cleanup,
436 archive_read_support_format_7zip_capabilities,
437 archive_read_format_7zip_has_encrypted_entries);
438
439 if (r != ARCHIVE_OK)
440 free(zip);
441 return (ARCHIVE_OK);
442 }
443
444 static int
archive_read_support_format_7zip_capabilities(struct archive_read * a)445 archive_read_support_format_7zip_capabilities(struct archive_read * a)
446 {
447 (void)a; /* UNUSED */
448 return (ARCHIVE_READ_FORMAT_CAPS_ENCRYPT_DATA |
449 ARCHIVE_READ_FORMAT_CAPS_ENCRYPT_METADATA);
450 }
451
452
453 static int
archive_read_format_7zip_has_encrypted_entries(struct archive_read * _a)454 archive_read_format_7zip_has_encrypted_entries(struct archive_read *_a)
455 {
456 if (_a && _a->format) {
457 struct _7zip * zip = (struct _7zip *)_a->format->data;
458 if (zip) {
459 return zip->has_encrypted_entries;
460 }
461 }
462 return ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW;
463 }
464
465 static int
archive_read_format_7zip_bid(struct archive_read * a,int best_bid)466 archive_read_format_7zip_bid(struct archive_read *a, int best_bid)
467 {
468 const char *p;
469
470 /* If someone has already bid more than 32, then avoid
471 trashing the look-ahead buffers with a seek. */
472 if (best_bid > 32)
473 return (-1);
474
475 if ((p = __archive_read_ahead(a, 6, NULL)) == NULL)
476 return (0);
477
478 /* If first six bytes are the 7-Zip signature,
479 * return the bid right now. */
480 if (memcmp(p, _7ZIP_SIGNATURE, 6) == 0)
481 return (48);
482
483 /*
484 * It may a 7-Zip SFX archive file. If first two bytes are
485 * 'M' and 'Z' available on Windows or first four bytes are
486 * "\x7F\x45LF" available on posix like system, seek the 7-Zip
487 * signature. Although we will perform a seek when reading
488 * a header, what we do not use __archive_read_seek() here is
489 * due to a bidding performance.
490 */
491 if ((p[0] == 'M' && p[1] == 'Z') || memcmp(p, "\x7F\x45LF", 4) == 0) {
492 ssize_t offset = SFX_MIN_ADDR;
493 ssize_t window = 4096;
494 ssize_t bytes_avail;
495 while (offset + window <= (SFX_MAX_ADDR)) {
496 const char *buff = __archive_read_ahead(a,
497 offset + window, &bytes_avail);
498 if (buff == NULL) {
499 /* Remaining bytes are less than window. */
500 window >>= 1;
501 if (window < 0x40)
502 return (0);
503 continue;
504 }
505 p = buff + offset;
506 while (p + 32 < buff + bytes_avail) {
507 int step = check_7zip_header_in_sfx(p);
508 if (step == 0)
509 return (48);
510 p += step;
511 }
512 offset = p - buff;
513 }
514 }
515 return (0);
516 }
517
518 static int
check_7zip_header_in_sfx(const char * p)519 check_7zip_header_in_sfx(const char *p)
520 {
521 switch ((unsigned char)p[5]) {
522 case 0x1C:
523 if (memcmp(p, _7ZIP_SIGNATURE, 6) != 0)
524 return (6);
525 /*
526 * Test the CRC because its extraction code has 7-Zip
527 * Magic Code, so we should do this in order not to
528 * make a mis-detection.
529 */
530 if (crc32(0, (const unsigned char *)p + 12, 20)
531 != archive_le32dec(p + 8))
532 return (6);
533 /* Hit the header! */
534 return (0);
535 case 0x37: return (5);
536 case 0x7A: return (4);
537 case 0xBC: return (3);
538 case 0xAF: return (2);
539 case 0x27: return (1);
540 default: return (6);
541 }
542 }
543
544 static int
skip_sfx(struct archive_read * a,ssize_t bytes_avail)545 skip_sfx(struct archive_read *a, ssize_t bytes_avail)
546 {
547 const void *h;
548 const char *p, *q;
549 size_t skip, offset;
550 ssize_t bytes, window;
551
552 /*
553 * If bytes_avail > SFX_MIN_ADDR we do not have to call
554 * __archive_read_seek() at this time since we have
555 * already had enough data.
556 */
557 if (bytes_avail > SFX_MIN_ADDR)
558 __archive_read_consume(a, SFX_MIN_ADDR);
559 else if (__archive_read_seek(a, SFX_MIN_ADDR, SEEK_SET) < 0)
560 return (ARCHIVE_FATAL);
561
562 offset = 0;
563 window = 1;
564 while (offset + window <= SFX_MAX_ADDR - SFX_MIN_ADDR) {
565 h = __archive_read_ahead(a, window, &bytes);
566 if (h == NULL) {
567 /* Remaining bytes are less than window. */
568 window >>= 1;
569 if (window < 0x40)
570 goto fatal;
571 continue;
572 }
573 if (bytes < 6) {
574 /* This case might happen when window == 1. */
575 window = 4096;
576 continue;
577 }
578 p = (const char *)h;
579 q = p + bytes;
580
581 /*
582 * Scan ahead until we find something that looks
583 * like the 7-Zip header.
584 */
585 while (p + 32 < q) {
586 int step = check_7zip_header_in_sfx(p);
587 if (step == 0) {
588 struct _7zip *zip =
589 (struct _7zip *)a->format->data;
590 skip = p - (const char *)h;
591 __archive_read_consume(a, skip);
592 zip->seek_base = SFX_MIN_ADDR + offset + skip;
593 return (ARCHIVE_OK);
594 }
595 p += step;
596 }
597 skip = p - (const char *)h;
598 __archive_read_consume(a, skip);
599 offset += skip;
600 if (window == 1)
601 window = 4096;
602 }
603 fatal:
604 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
605 "Couldn't find out 7-Zip header");
606 return (ARCHIVE_FATAL);
607 }
608
609 static int
archive_read_format_7zip_read_header(struct archive_read * a,struct archive_entry * entry)610 archive_read_format_7zip_read_header(struct archive_read *a,
611 struct archive_entry *entry)
612 {
613 struct _7zip *zip = (struct _7zip *)a->format->data;
614 struct _7zip_entry *zip_entry;
615 int r, ret = ARCHIVE_OK;
616 struct _7z_folder *folder = 0;
617 uint64_t fidx = 0;
618
619 /*
620 * It should be sufficient to call archive_read_next_header() for
621 * a reader to determine if an entry is encrypted or not. If the
622 * encryption of an entry is only detectable when calling
623 * archive_read_data(), so be it. We'll do the same check there
624 * as well.
625 */
626 if (zip->has_encrypted_entries == ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW) {
627 zip->has_encrypted_entries = 0;
628 }
629
630 a->archive.archive_format = ARCHIVE_FORMAT_7ZIP;
631 if (a->archive.archive_format_name == NULL)
632 a->archive.archive_format_name = "7-Zip";
633
634 if (zip->entries == NULL) {
635 struct _7z_header_info header;
636
637 memset(&header, 0, sizeof(header));
638 r = slurp_central_directory(a, zip, &header);
639 free_Header(&header);
640 if (r != ARCHIVE_OK)
641 return (r);
642 zip->entries_remaining = (size_t)zip->numFiles;
643 zip->entry = zip->entries;
644 } else {
645 ++zip->entry;
646 }
647 zip_entry = zip->entry;
648
649 if (zip->entries_remaining <= 0 || zip_entry == NULL)
650 return ARCHIVE_EOF;
651 --zip->entries_remaining;
652
653 zip->entry_offset = 0;
654 zip->end_of_entry = 0;
655 zip->entry_crc32 = crc32(0, NULL, 0);
656
657 /* Setup a string conversion for a filename. */
658 if (zip->sconv == NULL) {
659 zip->sconv = archive_string_conversion_from_charset(
660 &a->archive, "UTF-16LE", 1);
661 if (zip->sconv == NULL)
662 return (ARCHIVE_FATAL);
663 }
664
665 /* Figure out if the entry is encrypted by looking at the folder
666 that is associated to the current 7zip entry. If the folder
667 has a coder with a _7Z_CRYPTO codec then the folder is encrypted.
668 Hence the entry must also be encrypted. */
669 if (zip_entry && zip_entry->folderIndex < zip->si.ci.numFolders) {
670 folder = &(zip->si.ci.folders[zip_entry->folderIndex]);
671 for (fidx=0; folder && fidx<folder->numCoders; fidx++) {
672 switch(folder->coders[fidx].codec) {
673 case _7Z_CRYPTO_MAIN_ZIP:
674 case _7Z_CRYPTO_RAR_29:
675 case _7Z_CRYPTO_AES_256_SHA_256: {
676 archive_entry_set_is_data_encrypted(entry, 1);
677 zip->has_encrypted_entries = 1;
678 break;
679 }
680 }
681 }
682 }
683
684 /* Now that we've checked for encryption, if there were still no
685 * encrypted entries found we can say for sure that there are none.
686 */
687 if (zip->has_encrypted_entries == ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW) {
688 zip->has_encrypted_entries = 0;
689 }
690
691 if (archive_entry_copy_pathname_l(entry,
692 (const char *)zip_entry->utf16name,
693 zip_entry->name_len, zip->sconv) != 0) {
694 if (errno == ENOMEM) {
695 archive_set_error(&a->archive, ENOMEM,
696 "Can't allocate memory for Pathname");
697 return (ARCHIVE_FATAL);
698 }
699 archive_set_error(&a->archive,
700 ARCHIVE_ERRNO_FILE_FORMAT,
701 "Pathname cannot be converted "
702 "from %s to current locale.",
703 archive_string_conversion_charset_name(zip->sconv));
704 ret = ARCHIVE_WARN;
705 }
706
707 /* Populate some additional entry fields: */
708 archive_entry_set_mode(entry, zip_entry->mode);
709 if (zip_entry->flg & MTIME_IS_SET)
710 archive_entry_set_mtime(entry, zip_entry->mtime,
711 zip_entry->mtime_ns);
712 if (zip_entry->flg & CTIME_IS_SET)
713 archive_entry_set_ctime(entry, zip_entry->ctime,
714 zip_entry->ctime_ns);
715 if (zip_entry->flg & ATIME_IS_SET)
716 archive_entry_set_atime(entry, zip_entry->atime,
717 zip_entry->atime_ns);
718 if (zip_entry->ssIndex != (uint32_t)-1) {
719 zip->entry_bytes_remaining =
720 zip->si.ss.unpackSizes[zip_entry->ssIndex];
721 archive_entry_set_size(entry, zip->entry_bytes_remaining);
722 } else {
723 zip->entry_bytes_remaining = 0;
724 archive_entry_set_size(entry, 0);
725 }
726
727 /* If there's no body, force read_data() to return EOF immediately. */
728 if (zip->entry_bytes_remaining < 1)
729 zip->end_of_entry = 1;
730
731 if ((zip_entry->mode & AE_IFMT) == AE_IFLNK) {
732 unsigned char *symname = NULL;
733 size_t symsize = 0;
734
735 /*
736 * Symbolic-name is recorded as its contents. We have to
737 * read the contents at this time.
738 */
739 while (zip->entry_bytes_remaining > 0) {
740 const void *buff;
741 unsigned char *mem;
742 size_t size;
743 int64_t offset;
744
745 r = archive_read_format_7zip_read_data(a, &buff,
746 &size, &offset);
747 if (r < ARCHIVE_WARN) {
748 free(symname);
749 return (r);
750 }
751 mem = realloc(symname, symsize + size + 1);
752 if (mem == NULL) {
753 free(symname);
754 archive_set_error(&a->archive, ENOMEM,
755 "Can't allocate memory for Symname");
756 return (ARCHIVE_FATAL);
757 }
758 symname = mem;
759 memcpy(symname+symsize, buff, size);
760 symsize += size;
761 }
762 if (symsize == 0) {
763 /* If there is no symname, handle it as a regular
764 * file. */
765 zip_entry->mode &= ~AE_IFMT;
766 zip_entry->mode |= AE_IFREG;
767 archive_entry_set_mode(entry, zip_entry->mode);
768 } else {
769 symname[symsize] = '\0';
770 archive_entry_copy_symlink(entry,
771 (const char *)symname);
772 }
773 free(symname);
774 archive_entry_set_size(entry, 0);
775 }
776
777 /* Set up a more descriptive format name. */
778 sprintf(zip->format_name, "7-Zip");
779 a->archive.archive_format_name = zip->format_name;
780
781 return (ret);
782 }
783
784 static int
archive_read_format_7zip_read_data(struct archive_read * a,const void ** buff,size_t * size,int64_t * offset)785 archive_read_format_7zip_read_data(struct archive_read *a,
786 const void **buff, size_t *size, int64_t *offset)
787 {
788 struct _7zip *zip;
789 ssize_t bytes;
790 int ret = ARCHIVE_OK;
791
792 zip = (struct _7zip *)(a->format->data);
793
794 if (zip->has_encrypted_entries == ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW) {
795 zip->has_encrypted_entries = 0;
796 }
797
798 if (zip->pack_stream_bytes_unconsumed)
799 read_consume(a);
800
801 *offset = zip->entry_offset;
802 *size = 0;
803 *buff = NULL;
804 /*
805 * If we hit end-of-entry last time, clean up and return
806 * ARCHIVE_EOF this time.
807 */
808 if (zip->end_of_entry)
809 return (ARCHIVE_EOF);
810
811 const uint64_t max_read_size = 16 * 1024 * 1024; // Don't try to read more than 16 MB at a time
812 size_t bytes_to_read = max_read_size;
813 if ((uint64_t)bytes_to_read > zip->entry_bytes_remaining) {
814 bytes_to_read = zip->entry_bytes_remaining;
815 }
816 bytes = read_stream(a, buff, bytes_to_read, 0);
817 if (bytes < 0)
818 return ((int)bytes);
819 if (bytes == 0) {
820 archive_set_error(&a->archive,
821 ARCHIVE_ERRNO_FILE_FORMAT,
822 "Truncated 7-Zip file body");
823 return (ARCHIVE_FATAL);
824 }
825 zip->entry_bytes_remaining -= bytes;
826 if (zip->entry_bytes_remaining == 0)
827 zip->end_of_entry = 1;
828
829 /* Update checksum */
830 if ((zip->entry->flg & CRC32_IS_SET) && bytes)
831 zip->entry_crc32 = crc32(zip->entry_crc32, *buff,
832 (unsigned)bytes);
833
834 /* If we hit the end, swallow any end-of-data marker. */
835 if (zip->end_of_entry) {
836 /* Check computed CRC against file contents. */
837 if ((zip->entry->flg & CRC32_IS_SET) &&
838 zip->si.ss.digests[zip->entry->ssIndex] !=
839 zip->entry_crc32) {
840 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
841 "7-Zip bad CRC: 0x%lx should be 0x%lx",
842 (unsigned long)zip->entry_crc32,
843 (unsigned long)zip->si.ss.digests[
844 zip->entry->ssIndex]);
845 ret = ARCHIVE_WARN;
846 }
847 }
848
849 *size = bytes;
850 *offset = zip->entry_offset;
851 zip->entry_offset += bytes;
852
853 return (ret);
854 }
855
856 static int
archive_read_format_7zip_read_data_skip(struct archive_read * a)857 archive_read_format_7zip_read_data_skip(struct archive_read *a)
858 {
859 struct _7zip *zip;
860 int64_t bytes_skipped;
861
862 zip = (struct _7zip *)(a->format->data);
863
864 if (zip->pack_stream_bytes_unconsumed)
865 read_consume(a);
866
867 /* If we've already read to end of data, we're done. */
868 if (zip->end_of_entry)
869 return (ARCHIVE_OK);
870
871 /*
872 * If the length is at the beginning, we can skip the
873 * compressed data much more quickly.
874 */
875 bytes_skipped = skip_stream(a, (size_t)zip->entry_bytes_remaining);
876 if (bytes_skipped < 0)
877 return (ARCHIVE_FATAL);
878 zip->entry_bytes_remaining = 0;
879
880 /* This entry is finished and done. */
881 zip->end_of_entry = 1;
882 return (ARCHIVE_OK);
883 }
884
885 static int
archive_read_format_7zip_cleanup(struct archive_read * a)886 archive_read_format_7zip_cleanup(struct archive_read *a)
887 {
888 struct _7zip *zip;
889
890 zip = (struct _7zip *)(a->format->data);
891 free_StreamsInfo(&(zip->si));
892 free(zip->entries);
893 free(zip->entry_names);
894 free_decompression(a, zip);
895 free(zip->uncompressed_buffer);
896 free(zip->sub_stream_buff[0]);
897 free(zip->sub_stream_buff[1]);
898 free(zip->sub_stream_buff[2]);
899 free(zip->tmp_stream_buff);
900 free(zip);
901 (a->format->data) = NULL;
902 return (ARCHIVE_OK);
903 }
904
905 static void
read_consume(struct archive_read * a)906 read_consume(struct archive_read *a)
907 {
908 struct _7zip *zip = (struct _7zip *)a->format->data;
909
910 if (zip->pack_stream_bytes_unconsumed) {
911 __archive_read_consume(a, zip->pack_stream_bytes_unconsumed);
912 zip->stream_offset += zip->pack_stream_bytes_unconsumed;
913 zip->pack_stream_bytes_unconsumed = 0;
914 }
915 }
916
917 #ifdef HAVE_LZMA_H
918
919 /*
920 * Set an error code and choose an error message for liblzma.
921 */
922 static void
set_error(struct archive_read * a,int ret)923 set_error(struct archive_read *a, int ret)
924 {
925
926 switch (ret) {
927 case LZMA_STREAM_END: /* Found end of stream. */
928 case LZMA_OK: /* Decompressor made some progress. */
929 break;
930 case LZMA_MEM_ERROR:
931 archive_set_error(&a->archive, ENOMEM,
932 "Lzma library error: Cannot allocate memory");
933 break;
934 case LZMA_MEMLIMIT_ERROR:
935 archive_set_error(&a->archive, ENOMEM,
936 "Lzma library error: Out of memory");
937 break;
938 case LZMA_FORMAT_ERROR:
939 archive_set_error(&a->archive,
940 ARCHIVE_ERRNO_MISC,
941 "Lzma library error: format not recognized");
942 break;
943 case LZMA_OPTIONS_ERROR:
944 archive_set_error(&a->archive,
945 ARCHIVE_ERRNO_MISC,
946 "Lzma library error: Invalid options");
947 break;
948 case LZMA_DATA_ERROR:
949 archive_set_error(&a->archive,
950 ARCHIVE_ERRNO_MISC,
951 "Lzma library error: Corrupted input data");
952 break;
953 case LZMA_BUF_ERROR:
954 archive_set_error(&a->archive,
955 ARCHIVE_ERRNO_MISC,
956 "Lzma library error: No progress is possible");
957 break;
958 default:
959 /* Return an error. */
960 archive_set_error(&a->archive,
961 ARCHIVE_ERRNO_MISC,
962 "Lzma decompression failed: Unknown error");
963 break;
964 }
965 }
966
967 #endif
968
969 static unsigned long
decode_codec_id(const unsigned char * codecId,size_t id_size)970 decode_codec_id(const unsigned char *codecId, size_t id_size)
971 {
972 unsigned i;
973 unsigned long id = 0;
974
975 for (i = 0; i < id_size; i++) {
976 id <<= 8;
977 id += codecId[i];
978 }
979 return (id);
980 }
981
982 static Byte
ppmd_read(void * p)983 ppmd_read(void *p)
984 {
985 struct archive_read *a = ((IByteIn*)p)->a;
986 struct _7zip *zip = (struct _7zip *)(a->format->data);
987 Byte b;
988
989 if (zip->ppstream.avail_in == 0) {
990 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
991 "Truncated RAR file data");
992 zip->ppstream.overconsumed = 1;
993 return (0);
994 }
995 b = *zip->ppstream.next_in++;
996 zip->ppstream.avail_in--;
997 zip->ppstream.total_in++;
998 return (b);
999 }
1000
1001 static int
init_decompression(struct archive_read * a,struct _7zip * zip,const struct _7z_coder * coder1,const struct _7z_coder * coder2)1002 init_decompression(struct archive_read *a, struct _7zip *zip,
1003 const struct _7z_coder *coder1, const struct _7z_coder *coder2)
1004 {
1005 int r;
1006
1007 zip->codec = coder1->codec;
1008 zip->codec2 = -1;
1009
1010 switch (zip->codec) {
1011 case _7Z_COPY:
1012 case _7Z_BZ2:
1013 case _7Z_DEFLATE:
1014 case _7Z_PPMD:
1015 if (coder2 != NULL) {
1016 if (coder2->codec != _7Z_X86 &&
1017 coder2->codec != _7Z_X86_BCJ2) {
1018 archive_set_error(&a->archive,
1019 ARCHIVE_ERRNO_MISC,
1020 "Unsupported filter %lx for %lx",
1021 coder2->codec, coder1->codec);
1022 return (ARCHIVE_FAILED);
1023 }
1024 zip->codec2 = coder2->codec;
1025 zip->bcj_state = 0;
1026 if (coder2->codec == _7Z_X86)
1027 x86_Init(zip);
1028 }
1029 break;
1030 default:
1031 break;
1032 }
1033
1034 switch (zip->codec) {
1035 case _7Z_COPY:
1036 break;
1037
1038 case _7Z_LZMA: case _7Z_LZMA2:
1039 #ifdef HAVE_LZMA_H
1040 #if LZMA_VERSION_MAJOR >= 5
1041 /* Effectively disable the limiter. */
1042 #define LZMA_MEMLIMIT UINT64_MAX
1043 #else
1044 /* NOTE: This needs to check memory size which running system has. */
1045 #define LZMA_MEMLIMIT (1U << 30)
1046 #endif
1047 {
1048 lzma_options_delta delta_opt;
1049 lzma_filter filters[LZMA_FILTERS_MAX], *ff;
1050 int fi = 0;
1051
1052 if (zip->lzstream_valid) {
1053 lzma_end(&(zip->lzstream));
1054 zip->lzstream_valid = 0;
1055 }
1056
1057 /*
1058 * NOTE: liblzma incompletely handle the BCJ+LZMA compressed
1059 * data made by 7-Zip because 7-Zip does not add End-Of-
1060 * Payload Marker(EOPM) at the end of LZMA compressed data,
1061 * and so liblzma cannot know the end of the compressed data
1062 * without EOPM. So consequently liblzma will not return last
1063 * three or four bytes of uncompressed data because
1064 * LZMA_FILTER_X86 filter does not handle input data if its
1065 * data size is less than five bytes. If liblzma detect EOPM
1066 * or know the uncompressed data size, liblzma will flush out
1067 * the remaining that three or four bytes of uncompressed
1068 * data. That is why we have to use our converting program
1069 * for BCJ+LZMA. If we were able to tell the uncompressed
1070 * size to liblzma when using lzma_raw_decoder() liblzma
1071 * could correctly deal with BCJ+LZMA. But unfortunately
1072 * there is no way to do that.
1073 * Discussion about this can be found at XZ Utils forum.
1074 */
1075 if (coder2 != NULL) {
1076 zip->codec2 = coder2->codec;
1077
1078 filters[fi].options = NULL;
1079 switch (zip->codec2) {
1080 case _7Z_X86:
1081 if (zip->codec == _7Z_LZMA2) {
1082 filters[fi].id = LZMA_FILTER_X86;
1083 fi++;
1084 } else
1085 /* Use our filter. */
1086 x86_Init(zip);
1087 break;
1088 case _7Z_X86_BCJ2:
1089 /* Use our filter. */
1090 zip->bcj_state = 0;
1091 break;
1092 case _7Z_DELTA:
1093 if (coder2->propertiesSize != 1) {
1094 archive_set_error(&a->archive,
1095 ARCHIVE_ERRNO_MISC,
1096 "Invalid Delta parameter");
1097 return (ARCHIVE_FAILED);
1098 }
1099 filters[fi].id = LZMA_FILTER_DELTA;
1100 memset(&delta_opt, 0, sizeof(delta_opt));
1101 delta_opt.type = LZMA_DELTA_TYPE_BYTE;
1102 delta_opt.dist =
1103 (uint32_t)coder2->properties[0] + 1;
1104 filters[fi].options = &delta_opt;
1105 fi++;
1106 break;
1107 /* Following filters have not been tested yet. */
1108 case _7Z_POWERPC:
1109 filters[fi].id = LZMA_FILTER_POWERPC;
1110 fi++;
1111 break;
1112 case _7Z_IA64:
1113 filters[fi].id = LZMA_FILTER_IA64;
1114 fi++;
1115 break;
1116 case _7Z_ARM:
1117 filters[fi].id = LZMA_FILTER_ARM;
1118 fi++;
1119 break;
1120 case _7Z_ARMTHUMB:
1121 filters[fi].id = LZMA_FILTER_ARMTHUMB;
1122 fi++;
1123 break;
1124 case _7Z_SPARC:
1125 filters[fi].id = LZMA_FILTER_SPARC;
1126 fi++;
1127 break;
1128 default:
1129 archive_set_error(&a->archive,
1130 ARCHIVE_ERRNO_MISC,
1131 "Unexpected codec ID: %lX", zip->codec2);
1132 return (ARCHIVE_FAILED);
1133 }
1134 }
1135
1136 if (zip->codec == _7Z_LZMA2)
1137 filters[fi].id = LZMA_FILTER_LZMA2;
1138 else
1139 filters[fi].id = LZMA_FILTER_LZMA1;
1140 filters[fi].options = NULL;
1141 ff = &filters[fi];
1142 r = lzma_properties_decode(&filters[fi], NULL,
1143 coder1->properties, (size_t)coder1->propertiesSize);
1144 if (r != LZMA_OK) {
1145 set_error(a, r);
1146 return (ARCHIVE_FAILED);
1147 }
1148 fi++;
1149
1150 filters[fi].id = LZMA_VLI_UNKNOWN;
1151 filters[fi].options = NULL;
1152 r = lzma_raw_decoder(&(zip->lzstream), filters);
1153 free(ff->options);
1154 if (r != LZMA_OK) {
1155 set_error(a, r);
1156 return (ARCHIVE_FAILED);
1157 }
1158 zip->lzstream_valid = 1;
1159 zip->lzstream.total_in = 0;
1160 zip->lzstream.total_out = 0;
1161 break;
1162 }
1163 #else
1164 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1165 "LZMA codec is unsupported");
1166 return (ARCHIVE_FAILED);
1167 #endif
1168 case _7Z_BZ2:
1169 #if defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR)
1170 if (zip->bzstream_valid) {
1171 BZ2_bzDecompressEnd(&(zip->bzstream));
1172 zip->bzstream_valid = 0;
1173 }
1174 r = BZ2_bzDecompressInit(&(zip->bzstream), 0, 0);
1175 if (r == BZ_MEM_ERROR)
1176 r = BZ2_bzDecompressInit(&(zip->bzstream), 0, 1);
1177 if (r != BZ_OK) {
1178 int err = ARCHIVE_ERRNO_MISC;
1179 const char *detail = NULL;
1180 switch (r) {
1181 case BZ_PARAM_ERROR:
1182 detail = "invalid setup parameter";
1183 break;
1184 case BZ_MEM_ERROR:
1185 err = ENOMEM;
1186 detail = "out of memory";
1187 break;
1188 case BZ_CONFIG_ERROR:
1189 detail = "mis-compiled library";
1190 break;
1191 }
1192 archive_set_error(&a->archive, err,
1193 "Internal error initializing decompressor: %s",
1194 detail != NULL ? detail : "??");
1195 zip->bzstream_valid = 0;
1196 return (ARCHIVE_FAILED);
1197 }
1198 zip->bzstream_valid = 1;
1199 zip->bzstream.total_in_lo32 = 0;
1200 zip->bzstream.total_in_hi32 = 0;
1201 zip->bzstream.total_out_lo32 = 0;
1202 zip->bzstream.total_out_hi32 = 0;
1203 break;
1204 #else
1205 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1206 "BZ2 codec is unsupported");
1207 return (ARCHIVE_FAILED);
1208 #endif
1209 case _7Z_DEFLATE:
1210 #ifdef HAVE_ZLIB_H
1211 if (zip->stream_valid)
1212 r = inflateReset(&(zip->stream));
1213 else
1214 r = inflateInit2(&(zip->stream),
1215 -15 /* Don't check for zlib header */);
1216 if (r != Z_OK) {
1217 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1218 "Couldn't initialize zlib stream.");
1219 return (ARCHIVE_FAILED);
1220 }
1221 zip->stream_valid = 1;
1222 zip->stream.total_in = 0;
1223 zip->stream.total_out = 0;
1224 break;
1225 #else
1226 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1227 "DEFLATE codec is unsupported");
1228 return (ARCHIVE_FAILED);
1229 #endif
1230 case _7Z_PPMD:
1231 {
1232 unsigned order;
1233 uint32_t msize;
1234
1235 if (zip->ppmd7_valid) {
1236 __archive_ppmd7_functions.Ppmd7_Free(
1237 &zip->ppmd7_context);
1238 zip->ppmd7_valid = 0;
1239 }
1240
1241 if (coder1->propertiesSize < 5) {
1242 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1243 "Malformed PPMd parameter");
1244 return (ARCHIVE_FAILED);
1245 }
1246 order = coder1->properties[0];
1247 msize = archive_le32dec(&(coder1->properties[1]));
1248 if (order < PPMD7_MIN_ORDER || order > PPMD7_MAX_ORDER ||
1249 msize < PPMD7_MIN_MEM_SIZE || msize > PPMD7_MAX_MEM_SIZE) {
1250 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1251 "Malformed PPMd parameter");
1252 return (ARCHIVE_FAILED);
1253 }
1254 __archive_ppmd7_functions.Ppmd7_Construct(&zip->ppmd7_context);
1255 r = __archive_ppmd7_functions.Ppmd7_Alloc(
1256 &zip->ppmd7_context, msize);
1257 if (r == 0) {
1258 archive_set_error(&a->archive, ENOMEM,
1259 "Coludn't allocate memory for PPMd");
1260 return (ARCHIVE_FATAL);
1261 }
1262 __archive_ppmd7_functions.Ppmd7_Init(
1263 &zip->ppmd7_context, order);
1264 __archive_ppmd7_functions.Ppmd7z_RangeDec_CreateVTable(
1265 &zip->range_dec);
1266 zip->ppmd7_valid = 1;
1267 zip->ppmd7_stat = 0;
1268 zip->ppstream.overconsumed = 0;
1269 zip->ppstream.total_in = 0;
1270 zip->ppstream.total_out = 0;
1271 break;
1272 }
1273 case _7Z_X86:
1274 case _7Z_X86_BCJ2:
1275 case _7Z_POWERPC:
1276 case _7Z_IA64:
1277 case _7Z_ARM:
1278 case _7Z_ARMTHUMB:
1279 case _7Z_SPARC:
1280 case _7Z_DELTA:
1281 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1282 "Unexpected codec ID: %lX", zip->codec);
1283 return (ARCHIVE_FAILED);
1284 case _7Z_CRYPTO_MAIN_ZIP:
1285 case _7Z_CRYPTO_RAR_29:
1286 case _7Z_CRYPTO_AES_256_SHA_256:
1287 if (a->entry) {
1288 archive_entry_set_is_metadata_encrypted(a->entry, 1);
1289 archive_entry_set_is_data_encrypted(a->entry, 1);
1290 zip->has_encrypted_entries = 1;
1291 }
1292 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1293 "Crypto codec not supported yet (ID: 0x%lX)", zip->codec);
1294 return (ARCHIVE_FAILED);
1295 default:
1296 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1297 "Unknown codec ID: %lX", zip->codec);
1298 return (ARCHIVE_FAILED);
1299 }
1300
1301 return (ARCHIVE_OK);
1302 }
1303
1304 static int
decompress(struct archive_read * a,struct _7zip * zip,void * buff,size_t * outbytes,const void * b,size_t * used)1305 decompress(struct archive_read *a, struct _7zip *zip,
1306 void *buff, size_t *outbytes, const void *b, size_t *used)
1307 {
1308 const uint8_t *t_next_in;
1309 uint8_t *t_next_out;
1310 size_t o_avail_in, o_avail_out;
1311 size_t t_avail_in, t_avail_out;
1312 uint8_t *bcj2_next_out;
1313 size_t bcj2_avail_out;
1314 int r, ret = ARCHIVE_OK;
1315
1316 t_avail_in = o_avail_in = *used;
1317 t_avail_out = o_avail_out = *outbytes;
1318 t_next_in = b;
1319 t_next_out = buff;
1320
1321 if (zip->codec != _7Z_LZMA2 && zip->codec2 == _7Z_X86) {
1322 int i;
1323
1324 /* Do not copy out the BCJ remaining bytes when the output
1325 * buffer size is less than five bytes. */
1326 if (o_avail_in != 0 && t_avail_out < 5 && zip->odd_bcj_size) {
1327 *used = 0;
1328 *outbytes = 0;
1329 return (ret);
1330 }
1331 for (i = 0; zip->odd_bcj_size > 0 && t_avail_out; i++) {
1332 *t_next_out++ = zip->odd_bcj[i];
1333 t_avail_out--;
1334 zip->odd_bcj_size--;
1335 }
1336 if (o_avail_in == 0 || t_avail_out == 0) {
1337 *used = o_avail_in - t_avail_in;
1338 *outbytes = o_avail_out - t_avail_out;
1339 if (o_avail_in == 0)
1340 ret = ARCHIVE_EOF;
1341 return (ret);
1342 }
1343 }
1344
1345 bcj2_next_out = t_next_out;
1346 bcj2_avail_out = t_avail_out;
1347 if (zip->codec2 == _7Z_X86_BCJ2) {
1348 /*
1349 * Decord a remaining decompressed main stream for BCJ2.
1350 */
1351 if (zip->tmp_stream_bytes_remaining) {
1352 ssize_t bytes;
1353 size_t remaining = zip->tmp_stream_bytes_remaining;
1354 bytes = Bcj2_Decode(zip, t_next_out, t_avail_out);
1355 if (bytes < 0) {
1356 archive_set_error(&(a->archive),
1357 ARCHIVE_ERRNO_MISC,
1358 "BCJ2 conversion Failed");
1359 return (ARCHIVE_FAILED);
1360 }
1361 zip->main_stream_bytes_remaining -=
1362 remaining - zip->tmp_stream_bytes_remaining;
1363 t_avail_out -= bytes;
1364 if (o_avail_in == 0 || t_avail_out == 0) {
1365 *used = 0;
1366 *outbytes = o_avail_out - t_avail_out;
1367 if (o_avail_in == 0 &&
1368 zip->tmp_stream_bytes_remaining)
1369 ret = ARCHIVE_EOF;
1370 return (ret);
1371 }
1372 t_next_out += bytes;
1373 bcj2_next_out = t_next_out;
1374 bcj2_avail_out = t_avail_out;
1375 }
1376 t_next_out = zip->tmp_stream_buff;
1377 t_avail_out = zip->tmp_stream_buff_size;
1378 }
1379
1380 switch (zip->codec) {
1381 case _7Z_COPY:
1382 {
1383 size_t bytes =
1384 (t_avail_in > t_avail_out)?t_avail_out:t_avail_in;
1385
1386 memcpy(t_next_out, t_next_in, bytes);
1387 t_avail_in -= bytes;
1388 t_avail_out -= bytes;
1389 if (o_avail_in == 0)
1390 ret = ARCHIVE_EOF;
1391 break;
1392 }
1393 #ifdef HAVE_LZMA_H
1394 case _7Z_LZMA: case _7Z_LZMA2:
1395 zip->lzstream.next_in = t_next_in;
1396 zip->lzstream.avail_in = t_avail_in;
1397 zip->lzstream.next_out = t_next_out;
1398 zip->lzstream.avail_out = t_avail_out;
1399
1400 r = lzma_code(&(zip->lzstream), LZMA_RUN);
1401 switch (r) {
1402 case LZMA_STREAM_END: /* Found end of stream. */
1403 lzma_end(&(zip->lzstream));
1404 zip->lzstream_valid = 0;
1405 ret = ARCHIVE_EOF;
1406 break;
1407 case LZMA_OK: /* Decompressor made some progress. */
1408 break;
1409 default:
1410 archive_set_error(&(a->archive),
1411 ARCHIVE_ERRNO_MISC,
1412 "Decompression failed(%d)",
1413 r);
1414 return (ARCHIVE_FAILED);
1415 }
1416 t_avail_in = zip->lzstream.avail_in;
1417 t_avail_out = zip->lzstream.avail_out;
1418 break;
1419 #endif
1420 #if defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR)
1421 case _7Z_BZ2:
1422 zip->bzstream.next_in = (char *)(uintptr_t)t_next_in;
1423 zip->bzstream.avail_in = t_avail_in;
1424 zip->bzstream.next_out = (char *)(uintptr_t)t_next_out;
1425 zip->bzstream.avail_out = t_avail_out;
1426 r = BZ2_bzDecompress(&(zip->bzstream));
1427 switch (r) {
1428 case BZ_STREAM_END: /* Found end of stream. */
1429 switch (BZ2_bzDecompressEnd(&(zip->bzstream))) {
1430 case BZ_OK:
1431 break;
1432 default:
1433 archive_set_error(&(a->archive),
1434 ARCHIVE_ERRNO_MISC,
1435 "Failed to clean up decompressor");
1436 return (ARCHIVE_FAILED);
1437 }
1438 zip->bzstream_valid = 0;
1439 ret = ARCHIVE_EOF;
1440 break;
1441 case BZ_OK: /* Decompressor made some progress. */
1442 break;
1443 default:
1444 archive_set_error(&(a->archive),
1445 ARCHIVE_ERRNO_MISC,
1446 "bzip decompression failed");
1447 return (ARCHIVE_FAILED);
1448 }
1449 t_avail_in = zip->bzstream.avail_in;
1450 t_avail_out = zip->bzstream.avail_out;
1451 break;
1452 #endif
1453 #ifdef HAVE_ZLIB_H
1454 case _7Z_DEFLATE:
1455 zip->stream.next_in = (Bytef *)(uintptr_t)t_next_in;
1456 zip->stream.avail_in = (uInt)t_avail_in;
1457 zip->stream.next_out = t_next_out;
1458 zip->stream.avail_out = (uInt)t_avail_out;
1459 r = inflate(&(zip->stream), 0);
1460 switch (r) {
1461 case Z_STREAM_END: /* Found end of stream. */
1462 ret = ARCHIVE_EOF;
1463 break;
1464 case Z_OK: /* Decompressor made some progress.*/
1465 break;
1466 default:
1467 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1468 "File decompression failed (%d)", r);
1469 return (ARCHIVE_FAILED);
1470 }
1471 t_avail_in = zip->stream.avail_in;
1472 t_avail_out = zip->stream.avail_out;
1473 break;
1474 #endif
1475 case _7Z_PPMD:
1476 {
1477 uint64_t flush_bytes;
1478
1479 if (!zip->ppmd7_valid || zip->ppmd7_stat < 0 ||
1480 t_avail_out <= 0) {
1481 archive_set_error(&(a->archive),
1482 ARCHIVE_ERRNO_MISC,
1483 "Decompression internal error");
1484 return (ARCHIVE_FAILED);
1485 }
1486 zip->ppstream.next_in = t_next_in;
1487 zip->ppstream.avail_in = t_avail_in;
1488 zip->ppstream.next_out = t_next_out;
1489 zip->ppstream.avail_out = t_avail_out;
1490 if (zip->ppmd7_stat == 0) {
1491 zip->bytein.a = a;
1492 zip->bytein.Read = &ppmd_read;
1493 zip->range_dec.Stream = &zip->bytein;
1494 r = __archive_ppmd7_functions.Ppmd7z_RangeDec_Init(
1495 &(zip->range_dec));
1496 if (r == 0) {
1497 zip->ppmd7_stat = -1;
1498 archive_set_error(&a->archive,
1499 ARCHIVE_ERRNO_MISC,
1500 "Failed to initialize PPMd range decoder");
1501 return (ARCHIVE_FAILED);
1502 }
1503 if (zip->ppstream.overconsumed) {
1504 zip->ppmd7_stat = -1;
1505 return (ARCHIVE_FAILED);
1506 }
1507 zip->ppmd7_stat = 1;
1508 }
1509
1510 if (t_avail_in == 0)
1511 /* XXX Flush out remaining decoded data XXX */
1512 flush_bytes = zip->folder_outbytes_remaining;
1513 else
1514 flush_bytes = 0;
1515
1516 do {
1517 int sym;
1518
1519 sym = __archive_ppmd7_functions.Ppmd7_DecodeSymbol(
1520 &(zip->ppmd7_context), &(zip->range_dec.p));
1521 if (sym < 0) {
1522 zip->ppmd7_stat = -1;
1523 archive_set_error(&a->archive,
1524 ARCHIVE_ERRNO_FILE_FORMAT,
1525 "Failed to decode PPMd");
1526 return (ARCHIVE_FAILED);
1527 }
1528 if (zip->ppstream.overconsumed) {
1529 zip->ppmd7_stat = -1;
1530 return (ARCHIVE_FAILED);
1531 }
1532 *zip->ppstream.next_out++ = (unsigned char)sym;
1533 zip->ppstream.avail_out--;
1534 zip->ppstream.total_out++;
1535 if (flush_bytes)
1536 flush_bytes--;
1537 } while (zip->ppstream.avail_out &&
1538 (zip->ppstream.avail_in || flush_bytes));
1539
1540 t_avail_in = (size_t)zip->ppstream.avail_in;
1541 t_avail_out = (size_t)zip->ppstream.avail_out;
1542 break;
1543 }
1544 default:
1545 archive_set_error(&(a->archive), ARCHIVE_ERRNO_MISC,
1546 "Decompression internal error");
1547 return (ARCHIVE_FAILED);
1548 }
1549 if (ret != ARCHIVE_OK && ret != ARCHIVE_EOF)
1550 return (ret);
1551
1552 *used = o_avail_in - t_avail_in;
1553 *outbytes = o_avail_out - t_avail_out;
1554
1555 /*
1556 * Decord BCJ.
1557 */
1558 if (zip->codec != _7Z_LZMA2 && zip->codec2 == _7Z_X86) {
1559 size_t l = x86_Convert(zip, buff, *outbytes);
1560 zip->odd_bcj_size = *outbytes - l;
1561 if (zip->odd_bcj_size > 0 && zip->odd_bcj_size <= 4 &&
1562 o_avail_in && ret != ARCHIVE_EOF) {
1563 memcpy(zip->odd_bcj, ((unsigned char *)buff) + l,
1564 zip->odd_bcj_size);
1565 *outbytes = l;
1566 } else
1567 zip->odd_bcj_size = 0;
1568 }
1569
1570 /*
1571 * Decord BCJ2 with a decompressed main stream.
1572 */
1573 if (zip->codec2 == _7Z_X86_BCJ2) {
1574 ssize_t bytes;
1575
1576 zip->tmp_stream_bytes_avail =
1577 zip->tmp_stream_buff_size - t_avail_out;
1578 if (zip->tmp_stream_bytes_avail >
1579 zip->main_stream_bytes_remaining)
1580 zip->tmp_stream_bytes_avail =
1581 zip->main_stream_bytes_remaining;
1582 zip->tmp_stream_bytes_remaining = zip->tmp_stream_bytes_avail;
1583 bytes = Bcj2_Decode(zip, bcj2_next_out, bcj2_avail_out);
1584 if (bytes < 0) {
1585 archive_set_error(&(a->archive),
1586 ARCHIVE_ERRNO_MISC, "BCJ2 conversion Failed");
1587 return (ARCHIVE_FAILED);
1588 }
1589 zip->main_stream_bytes_remaining -=
1590 zip->tmp_stream_bytes_avail
1591 - zip->tmp_stream_bytes_remaining;
1592 bcj2_avail_out -= bytes;
1593 *outbytes = o_avail_out - bcj2_avail_out;
1594 }
1595
1596 return (ret);
1597 }
1598
1599 static int
free_decompression(struct archive_read * a,struct _7zip * zip)1600 free_decompression(struct archive_read *a, struct _7zip *zip)
1601 {
1602 int r = ARCHIVE_OK;
1603
1604 #if !defined(HAVE_ZLIB_H) &&\
1605 !(defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR))
1606 (void)a;/* UNUSED */
1607 #endif
1608 #ifdef HAVE_LZMA_H
1609 if (zip->lzstream_valid)
1610 lzma_end(&(zip->lzstream));
1611 #endif
1612 #if defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR)
1613 if (zip->bzstream_valid) {
1614 if (BZ2_bzDecompressEnd(&(zip->bzstream)) != BZ_OK) {
1615 archive_set_error(&a->archive,
1616 ARCHIVE_ERRNO_MISC,
1617 "Failed to clean up bzip2 decompressor");
1618 r = ARCHIVE_FATAL;
1619 }
1620 zip->bzstream_valid = 0;
1621 }
1622 #endif
1623 #ifdef HAVE_ZLIB_H
1624 if (zip->stream_valid) {
1625 if (inflateEnd(&(zip->stream)) != Z_OK) {
1626 archive_set_error(&a->archive,
1627 ARCHIVE_ERRNO_MISC,
1628 "Failed to clean up zlib decompressor");
1629 r = ARCHIVE_FATAL;
1630 }
1631 zip->stream_valid = 0;
1632 }
1633 #endif
1634 if (zip->ppmd7_valid) {
1635 __archive_ppmd7_functions.Ppmd7_Free(
1636 &zip->ppmd7_context);
1637 zip->ppmd7_valid = 0;
1638 }
1639 return (r);
1640 }
1641
1642 static int
parse_7zip_uint64(struct archive_read * a,uint64_t * val)1643 parse_7zip_uint64(struct archive_read *a, uint64_t *val)
1644 {
1645 const unsigned char *p;
1646 unsigned char avail, mask;
1647 int i;
1648
1649 if ((p = header_bytes(a, 1)) == NULL)
1650 return (-1);
1651 avail = *p;
1652 mask = 0x80;
1653 *val = 0;
1654 for (i = 0; i < 8; i++) {
1655 if (avail & mask) {
1656 if ((p = header_bytes(a, 1)) == NULL)
1657 return (-1);
1658 *val |= ((uint64_t)*p) << (8 * i);
1659 mask >>= 1;
1660 continue;
1661 }
1662 *val += ((uint64_t)(avail & (mask -1))) << (8 * i);
1663 break;
1664 }
1665 return (0);
1666 }
1667
1668 static int
read_Bools(struct archive_read * a,unsigned char * data,size_t num)1669 read_Bools(struct archive_read *a, unsigned char *data, size_t num)
1670 {
1671 const unsigned char *p;
1672 unsigned i, mask = 0, avail = 0;
1673
1674 for (i = 0; i < num; i++) {
1675 if (mask == 0) {
1676 if ((p = header_bytes(a, 1)) == NULL)
1677 return (-1);
1678 avail = *p;
1679 mask = 0x80;
1680 }
1681 data[i] = (avail & mask)?1:0;
1682 mask >>= 1;
1683 }
1684 return (0);
1685 }
1686
1687 static void
free_Digest(struct _7z_digests * d)1688 free_Digest(struct _7z_digests *d)
1689 {
1690 free(d->defineds);
1691 free(d->digests);
1692 }
1693
1694 static int
read_Digests(struct archive_read * a,struct _7z_digests * d,size_t num)1695 read_Digests(struct archive_read *a, struct _7z_digests *d, size_t num)
1696 {
1697 const unsigned char *p;
1698 unsigned i;
1699
1700 if (num == 0)
1701 return (-1);
1702 memset(d, 0, sizeof(*d));
1703
1704 d->defineds = malloc(num);
1705 if (d->defineds == NULL)
1706 return (-1);
1707 /*
1708 * Read Bools.
1709 */
1710 if ((p = header_bytes(a, 1)) == NULL)
1711 return (-1);
1712 if (*p == 0) {
1713 if (read_Bools(a, d->defineds, num) < 0)
1714 return (-1);
1715 } else
1716 /* All are defined */
1717 memset(d->defineds, 1, num);
1718
1719 d->digests = calloc(num, sizeof(*d->digests));
1720 if (d->digests == NULL)
1721 return (-1);
1722 for (i = 0; i < num; i++) {
1723 if (d->defineds[i]) {
1724 if ((p = header_bytes(a, 4)) == NULL)
1725 return (-1);
1726 d->digests[i] = archive_le32dec(p);
1727 }
1728 }
1729
1730 return (0);
1731 }
1732
1733 static void
free_PackInfo(struct _7z_pack_info * pi)1734 free_PackInfo(struct _7z_pack_info *pi)
1735 {
1736 free(pi->sizes);
1737 free(pi->positions);
1738 free_Digest(&(pi->digest));
1739 }
1740
1741 static int
read_PackInfo(struct archive_read * a,struct _7z_pack_info * pi)1742 read_PackInfo(struct archive_read *a, struct _7z_pack_info *pi)
1743 {
1744 const unsigned char *p;
1745 unsigned i;
1746
1747 memset(pi, 0, sizeof(*pi));
1748
1749 /*
1750 * Read PackPos.
1751 */
1752 if (parse_7zip_uint64(a, &(pi->pos)) < 0)
1753 return (-1);
1754
1755 /*
1756 * Read NumPackStreams.
1757 */
1758 if (parse_7zip_uint64(a, &(pi->numPackStreams)) < 0)
1759 return (-1);
1760 if (pi->numPackStreams == 0)
1761 return (-1);
1762 if (UMAX_ENTRY < pi->numPackStreams)
1763 return (-1);
1764
1765 /*
1766 * Read PackSizes[num]
1767 */
1768 if ((p = header_bytes(a, 1)) == NULL)
1769 return (-1);
1770 if (*p == kEnd)
1771 /* PackSizes[num] are not present. */
1772 return (0);
1773 if (*p != kSize)
1774 return (-1);
1775 pi->sizes = calloc((size_t)pi->numPackStreams, sizeof(uint64_t));
1776 pi->positions = calloc((size_t)pi->numPackStreams, sizeof(uint64_t));
1777 if (pi->sizes == NULL || pi->positions == NULL)
1778 return (-1);
1779
1780 for (i = 0; i < pi->numPackStreams; i++) {
1781 if (parse_7zip_uint64(a, &(pi->sizes[i])) < 0)
1782 return (-1);
1783 }
1784
1785 /*
1786 * Read PackStreamDigests[num]
1787 */
1788 if ((p = header_bytes(a, 1)) == NULL)
1789 return (-1);
1790 if (*p == kEnd) {
1791 /* PackStreamDigests[num] are not present. */
1792 pi->digest.defineds =
1793 calloc((size_t)pi->numPackStreams, sizeof(*pi->digest.defineds));
1794 pi->digest.digests =
1795 calloc((size_t)pi->numPackStreams, sizeof(*pi->digest.digests));
1796 if (pi->digest.defineds == NULL || pi->digest.digests == NULL)
1797 return (-1);
1798 return (0);
1799 }
1800
1801 if (*p != kCRC)
1802 return (-1);
1803
1804 if (read_Digests(a, &(pi->digest), (size_t)pi->numPackStreams) < 0)
1805 return (-1);
1806
1807 /*
1808 * Must be marked by kEnd.
1809 */
1810 if ((p = header_bytes(a, 1)) == NULL)
1811 return (-1);
1812 if (*p != kEnd)
1813 return (-1);
1814 return (0);
1815 }
1816
1817 static void
free_Folder(struct _7z_folder * f)1818 free_Folder(struct _7z_folder *f)
1819 {
1820 unsigned i;
1821
1822 if (f->coders) {
1823 for (i = 0; i< f->numCoders; i++) {
1824 free(f->coders[i].properties);
1825 }
1826 free(f->coders);
1827 }
1828 free(f->bindPairs);
1829 free(f->packedStreams);
1830 free(f->unPackSize);
1831 }
1832
1833 static int
read_Folder(struct archive_read * a,struct _7z_folder * f)1834 read_Folder(struct archive_read *a, struct _7z_folder *f)
1835 {
1836 struct _7zip *zip = (struct _7zip *)a->format->data;
1837 const unsigned char *p;
1838 uint64_t numInStreamsTotal = 0;
1839 uint64_t numOutStreamsTotal = 0;
1840 unsigned i;
1841
1842 memset(f, 0, sizeof(*f));
1843
1844 /*
1845 * Read NumCoders.
1846 */
1847 if (parse_7zip_uint64(a, &(f->numCoders)) < 0)
1848 return (-1);
1849 if (f->numCoders > 4)
1850 /* Too many coders. */
1851 return (-1);
1852
1853 f->coders = calloc((size_t)f->numCoders, sizeof(*f->coders));
1854 if (f->coders == NULL)
1855 return (-1);
1856 for (i = 0; i< f->numCoders; i++) {
1857 size_t codec_size;
1858 int simple, attr;
1859
1860 if ((p = header_bytes(a, 1)) == NULL)
1861 return (-1);
1862 /*
1863 * 0:3 CodecIdSize
1864 * 4: 0 - IsSimple
1865 * 1 - Is not Simple
1866 * 5: 0 - No Attributes
1867 * 1 - There are Attributes;
1868 * 7: Must be zero.
1869 */
1870 codec_size = *p & 0xf;
1871 simple = (*p & 0x10)?0:1;
1872 attr = *p & 0x20;
1873 if (*p & 0x80)
1874 return (-1);/* Not supported. */
1875
1876 /*
1877 * Read Decompression Method IDs.
1878 */
1879 if ((p = header_bytes(a, codec_size)) == NULL)
1880 return (-1);
1881
1882 f->coders[i].codec = decode_codec_id(p, codec_size);
1883
1884 if (simple) {
1885 f->coders[i].numInStreams = 1;
1886 f->coders[i].numOutStreams = 1;
1887 } else {
1888 if (parse_7zip_uint64(
1889 a, &(f->coders[i].numInStreams)) < 0)
1890 return (-1);
1891 if (UMAX_ENTRY < f->coders[i].numInStreams)
1892 return (-1);
1893 if (parse_7zip_uint64(
1894 a, &(f->coders[i].numOutStreams)) < 0)
1895 return (-1);
1896 if (UMAX_ENTRY < f->coders[i].numOutStreams)
1897 return (-1);
1898 }
1899
1900 if (attr) {
1901 if (parse_7zip_uint64(
1902 a, &(f->coders[i].propertiesSize)) < 0)
1903 return (-1);
1904 if ((p = header_bytes(
1905 a, (size_t)f->coders[i].propertiesSize)) == NULL)
1906 return (-1);
1907 f->coders[i].properties =
1908 malloc((size_t)f->coders[i].propertiesSize);
1909 if (f->coders[i].properties == NULL)
1910 return (-1);
1911 memcpy(f->coders[i].properties, p,
1912 (size_t)f->coders[i].propertiesSize);
1913 }
1914
1915 numInStreamsTotal += f->coders[i].numInStreams;
1916 numOutStreamsTotal += f->coders[i].numOutStreams;
1917 }
1918
1919 if (numOutStreamsTotal == 0 ||
1920 numInStreamsTotal < numOutStreamsTotal-1)
1921 return (-1);
1922
1923 f->numBindPairs = numOutStreamsTotal - 1;
1924 if (zip->header_bytes_remaining < f->numBindPairs)
1925 return (-1);
1926 if (f->numBindPairs > 0) {
1927 f->bindPairs =
1928 calloc((size_t)f->numBindPairs, sizeof(*f->bindPairs));
1929 if (f->bindPairs == NULL)
1930 return (-1);
1931 } else
1932 f->bindPairs = NULL;
1933 for (i = 0; i < f->numBindPairs; i++) {
1934 if (parse_7zip_uint64(a, &(f->bindPairs[i].inIndex)) < 0)
1935 return (-1);
1936 if (UMAX_ENTRY < f->bindPairs[i].inIndex)
1937 return (-1);
1938 if (parse_7zip_uint64(a, &(f->bindPairs[i].outIndex)) < 0)
1939 return (-1);
1940 if (UMAX_ENTRY < f->bindPairs[i].outIndex)
1941 return (-1);
1942 }
1943
1944 f->numPackedStreams = numInStreamsTotal - f->numBindPairs;
1945 f->packedStreams =
1946 calloc((size_t)f->numPackedStreams, sizeof(*f->packedStreams));
1947 if (f->packedStreams == NULL)
1948 return (-1);
1949 if (f->numPackedStreams == 1) {
1950 for (i = 0; i < numInStreamsTotal; i++) {
1951 unsigned j;
1952 for (j = 0; j < f->numBindPairs; j++) {
1953 if (f->bindPairs[j].inIndex == i)
1954 break;
1955 }
1956 if (j == f->numBindPairs)
1957 break;
1958 }
1959 if (i == numInStreamsTotal)
1960 return (-1);
1961 f->packedStreams[0] = i;
1962 } else {
1963 for (i = 0; i < f->numPackedStreams; i++) {
1964 if (parse_7zip_uint64(a, &(f->packedStreams[i])) < 0)
1965 return (-1);
1966 if (UMAX_ENTRY < f->packedStreams[i])
1967 return (-1);
1968 }
1969 }
1970 f->numInStreams = numInStreamsTotal;
1971 f->numOutStreams = numOutStreamsTotal;
1972
1973 return (0);
1974 }
1975
1976 static void
free_CodersInfo(struct _7z_coders_info * ci)1977 free_CodersInfo(struct _7z_coders_info *ci)
1978 {
1979 unsigned i;
1980
1981 if (ci->folders) {
1982 for (i = 0; i < ci->numFolders; i++)
1983 free_Folder(&(ci->folders[i]));
1984 free(ci->folders);
1985 }
1986 }
1987
1988 static int
read_CodersInfo(struct archive_read * a,struct _7z_coders_info * ci)1989 read_CodersInfo(struct archive_read *a, struct _7z_coders_info *ci)
1990 {
1991 const unsigned char *p;
1992 struct _7z_digests digest;
1993 unsigned i;
1994
1995 memset(ci, 0, sizeof(*ci));
1996 memset(&digest, 0, sizeof(digest));
1997
1998 if ((p = header_bytes(a, 1)) == NULL)
1999 goto failed;
2000 if (*p != kFolder)
2001 goto failed;
2002
2003 /*
2004 * Read NumFolders.
2005 */
2006 if (parse_7zip_uint64(a, &(ci->numFolders)) < 0)
2007 goto failed;
2008 if (UMAX_ENTRY < ci->numFolders)
2009 return (-1);
2010
2011 /*
2012 * Read External.
2013 */
2014 if ((p = header_bytes(a, 1)) == NULL)
2015 goto failed;
2016 switch (*p) {
2017 case 0:
2018 ci->folders =
2019 calloc((size_t)ci->numFolders, sizeof(*ci->folders));
2020 if (ci->folders == NULL)
2021 return (-1);
2022 for (i = 0; i < ci->numFolders; i++) {
2023 if (read_Folder(a, &(ci->folders[i])) < 0)
2024 goto failed;
2025 }
2026 break;
2027 case 1:
2028 if (parse_7zip_uint64(a, &(ci->dataStreamIndex)) < 0)
2029 return (-1);
2030 if (UMAX_ENTRY < ci->dataStreamIndex)
2031 return (-1);
2032 if (ci->numFolders > 0) {
2033 archive_set_error(&a->archive, -1,
2034 "Malformed 7-Zip archive");
2035 goto failed;
2036 }
2037 break;
2038 default:
2039 archive_set_error(&a->archive, -1,
2040 "Malformed 7-Zip archive");
2041 goto failed;
2042 }
2043
2044 if ((p = header_bytes(a, 1)) == NULL)
2045 goto failed;
2046 if (*p != kCodersUnPackSize)
2047 goto failed;
2048
2049 for (i = 0; i < ci->numFolders; i++) {
2050 struct _7z_folder *folder = &(ci->folders[i]);
2051 unsigned j;
2052
2053 folder->unPackSize =
2054 calloc((size_t)folder->numOutStreams, sizeof(*folder->unPackSize));
2055 if (folder->unPackSize == NULL)
2056 goto failed;
2057 for (j = 0; j < folder->numOutStreams; j++) {
2058 if (parse_7zip_uint64(a, &(folder->unPackSize[j])) < 0)
2059 goto failed;
2060 }
2061 }
2062
2063 /*
2064 * Read CRCs.
2065 */
2066 if ((p = header_bytes(a, 1)) == NULL)
2067 goto failed;
2068 if (*p == kEnd)
2069 return (0);
2070 if (*p != kCRC)
2071 goto failed;
2072 if (read_Digests(a, &digest, (size_t)ci->numFolders) < 0)
2073 goto failed;
2074 for (i = 0; i < ci->numFolders; i++) {
2075 ci->folders[i].digest_defined = digest.defineds[i];
2076 ci->folders[i].digest = digest.digests[i];
2077 }
2078
2079 /*
2080 * Must be kEnd.
2081 */
2082 if ((p = header_bytes(a, 1)) == NULL)
2083 goto failed;
2084 if (*p != kEnd)
2085 goto failed;
2086 free_Digest(&digest);
2087 return (0);
2088 failed:
2089 free_Digest(&digest);
2090 return (-1);
2091 }
2092
2093 static uint64_t
folder_uncompressed_size(struct _7z_folder * f)2094 folder_uncompressed_size(struct _7z_folder *f)
2095 {
2096 int n = (int)f->numOutStreams;
2097 unsigned pairs = (unsigned)f->numBindPairs;
2098
2099 while (--n >= 0) {
2100 unsigned i;
2101 for (i = 0; i < pairs; i++) {
2102 if (f->bindPairs[i].outIndex == (uint64_t)n)
2103 break;
2104 }
2105 if (i >= pairs)
2106 return (f->unPackSize[n]);
2107 }
2108 return (0);
2109 }
2110
2111 static void
free_SubStreamsInfo(struct _7z_substream_info * ss)2112 free_SubStreamsInfo(struct _7z_substream_info *ss)
2113 {
2114 free(ss->unpackSizes);
2115 free(ss->digestsDefined);
2116 free(ss->digests);
2117 }
2118
2119 static int
read_SubStreamsInfo(struct archive_read * a,struct _7z_substream_info * ss,struct _7z_folder * f,size_t numFolders)2120 read_SubStreamsInfo(struct archive_read *a, struct _7z_substream_info *ss,
2121 struct _7z_folder *f, size_t numFolders)
2122 {
2123 const unsigned char *p;
2124 uint64_t *usizes;
2125 size_t unpack_streams;
2126 int type;
2127 unsigned i;
2128 uint32_t numDigests;
2129
2130 memset(ss, 0, sizeof(*ss));
2131
2132 for (i = 0; i < numFolders; i++)
2133 f[i].numUnpackStreams = 1;
2134
2135 if ((p = header_bytes(a, 1)) == NULL)
2136 return (-1);
2137 type = *p;
2138
2139 if (type == kNumUnPackStream) {
2140 unpack_streams = 0;
2141 for (i = 0; i < numFolders; i++) {
2142 if (parse_7zip_uint64(a, &(f[i].numUnpackStreams)) < 0)
2143 return (-1);
2144 if (UMAX_ENTRY < f[i].numUnpackStreams)
2145 return (-1);
2146 if (unpack_streams > SIZE_MAX - UMAX_ENTRY) {
2147 return (-1);
2148 }
2149 unpack_streams += (size_t)f[i].numUnpackStreams;
2150 }
2151 if ((p = header_bytes(a, 1)) == NULL)
2152 return (-1);
2153 type = *p;
2154 } else
2155 unpack_streams = numFolders;
2156
2157 ss->unpack_streams = unpack_streams;
2158 if (unpack_streams) {
2159 ss->unpackSizes = calloc(unpack_streams,
2160 sizeof(*ss->unpackSizes));
2161 ss->digestsDefined = calloc(unpack_streams,
2162 sizeof(*ss->digestsDefined));
2163 ss->digests = calloc(unpack_streams,
2164 sizeof(*ss->digests));
2165 if (ss->unpackSizes == NULL || ss->digestsDefined == NULL ||
2166 ss->digests == NULL)
2167 return (-1);
2168 }
2169
2170 usizes = ss->unpackSizes;
2171 for (i = 0; i < numFolders; i++) {
2172 unsigned pack;
2173 uint64_t sum;
2174
2175 if (f[i].numUnpackStreams == 0)
2176 continue;
2177
2178 sum = 0;
2179 if (type == kSize) {
2180 for (pack = 1; pack < f[i].numUnpackStreams; pack++) {
2181 if (parse_7zip_uint64(a, usizes) < 0)
2182 return (-1);
2183 sum += *usizes++;
2184 }
2185 }
2186 *usizes++ = folder_uncompressed_size(&f[i]) - sum;
2187 }
2188
2189 if (type == kSize) {
2190 if ((p = header_bytes(a, 1)) == NULL)
2191 return (-1);
2192 type = *p;
2193 }
2194
2195 for (i = 0; i < unpack_streams; i++) {
2196 ss->digestsDefined[i] = 0;
2197 ss->digests[i] = 0;
2198 }
2199
2200 numDigests = 0;
2201 for (i = 0; i < numFolders; i++) {
2202 if (f[i].numUnpackStreams != 1 || !f[i].digest_defined)
2203 numDigests += (uint32_t)f[i].numUnpackStreams;
2204 }
2205
2206 if (type == kCRC) {
2207 struct _7z_digests tmpDigests;
2208 unsigned char *digestsDefined = ss->digestsDefined;
2209 uint32_t * digests = ss->digests;
2210 int di = 0;
2211
2212 memset(&tmpDigests, 0, sizeof(tmpDigests));
2213 if (read_Digests(a, &(tmpDigests), numDigests) < 0) {
2214 free_Digest(&tmpDigests);
2215 return (-1);
2216 }
2217 for (i = 0; i < numFolders; i++) {
2218 if (f[i].numUnpackStreams == 1 && f[i].digest_defined) {
2219 *digestsDefined++ = 1;
2220 *digests++ = f[i].digest;
2221 } else {
2222 unsigned j;
2223
2224 for (j = 0; j < f[i].numUnpackStreams;
2225 j++, di++) {
2226 *digestsDefined++ =
2227 tmpDigests.defineds[di];
2228 *digests++ =
2229 tmpDigests.digests[di];
2230 }
2231 }
2232 }
2233 free_Digest(&tmpDigests);
2234 if ((p = header_bytes(a, 1)) == NULL)
2235 return (-1);
2236 type = *p;
2237 }
2238
2239 /*
2240 * Must be kEnd.
2241 */
2242 if (type != kEnd)
2243 return (-1);
2244 return (0);
2245 }
2246
2247 static void
free_StreamsInfo(struct _7z_stream_info * si)2248 free_StreamsInfo(struct _7z_stream_info *si)
2249 {
2250 free_PackInfo(&(si->pi));
2251 free_CodersInfo(&(si->ci));
2252 free_SubStreamsInfo(&(si->ss));
2253 }
2254
2255 static int
read_StreamsInfo(struct archive_read * a,struct _7z_stream_info * si)2256 read_StreamsInfo(struct archive_read *a, struct _7z_stream_info *si)
2257 {
2258 struct _7zip *zip = (struct _7zip *)a->format->data;
2259 const unsigned char *p;
2260 unsigned i;
2261
2262 memset(si, 0, sizeof(*si));
2263
2264 if ((p = header_bytes(a, 1)) == NULL)
2265 return (-1);
2266 if (*p == kPackInfo) {
2267 uint64_t packPos;
2268
2269 if (read_PackInfo(a, &(si->pi)) < 0)
2270 return (-1);
2271
2272 if (si->pi.positions == NULL || si->pi.sizes == NULL)
2273 return (-1);
2274 /*
2275 * Calculate packed stream positions.
2276 */
2277 packPos = si->pi.pos;
2278 for (i = 0; i < si->pi.numPackStreams; i++) {
2279 si->pi.positions[i] = packPos;
2280 packPos += si->pi.sizes[i];
2281 if (packPos > zip->header_offset)
2282 return (-1);
2283 }
2284 if ((p = header_bytes(a, 1)) == NULL)
2285 return (-1);
2286 }
2287 if (*p == kUnPackInfo) {
2288 uint32_t packIndex;
2289 struct _7z_folder *f;
2290
2291 if (read_CodersInfo(a, &(si->ci)) < 0)
2292 return (-1);
2293
2294 /*
2295 * Calculate packed stream indexes.
2296 */
2297 packIndex = 0;
2298 f = si->ci.folders;
2299 for (i = 0; i < si->ci.numFolders; i++) {
2300 f[i].packIndex = packIndex;
2301 packIndex += (uint32_t)f[i].numPackedStreams;
2302 if (packIndex > si->pi.numPackStreams)
2303 return (-1);
2304 }
2305 if ((p = header_bytes(a, 1)) == NULL)
2306 return (-1);
2307 }
2308
2309 if (*p == kSubStreamsInfo) {
2310 if (read_SubStreamsInfo(a, &(si->ss),
2311 si->ci.folders, (size_t)si->ci.numFolders) < 0)
2312 return (-1);
2313 if ((p = header_bytes(a, 1)) == NULL)
2314 return (-1);
2315 }
2316
2317 /*
2318 * Must be kEnd.
2319 */
2320 if (*p != kEnd)
2321 return (-1);
2322 return (0);
2323 }
2324
2325 static void
free_Header(struct _7z_header_info * h)2326 free_Header(struct _7z_header_info *h)
2327 {
2328 free(h->emptyStreamBools);
2329 free(h->emptyFileBools);
2330 free(h->antiBools);
2331 free(h->attrBools);
2332 }
2333
2334 static int
read_Header(struct archive_read * a,struct _7z_header_info * h,int check_header_id)2335 read_Header(struct archive_read *a, struct _7z_header_info *h,
2336 int check_header_id)
2337 {
2338 struct _7zip *zip = (struct _7zip *)a->format->data;
2339 const unsigned char *p;
2340 struct _7z_folder *folders;
2341 struct _7z_stream_info *si = &(zip->si);
2342 struct _7zip_entry *entries;
2343 uint32_t folderIndex, indexInFolder;
2344 unsigned i;
2345 int eindex, empty_streams, sindex;
2346
2347 if (check_header_id) {
2348 /*
2349 * Read Header.
2350 */
2351 if ((p = header_bytes(a, 1)) == NULL)
2352 return (-1);
2353 if (*p != kHeader)
2354 return (-1);
2355 }
2356
2357 /*
2358 * Read ArchiveProperties.
2359 */
2360 if ((p = header_bytes(a, 1)) == NULL)
2361 return (-1);
2362 if (*p == kArchiveProperties) {
2363 for (;;) {
2364 uint64_t size;
2365 if ((p = header_bytes(a, 1)) == NULL)
2366 return (-1);
2367 if (*p == 0)
2368 break;
2369 if (parse_7zip_uint64(a, &size) < 0)
2370 return (-1);
2371 }
2372 if ((p = header_bytes(a, 1)) == NULL)
2373 return (-1);
2374 }
2375
2376 /*
2377 * Read MainStreamsInfo.
2378 */
2379 if (*p == kMainStreamsInfo) {
2380 if (read_StreamsInfo(a, &(zip->si)) < 0)
2381 return (-1);
2382 if ((p = header_bytes(a, 1)) == NULL)
2383 return (-1);
2384 }
2385 if (*p == kEnd)
2386 return (0);
2387
2388 /*
2389 * Read FilesInfo.
2390 */
2391 if (*p != kFilesInfo)
2392 return (-1);
2393
2394 if (parse_7zip_uint64(a, &(zip->numFiles)) < 0)
2395 return (-1);
2396 if (UMAX_ENTRY < zip->numFiles)
2397 return (-1);
2398
2399 zip->entries = calloc((size_t)zip->numFiles, sizeof(*zip->entries));
2400 if (zip->entries == NULL)
2401 return (-1);
2402 entries = zip->entries;
2403
2404 empty_streams = 0;
2405 for (;;) {
2406 int type;
2407 uint64_t size;
2408 size_t ll;
2409
2410 if ((p = header_bytes(a, 1)) == NULL)
2411 return (-1);
2412 type = *p;
2413 if (type == kEnd)
2414 break;
2415
2416 if (parse_7zip_uint64(a, &size) < 0)
2417 return (-1);
2418 if (zip->header_bytes_remaining < size)
2419 return (-1);
2420 ll = (size_t)size;
2421
2422 switch (type) {
2423 case kEmptyStream:
2424 if (h->emptyStreamBools != NULL)
2425 return (-1);
2426 h->emptyStreamBools = calloc((size_t)zip->numFiles,
2427 sizeof(*h->emptyStreamBools));
2428 if (h->emptyStreamBools == NULL)
2429 return (-1);
2430 if (read_Bools(
2431 a, h->emptyStreamBools, (size_t)zip->numFiles) < 0)
2432 return (-1);
2433 empty_streams = 0;
2434 for (i = 0; i < zip->numFiles; i++) {
2435 if (h->emptyStreamBools[i])
2436 empty_streams++;
2437 }
2438 break;
2439 case kEmptyFile:
2440 if (empty_streams <= 0) {
2441 /* Unexcepted sequence. Skip this. */
2442 if (header_bytes(a, ll) == NULL)
2443 return (-1);
2444 break;
2445 }
2446 if (h->emptyFileBools != NULL)
2447 return (-1);
2448 h->emptyFileBools = calloc(empty_streams,
2449 sizeof(*h->emptyFileBools));
2450 if (h->emptyFileBools == NULL)
2451 return (-1);
2452 if (read_Bools(a, h->emptyFileBools, empty_streams) < 0)
2453 return (-1);
2454 break;
2455 case kAnti:
2456 if (empty_streams <= 0) {
2457 /* Unexcepted sequence. Skip this. */
2458 if (header_bytes(a, ll) == NULL)
2459 return (-1);
2460 break;
2461 }
2462 if (h->antiBools != NULL)
2463 return (-1);
2464 h->antiBools = calloc(empty_streams,
2465 sizeof(*h->antiBools));
2466 if (h->antiBools == NULL)
2467 return (-1);
2468 if (read_Bools(a, h->antiBools, empty_streams) < 0)
2469 return (-1);
2470 break;
2471 case kCTime:
2472 case kATime:
2473 case kMTime:
2474 if (read_Times(a, h, type) < 0)
2475 return (-1);
2476 break;
2477 case kName:
2478 {
2479 unsigned char *np;
2480 size_t nl, nb;
2481
2482 /* Skip one byte. */
2483 if ((p = header_bytes(a, 1)) == NULL)
2484 return (-1);
2485 ll--;
2486
2487 if ((ll & 1) || ll < zip->numFiles * 4)
2488 return (-1);
2489
2490 if (zip->entry_names != NULL)
2491 return (-1);
2492 zip->entry_names = malloc(ll);
2493 if (zip->entry_names == NULL)
2494 return (-1);
2495 np = zip->entry_names;
2496 nb = ll;
2497 /*
2498 * Copy whole file names.
2499 * NOTE: This loop prevents from expanding
2500 * the uncompressed buffer in order not to
2501 * use extra memory resource.
2502 */
2503 while (nb) {
2504 size_t b;
2505 if (nb > UBUFF_SIZE)
2506 b = UBUFF_SIZE;
2507 else
2508 b = nb;
2509 if ((p = header_bytes(a, b)) == NULL)
2510 return (-1);
2511 memcpy(np, p, b);
2512 np += b;
2513 nb -= b;
2514 }
2515 np = zip->entry_names;
2516 nl = ll;
2517
2518 for (i = 0; i < zip->numFiles; i++) {
2519 entries[i].utf16name = np;
2520 #if defined(_WIN32) && !defined(__CYGWIN__) && defined(_DEBUG)
2521 entries[i].wname = (wchar_t *)np;
2522 #endif
2523
2524 /* Find a terminator. */
2525 while (nl >= 2 && (np[0] || np[1])) {
2526 np += 2;
2527 nl -= 2;
2528 }
2529 if (nl < 2)
2530 return (-1);/* Terminator not found */
2531 entries[i].name_len = np - entries[i].utf16name;
2532 np += 2;
2533 nl -= 2;
2534 }
2535 break;
2536 }
2537 case kAttributes:
2538 {
2539 int allAreDefined;
2540
2541 if ((p = header_bytes(a, 2)) == NULL)
2542 return (-1);
2543 allAreDefined = *p;
2544 if (h->attrBools != NULL)
2545 return (-1);
2546 h->attrBools = calloc((size_t)zip->numFiles,
2547 sizeof(*h->attrBools));
2548 if (h->attrBools == NULL)
2549 return (-1);
2550 if (allAreDefined)
2551 memset(h->attrBools, 1, (size_t)zip->numFiles);
2552 else {
2553 if (read_Bools(a, h->attrBools,
2554 (size_t)zip->numFiles) < 0)
2555 return (-1);
2556 }
2557 for (i = 0; i < zip->numFiles; i++) {
2558 if (h->attrBools[i]) {
2559 if ((p = header_bytes(a, 4)) == NULL)
2560 return (-1);
2561 entries[i].attr = archive_le32dec(p);
2562 }
2563 }
2564 break;
2565 }
2566 case kDummy:
2567 if (ll == 0)
2568 break;
2569 __LA_FALLTHROUGH;
2570 default:
2571 if (header_bytes(a, ll) == NULL)
2572 return (-1);
2573 break;
2574 }
2575 }
2576
2577 /*
2578 * Set up entry's attributes.
2579 */
2580 folders = si->ci.folders;
2581 eindex = sindex = 0;
2582 folderIndex = indexInFolder = 0;
2583 for (i = 0; i < zip->numFiles; i++) {
2584 if (h->emptyStreamBools == NULL || h->emptyStreamBools[i] == 0)
2585 entries[i].flg |= HAS_STREAM;
2586 /* The high 16 bits of attributes is a posix file mode. */
2587 entries[i].mode = entries[i].attr >> 16;
2588 if (entries[i].flg & HAS_STREAM) {
2589 if ((size_t)sindex >= si->ss.unpack_streams)
2590 return (-1);
2591 if (entries[i].mode == 0)
2592 entries[i].mode = AE_IFREG | 0666;
2593 if (si->ss.digestsDefined[sindex])
2594 entries[i].flg |= CRC32_IS_SET;
2595 entries[i].ssIndex = sindex;
2596 sindex++;
2597 } else {
2598 int dir;
2599 if (h->emptyFileBools == NULL)
2600 dir = 1;
2601 else {
2602 if (h->emptyFileBools[eindex])
2603 dir = 0;
2604 else
2605 dir = 1;
2606 eindex++;
2607 }
2608 if (entries[i].mode == 0) {
2609 if (dir)
2610 entries[i].mode = AE_IFDIR | 0777;
2611 else
2612 entries[i].mode = AE_IFREG | 0666;
2613 } else if (dir &&
2614 (entries[i].mode & AE_IFMT) != AE_IFDIR) {
2615 entries[i].mode &= ~AE_IFMT;
2616 entries[i].mode |= AE_IFDIR;
2617 }
2618 if ((entries[i].mode & AE_IFMT) == AE_IFDIR &&
2619 entries[i].name_len >= 2 &&
2620 (entries[i].utf16name[entries[i].name_len-2] != '/' ||
2621 entries[i].utf16name[entries[i].name_len-1] != 0)) {
2622 entries[i].utf16name[entries[i].name_len] = '/';
2623 entries[i].utf16name[entries[i].name_len+1] = 0;
2624 entries[i].name_len += 2;
2625 }
2626 entries[i].ssIndex = -1;
2627 }
2628 if (entries[i].attr & 0x01)
2629 entries[i].mode &= ~0222;/* Read only. */
2630
2631 if ((entries[i].flg & HAS_STREAM) == 0 && indexInFolder == 0) {
2632 /*
2633 * The entry is an empty file or a directory file,
2634 * those both have no contents.
2635 */
2636 entries[i].folderIndex = -1;
2637 continue;
2638 }
2639 if (indexInFolder == 0) {
2640 for (;;) {
2641 if (folderIndex >= si->ci.numFolders)
2642 return (-1);
2643 if (folders[folderIndex].numUnpackStreams)
2644 break;
2645 folderIndex++;
2646 }
2647 }
2648 entries[i].folderIndex = folderIndex;
2649 if ((entries[i].flg & HAS_STREAM) == 0)
2650 continue;
2651 indexInFolder++;
2652 if (indexInFolder >= folders[folderIndex].numUnpackStreams) {
2653 folderIndex++;
2654 indexInFolder = 0;
2655 }
2656 }
2657
2658 return (0);
2659 }
2660
2661 #define EPOC_TIME ARCHIVE_LITERAL_ULL(116444736000000000)
2662 static void
fileTimeToUtc(uint64_t fileTime,time_t * timep,long * ns)2663 fileTimeToUtc(uint64_t fileTime, time_t *timep, long *ns)
2664 {
2665
2666 if (fileTime >= EPOC_TIME) {
2667 fileTime -= EPOC_TIME;
2668 /* milli seconds base */
2669 *timep = (time_t)(fileTime / 10000000);
2670 /* nano seconds base */
2671 *ns = (long)(fileTime % 10000000) * 100;
2672 } else {
2673 *timep = 0;
2674 *ns = 0;
2675 }
2676 }
2677
2678 static int
read_Times(struct archive_read * a,struct _7z_header_info * h,int type)2679 read_Times(struct archive_read *a, struct _7z_header_info *h, int type)
2680 {
2681 struct _7zip *zip = (struct _7zip *)a->format->data;
2682 const unsigned char *p;
2683 struct _7zip_entry *entries = zip->entries;
2684 unsigned char *timeBools;
2685 int allAreDefined;
2686 unsigned i;
2687
2688 timeBools = calloc((size_t)zip->numFiles, sizeof(*timeBools));
2689 if (timeBools == NULL)
2690 return (-1);
2691
2692 /* Read allAreDefined. */
2693 if ((p = header_bytes(a, 1)) == NULL)
2694 goto failed;
2695 allAreDefined = *p;
2696 if (allAreDefined)
2697 memset(timeBools, 1, (size_t)zip->numFiles);
2698 else {
2699 if (read_Bools(a, timeBools, (size_t)zip->numFiles) < 0)
2700 goto failed;
2701 }
2702
2703 /* Read external. */
2704 if ((p = header_bytes(a, 1)) == NULL)
2705 goto failed;
2706 if (*p) {
2707 if (parse_7zip_uint64(a, &(h->dataIndex)) < 0)
2708 goto failed;
2709 if (UMAX_ENTRY < h->dataIndex)
2710 goto failed;
2711 }
2712
2713 for (i = 0; i < zip->numFiles; i++) {
2714 if (!timeBools[i])
2715 continue;
2716 if ((p = header_bytes(a, 8)) == NULL)
2717 goto failed;
2718 switch (type) {
2719 case kCTime:
2720 fileTimeToUtc(archive_le64dec(p),
2721 &(entries[i].ctime),
2722 &(entries[i].ctime_ns));
2723 entries[i].flg |= CTIME_IS_SET;
2724 break;
2725 case kATime:
2726 fileTimeToUtc(archive_le64dec(p),
2727 &(entries[i].atime),
2728 &(entries[i].atime_ns));
2729 entries[i].flg |= ATIME_IS_SET;
2730 break;
2731 case kMTime:
2732 fileTimeToUtc(archive_le64dec(p),
2733 &(entries[i].mtime),
2734 &(entries[i].mtime_ns));
2735 entries[i].flg |= MTIME_IS_SET;
2736 break;
2737 }
2738 }
2739
2740 free(timeBools);
2741 return (0);
2742 failed:
2743 free(timeBools);
2744 return (-1);
2745 }
2746
2747 static int
decode_encoded_header_info(struct archive_read * a,struct _7z_stream_info * si)2748 decode_encoded_header_info(struct archive_read *a, struct _7z_stream_info *si)
2749 {
2750 struct _7zip *zip = (struct _7zip *)a->format->data;
2751
2752 errno = 0;
2753 if (read_StreamsInfo(a, si) < 0) {
2754 if (errno == ENOMEM)
2755 archive_set_error(&a->archive, -1,
2756 "Couldn't allocate memory");
2757 else
2758 archive_set_error(&a->archive, -1,
2759 "Malformed 7-Zip archive");
2760 return (ARCHIVE_FATAL);
2761 }
2762
2763 if (si->pi.numPackStreams == 0 || si->ci.numFolders == 0) {
2764 archive_set_error(&a->archive, -1, "Malformed 7-Zip archive");
2765 return (ARCHIVE_FATAL);
2766 }
2767
2768 if (zip->header_offset < si->pi.pos + si->pi.sizes[0] ||
2769 (int64_t)(si->pi.pos + si->pi.sizes[0]) < 0 ||
2770 si->pi.sizes[0] == 0 || (int64_t)si->pi.pos < 0) {
2771 archive_set_error(&a->archive, -1, "Malformed Header offset");
2772 return (ARCHIVE_FATAL);
2773 }
2774
2775 return (ARCHIVE_OK);
2776 }
2777
2778 static const unsigned char *
header_bytes(struct archive_read * a,size_t rbytes)2779 header_bytes(struct archive_read *a, size_t rbytes)
2780 {
2781 struct _7zip *zip = (struct _7zip *)a->format->data;
2782 const unsigned char *p;
2783
2784 if (zip->header_bytes_remaining < rbytes)
2785 return (NULL);
2786 if (zip->pack_stream_bytes_unconsumed)
2787 read_consume(a);
2788
2789 if (zip->header_is_encoded == 0) {
2790 p = __archive_read_ahead(a, rbytes, NULL);
2791 if (p == NULL)
2792 return (NULL);
2793 zip->header_bytes_remaining -= rbytes;
2794 zip->pack_stream_bytes_unconsumed = rbytes;
2795 } else {
2796 const void *buff;
2797 ssize_t bytes;
2798
2799 bytes = read_stream(a, &buff, rbytes, rbytes);
2800 if (bytes <= 0)
2801 return (NULL);
2802 zip->header_bytes_remaining -= bytes;
2803 p = buff;
2804 }
2805
2806 /* Update checksum */
2807 zip->header_crc32 = crc32(zip->header_crc32, p, (unsigned)rbytes);
2808 return (p);
2809 }
2810
2811 static int
slurp_central_directory(struct archive_read * a,struct _7zip * zip,struct _7z_header_info * header)2812 slurp_central_directory(struct archive_read *a, struct _7zip *zip,
2813 struct _7z_header_info *header)
2814 {
2815 const unsigned char *p;
2816 uint64_t next_header_offset;
2817 uint64_t next_header_size;
2818 uint32_t next_header_crc;
2819 ssize_t bytes_avail;
2820 int check_header_crc, r;
2821
2822 if ((p = __archive_read_ahead(a, 32, &bytes_avail)) == NULL)
2823 return (ARCHIVE_FATAL);
2824
2825 if ((p[0] == 'M' && p[1] == 'Z') || memcmp(p, "\x7F\x45LF", 4) == 0) {
2826 /* This is an executable ? Must be self-extracting... */
2827 r = skip_sfx(a, bytes_avail);
2828 if (r < ARCHIVE_WARN)
2829 return (r);
2830 if ((p = __archive_read_ahead(a, 32, &bytes_avail)) == NULL)
2831 return (ARCHIVE_FATAL);
2832 }
2833 zip->seek_base += 32;
2834
2835 if (memcmp(p, _7ZIP_SIGNATURE, 6) != 0) {
2836 archive_set_error(&a->archive, -1, "Not 7-Zip archive file");
2837 return (ARCHIVE_FATAL);
2838 }
2839
2840 /* CRC check. */
2841 if (crc32(0, (const unsigned char *)p + 12, 20)
2842 != archive_le32dec(p + 8)) {
2843 archive_set_error(&a->archive, -1, "Header CRC error");
2844 return (ARCHIVE_FATAL);
2845 }
2846
2847 next_header_offset = archive_le64dec(p + 12);
2848 next_header_size = archive_le64dec(p + 20);
2849 next_header_crc = archive_le32dec(p + 28);
2850
2851 if (next_header_size == 0)
2852 /* There is no entry in an archive file. */
2853 return (ARCHIVE_EOF);
2854
2855 if (((int64_t)next_header_offset) < 0) {
2856 archive_set_error(&a->archive, -1, "Malformed 7-Zip archive");
2857 return (ARCHIVE_FATAL);
2858 }
2859 __archive_read_consume(a, 32);
2860 if (next_header_offset != 0) {
2861 if (bytes_avail >= (ssize_t)next_header_offset)
2862 __archive_read_consume(a, next_header_offset);
2863 else if (__archive_read_seek(a,
2864 next_header_offset + zip->seek_base, SEEK_SET) < 0)
2865 return (ARCHIVE_FATAL);
2866 }
2867 zip->stream_offset = next_header_offset;
2868 zip->header_offset = next_header_offset;
2869 zip->header_bytes_remaining = next_header_size;
2870 zip->header_crc32 = 0;
2871 zip->header_is_encoded = 0;
2872 zip->header_is_being_read = 1;
2873 zip->has_encrypted_entries = 0;
2874 check_header_crc = 1;
2875
2876 if ((p = header_bytes(a, 1)) == NULL) {
2877 archive_set_error(&a->archive,
2878 ARCHIVE_ERRNO_FILE_FORMAT,
2879 "Truncated 7-Zip file body");
2880 return (ARCHIVE_FATAL);
2881 }
2882 /* Parse ArchiveProperties. */
2883 switch (p[0]) {
2884 case kEncodedHeader:
2885 /*
2886 * The archive has an encoded header and we have to decode it
2887 * in order to parse the header correctly.
2888 */
2889 r = decode_encoded_header_info(a, &(zip->si));
2890
2891 /* Check the EncodedHeader CRC.*/
2892 if (r == 0 && zip->header_crc32 != next_header_crc) {
2893 archive_set_error(&a->archive, -1,
2894 "Damaged 7-Zip archive");
2895 r = -1;
2896 }
2897 if (r == 0) {
2898 if (zip->si.ci.folders[0].digest_defined)
2899 next_header_crc = zip->si.ci.folders[0].digest;
2900 else
2901 check_header_crc = 0;
2902 if (zip->pack_stream_bytes_unconsumed)
2903 read_consume(a);
2904 r = setup_decode_folder(a, zip->si.ci.folders, 1);
2905 if (r == 0) {
2906 zip->header_bytes_remaining =
2907 zip->folder_outbytes_remaining;
2908 r = seek_pack(a);
2909 }
2910 }
2911 /* Clean up StreamsInfo. */
2912 free_StreamsInfo(&(zip->si));
2913 memset(&(zip->si), 0, sizeof(zip->si));
2914 if (r < 0)
2915 return (ARCHIVE_FATAL);
2916 zip->header_is_encoded = 1;
2917 zip->header_crc32 = 0;
2918 /* FALL THROUGH */
2919 case kHeader:
2920 /*
2921 * Parse the header.
2922 */
2923 errno = 0;
2924 r = read_Header(a, header, zip->header_is_encoded);
2925 if (r < 0) {
2926 if (errno == ENOMEM)
2927 archive_set_error(&a->archive, -1,
2928 "Couldn't allocate memory");
2929 else
2930 archive_set_error(&a->archive, -1,
2931 "Damaged 7-Zip archive");
2932 return (ARCHIVE_FATAL);
2933 }
2934
2935 /*
2936 * Must be kEnd.
2937 */
2938 if ((p = header_bytes(a, 1)) == NULL ||*p != kEnd) {
2939 archive_set_error(&a->archive, -1,
2940 "Malformed 7-Zip archive");
2941 return (ARCHIVE_FATAL);
2942 }
2943
2944 /* Check the Header CRC.*/
2945 if (check_header_crc && zip->header_crc32 != next_header_crc) {
2946 archive_set_error(&a->archive, -1,
2947 "Malformed 7-Zip archive");
2948 return (ARCHIVE_FATAL);
2949 }
2950 break;
2951 default:
2952 archive_set_error(&a->archive, -1,
2953 "Unexpected Property ID = %X", p[0]);
2954 return (ARCHIVE_FATAL);
2955 }
2956
2957 /* Clean up variables be used for decoding the archive header */
2958 zip->pack_stream_remaining = 0;
2959 zip->pack_stream_index = 0;
2960 zip->folder_outbytes_remaining = 0;
2961 zip->uncompressed_buffer_bytes_remaining = 0;
2962 zip->pack_stream_bytes_unconsumed = 0;
2963 zip->header_is_being_read = 0;
2964
2965 return (ARCHIVE_OK);
2966 }
2967
2968 static ssize_t
get_uncompressed_data(struct archive_read * a,const void ** buff,size_t size,size_t minimum)2969 get_uncompressed_data(struct archive_read *a, const void **buff, size_t size,
2970 size_t minimum)
2971 {
2972 struct _7zip *zip = (struct _7zip *)a->format->data;
2973 ssize_t bytes_avail;
2974
2975 if (zip->codec == _7Z_COPY && zip->codec2 == (unsigned long)-1) {
2976 /* Copy mode. */
2977
2978 *buff = __archive_read_ahead(a, minimum, &bytes_avail);
2979 if (bytes_avail <= 0) {
2980 archive_set_error(&a->archive,
2981 ARCHIVE_ERRNO_FILE_FORMAT,
2982 "Truncated 7-Zip file data");
2983 return (ARCHIVE_FATAL);
2984 }
2985 if ((size_t)bytes_avail >
2986 zip->uncompressed_buffer_bytes_remaining)
2987 bytes_avail = (ssize_t)
2988 zip->uncompressed_buffer_bytes_remaining;
2989 if ((size_t)bytes_avail > size)
2990 bytes_avail = (ssize_t)size;
2991
2992 zip->pack_stream_bytes_unconsumed = bytes_avail;
2993 } else if (zip->uncompressed_buffer_pointer == NULL) {
2994 /* Decompression has failed. */
2995 archive_set_error(&(a->archive),
2996 ARCHIVE_ERRNO_MISC, "Damaged 7-Zip archive");
2997 return (ARCHIVE_FATAL);
2998 } else {
2999 /* Packed mode. */
3000 if (minimum > zip->uncompressed_buffer_bytes_remaining) {
3001 /*
3002 * If remaining uncompressed data size is less than
3003 * the minimum size, fill the buffer up to the
3004 * minimum size.
3005 */
3006 if (extract_pack_stream(a, minimum) < 0)
3007 return (ARCHIVE_FATAL);
3008 }
3009 if (size > zip->uncompressed_buffer_bytes_remaining)
3010 bytes_avail = (ssize_t)
3011 zip->uncompressed_buffer_bytes_remaining;
3012 else
3013 bytes_avail = (ssize_t)size;
3014 *buff = zip->uncompressed_buffer_pointer;
3015 zip->uncompressed_buffer_pointer += bytes_avail;
3016 }
3017 zip->uncompressed_buffer_bytes_remaining -= bytes_avail;
3018 return (bytes_avail);
3019 }
3020
3021 static ssize_t
extract_pack_stream(struct archive_read * a,size_t minimum)3022 extract_pack_stream(struct archive_read *a, size_t minimum)
3023 {
3024 struct _7zip *zip = (struct _7zip *)a->format->data;
3025 ssize_t bytes_avail;
3026 int r;
3027
3028 if (zip->codec == _7Z_COPY && zip->codec2 == (unsigned long)-1) {
3029 if (minimum == 0)
3030 minimum = 1;
3031 if (__archive_read_ahead(a, minimum, &bytes_avail) == NULL
3032 || bytes_avail <= 0) {
3033 archive_set_error(&a->archive,
3034 ARCHIVE_ERRNO_FILE_FORMAT,
3035 "Truncated 7-Zip file body");
3036 return (ARCHIVE_FATAL);
3037 }
3038 if ((uint64_t)bytes_avail > zip->pack_stream_inbytes_remaining)
3039 bytes_avail = (ssize_t)zip->pack_stream_inbytes_remaining;
3040 zip->pack_stream_inbytes_remaining -= bytes_avail;
3041 if ((uint64_t)bytes_avail > zip->folder_outbytes_remaining)
3042 bytes_avail = (ssize_t)zip->folder_outbytes_remaining;
3043 zip->folder_outbytes_remaining -= bytes_avail;
3044 zip->uncompressed_buffer_bytes_remaining = bytes_avail;
3045 return (ARCHIVE_OK);
3046 }
3047
3048 /* If the buffer hasn't been allocated, allocate it now. */
3049 if (zip->uncompressed_buffer == NULL) {
3050 zip->uncompressed_buffer_size = UBUFF_SIZE;
3051 if (zip->uncompressed_buffer_size < minimum) {
3052 zip->uncompressed_buffer_size = minimum + 1023;
3053 zip->uncompressed_buffer_size &= ~0x3ff;
3054 }
3055 zip->uncompressed_buffer =
3056 malloc(zip->uncompressed_buffer_size);
3057 if (zip->uncompressed_buffer == NULL) {
3058 archive_set_error(&a->archive, ENOMEM,
3059 "No memory for 7-Zip decompression");
3060 return (ARCHIVE_FATAL);
3061 }
3062 zip->uncompressed_buffer_bytes_remaining = 0;
3063 } else if (zip->uncompressed_buffer_size < minimum ||
3064 zip->uncompressed_buffer_bytes_remaining < minimum) {
3065 /*
3066 * Make sure the uncompressed buffer can have bytes
3067 * at least `minimum' bytes.
3068 * NOTE: This case happen when reading the header.
3069 */
3070 size_t used;
3071 if (zip->uncompressed_buffer_pointer != 0)
3072 used = zip->uncompressed_buffer_pointer -
3073 zip->uncompressed_buffer;
3074 else
3075 used = 0;
3076 if (zip->uncompressed_buffer_size < minimum) {
3077 /*
3078 * Expand the uncompressed buffer up to
3079 * the minimum size.
3080 */
3081 void *p;
3082 size_t new_size;
3083
3084 new_size = minimum + 1023;
3085 new_size &= ~0x3ff;
3086 p = realloc(zip->uncompressed_buffer, new_size);
3087 if (p == NULL) {
3088 archive_set_error(&a->archive, ENOMEM,
3089 "No memory for 7-Zip decompression");
3090 return (ARCHIVE_FATAL);
3091 }
3092 zip->uncompressed_buffer = (unsigned char *)p;
3093 zip->uncompressed_buffer_size = new_size;
3094 }
3095 /*
3096 * Move unconsumed bytes to the head.
3097 */
3098 if (used) {
3099 memmove(zip->uncompressed_buffer,
3100 zip->uncompressed_buffer + used,
3101 zip->uncompressed_buffer_bytes_remaining);
3102 }
3103 } else
3104 zip->uncompressed_buffer_bytes_remaining = 0;
3105 zip->uncompressed_buffer_pointer = NULL;
3106 for (;;) {
3107 size_t bytes_in, bytes_out;
3108 const void *buff_in;
3109 unsigned char *buff_out;
3110 int end_of_data;
3111
3112 /*
3113 * Note: '1' here is a performance optimization.
3114 * Recall that the decompression layer returns a count of
3115 * available bytes; asking for more than that forces the
3116 * decompressor to combine reads by copying data.
3117 */
3118 buff_in = __archive_read_ahead(a, 1, &bytes_avail);
3119 if (bytes_avail <= 0) {
3120 archive_set_error(&a->archive,
3121 ARCHIVE_ERRNO_FILE_FORMAT,
3122 "Truncated 7-Zip file body");
3123 return (ARCHIVE_FATAL);
3124 }
3125
3126 buff_out = zip->uncompressed_buffer
3127 + zip->uncompressed_buffer_bytes_remaining;
3128 bytes_out = zip->uncompressed_buffer_size
3129 - zip->uncompressed_buffer_bytes_remaining;
3130 bytes_in = bytes_avail;
3131 if (bytes_in > zip->pack_stream_inbytes_remaining)
3132 bytes_in = (size_t)zip->pack_stream_inbytes_remaining;
3133 /* Drive decompression. */
3134 r = decompress(a, zip, buff_out, &bytes_out,
3135 buff_in, &bytes_in);
3136 switch (r) {
3137 case ARCHIVE_OK:
3138 end_of_data = 0;
3139 break;
3140 case ARCHIVE_EOF:
3141 end_of_data = 1;
3142 break;
3143 default:
3144 return (ARCHIVE_FATAL);
3145 }
3146 zip->pack_stream_inbytes_remaining -= bytes_in;
3147 if (bytes_out > zip->folder_outbytes_remaining)
3148 bytes_out = (size_t)zip->folder_outbytes_remaining;
3149 zip->folder_outbytes_remaining -= bytes_out;
3150 zip->uncompressed_buffer_bytes_remaining += bytes_out;
3151 zip->pack_stream_bytes_unconsumed = bytes_in;
3152
3153 /*
3154 * Continue decompression until uncompressed_buffer is full.
3155 */
3156 if (zip->uncompressed_buffer_bytes_remaining ==
3157 zip->uncompressed_buffer_size)
3158 break;
3159 if (zip->codec2 == _7Z_X86 && zip->odd_bcj_size &&
3160 zip->uncompressed_buffer_bytes_remaining + 5 >
3161 zip->uncompressed_buffer_size)
3162 break;
3163 if (zip->pack_stream_inbytes_remaining == 0 &&
3164 zip->folder_outbytes_remaining == 0)
3165 break;
3166 if (end_of_data || (bytes_in == 0 && bytes_out == 0)) {
3167 archive_set_error(&(a->archive),
3168 ARCHIVE_ERRNO_MISC, "Damaged 7-Zip archive");
3169 return (ARCHIVE_FATAL);
3170 }
3171 read_consume(a);
3172 }
3173 if (zip->uncompressed_buffer_bytes_remaining < minimum) {
3174 archive_set_error(&(a->archive),
3175 ARCHIVE_ERRNO_MISC, "Damaged 7-Zip archive");
3176 return (ARCHIVE_FATAL);
3177 }
3178 zip->uncompressed_buffer_pointer = zip->uncompressed_buffer;
3179 return (ARCHIVE_OK);
3180 }
3181
3182 static int
seek_pack(struct archive_read * a)3183 seek_pack(struct archive_read *a)
3184 {
3185 struct _7zip *zip = (struct _7zip *)a->format->data;
3186 int64_t pack_offset;
3187
3188 if (zip->pack_stream_remaining <= 0) {
3189 archive_set_error(&(a->archive),
3190 ARCHIVE_ERRNO_MISC, "Damaged 7-Zip archive");
3191 return (ARCHIVE_FATAL);
3192 }
3193 zip->pack_stream_inbytes_remaining =
3194 zip->si.pi.sizes[zip->pack_stream_index];
3195 pack_offset = zip->si.pi.positions[zip->pack_stream_index];
3196 if (zip->stream_offset != pack_offset) {
3197 if (0 > __archive_read_seek(a, pack_offset + zip->seek_base,
3198 SEEK_SET))
3199 return (ARCHIVE_FATAL);
3200 zip->stream_offset = pack_offset;
3201 }
3202 zip->pack_stream_index++;
3203 zip->pack_stream_remaining--;
3204 return (ARCHIVE_OK);
3205 }
3206
3207 static ssize_t
read_stream(struct archive_read * a,const void ** buff,size_t size,size_t minimum)3208 read_stream(struct archive_read *a, const void **buff, size_t size,
3209 size_t minimum)
3210 {
3211 struct _7zip *zip = (struct _7zip *)a->format->data;
3212 uint64_t skip_bytes = 0;
3213 ssize_t r;
3214
3215 if (zip->uncompressed_buffer_bytes_remaining == 0) {
3216 if (zip->pack_stream_inbytes_remaining > 0) {
3217 r = extract_pack_stream(a, 0);
3218 if (r < 0)
3219 return (r);
3220 return (get_uncompressed_data(a, buff, size, minimum));
3221 } else if (zip->folder_outbytes_remaining > 0) {
3222 /* Extract a remaining pack stream. */
3223 r = extract_pack_stream(a, 0);
3224 if (r < 0)
3225 return (r);
3226 return (get_uncompressed_data(a, buff, size, minimum));
3227 }
3228 } else
3229 return (get_uncompressed_data(a, buff, size, minimum));
3230
3231 /*
3232 * Current pack stream has been consumed.
3233 */
3234 if (zip->pack_stream_remaining == 0) {
3235 if (zip->header_is_being_read) {
3236 /* Invalid sequence. This might happen when
3237 * reading a malformed archive. */
3238 archive_set_error(&(a->archive),
3239 ARCHIVE_ERRNO_MISC, "Malformed 7-Zip archive");
3240 return (ARCHIVE_FATAL);
3241 }
3242
3243 /*
3244 * All current folder's pack streams have been
3245 * consumed. Switch to next folder.
3246 */
3247 if (zip->folder_index == 0 &&
3248 (zip->si.ci.folders[zip->entry->folderIndex].skipped_bytes
3249 || zip->folder_index != zip->entry->folderIndex)) {
3250 zip->folder_index = zip->entry->folderIndex;
3251 skip_bytes =
3252 zip->si.ci.folders[zip->folder_index].skipped_bytes;
3253 }
3254
3255 if (zip->folder_index >= zip->si.ci.numFolders) {
3256 /*
3257 * We have consumed all folders and its pack streams.
3258 */
3259 *buff = NULL;
3260 return (0);
3261 }
3262 r = setup_decode_folder(a,
3263 &(zip->si.ci.folders[zip->folder_index]), 0);
3264 if (r != ARCHIVE_OK)
3265 return (ARCHIVE_FATAL);
3266
3267 zip->folder_index++;
3268 }
3269
3270 /*
3271 * Switch to next pack stream.
3272 */
3273 r = seek_pack(a);
3274 if (r < 0)
3275 return (r);
3276
3277 /* Extract a new pack stream. */
3278 r = extract_pack_stream(a, 0);
3279 if (r < 0)
3280 return (r);
3281
3282 /*
3283 * Skip the bytes we already has skipped in skip_stream().
3284 */
3285 while (skip_bytes) {
3286 ssize_t skipped;
3287
3288 if (zip->uncompressed_buffer_bytes_remaining == 0) {
3289 if (zip->pack_stream_inbytes_remaining > 0) {
3290 r = extract_pack_stream(a, 0);
3291 if (r < 0)
3292 return (r);
3293 } else if (zip->folder_outbytes_remaining > 0) {
3294 /* Extract a remaining pack stream. */
3295 r = extract_pack_stream(a, 0);
3296 if (r < 0)
3297 return (r);
3298 } else {
3299 archive_set_error(&a->archive,
3300 ARCHIVE_ERRNO_FILE_FORMAT,
3301 "Truncated 7-Zip file body");
3302 return (ARCHIVE_FATAL);
3303 }
3304 }
3305 skipped = get_uncompressed_data(
3306 a, buff, (size_t)skip_bytes, 0);
3307 if (skipped < 0)
3308 return (skipped);
3309 skip_bytes -= skipped;
3310 if (zip->pack_stream_bytes_unconsumed)
3311 read_consume(a);
3312 }
3313
3314 return (get_uncompressed_data(a, buff, size, minimum));
3315 }
3316
3317 static int
setup_decode_folder(struct archive_read * a,struct _7z_folder * folder,int header)3318 setup_decode_folder(struct archive_read *a, struct _7z_folder *folder,
3319 int header)
3320 {
3321 struct _7zip *zip = (struct _7zip *)a->format->data;
3322 const struct _7z_coder *coder1, *coder2;
3323 const char *cname = (header)?"archive header":"file content";
3324 unsigned i;
3325 int r, found_bcj2 = 0;
3326
3327 /*
3328 * Release the memory which the previous folder used for BCJ2.
3329 */
3330 for (i = 0; i < 3; i++) {
3331 free(zip->sub_stream_buff[i]);
3332 zip->sub_stream_buff[i] = NULL;
3333 }
3334
3335 /*
3336 * Initialize a stream reader.
3337 */
3338 zip->pack_stream_remaining = (unsigned)folder->numPackedStreams;
3339 zip->pack_stream_index = (unsigned)folder->packIndex;
3340 zip->folder_outbytes_remaining = folder_uncompressed_size(folder);
3341 zip->uncompressed_buffer_bytes_remaining = 0;
3342
3343 /*
3344 * Check coder types.
3345 */
3346 for (i = 0; i < folder->numCoders; i++) {
3347 switch(folder->coders[i].codec) {
3348 case _7Z_CRYPTO_MAIN_ZIP:
3349 case _7Z_CRYPTO_RAR_29:
3350 case _7Z_CRYPTO_AES_256_SHA_256: {
3351 /* For entry that is associated with this folder, mark
3352 it as encrypted (data+metadata). */
3353 zip->has_encrypted_entries = 1;
3354 if (a->entry) {
3355 archive_entry_set_is_data_encrypted(a->entry, 1);
3356 archive_entry_set_is_metadata_encrypted(a->entry, 1);
3357 }
3358 archive_set_error(&(a->archive),
3359 ARCHIVE_ERRNO_MISC,
3360 "The %s is encrypted, "
3361 "but currently not supported", cname);
3362 return (ARCHIVE_FATAL);
3363 }
3364 case _7Z_X86_BCJ2: {
3365 found_bcj2++;
3366 break;
3367 }
3368 }
3369 }
3370 /* Now that we've checked for encryption, if there were still no
3371 * encrypted entries found we can say for sure that there are none.
3372 */
3373 if (zip->has_encrypted_entries == ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW) {
3374 zip->has_encrypted_entries = 0;
3375 }
3376
3377 if ((folder->numCoders > 2 && !found_bcj2) || found_bcj2 > 1) {
3378 archive_set_error(&(a->archive),
3379 ARCHIVE_ERRNO_MISC,
3380 "The %s is encoded with many filters, "
3381 "but currently not supported", cname);
3382 return (ARCHIVE_FATAL);
3383 }
3384 coder1 = &(folder->coders[0]);
3385 if (folder->numCoders == 2)
3386 coder2 = &(folder->coders[1]);
3387 else
3388 coder2 = NULL;
3389
3390 if (found_bcj2) {
3391 /*
3392 * Preparation to decode BCJ2.
3393 * Decoding BCJ2 requires four sources. Those are at least,
3394 * as far as I know, two types of the storage form.
3395 */
3396 const struct _7z_coder *fc = folder->coders;
3397 static const struct _7z_coder coder_copy = {0, 1, 1, 0, NULL};
3398 const struct _7z_coder *scoder[3] =
3399 {&coder_copy, &coder_copy, &coder_copy};
3400 const void *buff;
3401 ssize_t bytes;
3402 unsigned char *b[3] = {NULL, NULL, NULL};
3403 uint64_t sunpack[3] ={-1, -1, -1};
3404 size_t s[3] = {0, 0, 0};
3405 int idx[3] = {0, 1, 2};
3406
3407 if (folder->numCoders == 4 && fc[3].codec == _7Z_X86_BCJ2 &&
3408 folder->numInStreams == 7 && folder->numOutStreams == 4 &&
3409 zip->pack_stream_remaining == 4) {
3410 /* Source type 1 made by 7zr or 7z with -m options. */
3411 if (folder->bindPairs[0].inIndex == 5) {
3412 /* The form made by 7zr */
3413 idx[0] = 1; idx[1] = 2; idx[2] = 0;
3414 scoder[1] = &(fc[1]);
3415 scoder[2] = &(fc[0]);
3416 sunpack[1] = folder->unPackSize[1];
3417 sunpack[2] = folder->unPackSize[0];
3418 coder1 = &(fc[2]);
3419 } else {
3420 /*
3421 * NOTE: Some patterns do not work.
3422 * work:
3423 * 7z a -m0=BCJ2 -m1=COPY -m2=COPY
3424 * -m3=(any)
3425 * 7z a -m0=BCJ2 -m1=COPY -m2=(any)
3426 * -m3=COPY
3427 * 7z a -m0=BCJ2 -m1=(any) -m2=COPY
3428 * -m3=COPY
3429 * not work:
3430 * other patterns.
3431 *
3432 * We have to handle this like `pipe' or
3433 * our libarchive7s filter frame work,
3434 * decoding the BCJ2 main stream sequentially,
3435 * m3 -> m2 -> m1 -> BCJ2.
3436 *
3437 */
3438 if (fc[0].codec == _7Z_COPY &&
3439 fc[1].codec == _7Z_COPY)
3440 coder1 = &(folder->coders[2]);
3441 else if (fc[0].codec == _7Z_COPY &&
3442 fc[2].codec == _7Z_COPY)
3443 coder1 = &(folder->coders[1]);
3444 else if (fc[1].codec == _7Z_COPY &&
3445 fc[2].codec == _7Z_COPY)
3446 coder1 = &(folder->coders[0]);
3447 else {
3448 archive_set_error(&(a->archive),
3449 ARCHIVE_ERRNO_MISC,
3450 "Unsupported form of "
3451 "BCJ2 streams");
3452 return (ARCHIVE_FATAL);
3453 }
3454 }
3455 coder2 = &(fc[3]);
3456 zip->main_stream_bytes_remaining =
3457 (size_t)folder->unPackSize[2];
3458 } else if (coder2 != NULL && coder2->codec == _7Z_X86_BCJ2 &&
3459 zip->pack_stream_remaining == 4 &&
3460 folder->numInStreams == 5 && folder->numOutStreams == 2) {
3461 /* Source type 0 made by 7z */
3462 zip->main_stream_bytes_remaining =
3463 (size_t)folder->unPackSize[0];
3464 } else {
3465 /* We got an unexpected form. */
3466 archive_set_error(&(a->archive),
3467 ARCHIVE_ERRNO_MISC,
3468 "Unsupported form of BCJ2 streams");
3469 return (ARCHIVE_FATAL);
3470 }
3471
3472 /* Skip the main stream at this time. */
3473 if ((r = seek_pack(a)) < 0)
3474 return (r);
3475 zip->pack_stream_bytes_unconsumed =
3476 (size_t)zip->pack_stream_inbytes_remaining;
3477 read_consume(a);
3478
3479 /* Read following three sub streams. */
3480 for (i = 0; i < 3; i++) {
3481 const struct _7z_coder *coder = scoder[i];
3482
3483 if ((r = seek_pack(a)) < 0) {
3484 free(b[0]); free(b[1]); free(b[2]);
3485 return (r);
3486 }
3487
3488 if (sunpack[i] == (uint64_t)-1)
3489 zip->folder_outbytes_remaining =
3490 zip->pack_stream_inbytes_remaining;
3491 else
3492 zip->folder_outbytes_remaining = sunpack[i];
3493
3494 r = init_decompression(a, zip, coder, NULL);
3495 if (r != ARCHIVE_OK) {
3496 free(b[0]); free(b[1]); free(b[2]);
3497 return (ARCHIVE_FATAL);
3498 }
3499
3500 /* Allocate memory for the decoded data of a sub
3501 * stream. */
3502 b[i] = malloc((size_t)zip->folder_outbytes_remaining);
3503 if (b[i] == NULL) {
3504 free(b[0]); free(b[1]); free(b[2]);
3505 archive_set_error(&a->archive, ENOMEM,
3506 "No memory for 7-Zip decompression");
3507 return (ARCHIVE_FATAL);
3508 }
3509
3510 /* Extract a sub stream. */
3511 while (zip->pack_stream_inbytes_remaining > 0) {
3512 r = (int)extract_pack_stream(a, 0);
3513 if (r < 0) {
3514 free(b[0]); free(b[1]); free(b[2]);
3515 return (r);
3516 }
3517 bytes = get_uncompressed_data(a, &buff,
3518 zip->uncompressed_buffer_bytes_remaining,
3519 0);
3520 if (bytes < 0) {
3521 free(b[0]); free(b[1]); free(b[2]);
3522 return ((int)bytes);
3523 }
3524 memcpy(b[i]+s[i], buff, bytes);
3525 s[i] += bytes;
3526 if (zip->pack_stream_bytes_unconsumed)
3527 read_consume(a);
3528 }
3529 }
3530
3531 /* Set the sub streams to the right place. */
3532 for (i = 0; i < 3; i++) {
3533 zip->sub_stream_buff[i] = b[idx[i]];
3534 zip->sub_stream_size[i] = s[idx[i]];
3535 zip->sub_stream_bytes_remaining[i] = s[idx[i]];
3536 }
3537
3538 /* Allocate memory used for decoded main stream bytes. */
3539 if (zip->tmp_stream_buff == NULL) {
3540 zip->tmp_stream_buff_size = 32 * 1024;
3541 zip->tmp_stream_buff =
3542 malloc(zip->tmp_stream_buff_size);
3543 if (zip->tmp_stream_buff == NULL) {
3544 archive_set_error(&a->archive, ENOMEM,
3545 "No memory for 7-Zip decompression");
3546 return (ARCHIVE_FATAL);
3547 }
3548 }
3549 zip->tmp_stream_bytes_avail = 0;
3550 zip->tmp_stream_bytes_remaining = 0;
3551 zip->odd_bcj_size = 0;
3552 zip->bcj2_outPos = 0;
3553
3554 /*
3555 * Reset a stream reader in order to read the main stream
3556 * of BCJ2.
3557 */
3558 zip->pack_stream_remaining = 1;
3559 zip->pack_stream_index = (unsigned)folder->packIndex;
3560 zip->folder_outbytes_remaining =
3561 folder_uncompressed_size(folder);
3562 zip->uncompressed_buffer_bytes_remaining = 0;
3563 }
3564
3565 /*
3566 * Initialize the decompressor for the new folder's pack streams.
3567 */
3568 r = init_decompression(a, zip, coder1, coder2);
3569 if (r != ARCHIVE_OK)
3570 return (ARCHIVE_FATAL);
3571 return (ARCHIVE_OK);
3572 }
3573
3574 static int64_t
skip_stream(struct archive_read * a,size_t skip_bytes)3575 skip_stream(struct archive_read *a, size_t skip_bytes)
3576 {
3577 struct _7zip *zip = (struct _7zip *)a->format->data;
3578 const void *p;
3579 int64_t skipped_bytes;
3580 size_t bytes = skip_bytes;
3581
3582 if (zip->folder_index == 0) {
3583 /*
3584 * Optimization for a list mode.
3585 * Avoid unnecessary decoding operations.
3586 */
3587 zip->si.ci.folders[zip->entry->folderIndex].skipped_bytes
3588 += skip_bytes;
3589 return (skip_bytes);
3590 }
3591
3592 while (bytes) {
3593 skipped_bytes = read_stream(a, &p, bytes, 0);
3594 if (skipped_bytes < 0)
3595 return (skipped_bytes);
3596 if (skipped_bytes == 0) {
3597 archive_set_error(&a->archive,
3598 ARCHIVE_ERRNO_FILE_FORMAT,
3599 "Truncated 7-Zip file body");
3600 return (ARCHIVE_FATAL);
3601 }
3602 bytes -= (size_t)skipped_bytes;
3603 if (zip->pack_stream_bytes_unconsumed)
3604 read_consume(a);
3605 }
3606 return (skip_bytes);
3607 }
3608
3609 /*
3610 * Brought from LZMA SDK.
3611 *
3612 * Bra86.c -- Converter for x86 code (BCJ)
3613 * 2008-10-04 : Igor Pavlov : Public domain
3614 *
3615 */
3616
3617 #define Test86MSByte(b) ((b) == 0 || (b) == 0xFF)
3618
3619 static void
x86_Init(struct _7zip * zip)3620 x86_Init(struct _7zip *zip)
3621 {
3622 zip->bcj_state = 0;
3623 zip->bcj_prevPosT = (size_t)0 - 1;
3624 zip->bcj_prevMask = 0;
3625 zip->bcj_ip = 5;
3626 }
3627
3628 static size_t
x86_Convert(struct _7zip * zip,uint8_t * data,size_t size)3629 x86_Convert(struct _7zip *zip, uint8_t *data, size_t size)
3630 {
3631 static const uint8_t kMaskToAllowedStatus[8] = {1, 1, 1, 0, 1, 0, 0, 0};
3632 static const uint8_t kMaskToBitNumber[8] = {0, 1, 2, 2, 3, 3, 3, 3};
3633 size_t bufferPos, prevPosT;
3634 uint32_t ip, prevMask;
3635
3636 if (size < 5)
3637 return 0;
3638
3639 bufferPos = 0;
3640 prevPosT = zip->bcj_prevPosT;
3641 prevMask = zip->bcj_prevMask;
3642 ip = zip->bcj_ip;
3643
3644 for (;;) {
3645 uint8_t *p = data + bufferPos;
3646 uint8_t *limit = data + size - 4;
3647
3648 for (; p < limit; p++)
3649 if ((*p & 0xFE) == 0xE8)
3650 break;
3651 bufferPos = (size_t)(p - data);
3652 if (p >= limit)
3653 break;
3654 prevPosT = bufferPos - prevPosT;
3655 if (prevPosT > 3)
3656 prevMask = 0;
3657 else {
3658 prevMask = (prevMask << ((int)prevPosT - 1)) & 0x7;
3659 if (prevMask != 0) {
3660 unsigned char b =
3661 p[4 - kMaskToBitNumber[prevMask]];
3662 if (!kMaskToAllowedStatus[prevMask] ||
3663 Test86MSByte(b)) {
3664 prevPosT = bufferPos;
3665 prevMask = ((prevMask << 1) & 0x7) | 1;
3666 bufferPos++;
3667 continue;
3668 }
3669 }
3670 }
3671 prevPosT = bufferPos;
3672
3673 if (Test86MSByte(p[4])) {
3674 uint32_t src = ((uint32_t)p[4] << 24) |
3675 ((uint32_t)p[3] << 16) | ((uint32_t)p[2] << 8) |
3676 ((uint32_t)p[1]);
3677 uint32_t dest;
3678 for (;;) {
3679 uint8_t b;
3680 int b_index;
3681
3682 dest = src - (ip + (uint32_t)bufferPos);
3683 if (prevMask == 0)
3684 break;
3685 b_index = kMaskToBitNumber[prevMask] * 8;
3686 b = (uint8_t)(dest >> (24 - b_index));
3687 if (!Test86MSByte(b))
3688 break;
3689 src = dest ^ ((1 << (32 - b_index)) - 1);
3690 }
3691 p[4] = (uint8_t)(~(((dest >> 24) & 1) - 1));
3692 p[3] = (uint8_t)(dest >> 16);
3693 p[2] = (uint8_t)(dest >> 8);
3694 p[1] = (uint8_t)dest;
3695 bufferPos += 5;
3696 } else {
3697 prevMask = ((prevMask << 1) & 0x7) | 1;
3698 bufferPos++;
3699 }
3700 }
3701 zip->bcj_prevPosT = prevPosT;
3702 zip->bcj_prevMask = prevMask;
3703 zip->bcj_ip += (uint32_t)bufferPos;
3704 return (bufferPos);
3705 }
3706
3707 /*
3708 * Brought from LZMA SDK.
3709 *
3710 * Bcj2.c -- Converter for x86 code (BCJ2)
3711 * 2008-10-04 : Igor Pavlov : Public domain
3712 *
3713 */
3714
3715 #define SZ_ERROR_DATA ARCHIVE_FAILED
3716
3717 #define IsJcc(b0, b1) ((b0) == 0x0F && ((b1) & 0xF0) == 0x80)
3718 #define IsJ(b0, b1) ((b1 & 0xFE) == 0xE8 || IsJcc(b0, b1))
3719
3720 #define kNumTopBits 24
3721 #define kTopValue ((uint32_t)1 << kNumTopBits)
3722
3723 #define kNumBitModelTotalBits 11
3724 #define kBitModelTotal (1 << kNumBitModelTotalBits)
3725 #define kNumMoveBits 5
3726
3727 #define RC_READ_BYTE (*buffer++)
3728 #define RC_TEST { if (buffer == bufferLim) return SZ_ERROR_DATA; }
3729 #define RC_INIT2 zip->bcj2_code = 0; zip->bcj2_range = 0xFFFFFFFF; \
3730 { int ii; for (ii = 0; ii < 5; ii++) { RC_TEST; zip->bcj2_code = (zip->bcj2_code << 8) | RC_READ_BYTE; }}
3731
3732 #define NORMALIZE if (zip->bcj2_range < kTopValue) { RC_TEST; zip->bcj2_range <<= 8; zip->bcj2_code = (zip->bcj2_code << 8) | RC_READ_BYTE; }
3733
3734 #define IF_BIT_0(p) ttt = *(p); bound = (zip->bcj2_range >> kNumBitModelTotalBits) * ttt; if (zip->bcj2_code < bound)
3735 #define UPDATE_0(p) zip->bcj2_range = bound; *(p) = (CProb)(ttt + ((kBitModelTotal - ttt) >> kNumMoveBits)); NORMALIZE;
3736 #define UPDATE_1(p) zip->bcj2_range -= bound; zip->bcj2_code -= bound; *(p) = (CProb)(ttt - (ttt >> kNumMoveBits)); NORMALIZE;
3737
3738 static ssize_t
Bcj2_Decode(struct _7zip * zip,uint8_t * outBuf,size_t outSize)3739 Bcj2_Decode(struct _7zip *zip, uint8_t *outBuf, size_t outSize)
3740 {
3741 size_t inPos = 0, outPos = 0;
3742 const uint8_t *buf0, *buf1, *buf2, *buf3;
3743 size_t size0, size1, size2, size3;
3744 const uint8_t *buffer, *bufferLim;
3745 unsigned int i, j;
3746
3747 size0 = zip->tmp_stream_bytes_remaining;
3748 buf0 = zip->tmp_stream_buff + zip->tmp_stream_bytes_avail - size0;
3749 size1 = zip->sub_stream_bytes_remaining[0];
3750 buf1 = zip->sub_stream_buff[0] + zip->sub_stream_size[0] - size1;
3751 size2 = zip->sub_stream_bytes_remaining[1];
3752 buf2 = zip->sub_stream_buff[1] + zip->sub_stream_size[1] - size2;
3753 size3 = zip->sub_stream_bytes_remaining[2];
3754 buf3 = zip->sub_stream_buff[2] + zip->sub_stream_size[2] - size3;
3755
3756 buffer = buf3;
3757 bufferLim = buffer + size3;
3758
3759 if (zip->bcj_state == 0) {
3760 /*
3761 * Initialize.
3762 */
3763 zip->bcj2_prevByte = 0;
3764 for (i = 0;
3765 i < sizeof(zip->bcj2_p) / sizeof(zip->bcj2_p[0]); i++)
3766 zip->bcj2_p[i] = kBitModelTotal >> 1;
3767 RC_INIT2;
3768 zip->bcj_state = 1;
3769 }
3770
3771 /*
3772 * Gather the odd bytes of a previous call.
3773 */
3774 for (i = 0; zip->odd_bcj_size > 0 && outPos < outSize; i++) {
3775 outBuf[outPos++] = zip->odd_bcj[i];
3776 zip->odd_bcj_size--;
3777 }
3778
3779 if (outSize == 0) {
3780 zip->bcj2_outPos += outPos;
3781 return (outPos);
3782 }
3783
3784 for (;;) {
3785 uint8_t b;
3786 CProb *prob;
3787 uint32_t bound;
3788 uint32_t ttt;
3789
3790 size_t limit = size0 - inPos;
3791 if (outSize - outPos < limit)
3792 limit = outSize - outPos;
3793
3794 if (zip->bcj_state == 1) {
3795 while (limit != 0) {
3796 uint8_t bb = buf0[inPos];
3797 outBuf[outPos++] = bb;
3798 if (IsJ(zip->bcj2_prevByte, bb)) {
3799 zip->bcj_state = 2;
3800 break;
3801 }
3802 inPos++;
3803 zip->bcj2_prevByte = bb;
3804 limit--;
3805 }
3806 }
3807
3808 if (limit == 0 || outPos == outSize)
3809 break;
3810 zip->bcj_state = 1;
3811
3812 b = buf0[inPos++];
3813
3814 if (b == 0xE8)
3815 prob = zip->bcj2_p + zip->bcj2_prevByte;
3816 else if (b == 0xE9)
3817 prob = zip->bcj2_p + 256;
3818 else
3819 prob = zip->bcj2_p + 257;
3820
3821 IF_BIT_0(prob) {
3822 UPDATE_0(prob)
3823 zip->bcj2_prevByte = b;
3824 } else {
3825 uint32_t dest;
3826 const uint8_t *v;
3827 uint8_t out[4];
3828
3829 UPDATE_1(prob)
3830 if (b == 0xE8) {
3831 v = buf1;
3832 if (size1 < 4)
3833 return SZ_ERROR_DATA;
3834 buf1 += 4;
3835 size1 -= 4;
3836 } else {
3837 v = buf2;
3838 if (size2 < 4)
3839 return SZ_ERROR_DATA;
3840 buf2 += 4;
3841 size2 -= 4;
3842 }
3843 dest = (((uint32_t)v[0] << 24) |
3844 ((uint32_t)v[1] << 16) |
3845 ((uint32_t)v[2] << 8) |
3846 ((uint32_t)v[3])) -
3847 ((uint32_t)zip->bcj2_outPos + (uint32_t)outPos + 4);
3848 out[0] = (uint8_t)dest;
3849 out[1] = (uint8_t)(dest >> 8);
3850 out[2] = (uint8_t)(dest >> 16);
3851 out[3] = zip->bcj2_prevByte = (uint8_t)(dest >> 24);
3852
3853 for (i = 0; i < 4 && outPos < outSize; i++)
3854 outBuf[outPos++] = out[i];
3855 if (i < 4) {
3856 /*
3857 * Save odd bytes which we could not add into
3858 * the output buffer because of out of space.
3859 */
3860 zip->odd_bcj_size = 4 -i;
3861 for (; i < 4; i++) {
3862 j = i - 4 + (unsigned)zip->odd_bcj_size;
3863 zip->odd_bcj[j] = out[i];
3864 }
3865 break;
3866 }
3867 }
3868 }
3869 zip->tmp_stream_bytes_remaining -= inPos;
3870 zip->sub_stream_bytes_remaining[0] = size1;
3871 zip->sub_stream_bytes_remaining[1] = size2;
3872 zip->sub_stream_bytes_remaining[2] = bufferLim - buffer;
3873 zip->bcj2_outPos += outPos;
3874
3875 return ((ssize_t)outPos);
3876 }
3877
3878