Java ApkFormatException类代码示例

import com.android.apksig.apk.ApkFormatException; //导入依赖的package包/类
/**
 * Returns the contents of the APK's {@code AndroidManifest.xml} or {@code null} if this entry
 * is not present in the APK.
 */
static ByteBuffer getAndroidManifestFromApk(
        List<CentralDirectoryRecord> cdRecords, DataSource lhfSection)
                throws IOException, ApkFormatException, ZipFormatException {
    CentralDirectoryRecord androidManifestCdRecord = null;
    for (CentralDirectoryRecord cdRecord : cdRecords) {
        if (ANDROID_MANIFEST_ZIP_ENTRY_NAME.equals(cdRecord.getName())) {
            androidManifestCdRecord = cdRecord;
            break;
        }
    }
    if (androidManifestCdRecord == null) {
        throw new ApkFormatException("Missing " + ANDROID_MANIFEST_ZIP_ENTRY_NAME);
    }

    return ByteBuffer.wrap(
            LocalFileRecord.getUncompressedData(
                    lhfSection, androidManifestCdRecord, lhfSection.size()));
}
 

import com.android.apksig.apk.ApkFormatException; //导入依赖的package包/类
/**
 * Verifies the APK's signatures and returns the result of verification. The APK can be
 * considered verified iff the result's {@link Result#isVerified()} returns {@code true}.
 * The verification result also includes errors, warnings, and information about signers.
 *
 * @throws IOException if an I/O error is encountered while reading the APK
 * @throws ApkFormatException if the APK is malformed
 * @throws NoSuchAlgorithmException if the APK's signatures cannot be verified because a
 *         required cryptographic algorithm implementation is missing
 * @throws IllegalStateException if this verifier's configuration is missing required
 *         information.
 */
public Result verify() throws IOException, ApkFormatException, NoSuchAlgorithmException,
        IllegalStateException {
    Closeable in = null;
    try {
        DataSource apk;
        if (mApkDataSource != null) {
            apk = mApkDataSource;
        } else if (mApkFile != null) {
            RandomAccessFile f = new RandomAccessFile(mApkFile, "r");
            in = f;
            apk = DataSources.asDataSource(f, 0, f.length());
        } else {
            throw new IllegalStateException("APK not provided");
        }
        return verify(apk);
    } finally {
        if (in != null) {
            in.close();
        }
    }
}
 

import com.android.apksig.apk.ApkFormatException; //导入依赖的package包/类
/**
 * Signs the provided APK using JAR signing (aka v1 signature scheme) and returns the list of
 * JAR entries which need to be added to the APK as part of the signature.
 *
 * @param signerConfigs signer configurations, one for each signer. At least one signer config
 *        must be provided.
 *
 * @throws ApkFormatException if the source manifest is malformed
 * @throws NoSuchAlgorithmException if a required cryptographic algorithm implementation is
 *         missing
 * @throws InvalidKeyException if a signing key is not suitable for this signature scheme or
 *         cannot be used in general
 * @throws SignatureException if an error occurs when computing digests of generating
 *         signatures
 */
public static List<Pair<String, byte[]>> sign(
        List<SignerConfig> signerConfigs,
        DigestAlgorithm jarEntryDigestAlgorithm,
        Map<String, byte[]> jarEntryDigests,
        List<Integer> apkSigningSchemeIds,
        byte[] sourceManifestBytes,
        String createdBy)
                throws NoSuchAlgorithmException, ApkFormatException, InvalidKeyException,
                        CertificateException, SignatureException {
    if (signerConfigs.isEmpty()) {
        throw new IllegalArgumentException("At least one signer config must be provided");
    }
    OutputManifestFile manifest =
            generateManifestFile(
                    jarEntryDigestAlgorithm, jarEntryDigests, sourceManifestBytes);

    return signManifest(
            signerConfigs, jarEntryDigestAlgorithm, apkSigningSchemeIds, createdBy, manifest);
}
 

