package org.snmp4j.transport.tls;

import java.security.Principal;
import java.security.cert.CertificateParsingException;
import java.security.cert.X509Certificate;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import org.snmp4j.log.LogAdapter;
import org.snmp4j.log.LogFactory;
import org.snmp4j.smi.Address;
import org.snmp4j.smi.OctetString;
import org.snmp4j.transport.TLSTM;
import org.snmp4j.transport.tls.SecurityNameMapping;

/* JADX INFO: loaded from: classes.dex */
public class DefaultTlsTmSecurityCallback implements TlsTmSecurityCallback<X509Certificate> {
    private LogAdapter LOGGER = LogFactory.getLogger(DefaultTlsTmSecurityCallback.class);
    private Map<SecurityNameMapping, OctetString> securityNameMapping = new HashMap();
    private Map<Address, String> localCertMapping = new HashMap();
    private Set<String> acceptedSubjectDN = new HashSet();
    private Set<String> acceptedIssuerDN = new HashSet();

    /* JADX INFO: renamed from: org.snmp4j.transport.tls.DefaultTlsTmSecurityCallback$1, reason: invalid class name */
    static /* synthetic */ class AnonymousClass1 {
        static final /* synthetic */ int[] $SwitchMap$org$snmp4j$transport$tls$SecurityNameMapping$CertMappingType;

        static {
            int[] iArr = new int[SecurityNameMapping.CertMappingType.values().length];
            $SwitchMap$org$snmp4j$transport$tls$SecurityNameMapping$CertMappingType = iArr;
            try {
                iArr[SecurityNameMapping.CertMappingType.Specified.ordinal()] = 1;
            } catch (NoSuchFieldError unused) {
            }
            try {
                $SwitchMap$org$snmp4j$transport$tls$SecurityNameMapping$CertMappingType[SecurityNameMapping.CertMappingType.SANAny.ordinal()] = 2;
            } catch (NoSuchFieldError unused2) {
            }
            try {
                $SwitchMap$org$snmp4j$transport$tls$SecurityNameMapping$CertMappingType[SecurityNameMapping.CertMappingType.SANRFC822Name.ordinal()] = 3;
            } catch (NoSuchFieldError unused3) {
            }
            try {
                $SwitchMap$org$snmp4j$transport$tls$SecurityNameMapping$CertMappingType[SecurityNameMapping.CertMappingType.SANDNSName.ordinal()] = 4;
            } catch (NoSuchFieldError unused4) {
            }
            try {
                $SwitchMap$org$snmp4j$transport$tls$SecurityNameMapping$CertMappingType[SecurityNameMapping.CertMappingType.SANIpAddress.ordinal()] = 5;
            } catch (NoSuchFieldError unused5) {
            }
            try {
                $SwitchMap$org$snmp4j$transport$tls$SecurityNameMapping$CertMappingType[SecurityNameMapping.CertMappingType.CommonName.ordinal()] = 6;
            } catch (NoSuchFieldError unused6) {
            }
        }
    }

    private OctetString mapCertToTSN(X509Certificate x509Certificate, SecurityNameMapping.CertMappingType certMappingType, OctetString octetString) throws CertificateParsingException {
        switch (AnonymousClass1.$SwitchMap$org$snmp4j$transport$tls$SecurityNameMapping$CertMappingType[certMappingType.ordinal()]) {
            case 1:
                return octetString;
            case 2:
            case 3:
                Object subjAltName = TLSTM.getSubjAltName(x509Certificate.getSubjectAlternativeNames(), 1);
                if (subjAltName != null) {
                    String[] strArrSplit = ((String) subjAltName).split("@");
                    return new OctetString(strArrSplit[0] + "@" + strArrSplit[1].toLowerCase());
                }
            case 4:
                Object subjAltName2 = TLSTM.getSubjAltName(x509Certificate.getSubjectAlternativeNames(), 2);
                if (subjAltName2 != null) {
                    return new OctetString(((String) subjAltName2).toLowerCase());
                }
            case 5:
                Object subjAltName3 = TLSTM.getSubjAltName(x509Certificate.getSubjectAlternativeNames(), 7);
                if (subjAltName3 != null) {
                    String lowerCase = ((String) subjAltName3).toLowerCase();
                    if (lowerCase.indexOf(58) < 0) {
                        return new OctetString(lowerCase);
                    }
                    StringBuilder sb = new StringBuilder(16);
                    for (String str : lowerCase.split(":")) {
                        for (int length = 2 - str.length(); length > 0; length--) {
                            sb.append('0');
                        }
                        sb.append(str);
                    }
                    return new OctetString(sb.toString());
                }
            case 6:
                return new OctetString(x509Certificate.getSubjectX500Principal().getName());
            default:
                return null;
        }
    }

