package io.netty.handler.ssl;

import com.cvte.vman.instance.InvokeCmd;
import io.netty.handler.ssl.OpenSslContext;
import io.netty.util.internal.logging.InternalLogger;
import io.netty.util.internal.logging.InternalLoggerFactory;
import java.io.File;
import java.security.KeyStore;
import java.security.PrivateKey;
import java.security.cert.X509Certificate;
import java.util.HashSet;
import java.util.Set;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLException;
import javax.net.ssl.SSLHandshakeException;
import javax.net.ssl.TrustManagerFactory;
import javax.net.ssl.X509ExtendedKeyManager;
import javax.net.ssl.X509ExtendedTrustManager;
import javax.net.ssl.X509KeyManager;
import javax.net.ssl.X509TrustManager;
import javax.security.auth.x500.X500Principal;
import org.apache.tomcat.jni.CertificateRequestedCallback;
import org.apache.tomcat.jni.SSLContext;

/* JADX INFO: loaded from: classes.dex */
public final class OpenSslClientContext extends OpenSslContext {
    private static final InternalLogger logger = InternalLoggerFactory.getInstance((Class<?>) OpenSslClientContext.class);
    private final OpenSslSessionContext sessionContext;

    private static final class ExtendedTrustManagerVerifyCallback extends OpenSslContext.AbstractCertificateVerifier {
        private final X509ExtendedTrustManager manager;

        ExtendedTrustManagerVerifyCallback(OpenSslEngineMap openSslEngineMap, X509ExtendedTrustManager x509ExtendedTrustManager) {
            super(openSslEngineMap);
            this.manager = x509ExtendedTrustManager;
        }

        @Override // io.netty.handler.ssl.OpenSslContext.AbstractCertificateVerifier
        void verify(OpenSslEngine openSslEngine, X509Certificate[] x509CertificateArr, String str) throws Exception {
            this.manager.checkServerTrusted(x509CertificateArr, str, openSslEngine);
        }
    }

    private static final class OpenSslCertificateRequestedCallback implements CertificateRequestedCallback {
        private final OpenSslEngineMap engineMap;
        private final OpenSslKeyMaterialManager keyManagerHolder;

        OpenSslCertificateRequestedCallback(OpenSslEngineMap openSslEngineMap, OpenSslKeyMaterialManager openSslKeyMaterialManager) {
            this.engineMap = openSslEngineMap;
            this.keyManagerHolder = openSslKeyMaterialManager;
        }

        private static String clientKeyType(byte b2) {
            if (b2 == 1) {
                return "RSA";
            }
            if (b2 == 3) {
                return "DH_RSA";
            }
            switch (b2) {
                case 64:
                    return "EC";
                case InvokeCmd.CMD_SYSTEMCTRL_GET_LOGO_DISPLAY /* 65 */:
                    return "EC_RSA";
                case InvokeCmd.CMD_SYSTEMCTRL_SET_WAKE_LOCK /* 66 */:
                    return "EC_EC";
                default:
                    return null;
            }
        }

        private static Set<String> supportedClientKeyTypes(byte[] bArr) {
            HashSet hashSet = new HashSet(bArr.length);
            for (byte b2 : bArr) {
                String strClientKeyType = clientKeyType(b2);
                if (strClientKeyType != null) {
                    hashSet.add(strClientKeyType);
                }
            }
            return hashSet;
        }

        public void requested(long j, byte[] bArr, byte[][] bArr2) {
            X500Principal[] x500PrincipalArr;
            OpenSslEngine openSslEngine = this.engineMap.get(j);
            try {
                Set<String> setSupportedClientKeyTypes = supportedClientKeyTypes(bArr);
                String[] strArr = (String[]) setSupportedClientKeyTypes.toArray(new String[setSupportedClientKeyTypes.size()]);
                if (bArr2 == null) {
                    x500PrincipalArr = null;
                } else {
                    x500PrincipalArr = new X500Principal[bArr2.length];
                    for (int i = 0; i < bArr2.length; i++) {
                        x500PrincipalArr[i] = new X500Principal(bArr2[i]);
                    }
                }
                this.keyManagerHolder.setKeyMaterial(openSslEngine, strArr, x500PrincipalArr);
            } catch (Throwable th) {
                OpenSslClientContext.logger.debug("request of key failed", th);
                SSLHandshakeException sSLHandshakeException = new SSLHandshakeException("General OpenSslEngine problem");
                sSLHandshakeException.initCause(th);
                openSslEngine.handshakeException = sSLHandshakeException;
            }
        }
    }

