Switch signapk to apksigner-core. (fa1da6c3) · Commits · e / os / android_build

tools/apksigner/core/src/com/android/apksigner/core/apk/ApkUtils.java

0 → 100644

+158 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2016 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		package com.android.apksigner.core.apk;

		import com.android.apksigner.core.internal.util.Pair;
		import com.android.apksigner.core.internal.zip.ZipUtils;
		import com.android.apksigner.core.util.DataSource;
		import com.android.apksigner.core.zip.ZipFormatException;

		import java.io.IOException;
		import java.nio.ByteBuffer;
		import java.nio.ByteOrder;

		/**
		* APK utilities.
		*/
		public class ApkUtils {

		private ApkUtils() {}

		/**
		* Finds the main ZIP sections of the provided APK.
		*
		* @throws IOException if an I/O error occurred while reading the APK
		* @throws ZipFormatException if the APK is malformed
		*/
		public static ZipSections findZipSections(DataSource apk)
		throws IOException, ZipFormatException {
		Pair<ByteBuffer, Long> eocdAndOffsetInFile =
		ZipUtils.findZipEndOfCentralDirectoryRecord(apk);
		if (eocdAndOffsetInFile == null) {
		throw new ZipFormatException("ZIP End of Central Directory record not found");
		}

		ByteBuffer eocdBuf = eocdAndOffsetInFile.getFirst();
		long eocdOffset = eocdAndOffsetInFile.getSecond();
		if (ZipUtils.isZip64EndOfCentralDirectoryLocatorPresent(apk, eocdOffset)) {
		throw new ZipFormatException("ZIP64 APK not supported");
		}
		eocdBuf.order(ByteOrder.LITTLE_ENDIAN);
		long cdStartOffset = ZipUtils.getZipEocdCentralDirectoryOffset(eocdBuf);
		if (cdStartOffset >= eocdOffset) {
		throw new ZipFormatException(
		"ZIP Central Directory start offset out of range: " + cdStartOffset
		+ ". ZIP End of Central Directory offset: " + eocdOffset);
		}

		long cdSizeBytes = ZipUtils.getZipEocdCentralDirectorySizeBytes(eocdBuf);
		long cdEndOffset = cdStartOffset + cdSizeBytes;
		if (cdEndOffset > eocdOffset) {
		throw new ZipFormatException(
		"ZIP Central Directory overlaps with End of Central Directory"
		+ ". CD end: " + cdEndOffset
		+ ", EoCD start: " + eocdOffset);
		}

		int cdRecordCount = ZipUtils.getZipEocdCentralDirectoryTotalRecordCount(eocdBuf);

		return new ZipSections(
		cdStartOffset,
		cdSizeBytes,
		cdRecordCount,
		eocdOffset,
		eocdBuf);
		}

		/**
		* Information about the ZIP sections of an APK.
		*/
		public static class ZipSections {
		private final long mCentralDirectoryOffset;
		private final long mCentralDirectorySizeBytes;
		private final int mCentralDirectoryRecordCount;
		private final long mEocdOffset;
		private final ByteBuffer mEocd;

		public ZipSections(
		long centralDirectoryOffset,
		long centralDirectorySizeBytes,
		int centralDirectoryRecordCount,
		long eocdOffset,
		ByteBuffer eocd) {
		mCentralDirectoryOffset = centralDirectoryOffset;
		mCentralDirectorySizeBytes = centralDirectorySizeBytes;
		mCentralDirectoryRecordCount = centralDirectoryRecordCount;
		mEocdOffset = eocdOffset;
		mEocd = eocd;
		}

		/**
		* Returns the start offset of the ZIP Central Directory. This value is taken from the
		* ZIP End of Central Directory record.
		*/
		public long getZipCentralDirectoryOffset() {
		return mCentralDirectoryOffset;
		}

		/**
		* Returns the size (in bytes) of the ZIP Central Directory. This value is taken from the
		* ZIP End of Central Directory record.
		*/
		public long getZipCentralDirectorySizeBytes() {
		return mCentralDirectorySizeBytes;
		}

		/**
		* Returns the number of records in the ZIP Central Directory. This value is taken from the
		* ZIP End of Central Directory record.
		*/
		public int getZipCentralDirectoryRecordCount() {
		return mCentralDirectoryRecordCount;
		}

		/**
		* Returns the start offset of the ZIP End of Central Directory record. The record extends
		* until the very end of the APK.
		*/
		public long getZipEndOfCentralDirectoryOffset() {
		return mEocdOffset;
		}

		/**
		* Returns the contents of the ZIP End of Central Directory.
		*/
		public ByteBuffer getZipEndOfCentralDirectory() {
		return mEocd;
		}
		}

		/**
		* Sets the offset of the start of the ZIP Central Directory in the APK's ZIP End of Central
		* Directory record.
		*
		* @param zipEndOfCentralDirectory APK's ZIP End of Central Directory record
		* @param offset offset of the ZIP Central Directory relative to the start of the archive. Must
		* be between {@code 0} and {@code 2^32 - 1} inclusive.
		*/
		public static void setZipEocdCentralDirectoryOffset(
		ByteBuffer zipEndOfCentralDirectory, long offset) {
		ByteBuffer eocd = zipEndOfCentralDirectory.slice();
		eocd.order(ByteOrder.LITTLE_ENDIAN);
		ZipUtils.setZipEocdCentralDirectoryOffset(eocd, offset);
		}
		}

