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