| /* |
| * Copyright (C) 2021 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 android.content.pm; |
| |
| import android.annotation.IntDef; |
| import android.annotation.NonNull; |
| import android.annotation.Nullable; |
| import android.os.Parcel; |
| import android.os.Parcelable; |
| import android.text.TextUtils; |
| import android.util.ArraySet; |
| import android.util.PackageUtils; |
| import android.util.Slog; |
| |
| import com.android.internal.annotations.VisibleForTesting; |
| import com.android.internal.util.DataClass; |
| |
| import libcore.util.HexEncoding; |
| |
| import java.lang.annotation.Retention; |
| import java.lang.annotation.RetentionPolicy; |
| import java.security.PublicKey; |
| import java.security.cert.CertificateException; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collections; |
| import java.util.List; |
| import java.util.Set; |
| |
| /** |
| * A container for signing-related data of an application package. |
| * |
| * @hide |
| */ |
| @DataClass(genConstructor = false, genConstDefs = false, genParcelable = true, genAidl = false) |
| public final class SigningDetails implements Parcelable { |
| |
| private static final String TAG = "SigningDetails"; |
| |
| @Retention(RetentionPolicy.SOURCE) |
| @IntDef({SignatureSchemeVersion.UNKNOWN, |
| SignatureSchemeVersion.JAR, |
| SignatureSchemeVersion.SIGNING_BLOCK_V2, |
| SignatureSchemeVersion.SIGNING_BLOCK_V3, |
| SignatureSchemeVersion.SIGNING_BLOCK_V4}) |
| public @interface SignatureSchemeVersion { |
| int UNKNOWN = 0; |
| int JAR = 1; |
| int SIGNING_BLOCK_V2 = 2; |
| int SIGNING_BLOCK_V3 = 3; |
| int SIGNING_BLOCK_V4 = 4; |
| } |
| |
| /** The signing certificates associated with this application package. */ |
| private final @Nullable Signature[] mSignatures; |
| |
| /** The signature scheme version for this application package. */ |
| private final @SignatureSchemeVersion int mSignatureSchemeVersion; |
| |
| /** The public keys set for the certificates. */ |
| private final @Nullable ArraySet<PublicKey> mPublicKeys; |
| |
| /** |
| * APK Signature Scheme v3 includes support for adding a proof-of-rotation record that |
| * contains two pieces of information: |
| * 1) the past signing certificates |
| * 2) the flags that APK wants to assign to each of the past signing certificates. |
| * |
| * This collection of {@code Signature} objects, each of which is formed from a former |
| * signing certificate of this APK before it was changed by signing certificate rotation, |
| * represents the first piece of information. It is the APK saying to the rest of the |
| * world: "hey if you trust the old cert, you can trust me!" This is useful, if for |
| * instance, the platform would like to determine whether or not to allow this APK to do |
| * something it would've allowed it to do under the old cert (like upgrade). |
| */ |
| private final @Nullable Signature[] mPastSigningCertificates; |
| |
| /** special value used to see if cert is in package - not exposed to callers */ |
| private static final int PAST_CERT_EXISTS = 0; |
| |
| @IntDef(flag = true, |
| value = {CertCapabilities.INSTALLED_DATA, |
| CertCapabilities.SHARED_USER_ID, |
| CertCapabilities.PERMISSION, |
| CertCapabilities.ROLLBACK}) |
| public @interface CertCapabilities { |
| |
| /** accept data from already installed pkg with this cert */ |
| int INSTALLED_DATA = 1; |
| |
| /** accept sharedUserId with pkg with this cert */ |
| int SHARED_USER_ID = 2; |
| |
| /** grant SIGNATURE permissions to pkgs with this cert */ |
| int PERMISSION = 4; |
| |
| /** allow pkg to update to one signed by this certificate */ |
| int ROLLBACK = 8; |
| |
| /** allow pkg to continue to have auth access gated by this cert */ |
| int AUTH = 16; |
| } |
| |
| @IntDef(value = {CapabilityMergeRule.MERGE_SELF_CAPABILITY, |
| CapabilityMergeRule.MERGE_OTHER_CAPABILITY, |
| CapabilityMergeRule.MERGE_RESTRICTED_CAPABILITY}) |
| public @interface CapabilityMergeRule { |
| /** |
| * When capabilities are different for a common signer in the lineage, use the capabilities |
| * from this instance. |
| */ |
| int MERGE_SELF_CAPABILITY = 0; |
| |
| /** |
| * When capabilities are different for a common signer in the lineage, use the capabilites |
| * from the other instance. |
| */ |
| int MERGE_OTHER_CAPABILITY = 1; |
| |
| /** |
| * When capabilities are different for a common signer in the lineage, use the most |
| * restrictive between the two signers. |
| */ |
| int MERGE_RESTRICTED_CAPABILITY = 2; |
| } |
| |
| /** A representation of unknown signing details. Use instead of null. */ |
| public static final SigningDetails UNKNOWN = new SigningDetails(/* signatures */ null, |
| SignatureSchemeVersion.UNKNOWN, /* keys */ null, /* pastSigningCertificates */ null); |
| |
| @VisibleForTesting |
| public SigningDetails(@Nullable Signature[] signatures, |
| @SignatureSchemeVersion int signatureSchemeVersion, |
| @Nullable ArraySet<PublicKey> keys, @Nullable Signature[] pastSigningCertificates) { |
| mSignatures = signatures; |
| mSignatureSchemeVersion = signatureSchemeVersion; |
| mPublicKeys = keys; |
| mPastSigningCertificates = pastSigningCertificates; |
| } |
| |
| public SigningDetails(@Nullable Signature[] signatures, |
| @SignatureSchemeVersion int signatureSchemeVersion, |
| @Nullable Signature[] pastSigningCertificates) |
| throws CertificateException { |
| this(signatures, signatureSchemeVersion, toSigningKeys(signatures), |
| pastSigningCertificates); |
| } |
| |
| public SigningDetails(@Nullable Signature[] signatures, |
| @SignatureSchemeVersion int signatureSchemeVersion) |
| throws CertificateException { |
| this(signatures, signatureSchemeVersion, /* pastSigningCertificates */ null); |
| } |
| |
| public SigningDetails(@Nullable SigningDetails orig) { |
| if (orig != null) { |
| if (orig.mSignatures != null) { |
| mSignatures = orig.mSignatures.clone(); |
| } else { |
| mSignatures = null; |
| } |
| mSignatureSchemeVersion = orig.mSignatureSchemeVersion; |
| mPublicKeys = new ArraySet<>(orig.mPublicKeys); |
| if (orig.mPastSigningCertificates != null) { |
| mPastSigningCertificates = orig.mPastSigningCertificates.clone(); |
| } else { |
| mPastSigningCertificates = null; |
| } |
| } else { |
| mSignatures = null; |
| mSignatureSchemeVersion = SignatureSchemeVersion.UNKNOWN; |
| mPublicKeys = null; |
| mPastSigningCertificates = null; |
| } |
| } |
| |
| /** |
| * Merges the signing lineage of this instance with the lineage in the provided {@code |
| * otherSigningDetails} using {@link CapabilityMergeRule#MERGE_OTHER_CAPABILITY} as the merge |
| * rule. |
| * |
| * @param otherSigningDetails the {@code SigningDetails} with which to merge |
| * @return Merged {@code SigningDetails} instance when one has the same or an ancestor signer |
| * of the other. If neither instance has a lineage, or if neither has the same or an |
| * ancestor signer then this instance is returned. |
| * @see #mergeLineageWith(SigningDetails, int) |
| */ |
| public @NonNull SigningDetails mergeLineageWith(@NonNull SigningDetails otherSigningDetails) { |
| return mergeLineageWith(otherSigningDetails, CapabilityMergeRule.MERGE_OTHER_CAPABILITY); |
| } |
| |
| /** |
| * Merges the signing lineage of this instance with the lineage in the provided {@code |
| * otherSigningDetails} when one has the same or an ancestor signer of the other using the |
| * provided {@code mergeRule} to handle differences in capabilities for shared signers. |
| * |
| * <p>Merging two signing lineages will result in a new {@code SigningDetails} instance |
| * containing the longest common lineage with differences in capabilities for shared signers |
| * resolved using the provided {@code mergeRule}. If the two lineages contain the same signers |
| * with the same capabilities then the instance on which this was invoked is returned without |
| * any changes. Similarly if neither instance has a lineage, or if neither has the same or an |
| * ancestor signer then this instance is returned. |
| * |
| * Following are some example results of this method for lineages with signers A, B, C, D: |
| * <ul> |
| * <li>lineage B merged with lineage A -> B returns lineage A -> B. |
| * <li>lineage A -> B merged with lineage B -> C returns lineage A -> B -> C |
| * <li>lineage A -> B with the {@code PERMISSION} capability revoked for A merged with |
| * lineage A -> B with the {@code SHARED_USER_ID} capability revoked for A returns the |
| * following based on the {@code mergeRule}: |
| * <ul> |
| * <li>{@code MERGE_SELF_CAPABILITY} - lineage A -> B with {@code PERMISSION} revoked |
| * for A. |
| * <li>{@code MERGE_OTHER_CAPABILITY} - lineage A -> B with {@code SHARED_USER_ID} |
| * revoked for A. |
| * <li>{@code MERGE_RESTRICTED_CAPABILITY} - lineage A -> B with {@code PERMISSION} and |
| * {@code SHARED_USER_ID} revoked for A. |
| * </ul> |
| * <li>lineage A -> B -> C merged with lineage A -> B -> D would return the original lineage |
| * A -> B -> C since the current signer of both instances is not the same or in the |
| * lineage of the other. |
| * </ul> |
| * |
| * @param otherSigningDetails the {@code SigningDetails} with which to merge |
| * @param mergeRule the {@link CapabilityMergeRule} to use when resolving differences in |
| * capabilities for shared signers |
| * @return Merged {@code SigningDetails} instance when one has the same or an ancestor signer |
| * of the other. If neither instance has a lineage, or if neither has the same or an |
| * ancestor signer then this instance is returned. |
| */ |
| public @NonNull SigningDetails mergeLineageWith(@NonNull SigningDetails otherSigningDetails, |
| @CapabilityMergeRule int mergeRule) { |
| if (!hasPastSigningCertificates()) { |
| return otherSigningDetails.hasPastSigningCertificates() |
| && otherSigningDetails.hasAncestorOrSelf(this) ? otherSigningDetails : this; |
| } |
| if (!otherSigningDetails.hasPastSigningCertificates()) { |
| return this; |
| } |
| // Use the utility method to determine which SigningDetails instance is the descendant |
| // and to confirm that the signing lineage does not diverge. |
| SigningDetails descendantSigningDetails = getDescendantOrSelf(otherSigningDetails); |
| if (descendantSigningDetails == null) { |
| return this; |
| } |
| SigningDetails mergedDetails = this; |
| if (descendantSigningDetails == this) { |
| // If this instance is the descendant then the merge will also be invoked against this |
| // instance and the provided mergeRule can be used as is. |
| mergedDetails = mergeLineageWithAncestorOrSelf(otherSigningDetails, mergeRule); |
| } else { |
| // If the provided instance is the descendant then the merge will be invoked against the |
| // other instance and a self or other merge rule will need to be flipped. |
| switch (mergeRule) { |
| case CapabilityMergeRule.MERGE_SELF_CAPABILITY: |
| mergedDetails = otherSigningDetails.mergeLineageWithAncestorOrSelf(this, |
| CapabilityMergeRule.MERGE_OTHER_CAPABILITY); |
| break; |
| case CapabilityMergeRule.MERGE_OTHER_CAPABILITY: |
| mergedDetails = otherSigningDetails.mergeLineageWithAncestorOrSelf(this, |
| CapabilityMergeRule.MERGE_SELF_CAPABILITY); |
| break; |
| case CapabilityMergeRule.MERGE_RESTRICTED_CAPABILITY: |
| mergedDetails = otherSigningDetails.mergeLineageWithAncestorOrSelf(this, |
| mergeRule); |
| break; |
| } |
| } |
| return mergedDetails; |
| } |
| |
| /** |
| * Merges the signing lineage of this instance with the lineage of the ancestor (or same) |
| * signer in the provided {@code otherSigningDetails}. |
| * |
| * @param otherSigningDetails the {@code SigningDetails} with which to merge |
| * @param mergeRule the {@link CapabilityMergeRule} to use when resolving differences in |
| * capabilities for shared signers |
| * @return Merged {@code SigningDetails} instance. |
| */ |
| private @NonNull SigningDetails mergeLineageWithAncestorOrSelf( |
| @NonNull SigningDetails otherSigningDetails, @CapabilityMergeRule int mergeRule) { |
| // This method should only be called with instances that contain lineages. |
| int index = mPastSigningCertificates.length - 1; |
| int otherIndex = otherSigningDetails.mPastSigningCertificates.length - 1; |
| if (index < 0 || otherIndex < 0) { |
| return this; |
| } |
| |
| List<Signature> mergedSignatures = new ArrayList<>(); |
| boolean capabilitiesModified = false; |
| // If this is a descendant lineage then add all of the descendant signer(s) to the |
| // merged lineage until the ancestor signer is reached. |
| while (index >= 0 && !mPastSigningCertificates[index].equals( |
| otherSigningDetails.mPastSigningCertificates[otherIndex])) { |
| mergedSignatures.add(new Signature(mPastSigningCertificates[index--])); |
| } |
| // If the signing lineage was exhausted then the provided ancestor is not actually an |
| // ancestor of this lineage. |
| if (index < 0) { |
| return this; |
| } |
| |
| do { |
| // Add the common signer to the merged lineage and resolve any differences in |
| // capabilites with the merge rule. |
| Signature signature = mPastSigningCertificates[index--]; |
| Signature ancestorSignature = |
| otherSigningDetails.mPastSigningCertificates[otherIndex--]; |
| Signature mergedSignature = new Signature(signature); |
| if (signature.getFlags() != ancestorSignature.getFlags()) { |
| capabilitiesModified = true; |
| switch (mergeRule) { |
| case CapabilityMergeRule.MERGE_SELF_CAPABILITY: |
| mergedSignature.setFlags(signature.getFlags()); |
| break; |
| case CapabilityMergeRule.MERGE_OTHER_CAPABILITY: |
| mergedSignature.setFlags(ancestorSignature.getFlags()); |
| break; |
| case CapabilityMergeRule.MERGE_RESTRICTED_CAPABILITY: |
| mergedSignature.setFlags( |
| signature.getFlags() & ancestorSignature.getFlags()); |
| break; |
| } |
| } |
| mergedSignatures.add(mergedSignature); |
| } while (index >= 0 && otherIndex >= 0 && mPastSigningCertificates[index].equals( |
| otherSigningDetails.mPastSigningCertificates[otherIndex])); |
| |
| // If both lineages still have elements then their lineages have diverged; since this is |
| // not supported return the invoking instance. |
| if (index >= 0 && otherIndex >= 0) { |
| return this; |
| } |
| |
| // Add any remaining elements from either lineage that is not yet exhausted to the |
| // the merged lineage. |
| while (otherIndex >= 0) { |
| mergedSignatures.add(new Signature( |
| otherSigningDetails.mPastSigningCertificates[otherIndex--])); |
| } |
| while (index >= 0) { |
| mergedSignatures.add(new Signature(mPastSigningCertificates[index--])); |
| } |
| |
| // if this lineage already contains all the elements in the ancestor and none of the |
| // capabilities were changed then just return this instance. |
| if (mergedSignatures.size() == mPastSigningCertificates.length |
| && !capabilitiesModified) { |
| return this; |
| } |
| // Since the signatures were added to the merged lineage from newest to oldest reverse |
| // the list to ensure the oldest signer is at index 0. |
| Collections.reverse(mergedSignatures); |
| try { |
| return new SigningDetails(new Signature[]{new Signature(mSignatures[0])}, |
| mSignatureSchemeVersion, mergedSignatures.toArray(new Signature[0])); |
| } catch (CertificateException e) { |
| Slog.e(TAG, "Caught an exception creating the merged lineage: ", e); |
| return this; |
| } |
| } |
| |
| /** |
| * Returns whether this and the provided {@code otherSigningDetails} share a common |
| * ancestor. |
| * |
| * <p>The two SigningDetails have a common ancestor if any of the following conditions are |
| * met: |
| * - If neither has a lineage and their current signer(s) are equal. |
| * - If only one has a lineage and the signer of the other is the same or in the lineage. |
| * - If both have a lineage and their current signers are the same or one is in the lineage |
| * of the other, and their lineages do not diverge to different signers. |
| */ |
| public boolean hasCommonAncestor(@NonNull SigningDetails otherSigningDetails) { |
| if (!hasPastSigningCertificates()) { |
| // If this instance does not have a lineage then it must either be in the ancestry |
| // of or the same signer of the otherSigningDetails. |
| return otherSigningDetails.hasAncestorOrSelf(this); |
| } |
| if (!otherSigningDetails.hasPastSigningCertificates()) { |
| return hasAncestorOrSelf(otherSigningDetails); |
| } |
| // If both have a lineage then use getDescendantOrSelf to obtain the descendant signing |
| // details; a null return from that method indicates there is no common lineage between |
| // the two or that they diverge at a point in the lineage. |
| return getDescendantOrSelf(otherSigningDetails) != null; |
| } |
| |
| /** |
| * Returns whether this instance is currently signed, or has ever been signed, with a |
| * signing certificate from the provided {@link Set} of {@code certDigests}. |
| * |
| * <p>The provided {@code certDigests} should contain the SHA-256 digest of the DER encoding |
| * of each trusted certificate with the digest characters in upper case. If this instance |
| * has multiple signers then all signers must be in the provided {@code Set}. If this |
| * instance has a signing lineage then this method will return true if any of the previous |
| * signers in the lineage match one of the entries in the {@code Set}. |
| */ |
| public boolean hasAncestorOrSelfWithDigest(@Nullable Set<String> certDigests) { |
| if (this == UNKNOWN || certDigests == null || certDigests.size() == 0) { |
| return false; |
| } |
| // If an app is signed by multiple signers then all of the signers must be in the Set. |
| if (mSignatures.length > 1) { |
| // If the Set has less elements than the number of signatures then immediately |
| // return false as there's no way to satisfy the requirement of all signatures being |
| // in the Set. |
| if (certDigests.size() < mSignatures.length) { |
| return false; |
| } |
| for (Signature signature : mSignatures) { |
| String signatureDigest = PackageUtils.computeSha256Digest( |
| signature.toByteArray()); |
| if (!certDigests.contains(signatureDigest)) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| String signatureDigest = PackageUtils.computeSha256Digest(mSignatures[0].toByteArray()); |
| if (certDigests.contains(signatureDigest)) { |
| return true; |
| } |
| if (hasPastSigningCertificates()) { |
| // The last element in the pastSigningCertificates array is the current signer; |
| // since that was verified above just check all the signers in the lineage. |
| for (int i = 0; i < mPastSigningCertificates.length - 1; i++) { |
| signatureDigest = PackageUtils.computeSha256Digest( |
| mPastSigningCertificates[i].toByteArray()); |
| if (certDigests.contains(signatureDigest)) { |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Returns the SigningDetails with a descendant (or same) signer after verifying the |
| * descendant has the same, a superset, or a subset of the lineage of the ancestor. |
| * |
| * <p>If this instance and the provided {@code otherSigningDetails} do not share an |
| * ancestry, or if their lineages diverge then null is returned to indicate there is no |
| * valid descendant SigningDetails. |
| */ |
| private @Nullable SigningDetails getDescendantOrSelf( |
| @NonNull SigningDetails otherSigningDetails) { |
| final SigningDetails descendantSigningDetails; |
| final SigningDetails ancestorSigningDetails; |
| if (hasAncestorOrSelf(otherSigningDetails)) { |
| // If the otherSigningDetails has the same signer or a signer in the lineage of this |
| // instance then treat this instance as the descendant. |
| descendantSigningDetails = this; |
| ancestorSigningDetails = otherSigningDetails; |
| } else if (otherSigningDetails.hasAncestor(this)) { |
| // The above check confirmed that the two instances do not have the same signer and |
| // the signer of otherSigningDetails is not in this instance's lineage; if this |
| // signer is in the otherSigningDetails lineage then treat this as the ancestor. |
| descendantSigningDetails = otherSigningDetails; |
| ancestorSigningDetails = this; |
| } else { |
| // The signers are not the same and neither has the current signer of the other in |
| // its lineage; return null to indicate there is no descendant signer. |
| return null; |
| } |
| // Once the descent (or same) signer is identified iterate through the ancestry until |
| // the current signer of the ancestor is found. |
| int descendantIndex = descendantSigningDetails.mPastSigningCertificates.length - 1; |
| int ancestorIndex = ancestorSigningDetails.mPastSigningCertificates.length - 1; |
| while (descendantIndex >= 0 |
| && !descendantSigningDetails.mPastSigningCertificates[descendantIndex].equals( |
| ancestorSigningDetails.mPastSigningCertificates[ancestorIndex])) { |
| descendantIndex--; |
| } |
| // Since the ancestry was verified above the descendant lineage should never be |
| // exhausted, but if for some reason the ancestor signer is not found then return null. |
| if (descendantIndex < 0) { |
| return null; |
| } |
| // Once the common ancestor (or same) signer is found iterate over the lineage of both |
| // to ensure that they are either the same or one is a subset of the other. |
| do { |
| descendantIndex--; |
| ancestorIndex--; |
| } while (descendantIndex >= 0 && ancestorIndex >= 0 |
| && descendantSigningDetails.mPastSigningCertificates[descendantIndex].equals( |
| ancestorSigningDetails.mPastSigningCertificates[ancestorIndex])); |
| |
| // If both lineages still have elements then they diverge and cannot be considered a |
| // valid common lineage. |
| if (descendantIndex >= 0 && ancestorIndex >= 0) { |
| return null; |
| } |
| // Since one or both of the lineages was exhausted they are either the same or one is a |
| // subset of the other; return the valid descendant. |
| return descendantSigningDetails; |
| } |
| |
| /** Returns true if the signing details have one or more signatures. */ |
| public boolean hasSignatures() { |
| return mSignatures != null && mSignatures.length > 0; |
| } |
| |
| /** Returns true if the signing details have past signing certificates. */ |
| public boolean hasPastSigningCertificates() { |
| return mPastSigningCertificates != null && mPastSigningCertificates.length > 0; |
| } |
| |
| /** |
| * Determines if the provided {@code oldDetails} is an ancestor of or the same as this one. |
| * If the {@code oldDetails} signing certificate appears in our pastSigningCertificates, |
| * then that means it has authorized a signing certificate rotation, which eventually leads |
| * to our certificate, and thus can be trusted. If this method evaluates to true, this |
| * SigningDetails object should be trusted if the previous one is. |
| */ |
| public boolean hasAncestorOrSelf(@NonNull SigningDetails oldDetails) { |
| if (this == UNKNOWN || oldDetails == UNKNOWN) { |
| return false; |
| } |
| if (oldDetails.mSignatures.length > 1) { |
| // multiple-signer packages cannot rotate signing certs, so we just compare current |
| // signers for an exact match |
| return signaturesMatchExactly(oldDetails); |
| } else { |
| // we may have signing certificate rotation history, check to see if the oldDetails |
| // was one of our old signing certificates |
| return hasCertificate(oldDetails.mSignatures[0]); |
| } |
| } |
| |
| /** |
| * Similar to {@code hasAncestorOrSelf}. Returns true only if this {@code SigningDetails} |
| * is a descendant of {@code oldDetails}, not if they're the same. This is used to |
| * determine if this object is newer than the provided one. |
| */ |
| public boolean hasAncestor(@NonNull SigningDetails oldDetails) { |
| if (this == UNKNOWN || oldDetails == UNKNOWN) { |
| return false; |
| } |
| if (hasPastSigningCertificates() && oldDetails.mSignatures.length == 1) { |
| // the last entry in pastSigningCertificates is the current signer, ignore it |
| for (int i = 0; i < mPastSigningCertificates.length - 1; i++) { |
| if (mPastSigningCertificates[i].equals(oldDetails.mSignatures[0])) { |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Returns whether this {@code SigningDetails} has a signer in common with the provided |
| * {@code otherDetails} with the specified {@code flags} capabilities provided by this |
| * signer. |
| * |
| * <p>Note this method allows for the signing lineage to diverge, so this should only be |
| * used for instances where the only requirement is a common signer in the lineage with |
| * the specified capabilities. If the current signer of this instance is an ancestor of |
| * {@code otherDetails} then {@code true} is immediately returned since the current signer |
| * has all capabilities granted. |
| */ |
| public boolean hasCommonSignerWithCapability(@NonNull SigningDetails otherDetails, |
| @CertCapabilities int flags) { |
| if (this == UNKNOWN || otherDetails == UNKNOWN) { |
| return false; |
| } |
| // If either is signed with more than one signer then both must be signed by the same |
| // signers to consider the capabilities granted. |
| if (mSignatures.length > 1 || otherDetails.mSignatures.length > 1) { |
| return signaturesMatchExactly(otherDetails); |
| } |
| // The Signature class does not use the granted capabilities in the hashCode |
| // computation, so a Set can be used to check for a common signer. |
| Set<Signature> otherSignatures = new ArraySet<>(); |
| if (otherDetails.hasPastSigningCertificates()) { |
| otherSignatures.addAll(Arrays.asList(otherDetails.mPastSigningCertificates)); |
| } else { |
| otherSignatures.addAll(Arrays.asList(otherDetails.mSignatures)); |
| } |
| // If the current signer of this instance is an ancestor of the other than return true |
| // since all capabilities are granted to the current signer. |
| if (otherSignatures.contains(mSignatures[0])) { |
| return true; |
| } |
| if (hasPastSigningCertificates()) { |
| // Since the current signer was checked above and the last signature in the |
| // pastSigningCertificates is the current signer skip checking the last element. |
| for (int i = 0; i < mPastSigningCertificates.length - 1; i++) { |
| if (otherSignatures.contains(mPastSigningCertificates[i])) { |
| // If the caller specified multiple capabilities ensure all are set. |
| if ((mPastSigningCertificates[i].getFlags() & flags) == flags) { |
| return true; |
| } |
| } |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Determines if the provided {@code oldDetails} is an ancestor of this one, and whether or |
| * not this one grants it the provided capability, represented by the {@code flags} |
| * parameter. In the event of signing certificate rotation, a package may still interact |
| * with entities signed by its old signing certificate and not want to break previously |
| * functioning behavior. The {@code flags} value determines which capabilities the app |
| * signed by the newer signing certificate would like to continue to give to its previous |
| * signing certificate(s). |
| */ |
| public boolean checkCapability(@NonNull SigningDetails oldDetails, |
| @CertCapabilities int flags) { |
| if (this == UNKNOWN || oldDetails == UNKNOWN) { |
| return false; |
| } |
| if (oldDetails.mSignatures.length > 1) { |
| // multiple-signer packages cannot rotate signing certs, so we must have an exact |
| // match, which also means all capabilities are granted |
| return signaturesMatchExactly(oldDetails); |
| } else { |
| // we may have signing certificate rotation history, check to see if the oldDetails |
| // was one of our old signing certificates, and if we grant it the capability it's |
| // requesting |
| return hasCertificate(oldDetails.mSignatures[0], flags); |
| } |
| } |
| |
| /** |
| * A special case of {@code checkCapability} which re-encodes both sets of signing |
| * certificates to counteract a previous re-encoding. |
| */ |
| public boolean checkCapabilityRecover(@NonNull SigningDetails oldDetails, |
| @CertCapabilities int flags) throws CertificateException { |
| if (oldDetails == UNKNOWN || this == UNKNOWN) { |
| return false; |
| } |
| if (hasPastSigningCertificates() && oldDetails.mSignatures.length == 1) { |
| // signing certificates may have rotated, check entire history for effective match |
| for (int i = 0; i < mPastSigningCertificates.length; i++) { |
| if (Signature.areEffectiveMatch( |
| oldDetails.mSignatures[0], |
| mPastSigningCertificates[i]) |
| && mPastSigningCertificates[i].getFlags() == flags) { |
| return true; |
| } |
| } |
| } else { |
| return Signature.areEffectiveMatch(oldDetails, this); |
| } |
| return false; |
| } |
| |
| /** |
| * Determine if {@code signature} is in this SigningDetails' signing certificate history, |
| * including the current signer. Automatically returns false if this object has multiple |
| * signing certificates, since rotation is only supported for single-signers; this is |
| * enforced by {@code hasCertificateInternal}. |
| */ |
| public boolean hasCertificate(@NonNull Signature signature) { |
| return hasCertificateInternal(signature, PAST_CERT_EXISTS); |
| } |
| |
| /** |
| * Determine if {@code signature} is in this SigningDetails' signing certificate history, |
| * including the current signer, and whether or not it has the given permission. |
| * Certificates which match our current signer automatically get all capabilities. |
| * Automatically returns false if this object has multiple signing certificates, since |
| * rotation is only supported for single-signers. |
| */ |
| public boolean hasCertificate(@NonNull Signature signature, @CertCapabilities int flags) { |
| return hasCertificateInternal(signature, flags); |
| } |
| |
| /** Convenient wrapper for calling {@code hasCertificate} with certificate's raw bytes. */ |
| public boolean hasCertificate(byte[] certificate) { |
| Signature signature = new Signature(certificate); |
| return hasCertificate(signature); |
| } |
| |
| private boolean hasCertificateInternal(@NonNull Signature signature, int flags) { |
| if (this == UNKNOWN) { |
| return false; |
| } |
| |
| // only single-signed apps can have pastSigningCertificates |
| if (hasPastSigningCertificates()) { |
| // check all past certs, except for the current one, which automatically gets all |
| // capabilities, since it is the same as the current signature |
| for (int i = 0; i < mPastSigningCertificates.length - 1; i++) { |
| if (mPastSigningCertificates[i].equals(signature)) { |
| if (flags == PAST_CERT_EXISTS |
| || (flags & mPastSigningCertificates[i].getFlags()) == flags) { |
| return true; |
| } |
| } |
| } |
| } |
| |
| // not in previous certs signing history, just check the current signer and make sure |
| // we are singly-signed |
| return mSignatures.length == 1 && mSignatures[0].equals(signature); |
| } |
| |
| /** |
| * Determines if the provided {@code sha256String} is an ancestor of this one, and whether |
| * or not this one grants it the provided capability, represented by the {@code flags} |
| * parameter. In the event of signing certificate rotation, a package may still interact |
| * with entities signed by its old signing certificate and not want to break previously |
| * functioning behavior. The {@code flags} value determines which capabilities the app |
| * signed by the newer signing certificate would like to continue to give to its previous |
| * signing certificate(s). |
| * |
| * @param sha256String A hex-encoded representation of a sha256 digest. In the case of an |
| * app with multiple signers, this represents the hex-encoded sha256 |
| * digest of the combined hex-encoded sha256 digests of each individual |
| * signing certificate according to {@link |
| * PackageUtils#computeSignaturesSha256Digest(Signature[])} |
| */ |
| public boolean checkCapability(@Nullable String sha256String, @CertCapabilities int flags) { |
| if (this == UNKNOWN || TextUtils.isEmpty(sha256String)) { |
| return false; |
| } |
| |
| // first see if the hash represents a single-signer in our signing history |
| final byte[] sha256Bytes = HexEncoding.decode(sha256String, false /* allowSingleChar */); |
| if (hasSha256Certificate(sha256Bytes, flags)) { |
| return true; |
| } |
| |
| // Not in signing history, either represents multiple signatures or not a match. |
| // Multiple signers can't rotate, so no need to check flags, just see if the SHAs match. |
| // We already check the single-signer case above as part of hasSha256Certificate, so no |
| // need to verify we have multiple signers, just run the old check |
| // just consider current signing certs |
| final String[] mSignaturesSha256Digests = |
| PackageUtils.computeSignaturesSha256Digests(mSignatures); |
| final String mSignaturesSha256Digest = |
| PackageUtils.computeSignaturesSha256Digest(mSignaturesSha256Digests); |
| return mSignaturesSha256Digest.equals(sha256String); |
| } |
| |
| /** |
| * Determine if the {@code sha256Certificate} is in this SigningDetails' signing certificate |
| * history, including the current signer. Automatically returns false if this object has |
| * multiple signing certificates, since rotation is only supported for single-signers. |
| */ |
| public boolean hasSha256Certificate(byte[] sha256Certificate) { |
| return hasSha256CertificateInternal(sha256Certificate, PAST_CERT_EXISTS); |
| } |
| |
| /** |
| * Determine if the {@code sha256Certificate} certificate hash corresponds to a signing |
| * certificate in this SigningDetails' signing certificate history, including the current |
| * signer, and whether or not it has the given permission. Certificates which match our |
| * current signer automatically get all capabilities. Automatically returns false if this |
| * object has multiple signing certificates, since rotation is only supported for |
| * single-signers. |
| */ |
| public boolean hasSha256Certificate(byte[] sha256Certificate, @CertCapabilities int flags) { |
| return hasSha256CertificateInternal(sha256Certificate, flags); |
| } |
| |
| private boolean hasSha256CertificateInternal(byte[] sha256Certificate, int flags) { |
| if (this == UNKNOWN) { |
| return false; |
| } |
| if (hasPastSigningCertificates()) { |
| // check all past certs, except for the last one, which automatically gets all |
| // capabilities, since it is the same as the current signature, and is checked below |
| for (int i = 0; i < mPastSigningCertificates.length - 1; i++) { |
| byte[] digest = PackageUtils.computeSha256DigestBytes( |
| mPastSigningCertificates[i].toByteArray()); |
| if (Arrays.equals(sha256Certificate, digest)) { |
| if (flags == PAST_CERT_EXISTS |
| || (flags & mPastSigningCertificates[i].getFlags()) == flags) { |
| return true; |
| } |
| } |
| } |
| } |
| |
| // not in previous certs signing history, just check the current signer |
| if (mSignatures.length == 1) { |
| byte[] digest = PackageUtils.computeSha256DigestBytes(mSignatures[0].toByteArray()); |
| return Arrays.equals(sha256Certificate, digest); |
| } |
| return false; |
| } |
| |
| /** Returns true if the signatures in this and other match exactly. */ |
| public boolean signaturesMatchExactly(@NonNull SigningDetails other) { |
| return Signature.areExactMatch(this, other); |
| } |
| |
| @Override |
| public int describeContents() { |
| return 0; |
| } |
| |
| @Override |
| public void writeToParcel(@NonNull Parcel dest, int flags) { |
| boolean isUnknown = UNKNOWN == this; |
| dest.writeBoolean(isUnknown); |
| if (isUnknown) { |
| return; |
| } |
| dest.writeTypedArray(mSignatures, flags); |
| dest.writeInt(mSignatureSchemeVersion); |
| dest.writeArraySet(mPublicKeys); |
| dest.writeTypedArray(mPastSigningCertificates, flags); |
| } |
| |
| protected SigningDetails(@NonNull Parcel in) { |
| final ClassLoader boot = Object.class.getClassLoader(); |
| mSignatures = in.createTypedArray(Signature.CREATOR); |
| mSignatureSchemeVersion = in.readInt(); |
| mPublicKeys = (ArraySet<PublicKey>) in.readArraySet(boot); |
| mPastSigningCertificates = in.createTypedArray(Signature.CREATOR); |
| } |
| |
| public static final @NonNull Parcelable.Creator<SigningDetails> CREATOR = |
| new Creator<SigningDetails>() { |
| @Override |
| public SigningDetails createFromParcel(@NonNull Parcel source) { |
| if (source.readBoolean()) { |
| return UNKNOWN; |
| } |
| return new SigningDetails(source); |
| } |
| |
| @Override |
| public SigningDetails[] newArray(int size) { |
| return new SigningDetails[size]; |
| } |
| }; |
| |
| @Override |
| public boolean equals(@Nullable Object o) { |
| if (this == o) return true; |
| if (!(o instanceof SigningDetails)) return false; |
| |
| final SigningDetails that = (SigningDetails) o; |
| |
| if (mSignatureSchemeVersion != that.mSignatureSchemeVersion) return false; |
| if (!Signature.areExactMatch(this, that)) return false; |
| if (mPublicKeys != null) { |
| if (!mPublicKeys.equals((that.mPublicKeys))) { |
| return false; |
| } |
| } else if (that.mPublicKeys != null) { |
| return false; |
| } |
| |
| // can't use Signature.areExactMatch() because order matters with the past signing certs |
| if (!Arrays.equals(mPastSigningCertificates, that.mPastSigningCertificates)) { |
| return false; |
| } |
| // The capabilities for the past signing certs must match as well. |
| if (mPastSigningCertificates != null) { |
| for (int i = 0; i < mPastSigningCertificates.length; i++) { |
| if (mPastSigningCertificates[i].getFlags() |
| != that.mPastSigningCertificates[i].getFlags()) { |
| return false; |
| } |
| } |
| } |
| return true; |
| } |
| |
| @Override |
| public int hashCode() { |
| int result = +Arrays.hashCode(mSignatures); |
| result = 31 * result + mSignatureSchemeVersion; |
| result = 31 * result + (mPublicKeys != null ? mPublicKeys.hashCode() : 0); |
| result = 31 * result + Arrays.hashCode(mPastSigningCertificates); |
| return result; |
| } |
| |
| /** |
| * Builder of {@code SigningDetails} instances. |
| */ |
| public static class Builder { |
| private @NonNull Signature[] mSignatures; |
| private @SignatureSchemeVersion int mSignatureSchemeVersion = |
| SignatureSchemeVersion.UNKNOWN; |
| private @Nullable Signature[] mPastSigningCertificates; |
| |
| public Builder() { |
| } |
| |
| /** get signing certificates used to sign the current APK */ |
| public SigningDetails.Builder setSignatures(@NonNull Signature[] signatures) { |
| mSignatures = signatures; |
| return this; |
| } |
| |
| /** set the signature scheme version used to sign the APK */ |
| public SigningDetails.Builder setSignatureSchemeVersion( |
| @SignatureSchemeVersion int signatureSchemeVersion) { |
| mSignatureSchemeVersion = signatureSchemeVersion; |
| return this; |
| } |
| |
| /** set the signing certificates by which the APK proved it can be authenticated */ |
| public SigningDetails.Builder setPastSigningCertificates( |
| @Nullable Signature[] pastSigningCertificates) { |
| mPastSigningCertificates = pastSigningCertificates; |
| return this; |
| } |
| |
| private void checkInvariants() { |
| // must have signatures and scheme version set |
| if (mSignatures == null) { |
| throw new IllegalStateException("SigningDetails requires the current signing" |
| + " certificates."); |
| } |
| } |
| /** build a {@code SigningDetails} object */ |
| public SigningDetails build() |
| throws CertificateException { |
| checkInvariants(); |
| return new SigningDetails(mSignatures, mSignatureSchemeVersion, |
| mPastSigningCertificates); |
| } |
| } |
| |
| /** Parses the public keys from the set of signatures. */ |
| public static ArraySet<PublicKey> toSigningKeys(@NonNull Signature[] signatures) |
| throws CertificateException { |
| final ArraySet<PublicKey> keys = new ArraySet<>(signatures.length); |
| for (int i = 0; i < signatures.length; i++) { |
| keys.add(signatures[i].getPublicKey()); |
| } |
| return keys; |
| } |
| |
| |
| |
| // Code below generated by codegen v1.0.23. |
| // |
| // DO NOT MODIFY! |
| // CHECKSTYLE:OFF Generated code |
| // |
| // To regenerate run: |
| // $ codegen $ANDROID_BUILD_TOP/frameworks/base/core/java/android/content/pm/SigningDetails.java |
| // |
| // To exclude the generated code from IntelliJ auto-formatting enable (one-time): |
| // Settings > Editor > Code Style > Formatter Control |
| //@formatter:off |
| |
| |
| /** |
| * The signing certificates associated with this application package. |
| */ |
| @DataClass.Generated.Member |
| public @Nullable Signature[] getSignatures() { |
| return mSignatures; |
| } |
| |
| /** |
| * The signature scheme version for this application package. |
| */ |
| @DataClass.Generated.Member |
| public @SignatureSchemeVersion int getSignatureSchemeVersion() { |
| return mSignatureSchemeVersion; |
| } |
| |
| /** |
| * The public keys set for the certificates. |
| */ |
| @DataClass.Generated.Member |
| public @Nullable ArraySet<PublicKey> getPublicKeys() { |
| return mPublicKeys; |
| } |
| |
| /** |
| * APK Signature Scheme v3 includes support for adding a proof-of-rotation record that |
| * contains two pieces of information: |
| * 1) the past signing certificates |
| * 2) the flags that APK wants to assign to each of the past signing certificates. |
| * |
| * This collection of {@code Signature} objects, each of which is formed from a former |
| * signing certificate of this APK before it was changed by signing certificate rotation, |
| * represents the first piece of information. It is the APK saying to the rest of the |
| * world: "hey if you trust the old cert, you can trust me!" This is useful, if for |
| * instance, the platform would like to determine whether or not to allow this APK to do |
| * something it would've allowed it to do under the old cert (like upgrade). |
| */ |
| @DataClass.Generated.Member |
| public @Nullable Signature[] getPastSigningCertificates() { |
| return mPastSigningCertificates; |
| } |
| |
| @DataClass.Generated( |
| time = 1650058974710L, |
| codegenVersion = "1.0.23", |
| sourceFile = "frameworks/base/core/java/android/content/pm/SigningDetails.java", |
| inputSignatures = "private static final java.lang.String TAG\nprivate final @android.annotation.Nullable android.content.pm.Signature[] mSignatures\nprivate final @android.content.pm.SigningDetails.SignatureSchemeVersion int mSignatureSchemeVersion\nprivate final @android.annotation.Nullable android.util.ArraySet<java.security.PublicKey> mPublicKeys\nprivate final @android.annotation.Nullable android.content.pm.Signature[] mPastSigningCertificates\nprivate static final int PAST_CERT_EXISTS\npublic static final android.content.pm.SigningDetails UNKNOWN\npublic static final @android.annotation.NonNull android.os.Parcelable.Creator<android.content.pm.SigningDetails> CREATOR\npublic @android.annotation.NonNull android.content.pm.SigningDetails mergeLineageWith(android.content.pm.SigningDetails)\npublic @android.annotation.NonNull android.content.pm.SigningDetails mergeLineageWith(android.content.pm.SigningDetails,int)\nprivate @android.annotation.NonNull android.content.pm.SigningDetails mergeLineageWithAncestorOrSelf(android.content.pm.SigningDetails,int)\npublic boolean hasCommonAncestor(android.content.pm.SigningDetails)\npublic boolean hasAncestorOrSelfWithDigest(java.util.Set<java.lang.String>)\nprivate @android.annotation.Nullable android.content.pm.SigningDetails getDescendantOrSelf(android.content.pm.SigningDetails)\npublic boolean hasSignatures()\npublic boolean hasPastSigningCertificates()\npublic boolean hasAncestorOrSelf(android.content.pm.SigningDetails)\npublic boolean hasAncestor(android.content.pm.SigningDetails)\npublic boolean hasCommonSignerWithCapability(android.content.pm.SigningDetails,int)\npublic boolean checkCapability(android.content.pm.SigningDetails,int)\npublic boolean checkCapabilityRecover(android.content.pm.SigningDetails,int)\npublic boolean hasCertificate(android.content.pm.Signature)\npublic boolean hasCertificate(android.content.pm.Signature,int)\npublic boolean hasCertificate(byte[])\nprivate boolean hasCertificateInternal(android.content.pm.Signature,int)\npublic boolean checkCapability(java.lang.String,int)\npublic boolean hasSha256Certificate(byte[])\npublic boolean hasSha256Certificate(byte[],int)\nprivate boolean hasSha256CertificateInternal(byte[],int)\npublic boolean signaturesMatchExactly(android.content.pm.SigningDetails)\npublic @java.lang.Override int describeContents()\npublic @java.lang.Override void writeToParcel(android.os.Parcel,int)\npublic @java.lang.Override boolean equals(java.lang.Object)\npublic @java.lang.Override int hashCode()\npublic static android.util.ArraySet<java.security.PublicKey> toSigningKeys(android.content.pm.Signature[])\nclass SigningDetails extends java.lang.Object implements [android.os.Parcelable]\nprivate @android.annotation.NonNull android.content.pm.Signature[] mSignatures\nprivate @android.content.pm.SigningDetails.SignatureSchemeVersion int mSignatureSchemeVersion\nprivate @android.annotation.Nullable android.content.pm.Signature[] mPastSigningCertificates\npublic android.content.pm.SigningDetails.Builder setSignatures(android.content.pm.Signature[])\npublic android.content.pm.SigningDetails.Builder setSignatureSchemeVersion(int)\npublic android.content.pm.SigningDetails.Builder setPastSigningCertificates(android.content.pm.Signature[])\nprivate void checkInvariants()\npublic android.content.pm.SigningDetails build()\nclass Builder extends java.lang.Object implements []\[email protected](genConstructor=false, genConstDefs=false, genParcelable=true, genAidl=false)") |
| @Deprecated |
| private void __metadata() {} |
| |
| |
| //@formatter:on |
| // End of generated code |
| |
| } |
