1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.commons.compress.archivers.zip;
18
19 import java.lang.reflect.Constructor;
20 import java.util.ArrayList;
21 import java.util.List;
22 import java.util.Objects;
23 import java.util.concurrent.ConcurrentHashMap;
24 import java.util.concurrent.ConcurrentMap;
25 import java.util.function.Supplier;
26 import java.util.zip.ZipException;
27
28
29
30
31
32 public class ExtraFieldUtils {
33
34
35
36
37
38
39
40
41
42 public static final class UnparseableExtraField implements UnparseableExtraFieldBehavior {
43
44
45
46
47 public static final int THROW_KEY = 0;
48
49
50
51 public static final int SKIP_KEY = 1;
52
53
54
55 public static final int READ_KEY = 2;
56
57
58
59
60 public static final UnparseableExtraField THROW = new UnparseableExtraField(THROW_KEY);
61
62
63
64
65 public static final UnparseableExtraField SKIP = new UnparseableExtraField(SKIP_KEY);
66
67
68
69
70 public static final UnparseableExtraField READ = new UnparseableExtraField(READ_KEY);
71
72 private final int key;
73
74 private UnparseableExtraField(final int k) {
75 key = k;
76 }
77
78
79
80
81
82
83 public int getKey() {
84 return key;
85 }
86
87 @Override
88 public ZipExtraField onUnparseableExtraField(final byte[] data, final int off, final int len, final boolean local, final int claimedLength)
89 throws ZipException {
90 switch (key) {
91 case THROW_KEY:
92 throw new ZipException("Bad extra field starting at " + off + ". Block length of " + claimedLength + " bytes exceeds remaining" + " data of "
93 + (len - WORD) + " bytes.");
94 case READ_KEY:
95 final UnparseableExtraFieldData field = new UnparseableExtraFieldData();
96 if (local) {
97 field.parseFromLocalFileData(data, off, len);
98 } else {
99 field.parseFromCentralDirectoryData(data, off, len);
100 }
101 return field;
102 case SKIP_KEY:
103 return null;
104 default:
105 throw new ZipException("Unknown UnparseableExtraField key: " + key);
106 }
107 }
108
109 }
110
111 private static final int WORD = 4;
112
113
114
115
116 private static final ConcurrentMap<ZipShort, Supplier<ZipExtraField>> IMPLEMENTATIONS;
117
118 static {
119 IMPLEMENTATIONS = new ConcurrentHashMap<>();
120 IMPLEMENTATIONS.put(AsiExtraField.HEADER_ID, AsiExtraField::new);
121 IMPLEMENTATIONS.put(X5455_ExtendedTimestamp.HEADER_ID, X5455_ExtendedTimestamp::new);
122 IMPLEMENTATIONS.put(X7875_NewUnix.HEADER_ID, X7875_NewUnix::new);
123 IMPLEMENTATIONS.put(JarMarker.ID, JarMarker::new);
124 IMPLEMENTATIONS.put(UnicodePathExtraField.UPATH_ID, UnicodePathExtraField::new);
125 IMPLEMENTATIONS.put(UnicodeCommentExtraField.UCOM_ID, UnicodeCommentExtraField::new);
126 IMPLEMENTATIONS.put(Zip64ExtendedInformationExtraField.HEADER_ID, Zip64ExtendedInformationExtraField::new);
127 IMPLEMENTATIONS.put(X000A_NTFS.HEADER_ID, X000A_NTFS::new);
128 IMPLEMENTATIONS.put(X0014_X509Certificates.HEADER_ID, X0014_X509Certificates::new);
129 IMPLEMENTATIONS.put(X0015_CertificateIdForFile.HEADER_ID, X0015_CertificateIdForFile::new);
130 IMPLEMENTATIONS.put(X0016_CertificateIdForCentralDirectory.HEADER_ID, X0016_CertificateIdForCentralDirectory::new);
131 IMPLEMENTATIONS.put(X0017_StrongEncryptionHeader.HEADER_ID, X0017_StrongEncryptionHeader::new);
132 IMPLEMENTATIONS.put(X0019_EncryptionRecipientCertificateList.HEADER_ID, X0019_EncryptionRecipientCertificateList::new);
133 IMPLEMENTATIONS.put(ResourceAlignmentExtraField.ID, ResourceAlignmentExtraField::new);
134 }
135
136 static final ZipExtraField[] EMPTY_ZIP_EXTRA_FIELD_ARRAY = {};
137
138
139
140
141
142
143
144 public static ZipExtraField createExtraField(final ZipShort headerId) {
145 final ZipExtraField field = createExtraFieldNoDefault(headerId);
146 if (field != null) {
147 return field;
148 }
149 final UnrecognizedExtraField u = new UnrecognizedExtraField();
150 u.setHeaderId(headerId);
151 return u;
152 }
153
154
155
156
157
158
159
160
161 public static ZipExtraField createExtraFieldNoDefault(final ZipShort headerId) {
162 final Supplier<ZipExtraField> provider = IMPLEMENTATIONS.get(headerId);
163 return provider != null ? provider.get() : null;
164 }
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185 public static ZipExtraField fillExtraField(final ZipExtraField ze, final byte[] data, final int off, final int len, final boolean local)
186 throws ZipException {
187 try {
188 if (local) {
189 ze.parseFromLocalFileData(data, off, len);
190 } else {
191 ze.parseFromCentralDirectoryData(data, off, len);
192 }
193 return ze;
194 } catch (final ArrayIndexOutOfBoundsException e) {
195 throw (ZipException) new ZipException("Failed to parse corrupt ZIP extra field of type " + Integer.toHexString(ze.getHeaderId().getValue()))
196 .initCause(e);
197 }
198 }
199
200
201
202
203
204
205
206 public static byte[] mergeCentralDirectoryData(final ZipExtraField[] data) {
207 final int dataLength = data.length;
208 final boolean lastIsUnparseableHolder = dataLength > 0 && data[dataLength - 1] instanceof UnparseableExtraFieldData;
209 final int regularExtraFieldCount = lastIsUnparseableHolder ? dataLength - 1 : dataLength;
210
211 int sum = WORD * regularExtraFieldCount;
212 for (final ZipExtraField element : data) {
213 sum += element.getCentralDirectoryLength().getValue();
214 }
215 final byte[] result = new byte[sum];
216 int start = 0;
217 for (int i = 0; i < regularExtraFieldCount; i++) {
218 System.arraycopy(data[i].getHeaderId().getBytes(), 0, result, start, 2);
219 System.arraycopy(data[i].getCentralDirectoryLength().getBytes(), 0, result, start + 2, 2);
220 start += WORD;
221 final byte[] central = data[i].getCentralDirectoryData();
222 if (central != null) {
223 System.arraycopy(central, 0, result, start, central.length);
224 start += central.length;
225 }
226 }
227 if (lastIsUnparseableHolder) {
228 final byte[] central = data[dataLength - 1].getCentralDirectoryData();
229 if (central != null) {
230 System.arraycopy(central, 0, result, start, central.length);
231 }
232 }
233 return result;
234 }
235
236
237
238
239
240
241
242 public static byte[] mergeLocalFileDataData(final ZipExtraField[] data) {
243 final int dataLength = data.length;
244 final boolean lastIsUnparseableHolder = dataLength > 0 && data[dataLength - 1] instanceof UnparseableExtraFieldData;
245 final int regularExtraFieldCount = lastIsUnparseableHolder ? dataLength - 1 : dataLength;
246
247 int sum = WORD * regularExtraFieldCount;
248 for (final ZipExtraField element : data) {
249 sum += element.getLocalFileDataLength().getValue();
250 }
251
252 final byte[] result = new byte[sum];
253 int start = 0;
254 for (int i = 0; i < regularExtraFieldCount; i++) {
255 System.arraycopy(data[i].getHeaderId().getBytes(), 0, result, start, 2);
256 System.arraycopy(data[i].getLocalFileDataLength().getBytes(), 0, result, start + 2, 2);
257 start += WORD;
258 final byte[] local = data[i].getLocalFileDataData();
259 if (local != null) {
260 System.arraycopy(local, 0, result, start, local.length);
261 start += local.length;
262 }
263 }
264 if (lastIsUnparseableHolder) {
265 final byte[] local = data[dataLength - 1].getLocalFileDataData();
266 if (local != null) {
267 System.arraycopy(local, 0, result, start, local.length);
268 }
269 }
270 return result;
271 }
272
273
274
275
276
277
278
279
280 public static ZipExtraField[] parse(final byte[] data) throws ZipException {
281 return parse(data, true, UnparseableExtraField.THROW);
282 }
283
284
285
286
287
288
289
290
291
292 public static ZipExtraField[] parse(final byte[] data, final boolean local) throws ZipException {
293 return parse(data, local, UnparseableExtraField.THROW);
294 }
295
296
297
298
299
300
301
302
303
304
305
306
307 public static ZipExtraField[] parse(final byte[] data, final boolean local, final ExtraFieldParsingBehavior parsingBehavior) throws ZipException {
308 final List<ZipExtraField> v = new ArrayList<>();
309 int start = 0;
310 final int dataLength = data.length;
311 LOOP: while (start <= dataLength - WORD) {
312 final ZipShort headerId = new ZipShort(data, start);
313 final int length = new ZipShort(data, start + 2).getValue();
314 if (start + WORD + length > dataLength) {
315 final ZipExtraField field = parsingBehavior.onUnparseableExtraField(data, start, dataLength - start, local, length);
316 if (field != null) {
317 v.add(field);
318 }
319
320
321
322 break LOOP;
323 }
324 try {
325 final ZipExtraField ze = Objects.requireNonNull(parsingBehavior.createExtraField(headerId), "createExtraField must not return null");
326 v.add(Objects.requireNonNull(parsingBehavior.fill(ze, data, start + WORD, length, local), "fill must not return null"));
327 start += length + WORD;
328 } catch (final InstantiationException | IllegalAccessException e) {
329 throw (ZipException) new ZipException(e.getMessage()).initCause(e);
330 }
331 }
332
333 return v.toArray(EMPTY_ZIP_EXTRA_FIELD_ARRAY);
334 }
335
336
337
338
339
340
341
342
343
344
345
346
347 public static ZipExtraField[] parse(final byte[] data, final boolean local, final UnparseableExtraField onUnparseableData) throws ZipException {
348 return parse(data, local, new ExtraFieldParsingBehavior() {
349
350 @Override
351 public ZipExtraField createExtraField(final ZipShort headerId) {
352 return ExtraFieldUtils.createExtraField(headerId);
353 }
354
355 @Override
356 public ZipExtraField fill(final ZipExtraField field, final byte[] data, final int off, final int len, final boolean local) throws ZipException {
357 return fillExtraField(field, data, off, len, local);
358 }
359
360 @Override
361 public ZipExtraField onUnparseableExtraField(final byte[] data, final int off, final int len, final boolean local, final int claimedLength)
362 throws ZipException {
363 return onUnparseableData.onUnparseableExtraField(data, off, len, local, claimedLength);
364 }
365 });
366 }
367
368
369
370
371
372
373
374
375
376
377
378
379 @Deprecated
380 public static void register(final Class<?> clazz) {
381 try {
382 final Constructor<? extends ZipExtraField> constructor = clazz.asSubclass(ZipExtraField.class).getConstructor();
383 final ZipExtraField zef = clazz.asSubclass(ZipExtraField.class).getConstructor().newInstance();
384 IMPLEMENTATIONS.put(zef.getHeaderId(), () -> {
385 try {
386 return constructor.newInstance();
387 } catch (final ReflectiveOperationException e) {
388 throw new IllegalStateException(clazz.toString(), e);
389 }
390 });
391 } catch (final ReflectiveOperationException e) {
392 throw new IllegalArgumentException(clazz.toString(), e);
393 }
394 }
395 }