package okhttp3;

import c.h;
import c.l.f;
import c.l.r;
import c.q.d.g;
import c.q.d.j;
import c.q.d.u;
import c.u.n;
import c.u.o;
import d.i;
import java.security.Principal;
import java.security.PublicKey;
import java.security.cert.Certificate;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import javax.net.ssl.SSLPeerUnverifiedException;
import okhttp3.HttpUrl;
import okhttp3.internal.tls.CertificateChainCleaner;

/* JADX INFO: compiled from: CertificatePinner.kt */
/* JADX INFO: loaded from: classes.dex */
public final class CertificatePinner {
    public static final Companion Companion = new Companion(null);
    public static final CertificatePinner DEFAULT = new Builder().build();
    public static final String WILDCARD = "*.";
    private final CertificateChainCleaner certificateChainCleaner;
    private final Set<Pin> pins;

    /* JADX INFO: compiled from: CertificatePinner.kt */
    public static final class Builder {
        private final List<Pin> pins = new ArrayList();

        public final Builder add(String str, String... strArr) {
            j.c(str, "pattern");
            j.c(strArr, "pins");
            for (String str2 : strArr) {
                this.pins.add(CertificatePinner.Companion.newPin$okhttp(str, str2));
            }
            return this;
        }

        public final CertificatePinner build() {
            return new CertificatePinner(r.B(this.pins), null);
        }
    }

    /* JADX INFO: compiled from: CertificatePinner.kt */
    public static final class Companion {
        private Companion() {
        }

        public final Pin newPin$okhttp(String str, String str2) {
            String strHost;
            j.c(str, "pattern");
            j.c(str2, "pin");
            if (n.t(str, CertificatePinner.WILDCARD, false, 2, null)) {
                HttpUrl.Companion companion = HttpUrl.Companion;
                StringBuilder sb = new StringBuilder();
                sb.append("http://");
                String strSubstring = str.substring(2);
                j.b(strSubstring, "(this as java.lang.String).substring(startIndex)");
                sb.append(strSubstring);
                strHost = companion.get(sb.toString()).host();
            } else {
                strHost = HttpUrl.Companion.get("http://" + str).host();
            }
            if (n.t(str2, "sha1/", false, 2, null)) {
                i.a aVar = i.f1573f;
                String strSubstring2 = str2.substring(5);
                j.b(strSubstring2, "(this as java.lang.String).substring(startIndex)");
                i iVarA = aVar.a(strSubstring2);
                if (iVarA != null) {
                    return new Pin(str, strHost, "sha1/", iVarA);
                }
                j.g();
                throw null;
            }
            if (!n.t(str2, "sha256/", false, 2, null)) {
                throw new IllegalArgumentException("pins must start with 'sha256/' or 'sha1/': " + str2);
            }
            i.a aVar2 = i.f1573f;
            String strSubstring3 = str2.substring(7);
            j.b(strSubstring3, "(this as java.lang.String).substring(startIndex)");
            i iVarA2 = aVar2.a(strSubstring3);
            if (iVarA2 != null) {
                return new Pin(str, strHost, "sha256/", iVarA2);
            }
            j.g();
            throw null;
        }

        public final String pin(Certificate certificate) {
            j.c(certificate, "certificate");
            if (!(certificate instanceof X509Certificate)) {
                throw new IllegalArgumentException("Certificate pinning requires X509 certificates".toString());
            }
            return "sha256/" + toSha256ByteString$okhttp((X509Certificate) certificate).a();
        }

        public final i toSha1ByteString$okhttp(X509Certificate x509Certificate) {
            j.c(x509Certificate, "$this$toSha1ByteString");
            i.a aVar = i.f1573f;
            PublicKey publicKey = x509Certificate.getPublicKey();
            j.b(publicKey, "publicKey");
            byte[] encoded = publicKey.getEncoded();
            j.b(encoded, "publicKey.encoded");
            return i.a.g(aVar, encoded, 0, 0, 3, null).q();
        }

        public final i toSha256ByteString$okhttp(X509Certificate x509Certificate) {
            j.c(x509Certificate, "$this$toSha256ByteString");
            i.a aVar = i.f1573f;
            PublicKey publicKey = x509Certificate.getPublicKey();
            j.b(publicKey, "publicKey");
            byte[] encoded = publicKey.getEncoded();
            j.b(encoded, "publicKey.encoded");
            return i.a.g(aVar, encoded, 0, 0, 3, null).r();
        }