    private static final class OpenSslClientSessionContext extends OpenSslSessionContext {
        @Override // javax.net.ssl.SSLSessionContext
        public int getSessionCacheSize() {
            return 0;
        }

        @Override // javax.net.ssl.SSLSessionContext
        public int getSessionTimeout() {
            return 0;
        }

        @Override // io.netty.handler.ssl.OpenSslSessionContext
        public boolean isSessionCacheEnabled() {
            return false;
        }

        @Override // io.netty.handler.ssl.OpenSslSessionContext
        public void setSessionCacheEnabled(boolean z) {
        }

        @Override // javax.net.ssl.SSLSessionContext
        public void setSessionCacheSize(int i) {
            if (i < 0) {
                throw new IllegalArgumentException();
            }
        }

        @Override // javax.net.ssl.SSLSessionContext
        public void setSessionTimeout(int i) {
            if (i < 0) {
                throw new IllegalArgumentException();
            }
        }

        private OpenSslClientSessionContext(OpenSslContext openSslContext) {
            super(openSslContext);
        }
    }

    private static final class TrustManagerVerifyCallback extends OpenSslContext.AbstractCertificateVerifier {
        private final X509TrustManager manager;

        TrustManagerVerifyCallback(OpenSslEngineMap openSslEngineMap, X509TrustManager x509TrustManager) {
            super(openSslEngineMap);
            this.manager = x509TrustManager;
        }

        @Override // io.netty.handler.ssl.OpenSslContext.AbstractCertificateVerifier
        void verify(OpenSslEngine openSslEngine, X509Certificate[] x509CertificateArr, String str) throws Exception {
            this.manager.checkServerTrusted(x509CertificateArr, str);
        }
    }

    @Deprecated
    public OpenSslClientContext() throws SSLException {
        this((File) null, (TrustManagerFactory) null, (File) null, (File) null, (String) null, (KeyManagerFactory) null, (Iterable<String>) null, IdentityCipherSuiteFilter.INSTANCE, (ApplicationProtocolConfig) null, 0L, 0L);
    }

    @Override // io.netty.handler.ssl.OpenSslContext
    OpenSslKeyMaterialManager keyMaterialManager() {
        return null;
    }

    @Deprecated
    public OpenSslClientContext(File file) throws SSLException {
        this(file, null);
    }

    @Override // io.netty.handler.ssl.OpenSslContext, io.netty.handler.ssl.SslContext
    public OpenSslSessionContext sessionContext() {
        return this.sessionContext;
    }

    @Deprecated
    public OpenSslClientContext(TrustManagerFactory trustManagerFactory) throws SSLException {
        this(null, trustManagerFactory);
    }

    @Deprecated
    public OpenSslClientContext(File file, TrustManagerFactory trustManagerFactory) throws SSLException {
        this(file, trustManagerFactory, (File) null, (File) null, (String) null, (KeyManagerFactory) null, (Iterable<String>) null, IdentityCipherSuiteFilter.INSTANCE, (ApplicationProtocolConfig) null, 0L, 0L);
    }

    @Deprecated
    public OpenSslClientContext(File file, TrustManagerFactory trustManagerFactory, Iterable<String> iterable, ApplicationProtocolConfig applicationProtocolConfig, long j, long j2) throws SSLException {
        this(file, trustManagerFactory, (File) null, (File) null, (String) null, (KeyManagerFactory) null, iterable, IdentityCipherSuiteFilter.INSTANCE, applicationProtocolConfig, j, j2);
    }

    @Deprecated
    public OpenSslClientContext(File file, TrustManagerFactory trustManagerFactory, Iterable<String> iterable, CipherSuiteFilter cipherSuiteFilter, ApplicationProtocolConfig applicationProtocolConfig, long j, long j2) throws SSLException {
        this(file, trustManagerFactory, (File) null, (File) null, (String) null, (KeyManagerFactory) null, iterable, cipherSuiteFilter, applicationProtocolConfig, j, j2);
    }

