Add decompiled APK source code (JADX)

- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/androidx/credentials/provider/CallingAppInfo.java

@@ -0,0 +1,309 @@
+package androidx.credentials.provider;
+
+import android.content.pm.Signature;
+import android.content.pm.SigningInfo;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Parcelable;
+import androidx.annotation.DeprecatedSinceApi;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+import androidx.annotation.VisibleForTesting;
+import androidx.credentials.provider.utils.PrivilegedApp;
+import androidx.credentials.provider.utils.RequestValidationUtil;
+import com.facebook.internal.security.CertificateUtil;
+import java.security.MessageDigest;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import kotlin.collections.ArraysKt___ArraysKt;
+import kotlin.collections.CollectionsKt__CollectionsJVMKt;
+import kotlin.collections.CollectionsKt___CollectionsKt;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+@SourceDebugExtension({"SMAP\nCallingAppInfo.kt\nKotlin\n*S Kotlin\n*F\n+ 1 CallingAppInfo.kt\nandroidx/credentials/provider/CallingAppInfo\n+ 2 fake.kt\nkotlin/jvm/internal/FakeKt\n*L\n1#1,339:1\n1#2:340\n*E\n"})
+/* loaded from: classes.dex */
+public final class CallingAppInfo {
+    public static final Companion Companion = new Companion(null);
+    public static final String EXTRA_CREDENTIAL_REQUEST_ORIGIN = "androidx.credentials.provider.extra.CREDENTIAL_REQUEST_ORIGIN";
+    private static final String EXTRA_CREDENTIAL_REQUEST_PACKAGE_NAME = "androidx.credentials.provider.extra.CREDENTIAL_REQUEST_PACKAGE_NAME";
+    private static final String EXTRA_CREDENTIAL_REQUEST_SIGNATURES = "androidx.credentials.provider.extra.CREDENTIAL_REQUEST_SIGNATURES";
+    private static final String EXTRA_CREDENTIAL_REQUEST_SIGNING_INFO = "androidx.credentials.provider.extra.CREDENTIAL_REQUEST_SIGNING_INFO";
+    private final String origin;
+    private final String packageName;
+    private SigningInfo signingInfo;
+    private final SigningInfoCompat signingInfoCompat;
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    @RequiresApi(28)
+    @VisibleForTesting
+    public CallingAppInfo(String packageName, SigningInfo signingInfo) {
+        this(packageName, signingInfo, (String) null, 4, (DefaultConstructorMarker) null);
+        Intrinsics.checkNotNullParameter(packageName, "packageName");
+        Intrinsics.checkNotNullParameter(signingInfo, "signingInfo");
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    @DeprecatedSinceApi(api = 28, message = "Use the SigningInfo based constructor instead")
+    @VisibleForTesting
+    public CallingAppInfo(String packageName, List<? extends Signature> signatures) {
+        this(packageName, signatures, (String) null, 4, (DefaultConstructorMarker) null);
+        Intrinsics.checkNotNullParameter(packageName, "packageName");
+        Intrinsics.checkNotNullParameter(signatures, "signatures");
+    }
+
+    public final String getOrigin$credentials_release() {
+        return this.origin;
+    }
+
+    public final String getPackageName() {
+        return this.packageName;
+    }
+
+    public final SigningInfoCompat getSigningInfoCompat() {
+        return this.signingInfoCompat;
+    }
+
+    public final boolean isOriginPopulated() {
+        return this.origin != null;
+    }
+
+    private CallingAppInfo(String str, String str2, SigningInfoCompat signingInfoCompat, SigningInfo signingInfo) {
+        this.packageName = str;
+        this.origin = str2;
+        this.signingInfoCompat = signingInfoCompat;
+        if (Build.VERSION.SDK_INT >= 28) {
+            Intrinsics.checkNotNull(signingInfo);
+            this.signingInfo = signingInfo;
+        }
+        if (str.length() <= 0) {
+            throw new IllegalArgumentException("packageName must not be empty".toString());
+        }
+    }
+
+    @RequiresApi(28)
+    public final SigningInfo getSigningInfo() {
+        SigningInfo signingInfo = this.signingInfo;
+        if (signingInfo != null) {
+            return signingInfo;
+        }
+        Intrinsics.throwUninitializedPropertyAccessException("signingInfo");
+        return null;
+    }
+
+    public /* synthetic */ CallingAppInfo(String str, SigningInfo signingInfo, String str2, int i, DefaultConstructorMarker defaultConstructorMarker) {
+        this(str, signingInfo, (i & 4) != 0 ? null : str2);
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    @RequiresApi(28)
+    @VisibleForTesting
+    public CallingAppInfo(String packageName, SigningInfo signingInfo, String str) {
+        this(packageName, str, SigningInfoCompat.Companion.fromSigningInfo(signingInfo), signingInfo);
+        Intrinsics.checkNotNullParameter(packageName, "packageName");
+        Intrinsics.checkNotNullParameter(signingInfo, "signingInfo");
+    }
+
+    public /* synthetic */ CallingAppInfo(String str, List list, String str2, int i, DefaultConstructorMarker defaultConstructorMarker) {
+        this(str, (List<? extends Signature>) list, (i & 4) != 0 ? null : str2);
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    @DeprecatedSinceApi(api = 28, message = "Use the SigningInfo based constructor instead")
+    @VisibleForTesting
+    public CallingAppInfo(String packageName, List<? extends Signature> signatures, String str) {
+        this(packageName, str, SigningInfoCompat.Companion.fromSignatures(signatures), null);
+        Intrinsics.checkNotNullParameter(packageName, "packageName");
+        Intrinsics.checkNotNullParameter(signatures, "signatures");
+    }
+
+    @SourceDebugExtension({"SMAP\nCallingAppInfo.kt\nKotlin\n*S Kotlin\n*F\n+ 1 CallingAppInfo.kt\nandroidx/credentials/provider/CallingAppInfo$Companion\n+ 2 ArraysJVM.kt\nkotlin/collections/ArraysKt__ArraysJVMKt\n+ 3 _Arrays.kt\nkotlin/collections/ArraysKt___ArraysKt\n*L\n1#1,339:1\n37#2,2:340\n11335#3:342\n11670#3,3:343\n*S KotlinDebug\n*F\n+ 1 CallingAppInfo.kt\nandroidx/credentials/provider/CallingAppInfo$Companion\n*L\n161#1:340,2\n178#1:342\n178#1:343,3\n*E\n"})
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        public static /* synthetic */ CallingAppInfo create$default(Companion companion, String str, SigningInfo signingInfo, String str2, int i, Object obj) {
+            if ((i & 4) != 0) {
+                str2 = null;
+            }
+            return companion.create(str, signingInfo, str2);
+        }
+
+        @RequiresApi(28)
+        @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+        public final CallingAppInfo create(String packageName, SigningInfo signingInfo, String str) {
+            Intrinsics.checkNotNullParameter(packageName, "packageName");
+            Intrinsics.checkNotNullParameter(signingInfo, "signingInfo");
+            return new CallingAppInfo(packageName, signingInfo, str);
+        }
+
+        public static /* synthetic */ CallingAppInfo create$default(Companion companion, String str, List list, String str2, int i, Object obj) {
+            if ((i & 4) != 0) {
+                str2 = null;
+            }
+            return companion.create(str, (List<? extends Signature>) list, str2);
+        }
+
+        @DeprecatedSinceApi(api = 28, message = "Use the SigningInfo based constructor instead")
+        @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+        public final CallingAppInfo create(String packageName, List<? extends Signature> signatures, String str) {
+            Intrinsics.checkNotNullParameter(packageName, "packageName");
+            Intrinsics.checkNotNullParameter(signatures, "signatures");
+            return new CallingAppInfo(packageName, signatures, str);
+        }
+
+        public final void setCallingAppInfo$credentials_release(Bundle bundle, CallingAppInfo info) {
+            Intrinsics.checkNotNullParameter(bundle, "<this>");
+            Intrinsics.checkNotNullParameter(info, "info");
+            bundle.putString(CallingAppInfo.EXTRA_CREDENTIAL_REQUEST_ORIGIN, info.getOrigin$credentials_release());
+            bundle.putString(CallingAppInfo.EXTRA_CREDENTIAL_REQUEST_PACKAGE_NAME, info.getPackageName());
+            if (Build.VERSION.SDK_INT >= 28) {
+                bundle.putParcelable(CallingAppInfo.EXTRA_CREDENTIAL_REQUEST_SIGNING_INFO, info.getSigningInfo());
+            } else {
+                bundle.putParcelableArray(CallingAppInfo.EXTRA_CREDENTIAL_REQUEST_SIGNATURES, (Parcelable[]) info.getSigningInfoCompat().getSigningCertificateHistory().toArray(new Signature[0]));
+            }
+        }
+
+        public final CallingAppInfo extractCallingAppInfo$credentials_release(Bundle bundle) {
+            Intrinsics.checkNotNullParameter(bundle, "bundle");
+            String string = bundle.getString(CallingAppInfo.EXTRA_CREDENTIAL_REQUEST_ORIGIN);
+            String string2 = bundle.getString(CallingAppInfo.EXTRA_CREDENTIAL_REQUEST_PACKAGE_NAME);
+            if (string2 == null) {
+                return null;
+            }
+            if (Build.VERSION.SDK_INT >= 28) {
+                SigningInfo m = CallingAppInfo$Companion$$ExternalSyntheticApiModelOutline0.m(bundle.getParcelable(CallingAppInfo.EXTRA_CREDENTIAL_REQUEST_SIGNING_INFO));
+                if (m == null) {
+                    return null;
+                }
+                return create(string2, m, string);
+            }
+            Parcelable[] parcelableArray = bundle.getParcelableArray(CallingAppInfo.EXTRA_CREDENTIAL_REQUEST_SIGNATURES);
+            if (parcelableArray == null) {
+                return null;
+            }
+            ArrayList arrayList = new ArrayList(parcelableArray.length);
+            for (Parcelable parcelable : parcelableArray) {
+                Intrinsics.checkNotNull(parcelable, "null cannot be cast to non-null type android.content.pm.Signature");
+                arrayList.add((Signature) parcelable);
+            }
+            return create(string2, arrayList, string);
+        }
+    }
+
+    public final String getOrigin(String privilegedAllowlist) {
+        Intrinsics.checkNotNullParameter(privilegedAllowlist, "privilegedAllowlist");
+        if (!RequestValidationUtil.Companion.isValidJSON(privilegedAllowlist)) {
+            throw new IllegalArgumentException("privilegedAllowlist must not be empty, and must be a valid JSON");
+        }
+        String str = this.origin;
+        if (str == null) {
+            return str;
+        }
+        try {
+            if (isAppPrivileged(PrivilegedApp.Companion.extractPrivilegedApps$credentials_release(new JSONObject(privilegedAllowlist)))) {
+                return this.origin;
+            }
+            throw new IllegalStateException("Origin is not being returned as the calling app did notmatch the privileged allowlist");
+        } catch (JSONException unused) {
+            throw new IllegalArgumentException("privilegedAllowlist must be formatted properly");
+        }
+    }
+
+    private final boolean isAppPrivileged(List<PrivilegedApp> list) {
+        for (PrivilegedApp privilegedApp : list) {
+            if (Intrinsics.areEqual(privilegedApp.getPackageName(), this.packageName)) {
+                return isAppPrivileged(privilegedApp.getFingerprints());
+            }
+        }
+        return false;
+    }
+
+    private final boolean isAppPrivileged(Set<String> set) {
+        return new SignatureVerifier(this.signingInfoCompat).verifySignatureFingerprints(set);
+    }
+
+    public static final class SignatureVerifier {
+        private final SigningInfoCompat signingInfoCompat;
+
+        public SignatureVerifier(SigningInfoCompat signingInfoCompat) {
+            Intrinsics.checkNotNullParameter(signingInfoCompat, "signingInfoCompat");
+            this.signingInfoCompat = signingInfoCompat;
+        }
+
+        private final Set<String> getSignatureFingerprints() {
+            LinkedHashSet linkedHashSet = new LinkedHashSet();
+            List<Signature> apkContentsSigners = this.signingInfoCompat.getApkContentsSigners();
+            if (this.signingInfoCompat.hasMultipleSigners() && (!apkContentsSigners.isEmpty())) {
+                linkedHashSet.addAll(convertToFingerprints(apkContentsSigners));
+            } else if (!this.signingInfoCompat.getSigningCertificateHistory().isEmpty()) {
+                linkedHashSet.addAll(convertToFingerprints(CollectionsKt__CollectionsJVMKt.listOf(this.signingInfoCompat.getSigningCertificateHistory().get(0))));
+            }
+            return linkedHashSet;
+        }
+
+        private final Set<String> convertToFingerprints(List<? extends Signature> list) {
+            String joinToString$default;
+            LinkedHashSet linkedHashSet = new LinkedHashSet();
+            Iterator<? extends Signature> it = list.iterator();
+            while (it.hasNext()) {
+                byte[] digest = MessageDigest.getInstance("SHA-256").digest(it.next().toByteArray());
+                Intrinsics.checkNotNullExpressionValue(digest, "digest");
+                joinToString$default = ArraysKt___ArraysKt.joinToString$default(digest, CertificateUtil.DELIMITER, (CharSequence) null, (CharSequence) null, 0, (CharSequence) null, new Function1() { // from class: androidx.credentials.provider.CallingAppInfo$SignatureVerifier$convertToFingerprints$1
+                    public final CharSequence invoke(byte b) {
+                        String format = String.format("%02X", Arrays.copyOf(new Object[]{Byte.valueOf(b)}, 1));
+                        Intrinsics.checkNotNullExpressionValue(format, "format(this, *args)");
+                        return format;
+                    }
+
+                    @Override // kotlin.jvm.functions.Function1
+                    public /* bridge */ /* synthetic */ Object invoke(Object obj) {
+                        return invoke(((Number) obj).byteValue());
+                    }
+                }, 30, (Object) null);
+                linkedHashSet.add(joinToString$default);
+            }
+            return linkedHashSet;
+        }
+
+        public final boolean verifySignatureFingerprints(Set<String> candidateSigFingerprints) {
+            Set intersect;
+            Intrinsics.checkNotNullParameter(candidateSigFingerprints, "candidateSigFingerprints");
+            Set<String> signatureFingerprints = getSignatureFingerprints();
+            if (this.signingInfoCompat.hasMultipleSigners()) {
+                return candidateSigFingerprints.containsAll(signatureFingerprints);
+            }
+            intersect = CollectionsKt___CollectionsKt.intersect(candidateSigFingerprints, signatureFingerprints);
+            return !intersect.isEmpty();
+        }
+    }
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof CallingAppInfo)) {
+            return false;
+        }
+        CallingAppInfo callingAppInfo = (CallingAppInfo) obj;
+        return Intrinsics.areEqual(this.packageName, callingAppInfo.packageName) && Intrinsics.areEqual(this.origin, callingAppInfo.origin) && Intrinsics.areEqual(this.signingInfoCompat, callingAppInfo.signingInfoCompat);
+    }
+
+    public int hashCode() {
+        int hashCode = this.packageName.hashCode() * 31;
+        String str = this.origin;
+        return ((hashCode + (str != null ? str.hashCode() : 0)) * 31) + this.signingInfoCompat.hashCode();
+    }
+}