package com.android.org.conscrypt;

import java.io.ByteArrayInputStream;
import java.nio.ByteBuffer;
import java.nio.charset.Charset;
import java.security.cert.CertificateEncodingException;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import java.util.Arrays;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;
import javax.net.ssl.SSLException;
import javax.net.ssl.SSLHandshakeException;
import javax.net.ssl.SSLPeerUnverifiedException;

/* JADX INFO: loaded from: classes.dex */
final class SSLUtils {
    private static final String KEY_TYPE_EC = "EC";
    private static final String KEY_TYPE_RSA = "RSA";
    private static final int MAX_ENCRYPTION_OVERHEAD_DIFF = 2147483561;
    private static final int MAX_ENCRYPTION_OVERHEAD_LENGTH = 86;
    private static final int MAX_PROTOCOL_LENGTH = 255;
    static final boolean USE_ENGINE_SOCKET_BY_DEFAULT = Boolean.parseBoolean(System.getProperty("com.android.org.conscrypt.useEngineSocketByDefault", "true"));
    private static final Charset US_ASCII = Charset.forName("US-ASCII");

    static final class EngineStates {
        static final int STATE_CLOSED = 8;
        static final int STATE_CLOSED_INBOUND = 6;
        static final int STATE_CLOSED_OUTBOUND = 7;
        static final int STATE_HANDSHAKE_COMPLETED = 3;
        static final int STATE_HANDSHAKE_STARTED = 2;
        static final int STATE_MODE_SET = 1;
        static final int STATE_NEW = 0;
        static final int STATE_READY = 5;
        static final int STATE_READY_HANDSHAKE_CUT_THROUGH = 4;

        private EngineStates() {
        }
    }

    enum SessionType {
        OPEN_SSL(1),
        OPEN_SSL_WITH_OCSP(2),
        OPEN_SSL_WITH_TLS_SCT(3);

        final int value;

        SessionType(int i3) {
            this.value = i3;
        }

        static boolean isSupportedType(int i3) {
            return i3 == OPEN_SSL.value || i3 == OPEN_SSL_WITH_OCSP.value || i3 == OPEN_SSL_WITH_TLS_SCT.value;
        }
    }

    private SSLUtils() {
    }

    static int calculateOutNetBufSize(int i3) {
        return Math.min(16709, Math.min(MAX_ENCRYPTION_OVERHEAD_DIFF, i3) + MAX_ENCRYPTION_OVERHEAD_LENGTH);
    }

    static String[] concat(String[]... strArr) {
        int length = 0;
        for (String[] strArr2 : strArr) {
            length += strArr2.length;
        }
        String[] strArr3 = new String[length];
        int length2 = 0;
        for (String[] strArr4 : strArr) {
            System.arraycopy(strArr4, 0, strArr3, length2, strArr4.length);
            length2 += strArr4.length;
        }
        return strArr3;
    }

    static String[] decodeProtocols(byte[] bArr) {
        String string;
        if (bArr.length == 0) {
            return EmptyArray.STRING;
        }
        int i3 = 0;
        int i4 = 0;
        int i5 = 0;
        while (i4 < bArr.length) {
            byte b3 = bArr[i4];
            if (b3 < 0 || b3 > bArr.length - i4) {
                StringBuilder sb = new StringBuilder();
                sb.append("Protocol has invalid length (");
                sb.append((int) b3);
                sb.append(" at position ");
                sb.append(i4);
                sb.append("): ");
                if (bArr.length < 50) {
                    string = Arrays.toString(bArr);
                } else {
                    string = bArr.length + " byte array";
                }
                sb.append(string);
                throw new IllegalArgumentException(sb.toString());
            }
            i5++;
            i4 += b3 + 1;
        }
        String[] strArr = new String[i5];
        int i6 = 0;
        while (i3 < bArr.length) {
            byte b4 = bArr[i3];
            int i7 = i6 + 1;
            strArr[i6] = b4 > 0 ? new String(bArr, i3 + 1, b4, US_ASCII) : "";
            i3 += b4 + 1;
            i6 = i7;
        }
        return strArr;
    }