import com.android.apksig.apk.ApkFormatException; //导入依赖的package包/类
/**
 * Verifies the provided APK's APK Signature Scheme v2 signatures and returns the result of
 * verification. APK is considered verified only if {@link Result#verified} is {@code true}. If
 * verification fails, the result will contain errors -- see {@link Result#getErrors()}.
 *
 * @throws ApkFormatException if the APK is malformed
 * @throws NoSuchAlgorithmException if the APK's signatures cannot be verified because a
 *         required cryptographic algorithm implementation is missing
 * @throws SignatureNotFoundException if no APK Signature Scheme v2 signatures are found
 * @throws IOException if an I/O error occurs when reading the APK
 */
public static Result verify(DataSource apk, ApkUtils.ZipSections zipSections)
        throws IOException, ApkFormatException, NoSuchAlgorithmException,
                SignatureNotFoundException {
    Result result = new Result();
    SignatureInfo signatureInfo = findSignature(apk, zipSections, result);

    DataSource beforeApkSigningBlock = apk.slice(0, signatureInfo.apkSigningBlockOffset);
    DataSource centralDir =
            apk.slice(
                    signatureInfo.centralDirOffset,
                    signatureInfo.eocdOffset - signatureInfo.centralDirOffset);
    ByteBuffer eocd = signatureInfo.eocd;

    verify(beforeApkSigningBlock,
            signatureInfo.signatureBlock,
            centralDir,
            eocd,
            result);
    return result;
}
 

import com.android.apksig.apk.ApkFormatException; //导入依赖的package包/类
private static ByteBuffer getLengthPrefixedSlice(ByteBuffer source) throws ApkFormatException {
    if (source.remaining() < 4) {
        throw new ApkFormatException(
                "Remaining buffer too short to contain length of length-prefixed field"
                        + ". Remaining: " + source.remaining());
    }
    int len = source.getInt();
    if (len < 0) {
        throw new IllegalArgumentException("Negative length");
    } else if (len > source.remaining()) {
        throw new ApkFormatException(
                "Length-prefixed field longer than remaining buffer"
                        + ". Field length: " + len + ", remaining: " + source.remaining());
    }
    return getByteBuffer(source, len);
}
 

import com.android.apksig.apk.ApkFormatException; //导入依赖的package包/类
public static int checkSignatureVersion(File apkFile) throws ApkFormatException, NoSuchAlgorithmException, IOException {
    int version = 0;
    ApkVerifier.Result result = new ApkVerifier.Builder(apkFile)
            .setMinCheckedPlatformVersion(1)
            .setMaxCheckedPlatformVersion(Integer.MAX_VALUE)
            .build()
            .verify();
    if (result.isVerified()) {
        if (result.isVerifiedUsingV2Scheme()) {
            version = 2;
        } else if (result.isVerifiedUsingV1Scheme()){
            version = 1;
        }
    }
    return version;
}
 

import com.android.apksig.apk.ApkFormatException; //导入依赖的package包/类
private static void fulfillInspectInputJarEntryRequest(
        DataSource lfhSection,
        LocalFileRecord localFileRecord,
        ApkSignerEngine.InspectJarEntryRequest inspectEntryRequest)
                throws IOException, ApkFormatException {
    try {
        localFileRecord.outputUncompressedData(lfhSection, inspectEntryRequest.getDataSink());
    } catch (ZipFormatException e) {
        throw new ApkFormatException("Malformed ZIP entry: " + localFileRecord.getName(), e);
    }
    inspectEntryRequest.done();
}
 

import com.android.apksig.apk.ApkFormatException; //导入依赖的package包/类
private static ByteBuffer getZipCentralDirectory(
        DataSource apk,
        ApkUtils.ZipSections apkSections) throws IOException, ApkFormatException {
    long cdSizeBytes = apkSections.getZipCentralDirectorySizeBytes();
    if (cdSizeBytes > Integer.MAX_VALUE) {
        throw new ApkFormatException("ZIP Central Directory too large: " + cdSizeBytes);
    }
    long cdOffset = apkSections.getZipCentralDirectoryOffset();
    ByteBuffer cd = apk.getByteBuffer(cdOffset, (int) cdSizeBytes);
    cd.order(ByteOrder.LITTLE_ENDIAN);
    return cd;
}
 