    @Deprecated
    public OpenSslClientContext(File file, TrustManagerFactory trustManagerFactory, File file2, File file3, String str, KeyManagerFactory keyManagerFactory, Iterable<String> iterable, CipherSuiteFilter cipherSuiteFilter, ApplicationProtocolConfig applicationProtocolConfig, long j, long j2) throws SSLException {
        this(SslContext.toX509CertificatesInternal(file), trustManagerFactory, SslContext.toX509CertificatesInternal(file2), SslContext.toPrivateKeyInternal(file3, str), str, keyManagerFactory, iterable, cipherSuiteFilter, applicationProtocolConfig, j, j2);
    }

    OpenSslClientContext(X509Certificate[] x509CertificateArr, TrustManagerFactory trustManagerFactory, X509Certificate[] x509CertificateArr2, PrivateKey privateKey, String str, KeyManagerFactory keyManagerFactory, Iterable<String> iterable, CipherSuiteFilter cipherSuiteFilter, ApplicationProtocolConfig applicationProtocolConfig, long j, long j2) throws SSLException {
        TrustManagerFactory trustManagerFactory2;
        super(iterable, cipherSuiteFilter, applicationProtocolConfig, j, j2, 0, x509CertificateArr2, ClientAuth.NONE);
        try {
            if ((privateKey == null && x509CertificateArr2 != null) || (privateKey != null && x509CertificateArr2 == null)) {
                throw new IllegalArgumentException("Either both keyCertChain and key needs to be null or none of them");
            }
            synchronized (OpenSslContext.class) {
                try {
                    try {
                        if (OpenSsl.supportsKeyManagerFactory()) {
                            KeyManagerFactory keyManagerFactoryBuildKeyManagerFactory = x509CertificateArr2 != null ? SslContext.buildKeyManagerFactory(x509CertificateArr2, privateKey, str, keyManagerFactory) : keyManagerFactory;
                            if (keyManagerFactoryBuildKeyManagerFactory != null) {
                                X509KeyManager x509KeyManagerChooseX509KeyManager = OpenSslContext.chooseX509KeyManager(keyManagerFactoryBuildKeyManagerFactory.getKeyManagers());
                                SSLContext.setCertRequestedCallback(this.ctx, new OpenSslCertificateRequestedCallback(this.engineMap, OpenSslContext.useExtendedKeyManager(x509KeyManagerChooseX509KeyManager) ? new OpenSslExtendedKeyMaterialManager((X509ExtendedKeyManager) x509KeyManagerChooseX509KeyManager, str) : new OpenSslKeyMaterialManager(x509KeyManagerChooseX509KeyManager, str)));
                            }
                        } else {
                            if (keyManagerFactory != null) {
                                throw new IllegalArgumentException("KeyManagerFactory not supported");
                            }
                            if (x509CertificateArr2 != null && privateKey != null) {
                                OpenSslContext.setKeyMaterial(this.ctx, x509CertificateArr2, privateKey, str);
                            }
                        }
                        SSLContext.setVerify(this.ctx, 0, 10);
                        try {
                            if (x509CertificateArr != null) {
                                trustManagerFactory2 = SslContext.buildTrustManagerFactory(x509CertificateArr, trustManagerFactory);
                            } else if (trustManagerFactory == null) {
                                trustManagerFactory2 = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
                                trustManagerFactory2.init((KeyStore) null);
                            } else {
                                trustManagerFactory2 = trustManagerFactory;
                            }
                            X509TrustManager x509TrustManagerChooseTrustManager = OpenSslContext.chooseTrustManager(trustManagerFactory2.getTrustManagers());
                            if (OpenSslContext.useExtendedTrustManager(x509TrustManagerChooseTrustManager)) {
                                SSLContext.setCertVerifyCallback(this.ctx, new ExtendedTrustManagerVerifyCallback(this.engineMap, (X509ExtendedTrustManager) x509TrustManagerChooseTrustManager));
                            } else {
                                SSLContext.setCertVerifyCallback(this.ctx, new TrustManagerVerifyCallback(this.engineMap, x509TrustManagerChooseTrustManager));
                            }
                        } catch (Exception e2) {
                            throw new SSLException("unable to setup trustmanager", e2);
                        }
                    } catch (Exception e3) {
                        throw new SSLException("failed to set certificate and key", e3);
                    }
                } catch (Throwable th) {
                    throw th;
                }
            }
            this.sessionContext = new OpenSslClientSessionContext(this);
        } catch (Throwable th2) {
            destroy();
            throw th2;
        }
    }
}