tools/apksigner/core/src/com/android/apksigner/core/internal/zip/ZipUtils.java

+224 −1

Original line number	Diff line number	Diff line
		@@ -16,9 +16,14 @@

		package com.android.apksigner.core.internal.zip;

		import java.io.IOException;
		import java.nio.ByteBuffer;
		import java.nio.ByteOrder;

		import com.android.apksigner.core.internal.util.ByteBufferSink;
		import com.android.apksigner.core.internal.util.Pair;
		import com.android.apksigner.core.util.DataSource;

		/**
		* Assorted ZIP format helpers.
		*
		@@ -28,7 +33,20 @@ import java.nio.ByteOrder;
		public abstract class ZipUtils {
		private ZipUtils() {}

		public static final short COMPRESSION_METHOD_STORED = 0;
		public static final short COMPRESSION_METHOD_DEFLATED = 8;

		private static final int ZIP_EOCD_REC_MIN_SIZE = 22;
		private static final int ZIP_EOCD_REC_SIG = 0x06054b50;
		private static final int ZIP_EOCD_CENTRAL_DIR_TOTAL_RECORD_COUNT_OFFSET = 10;
		private static final int ZIP_EOCD_CENTRAL_DIR_SIZE_FIELD_OFFSET = 12;
		private static final int ZIP_EOCD_CENTRAL_DIR_OFFSET_FIELD_OFFSET = 16;
		private static final int ZIP_EOCD_COMMENT_LENGTH_FIELD_OFFSET = 20;

		private static final int ZIP64_EOCD_LOCATOR_SIZE = 20;
		private static final int ZIP64_EOCD_LOCATOR_SIG = 0x07064b50;

		private static final int UINT16_MAX_VALUE = 0xffff;

		/**
		* Sets the offset of the start of the ZIP Central Directory in the archive.
		@@ -44,16 +62,221 @@ public abstract class ZipUtils {
		offset);
		}

		/**
		* Returns the offset of the start of the ZIP Central Directory in the archive.
		*
		* <p>NOTE: Byte order of {@code zipEndOfCentralDirectory} must be little-endian.
		*/
		public static long getZipEocdCentralDirectoryOffset(ByteBuffer zipEndOfCentralDirectory) {
		assertByteOrderLittleEndian(zipEndOfCentralDirectory);
		return getUnsignedInt32(
		zipEndOfCentralDirectory,
		zipEndOfCentralDirectory.position() + ZIP_EOCD_CENTRAL_DIR_OFFSET_FIELD_OFFSET);
		}

		/**
		* Returns the size (in bytes) of the ZIP Central Directory.
		*
		* <p>NOTE: Byte order of {@code zipEndOfCentralDirectory} must be little-endian.
		*/
		public static long getZipEocdCentralDirectorySizeBytes(ByteBuffer zipEndOfCentralDirectory) {
		assertByteOrderLittleEndian(zipEndOfCentralDirectory);
		return getUnsignedInt32(
		zipEndOfCentralDirectory,
		zipEndOfCentralDirectory.position() + ZIP_EOCD_CENTRAL_DIR_SIZE_FIELD_OFFSET);
		}

		/**
		* Returns the total number of records in ZIP Central Directory.
		*
		* <p>NOTE: Byte order of {@code zipEndOfCentralDirectory} must be little-endian.
		*/
		public static int getZipEocdCentralDirectoryTotalRecordCount(
		ByteBuffer zipEndOfCentralDirectory) {
		assertByteOrderLittleEndian(zipEndOfCentralDirectory);
		return getUnsignedInt16(
		zipEndOfCentralDirectory,
		zipEndOfCentralDirectory.position()
		+ ZIP_EOCD_CENTRAL_DIR_TOTAL_RECORD_COUNT_OFFSET);
		}

		/**
		* Returns the ZIP End of Central Directory record of the provided ZIP file.
		*
		* @return contents of the ZIP End of Central Directory record and the record's offset in the
		* file or {@code null} if the file does not contain the record.
		*
		* @throws IOException if an I/O error occurs while reading the file.
		*/
		public static Pair<ByteBuffer, Long> findZipEndOfCentralDirectoryRecord(DataSource zip)
		throws IOException {
		// ZIP End of Central Directory (EOCD) record is located at the very end of the ZIP archive.
		// The record can be identified by its 4-byte signature/magic which is located at the very
		// beginning of the record. A complication is that the record is variable-length because of
		// the comment field.
		// The algorithm for locating the ZIP EOCD record is as follows. We search backwards from
		// end of the buffer for the EOCD record signature. Whenever we find a signature, we check
		// the candidate record's comment length is such that the remainder of the record takes up
		// exactly the remaining bytes in the buffer. The search is bounded because the maximum
		// size of the comment field is 65535 bytes because the field is an unsigned 16-bit number.

		long fileSize = zip.size();
		if (fileSize < ZIP_EOCD_REC_MIN_SIZE) {
		return null;
		}

		// Optimization: 99.99% of APKs have a zero-length comment field in the EoCD record and thus
		// the EoCD record offset is known in advance. Try that offset first to avoid unnecessarily
		// reading more data.
		Pair<ByteBuffer, Long> result = findZipEndOfCentralDirectoryRecord(zip, 0);
		if (result != null) {
		return result;
		}

		// EoCD does not start where we expected it to. Perhaps it contains a non-empty comment
		// field. Expand the search. The maximum size of the comment field in EoCD is 65535 because
		// the comment length field is an unsigned 16-bit number.
		return findZipEndOfCentralDirectoryRecord(zip, UINT16_MAX_VALUE);
		}

		/**
		* Returns the ZIP End of Central Directory record of the provided ZIP file.
		*
		* @param maxCommentSize maximum accepted size (in bytes) of EoCD comment field. The permitted
		* value is from 0 to 65535 inclusive. The smaller the value, the faster this method
		* locates the record, provided its comment field is no longer than this value.
		*
		* @return contents of the ZIP End of Central Directory record and the record's offset in the
		* file or {@code null} if the file does not contain the record.
		*
		* @throws IOException if an I/O error occurs while reading the file.
		*/
		private static Pair<ByteBuffer, Long> findZipEndOfCentralDirectoryRecord(
		DataSource zip, int maxCommentSize) throws IOException {
		// ZIP End of Central Directory (EOCD) record is located at the very end of the ZIP archive.
		// The record can be identified by its 4-byte signature/magic which is located at the very
		// beginning of the record. A complication is that the record is variable-length because of
		// the comment field.
		// The algorithm for locating the ZIP EOCD record is as follows. We search backwards from
		// end of the buffer for the EOCD record signature. Whenever we find a signature, we check
		// the candidate record's comment length is such that the remainder of the record takes up
		// exactly the remaining bytes in the buffer. The search is bounded because the maximum
		// size of the comment field is 65535 bytes because the field is an unsigned 16-bit number.

		if ((maxCommentSize < 0) \|\| (maxCommentSize > UINT16_MAX_VALUE)) {
		throw new IllegalArgumentException("maxCommentSize: " + maxCommentSize);
		}

		long fileSize = zip.size();
		if (fileSize < ZIP_EOCD_REC_MIN_SIZE) {
		// No space for EoCD record in the file.
		return null;
		}
		// Lower maxCommentSize if the file is too small.
		maxCommentSize = (int) Math.min(maxCommentSize, fileSize - ZIP_EOCD_REC_MIN_SIZE);

		ByteBuffer buf = ByteBuffer.allocate(ZIP_EOCD_REC_MIN_SIZE + maxCommentSize);
		buf.order(ByteOrder.LITTLE_ENDIAN);
		long bufOffsetInFile = fileSize - buf.capacity();
		zip.feed(bufOffsetInFile, buf.remaining(), new ByteBufferSink(buf));
		buf.flip();
		int eocdOffsetInBuf = findZipEndOfCentralDirectoryRecord(buf);
		if (eocdOffsetInBuf == -1) {
		// No EoCD record found in the buffer
		return null;
		}
		// EoCD found
		buf.position(eocdOffsetInBuf);
		ByteBuffer eocd = buf.slice();
		eocd.order(ByteOrder.LITTLE_ENDIAN);
		return Pair.of(eocd, bufOffsetInFile + eocdOffsetInBuf);
		}

		/**
		* Returns the position at which ZIP End of Central Directory record starts in the provided
		* buffer or {@code -1} if the record is not present.
		*
		* <p>NOTE: Byte order of {@code zipContents} must be little-endian.
		*/
		private static int findZipEndOfCentralDirectoryRecord(ByteBuffer zipContents) {
		assertByteOrderLittleEndian(zipContents);

		// ZIP End of Central Directory (EOCD) record is located at the very end of the ZIP archive.
		// The record can be identified by its 4-byte signature/magic which is located at the very
		// beginning of the record. A complication is that the record is variable-length because of
		// the comment field.
		// The algorithm for locating the ZIP EOCD record is as follows. We search backwards from
		// end of the buffer for the EOCD record signature. Whenever we find a signature, we check
		// the candidate record's comment length is such that the remainder of the record takes up
		// exactly the remaining bytes in the buffer. The search is bounded because the maximum
		// size of the comment field is 65535 bytes because the field is an unsigned 16-bit number.

		int archiveSize = zipContents.capacity();
		if (archiveSize < ZIP_EOCD_REC_MIN_SIZE) {
		return -1;
		}
		int maxCommentLength = Math.min(archiveSize - ZIP_EOCD_REC_MIN_SIZE, UINT16_MAX_VALUE);
		int eocdWithEmptyCommentStartPosition = archiveSize - ZIP_EOCD_REC_MIN_SIZE;
		for (int expectedCommentLength = 0; expectedCommentLength < maxCommentLength;
		expectedCommentLength++) {
		int eocdStartPos = eocdWithEmptyCommentStartPosition - expectedCommentLength;
		if (zipContents.getInt(eocdStartPos) == ZIP_EOCD_REC_SIG) {
		int actualCommentLength =
		getUnsignedInt16(
		zipContents, eocdStartPos + ZIP_EOCD_COMMENT_LENGTH_FIELD_OFFSET);
		if (actualCommentLength == expectedCommentLength) {
		return eocdStartPos;
		}
		}
		}

		return -1;
		}

		/**
		* Returns {@code true} if the provided file contains a ZIP64 End of Central Directory
		* Locator.
		*
		* @param zipEndOfCentralDirectoryPosition offset of the ZIP End of Central Directory record
		* in the file.
		*
		* @throws IOException if an I/O error occurs while reading the data source
		*/
		public static final boolean isZip64EndOfCentralDirectoryLocatorPresent(
		DataSource zip, long zipEndOfCentralDirectoryPosition) throws IOException {

		// ZIP64 End of Central Directory Locator immediately precedes the ZIP End of Central
		// Directory Record.
		long locatorPosition = zipEndOfCentralDirectoryPosition - ZIP64_EOCD_LOCATOR_SIZE;
		if (locatorPosition < 0) {
		return false;
		}

		ByteBuffer sig = ByteBuffer.allocate(4);
		sig.order(ByteOrder.LITTLE_ENDIAN);
		zip.feed(locatorPosition, sig.remaining(), new ByteBufferSink(sig));
		sig.flip();
		return sig.getInt(0) == ZIP64_EOCD_LOCATOR_SIG;
		}

		private static void assertByteOrderLittleEndian(ByteBuffer buffer) {
		if (buffer.order() != ByteOrder.LITTLE_ENDIAN) {
		throw new IllegalArgumentException("ByteBuffer byte order must be little endian");
		}
		}

		private static int getUnsignedInt16(ByteBuffer buffer, int offset) {
		return buffer.getShort(offset) & 0xffff;
		}

		private static void setUnsignedInt32(ByteBuffer buffer, int offset, long value) {
		if ((value < 0) \|\| (value > 0xffffffffL)) {
		throw new IllegalArgumentException("uint32 value of out range: " + value);
		}
		buffer.putInt(buffer.position() + offset, (int) value);
		buffer.putInt(offset, (int) value);
		}

		private static long getUnsignedInt32(ByteBuffer buffer, int offset) {
		return buffer.getInt(offset) & 0xffffffffL;
		}
		}
		No newline at end of file

