| /* |
| * Copyright (C) 2020 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.server.pm; |
| |
| import static android.content.pm.Checksum.TYPE_PARTIAL_MERKLE_ROOT_1M_SHA256; |
| import static android.content.pm.Checksum.TYPE_PARTIAL_MERKLE_ROOT_1M_SHA512; |
| import static android.content.pm.Checksum.TYPE_WHOLE_MD5; |
| import static android.content.pm.Checksum.TYPE_WHOLE_MERKLE_ROOT_4K_SHA256; |
| import static android.content.pm.Checksum.TYPE_WHOLE_SHA1; |
| import static android.content.pm.Checksum.TYPE_WHOLE_SHA256; |
| import static android.content.pm.Checksum.TYPE_WHOLE_SHA512; |
| import static android.content.pm.parsing.ApkLiteParseUtils.APK_FILE_EXTENSION; |
| import static android.util.apk.ApkSigningBlockUtils.CONTENT_DIGEST_CHUNKED_SHA256; |
| import static android.util.apk.ApkSigningBlockUtils.CONTENT_DIGEST_CHUNKED_SHA512; |
| import static android.util.apk.ApkSigningBlockUtils.CONTENT_DIGEST_VERITY_CHUNKED_SHA256; |
| |
| import android.annotation.NonNull; |
| import android.annotation.Nullable; |
| import android.content.Context; |
| import android.content.pm.ApkChecksum; |
| import android.content.pm.Checksum; |
| import android.content.pm.IOnChecksumsReadyListener; |
| import android.content.pm.PackageManagerInternal; |
| import android.content.pm.Signature; |
| import android.content.pm.SigningDetails.SignatureSchemeVersion; |
| import android.content.pm.parsing.ApkLiteParseUtils; |
| import android.content.pm.parsing.result.ParseResult; |
| import android.content.pm.parsing.result.ParseTypeImpl; |
| import android.os.Handler; |
| import android.os.RemoteException; |
| import android.os.SystemClock; |
| import android.os.incremental.IncrementalManager; |
| import android.os.incremental.IncrementalStorage; |
| import android.util.ArrayMap; |
| import android.util.ArraySet; |
| import android.util.Pair; |
| import android.util.Slog; |
| import android.util.apk.ApkSignatureSchemeV2Verifier; |
| import android.util.apk.ApkSignatureSchemeV3Verifier; |
| import android.util.apk.ApkSignatureSchemeV4Verifier; |
| import android.util.apk.ApkSignatureVerifier; |
| import android.util.apk.ApkSigningBlockUtils; |
| import android.util.apk.ByteBufferFactory; |
| import android.util.apk.SignatureInfo; |
| import android.util.apk.SignatureNotFoundException; |
| import android.util.apk.VerityBuilder; |
| |
| import com.android.internal.annotations.VisibleForTesting; |
| import com.android.internal.security.VerityUtils; |
| import com.android.server.pm.pkg.AndroidPackage; |
| |
| import java.io.ByteArrayOutputStream; |
| import java.io.DataInputStream; |
| import java.io.DataOutputStream; |
| import java.io.EOFException; |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.io.RandomAccessFile; |
| import java.nio.ByteBuffer; |
| import java.nio.ByteOrder; |
| import java.nio.file.Files; |
| import java.security.DigestException; |
| import java.security.InvalidParameterException; |
| import java.security.MessageDigest; |
| import java.security.NoSuchAlgorithmException; |
| import java.security.SignatureException; |
| import java.security.cert.Certificate; |
| import java.security.cert.CertificateEncodingException; |
| import java.security.cert.X509Certificate; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import sun.security.pkcs.PKCS7; |
| import sun.security.pkcs.SignerInfo; |
| |
| /** |
| * Provides checksums for APK. |
| */ |
| public class ApkChecksums { |
| static final String TAG = "ApkChecksums"; |
| |
| private static final String DIGESTS_FILE_EXTENSION = ".digests"; |
| private static final String DIGESTS_SIGNATURE_FILE_EXTENSION = ".signature"; |
| |
| // MessageDigest algorithms. |
| static final String ALGO_MD5 = "MD5"; |
| static final String ALGO_SHA1 = "SHA1"; |
| static final String ALGO_SHA256 = "SHA256"; |
| static final String ALGO_SHA512 = "SHA512"; |
| |
| private static final Certificate[] EMPTY_CERTIFICATE_ARRAY = {}; |
| |
| /** |
| * Arbitrary size restriction for the signature, used to sign the checksums. |
| */ |
| private static final int MAX_SIGNATURE_SIZE_BYTES = 35 * 1024; |
| |
| /** |
| * Check back in 1 second after we detected we needed to wait for the APK to be fully available. |
| */ |
| private static final long PROCESS_REQUIRED_CHECKSUMS_DELAY_MILLIS = 1000; |
| |
| /** |
| * 24 hours timeout to wait till all files are loaded. |
| */ |
| private static final long PROCESS_REQUIRED_CHECKSUMS_TIMEOUT_MILLIS = 1000 * 3600 * 24; |
| |
| /** |
| * Unit tests will instantiate, extend and/or mock to mock dependencies / behaviors. |
| * |
| * NOTE: All getters should return the same instance for every call. |
| */ |
| @VisibleForTesting(visibility = VisibleForTesting.Visibility.PRIVATE) |
| static class Injector { |
| |
| @VisibleForTesting(visibility = VisibleForTesting.Visibility.PRIVATE) |
| interface Producer<T> { |
| /** Produce an instance of type {@link T} */ |
| T produce(); |
| } |
| |
| private final Producer<Context> mContext; |
| private final Producer<Handler> mHandlerProducer; |
| private final Producer<IncrementalManager> mIncrementalManagerProducer; |
| private final Producer<PackageManagerInternal> mPackageManagerInternalProducer; |
| |
| Injector(Producer<Context> context, Producer<Handler> handlerProducer, |
| Producer<IncrementalManager> incrementalManagerProducer, |
| Producer<PackageManagerInternal> packageManagerInternalProducer) { |
| mContext = context; |
| mHandlerProducer = handlerProducer; |
| mIncrementalManagerProducer = incrementalManagerProducer; |
| mPackageManagerInternalProducer = packageManagerInternalProducer; |
| } |
| |
| public Context getContext() { |
| return mContext.produce(); |
| } |
| |
| public Handler getHandler() { |
| return mHandlerProducer.produce(); |
| } |
| |
| public IncrementalManager getIncrementalManager() { |
| return mIncrementalManagerProducer.produce(); |
| } |
| |
| public PackageManagerInternal getPackageManagerInternal() { |
| return mPackageManagerInternalProducer.produce(); |
| } |
| } |
| |
| /** |
| * Return the digests path associated with the given code path |
| * (replaces '.apk' extension with '.digests') |
| * |
| * @throws IllegalArgumentException if the code path is not an .apk. |
| */ |
| public static String buildDigestsPathForApk(String codePath) { |
| if (!ApkLiteParseUtils.isApkPath(codePath)) { |
| throw new IllegalStateException("Code path is not an apk " + codePath); |
| } |
| return codePath.substring(0, codePath.length() - APK_FILE_EXTENSION.length()) |
| + DIGESTS_FILE_EXTENSION; |
| } |
| |
| /** |
| * Return the signature path associated with the given digests path. |
| * (appends '.signature' to the end) |
| */ |
| public static String buildSignaturePathForDigests(String digestsPath) { |
| return digestsPath + DIGESTS_SIGNATURE_FILE_EXTENSION; |
| } |
| |
| /** Returns true if the given file looks like containing digests or digests' signature. */ |
| public static boolean isDigestOrDigestSignatureFile(File file) { |
| final String name = file.getName(); |
| return name.endsWith(DIGESTS_FILE_EXTENSION) || name.endsWith( |
| DIGESTS_SIGNATURE_FILE_EXTENSION); |
| } |
| |
| /** |
| * Search for the digests file associated with the given target file. |
| * If it exists, the method returns the digests file; otherwise it returns null. |
| */ |
| public static File findDigestsForFile(File targetFile) { |
| String digestsPath = buildDigestsPathForApk(targetFile.getAbsolutePath()); |
| File digestsFile = new File(digestsPath); |
| return digestsFile.exists() ? digestsFile : null; |
| } |
| |
| /** |
| * Search for the signature file associated with the given digests file. |
| * If it exists, the method returns the signature file; otherwise it returns null. |
| */ |
| public static File findSignatureForDigests(File digestsFile) { |
| String signaturePath = buildSignaturePathForDigests(digestsFile.getAbsolutePath()); |
| File signatureFile = new File(signaturePath); |
| return signatureFile.exists() ? signatureFile : null; |
| } |
| |
| /** |
| * Serialize checksums to the stream in binary format. |
| */ |
| public static void writeChecksums(OutputStream os, Checksum[] checksums) |
| throws IOException { |
| try (DataOutputStream dos = new DataOutputStream(os)) { |
| for (Checksum checksum : checksums) { |
| Checksum.writeToStream(dos, checksum); |
| } |
| } |
| } |
| |
| private static Checksum[] readChecksums(File file) throws IOException { |
| try (InputStream is = new FileInputStream(file)) { |
| return readChecksums(is); |
| } |
| } |
| |
| /** |
| * Deserialize array of checksums previously stored in |
| * {@link #writeChecksums(OutputStream, Checksum[])}. |
| */ |
| public static Checksum[] readChecksums(InputStream is) throws IOException { |
| try (DataInputStream dis = new DataInputStream(is)) { |
| ArrayList<Checksum> checksums = new ArrayList<>(); |
| try { |
| // 100 is an arbitrary very big number. We should stop at EOF. |
| for (int i = 0; i < 100; ++i) { |
| checksums.add(Checksum.readFromStream(dis)); |
| } |
| } catch (EOFException e) { |
| // expected |
| } |
| return checksums.toArray(new Checksum[checksums.size()]); |
| } |
| } |
| |
| /** |
| * Verifies signature over binary serialized checksums. |
| * @param checksums array of checksums |
| * @param signature detached PKCS7 signature in DER format |
| * @return all certificates that passed verification |
| * @throws SignatureException if verification fails |
| */ |
| public static @NonNull Certificate[] verifySignature(Checksum[] checksums, byte[] signature) |
| throws NoSuchAlgorithmException, IOException, SignatureException { |
| if (signature == null || signature.length > MAX_SIGNATURE_SIZE_BYTES) { |
| throw new SignatureException("Invalid signature"); |
| } |
| |
| final byte[] blob; |
| try (ByteArrayOutputStream os = new ByteArrayOutputStream()) { |
| writeChecksums(os, checksums); |
| blob = os.toByteArray(); |
| } |
| |
| PKCS7 pkcs7 = new PKCS7(signature); |
| |
| final Certificate[] certs = pkcs7.getCertificates(); |
| if (certs == null || certs.length == 0) { |
| throw new SignatureException("Signature missing certificates"); |
| } |
| |
| final SignerInfo[] signerInfos = pkcs7.verify(blob); |
| if (signerInfos == null || signerInfos.length == 0) { |
| throw new SignatureException("Verification failed"); |
| } |
| |
| ArrayList<Certificate> certificates = new ArrayList<>(signerInfos.length); |
| for (SignerInfo signerInfo : signerInfos) { |
| ArrayList<X509Certificate> chain = signerInfo.getCertificateChain(pkcs7); |
| if (chain == null) { |
| throw new SignatureException( |
| "Verification passed, but certification chain is empty."); |
| } |
| certificates.addAll(chain); |
| } |
| |
| return certificates.toArray(new Certificate[certificates.size()]); |
| } |
| |
| /** |
| * Fetch or calculate checksums for the collection of files. |
| * |
| * @param filesToChecksum split name, null for base and File to fetch checksums for |
| * @param optional mask to fetch readily available checksums |
| * @param required mask to forcefully calculate if not available |
| * @param installerPackageName package name of the installer of the packages |
| * @param trustedInstallers array of certificate to trust, two specific cases: |
| * null - trust anybody, |
| * [] - trust nobody. |
| * @param onChecksumsReadyListener to receive the resulting checksums |
| */ |
| public static void getChecksums(List<Pair<String, File>> filesToChecksum, |
| @Checksum.TypeMask int optional, |
| @Checksum.TypeMask int required, |
| @Nullable String installerPackageName, |
| @Nullable Certificate[] trustedInstallers, |
| @NonNull IOnChecksumsReadyListener onChecksumsReadyListener, |
| @NonNull Injector injector) { |
| List<Map<Integer, ApkChecksum>> result = new ArrayList<>(filesToChecksum.size()); |
| for (int i = 0, size = filesToChecksum.size(); i < size; ++i) { |
| final String split = filesToChecksum.get(i).first; |
| final File file = filesToChecksum.get(i).second; |
| Map<Integer, ApkChecksum> checksums = new ArrayMap<>(); |
| result.add(checksums); |
| |
| try { |
| getAvailableApkChecksums(split, file, optional | required, installerPackageName, |
| trustedInstallers, checksums, injector); |
| } catch (Throwable e) { |
| Slog.e(TAG, "Preferred checksum calculation error", e); |
| } |
| } |
| |
| long startTime = SystemClock.uptimeMillis(); |
| processRequiredChecksums(filesToChecksum, result, required, onChecksumsReadyListener, |
| injector, startTime); |
| } |
| |
| private static void processRequiredChecksums(List<Pair<String, File>> filesToChecksum, |
| List<Map<Integer, ApkChecksum>> result, |
| @Checksum.TypeMask int required, |
| @NonNull IOnChecksumsReadyListener onChecksumsReadyListener, |
| @NonNull Injector injector, |
| long startTime) { |
| final boolean timeout = |
| SystemClock.uptimeMillis() - startTime >= PROCESS_REQUIRED_CHECKSUMS_TIMEOUT_MILLIS; |
| List<ApkChecksum> allChecksums = new ArrayList<>(); |
| for (int i = 0, size = filesToChecksum.size(); i < size; ++i) { |
| final String split = filesToChecksum.get(i).first; |
| final File file = filesToChecksum.get(i).second; |
| Map<Integer, ApkChecksum> checksums = result.get(i); |
| |
| try { |
| if (!timeout || required != 0) { |
| if (needToWait(file, required, checksums, injector)) { |
| // Not ready, come back later. |
| injector.getHandler().postDelayed(() -> { |
| processRequiredChecksums(filesToChecksum, result, required, |
| onChecksumsReadyListener, injector, startTime); |
| }, PROCESS_REQUIRED_CHECKSUMS_DELAY_MILLIS); |
| return; |
| } |
| |
| getRequiredApkChecksums(split, file, required, checksums); |
| } |
| allChecksums.addAll(checksums.values()); |
| } catch (Throwable e) { |
| Slog.e(TAG, "Required checksum calculation error", e); |
| } |
| } |
| |
| try { |
| onChecksumsReadyListener.onChecksumsReady(allChecksums); |
| } catch (RemoteException e) { |
| Slog.w(TAG, e); |
| } |
| } |
| |
| /** |
| * Fetch readily available checksums - enforced by kernel or provided by Installer. |
| * |
| * @param split split name, null for base |
| * @param file to fetch checksums for |
| * @param types mask to fetch checksums |
| * @param installerPackageName package name of the installer of the packages |
| * @param trustedInstallers array of certificate to trust, two specific cases: |
| * null - trust anybody, |
| * [] - trust nobody. |
| * @param checksums resulting checksums |
| */ |
| private static void getAvailableApkChecksums(String split, File file, |
| @Checksum.TypeMask int types, |
| @Nullable String installerPackageName, |
| @Nullable Certificate[] trustedInstallers, |
| Map<Integer, ApkChecksum> checksums, |
| @NonNull Injector injector) { |
| if (!file.exists()) { |
| return; |
| } |
| final String filePath = file.getAbsolutePath(); |
| |
| // Always available: FSI or IncFs. |
| if (isRequired(TYPE_WHOLE_MERKLE_ROOT_4K_SHA256, types, checksums)) { |
| // Hashes in fs-verity and IncFS are always verified. |
| ApkChecksum checksum = extractHashFromFS(split, filePath); |
| if (checksum != null) { |
| checksums.put(checksum.getType(), checksum); |
| } |
| } |
| |
| // System enforced: v2/v3. |
| if (isRequired(TYPE_PARTIAL_MERKLE_ROOT_1M_SHA256, types, checksums) || isRequired( |
| TYPE_PARTIAL_MERKLE_ROOT_1M_SHA512, types, checksums)) { |
| Map<Integer, ApkChecksum> v2v3checksums = extractHashFromV2V3Signature( |
| split, filePath, types); |
| if (v2v3checksums != null) { |
| checksums.putAll(v2v3checksums); |
| } |
| } |
| |
| // Note: this compares installer and system digests internally and |
| // has to be called right after all system digests are populated. |
| getInstallerChecksums(split, file, types, installerPackageName, trustedInstallers, |
| checksums, injector); |
| } |
| |
| private static void getInstallerChecksums(String split, File file, |
| @Checksum.TypeMask int types, |
| @Nullable String installerPackageName, |
| @Nullable Certificate[] trustedInstallers, |
| Map<Integer, ApkChecksum> checksums, |
| @NonNull Injector injector) { |
| if (PackageManagerServiceUtils.isInstalledByAdb(installerPackageName)) { |
| return; |
| } |
| if (trustedInstallers != null && trustedInstallers.length == 0) { |
| return; |
| } |
| |
| final File digestsFile = findDigestsForFile(file); |
| if (digestsFile == null) { |
| return; |
| } |
| final File signatureFile = findSignatureForDigests(digestsFile); |
| |
| try { |
| final Checksum[] digests = readChecksums(digestsFile); |
| final Signature[] certs; |
| final Signature[] pastCerts; |
| |
| if (signatureFile != null) { |
| final Certificate[] certificates = verifySignature(digests, |
| Files.readAllBytes(signatureFile.toPath())); |
| if (certificates == null || certificates.length == 0) { |
| Slog.e(TAG, "Error validating signature"); |
| return; |
| } |
| |
| certs = new Signature[certificates.length]; |
| for (int i = 0, size = certificates.length; i < size; i++) { |
| certs[i] = new Signature(certificates[i].getEncoded()); |
| } |
| |
| pastCerts = null; |
| } else { |
| final AndroidPackage installer = injector.getPackageManagerInternal().getPackage( |
| installerPackageName); |
| if (installer == null) { |
| Slog.e(TAG, "Installer package not found."); |
| return; |
| } |
| |
| // Obtaining array of certificates used for signing the installer package. |
| certs = installer.getSigningDetails().getSignatures(); |
| pastCerts = installer.getSigningDetails().getPastSigningCertificates(); |
| } |
| if (certs == null || certs.length == 0 || certs[0] == null) { |
| Slog.e(TAG, "Can't obtain certificates."); |
| return; |
| } |
| |
| // According to V2/V3 signing schema, the first certificate corresponds to the public |
| // key in the signing block. |
| byte[] trustedCertBytes = certs[0].toByteArray(); |
| |
| final Set<Signature> trusted = convertToSet(trustedInstallers); |
| |
| if (trusted != null && !trusted.isEmpty()) { |
| // Obtaining array of certificates used for signing the installer package. |
| Signature trustedCert = isTrusted(certs, trusted); |
| if (trustedCert == null) { |
| trustedCert = isTrusted(pastCerts, trusted); |
| } |
| if (trustedCert == null) { |
| return; |
| } |
| trustedCertBytes = trustedCert.toByteArray(); |
| } |
| |
| // Compare OS-enforced digests. |
| for (Checksum digest : digests) { |
| final ApkChecksum system = checksums.get(digest.getType()); |
| if (system != null && !Arrays.equals(system.getValue(), digest.getValue())) { |
| throw new InvalidParameterException("System digest " + digest.getType() |
| + " mismatch, can't bind installer-provided digests to the APK."); |
| } |
| } |
| |
| // Append missing digests. |
| for (Checksum digest : digests) { |
| if (isRequired(digest.getType(), types, checksums)) { |
| checksums.put(digest.getType(), |
| new ApkChecksum(split, digest, installerPackageName, trustedCertBytes)); |
| } |
| } |
| } catch (IOException e) { |
| Slog.e(TAG, "Error reading .digests or .signature", e); |
| } catch (NoSuchAlgorithmException | SignatureException | InvalidParameterException e) { |
| Slog.e(TAG, "Error validating digests. Invalid digests will be removed", e); |
| try { |
| Files.deleteIfExists(digestsFile.toPath()); |
| if (signatureFile != null) { |
| Files.deleteIfExists(signatureFile.toPath()); |
| } |
| } catch (IOException ignored) { |
| } |
| } catch (CertificateEncodingException e) { |
| Slog.e(TAG, "Error encoding trustedInstallers", e); |
| } |
| } |
| |
| /** |
| * Whether the file is available for checksumming or we need to wait. |
| */ |
| private static boolean needToWait(File file, |
| @Checksum.TypeMask int types, |
| Map<Integer, ApkChecksum> checksums, |
| @NonNull Injector injector) throws IOException { |
| if (!isRequired(TYPE_WHOLE_MERKLE_ROOT_4K_SHA256, types, checksums) |
| && !isRequired(TYPE_WHOLE_MD5, types, checksums) |
| && !isRequired(TYPE_WHOLE_SHA1, types, checksums) |
| && !isRequired(TYPE_WHOLE_SHA256, types, checksums) |
| && !isRequired(TYPE_WHOLE_SHA512, types, checksums) |
| && !isRequired(TYPE_PARTIAL_MERKLE_ROOT_1M_SHA256, types, checksums) |
| && !isRequired(TYPE_PARTIAL_MERKLE_ROOT_1M_SHA512, types, checksums)) { |
| return false; |
| } |
| |
| final String filePath = file.getAbsolutePath(); |
| if (!IncrementalManager.isIncrementalPath(filePath)) { |
| return false; |
| } |
| |
| IncrementalManager manager = injector.getIncrementalManager(); |
| if (manager == null) { |
| Slog.e(TAG, "IncrementalManager is missing."); |
| return false; |
| } |
| IncrementalStorage storage = manager.openStorage(filePath); |
| if (storage == null) { |
| Slog.e(TAG, "IncrementalStorage is missing for a path on IncFs: " + filePath); |
| return false; |
| } |
| |
| return !storage.isFileFullyLoaded(filePath); |
| } |
| |
| /** |
| * Fetch or calculate checksums for the specific file. |
| * |
| * @param split split name, null for base |
| * @param file to fetch checksums for |
| * @param types mask to forcefully calculate if not available |
| * @param checksums resulting checksums |
| */ |
| private static void getRequiredApkChecksums(String split, File file, |
| @Checksum.TypeMask int types, |
| Map<Integer, ApkChecksum> checksums) { |
| final String filePath = file.getAbsolutePath(); |
| |
| // Manually calculating required checksums if not readily available. |
| if (isRequired(TYPE_WHOLE_MERKLE_ROOT_4K_SHA256, types, checksums)) { |
| try { |
| byte[] generatedRootHash = VerityBuilder.generateFsVerityRootHash( |
| filePath, /*salt=*/null, |
| new ByteBufferFactory() { |
| @Override |
| public ByteBuffer create(int capacity) { |
| return ByteBuffer.allocate(capacity); |
| } |
| }); |
| checksums.put(TYPE_WHOLE_MERKLE_ROOT_4K_SHA256, |
| new ApkChecksum(split, TYPE_WHOLE_MERKLE_ROOT_4K_SHA256, |
| verityHashForFile(file, generatedRootHash))); |
| } catch (IOException | NoSuchAlgorithmException | DigestException e) { |
| Slog.e(TAG, "Error calculating WHOLE_MERKLE_ROOT_4K_SHA256", e); |
| } |
| } |
| |
| calculateChecksumIfRequested(checksums, split, file, types, TYPE_WHOLE_MD5); |
| calculateChecksumIfRequested(checksums, split, file, types, TYPE_WHOLE_SHA1); |
| calculateChecksumIfRequested(checksums, split, file, types, TYPE_WHOLE_SHA256); |
| calculateChecksumIfRequested(checksums, split, file, types, TYPE_WHOLE_SHA512); |
| |
| calculatePartialChecksumsIfRequested(checksums, split, file, types); |
| } |
| |
| private static boolean isRequired(@Checksum.Type int type, |
| @Checksum.TypeMask int types, Map<Integer, ApkChecksum> checksums) { |
| if ((types & type) == 0) { |
| return false; |
| } |
| if (checksums.containsKey(type)) { |
| return false; |
| } |
| return true; |
| } |
| |
| /** |
| * Signature class provides a fast way to compare certificates using their hashes. |
| * The hash is exactly the same as in X509/Certificate. |
| */ |
| private static Set<Signature> convertToSet(@Nullable Certificate[] array) throws |
| CertificateEncodingException { |
| if (array == null) { |
| return null; |
| } |
| final Set<Signature> set = new ArraySet<>(array.length); |
| for (Certificate item : array) { |
| set.add(new Signature(item.getEncoded())); |
| } |
| return set; |
| } |
| |
| private static Signature isTrusted(Signature[] signatures, Set<Signature> trusted) { |
| if (signatures == null) { |
| return null; |
| } |
| for (Signature signature : signatures) { |
| if (trusted.contains(signature)) { |
| return signature; |
| } |
| } |
| return null; |
| } |
| |
| private static ApkChecksum extractHashFromFS(String split, String filePath) { |
| // verity first |
| if (VerityUtils.hasFsverity(filePath)) { |
| byte[] verityHash = VerityUtils.getFsverityDigest(filePath); |
| if (verityHash != null) { |
| return new ApkChecksum(split, TYPE_WHOLE_MERKLE_ROOT_4K_SHA256, verityHash); |
| } |
| } |
| // v4 next |
| try { |
| ApkSignatureSchemeV4Verifier.VerifiedSigner signer = |
| ApkSignatureSchemeV4Verifier.extractCertificates(filePath); |
| byte[] rootHash = signer.contentDigests.getOrDefault( |
| CONTENT_DIGEST_VERITY_CHUNKED_SHA256, null); |
| if (rootHash != null) { |
| return new ApkChecksum(split, TYPE_WHOLE_MERKLE_ROOT_4K_SHA256, |
| verityHashForFile(new File(filePath), rootHash)); |
| } |
| } catch (SignatureNotFoundException e) { |
| // Nothing |
| } catch (SignatureException | SecurityException e) { |
| Slog.e(TAG, "V4 signature error", e); |
| } |
| return null; |
| } |
| |
| /** |
| * Returns fs-verity digest as described in |
| * https://www.kernel.org/doc/html/latest/filesystems/fsverity.html#fs-verity-descriptor |
| * @param file the Merkle tree is built over |
| * @param rootHash Merkle tree root hash |
| */ |
| static byte[] verityHashForFile(File file, byte[] rootHash) { |
| try { |
| ByteBuffer buffer = ByteBuffer.allocate(256); // sizeof(fsverity_descriptor) |
| buffer.order(ByteOrder.LITTLE_ENDIAN); |
| buffer.put((byte) 1); // __u8 version, must be 1 |
| buffer.put((byte) 1); // __u8 hash_algorithm, FS_VERITY_HASH_ALG_SHA256 |
| buffer.put((byte) 12); // __u8, FS_VERITY_LOG_BLOCKSIZE |
| buffer.put((byte) 0); // __u8, size of salt in bytes; 0 if none |
| buffer.putInt(0); // __le32 __reserved_0x04, must be 0 |
| buffer.putLong(file.length()); // __le64 data_size |
| buffer.put(rootHash); // root_hash, first 32 bytes |
| final int padding = 32 + 32 + 144; // root_hash, last 32 bytes, we are using sha256. |
| // salt, 32 bytes |
| // reserved, 144 bytes |
| for (int i = 0; i < padding; ++i) { |
| buffer.put((byte) 0); |
| } |
| |
| buffer.flip(); |
| |
| final MessageDigest md = MessageDigest.getInstance(ALGO_SHA256); |
| md.update(buffer); |
| return md.digest(); |
| } catch (NoSuchAlgorithmException e) { |
| Slog.e(TAG, "Device does not support MessageDigest algorithm", e); |
| return null; |
| } |
| } |
| |
| private static Map<Integer, ApkChecksum> extractHashFromV2V3Signature( |
| String split, String filePath, int types) { |
| Map<Integer, byte[]> contentDigests = null; |
| final ParseTypeImpl input = ParseTypeImpl.forDefaultParsing(); |
| final ParseResult<ApkSignatureVerifier.SigningDetailsWithDigests> result = |
| ApkSignatureVerifier.verifySignaturesInternal(input, filePath, |
| SignatureSchemeVersion.SIGNING_BLOCK_V2, false /*verifyFull*/); |
| if (result.isError()) { |
| if (!(result.getException() instanceof SignatureNotFoundException)) { |
| Slog.e(TAG, "Signature verification error", result.getException()); |
| } |
| } else { |
| contentDigests = result.getResult().contentDigests; |
| } |
| |
| if (contentDigests == null) { |
| return null; |
| } |
| |
| Map<Integer, ApkChecksum> checksums = new ArrayMap<>(); |
| if ((types & TYPE_PARTIAL_MERKLE_ROOT_1M_SHA256) != 0) { |
| byte[] hash = contentDigests.getOrDefault(CONTENT_DIGEST_CHUNKED_SHA256, null); |
| if (hash != null) { |
| checksums.put(TYPE_PARTIAL_MERKLE_ROOT_1M_SHA256, |
| new ApkChecksum(split, TYPE_PARTIAL_MERKLE_ROOT_1M_SHA256, hash)); |
| } |
| } |
| if ((types & TYPE_PARTIAL_MERKLE_ROOT_1M_SHA512) != 0) { |
| byte[] hash = contentDigests.getOrDefault(CONTENT_DIGEST_CHUNKED_SHA512, null); |
| if (hash != null) { |
| checksums.put(TYPE_PARTIAL_MERKLE_ROOT_1M_SHA512, |
| new ApkChecksum(split, TYPE_PARTIAL_MERKLE_ROOT_1M_SHA512, hash)); |
| } |
| } |
| return checksums; |
| } |
| |
| private static String getMessageDigestAlgoForChecksumKind(int type) |
| throws NoSuchAlgorithmException { |
| switch (type) { |
| case TYPE_WHOLE_MD5: |
| return ALGO_MD5; |
| case TYPE_WHOLE_SHA1: |
| return ALGO_SHA1; |
| case TYPE_WHOLE_SHA256: |
| return ALGO_SHA256; |
| case TYPE_WHOLE_SHA512: |
| return ALGO_SHA512; |
| default: |
| throw new NoSuchAlgorithmException("Invalid checksum type: " + type); |
| } |
| } |
| |
| private static void calculateChecksumIfRequested(Map<Integer, ApkChecksum> checksums, |
| String split, File file, int required, int type) { |
| if ((required & type) != 0 && !checksums.containsKey(type)) { |
| final byte[] checksum = getApkChecksum(file, type); |
| if (checksum != null) { |
| checksums.put(type, new ApkChecksum(split, type, checksum)); |
| } |
| } |
| } |
| |
| static final int MIN_BUFFER_SIZE = 4 * 1024; |
| static final int MAX_BUFFER_SIZE = 128 * 1024; |
| |
| private static byte[] getApkChecksum(File file, int type) { |
| final int bufferSize = (int) Math.max(MIN_BUFFER_SIZE, |
| Math.min(MAX_BUFFER_SIZE, file.length())); |
| try (FileInputStream fis = new FileInputStream(file)) { |
| final byte[] buffer = new byte[bufferSize]; |
| int nread = 0; |
| |
| final String algo = getMessageDigestAlgoForChecksumKind(type); |
| MessageDigest md = MessageDigest.getInstance(algo); |
| while ((nread = fis.read(buffer)) != -1) { |
| md.update(buffer, 0, nread); |
| } |
| |
| return md.digest(); |
| } catch (IOException e) { |
| Slog.e(TAG, "Error reading " + file.getAbsolutePath() + " to compute hash.", e); |
| return null; |
| } catch (NoSuchAlgorithmException e) { |
| Slog.e(TAG, "Device does not support MessageDigest algorithm", e); |
| return null; |
| } |
| } |
| |
| private static int[] getContentDigestAlgos(boolean needSignatureSha256, |
| boolean needSignatureSha512) { |
| if (needSignatureSha256 && needSignatureSha512) { |
| // Signature block present, but no digests??? |
| return new int[]{CONTENT_DIGEST_CHUNKED_SHA256, CONTENT_DIGEST_CHUNKED_SHA512}; |
| } else if (needSignatureSha256) { |
| return new int[]{CONTENT_DIGEST_CHUNKED_SHA256}; |
| } else { |
| return new int[]{CONTENT_DIGEST_CHUNKED_SHA512}; |
| } |
| } |
| |
| private static int getChecksumKindForContentDigestAlgo(int contentDigestAlgo) { |
| switch (contentDigestAlgo) { |
| case CONTENT_DIGEST_CHUNKED_SHA256: |
| return TYPE_PARTIAL_MERKLE_ROOT_1M_SHA256; |
| case CONTENT_DIGEST_CHUNKED_SHA512: |
| return TYPE_PARTIAL_MERKLE_ROOT_1M_SHA512; |
| default: |
| return -1; |
| } |
| } |
| |
| private static void calculatePartialChecksumsIfRequested(Map<Integer, ApkChecksum> checksums, |
| String split, File file, int required) { |
| boolean needSignatureSha256 = |
| (required & TYPE_PARTIAL_MERKLE_ROOT_1M_SHA256) != 0 && !checksums.containsKey( |
| TYPE_PARTIAL_MERKLE_ROOT_1M_SHA256); |
| boolean needSignatureSha512 = |
| (required & TYPE_PARTIAL_MERKLE_ROOT_1M_SHA512) != 0 && !checksums.containsKey( |
| TYPE_PARTIAL_MERKLE_ROOT_1M_SHA512); |
| if (!needSignatureSha256 && !needSignatureSha512) { |
| return; |
| } |
| |
| try (RandomAccessFile raf = new RandomAccessFile(file, "r")) { |
| SignatureInfo signatureInfo = null; |
| try { |
| signatureInfo = ApkSignatureSchemeV3Verifier.findSignature(raf); |
| } catch (SignatureNotFoundException e) { |
| try { |
| signatureInfo = ApkSignatureSchemeV2Verifier.findSignature(raf); |
| } catch (SignatureNotFoundException ee) { |
| } |
| } |
| if (signatureInfo == null) { |
| Slog.e(TAG, "V2/V3 signatures not found in " + file.getAbsolutePath()); |
| return; |
| } |
| |
| final int[] digestAlgos = getContentDigestAlgos(needSignatureSha256, |
| needSignatureSha512); |
| byte[][] digests = ApkSigningBlockUtils.computeContentDigestsPer1MbChunk(digestAlgos, |
| raf.getFD(), signatureInfo); |
| for (int i = 0, size = digestAlgos.length; i < size; ++i) { |
| int checksumKind = getChecksumKindForContentDigestAlgo(digestAlgos[i]); |
| if (checksumKind != -1) { |
| checksums.put(checksumKind, new ApkChecksum(split, checksumKind, digests[i])); |
| } |
| } |
| } catch (IOException | DigestException e) { |
| Slog.e(TAG, "Error computing hash.", e); |
| } |
| } |
| } |
