package io.netty.handler.ssl;

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;

/* JADX INFO: loaded from: classes.dex */
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)-(?:DSS|RSA|ECDSA)|(?: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("TLS", "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 str2 = "SSL_" + javaUncached;
        String str3 = "TLS_" + javaUncached;
        HashMap map = new HashMap(4);
        map.put("", javaUncached);
        map.put("SSL", str2);
        map.put("TLS", str3);
        o2j.putIfAbsent(str, map);
        j2o.putIfAbsent(str3, str);
        j2o.putIfAbsent(str2, str);
        logger.debug("Cipher suite mapping: {} => {}", str3, str);
        logger.debug("Cipher suite mapping: {} => {}", str2, str);
        return map;
    }

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

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

    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));
    }

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

    private static String toJavaBulkCipher(String str, boolean z) {
        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) ? z ? "RC4_40" : "RC4_128" : "DES-CBC".equals(str) ? z ? "DES_CBC_40" : "DES_CBC" : "RC2-CBC".equals(str) ? z ? "RC2_CBC_40" : "RC2_CBC" : str.replace('-', '_');
    }

    private static String toJavaHandshakeAlgo(String str, boolean z) {
        if (str.length() == 0) {
            str = "RSA";
        } else if ("ADH".equals(str)) {
            str = "DH_anon";
        } else if ("AECDH".equals(str)) {
            str = "ECDH_anon";
        }
        String strReplace = str.replace('-', '_');
        if (!z) {
            return strReplace;
        }
        return strReplace + "_EXPORT";
    }

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

    static String toJavaUncached(String str) {
        Matcher matcher = OPENSSL_CIPHERSUITE_PATTERN.matcher(str);
        if (!matcher.matches()) {
            return null;
        }
        boolean z = true;
        String strGroup = matcher.group(1);
        if (strGroup != null) {
            if (strGroup.startsWith("EXP-")) {
                strGroup = strGroup.substring(4);
            } else if (!"EXP".equals(strGroup)) {
                z = false;
            }
            return toJavaHandshakeAlgo(strGroup, z) + "_WITH_" + toJavaBulkCipher(matcher.group(2), z) + '_' + toJavaHmacAlgo(matcher.group(3));
        }
        z = false;
        strGroup = "";
        return toJavaHandshakeAlgo(strGroup, z) + "_WITH_" + toJavaBulkCipher(matcher.group(2), z) + '_' + toJavaHmacAlgo(matcher.group(3));
    }

    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(':');
        }
        if (sb.length() <= 0) {
            return "";
        }
        sb.setLength(sb.length() - 1);
        return sb.toString();
    }

    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 ("RSA".equals(str)) {
            str = "";
        } else if (str.endsWith("_anon")) {
            str = 'A' + str.substring(0, str.length() - 5);
        }
        if (zEndsWith) {
            if (str.length() == 0) {
                str = "EXP";
            } else {
                str = "EXP-" + str;
            }
        }
        return str.replace('_', '-');
    }

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

    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.length() == 0) {
            return openSslBulkCipher + '-' + openSslHmacAlgo;
        }
        return openSslHandshakeAlgo + '-' + openSslBulkCipher + '-' + openSslHmacAlgo;
    }

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