Support zip64 jars

See gh-16091

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

@@ -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,22 +118,137 @@ class CentralDirectoryEndRecord {
 	 * @return the central directory data
 	 */
 	RandomAccessData getCentralDirectory(RandomAccessData data) {
+		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);
 		}
+	}
 
 	/**
 	 * Return the number of ZIP entries in the file.
 	 * @return the number of records in the zip
 	 */
 	int getNumberOfRecords() {
-		long numberOfRecords = Bytes.littleEndianValue(this.block, this.offset + 10, 2);
+		if (isZip64()) {
-		if (numberOfRecords == 0xFFFF) {
+			return this.zip64End.get().getNumberOfRecords();
-			throw new IllegalStateException("Zip64 archives are not supported");
 		}
+		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 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() {
 		int commentLength = (int) Bytes.littleEndianValue(this.block, this.offset + COMMENT_LENGTH_OFFSET, 2);

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,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))
+		JarFileArchive zip64Archive = new JarFileArchive(file);
-				.withMessageContaining("Zip64 archives are not supported");
+		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 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 {