package com.ifpdos.daemonserver;

import android.os.Build;
import java.io.BufferedInputStream;
import java.io.InputStream;
import java.security.InvalidKeyException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.SignatureException;
import java.security.cert.Certificate;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.TrustManagerFactory;
import javax.net.ssl.X509TrustManager;
import org.eclipse.paho.client.mqttv3.internal.security.SSLSocketFactoryFactory;

/* JADX INFO: compiled from: SSLSocketFactoryHelper.java */
/* JADX INFO: loaded from: classes.dex */
public class g {

    /* JADX INFO: compiled from: SSLSocketFactoryHelper.java */
    class a implements X509TrustManager {

        /* JADX INFO: renamed from: a, reason: collision with root package name */
        final /* synthetic */ KeyStore f1506a;

        /* JADX INFO: renamed from: b, reason: collision with root package name */
        final /* synthetic */ String f1507b;

        a(KeyStore keyStore, String str) {
            this.f1506a = keyStore;
            this.f1507b = str;
        }

        @Override // javax.net.ssl.X509TrustManager
        public void checkClientTrusted(X509Certificate[] x509CertificateArr, String str) {
        }

        @Override // javax.net.ssl.X509TrustManager
        public void checkServerTrusted(X509Certificate[] x509CertificateArr, String str) throws CertificateException {
            try {
                for (X509Certificate x509Certificate : x509CertificateArr) {
                    x509Certificate.verify(this.f1506a.getCertificate(this.f1507b).getPublicKey());
                }
            } catch (InvalidKeyException | KeyStoreException | NoSuchAlgorithmException | NoSuchProviderException | SignatureException e2) {
                throw new CertificateException(e2);
            }
        }

        @Override // javax.net.ssl.X509TrustManager
        public X509Certificate[] getAcceptedIssuers() {
            return new X509Certificate[0];
        }
    }

    public static SSLSocketFactory a(InputStream inputStream, InputStream inputStream2, String str) throws Exception {
        KeyStore keyStoreC = c(inputStream, "ca");
        KeyStore keyStore = KeyStore.getInstance("PKCS12");
        keyStore.load(inputStream2, str.toCharArray());
        TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
        trustManagerFactory.init(keyStoreC);
        KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
        keyManagerFactory.init(keyStore, null);
        SSLContext sSLContext = SSLContext.getInstance(SSLSocketFactoryFactory.DEFAULT_PROTOCOL);
        sSLContext.init(keyManagerFactory.getKeyManagers(), Build.VERSION.SDK_INT >= 30 ? b(keyStoreC, "ca") : trustManagerFactory.getTrustManagers(), null);
        return sSLContext.getSocketFactory();
    }

    private static TrustManager[] b(KeyStore keyStore, String str) {
        return new TrustManager[]{new a(keyStore, str)};
    }

    private static KeyStore c(InputStream inputStream, String str) throws Exception {
        CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509");
        BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);
        try {
            Certificate certificateGenerateCertificate = certificateFactory.generateCertificate(bufferedInputStream);
            bufferedInputStream.close();
            KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
            keyStore.load(null, null);
            keyStore.setCertificateEntry(str, certificateGenerateCertificate);
            return keyStore;
        } catch (Throwable th) {
            try {
                bufferedInputStream.close();
            } catch (Throwable th2) {
                th.addSuppressed(th2);
            }
            throw th;
        }
    }
}