        public /* synthetic */ Companion(g gVar) {
            this();
        }
    }

    /* JADX INFO: compiled from: CertificatePinner.kt */
    public static final class Pin {
        private final String canonicalHostname;
        private final i hash;
        private final String hashAlgorithm;
        private final String pattern;

        public Pin(String str, String str2, String str3, i iVar) {
            j.c(str, "pattern");
            j.c(str2, "canonicalHostname");
            j.c(str3, "hashAlgorithm");
            j.c(iVar, "hash");
            this.pattern = str;
            this.canonicalHostname = str2;
            this.hashAlgorithm = str3;
            this.hash = iVar;
        }

        private final String component2() {
            return this.canonicalHostname;
        }

        public static /* synthetic */ Pin copy$default(Pin pin, String str, String str2, String str3, i iVar, int i, Object obj) {
            if ((i & 1) != 0) {
                str = pin.pattern;
            }
            if ((i & 2) != 0) {
                str2 = pin.canonicalHostname;
            }
            if ((i & 4) != 0) {
                str3 = pin.hashAlgorithm;
            }
            if ((i & 8) != 0) {
                iVar = pin.hash;
            }
            return pin.copy(str, str2, str3, iVar);
        }

        public final String component1() {
            return this.pattern;
        }

        public final String component3() {
            return this.hashAlgorithm;
        }

        public final i component4() {
            return this.hash;
        }

        public final Pin copy(String str, String str2, String str3, i iVar) {
            j.c(str, "pattern");
            j.c(str2, "canonicalHostname");
            j.c(str3, "hashAlgorithm");
            j.c(iVar, "hash");
            return new Pin(str, str2, str3, iVar);
        }

        public boolean equals(Object obj) {
            if (this == obj) {
                return true;
            }
            if (!(obj instanceof Pin)) {
                return false;
            }
            Pin pin = (Pin) obj;
            return j.a(this.pattern, pin.pattern) && j.a(this.canonicalHostname, pin.canonicalHostname) && j.a(this.hashAlgorithm, pin.hashAlgorithm) && j.a(this.hash, pin.hash);
        }

        public final i getHash() {
            return this.hash;
        }

        public final String getHashAlgorithm() {
            return this.hashAlgorithm;
        }

        public final String getPattern() {
            return this.pattern;
        }

        public int hashCode() {
            String str = this.pattern;
            int iHashCode = (str != null ? str.hashCode() : 0) * 31;
            String str2 = this.canonicalHostname;
            int iHashCode2 = (iHashCode + (str2 != null ? str2.hashCode() : 0)) * 31;
            String str3 = this.hashAlgorithm;
            int iHashCode3 = (iHashCode2 + (str3 != null ? str3.hashCode() : 0)) * 31;
            i iVar = this.hash;
            return iHashCode3 + (iVar != null ? iVar.hashCode() : 0);
        }

        public final boolean matches(String str) {
            j.c(str, "hostname");
            if (!n.t(this.pattern, CertificatePinner.WILDCARD, false, 2, null)) {
                return j.a(str, this.canonicalHostname);
            }
            int iG = o.G(str, '.', 0, false, 6, null);
            return (str.length() - iG) - 1 == this.canonicalHostname.length() && n.s(str, this.canonicalHostname, iG + 1, false, 4, null);
        }

        public String toString() {
            return this.hashAlgorithm + this.hash.a();
        }
    }

    public CertificatePinner(Set<Pin> set, CertificateChainCleaner certificateChainCleaner) {
        j.c(set, "pins");
        this.pins = set;
        this.certificateChainCleaner = certificateChainCleaner;
    }

    public static final String pin(Certificate certificate) {
        return Companion.pin(certificate);
    }

