1 /*
2  * Copyright (C) 2015 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #ifndef LIBZIPARCHIVE_ZIPARCHIVECOMMON_H_
18 #define LIBZIPARCHIVE_ZIPARCHIVECOMMON_H_
19 
20 #include "android-base/macros.h"
21 
22 #include <inttypes.h>
23 
24 #include <optional>
25 
26 // The "end of central directory" (EOCD) record. Each archive
27 // contains exactly once such record which appears at the end of
28 // the archive. It contains archive wide information like the
29 // number of entries in the archive and the offset to the central
30 // directory of the offset.
31 struct EocdRecord {
32   static const uint32_t kSignature = 0x06054b50;
33 
34   // End of central directory signature, should always be
35   // |kSignature|.
36   uint32_t eocd_signature;
37   // The number of the current "disk", i.e, the "disk" that this
38   // central directory is on.
39   //
40   // This implementation assumes that each archive spans a single
41   // disk only. i.e, that disk_num == 1.
42   uint16_t disk_num;
43   // The disk where the central directory starts.
44   //
45   // This implementation assumes that each archive spans a single
46   // disk only. i.e, that cd_start_disk == 1.
47   uint16_t cd_start_disk;
48   // The number of central directory records on this disk.
49   //
50   // This implementation assumes that each archive spans a single
51   // disk only. i.e, that num_records_on_disk == num_records.
52   uint16_t num_records_on_disk;
53   // The total number of central directory records.
54   uint16_t num_records;
55   // The size of the central directory (in bytes).
56   uint32_t cd_size;
57   // The offset of the start of the central directory, relative
58   // to the start of the file.
59   uint32_t cd_start_offset;
60   // Length of the central directory comment.
61   uint16_t comment_length;
62 
63   EocdRecord() = default;
64 
65  private:
66   DISALLOW_COPY_AND_ASSIGN(EocdRecord);
67 } __attribute__((packed));
68 
69 // A structure representing the fixed length fields for a single
70 // record in the central directory of the archive. In addition to
71 // the fixed length fields listed here, each central directory
72 // record contains a variable length "file_name" and "extra_field"
73 // whose lengths are given by |file_name_length| and |extra_field_length|
74 // respectively.
75 struct CentralDirectoryRecord {
76   static const uint32_t kSignature = 0x02014b50;
77 
78   // The start of record signature. Must be |kSignature|.
79   uint32_t record_signature;
80   // Source tool version. Top byte gives source OS.
81   uint16_t version_made_by;
82   // Tool version. Ignored by this implementation.
83   uint16_t version_needed;
84   // The "general purpose bit flags" for this entry. The only
85   // flag value that we currently check for is the "data descriptor"
86   // flag.
87   uint16_t gpb_flags;
88   // The compression method for this entry, one of |kCompressStored|
89   // and |kCompressDeflated|.
90   uint16_t compression_method;
91   // The file modification time and date for this entry.
92   uint16_t last_mod_time;
93   uint16_t last_mod_date;
94   // The CRC-32 checksum for this entry.
95   uint32_t crc32;
96   // The compressed size (in bytes) of this entry.
97   uint32_t compressed_size;
98   // The uncompressed size (in bytes) of this entry.
99   uint32_t uncompressed_size;
100   // The length of the entry file name in bytes. The file name
101   // will appear immediately after this record.
102   uint16_t file_name_length;
103   // The length of the extra field info (in bytes). This data
104   // will appear immediately after the entry file name.
105   uint16_t extra_field_length;
106   // The length of the entry comment (in bytes). This data will
107   // appear immediately after the extra field.
108   uint16_t comment_length;
109   // The start disk for this entry. Ignored by this implementation).
110   uint16_t file_start_disk;
111   // File attributes. Ignored by this implementation.
112   uint16_t internal_file_attributes;
113   // File attributes. For archives created on Unix, the top bits are the mode.
114   uint32_t external_file_attributes;
115   // The offset to the local file header for this entry, from the
116   // beginning of this archive.
117   uint32_t local_file_header_offset;
118 
119   CentralDirectoryRecord() = default;
120 
121  private:
122   DISALLOW_COPY_AND_ASSIGN(CentralDirectoryRecord);
123 } __attribute__((packed));
124 
125 // The local file header for a given entry. This duplicates information
126 // present in the central directory of the archive. It is an error for
127 // the information here to be different from the central directory
128 // information for a given entry.
129 struct LocalFileHeader {
130   static const uint32_t kSignature = 0x04034b50;
131 
132   // The local file header signature, must be |kSignature|.
133   uint32_t lfh_signature;
134   // Tool version. Ignored by this implementation.
135   uint16_t version_needed;
136   // The "general purpose bit flags" for this entry. The only
137   // flag value that we currently check for is the "data descriptor"
138   // flag.
139   uint16_t gpb_flags;
140   // The compression method for this entry, one of |kCompressStored|
141   // and |kCompressDeflated|.
142   uint16_t compression_method;
143   // The file modification time and date for this entry.
144   uint16_t last_mod_time;
145   uint16_t last_mod_date;
146   // The CRC-32 checksum for this entry.
147   uint32_t crc32;
148   // The compressed size (in bytes) of this entry.
149   uint32_t compressed_size;
150   // The uncompressed size (in bytes) of this entry.
151   uint32_t uncompressed_size;
152   // The length of the entry file name in bytes. The file name
153   // will appear immediately after this record.
154   uint16_t file_name_length;
155   // The length of the extra field info (in bytes). This data
156   // will appear immediately after the entry file name.
157   uint16_t extra_field_length;
158 
159   LocalFileHeader() = default;
160 
161  private:
162   DISALLOW_COPY_AND_ASSIGN(LocalFileHeader);
163 } __attribute__((packed));
164 
165 struct DataDescriptor {
166   // The *optional* data descriptor start signature.
167   static const uint32_t kOptSignature = 0x08074b50;
168 
169   // CRC-32 checksum of the entry.
170   uint32_t crc32;
171 
172   // For ZIP64 format archives, the compressed and uncompressed sizes are 8
173   // bytes each. Also, the ZIP64 format MAY be used regardless of the size
174   // of a file.  When extracting, if the zip64 extended information extra field
175   // is present for the file the compressed and uncompressed sizes will be 8
176   // byte values.
177 
178   // Compressed size of the entry, the field can be either 4 bytes or 8 bytes
179   // in the zip file.
180   uint64_t compressed_size;
181   // Uncompressed size of the entry, the field can be either 4 bytes or 8 bytes
182   // in the zip file.
183   uint64_t uncompressed_size;
184 
185   DataDescriptor() = default;
186 
187  private:
188   DISALLOW_COPY_AND_ASSIGN(DataDescriptor);
189 };
190 
191 // The zip64 end of central directory locator helps to find the zip64 EOCD.
192 struct Zip64EocdLocator {
193   static constexpr uint32_t kSignature = 0x07064b50;
194 
195   // The signature of zip64 eocd locator, must be |kSignature|
196   uint32_t locator_signature;
197   // The start disk of the zip64 eocd. This implementation assumes that each
198   // archive spans a single disk only.
199   uint32_t eocd_start_disk;
200   // The offset offset of the zip64 end of central directory record.
201   uint64_t zip64_eocd_offset;
202   // The total number of disks. This implementation assumes that each archive
203   // spans a single disk only.
204   uint32_t num_of_disks;
205 
206   Zip64EocdLocator() = default;
207 
208  private:
209   DISALLOW_COPY_AND_ASSIGN(Zip64EocdLocator);
210 } __attribute__((packed));
211 
212 // The optional zip64 EOCD. If one of the fields in the end of central directory
213 // record is too small to hold required data, the field SHOULD be  set to -1
214 // (0xFFFF or 0xFFFFFFFF) and the ZIP64 format record SHOULD be created.
215 struct Zip64EocdRecord {
216   static constexpr uint32_t kSignature = 0x06064b50;
217 
218   // The signature of zip64 eocd record, must be |kSignature|
219   uint32_t record_signature;
220   // Size of zip64 end of central directory record. It SHOULD be the size of the
221   // remaining record and SHOULD NOT include the leading 12 bytes.
222   uint64_t record_size;
223   // The version of the tool that make this archive.
224   uint16_t version_made_by;
225   // Tool version needed to extract this archive.
226   uint16_t version_needed;
227   // Number of this disk.
228   uint32_t disk_num;
229   // Number of the disk with the start of the central directory.
230   uint32_t cd_start_disk;
231   // Total number of entries in the central directory on this disk.
232   // This implementation assumes that each archive spans a single
233   // disk only. i.e, that num_records_on_disk == num_records.
234   uint64_t num_records_on_disk;
235   // The total number of central directory records.
236   uint64_t num_records;
237   // The size of the central directory in bytes.
238   uint64_t cd_size;
239   // The offset of the start of the central directory, relative to the start of
240   // the file.
241   uint64_t cd_start_offset;
242 
243   Zip64EocdRecord() = default;
244 
245  private:
246   DISALLOW_COPY_AND_ASSIGN(Zip64EocdRecord);
247 } __attribute__((packed));
248 
249 // The possible contents of the Zip64 Extended Information Extra Field. It may appear in
250 // the 'extra' field of a central directory record or local file header. The order of
251 // the fields in the zip64 extended information record is fixed, but the fields MUST
252 // only appear if the corresponding local or central directory record field is set to
253 // 0xFFFF or 0xFFFFFFFF. And this entry in the Local header MUST include BOTH original
254 // and compressed file size fields.
255 struct Zip64ExtendedInfo {
256   static constexpr uint16_t kHeaderId = 0x0001;
257   // The header tag for this 'extra' block, should be |kHeaderId|.
258   uint16_t header_id;
259   // The size in bytes of the remaining data (excluding the top 4 bytes).
260   uint16_t data_size;
261   // Size in bytes of the uncompressed file.
262   std::optional<uint64_t> uncompressed_file_size;
263   // Size in bytes of the compressed file.
264   std::optional<uint64_t> compressed_file_size;
265   // Local file header offset relative to the start of the zip file.
266   std::optional<uint64_t> local_header_offset;
267 
268   // This implementation assumes that each archive spans a single disk only. So
269   // the disk_number is not used.
270   // uint32_t disk_num;
271   Zip64ExtendedInfo() = default;
272 
273  private:
274   DISALLOW_COPY_AND_ASSIGN(Zip64ExtendedInfo);
275 };
276 
277 // mask value that signifies that the entry has a DD
278 static const uint32_t kGPBDDFlagMask = 0x0008;
279 
280 // The maximum size of a central directory or a file
281 // comment in bytes.
282 static const uint32_t kMaxCommentLen = 65535;
283 
284 #endif /* LIBZIPARCHIVE_ZIPARCHIVECOMMON_H_ */
285