安卓PMS模块之APK签名及验证流程(2)

private static void collectCertificates(Package pkg, File apkFile, int parseFlags)
        throws PackageParserException {
    final String apkPath = apkFile.getAbsolutePath();
    boolean verified = false;//V2签名验证标记位
    {
        Certificate[][] allSignersCerts = null;
        Signature[] signatures = null;
        try {
            Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "verifyV2");
            //第一步：V2签名验证
            allSignersCerts = ApkSignatureSchemeV2Verifier.verify(apkPath);
            signatures = convertToSignatures(allSignersCerts);
            // APK verified using APK Signature Scheme v2.
            verified = true;
        } catch (ApkSignatureSchemeV2Verifier.SignatureNotFoundException e) {
          ...
                Trace.traceEnd(TRACE_TAG_PACKAGE_MANAGER);
        }
        // 如果V2签名验证通过  
        if (verified) {
            if (pkg.mCertificates == null) {
                pkg.mCertificates = allSignersCerts;
                pkg.mSignatures = signatures;
                pkg.mSigningKeys = new ArraySet<>(allSignersCerts.length);
                for (int i = 0; i < allSignersCerts.length; i++) {
                    Certificate[] signerCerts = allSignersCerts[i];
                    Certificate signerCert = signerCerts[0];
                    pkg.mSigningKeys.add(signerCert.getPublicKey());
                }
            }
        }

        int objectNumber = verified ? 1 : NUMBER_OF_CORES;
        StrictJarFile[] jarFile = new StrictJarFile[objectNumber];
        final ArrayMap<String, StrictJarFile> strictJarFiles = new ArrayMap<String, StrictJarFile>();
        try {
            // 第二步：进行.SF和.RSA文件的验证工作
            Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "strictJarFileCtor");
            ...
            for (int i = 0; i < objectNumber; i++) {
                //这里做了.SF和.RSA的验证工作
                jarFile[i] = new StrictJarFile(
                        apkPath,
                        !verified, // whether to verify JAR signature
                        signatureSchemeRollbackProtectionsEnforced);
            }
            Trace.traceEnd(TRACE_TAG_PACKAGE_MANAGER);

            // Always verify manifest, regardless of source
            // 第三步：验证AndroidManifest.xml是否存在，不存在抛出异常
            final ZipEntry manifestEntry = jarFile[0].findEntry(ANDROID_MANIFEST_FILENAME);
            if (manifestEntry == null) {
                throw new PackageParserException(INSTALL_PARSE_FAILED_BAD_MANIFEST,
                        "Package " + apkPath + " has no manifest");
            }

            // Optimization: early termination when APK already verified
            // 第四步 ：V2签名验证通过的话，就不需要继续下面的工作了
            if (verified) {
                return;
            }

            // 第五步：对apk文件进行验证，主要是通过MANIFEST.MF文件记录的消息摘要与源文件生成的对比
            Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "verifyV1");
            final List<ZipEntry> toVerify = new ArrayList<>();
            toVerify.add(manifestEntry);

            // 非系统apk需要验证apk的文件,除了AndroidManifest.xml和META-INF文件夹下的文件都不需要验证
            if ((parseFlags & PARSE_IS_SYSTEM_DIR) == 0) {
                final Iterator<ZipEntry> i = jarFile[0].iterator();
                while (i.hasNext()) {
                    final ZipEntry entry = i.next();

                    if (entry.isDirectory()) continue;

                    final String entryName = entry.getName();
                    if (entryName.startsWith("META-INF/")) continue;
                    if (entryName.equals(ANDROID_MANIFEST_FILENAME)) continue;

                    toVerify.add(entry);
                }
            }

            final StrictJarFile[] sJarFiles = jarFile;
            class VerificationData {
                public Exception exception;
                public int exceptionFlag;
                public boolean wait;
                public int index;
                public Object objWaitAll;
                public boolean shutDown;
            }
            VerificationData vData = new VerificationData();
            vData.objWaitAll = new Object();
            // 开启线程池进行验证，提高验证效率
            final ThreadPoolExecutor verificationExecutor = new ThreadPoolExecutor(
                    NUMBER_OF_CORES,
                    NUMBER_OF_CORES,
                    1,/*keep alive time*/
                    TimeUnit.SECONDS,
                    new LinkedBlockingQueue<Runnable>());
            // 遍历验证文件
            for (ZipEntry entry : toVerify) {
                Runnable verifyTask = new Runnable(){
                    public void run() {
                        try {
                            ...
                            // 文件验证通过则返回证书
                            final Certificate[][] entryCerts = loadCertificates(tempJarFile, entry);
                            if (ArrayUtils.isEmpty(entryCerts)) {
                                throw new PackageParserException(INSTALL_PARSE_FAILED_NO_CERTIFICATES,
                                        "Package " + apkPath + " has no certificates at entry "
                                        + entry.getName());
                            }
                            final Signature[] entrySignatures = convertToSignatures(entryCerts);
    // 第六步：认证开发者身份
    synchronized (pkg) {
        if (pkg.mCertificates == null) {
            pkg.mCertificates = entryCerts;
            pkg.mSignatures = entrySignatures;
            pkg.mSigningKeys = new ArraySet<PublicKey>();
            for (int i=0; i < entryCerts.length; i++) {
                pkg.mSigningKeys.add(entryCerts[i][0].getPublicKey());
            }
        } else {
            if (!Signature.areExactMatch(pkg.mSignatures, entrySignatures)) {
                    throw new PackageParserException(
                                                INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES, "Package " + apkPath
                                                + " has mismatched certificates at entry "
                                                + entry.getName());
             }
        }
    }
    ...
}

private StrictJarFile(String name,FileDescriptor fd,boolean verify,
        boolean signatureSchemeRollbackProtectionsEnforced)
        throws IOException, SecurityException {
    this.nativeHandle = nativeOpenJarFile(name, fd.getInt$());
    this.fd = fd;

    try {
        if (verify) {
            // 将MANIFEST.MF、CERT.SF和CERT.RSA缓存到metaEntries中，key为文件名字，如META-INF/MANIFEST.MF
            HashMap<String, byte[]> metaEntries = getMetaEntries();
            // 创建MANIFEST.MF的StrictJarManifest对象，StrictJarManifest的构造器会检查MANIFEST.MF中是否有
            // 相同的Name条目，如Name: AndroidManifest.xml，如果有相同的条目，则抛出异常
            this.manifest = new StrictJarManifest(metaEntries.get(JarFile.MANIFEST_NAME), true);
            this.verifier =
                    new StrictJarVerifier(
                            name,
                            manifest,
                            metaEntries,
                            signatureSchemeRollbackProtectionsEnforced);
            Set<String> files = manifest.getEntries().keySet();
            for (String file : files) {
                if (findEntry(file) == null) {
                    throw new SecurityException("File " + file + " in manifest does not exist");
                }
            }
            // isSignedJar方法只要有认证过的签名文件就为true
            isSigned = verifier.readCertificates() && verifier.isSignedJar();
        } 
        ...
    }

synchronized boolean readCertificates() {
    if (metaEntries.isEmpty()) {
        return false;
    }

    Iterator<String> it = metaEntries.keySet().iterator();
    while (it.hasNext()) {
        String key = it.next();
        if (key.endsWith(".DSA") || key.endsWith(".RSA") || key.endsWith(".EC")) {
            verifyCertificate(key);
            it.remove();
        }
    }
    return true;
}

private void verifyCertificate(String certFile) {
    String signatureFile = certFile.substring(0, certFile.lastIndexOf('.')) + ".SF";
    // .SF
    byte[] sfBytes = metaEntries.get(signatureFile);
    if (sfBytes == null) {
        return;
    }
    // MANIFEST.MF
    byte[] manifestBytes = metaEntries.get(JarFile.MANIFEST_NAME);
    // Manifest entry is required for any verifications.
    if (manifestBytes == null) {
        return;
    }
    // .RSA文件
    byte[] sBlockBytes = metaEntries.get(certFile);
    try {
        // 第一步：验证.SF文件，主要是通过.RSA文件与.SF文件的对比
        Certificate[] signerCertChain = verifyBytes(sBlockBytes, sfBytes);
        if (signerCertChain != null) {
            certificates.put(signatureFile, signerCertChain);
        }
    } catch (GeneralSecurityException e) {
      throw failedVerification(jarName, signatureFile, e);
    }

    // Verify manifest hash in .sf file
    Attributes attributes = new Attributes();
    HashMap<String, Attributes> entries = new HashMap<String, Attributes>();
    try {
        StrictJarManifestReader im = new StrictJarManifestReader(sfBytes, attributes);
        im.readEntries(entries, null);
    } catch (IOException e) {
        return;
    }
    //第二步：检验是否有V2签名标记
    if (signatureSchemeRollbackProtectionsEnforced) {
        String apkSignatureSchemeIdList =
                attributes.getValue(
                ApkSignatureSchemeV2Verifier.SF_ATTRIBUTE_ANDROID_APK_SIGNED_NAME);
        if (apkSignatureSchemeIdList != null) {
            boolean v2SignatureGenerated = false;
            StringTokenizer tokenizer = new StringTokenizer(apkSignatureSchemeIdList, ",");

            //如果CERT.SF头部有X-Android-APK-Signed: 2，证明是用V2签名方案的，此流程是验证V1方案，
            //因此抛出异常
            if (id == ApkSignatureSchemeV2Verifier.SF_ATTRIBUTE_ANDROID_APK_SIGNED_ID) {
                    v2SignatureGenerated = true;
                    break;
                }
            }

            if (v2SignatureGenerated) {
                throw new SecurityException(signatureFile + " indicates " + jarName
                        + " is signed using APK Signature Scheme v2, but no such signature was"
                        + " found. Signature stripped?");
            }
        }
    }

    // 第三步：使用.SF的"-Digest-Manifest-Main-Attributes"摘要验证.MF
    if (mainAttributesEnd > 0 && !createdBySigntool) {
        String digestAttribute = "-Digest-Manifest-Main-Attributes";
        if (!verify(attributes, digestAttribute, manifestBytes, 0, mainAttributesEnd, false, true)) {
            throw failedVerification(jarName, signatureFile);
        }
    }

    // 第四步：使用.SF分别验证.MF各个条目
    String digestAttribute = createdBySigntool ? "-Digest" : "-Digest-Manifest";
    if (!verify(attributes, digestAttribute, manifestBytes, 0, manifestBytes.length, false, false)) {
        Iterator<Map.Entry<String, Attributes>> it = entries.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry<String, Attributes> entry = it.next();
            StrictJarManifest.Chunk chunk = manifest.getChunk(entry.getKey());
            if (chunk == null) {
                return;
            }
            if (!verify(entry.getValue(), "-Digest", manifestBytes,
                    chunk.start, chunk.end, createdBySigntool, false)) {
                throw invalidDigest(signatureFile, entry.getKey(), jarName);
            }
        }
    }
    // 第五步：缓存.SF文件的entries
    metaEntries.put(signatureFile, null);
    signatures.put(signatureFile, entries);
}

static Certificate[] verifyBytes(byte[] blockBytes, byte[] sfBytes)
    throws GeneralSecurityException {
    Object obj = null;
    try {

        obj = Providers.startJarVerification();
        PKCS7 block = new PKCS7(blockBytes);
        // 提取.RSA中的消息摘要验证.SF整个文件
        SignerInfo[] verifiedSignerInfos = block.verify(sfBytes);
        if ((verifiedSignerInfos == null) || (verifiedSignerInfos.length == 0)) {
            throw new GeneralSecurityException(
                    "Failed to verify signature: no verified SignerInfos");
        }
        SignerInfo verifiedSignerInfo = verifiedSignerInfos[0];
        List<X509Certificate> verifiedSignerCertChain =
                verifiedSignerInfo.getCertificateChain(block);
        if (verifiedSignerCertChain == null) {
            throw new GeneralSecurityException(
                "Failed to find verified SignerInfo certificate chain");
        } else if (verifiedSignerCertChain.isEmpty()) {
            throw new GeneralSecurityException(
                "Verified SignerInfo certificate chain is emtpy");
        }
        
        return verifiedSignerCertChain.toArray(
                new X509Certificate[verifiedSignerCertChain.size()]);
        } catch (IOException e) {
            throw new GeneralSecurityException("IO exception verifying jar cert", e);
        } finally {
            Providers.stopJarVerification(obj);
        }
}

public SignerInfo[] verify(byte[] bytes)
    throws NoSuchAlgorithmException, SignatureException {

    Vector<SignerInfo> intResult = new Vector<SignerInfo>();
    for (int i = 0; i < signerInfos.length; i++) {

        SignerInfo signerInfo = verify(signerInfos[i], bytes);
        if (signerInfo != null) {
            intResult.addElement(signerInfo);
        }
    }
    ...
}

SignerInfo verify(PKCS7 block, InputStream inputStream)
    throws NoSuchAlgorithmException, SignatureException, IOException {

   try {
        ...

            // first, check content type
            // 检查内容类型
            ObjectIdentifier contentType = (ObjectIdentifier)
                   authenticatedAttributes.getAttributeValue(
                     PKCS9Attribute.CONTENT_TYPE_OID);
            if (contentType == null ||
                !contentType.equals((Object)content.contentType))
                return null;  // contentType does not match, bad SignerInfo

            // now, check message digest
       		// 检查消息摘要
            byte[] messageDigest = (byte[])
                authenticatedAttributes.getAttributeValue(
                     PKCS9Attribute.MESSAGE_DIGEST_OID);

            if (messageDigest == null) // fail if there is no message digest
                return null;

            // check that algorithm is not restricted
            if (!JAR_DISABLED_CHECK.permits(DIGEST_PRIMITIVE_SET,
                    digestAlgname, null)) {
                throw new SignatureException("Digest check failed. " +
                        "Disabled algorithm used: " + digestAlgname);
            }

           // 对.SF文件计算消息摘要
            MessageDigest md = MessageDigest.getInstance(digestAlgname);

            byte[] buffer = new byte[4096];
            int read = 0;
            while ((read = inputStream.read(buffer)) != -1) {
               md.update(buffer, 0 , read);
            }
            byte[] computedMessageDigest = md.digest();

            if (messageDigest.length != computedMessageDigest.length)
                return null;
            // 计算出来的.SF文件的消息摘要和保存在.RSA文件中的消息摘要进行对比
            for (int i = 0; i < messageDigest.length; i++) {
                if (messageDigest[i] != computedMessageDigest[i])
                    return null;
            }

            ...
}

// 第四步：使用.SF分别验证.MF各个条目
    String digestAttribute = createdBySigntool ? "-Digest" : "-Digest-Manifest";
    if (!verify(attributes, digestAttribute, manifestBytes, 0, manifestBytes.length, false, false)) {
        Iterator<Map.Entry<String, Attributes>> it = entries.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry<String, Attributes> entry = it.next();
            StrictJarManifest.Chunk chunk = manifest.getChunk(entry.getKey());
            if (chunk == null) {
                return;
            }
            if (!verify(entry.getValue(), "-Digest", manifestBytes,
                    chunk.start, chunk.end, createdBySigntool, false)) {
                throw invalidDigest(signatureFile, entry.getKey(), jarName);
            }
        }
    }

private boolean verify(Attributes attributes, String entry, byte[] data,
        int start, int end, boolean ignoreSecondEndline, boolean ignorable) {
           
    for (int i = 0; i < DIGEST_ALGORITHMS.length; i++) {
        String algorithm = DIGEST_ALGORITHMS[i];
        String hash = attributes.getValue(algorithm + entry);
        if (hash == null) {
            continue;
        }

        MessageDigest md;
        try {
            md = MessageDigest.getInstance(algorithm);
        } catch (NoSuchAlgorithmException e) {
            continue;
        }
        if (ignoreSecondEndline && data[end - 1] == '\n' && data[end - 2] == '\n') {
            md.update(data, start, end - 1 - start);
        } else {
            md.update(data, start, end - start);
        }
        // 相同的算法提取apk中MANIFEST.MF内容的摘要
        byte[] b = md.digest();
        // 获取.SF文件中对应内容
        byte[] encodedHashBytes = hash.getBytes(StandardCharsets.ISO_8859_1);
        // 将b进行base64编码直接与.SF的内容进行相等比较
        return verifyMessageDigest(b, encodedHashBytes);
    }
    return ignorable;
}

private static boolean verifyMessageDigest(byte[] expected, byte[] encodedActual) {
    byte[] actual;
    try {
        actual = java.util.Base64.getDecoder().decode(encodedActual);
    } catch (IllegalArgumentException e) {
        return false;
    }
    return MessageDigest.isEqual(expected, actual);
}

private static Certificate[][] loadCertificates(StrictJarFile jarFile, ZipEntry entry)
        throws PackageParserException {
    InputStream is = null;
    try {
        // We must read the stream for the JarEntry to retrieve
        // its certificates.
        is = jarFile.getInputStream(entry);// 第一步：获取apk的指定的源文件
        readFullyIgnoringContents(is);// 第二步：读取内容并验证
        return jarFile.getCertificateChains(entry);// 第三步：返回认证信息
    } catch (IOException | RuntimeException e) {
        throw new PackageParserException(INSTALL_PARSE_FAILED_UNEXPECTED_EXCEPTION,
                "Failed reading " + entry.getName() + " in " + jarFile, e);
    } finally {
        IoUtils.closeQuietly(is);
    }
}

public InputStream getInputStream(ZipEntry ze) {
    final InputStream is = getZipInputStream(ze);

    // apk签名已验证成功
    if (isSigned) {
        // 获取VerifierEntry实例
        StrictJarVerifier.VerifierEntry entry = verifier.initEntry(ze.getName());
        if (entry == null) {
            return is;
        }

        return new JarFileInputStream(is, ze.getSize(), entry);
    }

    return is;
}

VerifierEntry initEntry(String name) {
    if (manifest == null || signatures.isEmpty()) {
        return null;
    }
    // 获取MANIFEST.MF中相应内容(文件)的内容
    Attributes attributes = manifest.getAttributes(name);
    ...

    for (int i = 0; i < DIGEST_ALGORITHMS.length; i++) {
        final String algorithm = DIGEST_ALGORITHMS[i];
        final String hash = attributes.getValue(algorithm + "-Digest");
        if (hash == null) {
            continue;
        }
        //获取对应的编码摘要
        byte[] hashBytes = hash.getBytes(StandardCharsets.ISO_8859_1);

        try {
            // 构建VerifierEntry对象
            return new VerifierEntry(name, MessageDigest.getInstance(algorithm), hashBytes,
                    certChainsArray, verifiedEntries);
        } catch (NoSuchAlgorithmException ignored) {
        }
    }
    return null;
}

public static long readFullyIgnoringContents(InputStream in) throws IOException {
    byte[] buffer = sBuffer.getAndSet(null);
    if (buffer == null) {
        buffer = new byte[4096];
    }

    int n = 0;
    int count = 0;
    while ((n = in.read(buffer, 0, buffer.length)) != -1) {
        count += n;
    }

    sBuffer.set(buffer);
    return count;
}

@Override
public int read() throws IOException {
    if (done) {
        return -1;
    }
    if (count > 0) {
        int r = super.read();
        if (r != -1) {
            entry.write(r);// 写入到VerifierEntry中
            count--;
        } else {
            count = 0;
        }
        if (count == 0) {// 读取完毕
            done = true;
            entry.verify();// 使用VerifierEntry进行认证
        }
        return r;
    } else {
        done = true;
        entry.verify();
        return -1;
    }
}

@Override
public void write(int value) {
    digest.update((byte) value);
}

void verify() {
    byte[] d = digest.digest();
    // 文件摘要与MANIFEST.MF中记录对应的文件摘要进行比较
    if (!verifyMessageDigest(d, hash)) {
        throw invalidDigest(JarFile.MANIFEST_NAME, name, name);
    }
    verifiedEntries.put(name, certChains);
}

private static boolean verifyMessageDigest(byte[] expected, byte[] encodedActual) {
    byte[] actual;
    try {
        actual = java.util.Base64.getDecoder().decode(encodedActual);
    } catch (IllegalArgumentException e) {
        return false;
    }
    return MessageDigest.isEqual(expected, actual);
}

// 第六步：认证开发者身份
synchronized (pkg) {
    // 如果没有旧的apk，则将认证信息填入
    if (pkg.mCertificates == null) {
        pkg.mCertificates = entryCerts;
        pkg.mSignatures = entrySignatures;
        pkg.mSigningKeys = new ArraySet<PublicKey>();
        for (int i=0; i < entryCerts.length; i++) {
            pkg.mSigningKeys.add(entryCerts[i][0].getPublicKey());
        }
    // 如果有旧的apk，则要比较新旧apk的开发者签名信息，相同才能认证成功
    } else {
        if (!Signature.areExactMatch(pkg.mSignatures, entrySignatures)) {
                throw new PackageParserException(
                                                INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES, "Package " + apkPath
                                           + " has mismatched certificates at entry "
                                            + entry.getName());
         }
    }
}

private static void collectCertificates(Package pkg, File apkFile, int parseFlags)
        throws PackageParserException {
    final String apkPath = apkFile.getAbsolutePath();
    boolean verified = false;//V2签名验证标记位
    {
        Certificate[][] allSignersCerts = null;
        Signature[] signatures = null;
        try {
            Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "verifyV2");
            //第一步：V2签名验证
            allSignersCerts = ApkSignatureSchemeV2Verifier.verify(apkPath);
            signatures = convertToSignatures(allSignersCerts);
            // APK verified using APK Signature Scheme v2.
            verified = true;
        } catch (ApkSignatureSchemeV2Verifier.SignatureNotFoundException e) {
          ...
                Trace.traceEnd(TRACE_TAG_PACKAGE_MANAGER);
        }
        // V2认证通过后，继续认证新老apk的开发者信息，和V1一样；如果V2没认证，则使用V1
        if (verified) {
            if (pkg.mCertificates == null) {
                pkg.mCertificates = allSignersCerts;
                pkg.mSignatures = signatures;
                pkg.mSigningKeys = new ArraySet<>(allSignersCerts.length);
                for (int i = 0; i < allSignersCerts.length; i++) {
                    Certificate[] signerCerts = allSignersCerts[i];
                    Certificate signerCert = signerCerts[0];
                    pkg.mSigningKeys.add(signerCert.getPublicKey());
                }
            }
        }
        ...

public static X509Certificate[][] verify(String apkFile)
        throws SignatureNotFoundException, SecurityException, IOException {
    try (RandomAccessFile apk = new RandomAccessFile(apkFile, "r")) {
        return verify(apk);
    }
}
private static X509Certificate[][] verify(RandomAccessFile apk)
        throws SignatureNotFoundException, SecurityException, IOException {
    // 第一步：验证apk文件格式并获取签名块内容
    SignatureInfo signatureInfo = findSignature(apk);
    // 第二步：认证流程
    return verify(apk.getFD(), signatureInfo);
}

private static SignatureInfo findSignature(RandomAccessFile apk)
        throws IOException, SignatureNotFoundException {
    // Find the ZIP End of Central Directory (EoCD) record.
    // 第一步：通过EoCD的信息确定CD的位置
    Pair<ByteBuffer, Long> eocdAndOffsetInFile = getEocd(apk);
    ByteBuffer eocd = eocdAndOffsetInFile.first;
    long eocdOffset = eocdAndOffsetInFile.second;
    if (ZipUtils.isZip64EndOfCentralDirectoryLocatorPresent(apk, eocdOffset)) {
        throw new SignatureNotFoundException("ZIP64 APK not supported");
    }

    // Find the APK Signing Block. The block immediately precedes the Central Directory.
    // 第二步：通过CD的信息确定签名块的位置
    long centralDirOffset = getCentralDirOffset(eocd, eocdOffset);
    Pair<ByteBuffer, Long> apkSigningBlockAndOffsetInFile =
            findApkSigningBlock(apk, centralDirOffset);
    ByteBuffer apkSigningBlock = apkSigningBlockAndOffsetInFile.first;
    long apkSigningBlockOffset = apkSigningBlockAndOffsetInFile.second;

    // Find the APK Signature Scheme v2 Block inside the APK Signing Block.
    // 第三步：读取签名块中的签名数据信息
    ByteBuffer apkSignatureSchemeV2Block = findApkSignatureSchemeV2Block(apkSigningBlock);
   // 构建签名数据对象
    return new SignatureInfo(
            apkSignatureSchemeV2Block,
            apkSigningBlockOffset,
            centralDirOffset,
            eocdOffset,
            eocd);
}

private static ByteBuffer findApkSignatureSchemeV2Block(ByteBuffer apkSigningBlock)
        throws SignatureNotFoundException {
    checkByteOrderLittleEndian(apkSigningBlock);
    // FORMAT:
    // OFFSET       DATA TYPE  DESCRIPTION
    // * @+0  bytes uint64:    size in bytes (excluding this field)
    // * @+8  bytes pairs
    // * @-24 bytes uint64:    size in bytes (same as the one above)
    // * @-16 bytes uint128:   magic
    ByteBuffer pairs = sliceFromTo(apkSigningBlock, 8, apkSigningBlock.capacity() - 24);

    int entryCount = 0;
    while (pairs.hasRemaining()) {
        entryCount++;
        if (pairs.remaining() < 8) {
           throw new SignatureNotFoundException(
                   "Insufficient data to read size of APK Signing Block entry #" + entryCount);
        }
        long lenLong = pairs.getLong();
        if ((lenLong < 4) || (lenLong > Integer.MAX_VALUE)) {
           throw new SignatureNotFoundException(
                    "APK Signing Block entry #" + entryCount
                            + " size out of range: " + lenLong);
        }
        int len = (int) lenLong;
        int nextEntryPos = pairs.position() + len;
        if (len > pairs.remaining()) {
           throw new SignatureNotFoundException(
                    "APK Signing Block entry #" + entryCount + " size out of range: " + len
                           + ", available: " + pairs.remaining());
        }
        int id = pairs.getInt();
        //从ID-value中找到签名数据
        if (id == APK_SIGNATURE_SCHEME_V2_BLOCK_ID) {
            return getByteBuffer(pairs, len - 4);
        }
        pairs.position(nextEntryPos);
    }

    throw new SignatureNotFoundException(
            "No APK Signature Scheme v2 block in APK Signing Block");
}

private static X509Certificate[][] verify(
        FileDescriptor apkFileDescriptor,
        SignatureInfo signatureInfo) throws SecurityException {
    int signerCount = 0;
    Map<Integer, byte[]> contentDigests = new ArrayMap<>();
    List<X509Certificate[]> signerCerts = new ArrayList<>();
    CertificateFactory certFactory;
    try {
        certFactory = CertificateFactory.getInstance("X.509");
    } catch (CertificateException e) {
        throw new RuntimeException("Failed to obtain X.509 CertificateFactory", e);
    }
    ByteBuffer signers;
    try {
        // 读取签名块内所有签名信息
        signers = getLengthPrefixedSlice(signatureInfo.signatureBlock);
    } catch (IOException e) {
        throw new SecurityException("Failed to read list of signers", e);
    }
    // 第一步：验证每个签名，一个apk可以有多个签名，但一般只签名一次
    while (signers.hasRemaining()) {
        signerCount++;
        try {
            ByteBuffer signer = getLengthPrefixedSlice(signers);
            X509Certificate[] certs = verifySigner(signer, contentDigests, certFactory);
            signerCerts.add(certs);
        } catch (IOException | BufferUnderflowException | SecurityException e) {
            throw new SecurityException(
                    "Failed to parse/verify signer #" + signerCount + " block",
                    e);
        }
    }

    if (signerCount < 1) {
        throw new SecurityException("No signers found");
    }

    if (contentDigests.isEmpty()) {
        throw new SecurityException("No content digests found");
    }
    // 第二步：验证摘要
    verifyIntegrity(
            contentDigests,
            apkFileDescriptor,
            signatureInfo.apkSigningBlockOffset,
            signatureInfo.centralDirOffset,
            signatureInfo.eocdOffset,
            signatureInfo.eocd);
    // 返回所有验证通过的信息
    return signerCerts.toArray(new X509Certificate[signerCerts.size()][]);
}

private static X509Certificate[] verifySigner(
        ByteBuffer signerBlock,
        Map<Integer, byte[]> contentDigests,
        CertificateFactory certFactory) throws SecurityException, IOException {
    // 签名块的三部分数据，可见2.2.4 V2 分块格式小节的图
    ByteBuffer signedData = getLengthPrefixedSlice(signerBlock);
    ByteBuffer signatures = getLengthPrefixedSlice(signerBlock);
    byte[] publicKeyBytes = readLengthPrefixedByteArray(signerBlock);

    int signatureCount = 0;
    int bestSigAlgorithm = -1;
    byte[] bestSigAlgorithmSignatureBytes = null;
    List<Integer> signaturesSigAlgorithms = new ArrayList<>();
    while (signatures.hasRemaining()) {
        signatureCount++;
        try {
            ByteBuffer signature = getLengthPrefixedSlice(signatures);
            if (signature.remaining() < 8) {
                throw new SecurityException("Signature record too short");
            }
            int sigAlgorithm = signature.getInt();
            signaturesSigAlgorithms.add(sigAlgorithm);
            if (!isSupportedSignatureAlgorithm(sigAlgorithm)) {
                continue;
            }
            // 第一步： 从signatures中选择安全系数最高的受支持 signature algorithm ID那个
            if ((bestSigAlgorithm == -1)
                    || (compareSignatureAlgorithm(sigAlgorithm, bestSigAlgorithm) > 0)) {
                bestSigAlgorithm = sigAlgorithm;
                bestSigAlgorithmSignatureBytes = readLengthPrefixedByteArray(signature);
            }
        } catch (IOException | BufferUnderflowException e) {
            throw new SecurityException(
                    "Failed to parse signature record #" + signatureCount,
                    e);
        }
    }
    if (bestSigAlgorithm == -1) {
        if (signatureCount == 0) {
                throw new SecurityException("No signatures found");
        } else {
            throw new SecurityException("No supported signatures found");
        }
    }

    String keyAlgorithm = getSignatureAlgorithmJcaKeyAlgorithm(bestSigAlgorithm);
    Pair<String, ? extends AlgorithmParameterSpec> signatureAlgorithmParams =
           getSignatureAlgorithmJcaSignatureAlgorithm(bestSigAlgorithm);
    String jcaSignatureAlgorithm = signatureAlgorithmParams.first;
    AlgorithmParameterSpec jcaSignatureAlgorithmParams = signatureAlgorithmParams.second;
    boolean sigVerified;
    try {
        PublicKey publicKey =
                KeyFactory.getInstance(keyAlgorithm)
                        .generatePublic(new X509EncodedKeySpec(publicKeyBytes));
        Signature sig = Signature.getInstance(jcaSignatureAlgorithm);
        sig.initVerify(publicKey);
        if (jcaSignatureAlgorithmParams != null) {
            sig.setParameter(jcaSignatureAlgorithmParams);
        }
        sig.update(signedData);
        // 第二步：使用公钥验证签名信息
        sigVerified = sig.verify(bestSigAlgorithmSignatureBytes);
    } catch (NoSuchAlgorithmException | InvalidKeySpecException | InvalidKeyException
            | InvalidAlgorithmParameterException | SignatureException e) {
        throw new SecurityException(
                "Failed to verify " + jcaSignatureAlgorithm + " signature", e);
    }
    if (!sigVerified) {
        throw new SecurityException(jcaSignatureAlgorithm + " signature did not verify");
    }

    // Signature over signedData has verified.
    // 第三步：取出signed data中记录的摘要信息，以便后面做摘要验证
    byte[] contentDigest = null;
    signedData.clear();
    ByteBuffer digests = getLengthPrefixedSlice(signedData);
    List<Integer> digestsSigAlgorithms = new ArrayList<>();
    int digestCount = 0;
    while (digests.hasRemaining()) {
        digestCount++;
        try {
            ByteBuffer digest = getLengthPrefixedSlice(digests);
            if (digest.remaining() < 8) {
                throw new IOException("Record too short");
            }
            int sigAlgorithm = digest.getInt();
            digestsSigAlgorithms.add(sigAlgorithm);
            if (sigAlgorithm == bestSigAlgorithm) {
                contentDigest = readLengthPrefixedByteArray(digest);
            }
        } catch (IOException | BufferUnderflowException e) {
            throw new IOException("Failed to parse digest record #" + digestCount, e);
        }
    }

    if (!signaturesSigAlgorithms.equals(digestsSigAlgorithms)) {
        throw new SecurityException(
                "Signature algorithms don't match between digests and signatures records");
    }
    int digestAlgorithm = getSignatureAlgorithmContentDigestAlgorithm(bestSigAlgorithm);
    byte[] previousSignerDigest = contentDigests.put(digestAlgorithm, contentDigest);
    if ((previousSignerDigest != null)
            && (!MessageDigest.isEqual(previousSignerDigest, contentDigest))) {
        throw new SecurityException(
                getContentDigestAlgorithmJcaDigestAlgorithm(digestAlgorithm)
                + " contents digest does not match the digest specified by a preceding signer");
    }
    // 第四步：取出signed data中的证书信息
    ByteBuffer certificates = getLengthPrefixedSlice(signedData);
    List<X509Certificate> certs = new ArrayList<>();
    int certificateCount = 0;
    while (certificates.hasRemaining()) {
        certificateCount++;
        byte[] encodedCert = readLengthPrefixedByteArray(certificates);
        X509Certificate certificate;
        try {
            certificate = (X509Certificate)
                    certFactory.generateCertificate(new ByteArrayInputStream(encodedCert));
        } catch (CertificateException e) {
            throw new SecurityException("Failed to decode certificate #" + certificateCount, e);
        }
        certificate = new VerbatimX509Certificate(certificate, encodedCert);
        certs.add(certificate);
    }

    if (certs.isEmpty()) {
        throw new SecurityException("No certificates listed");
    }
    // 第五步：验证证书身份和公钥是否为同一个身份
    X509Certificate mainCertificate = certs.get(0);
    byte[] certificatePublicKeyBytes = mainCertificate.getPublicKey().getEncoded();
    if (!Arrays.equals(publicKeyBytes, certificatePublicKeyBytes)) {
        throw new SecurityException(
                "Public key mismatch between certificate and signature record");
    }
    // 返回证书信息
    return certs.toArray(new X509Certificate[certs.size()]);
}

verifyIntegrity(
        contentDigests,
        apkFileDescriptor,
        signatureInfo.apkSigningBlockOffset,
        signatureInfo.centralDirOffset,
        signatureInfo.eocdOffset,
        signatureInfo.eocd);

private static void verifyIntegrity(
        Map<Integer, byte[]> expectedDigests,
        FileDescriptor apkFileDescriptor,
        long apkSigningBlockOffset,
        long centralDirOffset,
        long eocdOffset,
        ByteBuffer eocdBuf) throws SecurityException {

    if (expectedDigests.isEmpty()) {
        throw new SecurityException("No digests provided");
    }
    // 获取apk的contents、CD、EoCD三个部分内容
    DataSource beforeApkSigningBlock =
            new MemoryMappedFileDataSource(apkFileDescriptor, 0, apkSigningBlockOffset);
    DataSource centralDir =
            new MemoryMappedFileDataSource(
                    apkFileDescriptor, centralDirOffset, eocdOffset - centralDirOffset);

    eocdBuf = eocdBuf.duplicate();
    eocdBuf.order(ByteOrder.LITTLE_ENDIAN);
    ZipUtils.setZipEocdCentralDirectoryOffset(eocdBuf, apkSigningBlockOffset);
    DataSource eocd = new ByteBufferDataSource(eocdBuf);

    int[] digestAlgorithms = new int[expectedDigests.size()];
    int digestAlgorithmCount = 0;
    for (int digestAlgorithm : expectedDigests.keySet()) {
        digestAlgorithms[digestAlgorithmCount] = digestAlgorithm;
        digestAlgorithmCount++;
    }
    // 计算每个部分内容的实际摘要值
    byte[][] actualDigests;
    try {
        actualDigests =
                computeContentDigests(
                        digestAlgorithms,
                        new DataSource[] {beforeApkSigningBlock, centralDir, eocd});
    } catch (DigestException e) {
        throw new SecurityException("Failed to compute digest(s) of contents", e);
    }
    // 对比每个部分的实际摘要值和signed data中对应的原始摘要值，如果全部相等则说明内容未被篡改，通过验证
    for (int i = 0; i < digestAlgorithms.length; i++) {
        int digestAlgorithm = digestAlgorithms[i];
        byte[] expectedDigest = expectedDigests.get(digestAlgorithm);
        byte[] actualDigest = actualDigests[i];
        if (!MessageDigest.isEqual(expectedDigest, actualDigest)) {
            throw new SecurityException(
                    getContentDigestAlgorithmJcaDigestAlgorithm(digestAlgorithm)
                            + " digest of contents did not verify");
        }
    }
}