root
/
spring-boot
1
0
Fork 0
Code Issues Pull Requests 1 Packages Projects Releases Wiki Activity

Support zip64 jars

Browse Source 
See gh-16091
pull/18295/head
Camille Vienot 6 years ago committed by Andy Wilkinson
parent d5fc324537
commit 1917e1eac5
2 changed files with 150 additions and 17 deletions
Show Stats Download Patch File Download Diff File

143
spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/CentralDirectoryEndRecord.java
Unescape Escape View File

@ -17,6 +17,7 @@
package org.springframework.boot.loader.jar;
import java.io.IOException;
import java.util.Optional;
import org.springframework.boot.loader.data.RandomAccessData;
@ -25,6 +26,7 @@ import org.springframework.boot.loader.data.RandomAccessData;
*
* @author Phillip Webb
* @author Andy Wilkinson
* @author Camille Vienot
* @see <a href="https://en.wikipedia.org/wiki/Zip_%28file_format%29">Zip File Format</a>
*/
class CentralDirectoryEndRecord {
@ -33,6 +35,8 @@ class CentralDirectoryEndRecord {
private static final int MAXIMUM_COMMENT_LENGTH = 0xFFFF;
private static final int ZIP64_MAGICCOUNT = 0xFFFF;
private static final int MAXIMUM_SIZE = MINIMUM_SIZE + MAXIMUM_COMMENT_LENGTH;
private static final int SIGNATURE = 0x06054b50;
@ -41,6 +45,8 @@ class CentralDirectoryEndRecord {
private static final int READ_BLOCK_SIZE = 256;
private final Optional<Zip64End> zip64End;
private byte[] block;
private int offset;
@ -69,6 +75,9 @@ class CentralDirectoryEndRecord {
}
this.offset = this.block.length - this.size;
}
int startOfCentralDirectoryEndRecord = (int) (data.getSize() - this.size);
this.zip64End = Optional.ofNullable(
isZip64() ? new Zip64End(data, startOfCentralDirectoryEndRecord) : null);
}
private byte[] createBlockFromEndOfData(RandomAccessData data, int size) throws IOException {
@ -95,7 +104,10 @@ class CentralDirectoryEndRecord {
long getStartOfArchive(RandomAccessData data) {
long length = Bytes.littleEndianValue(this.block, this.offset + 12, 4);
long specifiedOffset = Bytes.littleEndianValue(this.block, this.offset + 16, 4);
long actualOffset = data.getSize() - this.size - length;
long zip64EndSize = this.zip64End.map((x) -> x.getSize()).orElse(0L);
int zip64LocSize = this.zip64End.map((x) -> Zip64Locator.ZIP64_LOCSIZE).orElse(0);
long actualOffset = data.getSize() - this.size - length - zip64EndSize
- zip64LocSize;
return actualOffset - specifiedOffset;
}
@ -106,9 +118,14 @@ class CentralDirectoryEndRecord {
* @return the central directory data
*/
RandomAccessData getCentralDirectory(RandomAccessData data) {
long offset = Bytes.littleEndianValue(this.block, this.offset + 16, 4);
long length = Bytes.littleEndianValue(this.block, this.offset + 12, 4);
return data.getSubsection(offset, length);
if (isZip64()) {
return this.zip64End.get().getCentratDirectory(data);
}
else {
long offset = Bytes.littleEndianValue(this.block, this.offset + 16, 4);
long length = Bytes.littleEndianValue(this.block, this.offset + 12, 4);
return data.getSubsection(offset, length);
}
}
/**
@ -116,11 +133,121 @@ class CentralDirectoryEndRecord {
* @return the number of records in the zip
*/
int getNumberOfRecords() {
long numberOfRecords = Bytes.littleEndianValue(this.block, this.offset + 10, 2);
if (numberOfRecords == 0xFFFF) {
throw new IllegalStateException("Zip64 archives are not supported");
if (isZip64()) {
return this.zip64End.get().getNumberOfRecords();
}
else {
long numberOfRecords = Bytes.littleEndianValue(this.block, this.offset + 10,
2);
return (int) numberOfRecords;
}
}
boolean isZip64() {
return (int) Bytes.littleEndianValue(this.block, this.offset + 10,
2) == ZIP64_MAGICCOUNT;
}
/**
* A Zip64 end of central directory record.
*
* @see <a href="https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT">Chapter
* 4.3.14 of Zip64 specification</a>
*/
private static class Zip64End {
static final int ZIP64_ENDTOT = 32; // total number of entries
static final int ZIP64_ENDSIZ = 40; // central directory size in bytes
static final int ZIP64_ENDOFF = 48; // offset of first CEN header
private final Zip64Locator locator;
private final long centralDirectoryOffset;
private final long centralDirectoryLength;
private int numberOfRecords;
Zip64End(RandomAccessData data, int centratDirectoryEndOffset)
throws IOException {
this(data, new Zip64Locator(data, centratDirectoryEndOffset));
}
Zip64End(RandomAccessData data, Zip64Locator locator) throws IOException {
this.locator = locator;
byte[] block = data.read(locator.getZip64EndOffset(), 56);
this.centralDirectoryOffset = Bytes.littleEndianValue(block, ZIP64_ENDOFF, 8);
this.centralDirectoryLength = Bytes.littleEndianValue(block, ZIP64_ENDSIZ, 8);
this.numberOfRecords = (int) Bytes.littleEndianValue(block, ZIP64_ENDTOT, 8);
}
return (int) numberOfRecords;
/**
* Return the size of this zip 64 end of central directory record.
* @return size of this zip 64 end of central directory record
*/
public long getSize() {
return this.locator.getZip64EndSize();
}
/**
* Return the bytes of the "Central directory" based on the offset indicated in
* this record.
* @param data the source data
* @return the central directory data
*/
public RandomAccessData getCentratDirectory(RandomAccessData data) {
return data.getSubsection(this.centralDirectoryOffset,
this.centralDirectoryLength);
}
/**
* Return the number of entries in the zip64 archive.
* @return the number of records in the zip
*/
public int getNumberOfRecords() {
return this.numberOfRecords;
}
}
/**
* A Zip64 end of central directory locator.
*
* @see <a href="https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT">Chapter
* 4.3.15 of Zip64 specification</a>
*/
private static class Zip64Locator {
static final int ZIP64_LOCSIZE = 20; // locator size
static final int ZIP64_LOCOFF = 8; // offset of zip64 end
private final long zip64EndOffset;
private final int offset;
Zip64Locator(RandomAccessData data, int centralDirectoryEndOffset)
throws IOException {
this.offset = centralDirectoryEndOffset - ZIP64_LOCSIZE;
byte[] block = data.read(this.offset, ZIP64_LOCSIZE);
this.zip64EndOffset = Bytes.littleEndianValue(block, ZIP64_LOCOFF, 8);
}
/**
* Return the size of the zip 64 end record located by this zip64 end locator.
* @return size of the zip 64 end record located by this zip64 end locator
*/
public long getZip64EndSize() {
return this.offset - this.zip64EndOffset;
}
/**
* Return the offset to locate {@link Zip64End}.
* @return offset of the Zip64 end of central directory record
*/
public long getZip64EndOffset() {
return this.zip64EndOffset;
}
}
String getComment() {

24
spring-boot-project/spring-boot-tools/spring-boot-loader/src/test/java/org/springframework/boot/loader/archive/JarFileArchiveTests.java
Unescape Escape View File

@ -22,6 +22,7 @@ import java.io.FileOutputStream;
import java.io.IOException;
import java.net.URL;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.jar.JarEntry;
import java.util.jar.JarOutputStream;
@ -38,13 +39,13 @@ import org.springframework.boot.loader.archive.Archive.Entry;
import org.springframework.util.FileCopyUtils;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
/**
* Tests for {@link JarFileArchive}.
*
* @author Phillip Webb
* @author Andy Wilkinson
* @author Camille Vienot
*/
class JarFileArchiveTests {
@ -142,11 +143,15 @@ class JarFileArchiveTests {
}
@Test
void zip64ArchivesAreHandledGracefully() throws IOException {
void filesInzip64ArchivesAreAllListed() throws IOException {
File file = new File(this.tempDir, "test.jar");
FileCopyUtils.copy(writeZip64Jar(), file);
assertThatIllegalStateException().isThrownBy(() -> new JarFileArchive(file))
.withMessageContaining("Zip64 archives are not supported");
JarFileArchive zip64Archive = new JarFileArchive(file);
Iterator<Entry> it = zip64Archive.iterator();
for (int i = 0; i < 65537; i++) {
assertThat(it.hasNext()).as(i + "nth file is present").isTrue();
it.next();
}
}
@Test
@ -166,11 +171,12 @@ class JarFileArchiveTests {
output.closeEntry();
output.close();
JarFileArchive jarFileArchive = new JarFileArchive(file);
assertThatIllegalStateException().isThrownBy(() -> {
Archive archive = jarFileArchive.getNestedArchive(getEntriesMap(jarFileArchive).get("nested/zip64.jar"));
((JarFileArchive) archive).close();
}).withMessageContaining("Failed to get nested archive for entry nested/zip64.jar");
jarFileArchive.close();
Archive nestedArchive = jarFileArchive.getNestedArchive(getEntriesMap(jarFileArchive).get("nested/zip64.jar"));
Iterator<Entry> it = nestedArchive.iterator();
for (int i = 0; i < 65537; i++) {
assertThat(it.hasNext()).as(i + "nth file is present").isTrue();
it.next();
}
}
private byte[] writeZip64Jar() throws IOException {

Write Preview
Loading…
Cancel
Save