root
/
spring-boot
mirror of https://github.com/spring-projects/spring-boot.git
1
0
Fork 0
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #16091 from cvienot 

* gh-16091:
  Polish "Support zip64 jars"
  Support zip64 jars

Closes gh-16091
This commit is contained in:
Andy Wilkinson 2019-09-20 14:35:35 +01:00
parent d5fc324537 02ac089767
commit 185d9a3d71
4 changed files with 207 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
spring-boot-project/spring-boot-docs/src/main/asciidoc/deployment.adoc
View File

@ -404,6 +404,10 @@ Currently, some tools do not accept this format, so you may not always be able t
For example, `jar -xf` may silently fail to extract a jar or war that has been made fully executable.
It is recommended that you make your jar or war fully executable only if you intend to execute it directly, rather than running it with `java -jar`or deploying it to a servlet container.
CAUTION: A zip64-format jar file cannot be made fully executable.
Attempting to do so will result in a jar file that is reported as corrupt when executed directly or with `java -jar`.
A standard-format jar file that contains one or more zip64-format nested jars can be fully executable.
To create a '`fully executable`' jar with Maven, use the following plugin configuration:
[source,xml,indent=0,subs="verbatim,quotes,attributes"]

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

@ -25,6 +25,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 +34,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 +44,8 @@ class CentralDirectoryEndRecord {
private static final int READ_BLOCK_SIZE = 256;
private final Zip64End zip64End;
private byte[] block;
private int offset;
@ -69,6 +74,8 @@ class CentralDirectoryEndRecord {
}
this.offset = this.block.length - this.size;
}
int startOfCentralDirectoryEndRecord = (int) (data.getSize() - this.size);
this.zip64End = isZip64() ? new Zip64End(data, startOfCentralDirectoryEndRecord) : null;
}
private byte[] createBlockFromEndOfData(RandomAccessData data, int size) throws IOException {
@ -85,6 +92,10 @@ class CentralDirectoryEndRecord {
return this.size == MINIMUM_SIZE + commentLength;
}
private boolean isZip64() {
return (int) Bytes.littleEndianValue(this.block, this.offset + 10, 2) == ZIP64_MAGICCOUNT;
}
/**
* Returns the location in the data that the archive actually starts. For most files
* the archive data will start at 0, however, it is possible to have prefixed bytes
@ -95,7 +106,9 @@ 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 != null) ? this.zip64End.getSize() : 0L;
int zip64LocSize = (this.zip64End != null) ? Zip64Locator.ZIP64_LOCSIZE : 0;
long actualOffset = data.getSize() - this.size - length - zip64EndSize - zip64LocSize;
return actualOffset - specifiedOffset;
}
@ -106,6 +119,9 @@ class CentralDirectoryEndRecord {
* @return the central directory data
*/
RandomAccessData getCentralDirectory(RandomAccessData data) {
if (this.zip64End != null) {
return this.zip64End.getCentralDirectory(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);
@ -116,10 +132,10 @@ 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 (this.zip64End != null) {
return this.zip64End.getNumberOfRecords();
}
long numberOfRecords = Bytes.littleEndianValue(this.block, this.offset + 10, 2);
return (int) numberOfRecords;
}
@ -129,4 +145,105 @@ class CentralDirectoryEndRecord {
return comment.toString();
}
/**
* 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 final class Zip64End {
private static final int ZIP64_ENDTOT = 32; // total number of entries
private static final int ZIP64_ENDSIZ = 40; // central directory size in bytes
private 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;
private Zip64End(RandomAccessData data, int centratDirectoryEndOffset) throws IOException {
this(data, new Zip64Locator(data, centratDirectoryEndOffset));
}
private 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 the size of this zip 64 end of central directory record.
* @return size of this zip 64 end of central directory record
*/
private 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
*/
private RandomAccessData getCentralDirectory(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
*/
private 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 final 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;
private 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
*/
private long getZip64EndSize() {
return this.offset - this.zip64EndOffset;
}
/**
* Return the offset to locate {@link Zip64End}.
* @return offset of the Zip64 end of central directory record
*/
private long getZip64EndOffset() {
return this.zip64EndOffset;
}
}
}

25
spring-boot-project/spring-boot-tools/spring-boot-loader/src/test/java/org/springframework/boot/loader/archive/JarFileArchiveTests.java
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,16 @@ 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");
try (JarFileArchive zip64Archive = new JarFileArchive(file)) {
Iterator<Entry> entries = zip64Archive.iterator();
for (int i = 0; i < 65537; i++) {
assertThat(entries.hasNext()).as(i + "nth file is present").isTrue();
entries.next();
}
}
}
@Test
@ -166,11 +172,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 {

66
spring-boot-project/spring-boot-tools/spring-boot-loader/src/test/java/org/springframework/boot/loader/jar/JarFileTests.java
View File

@ -16,19 +16,26 @@
package org.springframework.boot.loader.jar;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FilePermission;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.net.URLClassLoader;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.Collections;
import java.util.Enumeration;
import java.util.List;
import java.util.jar.JarEntry;
import java.util.jar.JarInputStream;
import java.util.jar.JarOutputStream;
import java.util.jar.Manifest;
import java.util.zip.CRC32;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
@ -512,6 +519,65 @@ class JarFileTests {
}
}
@Test
void zip64JarCanBeRead() throws Exception {
File zip64Jar = new File(this.tempDir, "zip64.jar");
FileCopyUtils.copy(zip64Jar(), zip64Jar);
try (JarFile zip64JarFile = new JarFile(zip64Jar)) {
List<JarEntry> entries = Collections.list(zip64JarFile.entries());
assertThat(entries).hasSize(65537);
for (int i = 0; i < entries.size(); i++) {
JarEntry entry = entries.get(i);
InputStream entryInput = zip64JarFile.getInputStream(entry);
String contents = StreamUtils.copyToString(entryInput, StandardCharsets.UTF_8);
assertThat(contents).isEqualTo("Entry " + (i + 1));
}
}
}
@Test
void nestedZip64JarCanBeRead() throws Exception {
File outer = new File(this.tempDir, "outer.jar");
try (JarOutputStream jarOutput = new JarOutputStream(new FileOutputStream(outer))) {
JarEntry nestedEntry = new JarEntry("nested-zip64.jar");
byte[] contents = zip64Jar();
nestedEntry.setSize(contents.length);
nestedEntry.setCompressedSize(contents.length);
CRC32 crc32 = new CRC32();
crc32.update(contents);
nestedEntry.setCrc(crc32.getValue());
nestedEntry.setMethod(ZipEntry.STORED);
jarOutput.putNextEntry(nestedEntry);
jarOutput.write(contents);
jarOutput.closeEntry();
}
try (JarFile outerJarFile = new JarFile(outer)) {
try (JarFile nestedZip64JarFile = outerJarFile
.getNestedJarFile(outerJarFile.getJarEntry("nested-zip64.jar"))) {
List<JarEntry> entries = Collections.list(nestedZip64JarFile.entries());
assertThat(entries).hasSize(65537);
for (int i = 0; i < entries.size(); i++) {
JarEntry entry = entries.get(i);
InputStream entryInput = nestedZip64JarFile.getInputStream(entry);
String contents = StreamUtils.copyToString(entryInput, StandardCharsets.UTF_8);
assertThat(contents).isEqualTo("Entry " + (i + 1));
}
}
}
}
private byte[] zip64Jar() throws IOException {
ByteArrayOutputStream bytes = new ByteArrayOutputStream();
JarOutputStream jarOutput = new JarOutputStream(bytes);
for (int i = 0; i < 65537; i++) {
jarOutput.putNextEntry(new JarEntry(i + ".dat"));
jarOutput.write(("Entry " + (i + 1)).getBytes(StandardCharsets.UTF_8));
jarOutput.closeEntry();
}
jarOutput.close();
return bytes.toByteArray();
}
private int getJavaVersion() {
try {
Object runtimeVersion = Runtime.class.getMethod("version").invoke(null);