373 lines
15 KiB
Java
373 lines
15 KiB
Java
/*
|
|
* Copyright (c) 2023, 2024, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
/* @test
|
|
* @bug 8272746
|
|
* @modules java.base/jdk.internal.util
|
|
* @summary Verify that ZipFile rejects files with CEN sizes exceeding the implementation limit
|
|
* @run junit/othervm EndOfCenValidation
|
|
*/
|
|
|
|
import jdk.internal.util.ArraysSupport;
|
|
import org.junit.jupiter.api.BeforeEach;
|
|
import org.junit.jupiter.api.AfterEach;
|
|
import org.junit.jupiter.api.Test;
|
|
import org.junit.jupiter.params.ParameterizedTest;
|
|
import org.junit.jupiter.params.provider.ValueSource;
|
|
|
|
import java.io.*;
|
|
import java.nio.ByteBuffer;
|
|
import java.nio.ByteOrder;
|
|
import java.nio.channels.FileChannel;
|
|
import java.nio.charset.StandardCharsets;
|
|
import java.nio.file.Files;
|
|
import java.nio.file.Path;
|
|
import java.nio.file.StandardOpenOption;
|
|
import java.util.Arrays;
|
|
import java.util.EnumSet;
|
|
import java.util.HexFormat;
|
|
import java.util.zip.ZipEntry;
|
|
import java.util.zip.ZipException;
|
|
import java.util.zip.ZipFile;
|
|
import java.util.zip.ZipOutputStream;
|
|
|
|
import static org.junit.jupiter.api.Assertions.*;
|
|
|
|
/**
|
|
* This test augments {@link TestTooManyEntries}. It creates sparse ZIPs where
|
|
* the CEN size is inflated to the desired value. This helps this test run
|
|
* fast with much less resources.
|
|
*
|
|
* While the CEN in these files are zero-filled and the produced ZIPs are technically
|
|
* invalid, the CEN is never actually read by ZipFile since it does
|
|
* 'End of central directory record' (END header) validation before reading the CEN.
|
|
*/
|
|
public class EndOfCenValidation {
|
|
|
|
// Zip files produced by this test
|
|
public static final Path CEN_TOO_LARGE_ZIP = Path.of("cen-size-too-large.zip");
|
|
public static final Path INVALID_CEN_SIZE = Path.of("invalid-zen-size.zip");
|
|
public static final Path BAD_CEN_OFFSET_ZIP = Path.of("bad-cen-offset.zip");
|
|
// Some ZipFile constants for manipulating the 'End of central directory record' (END header)
|
|
private static final int ENDHDR = ZipFile.ENDHDR; // End of central directory record size
|
|
private static final int ENDSIZ = ZipFile.ENDSIZ; // Offset of CEN size field within ENDHDR
|
|
private static final int ENDOFF = ZipFile.ENDOFF; // Offset of CEN offset field within ENDHDR
|
|
// Maximum allowed CEN size allowed by ZipFile
|
|
private static final int MAX_CEN_SIZE = ArraysSupport.SOFT_MAX_ARRAY_LENGTH;
|
|
|
|
// Expected message when CEN size does not match file size
|
|
private static final String INVALID_CEN_BAD_SIZE = "invalid END header (bad central directory size)";
|
|
// Expected message when CEN offset is too large
|
|
private static final String INVALID_CEN_BAD_OFFSET = "invalid END header (bad central directory offset)";
|
|
// Expected message when CEN size is too large
|
|
private static final String INVALID_CEN_SIZE_TOO_LARGE = "invalid END header (central directory size too large)";
|
|
// Expected message when total entry count is too large
|
|
private static final String INVALID_BAD_ENTRY_COUNT = "invalid END header (total entries count too large)";
|
|
|
|
// A valid ZIP file, used as a template
|
|
private byte[] zipBytes;
|
|
|
|
/**
|
|
* Create a valid ZIP file, used as a template
|
|
* @throws IOException if an error occurs
|
|
*/
|
|
@BeforeEach
|
|
public void setup() throws IOException {
|
|
zipBytes = templateZip();
|
|
}
|
|
|
|
/**
|
|
* Delete big files after test, in case the file system did not support sparse files.
|
|
* @throws IOException if an error occurs
|
|
*/
|
|
@AfterEach
|
|
public void cleanup() throws IOException {
|
|
Files.deleteIfExists(CEN_TOO_LARGE_ZIP);
|
|
Files.deleteIfExists(INVALID_CEN_SIZE);
|
|
Files.deleteIfExists(BAD_CEN_OFFSET_ZIP);
|
|
}
|
|
|
|
/**
|
|
* Validates that an 'End of central directory record' (END header) with a CEN
|
|
* length exceeding {@link #MAX_CEN_SIZE} limit is rejected
|
|
* @throws IOException if an error occurs
|
|
*/
|
|
@Test
|
|
public void shouldRejectTooLargeCenSize() throws IOException {
|
|
int size = MAX_CEN_SIZE + 1;
|
|
|
|
Path zip = zipWithModifiedEndRecord(size, true, 0, CEN_TOO_LARGE_ZIP);
|
|
|
|
ZipException ex = assertThrows(ZipException.class, () -> {
|
|
new ZipFile(zip.toFile());
|
|
});
|
|
|
|
assertEquals(INVALID_CEN_SIZE_TOO_LARGE, ex.getMessage());
|
|
}
|
|
|
|
/**
|
|
* Validate that an 'End of central directory record' (END header)
|
|
* where the value of the CEN size field exceeds the position of
|
|
* the END header is rejected.
|
|
* @throws IOException if an error occurs
|
|
*/
|
|
@Test
|
|
public void shouldRejectInvalidCenSize() throws IOException {
|
|
|
|
int size = MAX_CEN_SIZE;
|
|
|
|
Path zip = zipWithModifiedEndRecord(size, false, 0, INVALID_CEN_SIZE);
|
|
|
|
ZipException ex = assertThrows(ZipException.class, () -> {
|
|
new ZipFile(zip.toFile());
|
|
});
|
|
|
|
assertEquals(INVALID_CEN_BAD_SIZE, ex.getMessage());
|
|
}
|
|
|
|
/**
|
|
* Validate that an 'End of central directory record' (the END header)
|
|
* where the value of the CEN offset field is larger than the position
|
|
* of the END header minus the CEN size is rejected
|
|
* @throws IOException if an error occurs
|
|
*/
|
|
@Test
|
|
public void shouldRejectInvalidCenOffset() throws IOException {
|
|
|
|
int size = MAX_CEN_SIZE;
|
|
|
|
Path zip = zipWithModifiedEndRecord(size, true, 100, BAD_CEN_OFFSET_ZIP);
|
|
|
|
ZipException ex = assertThrows(ZipException.class, () -> {
|
|
new ZipFile(zip.toFile());
|
|
});
|
|
|
|
assertEquals(INVALID_CEN_BAD_OFFSET, ex.getMessage());
|
|
}
|
|
|
|
/**
|
|
* Validate that a 'Zip64 End of Central Directory' record (the END header)
|
|
* where the value of the 'total entries' field is larger than what fits
|
|
* in the CEN size is rejected.
|
|
*
|
|
* @throws IOException if an error occurs
|
|
*/
|
|
@ParameterizedTest
|
|
@ValueSource(longs = {
|
|
-1, // Negative
|
|
Long.MIN_VALUE, // Very negative
|
|
0x3B / 3L - 1, // Cannot fit in test ZIP's CEN
|
|
MAX_CEN_SIZE / 3 + 1, // Too large to allocate int[] entries array
|
|
Long.MAX_VALUE // Unreasonably large
|
|
})
|
|
public void shouldRejectBadTotalEntries(long totalEntries) throws IOException {
|
|
/**
|
|
* A small ZIP using the ZIP64 format.
|
|
*
|
|
* ZIP created using: "echo -n hello | zip zip64.zip -"
|
|
* Hex encoded using: "cat zip64.zip | xxd -ps"
|
|
*
|
|
* The file has the following structure:
|
|
*
|
|
* 0000 LOCAL HEADER #1 04034B50
|
|
* 0004 Extract Zip Spec 2D '4.5'
|
|
* 0005 Extract OS 00 'MS-DOS'
|
|
* 0006 General Purpose Flag 0000
|
|
* 0008 Compression Method 0000 'Stored'
|
|
* 000A Last Mod Time 5947AB78 'Mon Oct 7 21:27:48 2024'
|
|
* 000E CRC 363A3020
|
|
* 0012 Compressed Length FFFFFFFF
|
|
* 0016 Uncompressed Length FFFFFFFF
|
|
* 001A Filename Length 0001
|
|
* 001C Extra Length 0014
|
|
* 001E Filename '-'
|
|
* 001F Extra ID #0001 0001 'ZIP64'
|
|
* 0021 Length 0010
|
|
* 0023 Uncompressed Size 0000000000000006
|
|
* 002B Compressed Size 0000000000000006
|
|
* 0033 PAYLOAD hello.
|
|
*
|
|
* 0039 CENTRAL HEADER #1 02014B50
|
|
* 003D Created Zip Spec 1E '3.0'
|
|
* 003E Created OS 03 'Unix'
|
|
* 003F Extract Zip Spec 2D '4.5'
|
|
* 0040 Extract OS 00 'MS-DOS'
|
|
* 0041 General Purpose Flag 0000
|
|
* 0043 Compression Method 0000 'Stored'
|
|
* 0045 Last Mod Time 5947AB78 'Mon Oct 7 21:27:48 2024'
|
|
* 0049 CRC 363A3020
|
|
* 004D Compressed Length 00000006
|
|
* 0051 Uncompressed Length FFFFFFFF
|
|
* 0055 Filename Length 0001
|
|
* 0057 Extra Length 000C
|
|
* 0059 Comment Length 0000
|
|
* 005B Disk Start 0000
|
|
* 005D Int File Attributes 0001
|
|
* [Bit 0] 1 Text Data
|
|
* 005F Ext File Attributes 11B00000
|
|
* 0063 Local Header Offset 00000000
|
|
* 0067 Filename '-'
|
|
* 0068 Extra ID #0001 0001 'ZIP64'
|
|
* 006A Length 0008
|
|
* 006C Uncompressed Size 0000000000000006
|
|
*
|
|
* 0074 ZIP64 END CENTRAL DIR 06064B50
|
|
* RECORD
|
|
* 0078 Size of record 000000000000002C
|
|
* 0080 Created Zip Spec 1E '3.0'
|
|
* 0081 Created OS 03 'Unix'
|
|
* 0082 Extract Zip Spec 2D '4.5'
|
|
* 0083 Extract OS 00 'MS-DOS'
|
|
* 0084 Number of this disk 00000000
|
|
* 0088 Central Dir Disk no 00000000
|
|
* 008C Entries in this disk 0000000000000001
|
|
* 0094 Total Entries 0000000000000001
|
|
* 009C Size of Central Dir 000000000000003B
|
|
* 00A4 Offset to Central dir 0000000000000039
|
|
*
|
|
* 00AC ZIP64 END CENTRAL DIR 07064B50
|
|
* LOCATOR
|
|
* 00B0 Central Dir Disk no 00000000
|
|
* 00B4 Offset to Central dir 0000000000000074
|
|
* 00BC Total no of Disks 00000001
|
|
*
|
|
* 00C0 END CENTRAL HEADER 06054B50
|
|
* 00C4 Number of this disk 0000
|
|
* 00C6 Central Dir Disk no 0000
|
|
* 00C8 Entries in this disk 0001
|
|
* 00CA Total Entries 0001
|
|
* 00CC Size of Central Dir 0000003B
|
|
* 00D0 Offset to Central Dir FFFFFFFF
|
|
* 00D4 Comment Length 0000
|
|
*/
|
|
|
|
byte[] zipBytes = HexFormat.of().parseHex("""
|
|
504b03042d000000000078ab475920303a36ffffffffffffffff01001400
|
|
2d010010000600000000000000060000000000000068656c6c6f0a504b01
|
|
021e032d000000000078ab475920303a3606000000ffffffff01000c0000
|
|
00000001000000b011000000002d010008000600000000000000504b0606
|
|
2c000000000000001e032d00000000000000000001000000000000000100
|
|
0000000000003b000000000000003900000000000000504b060700000000
|
|
740000000000000001000000504b050600000000010001003b000000ffff
|
|
ffff0000
|
|
""".replaceAll("\n",""));
|
|
|
|
// Buffer to manipulate the above ZIP
|
|
ByteBuffer buf = ByteBuffer.wrap(zipBytes).order(ByteOrder.LITTLE_ENDIAN);
|
|
// Offset of the 'total entries' in the 'ZIP64 END CENTRAL DIR' record
|
|
// Update ZIP64 entry count to a value which cannot possibly fit in the small CEN
|
|
buf.putLong(0x94, totalEntries);
|
|
// The corresponding END field needs the ZIP64 magic value
|
|
buf.putShort(0xCA, (short) 0xFFFF);
|
|
// Write the ZIP to disk
|
|
Path zipFile = Path.of("bad-entry-count.zip");
|
|
Files.write(zipFile, zipBytes);
|
|
|
|
// Verify that the END header is rejected
|
|
ZipException ex = assertThrows(ZipException.class, () -> {
|
|
try (var zf = new ZipFile(zipFile.toFile())) {
|
|
}
|
|
});
|
|
|
|
assertEquals(INVALID_BAD_ENTRY_COUNT, ex.getMessage());
|
|
}
|
|
|
|
/**
|
|
* Create an ZIP file with a single entry, then modify the CEN size
|
|
* in the 'End of central directory record' (END header) to the given size.
|
|
*
|
|
* The CEN is optionally "inflated" with trailing zero bytes such that
|
|
* its actual size matches the one stated in the END header.
|
|
*
|
|
* The CEN offset is optiontially adjusted by the given amount
|
|
*
|
|
* The resulting ZIP is technically not valid, but it does allow us
|
|
* to test that large or invalid CEN sizes are rejected
|
|
* @param cenSize the CEN size to put in the END record
|
|
* @param inflateCen if true, zero-pad the CEN to the desired size
|
|
* @param cenOffAdjust Adjust the CEN offset field of the END record with this amount
|
|
* @throws IOException if an error occurs
|
|
*/
|
|
private Path zipWithModifiedEndRecord(int cenSize,
|
|
boolean inflateCen,
|
|
int cenOffAdjust,
|
|
Path zip) throws IOException {
|
|
|
|
// A byte buffer for reading the END
|
|
ByteBuffer buffer = ByteBuffer.wrap(zipBytes.clone()).order(ByteOrder.LITTLE_ENDIAN);
|
|
|
|
// Offset of the END header
|
|
int endOffset = buffer.limit() - ENDHDR;
|
|
|
|
// Modify the CEN size
|
|
int sizeOffset = endOffset + ENDSIZ;
|
|
int currentCenSize = buffer.getInt(sizeOffset);
|
|
buffer.putInt(sizeOffset, cenSize);
|
|
|
|
// Optionally modify the CEN offset
|
|
if (cenOffAdjust != 0) {
|
|
int offOffset = endOffset + ENDOFF;
|
|
int currentCenOff = buffer.getInt(offOffset);
|
|
buffer.putInt(offOffset, currentCenOff + cenOffAdjust);
|
|
}
|
|
|
|
// When creating a sparse file, the file must not already exit
|
|
Files.deleteIfExists(zip);
|
|
|
|
// Open a FileChannel for writing a sparse file
|
|
EnumSet<StandardOpenOption> options = EnumSet.of(StandardOpenOption.CREATE_NEW,
|
|
StandardOpenOption.WRITE,
|
|
StandardOpenOption.SPARSE);
|
|
|
|
try (FileChannel channel = FileChannel.open(zip, options)) {
|
|
|
|
// Write everything up to END
|
|
channel.write(buffer.slice(0, buffer.limit() - ENDHDR));
|
|
|
|
if (inflateCen) {
|
|
// Inject "empty bytes" to make the actual CEN size match the END
|
|
int injectBytes = cenSize - currentCenSize;
|
|
channel.position(channel.position() + injectBytes);
|
|
}
|
|
// Write the modified END
|
|
channel.write(buffer.slice(buffer.limit() - ENDHDR, ENDHDR));
|
|
}
|
|
return zip;
|
|
}
|
|
|
|
/**
|
|
* Produce a byte array of a ZIP with a single entry
|
|
*
|
|
* @throws IOException if an error occurs
|
|
*/
|
|
private byte[] templateZip() throws IOException {
|
|
ByteArrayOutputStream bout = new ByteArrayOutputStream();
|
|
try (ZipOutputStream zo = new ZipOutputStream(bout)) {
|
|
ZipEntry entry = new ZipEntry("duke.txt");
|
|
zo.putNextEntry(entry);
|
|
zo.write("duke".getBytes(StandardCharsets.UTF_8));
|
|
}
|
|
return bout.toByteArray();
|
|
}
|
|
}
|