    public final void check(String str, List<? extends Certificate> list) throws SSLPeerUnverifiedException {
        j.c(str, "hostname");
        j.c(list, "peerCertificates");
        List<Pin> listFindMatchingPins$okhttp = findMatchingPins$okhttp(str);
        if (listFindMatchingPins$okhttp.isEmpty()) {
            return;
        }
        CertificateChainCleaner certificateChainCleaner = this.certificateChainCleaner;
        if (certificateChainCleaner != null) {
            list = certificateChainCleaner.clean(list, str);
        }
        for (Certificate certificate : list) {
            if (certificate == null) {
                throw new h("null cannot be cast to non-null type java.security.cert.X509Certificate");
            }
            X509Certificate x509Certificate = (X509Certificate) certificate;
            i sha1ByteString$okhttp = null;
            i sha256ByteString$okhttp = null;
            for (Pin pin : listFindMatchingPins$okhttp) {
                String hashAlgorithm = pin.getHashAlgorithm();
                int iHashCode = hashAlgorithm.hashCode();
                if (iHashCode != 109397962) {
                    if (iHashCode != 2052263656 || !hashAlgorithm.equals("sha256/")) {
                        throw new AssertionError("unsupported hashAlgorithm: " + pin.getHashAlgorithm());
                    }
                    if (sha256ByteString$okhttp == null) {
                        sha256ByteString$okhttp = Companion.toSha256ByteString$okhttp(x509Certificate);
                    }
                    if (j.a(pin.getHash(), sha256ByteString$okhttp)) {
                        return;
                    }
                } else {
                    if (!hashAlgorithm.equals("sha1/")) {
                        throw new AssertionError("unsupported hashAlgorithm: " + pin.getHashAlgorithm());
                    }
                    if (sha1ByteString$okhttp == null) {
                        sha1ByteString$okhttp = Companion.toSha1ByteString$okhttp(x509Certificate);
                    }
                    if (j.a(pin.getHash(), sha1ByteString$okhttp)) {
                        return;
                    }
                }
            }
        }
        StringBuilder sb = new StringBuilder();
        sb.append("Certificate pinning failure!");
        sb.append("\n  Peer certificate chain:");
        int size = list.size();
        for (int i = 0; i < size; i++) {
            Certificate certificate2 = list.get(i);
            if (certificate2 == null) {
                throw new h("null cannot be cast to non-null type java.security.cert.X509Certificate");
            }
            X509Certificate x509Certificate2 = (X509Certificate) certificate2;
            sb.append("\n    ");
            sb.append(Companion.pin(x509Certificate2));
            sb.append(": ");
            Principal subjectDN = x509Certificate2.getSubjectDN();
            j.b(subjectDN, "x509Certificate.subjectDN");
            sb.append(subjectDN.getName());
        }
        sb.append("\n  Pinned certificates for ");
        sb.append(str);
        sb.append(":");
        for (Pin pin2 : listFindMatchingPins$okhttp) {
            sb.append("\n    ");
            sb.append(pin2);
        }
        String string = sb.toString();
        j.b(string, "StringBuilder().apply(builderAction).toString()");
        throw new SSLPeerUnverifiedException(string);
    }

    public boolean equals(Object obj) {
        if (obj instanceof CertificatePinner) {
            CertificatePinner certificatePinner = (CertificatePinner) obj;
            if (j.a(certificatePinner.pins, this.pins) && j.a(certificatePinner.certificateChainCleaner, this.certificateChainCleaner)) {
                return true;
            }
        }
        return false;
    }

    public final List<Pin> findMatchingPins$okhttp(String str) {
        j.c(str, "hostname");
        List<Pin> listF = c.l.j.f();
        for (Pin pin : this.pins) {
            if (pin.matches(str)) {
                if (listF.isEmpty()) {
                    listF = new ArrayList<>();
                }
                if (listF == null) {
                    throw new h("null cannot be cast to non-null type kotlin.collections.MutableList<okhttp3.CertificatePinner.Pin>");
                }
                u.a(listF).add(pin);
            }
        }
        return listF;
    }

    public int hashCode() {
        int iHashCode = (1517 + this.pins.hashCode()) * 41;
        CertificateChainCleaner certificateChainCleaner = this.certificateChainCleaner;
        return iHashCode + (certificateChainCleaner != null ? certificateChainCleaner.hashCode() : 0);
    }

    public final CertificatePinner withCertificateChainCleaner$okhttp(CertificateChainCleaner certificateChainCleaner) {
        return j.a(this.certificateChainCleaner, certificateChainCleaner) ? this : new CertificatePinner(this.pins, certificateChainCleaner);
    }

    public final void check(String str, Certificate... certificateArr) throws SSLPeerUnverifiedException {
        j.c(str, "hostname");
        j.c(certificateArr, "peerCertificates");
        check(str, f.k(certificateArr));
    }
}