    public void addAcceptedIssuerDN(String str) {
        this.acceptedIssuerDN.add(str);
    }

    public void addAcceptedSubjectDN(String str) {
        this.acceptedSubjectDN.add(str);
    }

    public void addLocalCertMapping(Address address, String str) {
        this.localCertMapping.put(address, str);
    }

    public void addSecurityNameMapping(OctetString octetString, SecurityNameMapping.CertMappingType certMappingType, OctetString octetString2, OctetString octetString3) {
        this.securityNameMapping.put(new SecurityNameMapping(octetString, octetString2, certMappingType, octetString3), octetString3);
    }

    @Override // org.snmp4j.transport.tls.TlsTmSecurityCallback
    public String getLocalCertificateAlias(Address address) {
        String str = this.localCertMapping.get(address);
        return str == null ? this.localCertMapping.get(null) : str;
    }

    public boolean removeAcceptedIssuerDN(String str) {
        return this.acceptedIssuerDN.remove(str);
    }

    public boolean removeAcceptedSubjectDN(String str) {
        return this.acceptedSubjectDN.remove(str);
    }

    public String removeLocalCertMapping(Address address) {
        return this.localCertMapping.remove(address);
    }

    public OctetString removeSecurityNameMapping(OctetString octetString, SecurityNameMapping.CertMappingType certMappingType, OctetString octetString2) {
        return this.securityNameMapping.remove(new SecurityNameMapping(octetString, octetString2, certMappingType, null));
    }

    @Override // org.snmp4j.transport.tls.TlsTmSecurityCallback
    public OctetString getSecurityName(X509Certificate[] x509CertificateArr) {
        OctetString octetStringMapCertToTSN;
        for (Map.Entry<SecurityNameMapping, OctetString> entry : this.securityNameMapping.entrySet()) {
            OctetString fingerprint = entry.getKey().getFingerprint();
            for (X509Certificate x509Certificate : x509CertificateArr) {
                OctetString fingerprint2 = TLSTM.getFingerprint(x509Certificate);
                if (fingerprint2 != null && fingerprint2.equals(fingerprint)) {
                    try {
                        octetStringMapCertToTSN = mapCertToTSN(x509Certificate, entry.getKey().getType(), entry.getKey().getData());
                    } catch (CertificateParsingException e2) {
                        this.LOGGER.warn("Failed to parse client certificate: " + e2.getMessage());
                        octetStringMapCertToTSN = null;
                    }
                    if (octetStringMapCertToTSN != null && octetStringMapCertToTSN.length() <= 32) {
                        return octetStringMapCertToTSN;
                    }
                }
            }
        }
        return null;
    }

    @Override // org.snmp4j.transport.tls.TlsTmSecurityCallback
    public boolean isAcceptedIssuer(X509Certificate x509Certificate) {
        Principal issuerDN = x509Certificate.getIssuerDN();
        return issuerDN != null && this.acceptedIssuerDN.contains(issuerDN.getName());
    }

    @Override // org.snmp4j.transport.tls.TlsTmSecurityCallback
    public boolean isClientCertificateAccepted(X509Certificate x509Certificate) {
        return this.acceptedSubjectDN.contains(x509Certificate.getSubjectDN().getName());
    }

    @Override // org.snmp4j.transport.tls.TlsTmSecurityCallback
    public boolean isServerCertificateAccepted(X509Certificate[] x509CertificateArr) {
        if (this.acceptedSubjectDN.contains(x509CertificateArr[0].getSubjectDN().getName())) {
            return true;
        }
        for (X509Certificate x509Certificate : x509CertificateArr) {
            Principal issuerDN = x509Certificate.getIssuerDN();
            if (issuerDN != null && this.acceptedIssuerDN.contains(issuerDN.getName())) {
                return true;
            }
        }
        return false;
    }
}