    private static X509Certificate decodeX509Certificate(CertificateFactory certificateFactory, byte[] bArr) throws CertificateException {
        return certificateFactory != null ? (X509Certificate) certificateFactory.generateCertificate(new ByteArrayInputStream(bArr)) : OpenSSLX509Certificate.fromX509Der(bArr);
    }

    static X509Certificate[] decodeX509CertificateChain(byte[][] bArr) throws CertificateException {
        CertificateFactory certificateFactory = getCertificateFactory();
        int length = bArr.length;
        X509Certificate[] x509CertificateArr = new X509Certificate[length];
        for (int i3 = 0; i3 < length; i3++) {
            x509CertificateArr[i3] = decodeX509Certificate(certificateFactory, bArr[i3]);
        }
        return x509CertificateArr;
    }

    static byte[] encodeProtocols(String[] strArr) {
        if (strArr == null) {
            throw new IllegalArgumentException("protocols array must be non-null");
        }
        if (strArr.length == 0) {
            return EmptyArray.BYTE;
        }
        int i3 = 0;
        for (int i4 = 0; i4 < strArr.length; i4++) {
            if (strArr[i4] == null) {
                throw new IllegalArgumentException("protocol[" + i4 + "] is null");
            }
            int length = strArr[i4].length();
            if (length == 0 || length > MAX_PROTOCOL_LENGTH) {
                throw new IllegalArgumentException("protocol[" + i4 + "] has invalid length: " + length);
            }
            i3 += length + 1;
        }
        byte[] bArr = new byte[i3];
        int i5 = 0;
        for (String str : strArr) {
            int length2 = str.length();
            bArr[i5] = (byte) length2;
            i5++;
            int i6 = 0;
            while (i6 < length2) {
                char cCharAt = str.charAt(i6);
                if (cCharAt > 127) {
                    throw new IllegalArgumentException("Protocol contains invalid character: " + cCharAt + "(protocol=" + str + ")");
                }
                bArr[i5] = (byte) cCharAt;
                i6++;
                i5++;
            }
        }
        return bArr;
    }

    static byte[][] encodeSubjectX509Principals(X509Certificate[] x509CertificateArr) throws CertificateEncodingException {
        byte[][] bArr = new byte[x509CertificateArr.length][];
        for (int i3 = 0; i3 < x509CertificateArr.length; i3++) {
            bArr[i3] = x509CertificateArr[i3].getSubjectX500Principal().getEncoded();
        }
        return bArr;
    }

    private static CertificateFactory getCertificateFactory() {
        try {
            return CertificateFactory.getInstance("X.509");
        } catch (CertificateException unused) {
            return null;
        }
    }

    static String getClientKeyType(byte b3) {
        if (b3 == 1) {
            return KEY_TYPE_RSA;
        }
        if (b3 != 64) {
            return null;
        }
        return KEY_TYPE_EC;
    }

    static String getClientKeyTypeFromSignatureAlg(int i3) {
        int iSSL_get_signature_algorithm_key_type = NativeCrypto.SSL_get_signature_algorithm_key_type(i3);
        if (iSSL_get_signature_algorithm_key_type == 6) {
            return KEY_TYPE_RSA;
        }
        if (iSSL_get_signature_algorithm_key_type != 408) {
            return null;
        }
        return KEY_TYPE_EC;
    }

    static int getEncryptedPacketLength(ByteBuffer[] byteBufferArr, int i3) {
        ByteBuffer byteBuffer = byteBufferArr[i3];
        if (byteBuffer.remaining() >= 5) {
            return getEncryptedPacketLength(byteBuffer);
        }
        ByteBuffer byteBufferAllocate = ByteBuffer.allocate(5);
        while (true) {
            int i4 = i3 + 1;
            ByteBuffer byteBuffer2 = byteBufferArr[i3];
            int iPosition = byteBuffer2.position();
            int iLimit = byteBuffer2.limit();
            if (byteBuffer2.remaining() > byteBufferAllocate.remaining()) {
                byteBuffer2.limit(byteBufferAllocate.remaining() + iPosition);
            }
            try {
                byteBufferAllocate.put(byteBuffer2);
                byteBuffer2.limit(iLimit);
                byteBuffer2.position(iPosition);
                if (!byteBufferAllocate.hasRemaining()) {
                    byteBufferAllocate.flip();
                    return getEncryptedPacketLength(byteBufferAllocate);
                }
                i3 = i4;
            } catch (Throwable th) {
                byteBuffer2.limit(iLimit);
                byteBuffer2.position(iPosition);
                throw th;
            }
        }
    }