tools/signapk/src/com/android/signapk/Pair.java→tools/apksigner/core/src/com/android/apksigner/core/zip/ZipFormatException.java

+32 −0

Original line number	Diff line number	Diff line
		@@ -14,68 +14,19 @@
		* limitations under the License.
		*/

		package com.android.signapk;
		package com.android.apksigner.core.zip;

		/**
		* Pair of two elements.
		* Indicates that a ZIP archive is not well-formed.
		*/
		public final class Pair<A, B> {
		private final A mFirst;
		private final B mSecond;
		public class ZipFormatException extends Exception {
		private static final long serialVersionUID = 1L;

		private Pair(A first, B second) {
		mFirst = first;
		mSecond = second;
		public ZipFormatException(String message) {
		super(message);
		}

		public static <A, B> Pair<A, B> create(A first, B second) {
		return new Pair<A, B>(first, second);
		}

		public A getFirst() {
		return mFirst;
		}

		public B getSecond() {
		return mSecond;
		}

		@Override
		public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((mFirst == null) ? 0 : mFirst.hashCode());
		result = prime * result + ((mSecond == null) ? 0 : mSecond.hashCode());
		return result;
		}

		@Override
		public boolean equals(Object obj) {
		if (this == obj) {
		return true;
		}
		if (obj == null) {
		return false;
		}
		if (getClass() != obj.getClass()) {
		return false;
		}
		@SuppressWarnings("rawtypes")
		Pair other = (Pair) obj;
		if (mFirst == null) {
		if (other.mFirst != null) {
		return false;
		}
		} else if (!mFirst.equals(other.mFirst)) {
		return false;
		}
		if (mSecond == null) {
		if (other.mSecond != null) {
		return false;
		}
		} else if (!mSecond.equals(other.mSecond)) {
		return false;
		}
		return true;
		public ZipFormatException(String message, Throwable cause) {
		super(message, cause);
		}
		}

tools/signapk/Android.mk

+5 −1

Original line number	Diff line number	Diff line
		@@ -21,7 +21,11 @@ include $(CLEAR_VARS)
		LOCAL_MODULE := signapk
		LOCAL_SRC_FILES := $(call all-java-files-under, src)
		LOCAL_JAR_MANIFEST := SignApk.mf
		LOCAL_STATIC_JAVA_LIBRARIES := bouncycastle-host bouncycastle-bcpkix-host conscrypt-host
		LOCAL_STATIC_JAVA_LIBRARIES := \
		apksigner-core \
		bouncycastle-host \
		bouncycastle-bcpkix-host \
		conscrypt-host
		LOCAL_REQUIRED_MODULES := libconscrypt_openjdk_jni
		include $(BUILD_HOST_JAVA_LIBRARY)

tools/signapk/src/com/android/signapk/ApkSignerV2.java

deleted100644 → 0

+0 −725

File deleted.

Preview size limit exceeded, changes collapsed.