| /* |
| * 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.apksig.apk; |
| |
| import com.android.apksig.internal.apk.AndroidBinXmlParser; |
| import com.android.apksig.internal.util.Pair; |
| import com.android.apksig.internal.zip.ZipUtils; |
| import com.android.apksig.util.DataSource; |
| import com.android.apksig.zip.ZipFormatException; |
| import java.io.IOException; |
| import java.nio.ByteBuffer; |
| import java.nio.ByteOrder; |
| import java.util.Arrays; |
| import java.util.Comparator; |
| |
| /** |
| * APK utilities. |
| */ |
| public abstract 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(); |
| 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); |
| } |
| |
| /** |
| * Name of the Android manifest ZIP entry in APKs. |
| */ |
| private static final String ANDROID_MANIFEST_ZIP_ENTRY_NAME = "AndroidManifest.xml"; |
| |
| /** |
| * Android resource ID of the {@code android:minSdkVersion} attribute in AndroidManifest.xml. |
| */ |
| private static final int MIN_SDK_VERSION_ATTR_ID = 0x0101020c; |
| |
| /** |
| * Returns the lowest Android platform version (API Level) supported by an APK with the |
| * provided {@code AndroidManifest.xml}. |
| * |
| * @param androidManifestContents contents of {@code AndroidManifest.xml} in binary Android |
| * resource format |
| * |
| * @throws MinSdkVersionException if an error occurred while determining the API Level |
| */ |
| public static int getMinSdkVersionFromBinaryAndroidManifest( |
| ByteBuffer androidManifestContents) throws MinSdkVersionException { |
| // IMPLEMENTATION NOTE: Minimum supported Android platform version number is declared using |
| // uses-sdk elements which are children of the top-level manifest element. uses-sdk element |
| // declares the minimum supported platform version using the android:minSdkVersion attribute |
| // whose default value is 1. |
| // For each encountered uses-sdk element, the Android runtime checks that its minSdkVersion |
| // is not higher than the runtime's API Level and rejects APKs if it is higher. Thus, the |
| // effective minSdkVersion value is the maximum over the encountered minSdkVersion values. |
| |
| try { |
| // If no uses-sdk elements are encountered, Android accepts the APK. We treat this |
| // scenario as though the minimum supported API Level is 1. |
| int result = 1; |
| |
| AndroidBinXmlParser parser = new AndroidBinXmlParser(androidManifestContents); |
| int eventType = parser.getEventType(); |
| while (eventType != AndroidBinXmlParser.EVENT_END_DOCUMENT) { |
| if ((eventType == AndroidBinXmlParser.EVENT_START_ELEMENT) |
| && (parser.getDepth() == 2) |
| && ("uses-sdk".equals(parser.getName())) |
| && (parser.getNamespace().isEmpty())) { |
| // In each uses-sdk element, minSdkVersion defaults to 1 |
| int minSdkVersion = 1; |
| for (int i = 0; i < parser.getAttributeCount(); i++) { |
| if (parser.getAttributeNameResourceId(i) == MIN_SDK_VERSION_ATTR_ID) { |
| int valueType = parser.getAttributeValueType(i); |
| switch (valueType) { |
| case AndroidBinXmlParser.VALUE_TYPE_INT: |
| minSdkVersion = parser.getAttributeIntValue(i); |
| break; |
| case AndroidBinXmlParser.VALUE_TYPE_STRING: |
| minSdkVersion = |
| getMinSdkVersionForCodename( |
| parser.getAttributeStringValue(i)); |
| break; |
| default: |
| throw new MinSdkVersionException( |
| "Unable to determine APK's minimum supported Android" |
| + ": unsupported value type in " |
| + ANDROID_MANIFEST_ZIP_ENTRY_NAME + "'s" |
| + " minSdkVersion" |
| + ". Only integer values supported."); |
| } |
| break; |
| } |
| } |
| result = Math.max(result, minSdkVersion); |
| } |
| eventType = parser.next(); |
| } |
| |
| return result; |
| } catch (AndroidBinXmlParser.XmlParserException e) { |
| throw new MinSdkVersionException( |
| "Unable to determine APK's minimum supported Android platform version" |
| + ": malformed binary resource: " + ANDROID_MANIFEST_ZIP_ENTRY_NAME, |
| e); |
| } |
| } |
| |
| private static class CodenamesLazyInitializer { |
| |
| /** |
| * List of platform codename (first letter of) to API Level mappings. The list must be |
| * sorted by the first letter. For codenames not in the list, the assumption is that the API |
| * Level is incremented by one for every increase in the codename's first letter. |
| */ |
| @SuppressWarnings("unchecked") |
| private static final Pair<Character, Integer>[] SORTED_CODENAMES_FIRST_CHAR_TO_API_LEVEL = |
| new Pair[] { |
| Pair.of('C', 2), |
| Pair.of('D', 3), |
| Pair.of('E', 4), |
| Pair.of('F', 7), |
| Pair.of('G', 8), |
| Pair.of('H', 10), |
| Pair.of('I', 13), |
| Pair.of('J', 15), |
| Pair.of('K', 18), |
| Pair.of('L', 20), |
| Pair.of('M', 22), |
| Pair.of('N', 23), |
| Pair.of('O', 25), |
| }; |
| |
| private static final Comparator<Pair<Character, Integer>> CODENAME_FIRST_CHAR_COMPARATOR = |
| new ByFirstComparator(); |
| |
| private static class ByFirstComparator implements Comparator<Pair<Character, Integer>> { |
| @Override |
| public int compare(Pair<Character, Integer> o1, Pair<Character, Integer> o2) { |
| char c1 = o1.getFirst(); |
| char c2 = o2.getFirst(); |
| return c1 - c2; |
| } |
| } |
| } |
| |
| /** |
| * Returns the API Level corresponding to the provided platform codename. |
| * |
| * <p>This method is pessimistic. It returns a value one lower than the API Level with which the |
| * platform is actually released (e.g., 23 for N which was released as API Level 24). This is |
| * because new features which first appear in an API Level are not available in the early days |
| * of that platform version's existence, when the platform only has a codename. Moreover, this |
| * method currently doesn't differentiate between initial and MR releases, meaning API Level |
| * returned for MR releases may be more than one lower than the API Level with which the |
| * platform version is actually released. |
| * |
| * @throws CodenameMinSdkVersionException if the {@code codename} is not supported |
| */ |
| static int getMinSdkVersionForCodename(String codename) throws CodenameMinSdkVersionException { |
| char firstChar = codename.isEmpty() ? ' ' : codename.charAt(0); |
| // Codenames are case-sensitive. Only codenames starting with A-Z are supported for now. |
| // We only look at the first letter of the codename as this is the most important letter. |
| if ((firstChar >= 'A') && (firstChar <= 'Z')) { |
| Pair<Character, Integer>[] sortedCodenamesFirstCharToApiLevel = |
| CodenamesLazyInitializer.SORTED_CODENAMES_FIRST_CHAR_TO_API_LEVEL; |
| int searchResult = |
| Arrays.binarySearch( |
| sortedCodenamesFirstCharToApiLevel, |
| Pair.of(firstChar, null), // second element of the pair is ignored here |
| CodenamesLazyInitializer.CODENAME_FIRST_CHAR_COMPARATOR); |
| if (searchResult >= 0) { |
| // Exact match -- searchResult is the index of the matching element |
| return sortedCodenamesFirstCharToApiLevel[searchResult].getSecond(); |
| } |
| // Not an exact match -- searchResult is negative and is -(insertion index) - 1. |
| // The element at insertionIndex - 1 (if present) is smaller than firstChar and the |
| // element at insertionIndex (if present) is greater than firstChar. |
| int insertionIndex = -1 - searchResult; // insertionIndex is in [0; array length] |
| if (insertionIndex == 0) { |
| // 'A' or 'B' -- never released to public |
| return 1; |
| } else { |
| // The element at insertionIndex - 1 is the newest older codename. |
| // API Level bumped by at least 1 for every change in the first letter of codename |
| Pair<Character, Integer> newestOlderCodenameMapping = |
| sortedCodenamesFirstCharToApiLevel[insertionIndex - 1]; |
| char newestOlderCodenameFirstChar = newestOlderCodenameMapping.getFirst(); |
| int newestOlderCodenameApiLevel = newestOlderCodenameMapping.getSecond(); |
| return newestOlderCodenameApiLevel + (firstChar - newestOlderCodenameFirstChar); |
| } |
| } |
| |
| throw new CodenameMinSdkVersionException( |
| "Unable to determine APK's minimum supported Android platform version" |
| + " : Unsupported codename in " + ANDROID_MANIFEST_ZIP_ENTRY_NAME |
| + "'s minSdkVersion: \"" + codename + "\"", |
| codename); |
| } |
| } |