import com.android.apksig.apk.ApkFormatException; //导入依赖的package包/类
private static List<CentralDirectoryRecord> parseZipCentralDirectory(
        ByteBuffer cd,
        ApkUtils.ZipSections apkSections) throws ApkFormatException {
    long cdOffset = apkSections.getZipCentralDirectoryOffset();
    int expectedCdRecordCount = apkSections.getZipCentralDirectoryRecordCount();
    List<CentralDirectoryRecord> cdRecords = new ArrayList<>(expectedCdRecordCount);
    Set<String> entryNames = new HashSet<>(expectedCdRecordCount);
    for (int i = 0; i < expectedCdRecordCount; i++) {
        CentralDirectoryRecord cdRecord;
        int offsetInsideCd = cd.position();
        try {
            cdRecord = CentralDirectoryRecord.getRecord(cd);
        } catch (ZipFormatException e) {
            throw new ApkFormatException(
                    "Malformed ZIP Central Directory record #" + (i + 1)
                            + " at file offset " + (cdOffset + offsetInsideCd),
                    e);
        }
        String entryName = cdRecord.getName();
        if (!entryNames.add(entryName)) {
            throw new ApkFormatException(
                    "Multiple ZIP entries with the same name: " + entryName);
        }
        cdRecords.add(cdRecord);
    }
    if (cd.hasRemaining()) {
        throw new ApkFormatException(
                "Unused space at the end of ZIP Central Directory: " + cd.remaining()
                        + " bytes starting at file offset " + (cdOffset + cd.position()));
    }

    return cdRecords;
}
 

import com.android.apksig.apk.ApkFormatException; //导入依赖的package包/类
/**
 * Returns the minimum Android version (API Level) supported by the provided APK. This is based
 * on the {@code android:minSdkVersion} attributes of the APK's {@code AndroidManifest.xml}.
 */
private static int getMinSdkVersionFromApk(
        List<CentralDirectoryRecord> cdRecords, DataSource lhfSection)
                throws IOException, MinSdkVersionException {
    ByteBuffer androidManifest;
    try {
        androidManifest = getAndroidManifestFromApk(cdRecords, lhfSection);
    } catch (ZipFormatException | ApkFormatException e) {
        throw new MinSdkVersionException(
                "Failed to determine APK's minimum supported Android platform version",
                e);
    }
    return ApkUtils.getMinSdkVersionFromBinaryAndroidManifest(androidManifest);
}
 

import com.android.apksig.apk.ApkFormatException; //导入依赖的package包/类
private static ByteBuffer getAndroidManifestFromApk(
        DataSource apk, ApkUtils.ZipSections zipSections)
                throws IOException, ApkFormatException {
    List<CentralDirectoryRecord> cdRecords =
            V1SchemeVerifier.parseZipCentralDirectory(apk, zipSections);
    try {
        return ApkSigner.getAndroidManifestFromApk(
                cdRecords,
                apk.slice(0, zipSections.getZipCentralDirectoryOffset()));
    } catch (ZipFormatException e) {
        throw new ApkFormatException("Failed to read AndroidManifest.xml", e);
    }
}
 

import com.android.apksig.apk.ApkFormatException; //导入依赖的package包/类
/**
 * Verifies the provided APK's JAR signatures and returns the result of verification. APK is
 * considered verified only if {@link Result#verified} is {@code true}. If verification fails,
 * the result will contain errors -- see {@link Result#getErrors()}.
 *
 * @throws ApkFormatException if the APK is malformed
 * @throws IOException if an I/O error occurs when reading the APK
 * @throws NoSuchAlgorithmException if the APK's JAR signatures cannot be verified because a
 *         required cryptographic algorithm implementation is missing
 */
