package io.netty.handler.ssl;

import g.a.a.a.a;
import io.netty.util.internal.PlatformDependent;
import io.netty.util.internal.logging.InternalLogger;
import io.netty.util.internal.logging.InternalLoggerFactory;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.ConcurrentMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import kotlinx.serialization.json.internal.AbstractJsonLexerKt;

/* JADX INFO: loaded from: classes.dex */
public final class CipherSuiteConverter {
    private static final InternalLogger logger = InternalLoggerFactory.getInstance((Class<?>) CipherSuiteConverter.class);
    private static final Pattern JAVA_CIPHERSUITE_PATTERN = Pattern.compile("^(?:TLS|SSL)_((?:(?!_WITH_).)+)_WITH_(.*)_(.*)$");
    private static final Pattern OPENSSL_CIPHERSUITE_PATTERN = Pattern.compile("^(?:((?:(?:EXP-)?(?:(?:DHE|EDH|ECDH|ECDHE|SRP|RSA)-(?:DSS|RSA|ECDSA|PSK)|(?:ADH|AECDH|KRB5|PSK|SRP)))|EXP)-)?(.*)-(.*)$");
    private static final Pattern JAVA_AES_CBC_PATTERN = Pattern.compile("^(AES)_([0-9]+)_CBC$");
    private static final Pattern JAVA_AES_PATTERN = Pattern.compile("^(AES)_([0-9]+)_(.*)$");
    private static final Pattern OPENSSL_AES_CBC_PATTERN = Pattern.compile("^(AES)([0-9]+)$");
    private static final Pattern OPENSSL_AES_PATTERN = Pattern.compile("^(AES)([0-9]+)-(.*)$");
    private static final ConcurrentMap<String, String> j2o = PlatformDependent.newConcurrentHashMap();
    private static final ConcurrentMap<String, Map<String, String>> o2j = PlatformDependent.newConcurrentHashMap();

    private CipherSuiteConverter() {
    }

    private static String cacheFromJava(String str) {
        String openSslUncached = toOpenSslUncached(str);
        if (openSslUncached == null) {
            return null;
        }
        j2o.putIfAbsent(str, openSslUncached);
        String strSubstring = str.substring(4);
        HashMap map = new HashMap(4);
        map.put("", strSubstring);
        map.put("SSL", "SSL_" + strSubstring);
        map.put(JdkSslContext.PROTOCOL, "TLS_" + strSubstring);
        o2j.put(openSslUncached, map);
        logger.debug("Cipher suite mapping: {} => {}", str, openSslUncached);
        return openSslUncached;
    }

    private static Map<String, String> cacheFromOpenSsl(String str) {
        String javaUncached = toJavaUncached(str);
        if (javaUncached == null) {
            return null;
        }
        String strT = a.t("SSL_", javaUncached);
        String strT2 = a.t("TLS_", javaUncached);
        HashMap map = new HashMap(4);
        map.put("", javaUncached);
        map.put("SSL", strT);
        map.put(JdkSslContext.PROTOCOL, strT2);
        o2j.putIfAbsent(str, map);
        ConcurrentMap<String, String> concurrentMap = j2o;
        concurrentMap.putIfAbsent(strT2, str);
        concurrentMap.putIfAbsent(strT, str);
        InternalLogger internalLogger = logger;
        internalLogger.debug("Cipher suite mapping: {} => {}", strT2, str);
        internalLogger.debug("Cipher suite mapping: {} => {}", strT, str);
        return map;
    }

    public static void clearCache() {
        j2o.clear();
        o2j.clear();
    }

    public static boolean isJ2OCached(String str, String str2) {
        return str2.equals(j2o.get(str));
    }

    public static boolean isO2JCached(String str, String str2, String str3) {
        Map<String, String> map = o2j.get(str);
        if (map == null) {
            return false;
        }
        return str3.equals(map.get(str2));
    }

    public static String toJava(String str, String str2) {
        Map<String, String> mapCacheFromOpenSsl = o2j.get(str);
        if (mapCacheFromOpenSsl == null && (mapCacheFromOpenSsl = cacheFromOpenSsl(str)) == null) {
            return null;
        }
        String str3 = mapCacheFromOpenSsl.get(str2);
        if (str3 != null) {
            return str3;
        }
        return str2 + '_' + mapCacheFromOpenSsl.get("");
    }

    private static String toJavaBulkCipher(String str, boolean z2) {
        if (str.startsWith("AES")) {
            Matcher matcher = OPENSSL_AES_CBC_PATTERN.matcher(str);
            if (matcher.matches()) {
                return matcher.replaceFirst("$1_$2_CBC");
            }
            Matcher matcher2 = OPENSSL_AES_PATTERN.matcher(str);
            if (matcher2.matches()) {
                return matcher2.replaceFirst("$1_$2_$3");
            }
        }
        return "DES-CBC3".equals(str) ? "3DES_EDE_CBC" : "RC4".equals(str) ? z2 ? "RC4_40" : "RC4_128" : "DES-CBC".equals(str) ? z2 ? "DES_CBC_40" : "DES_CBC" : "RC2-CBC".equals(str) ? z2 ? "RC2_CBC_40" : "RC2_CBC" : str.replace('-', '_');
    }

    private static String toJavaHandshakeAlgo(String str, boolean z2) {
        if (str.isEmpty()) {
            str = OpenSslKeyMaterialManager.KEY_TYPE_RSA;
        } else if ("ADH".equals(str)) {
            str = "DH_anon";
        } else if ("AECDH".equals(str)) {
            str = "ECDH_anon";
        }
        String strReplace = str.replace('-', '_');
        return z2 ? a.t(strReplace, "_EXPORT") : strReplace;
    }

