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/com/mbridge/msdk/thrid/okhttp/internal/tls/BasicCertificateChainCleaner.java

@@ -0,0 +1,78 @@
+package com.mbridge.msdk.thrid.okhttp.internal.tls;
+
+import java.security.GeneralSecurityException;
+import java.security.cert.Certificate;
+import java.security.cert.X509Certificate;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import javax.net.ssl.SSLPeerUnverifiedException;
+
+/* loaded from: classes4.dex */
+public final class BasicCertificateChainCleaner extends CertificateChainCleaner {
+    private static final int MAX_SIGNERS = 9;
+    private final TrustRootIndex trustRootIndex;
+
+    public BasicCertificateChainCleaner(TrustRootIndex trustRootIndex) {
+        this.trustRootIndex = trustRootIndex;
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.tls.CertificateChainCleaner
+    public List<Certificate> clean(List<Certificate> list, String str) throws SSLPeerUnverifiedException {
+        ArrayDeque arrayDeque = new ArrayDeque(list);
+        ArrayList arrayList = new ArrayList();
+        arrayList.add(arrayDeque.removeFirst());
+        boolean z = false;
+        for (int i = 0; i < 9; i++) {
+            X509Certificate x509Certificate = (X509Certificate) arrayList.get(arrayList.size() - 1);
+            X509Certificate findByIssuerAndSignature = this.trustRootIndex.findByIssuerAndSignature(x509Certificate);
+            if (findByIssuerAndSignature != null) {
+                if (arrayList.size() > 1 || !x509Certificate.equals(findByIssuerAndSignature)) {
+                    arrayList.add(findByIssuerAndSignature);
+                }
+                if (verifySignature(findByIssuerAndSignature, findByIssuerAndSignature)) {
+                    return arrayList;
+                }
+                z = true;
+            } else {
+                Iterator it = arrayDeque.iterator();
+                while (it.hasNext()) {
+                    X509Certificate x509Certificate2 = (X509Certificate) it.next();
+                    if (verifySignature(x509Certificate, x509Certificate2)) {
+                        it.remove();
+                        arrayList.add(x509Certificate2);
+                    }
+                }
+                if (z) {
+                    return arrayList;
+                }
+                throw new SSLPeerUnverifiedException("Failed to find a trusted cert that signed " + x509Certificate);
+            }
+        }
+        throw new SSLPeerUnverifiedException("Certificate chain too long: " + arrayList);
+    }
+
+    private boolean verifySignature(X509Certificate x509Certificate, X509Certificate x509Certificate2) {
+        if (!x509Certificate.getIssuerDN().equals(x509Certificate2.getSubjectDN())) {
+            return false;
+        }
+        try {
+            x509Certificate.verify(x509Certificate2.getPublicKey());
+            return true;
+        } catch (GeneralSecurityException unused) {
+            return false;
+        }
+    }
+
+    public int hashCode() {
+        return this.trustRootIndex.hashCode();
+    }
+
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        return (obj instanceof BasicCertificateChainCleaner) && ((BasicCertificateChainCleaner) obj).trustRootIndex.equals(this.trustRootIndex);
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/tls/BasicTrustRootIndex.java

@@ -0,0 +1,52 @@
+package com.mbridge.msdk.thrid.okhttp.internal.tls;
+
+import java.security.cert.X509Certificate;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Set;
+import javax.security.auth.x500.X500Principal;
+
+/* loaded from: classes4.dex */
+public final class BasicTrustRootIndex implements TrustRootIndex {
+    private final Map<X500Principal, Set<X509Certificate>> subjectToCaCerts = new LinkedHashMap();
+
+    public BasicTrustRootIndex(X509Certificate... x509CertificateArr) {
+        for (X509Certificate x509Certificate : x509CertificateArr) {
+            X500Principal subjectX500Principal = x509Certificate.getSubjectX500Principal();
+            Set<X509Certificate> set = this.subjectToCaCerts.get(subjectX500Principal);
+            if (set == null) {
+                set = new LinkedHashSet<>(1);
+                this.subjectToCaCerts.put(subjectX500Principal, set);
+            }
+            set.add(x509Certificate);
+        }
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.tls.TrustRootIndex
+    public X509Certificate findByIssuerAndSignature(X509Certificate x509Certificate) {
+        Set<X509Certificate> set = this.subjectToCaCerts.get(x509Certificate.getIssuerX500Principal());
+        if (set == null) {
+            return null;
+        }
+        for (X509Certificate x509Certificate2 : set) {
+            try {
+                x509Certificate.verify(x509Certificate2.getPublicKey());
+                return x509Certificate2;
+            } catch (Exception unused) {
+            }
+        }
+        return null;
+    }
+
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        return (obj instanceof BasicTrustRootIndex) && ((BasicTrustRootIndex) obj).subjectToCaCerts.equals(this.subjectToCaCerts);
+    }
+
+    public int hashCode() {
+        return this.subjectToCaCerts.hashCode();
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/tls/CertificateChainCleaner.java

@@ -0,0 +1,21 @@
+package com.mbridge.msdk.thrid.okhttp.internal.tls;
+
+import com.mbridge.msdk.thrid.okhttp.internal.platform.Platform;
+import java.security.cert.Certificate;
+import java.security.cert.X509Certificate;
+import java.util.List;
+import javax.net.ssl.SSLPeerUnverifiedException;
+import javax.net.ssl.X509TrustManager;
+
+/* loaded from: classes4.dex */
+public abstract class CertificateChainCleaner {
+    public abstract List<Certificate> clean(List<Certificate> list, String str) throws SSLPeerUnverifiedException;
+
+    public static CertificateChainCleaner get(X509TrustManager x509TrustManager) {
+        return Platform.get().buildCertificateChainCleaner(x509TrustManager);
+    }
+
+    public static CertificateChainCleaner get(X509Certificate... x509CertificateArr) {
+        return new BasicCertificateChainCleaner(new BasicTrustRootIndex(x509CertificateArr));
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/tls/DistinguishedNameParser.java

@@ -0,0 +1,420 @@
+package com.mbridge.msdk.thrid.okhttp.internal.tls;
+
+import com.fyber.inneractive.sdk.bidder.TokenParametersOuterClass$TokenParameters;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.PsExtractor;
+import javax.security.auth.x500.X500Principal;
+
+/* loaded from: classes4.dex */
+final class DistinguishedNameParser {
+    private int beg;
+    private char[] chars;
+    private int cur;
+    private final String dn;
+    private int end;
+    private final int length;
+    private int pos;
+
+    public DistinguishedNameParser(X500Principal x500Principal) {
+        String name = x500Principal.getName("RFC2253");
+        this.dn = name;
+        this.length = name.length();
+    }
+
+    private String nextAT() {
+        int i;
+        int i2;
+        int i3;
+        int i4;
+        char c;
+        int i5;
+        int i6;
+        char c2;
+        char c3;
+        while (true) {
+            i = this.pos;
+            i2 = this.length;
+            if (i >= i2 || this.chars[i] != ' ') {
+                break;
+            }
+            this.pos = i + 1;
+        }
+        if (i == i2) {
+            return null;
+        }
+        this.beg = i;
+        this.pos = i + 1;
+        while (true) {
+            i3 = this.pos;
+            i4 = this.length;
+            if (i3 >= i4 || (c3 = this.chars[i3]) == '=' || c3 == ' ') {
+                break;
+            }
+            this.pos = i3 + 1;
+        }
+        if (i3 >= i4) {
+            throw new IllegalStateException("Unexpected end of DN: " + this.dn);
+        }
+        this.end = i3;
+        if (this.chars[i3] == ' ') {
+            while (true) {
+                i5 = this.pos;
+                i6 = this.length;
+                if (i5 >= i6 || (c2 = this.chars[i5]) == '=' || c2 != ' ') {
+                    break;
+                }
+                this.pos = i5 + 1;
+            }
+            if (this.chars[i5] != '=' || i5 == i6) {
+                throw new IllegalStateException("Unexpected end of DN: " + this.dn);
+            }
+        }
+        this.pos++;
+        while (true) {
+            int i7 = this.pos;
+            if (i7 >= this.length || this.chars[i7] != ' ') {
+                break;
+            }
+            this.pos = i7 + 1;
+        }
+        int i8 = this.end;
+        int i9 = this.beg;
+        if (i8 - i9 > 4) {
+            char[] cArr = this.chars;
+            if (cArr[i9 + 3] == '.' && (((c = cArr[i9]) == 'O' || c == 'o') && ((cArr[i9 + 1] == 'I' || cArr[i9 + 1] == 'i') && (cArr[i9 + 2] == 'D' || cArr[i9 + 2] == 'd')))) {
+                this.beg = i9 + 4;
+            }
+        }
+        char[] cArr2 = this.chars;
+        int i10 = this.beg;
+        return new String(cArr2, i10, i8 - i10);
+    }
+
+    private String quotedAV() {
+        int i = this.pos + 1;
+        this.pos = i;
+        this.beg = i;
+        this.end = i;
+        while (true) {
+            int i2 = this.pos;
+            if (i2 == this.length) {
+                throw new IllegalStateException("Unexpected end of DN: " + this.dn);
+            }
+            char[] cArr = this.chars;
+            char c = cArr[i2];
+            if (c == '\"') {
+                this.pos = i2 + 1;
+                while (true) {
+                    int i3 = this.pos;
+                    if (i3 >= this.length || this.chars[i3] != ' ') {
+                        break;
+                    }
+                    this.pos = i3 + 1;
+                }
+                char[] cArr2 = this.chars;
+                int i4 = this.beg;
+                return new String(cArr2, i4, this.end - i4);
+            }
+            if (c == '\\') {
+                cArr[this.end] = getEscaped();
+            } else {
+                cArr[this.end] = c;
+            }
+            this.pos++;
+            this.end++;
+        }
+    }
+
+    private String hexAV() {
+        int i;
+        char[] cArr;
+        char c;
+        int i2 = this.pos;
+        if (i2 + 4 >= this.length) {
+            throw new IllegalStateException("Unexpected end of DN: " + this.dn);
+        }
+        this.beg = i2;
+        this.pos = i2 + 1;
+        while (true) {
+            i = this.pos;
+            if (i == this.length || (c = (cArr = this.chars)[i]) == '+' || c == ',' || c == ';') {
+                break;
+            }
+            if (c == ' ') {
+                this.end = i;
+                this.pos = i + 1;
+                while (true) {
+                    int i3 = this.pos;
+                    if (i3 >= this.length || this.chars[i3] != ' ') {
+                        break;
+                    }
+                    this.pos = i3 + 1;
+                }
+            } else {
+                if (c >= 'A' && c <= 'F') {
+                    cArr[i] = (char) (c + ' ');
+                }
+                this.pos = i + 1;
+            }
+        }
+        this.end = i;
+        int i4 = this.end;
+        int i5 = this.beg;
+        int i6 = i4 - i5;
+        if (i6 < 5 || (i6 & 1) == 0) {
+            throw new IllegalStateException("Unexpected end of DN: " + this.dn);
+        }
+        int i7 = i6 / 2;
+        byte[] bArr = new byte[i7];
+        int i8 = i5 + 1;
+        for (int i9 = 0; i9 < i7; i9++) {
+            bArr[i9] = (byte) getByte(i8);
+            i8 += 2;
+        }
+        return new String(this.chars, this.beg, i6);
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:21:0x009b, code lost:
+    
+        return new java.lang.String(r1, r2, r8.cur - r2);
+     */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    private java.lang.String escapedAV() {
+        /*
+            r8 = this;
+            int r0 = r8.pos
+            r8.beg = r0
+            r8.end = r0
+        L6:
+            int r0 = r8.pos
+            int r1 = r8.length
+            if (r0 < r1) goto L19
+            java.lang.String r0 = new java.lang.String
+            char[] r1 = r8.chars
+            int r2 = r8.beg
+            int r3 = r8.end
+            int r3 = r3 - r2
+            r0.<init>(r1, r2, r3)
+            return r0
+        L19:
+            char[] r1 = r8.chars
+            char r2 = r1[r0]
+            r3 = 44
+            r4 = 43
+            r5 = 59
+            r6 = 32
+            if (r2 == r6) goto L5c
+            if (r2 == r5) goto L51
+            r5 = 92
+            if (r2 == r5) goto L3e
+            if (r2 == r4) goto L51
+            if (r2 == r3) goto L51
+            int r3 = r8.end
+            int r4 = r3 + 1
+            r8.end = r4
+            r1[r3] = r2
+            int r0 = r0 + 1
+            r8.pos = r0
+            goto L6
+        L3e:
+            int r0 = r8.end
+            int r2 = r0 + 1
+            r8.end = r2
+            char r2 = r8.getEscaped()
+            r1[r0] = r2
+            int r0 = r8.pos
+            int r0 = r0 + 1
+            r8.pos = r0
+            goto L6
+        L51:
+            java.lang.String r0 = new java.lang.String
+            int r2 = r8.beg
+            int r3 = r8.end
+            int r3 = r3 - r2
+            r0.<init>(r1, r2, r3)
+            return r0
+        L5c:
+            int r2 = r8.end
+            r8.cur = r2
+            int r0 = r0 + 1
+            r8.pos = r0
+            int r0 = r2 + 1
+            r8.end = r0
+            r1[r2] = r6
+        L6a:
+            int r0 = r8.pos
+            int r1 = r8.length
+            if (r0 >= r1) goto L83
+            char[] r2 = r8.chars
+            char r7 = r2[r0]
+            if (r7 != r6) goto L83
+            int r1 = r8.end
+            int r7 = r1 + 1
+            r8.end = r7
+            r2[r1] = r6
+            int r0 = r0 + 1
+            r8.pos = r0
+            goto L6a
+        L83:
+            if (r0 == r1) goto L8f
+            char[] r1 = r8.chars
+            char r0 = r1[r0]
+            if (r0 == r3) goto L8f
+            if (r0 == r4) goto L8f
+            if (r0 != r5) goto L6
+        L8f:
+            java.lang.String r0 = new java.lang.String
+            char[] r1 = r8.chars
+            int r2 = r8.beg
+            int r3 = r8.cur
+            int r3 = r3 - r2
+            r0.<init>(r1, r2, r3)
+            return r0
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.mbridge.msdk.thrid.okhttp.internal.tls.DistinguishedNameParser.escapedAV():java.lang.String");
+    }
+
+    private char getEscaped() {
+        int i = this.pos + 1;
+        this.pos = i;
+        if (i == this.length) {
+            throw new IllegalStateException("Unexpected end of DN: " + this.dn);
+        }
+        char c = this.chars[i];
+        if (c == ' ' || c == '%' || c == '\\' || c == '_' || c == '\"' || c == '#') {
+            return c;
+        }
+        switch (c) {
+            case '*':
+            case '+':
+            case ',':
+                return c;
+            default:
+                switch (c) {
+                    case TokenParametersOuterClass$TokenParameters.PRIORCLICKS_FIELD_NUMBER /* 59 */:
+                    case '<':
+                    case TokenParametersOuterClass$TokenParameters.PRIORCLICKTYPES_FIELD_NUMBER /* 61 */:
+                    case '>':
+                        return c;
+                    default:
+                        return getUTF8();
+                }
+        }
+    }
+
+    private char getUTF8() {
+        int i;
+        int i2;
+        int i3 = getByte(this.pos);
+        this.pos++;
+        if (i3 < 128) {
+            return (char) i3;
+        }
+        if (i3 < 192 || i3 > 247) {
+            return '?';
+        }
+        if (i3 <= 223) {
+            i = i3 & 31;
+            i2 = 1;
+        } else if (i3 <= 239) {
+            i = i3 & 15;
+            i2 = 2;
+        } else {
+            i = i3 & 7;
+            i2 = 3;
+        }
+        for (int i4 = 0; i4 < i2; i4++) {
+            int i5 = this.pos;
+            int i6 = i5 + 1;
+            this.pos = i6;
+            if (i6 == this.length || this.chars[i6] != '\\') {
+                return '?';
+            }
+            int i7 = i5 + 2;
+            this.pos = i7;
+            int i8 = getByte(i7);
+            this.pos++;
+            if ((i8 & PsExtractor.AUDIO_STREAM) != 128) {
+                return '?';
+            }
+            i = (i << 6) + (i8 & 63);
+        }
+        return (char) i;
+    }
+
+    private int getByte(int i) {
+        int i2;
+        int i3;
+        int i4 = i + 1;
+        if (i4 >= this.length) {
+            throw new IllegalStateException("Malformed DN: " + this.dn);
+        }
+        char[] cArr = this.chars;
+        char c = cArr[i];
+        if (c >= '0' && c <= '9') {
+            i2 = c - '0';
+        } else if (c >= 'a' && c <= 'f') {
+            i2 = c - 'W';
+        } else {
+            if (c < 'A' || c > 'F') {
+                throw new IllegalStateException("Malformed DN: " + this.dn);
+            }
+            i2 = c - '7';
+        }
+        char c2 = cArr[i4];
+        if (c2 >= '0' && c2 <= '9') {
+            i3 = c2 - '0';
+        } else if (c2 >= 'a' && c2 <= 'f') {
+            i3 = c2 - 'W';
+        } else {
+            if (c2 < 'A' || c2 > 'F') {
+                throw new IllegalStateException("Malformed DN: " + this.dn);
+            }
+            i3 = c2 - '7';
+        }
+        return (i2 << 4) + i3;
+    }
+
+    public String findMostSpecific(String str) {
+        String quotedAV;
+        this.pos = 0;
+        this.beg = 0;
+        this.end = 0;
+        this.cur = 0;
+        this.chars = this.dn.toCharArray();
+        String nextAT = nextAT();
+        if (nextAT == null) {
+            return null;
+        }
+        do {
+            int i = this.pos;
+            if (i == this.length) {
+                return null;
+            }
+            char c = this.chars[i];
+            if (c == '\"') {
+                quotedAV = quotedAV();
+            } else if (c == '#') {
+                quotedAV = hexAV();
+            } else {
+                quotedAV = (c == '+' || c == ',' || c == ';') ? "" : escapedAV();
+            }
+            if (str.equalsIgnoreCase(nextAT)) {
+                return quotedAV;
+            }
+            int i2 = this.pos;
+            if (i2 >= this.length) {
+                return null;
+            }
+            char c2 = this.chars[i2];
+            if (c2 != ',' && c2 != ';' && c2 != '+') {
+                throw new IllegalStateException("Malformed DN: " + this.dn);
+            }
+            this.pos = i2 + 1;
+            nextAT = nextAT();
+        } while (nextAT != null);
+        throw new IllegalStateException("Malformed DN: " + this.dn);
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/tls/OkHostnameVerifier.java

@@ -0,0 +1,118 @@
+package com.mbridge.msdk.thrid.okhttp.internal.tls;
+
+import androidx.webkit.ProxyConfig;
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import csdk.gluads.Consts;
+import java.security.cert.CertificateParsingException;
+import java.security.cert.X509Certificate;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Locale;
+import javax.net.ssl.HostnameVerifier;
+import javax.net.ssl.SSLException;
+import javax.net.ssl.SSLSession;
+
+/* loaded from: classes4.dex */
+public final class OkHostnameVerifier implements HostnameVerifier {
+    private static final int ALT_DNS_NAME = 2;
+    private static final int ALT_IPA_NAME = 7;
+    public static final OkHostnameVerifier INSTANCE = new OkHostnameVerifier();
+
+    private OkHostnameVerifier() {
+    }
+
+    @Override // javax.net.ssl.HostnameVerifier
+    public boolean verify(String str, SSLSession sSLSession) {
+        try {
+            return verify(str, (X509Certificate) sSLSession.getPeerCertificates()[0]);
+        } catch (SSLException unused) {
+            return false;
+        }
+    }
+
+    public boolean verify(String str, X509Certificate x509Certificate) {
+        if (Util.verifyAsIpAddress(str)) {
+            return verifyIpAddress(str, x509Certificate);
+        }
+        return verifyHostname(str, x509Certificate);
+    }
+
+    private boolean verifyIpAddress(String str, X509Certificate x509Certificate) {
+        List<String> subjectAltNames = getSubjectAltNames(x509Certificate, 7);
+        int size = subjectAltNames.size();
+        for (int i = 0; i < size; i++) {
+            if (str.equalsIgnoreCase(subjectAltNames.get(i))) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private boolean verifyHostname(String str, X509Certificate x509Certificate) {
+        String lowerCase = str.toLowerCase(Locale.US);
+        Iterator<String> it = getSubjectAltNames(x509Certificate, 2).iterator();
+        while (it.hasNext()) {
+            if (verifyHostname(lowerCase, it.next())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public static List<String> allSubjectAltNames(X509Certificate x509Certificate) {
+        List<String> subjectAltNames = getSubjectAltNames(x509Certificate, 7);
+        List<String> subjectAltNames2 = getSubjectAltNames(x509Certificate, 2);
+        ArrayList arrayList = new ArrayList(subjectAltNames.size() + subjectAltNames2.size());
+        arrayList.addAll(subjectAltNames);
+        arrayList.addAll(subjectAltNames2);
+        return arrayList;
+    }
+
+    private static List<String> getSubjectAltNames(X509Certificate x509Certificate, int i) {
+        Integer num;
+        String str;
+        ArrayList arrayList = new ArrayList();
+        try {
+            Collection<List<?>> subjectAlternativeNames = x509Certificate.getSubjectAlternativeNames();
+            if (subjectAlternativeNames == null) {
+                return Collections.emptyList();
+            }
+            for (List<?> list : subjectAlternativeNames) {
+                if (list != null && list.size() >= 2 && (num = (Integer) list.get(0)) != null && num.intValue() == i && (str = (String) list.get(1)) != null) {
+                    arrayList.add(str);
+                }
+            }
+            return arrayList;
+        } catch (CertificateParsingException unused) {
+            return Collections.emptyList();
+        }
+    }
+
+    public boolean verifyHostname(String str, String str2) {
+        if (str != null && str.length() != 0 && !str.startsWith(Consts.STRING_PERIOD) && !str.endsWith("..") && str2 != null && str2.length() != 0 && !str2.startsWith(Consts.STRING_PERIOD) && !str2.endsWith("..")) {
+            if (!str.endsWith(Consts.STRING_PERIOD)) {
+                str = str + '.';
+            }
+            if (!str2.endsWith(Consts.STRING_PERIOD)) {
+                str2 = str2 + '.';
+            }
+            String lowerCase = str2.toLowerCase(Locale.US);
+            if (!lowerCase.contains(ProxyConfig.MATCH_ALL_SCHEMES)) {
+                return str.equals(lowerCase);
+            }
+            if (!lowerCase.startsWith("*.") || lowerCase.indexOf(42, 1) != -1 || str.length() < lowerCase.length() || "*.".equals(lowerCase)) {
+                return false;
+            }
+            String substring = lowerCase.substring(1);
+            if (!str.endsWith(substring)) {
+                return false;
+            }
+            int length = str.length() - substring.length();
+            return length <= 0 || str.lastIndexOf(46, length - 1) == -1;
+        }
+        return false;
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/tls/TrustRootIndex.java

@@ -0,0 +1,8 @@
+package com.mbridge.msdk.thrid.okhttp.internal.tls;
+
+import java.security.cert.X509Certificate;
+
+/* loaded from: classes4.dex */
+public interface TrustRootIndex {
+    X509Certificate findByIssuerAndSignature(X509Certificate x509Certificate);
+}