public static Result verify(
        DataSource apk,
        ApkUtils.ZipSections apkSections,
        Map<Integer, String> supportedApkSigSchemeNames,
        Set<Integer> foundApkSigSchemeIds,
        int minSdkVersion,
        int maxSdkVersion) throws IOException, ApkFormatException, NoSuchAlgorithmException {
    if (minSdkVersion > maxSdkVersion) {
        throw new IllegalArgumentException(
                "minSdkVersion (" + minSdkVersion + ") > maxSdkVersion (" + maxSdkVersion
                        + ")");
    }

    Result result = new Result();

    // Parse the ZIP Central Directory and check that there are no entries with duplicate names.
    List<CentralDirectoryRecord> cdRecords = parseZipCentralDirectory(apk, apkSections);
    Set<String> cdEntryNames = checkForDuplicateEntries(cdRecords, result);
    if (result.containsErrors()) {
        return result;
    }

    // Verify JAR signature(s).
    Signers.verify(
            apk,
            apkSections.getZipCentralDirectoryOffset(),
            cdRecords,
            cdEntryNames,
            supportedApkSigSchemeNames,
            foundApkSigSchemeIds,
            minSdkVersion,
            maxSdkVersion,
            result);

    return result;
}
 

import com.android.apksig.apk.ApkFormatException; //导入依赖的package包/类
public static List<CentralDirectoryRecord> parseZipCentralDirectory(
        DataSource apk,
        ApkUtils.ZipSections apkSections)
                throws IOException, ApkFormatException {
    // Read the ZIP Central Directory
    long cdSizeBytes = apkSections.getZipCentralDirectorySizeBytes();
    if (cdSizeBytes > Integer.MAX_VALUE) {
        throw new ApkFormatException("ZIP Central Directory too large: " + cdSizeBytes);
    }
    long cdOffset = apkSections.getZipCentralDirectoryOffset();
    ByteBuffer cd = apk.getByteBuffer(cdOffset, (int) cdSizeBytes);
    cd.order(ByteOrder.LITTLE_ENDIAN);

    // Parse the ZIP Central Directory
    int expectedCdRecordCount = apkSections.getZipCentralDirectoryRecordCount();
    List<CentralDirectoryRecord> cdRecords = new ArrayList<>(expectedCdRecordCount);
    for (int i = 0; i < expectedCdRecordCount; i++) {
        CentralDirectoryRecord cdRecord;
        int offsetInsideCd = cd.position();
        try {
            cdRecord = CentralDirectoryRecord.getRecord(cd);
        } catch (ZipFormatException e) {
            throw new ApkFormatException(
                    "Malformed ZIP Central Directory record #" + (i + 1)
                            + " at file offset " + (cdOffset + offsetInsideCd),
                    e);
        }
        String entryName = cdRecord.getName();
        if (entryName.endsWith("/")) {
            // Ignore directory entries
            continue;
        }
        cdRecords.add(cdRecord);
    }
    // There may be more data in Central Directory, but we don't warn or throw because Android
    // ignores unused CD data.

    return cdRecords;
}
 

import com.android.apksig.apk.ApkFormatException; //导入依赖的package包/类
private static void checkEntryNameValid(String name) throws ApkFormatException {
    // JAR signing spec says CR, LF, and NUL are not permitted in entry names
    // CR or LF in entry names will result in malformed MANIFEST.MF and .SF files because there
    // is no way to escape characters in MANIFEST.MF and .SF files. NUL can, presumably, cause
    // issues when parsing using C and C++ like languages.
    for (char c : name.toCharArray()) {
        if ((c == '\r') || (c == '\n') || (c == 0)) {
            throw new ApkFormatException(
                    String.format(
                            "Unsupported character 0x%1$02x in ZIP entry name \"%2$s\"",
                            (int) c,
                            name));
        }
    }
}
 

import com.android.apksig.apk.ApkFormatException; //导入依赖的package包/类
private static byte[] readLengthPrefixedByteArray(ByteBuffer buf) throws ApkFormatException {
    int len = buf.getInt();
    if (len < 0) {
        throw new ApkFormatException("Negative length");
    } else if (len > buf.remaining()) {
        throw new ApkFormatException(
                "Underflow while reading length-prefixed value. Length: " + len
                        + ", available: " + buf.remaining());
    }
    byte[] result = new byte[len];
    buf.get(result);
    return result;
}