    private static String toJavaHmacAlgo(String str) {
        return str;
    }

    /* JADX WARN: Removed duplicated region for block: B:18:0x006d  */
    /* JADX WARN: Removed duplicated region for block: B:20:? A[RETURN, SYNTHETIC] */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    public static java.lang.String toJavaUncached(java.lang.String r5) {
        /*
            java.util.regex.Pattern r0 = io.netty.handler.ssl.CipherSuiteConverter.OPENSSL_CIPHERSUITE_PATTERN
            java.util.regex.Matcher r5 = r0.matcher(r5)
            boolean r0 = r5.matches()
            if (r0 != 0) goto Le
            r5 = 0
            return r5
        Le:
            r0 = 1
            java.lang.String r1 = r5.group(r0)
            r2 = 0
            java.lang.String r3 = ""
            if (r1 != 0) goto L1a
            r0 = r2
            goto L30
        L1a:
            java.lang.String r4 = "EXP-"
            boolean r4 = r1.startsWith(r4)
            if (r4 == 0) goto L28
            r2 = 4
            java.lang.String r1 = r1.substring(r2)
            goto L33
        L28:
            java.lang.String r4 = "EXP"
            boolean r4 = r4.equals(r1)
            if (r4 == 0) goto L32
        L30:
            r1 = r3
            goto L33
        L32:
            r0 = r2
        L33:
            java.lang.String r1 = toJavaHandshakeAlgo(r1, r0)
            r2 = 2
            java.lang.String r2 = r5.group(r2)
            java.lang.String r0 = toJavaBulkCipher(r2, r0)
            r2 = 3
            java.lang.String r5 = r5.group(r2)
            java.lang.String r5 = toJavaHmacAlgo(r5)
            java.lang.StringBuilder r2 = new java.lang.StringBuilder
            r2.<init>()
            r2.append(r1)
            java.lang.String r1 = "_WITH_"
            r2.append(r1)
            r2.append(r0)
            r1 = 95
            r2.append(r1)
            r2.append(r5)
            java.lang.String r5 = r2.toString()
            java.lang.String r1 = "CHACHA20"
            boolean r0 = r0.contains(r1)
            if (r0 == 0) goto L73
            java.lang.String r0 = "_SHA256"
            java.lang.String r5 = g.a.a.a.a.t(r5, r0)
        L73:
            return r5
        */
        throw new UnsupportedOperationException("Method not decompiled: io.netty.handler.ssl.CipherSuiteConverter.toJavaUncached(java.lang.String):java.lang.String");
    }

    public static String toOpenSsl(Iterable<String> iterable) {
        String next;
        StringBuilder sb = new StringBuilder();
        Iterator<String> it = iterable.iterator();
        while (it.hasNext() && (next = it.next()) != null) {
            String openSsl = toOpenSsl(next);
            if (openSsl != null) {
                next = openSsl;
            }
            sb.append(next);
            sb.append(AbstractJsonLexerKt.COLON);
        }
        if (sb.length() <= 0) {
            return "";
        }
        sb.setLength(sb.length() - 1);
        return sb.toString();
    }

    public static String toOpenSsl(String str) {
        String str2 = j2o.get(str);
        return str2 != null ? str2 : cacheFromJava(str);
    }

    private static String toOpenSslBulkCipher(String str) {
        if (str.startsWith("AES_")) {
            Matcher matcher = JAVA_AES_CBC_PATTERN.matcher(str);
            if (matcher.matches()) {
                return matcher.replaceFirst("$1$2");
            }
            Matcher matcher2 = JAVA_AES_PATTERN.matcher(str);
            if (matcher2.matches()) {
                return matcher2.replaceFirst("$1$2-$3");
            }
        }
        return "3DES_EDE_CBC".equals(str) ? "DES-CBC3" : ("RC4_128".equals(str) || "RC4_40".equals(str)) ? "RC4" : ("DES40_CBC".equals(str) || "DES_CBC_40".equals(str)) ? "DES-CBC" : "RC2_CBC_40".equals(str) ? "RC2-CBC" : str.replace('_', '-');
    }

    private static String toOpenSslHandshakeAlgo(String str) {
        boolean zEndsWith = str.endsWith("_EXPORT");
        if (zEndsWith) {
            str = str.substring(0, str.length() - 7);
        }
        if (OpenSslKeyMaterialManager.KEY_TYPE_RSA.equals(str)) {
            str = "";
        } else if (str.endsWith("_anon")) {
            StringBuilder sbE = a.E('A');
            sbE.append(str.substring(0, str.length() - 5));
            str = sbE.toString();
        }
        if (zEndsWith) {
            str = str.isEmpty() ? "EXP" : a.t("EXP-", str);
        }
        return str.replace('_', '-');
    }

    private static String toOpenSslHmacAlgo(String str) {
        return str;
    }

    public static String toOpenSslUncached(String str) {
        Matcher matcher = JAVA_CIPHERSUITE_PATTERN.matcher(str);
        if (!matcher.matches()) {
            return null;
        }
        String openSslHandshakeAlgo = toOpenSslHandshakeAlgo(matcher.group(1));
        String openSslBulkCipher = toOpenSslBulkCipher(matcher.group(2));
        String openSslHmacAlgo = toOpenSslHmacAlgo(matcher.group(3));
        if (openSslHandshakeAlgo.isEmpty()) {
            return a.k(openSslBulkCipher, '-', openSslHmacAlgo);
        }
        if (openSslBulkCipher.contains("CHACHA20")) {
            return a.k(openSslHandshakeAlgo, '-', openSslBulkCipher);
        }
        return openSslHandshakeAlgo + '-' + openSslBulkCipher + '-' + openSslHmacAlgo;
    }
}