Merge pull request #16091 from cvienot

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

Closes gh-16091

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

@@ -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"]

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

@@ -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 (this.zip64End != null) {
-		if (numberOfRecords == 0xFFFF) {
+			return this.zip64End.getNumberOfRecords();
-			throw new IllegalStateException("Zip64 archives are not supported");
 		}
+		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;
+		}
+
+	}
+
 }

spring-boot-project/spring-boot-tools/spring-boot-loader/src/test/java/org/springframework/boot/loader/archive/JarFileArchiveTests.java

@@ -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))
+		try (JarFileArchive zip64Archive = new JarFileArchive(file)) {
-				.withMessageContaining("Zip64 archives are not supported");
+			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 nestedArchive = jarFileArchive.getNestedArchive(getEntriesMap(jarFileArchive).get("nested/zip64.jar"));
-			Archive archive = jarFileArchive.getNestedArchive(getEntriesMap(jarFileArchive).get("nested/zip64.jar"));
+		Iterator<Entry> it = nestedArchive.iterator();
-			((JarFileArchive) archive).close();
+		for (int i = 0; i < 65537; i++) {
-		}).withMessageContaining("Failed to get nested archive for entry nested/zip64.jar");
+			assertThat(it.hasNext()).as(i + "nth file is present").isTrue();
-		jarFileArchive.close();
+			it.next();
+		}
 	}
 
 	private byte[] writeZip64Jar() throws IOException {

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

@@ -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);