    static String getServerX509KeyType(long j3) {
        String strSSL_CIPHER_get_kx_name = NativeCrypto.SSL_CIPHER_get_kx_name(j3);
        if (strSSL_CIPHER_get_kx_name.equals(KEY_TYPE_RSA) || strSSL_CIPHER_get_kx_name.equals("DHE_RSA") || strSSL_CIPHER_get_kx_name.equals("ECDHE_RSA")) {
            return KEY_TYPE_RSA;
        }
        if (strSSL_CIPHER_get_kx_name.equals("ECDHE_ECDSA")) {
            return KEY_TYPE_EC;
        }
        return null;
    }

    static Set<String> getSupportedClientKeyTypes(byte[] bArr, int[] iArr) {
        HashSet hashSet = new HashSet(bArr.length);
        for (byte b3 : bArr) {
            String clientKeyType = getClientKeyType(b3);
            if (clientKeyType != null) {
                hashSet.add(clientKeyType);
            }
        }
        LinkedHashSet linkedHashSet = new LinkedHashSet(iArr.length);
        for (int i3 : iArr) {
            String clientKeyTypeFromSignatureAlg = getClientKeyTypeFromSignatureAlg(i3);
            if (clientKeyTypeFromSignatureAlg != null) {
                linkedHashSet.add(clientKeyTypeFromSignatureAlg);
            }
        }
        if (bArr.length <= 0 || iArr.length <= 0) {
            return iArr.length > 0 ? linkedHashSet : hashSet;
        }
        linkedHashSet.retainAll(hashSet);
        return linkedHashSet;
    }

    static javax.security.cert.X509Certificate[] toCertificateChain(X509Certificate[] x509CertificateArr) throws SSLPeerUnverifiedException {
        try {
            javax.security.cert.X509Certificate[] x509CertificateArr2 = new javax.security.cert.X509Certificate[x509CertificateArr.length];
            for (int i3 = 0; i3 < x509CertificateArr.length; i3++) {
                x509CertificateArr2[i3] = javax.security.cert.X509Certificate.getInstance(x509CertificateArr[i3].getEncoded());
            }
            return x509CertificateArr2;
        } catch (CertificateEncodingException e3) {
            SSLPeerUnverifiedException sSLPeerUnverifiedException = new SSLPeerUnverifiedException(e3.getMessage());
            sSLPeerUnverifiedException.initCause(e3);
            throw sSLPeerUnverifiedException;
        } catch (javax.security.cert.CertificateException e4) {
            SSLPeerUnverifiedException sSLPeerUnverifiedException2 = new SSLPeerUnverifiedException(e4.getMessage());
            sSLPeerUnverifiedException2.initCause(e4);
            throw sSLPeerUnverifiedException2;
        }
    }

    static byte[] toProtocolBytes(String str) {
        if (str == null) {
            return null;
        }
        return str.getBytes(US_ASCII);
    }

    static String toProtocolString(byte[] bArr) {
        if (bArr == null) {
            return null;
        }
        return new String(bArr, US_ASCII);
    }

    static SSLException toSSLException(Throwable th) {
        return th instanceof SSLException ? (SSLException) th : new SSLException(th);
    }

    static SSLHandshakeException toSSLHandshakeException(Throwable th) {
        return th instanceof SSLHandshakeException ? (SSLHandshakeException) th : (SSLHandshakeException) new SSLHandshakeException(th.getMessage()).initCause(th);
    }

    private static short unsignedByte(byte b3) {
        return (short) (b3 & 255);
    }

    private static int unsignedShort(short s2) {
        return s2 & 65535;
    }

    private static int getEncryptedPacketLength(ByteBuffer byteBuffer) {
        int iPosition = byteBuffer.position();
        switch (unsignedByte(byteBuffer.get(iPosition))) {
            case 20:
            case 21:
            case 22:
            case 23:
                if (unsignedByte(byteBuffer.get(iPosition + 1)) == 3 && (r4 = unsignedShort(byteBuffer.getShort(iPosition + 3)) + 5) > 5) {
                }
                break;
        }
        return -1;
    }
}