-
Notifications
You must be signed in to change notification settings - Fork 0
/
zip_archive.cc
1894 lines (1637 loc) · 69.6 KB
/
zip_archive.cc
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*
* Copyright (C) 2008 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* Read-only access to Zip archives, with minimal heap allocation.
*/
#define LOG_TAG "ziparchive"
#include "ziparchive/zip_archive.h"
#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
#include <limits.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#ifdef __linux__
#include <linux/fs.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#endif
#include <memory>
#include <optional>
#include <span>
#include <vector>
#if defined(__APPLE__)
#define lseek64 lseek
#endif
#if defined(__BIONIC__)
#include <android/fdsan.h>
#endif
#include <android-base/file.h>
#include <android-base/logging.h>
#include <android-base/macros.h> // TEMP_FAILURE_RETRY may or may not be in unistd
#include <android-base/mapped_file.h>
#include <android-base/memory.h>
#include <android-base/strings.h>
#include <android-base/utf8.h>
#include <log/log.h>
#include "entry_name_utils-inl.h"
#include "incfs_support/signal_handling.h"
#include "incfs_support/util.h"
#include "zip_archive_common.h"
#include "zip_archive_private.h"
#include "zlib.h"
// Used to turn on crc checks - verify that the content CRC matches the values
// specified in the local file header and the central directory.
static constexpr bool kCrcChecksEnabled = false;
// The maximum number of bytes to scan backwards for the EOCD start.
static const uint32_t kMaxEOCDSearch = kMaxCommentLen + sizeof(EocdRecord);
// Set a reasonable cap (256 GiB) for the zip file size. So the data is always valid when
// we parse the fields in cd or local headers as 64 bits signed integers.
static constexpr uint64_t kMaxFileLength = 256 * static_cast<uint64_t>(1u << 30u);
/*
* A Read-only Zip archive.
*
* We want "open" and "find entry by name" to be fast operations, and
* we want to use as little memory as possible. We memory-map the zip
* central directory, and load a hash table with pointers to the filenames
* (which aren't null-terminated). The other fields are at a fixed offset
* from the filename, so we don't need to extract those (but we do need
* to byte-read and endian-swap them every time we want them).
*
* It's possible that somebody has handed us a massive (~1GB) zip archive,
* so we can't expect to mmap the entire file.
*
* To speed comparisons when doing a lookup by name, we could make the mapping
* "private" (copy-on-write) and null-terminate the filenames after verifying
* the record structure. However, this requires a private mapping of
* every page that the Central Directory touches. Easier to tuck a copy
* of the string length into the hash table entry.
*/
#ifdef __linux__
static const size_t kPageSize = getpagesize();
#else
constexpr size_t kPageSize = 4096;
#endif
[[maybe_unused]] static uintptr_t pageAlignDown(uintptr_t ptr_int) {
return ptr_int & ~(kPageSize - 1);
}
[[maybe_unused]] static uintptr_t pageAlignUp(uintptr_t ptr_int) {
return pageAlignDown(ptr_int + kPageSize - 1);
}
[[maybe_unused]] static std::pair<void*, size_t> expandToPageBounds(void* ptr, size_t size) {
const auto ptr_int = reinterpret_cast<uintptr_t>(ptr);
const auto aligned_ptr_int = pageAlignDown(ptr_int);
const auto aligned_size = pageAlignUp(ptr_int + size) - aligned_ptr_int;
return {reinterpret_cast<void*>(aligned_ptr_int), aligned_size};
}
[[maybe_unused]] static void maybePrefetch([[maybe_unused]] const void* ptr,
[[maybe_unused]] size_t size) {
#ifdef __linux__
// Let's only ask for a readahead explicitly if there's enough pages to read. A regular OS
// readahead implementation would take care of the smaller requests, and it would also involve
// only a single kernel transition, just an implicit one from the page fault.
//
// Note: there's no implementation for other OSes, as the prefetch logic is highly specific
// to the memory manager, and we don't have any well defined benchmarks on Windows/Mac;
// it also mostly matters only for the cold OS boot where no files are in the page cache yet,
// but we rarely would hit this situation outside of the device startup.
auto [aligned_ptr, aligned_size] = expandToPageBounds(const_cast<void*>(ptr), size);
if (aligned_size > 32 * kPageSize) {
if (::madvise(aligned_ptr, aligned_size, MADV_WILLNEED)) {
ALOGW("Zip: madvise(file, WILLNEED) failed: %s (%d)", strerror(errno), errno);
}
}
#endif
}
[[maybe_unused]] static void maybePrepareSequentialReading([[maybe_unused]] const void* ptr,
[[maybe_unused]] size_t size) {
#ifdef __linux__
auto [aligned_ptr, aligned_size] = expandToPageBounds(const_cast<void*>(ptr), size);
if (::madvise(reinterpret_cast<void*>(aligned_ptr), aligned_size, MADV_SEQUENTIAL)) {
ALOGW("Zip: madvise(file, SEQUENTIAL) failed: %s (%d)", strerror(errno), errno);
}
#endif
}
#if defined(__BIONIC__)
static uint64_t GetOwnerTag(const ZipArchive* archive) {
return android_fdsan_create_owner_tag(ANDROID_FDSAN_OWNER_TYPE_ZIPARCHIVE,
reinterpret_cast<uint64_t>(archive));
}
#endif
ZipArchive::ZipArchive(MappedZipFile&& map, bool assume_ownership)
: mapped_zip(std::move(map)),
close_file(assume_ownership),
directory_offset(0),
central_directory(),
directory_map(),
num_entries(0) {
#if defined(__BIONIC__)
if (assume_ownership) {
CHECK(mapped_zip.GetFileDescriptor() >= 0 || !mapped_zip.GetBasePtr());
android_fdsan_exchange_owner_tag(mapped_zip.GetFileDescriptor(), 0, GetOwnerTag(this));
}
#endif
}
ZipArchive::ZipArchive(const void* address, size_t length)
: mapped_zip(address, length),
close_file(false),
directory_offset(0),
central_directory(),
directory_map(),
num_entries(0) {}
ZipArchive::~ZipArchive() {
if (close_file && mapped_zip.GetFileDescriptor() >= 0) {
#if defined(__BIONIC__)
android_fdsan_close_with_tag(mapped_zip.GetFileDescriptor(), GetOwnerTag(this));
#else
close(mapped_zip.GetFileDescriptor());
#endif
}
}
struct CentralDirectoryInfo {
uint64_t num_records;
// The size of the central directory (in bytes).
uint64_t cd_size;
// The offset of the start of the central directory, relative
// to the start of the file.
uint64_t cd_start_offset;
};
// Reads |T| at |readPtr| and increments |readPtr|. Returns std::nullopt if the boundary check
// fails.
template <typename T>
static std::optional<T> TryConsumeUnaligned(uint8_t** readPtr, const uint8_t* bufStart,
size_t bufSize) {
if (bufSize < sizeof(T) || *readPtr - bufStart > bufSize - sizeof(T)) {
ALOGW("Zip: %zu byte read exceeds the boundary of allocated buf, offset %zu, bufSize %zu",
sizeof(T), *readPtr - bufStart, bufSize);
return std::nullopt;
}
return ConsumeUnaligned<T>(readPtr);
}
static ZipError FindCentralDirectoryInfoForZip64(const char* debugFileName, ZipArchive* archive,
off64_t eocdOffset, CentralDirectoryInfo* cdInfo) {
if (eocdOffset <= sizeof(Zip64EocdLocator)) {
ALOGW("Zip: %s: Not enough space for zip64 eocd locator", debugFileName);
return kInvalidFile;
}
// We expect to find the zip64 eocd locator immediately before the zip eocd.
const int64_t locatorOffset = eocdOffset - sizeof(Zip64EocdLocator);
Zip64EocdLocator zip64EocdLocatorBuf;
const auto zip64EocdLocator = reinterpret_cast<const Zip64EocdLocator*>(
archive->mapped_zip.ReadAtOffset(reinterpret_cast<uint8_t*>((&zip64EocdLocatorBuf)),
sizeof(zip64EocdLocatorBuf), locatorOffset));
if (!zip64EocdLocator) {
ALOGW("Zip: %s: Read %zu from offset %" PRId64 " failed %s", debugFileName,
sizeof(zip64EocdLocatorBuf), locatorOffset, debugFileName);
return kIoError;
}
if (zip64EocdLocator->locator_signature != Zip64EocdLocator::kSignature) {
ALOGW("Zip: %s: Zip64 eocd locator signature not found at offset %" PRId64, debugFileName,
locatorOffset);
return kInvalidFile;
}
const int64_t zip64EocdOffset = zip64EocdLocator->zip64_eocd_offset;
if (locatorOffset <= sizeof(Zip64EocdRecord) ||
zip64EocdOffset > locatorOffset - sizeof(Zip64EocdRecord)) {
ALOGW("Zip: %s: Bad zip64 eocd offset %" PRId64 ", eocd locator offset %" PRId64, debugFileName,
zip64EocdOffset, locatorOffset);
return kInvalidOffset;
}
Zip64EocdRecord zip64EocdRecordBuf;
const auto zip64EocdRecord = reinterpret_cast<const Zip64EocdRecord*>(
archive->mapped_zip.ReadAtOffset(reinterpret_cast<uint8_t*>(&zip64EocdRecordBuf),
sizeof(zip64EocdRecordBuf), zip64EocdOffset));
if (!zip64EocdRecord) {
ALOGW("Zip: %s: read %zu from offset %" PRId64 " failed %s", debugFileName,
sizeof(zip64EocdRecordBuf), zip64EocdOffset, debugFileName);
return kIoError;
}
if (zip64EocdRecord->record_signature != Zip64EocdRecord::kSignature) {
ALOGW("Zip: %s: Zip64 eocd record signature not found at offset %" PRId64, debugFileName,
zip64EocdOffset);
return kInvalidFile;
}
if (zip64EocdOffset <= zip64EocdRecord->cd_size ||
zip64EocdRecord->cd_start_offset > zip64EocdOffset - zip64EocdRecord->cd_size) {
ALOGW("Zip: %s: Bad offset for zip64 central directory. cd offset %" PRIu64 ", cd size %" PRIu64
", zip64 eocd offset %" PRIu64,
debugFileName, zip64EocdRecord->cd_start_offset, zip64EocdRecord->cd_size,
zip64EocdOffset);
return kInvalidOffset;
}
*cdInfo = {.num_records = zip64EocdRecord->num_records,
.cd_size = zip64EocdRecord->cd_size,
.cd_start_offset = zip64EocdRecord->cd_start_offset};
return kSuccess;
}
static ZipError FindCentralDirectoryInfo(const char* debug_file_name,
ZipArchive* archive,
off64_t file_length,
std::span<uint8_t> scan_buffer,
CentralDirectoryInfo* cdInfo) {
const auto read_amount = static_cast<uint32_t>(scan_buffer.size());
const off64_t search_start = file_length - read_amount;
const auto data = archive->mapped_zip.ReadAtOffset(scan_buffer.data(), read_amount, search_start);
if (!data) {
ALOGE("Zip: read %" PRId64 " from offset %" PRId64 " failed", static_cast<int64_t>(read_amount),
static_cast<int64_t>(search_start));
return kIoError;
}
/*
* Scan backward for the EOCD magic. In an archive without a trailing
* comment, we'll find it on the first try. (We may want to consider
* doing an initial minimal read; if we don't find it, retry with a
* second read as above.)
*/
CHECK_LE(read_amount, std::numeric_limits<int32_t>::max());
int32_t i = read_amount - sizeof(EocdRecord);
for (; i >= 0; i--) {
if (data[i] == 0x50) {
const uint32_t* sig_addr = reinterpret_cast<const uint32_t*>(&data[i]);
if (android::base::get_unaligned<uint32_t>(sig_addr) == EocdRecord::kSignature) {
ALOGV("+++ Found EOCD at buf+%d", i);
break;
}
}
}
if (i < 0) {
ALOGD("Zip: EOCD not found, %s is not zip", debug_file_name);
return kInvalidFile;
}
const off64_t eocd_offset = search_start + i;
auto eocd = reinterpret_cast<const EocdRecord*>(data + i);
/*
* Verify that there's no trailing space at the end of the central directory
* and its comment.
*/
const off64_t calculated_length = eocd_offset + sizeof(EocdRecord) + eocd->comment_length;
if (calculated_length != file_length) {
ALOGW("Zip: %" PRId64 " extraneous bytes at the end of the central directory",
static_cast<int64_t>(file_length - calculated_length));
return kInvalidFile;
}
// One of the field is 0xFFFFFFFF, look for the zip64 EOCD instead.
if (eocd->num_records_on_disk == UINT16_MAX || eocd->num_records == UINT16_MAX ||
eocd->cd_size == UINT32_MAX || eocd->cd_start_offset == UINT32_MAX ||
eocd->comment_length == UINT16_MAX) {
ALOGV("Looking for the zip64 EOCD (cd_size: %" PRIu32 ", cd_start_offset: %" PRIu32
", comment_length: %" PRIu16 ", num_records: %" PRIu16 ", num_records_on_disk: %" PRIu16
")",
eocd->cd_size, eocd->cd_start_offset, eocd->comment_length, eocd->num_records,
eocd->num_records_on_disk);
return FindCentralDirectoryInfoForZip64(debug_file_name, archive, eocd_offset, cdInfo);
}
/*
* Grab the CD offset and size, and the number of entries in the
* archive and verify that they look reasonable.
*/
if (static_cast<off64_t>(eocd->cd_start_offset) + eocd->cd_size > eocd_offset) {
ALOGW("Zip: bad offsets (dir %" PRIu32 ", size %" PRIu32 ", eocd %" PRId64 ")",
eocd->cd_start_offset, eocd->cd_size, static_cast<int64_t>(eocd_offset));
return kInvalidOffset;
}
*cdInfo = {.num_records = eocd->num_records,
.cd_size = eocd->cd_size,
.cd_start_offset = eocd->cd_start_offset};
return kSuccess;
}
/*
* Find the zip Central Directory and memory-map it.
*
* On success, returns kSuccess after populating fields from the EOCD area:
* directory_offset
* directory_ptr
* num_entries
*/
static ZipError MapCentralDirectory(const char* debug_file_name, ZipArchive* archive) {
// Test file length. We want to make sure the file is small enough to be a zip
// file.
off64_t file_length = archive->mapped_zip.GetFileLength();
if (file_length == -1) {
return kInvalidFile;
}
if (file_length > kMaxFileLength) {
ALOGV("Zip: zip file too long %" PRId64, static_cast<int64_t>(file_length));
return kInvalidFile;
}
if (file_length < static_cast<off64_t>(sizeof(EocdRecord))) {
ALOGV("Zip: length %" PRId64 " is too small to be zip", static_cast<int64_t>(file_length));
return kInvalidFile;
}
/*
* Perform the traditional EOCD snipe hunt.
*
* We're searching for the End of Central Directory magic number,
* which appears at the start of the EOCD block. It's followed by
* 18 bytes of EOCD stuff and up to 64KB of archive comment. We
* need to read the last part of the file into a buffer, dig through
* it to find the magic number, parse some values out, and use those
* to determine the extent of the CD.
*
* We start by pulling in the last part of the file.
*/
const auto read_amount = uint32_t(std::min<off64_t>(file_length, kMaxEOCDSearch));
CentralDirectoryInfo cdInfo = {};
std::vector<uint8_t> scan_buffer(read_amount);
SCOPED_SIGBUS_HANDLER({
incfs::util::clearAndFree(scan_buffer);
return kIoError;
});
if (auto result = FindCentralDirectoryInfo(debug_file_name, archive,
file_length, scan_buffer, &cdInfo);
result != kSuccess) {
return result;
}
scan_buffer.clear();
if (cdInfo.num_records == 0) {
#if defined(__ANDROID__)
ALOGW("Zip: empty archive?");
#endif
return kEmptyArchive;
}
if (cdInfo.cd_size >= SIZE_MAX) {
ALOGW("Zip: The size of central directory doesn't fit in range of size_t: %" PRIu64,
cdInfo.cd_size);
return kInvalidFile;
}
ALOGV("+++ num_entries=%" PRIu64 " dir_size=%" PRIu64 " dir_offset=%" PRIu64, cdInfo.num_records,
cdInfo.cd_size, cdInfo.cd_start_offset);
// It all looks good. Create a mapping for the CD, and set the fields in archive.
if (!archive->InitializeCentralDirectory(static_cast<off64_t>(cdInfo.cd_start_offset),
static_cast<size_t>(cdInfo.cd_size))) {
return kMmapFailed;
}
archive->num_entries = cdInfo.num_records;
archive->directory_offset = cdInfo.cd_start_offset;
return kSuccess;
}
static ZipError ParseZip64ExtendedInfoInExtraField(
const uint8_t* extraFieldStart, uint16_t extraFieldLength, uint32_t zip32UncompressedSize,
uint32_t zip32CompressedSize, std::optional<uint32_t> zip32LocalFileHeaderOffset,
Zip64ExtendedInfo* zip64Info) {
if (extraFieldLength <= 4) {
ALOGW("Zip: Extra field isn't large enough to hold zip64 info, size %" PRIu16,
extraFieldLength);
return kInvalidFile;
}
// Each header MUST consist of:
// Header ID - 2 bytes
// Data Size - 2 bytes
uint16_t offset = 0;
while (offset < extraFieldLength - 4) {
auto readPtr = const_cast<uint8_t*>(extraFieldStart + offset);
auto headerId = ConsumeUnaligned<uint16_t>(&readPtr);
auto dataSize = ConsumeUnaligned<uint16_t>(&readPtr);
offset += 4;
if (dataSize > extraFieldLength - offset) {
ALOGW("Zip: Data size exceeds the boundary of extra field, data size %" PRIu16, dataSize);
return kInvalidOffset;
}
// Skip the other types of extensible data fields. Details in
// https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT section 4.5
if (headerId != Zip64ExtendedInfo::kHeaderId) {
offset += dataSize;
continue;
}
// Layout for Zip64 extended info (not include first 4 bytes of header)
// Original
// Size 8 bytes Original uncompressed file size
// Compressed
// Size 8 bytes Size of compressed data
// Relative Header
// Offset 8 bytes Offset of local header record
// Disk Start
// Number 4 bytes Number of the disk on which
// this file starts
if (dataSize == 8 * 3 + 4) {
ALOGW(
"Zip: Found `Disk Start Number` field in extra block. Ignoring it.");
dataSize -= 4;
}
// Sometimes, only a subset of {uncompressed size, compressed size, relative
// header offset} is presents. but golang's zip writer will write out all
// 3 even if only 1 is necessary. We should parse all 3 fields if they are
// there.
const bool completeField = dataSize == 8 * 3;
std::optional<uint64_t> uncompressedFileSize;
std::optional<uint64_t> compressedFileSize;
std::optional<uint64_t> localHeaderOffset;
if (zip32UncompressedSize == UINT32_MAX || completeField) {
uncompressedFileSize = TryConsumeUnaligned<uint64_t>(
&readPtr, extraFieldStart, extraFieldLength);
if (!uncompressedFileSize.has_value()) return kInvalidOffset;
}
if (zip32CompressedSize == UINT32_MAX || completeField) {
compressedFileSize = TryConsumeUnaligned<uint64_t>(
&readPtr, extraFieldStart, extraFieldLength);
if (!compressedFileSize.has_value()) return kInvalidOffset;
}
if (zip32LocalFileHeaderOffset == UINT32_MAX || completeField) {
localHeaderOffset = TryConsumeUnaligned<uint64_t>(
&readPtr, extraFieldStart, extraFieldLength);
if (!localHeaderOffset.has_value()) return kInvalidOffset;
}
// calculate how many bytes we read after the data size field.
size_t bytesRead = readPtr - (extraFieldStart + offset);
if (bytesRead == 0) {
ALOGW("Zip: Data size should not be 0 in zip64 extended field");
return kInvalidFile;
}
if (dataSize != bytesRead) {
auto localOffsetString = zip32LocalFileHeaderOffset.has_value()
? std::to_string(zip32LocalFileHeaderOffset.value())
: "missing";
ALOGW("Zip: Invalid data size in zip64 extended field, expect %zu , get %" PRIu16
", uncompressed size %" PRIu32 ", compressed size %" PRIu32 ", local header offset %s",
bytesRead, dataSize, zip32UncompressedSize, zip32CompressedSize,
localOffsetString.c_str());
return kInvalidFile;
}
zip64Info->uncompressed_file_size = uncompressedFileSize;
zip64Info->compressed_file_size = compressedFileSize;
zip64Info->local_header_offset = localHeaderOffset;
return kSuccess;
}
ALOGW("Zip: zip64 extended info isn't found in the extra field.");
return kInvalidFile;
}
/*
* Parses the Zip archive's Central Directory. Allocates and populates the
* hash table.
*
* Returns 0 on success.
*/
static ZipError ParseZipArchive(ZipArchive* archive) {
SCOPED_SIGBUS_HANDLER(return kIoError);
maybePrefetch(archive->central_directory.GetBasePtr(), archive->central_directory.GetMapLength());
const uint8_t* const cd_ptr = archive->central_directory.GetBasePtr();
const size_t cd_length = archive->central_directory.GetMapLength();
const uint8_t* const cd_end = cd_ptr + cd_length;
const uint64_t num_entries = archive->num_entries;
const uint8_t* ptr = cd_ptr;
uint16_t max_file_name_length = 0;
/* Walk through the central directory and verify values */
for (uint64_t i = 0; i < num_entries; i++) {
if (ptr > cd_end - sizeof(CentralDirectoryRecord)) {
ALOGW("Zip: ran off the end (item #%" PRIu64 ", %zu bytes of central directory)", i,
cd_length);
#if defined(__ANDROID__)
android_errorWriteLog(0x534e4554, "36392138");
#endif
return kInvalidFile;
}
auto cdr = reinterpret_cast<const CentralDirectoryRecord*>(ptr);
if (cdr->record_signature != CentralDirectoryRecord::kSignature) {
ALOGW("Zip: missed a central dir sig (at %" PRIu64 ")", i);
return kInvalidFile;
}
const uint16_t file_name_length = cdr->file_name_length;
const uint16_t extra_length = cdr->extra_field_length;
const uint16_t comment_length = cdr->comment_length;
const uint8_t* file_name = ptr + sizeof(CentralDirectoryRecord);
if (file_name_length >= cd_length || file_name > cd_end - file_name_length) {
ALOGW("Zip: file name for entry %" PRIu64
" exceeds the central directory range, file_name_length: %" PRIu16 ", cd_length: %zu",
i, file_name_length, cd_length);
return kInvalidEntryName;
}
max_file_name_length = std::max(max_file_name_length, file_name_length);
const uint8_t* extra_field = file_name + file_name_length;
if (extra_length >= cd_length || extra_field > cd_end - extra_length) {
ALOGW("Zip: extra field for entry %" PRIu64
" exceeds the central directory range, file_name_length: %" PRIu16 ", cd_length: %zu",
i, extra_length, cd_length);
return kInvalidFile;
}
off64_t local_header_offset = cdr->local_file_header_offset;
if (local_header_offset == UINT32_MAX) {
Zip64ExtendedInfo zip64_info{};
if (auto status = ParseZip64ExtendedInfoInExtraField(
extra_field, extra_length, cdr->uncompressed_size, cdr->compressed_size,
cdr->local_file_header_offset, &zip64_info);
status != kSuccess) {
return status;
}
CHECK(zip64_info.local_header_offset.has_value());
local_header_offset = zip64_info.local_header_offset.value();
}
if (local_header_offset >= archive->directory_offset) {
ALOGW("Zip: bad LFH offset %" PRId64 " at entry %" PRIu64,
static_cast<int64_t>(local_header_offset), i);
return kInvalidFile;
}
// Check that file name is valid UTF-8 and doesn't contain NUL (U+0000) characters.
if (!IsValidEntryName(file_name, file_name_length)) {
ALOGW("Zip: invalid file name at entry %" PRIu64, i);
return kInvalidEntryName;
}
ptr += sizeof(CentralDirectoryRecord) + file_name_length + extra_length + comment_length;
if ((ptr - cd_ptr) > static_cast<int64_t>(cd_length)) {
ALOGW("Zip: bad CD advance (%tu vs %zu) at entry %" PRIu64, ptr - cd_ptr, cd_length, i);
return kInvalidFile;
}
}
/* Create memory efficient entry map */
archive->cd_entry_map = CdEntryMapInterface::Create(num_entries, cd_length, max_file_name_length);
if (archive->cd_entry_map == nullptr) {
return kAllocationFailed;
}
/* Central directory verified, now add entries to the hash table */
ptr = cd_ptr;
for (uint64_t i = 0; i < num_entries; i++) {
auto cdr = reinterpret_cast<const CentralDirectoryRecord*>(ptr);
std::string_view entry_name{reinterpret_cast<const char*>(ptr + sizeof(*cdr)),
cdr->file_name_length};
auto add_result = archive->cd_entry_map->AddToMap(entry_name, cd_ptr);
if (add_result != 0) {
ALOGW("Zip: Error adding entry to hash table %d", add_result);
return add_result;
}
ptr += sizeof(*cdr) + cdr->file_name_length + cdr->extra_field_length + cdr->comment_length;
}
uint32_t lfh_start_bytes_buf;
auto lfh_start_bytes = reinterpret_cast<const uint32_t*>(archive->mapped_zip.ReadAtOffset(
reinterpret_cast<uint8_t*>(&lfh_start_bytes_buf), sizeof(lfh_start_bytes_buf), 0));
if (!lfh_start_bytes) {
ALOGW("Zip: Unable to read header for entry at offset == 0.");
return kInvalidFile;
}
if (*lfh_start_bytes != LocalFileHeader::kSignature) {
ALOGW("Zip: Entry at offset zero has invalid LFH signature %" PRIx32, *lfh_start_bytes);
#if defined(__ANDROID__)
android_errorWriteLog(0x534e4554, "64211847");
#endif
return kInvalidFile;
}
ALOGV("+++ zip good scan %" PRIu64 " entries", num_entries);
return kSuccess;
}
static int32_t OpenArchiveInternal(ZipArchive* archive, const char* debug_file_name) {
int32_t result = MapCentralDirectory(debug_file_name, archive);
return result != kSuccess ? result : ParseZipArchive(archive);
}
int32_t OpenArchiveFd(int fd, const char* debug_file_name, ZipArchiveHandle* handle,
bool assume_ownership) {
ZipArchive* archive = new ZipArchive(MappedZipFile(fd), assume_ownership);
*handle = archive;
return OpenArchiveInternal(archive, debug_file_name);
}
int32_t OpenArchiveFdRange(int fd, const char* debug_file_name, ZipArchiveHandle* handle,
off64_t length, off64_t offset, bool assume_ownership) {
ZipArchive* archive = new ZipArchive(MappedZipFile(fd, length, offset), assume_ownership);
*handle = archive;
if (length < 0) {
ALOGW("Invalid zip length %" PRId64, length);
return kIoError;
}
if (offset < 0) {
ALOGW("Invalid zip offset %" PRId64, offset);
return kIoError;
}
return OpenArchiveInternal(archive, debug_file_name);
}
int32_t OpenArchive(const char* fileName, ZipArchiveHandle* handle) {
const int fd = ::android::base::utf8::open(fileName, O_RDONLY | O_BINARY | O_CLOEXEC, 0);
ZipArchive* archive = new ZipArchive(MappedZipFile(fd), true);
*handle = archive;
if (fd < 0) {
ALOGW("Unable to open '%s': %s", fileName, strerror(errno));
return kIoError;
}
return OpenArchiveInternal(archive, fileName);
}
int32_t OpenArchiveFromMemory(const void* address, size_t length, const char* debug_file_name,
ZipArchiveHandle* handle) {
ZipArchive* archive = new ZipArchive(address, length);
*handle = archive;
return OpenArchiveInternal(archive, debug_file_name);
}
ZipArchiveInfo GetArchiveInfo(ZipArchiveHandle archive) {
ZipArchiveInfo result;
result.archive_size = archive->mapped_zip.GetFileLength();
result.entry_count = archive->num_entries;
return result;
}
/*
* Close a ZipArchive, closing the file and freeing the contents.
*/
void CloseArchive(ZipArchiveHandle archive) {
ALOGV("Closing archive %p", archive);
delete archive;
}
static int32_t ValidateDataDescriptor(MappedZipFile& mapped_zip, const ZipEntry64* entry) {
SCOPED_SIGBUS_HANDLER(return kIoError);
// Maximum possible size for data descriptor: 2 * 4 + 2 * 8 = 24 bytes
// The zip format doesn't specify the size of data descriptor. But we won't read OOB here even
// if the descriptor isn't present. Because the size cd + eocd in the end of the zipfile is
// larger than 24 bytes. And if the descriptor contains invalid data, we'll abort due to
// kInconsistentInformation.
uint8_t ddBuf[24];
off64_t offset = entry->offset;
if (entry->method != kCompressStored) {
offset += entry->compressed_length;
} else {
offset += entry->uncompressed_length;
}
const auto ddPtr = mapped_zip.ReadAtOffset(ddBuf, sizeof(ddBuf), offset);
if (!ddPtr) {
return kIoError;
}
const uint32_t ddSignature = *(reinterpret_cast<const uint32_t*>(ddPtr));
const uint8_t* ddReadPtr = (ddSignature == DataDescriptor::kOptSignature) ? ddPtr + 4 : ddPtr;
DataDescriptor descriptor{};
descriptor.crc32 = ConsumeUnaligned<uint32_t>(&ddReadPtr);
// Don't use entry->zip64_format_size, because that is set to true even if
// both compressed/uncompressed size are < 0xFFFFFFFF.
constexpr auto u32max = std::numeric_limits<uint32_t>::max();
if (entry->compressed_length >= u32max ||
entry->uncompressed_length >= u32max) {
descriptor.compressed_size = ConsumeUnaligned<uint64_t>(&ddReadPtr);
descriptor.uncompressed_size = ConsumeUnaligned<uint64_t>(&ddReadPtr);
} else {
descriptor.compressed_size = ConsumeUnaligned<uint32_t>(&ddReadPtr);
descriptor.uncompressed_size = ConsumeUnaligned<uint32_t>(&ddReadPtr);
}
// Validate that the values in the data descriptor match those in the central
// directory.
if (entry->compressed_length != descriptor.compressed_size ||
entry->uncompressed_length != descriptor.uncompressed_size ||
entry->crc32 != descriptor.crc32) {
ALOGW("Zip: size/crc32 mismatch. expected {%" PRIu64 ", %" PRIu64 ", %" PRIx32
"}, was {%" PRIu64 ", %" PRIu64 ", %" PRIx32 "}",
entry->compressed_length, entry->uncompressed_length, entry->crc32,
descriptor.compressed_size, descriptor.uncompressed_size, descriptor.crc32);
return kInconsistentInformation;
}
return 0;
}
static int32_t FindEntry(const ZipArchive* archive, std::string_view entryName,
const uint64_t nameOffset, ZipEntry64* data) {
std::vector<uint8_t> buffer;
SCOPED_SIGBUS_HANDLER({
incfs::util::clearAndFree(buffer);
return kIoError;
});
// Recover the start of the central directory entry from the filename
// pointer. The filename is the first entry past the fixed-size data,
// so we can just subtract back from that.
const uint8_t* base_ptr = archive->central_directory.GetBasePtr();
const uint8_t* ptr = base_ptr + nameOffset;
ptr -= sizeof(CentralDirectoryRecord);
// This is the base of our mmapped region, we have to check that
// the name that's in the hash table is a pointer to a location within
// this mapped region.
if (ptr < base_ptr || ptr > base_ptr + archive->central_directory.GetMapLength()) {
ALOGW("Zip: Invalid entry pointer");
return kInvalidOffset;
}
auto cdr = reinterpret_cast<const CentralDirectoryRecord*>(ptr);
// The offset of the start of the central directory in the zipfile.
// We keep this lying around so that we can check all our lengths
// and our per-file structures.
const off64_t cd_offset = archive->directory_offset;
// Fill out the compression method, modification time, crc32
// and other interesting attributes from the central directory. These
// will later be compared against values from the local file header.
data->method = cdr->compression_method;
data->mod_time = cdr->last_mod_date << 16 | cdr->last_mod_time;
data->crc32 = cdr->crc32;
data->compressed_length = cdr->compressed_size;
data->uncompressed_length = cdr->uncompressed_size;
// Figure out the local header offset from the central directory. The
// actual file data will begin after the local header and the name /
// extra comments.
off64_t local_header_offset = cdr->local_file_header_offset;
// One of the info field is UINT32_MAX, try to parse the real value in the zip64 extended info in
// the extra field.
if (cdr->uncompressed_size == UINT32_MAX || cdr->compressed_size == UINT32_MAX ||
cdr->local_file_header_offset == UINT32_MAX) {
const uint8_t* extra_field = ptr + sizeof(CentralDirectoryRecord) + cdr->file_name_length;
Zip64ExtendedInfo zip64_info{};
if (auto status = ParseZip64ExtendedInfoInExtraField(
extra_field, cdr->extra_field_length, cdr->uncompressed_size, cdr->compressed_size,
cdr->local_file_header_offset, &zip64_info);
status != kSuccess) {
return status;
}
data->uncompressed_length = zip64_info.uncompressed_file_size.value_or(cdr->uncompressed_size);
data->compressed_length = zip64_info.compressed_file_size.value_or(cdr->compressed_size);
local_header_offset = zip64_info.local_header_offset.value_or(local_header_offset);
data->zip64_format_size =
cdr->uncompressed_size == UINT32_MAX || cdr->compressed_size == UINT32_MAX;
}
off64_t local_header_end;
if (__builtin_add_overflow(local_header_offset, sizeof(LocalFileHeader), &local_header_end) ||
local_header_end >= cd_offset) {
// We tested >= because the name that follows can't be zero length.
ALOGW("Zip: bad local hdr offset in zip");
return kInvalidOffset;
}
uint8_t lfh_buf[sizeof(LocalFileHeader)];
const auto lfh = reinterpret_cast<const LocalFileHeader*>(
archive->mapped_zip.ReadAtOffset(lfh_buf, sizeof(lfh_buf), local_header_offset));
if (!lfh) {
ALOGW("Zip: failed reading lfh name from offset %" PRId64,
static_cast<int64_t>(local_header_offset));
return kIoError;
}
if (lfh->lfh_signature != LocalFileHeader::kSignature) {
ALOGW("Zip: didn't find signature at start of lfh, offset=%" PRId64,
static_cast<int64_t>(local_header_offset));
return kInvalidOffset;
}
// Check that the local file header name matches the declared name in the central directory.
CHECK_LE(entryName.size(), UINT16_MAX);
auto name_length = static_cast<uint16_t>(entryName.size());
if (lfh->file_name_length != name_length) {
ALOGW("Zip: lfh name length did not match central directory for %s: %" PRIu16 " %" PRIu16,
std::string(entryName).c_str(), lfh->file_name_length, name_length);
return kInconsistentInformation;
}
off64_t name_offset;
if (__builtin_add_overflow(local_header_offset, sizeof(LocalFileHeader), &name_offset)) {
ALOGW("Zip: lfh name offset invalid");
return kInvalidOffset;
}
off64_t name_end;
if (__builtin_add_overflow(name_offset, name_length, &name_end) || name_end > cd_offset) {
// We tested > cd_offset here because the file data that follows can be zero length.
ALOGW("Zip: lfh name length invalid");
return kInvalidOffset;
}
// An optimization: get enough memory on the stack to be able to use it later without an extra
// allocation when reading the zip64 extended info. Reasonable names should be under half the
// MAX_PATH (256 chars), and Zip64 header size is 32 bytes; archives often have some other extras,
// e.g. alignment, so 128 bytes is outght to be enough for (almost) anybody. If it's not we'll
// reallocate later anyway.
uint8_t static_buf[128];
auto name_buf = static_buf;
if (name_length > std::size(static_buf)) {
buffer.resize(name_length);
name_buf = buffer.data();
}
const auto read_name = archive->mapped_zip.ReadAtOffset(name_buf, name_length, name_offset);
if (!read_name) {
ALOGW("Zip: failed reading lfh name from offset %" PRId64, static_cast<int64_t>(name_offset));
return kIoError;
}
if (memcmp(entryName.data(), read_name, name_length) != 0) {
ALOGW("Zip: lfh name did not match central directory");
return kInconsistentInformation;
}
uint64_t lfh_uncompressed_size = lfh->uncompressed_size;
uint64_t lfh_compressed_size = lfh->compressed_size;
if (lfh_uncompressed_size == UINT32_MAX || lfh_compressed_size == UINT32_MAX) {
if (lfh_uncompressed_size != UINT32_MAX || lfh_compressed_size != UINT32_MAX) {
ALOGW(
"Zip: The zip64 extended field in the local header MUST include BOTH original and "
"compressed file size fields.");
return kInvalidFile;
}
const off64_t lfh_extra_field_offset = name_offset + lfh->file_name_length;
const uint16_t lfh_extra_field_size = lfh->extra_field_length;
if (lfh_extra_field_offset > cd_offset - lfh_extra_field_size) {
ALOGW("Zip: extra field has a bad size for entry %s", std::string(entryName).c_str());
return kInvalidOffset;
}
auto lfh_extra_field_buf = static_buf;
if (lfh_extra_field_size > std::size(static_buf)) {
// Make sure vector won't try to copy existing data if it needs to reallocate.
buffer.clear();
buffer.resize(lfh_extra_field_size);
lfh_extra_field_buf = buffer.data();
}
const auto local_extra_field = archive->mapped_zip.ReadAtOffset(
lfh_extra_field_buf, lfh_extra_field_size, lfh_extra_field_offset);
if (!local_extra_field) {
ALOGW("Zip: failed reading lfh extra field from offset %" PRId64, lfh_extra_field_offset);
return kIoError;
}
Zip64ExtendedInfo zip64_info{};
if (auto status = ParseZip64ExtendedInfoInExtraField(
local_extra_field, lfh_extra_field_size, lfh->uncompressed_size, lfh->compressed_size,
std::nullopt, &zip64_info);
status != kSuccess) {
return status;
}
CHECK(zip64_info.uncompressed_file_size.has_value());
CHECK(zip64_info.compressed_file_size.has_value());
lfh_uncompressed_size = zip64_info.uncompressed_file_size.value();
lfh_compressed_size = zip64_info.compressed_file_size.value();
}
// Paranoia: Match the values specified in the local file header
// to those specified in the central directory.
// Warn if central directory and local file header don't agree on the use
// of a trailing Data Descriptor. The reference implementation is inconsistent
// and appears to use the LFH value during extraction (unzip) but the CD value
// while displayng information about archives (zipinfo). The spec remains
// silent on this inconsistency as well.
//
// For now, always use the version from the LFH but make sure that the values
// specified in the central directory match those in the data descriptor.
//
// NOTE: It's also worth noting that unzip *does* warn about inconsistencies in
// bit 11 (EFS: The language encoding flag, marking that filename and comment are
// encoded using UTF-8). This implementation does not check for the presence of
// that flag and always enforces that entry names are valid UTF-8.
if ((lfh->gpb_flags & kGPBDDFlagMask) != (cdr->gpb_flags & kGPBDDFlagMask)) {
ALOGW("Zip: gpb flag mismatch at bit 3. expected {%04" PRIx16 "}, was {%04" PRIx16 "}",
cdr->gpb_flags, lfh->gpb_flags);
}
// If there is no trailing data descriptor, verify that the central directory and local file
// header agree on the crc, compressed, and uncompressed sizes of the entry.
if ((lfh->gpb_flags & kGPBDDFlagMask) == 0) {
data->has_data_descriptor = 0;
if (data->compressed_length != lfh_compressed_size ||
data->uncompressed_length != lfh_uncompressed_size || data->crc32 != lfh->crc32) {
ALOGW("Zip: size/crc32 mismatch. expected {%" PRIu64 ", %" PRIu64 ", %" PRIx32
"}, was {%" PRIu64 ", %" PRIu64 ", %" PRIx32 "}",
data->compressed_length, data->uncompressed_length, data->crc32, lfh_compressed_size,
lfh_uncompressed_size, lfh->crc32);
return kInconsistentInformation;
}
} else {
data->has_data_descriptor = 1;
}
// 4.4.2.1: the upper byte of `version_made_by` gives the source OS. Unix is 3.
data->version_made_by = cdr->version_made_by;
data->external_file_attributes = cdr->external_file_attributes;
if ((data->version_made_by >> 8) == 3) {
data->unix_mode = (cdr->external_file_attributes >> 16) & 0xffff;