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