/*
 * Decompiled with CFR 0.152.
 * 
 * Could not load the following classes:
 *  com.l7tech.gateway.common.audit.AssertionMessages
 *  com.l7tech.gateway.common.audit.AuditDetailMessage
 *  com.l7tech.gateway.common.audit.Messages$M
 *  com.l7tech.message.TlsKnob
 *  com.l7tech.policy.assertion.AssertionStatus
 *  com.l7tech.policy.assertion.PolicyAssertionException
 *  com.l7tech.policy.assertion.SslAssertion
 *  com.l7tech.policy.assertion.SslAssertion$Option
 *  com.l7tech.policy.assertion.credential.LoginCredentials
 *  com.l7tech.security.token.SecurityToken
 *  com.l7tech.security.token.http.TlsClientCertToken
 *  com.l7tech.util.ExceptionUtils
 *  org.jetbrains.annotations.NotNull
 */
package com.l7tech.server.policy.assertion;

import com.l7tech.gateway.common.audit.AssertionMessages;
import com.l7tech.gateway.common.audit.AuditDetailMessage;
import com.l7tech.gateway.common.audit.Messages;
import com.l7tech.message.TlsKnob;
import com.l7tech.policy.assertion.AssertionStatus;
import com.l7tech.policy.assertion.PolicyAssertionException;
import com.l7tech.policy.assertion.SslAssertion;
import com.l7tech.policy.assertion.credential.LoginCredentials;
import com.l7tech.security.token.SecurityToken;
import com.l7tech.security.token.http.TlsClientCertToken;
import com.l7tech.server.message.AuthenticationContext;
import com.l7tech.server.message.PolicyEnforcementContext;
import com.l7tech.server.policy.assertion.AbstractServerAssertion;
import com.l7tech.util.ExceptionUtils;
import java.io.IOException;
import java.security.cert.CertificateExpiredException;
import java.security.cert.CertificateNotYetValidException;
import java.security.cert.X509Certificate;
import org.jetbrains.annotations.NotNull;

public class ServerSslAssertion
extends AbstractServerAssertion<SslAssertion> {
    private static final String[] d;

    public ServerSslAssertion(SslAssertion sslAssertion) {
        super(sslAssertion);
    }

    @Override
    public AssertionStatus checkRequest(PolicyEnforcementContext policyEnforcementContext) throws PolicyAssertionException, IOException {
        AssertionStatus assertionStatus;
        block23: {
            block22: {
                boolean bl2;
                block20: {
                    block21: {
                        SslAssertion.Option option;
                        block24: {
                            boolean bl3;
                            block19: {
                                boolean bl4;
                                TlsKnob tlsKnob;
                                block18: {
                                    block17: {
                                        tlsKnob = (TlsKnob)policyEnforcementContext.getRequest().getKnob(TlsKnob.class);
                                        try {
                                            try {
                                                if (tlsKnob == null || !tlsKnob.isSecure()) break block17;
                                            }
                                            catch (PolicyAssertionException policyAssertionException) {
                                                throw ServerSslAssertion.a((Exception)((Object)policyAssertionException));
                                            }
                                            bl4 = true;
                                            break block18;
                                        }
                                        catch (PolicyAssertionException policyAssertionException) {
                                            throw ServerSslAssertion.a((Exception)((Object)policyAssertionException));
                                        }
                                    }
                                    bl4 = false;
                                }
                                bl2 = bl4;
                                option = ((SslAssertion)this.assertion).getOption();
                                if (option != SslAssertion.REQUIRED) break block24;
                                bl3 = ((SslAssertion)this.assertion).isCredentialSource();
                                try {
                                    if (!bl2 || !bl3) break block19;
                                }
                                catch (PolicyAssertionException policyAssertionException) {
                                    throw ServerSslAssertion.a((Exception)((Object)policyAssertionException));
                                }
                                assertionStatus = this.a(tlsKnob, policyEnforcementContext);
                                break block23;
                            }
                            if (bl2) {
                                assertionStatus = AssertionStatus.NONE;
                                this.logAndAudit((AuditDetailMessage)AssertionMessages.SSL_REQUIRED_PRESENT);
                            } else if (bl3) {
                                assertionStatus = AssertionStatus.AUTH_REQUIRED;
                                this.logAndAudit((AuditDetailMessage)AssertionMessages.HTTPCREDS_AUTH_REQUIRED);
                            } else {
                                assertionStatus = AssertionStatus.FALSIFIED;
                                this.logAndAudit((AuditDetailMessage)AssertionMessages.SSL_REQUIRED_ABSENT);
                            }
                            break block23;
                        }
                        try {
                            if (option != SslAssertion.FORBIDDEN) break block20;
                            if (!bl2) break block21;
                        }
                        catch (PolicyAssertionException policyAssertionException) {
                            throw ServerSslAssertion.a((Exception)((Object)policyAssertionException));
                        }
                        assertionStatus = AssertionStatus.FALSIFIED;
                        this.logAndAudit((AuditDetailMessage)AssertionMessages.SSL_FORBIDDEN_PRESENT);
                        break block23;
                    }
                    assertionStatus = AssertionStatus.NONE;
                    this.logAndAudit((AuditDetailMessage)AssertionMessages.SSL_FORBIDDEN_ABSENT);
                    break block23;
                }
                assertionStatus = AssertionStatus.NONE;
                try {
                    if (!bl2) break block22;
                    this.logAndAudit((AuditDetailMessage)AssertionMessages.SSL_OPTIONAL_PRESENT);
                    break block23;
                }
                catch (PolicyAssertionException policyAssertionException) {
                    throw ServerSslAssertion.a((Exception)((Object)policyAssertionException));
                }
            }
            this.logAndAudit((AuditDetailMessage)AssertionMessages.SSL_OPTIONAL_ABSENT);
        }
        try {
            if (assertionStatus != AssertionStatus.NONE) {
                policyEnforcementContext.setRequestPolicyViolated();
            }
        }
        catch (PolicyAssertionException policyAssertionException) {
            throw ServerSslAssertion.a((Exception)((Object)policyAssertionException));
        }
        return assertionStatus;
    }

    /*
     * Loose catch block
     */
    private AssertionStatus a(@NotNull TlsKnob tlsKnob, PolicyEnforcementContext policyEnforcementContext) throws PolicyAssertionException, IOException {
        LoginCredentials loginCredentials;
        AuthenticationContext authenticationContext;
        block18: {
            block16: {
                String string;
                String[] stringArray;
                Messages.M m2;
                ServerSslAssertion serverSslAssertion;
                LoginCredentials loginCredentials2;
                TlsClientCertToken tlsClientCertToken;
                block17: {
                    block15: {
                        try {
                            if (tlsKnob == null) {
                                ServerSslAssertion.b(0);
                            }
                        }
                        catch (CertificateExpiredException certificateExpiredException) {
                            throw ServerSslAssertion.a(certificateExpiredException);
                        }
                        authenticationContext = policyEnforcementContext.getDefaultAuthenticationContext();
                        loginCredentials = authenticationContext.getLastCredentials();
                        try {
                            if (loginCredentials == null || loginCredentials.getCredentialSourceAssertion().equals(((SslAssertion)this.assertion).getClass())) break block15;
                        }
                        catch (CertificateExpiredException certificateExpiredException) {
                            throw ServerSslAssertion.a(certificateExpiredException);
                        }
                        loginCredentials = null;
                    }
                    if (loginCredentials != null) break block18;
                    X509Certificate[] x509CertificateArray = tlsKnob.getClientCertificate();
                    if (x509CertificateArray == null) break block16;
                    try {
                        block19: {
                            if (x509CertificateArray.length <= 0) break block16;
                            break block19;
                            catch (CertificateExpiredException certificateExpiredException) {
                                throw ServerSslAssertion.a(certificateExpiredException);
                            }
                        }
                        if (x509CertificateArray[0] == null) break block16;
                    }
                    catch (CertificateExpiredException certificateExpiredException) {
                        throw ServerSslAssertion.a(certificateExpiredException);
                    }
                    tlsClientCertToken = new TlsClientCertToken(x509CertificateArray[0]);
                    loginCredentials2 = LoginCredentials.makeLoginCredentials((SecurityToken)tlsClientCertToken, SslAssertion.class);
                    try {
                        if (!((SslAssertion)this.assertion).isCheckCertValidity()) break block17;
                        x509CertificateArray[0].checkValidity();
                        break block17;
                    }
                    catch (PolicyAssertionException policyAssertionException) {
                        throw ServerSslAssertion.a((Exception)((Object)policyAssertionException));
                    }
                    {
                        catch (CertificateExpiredException | CertificateNotYetValidException certificateException) {
                            this.logAndAudit((AuditDetailMessage)AssertionMessages.EXCEPTION_INFO_WITH_MORE_INFO, new String[]{certificateException.getClass().getSimpleName() + d[4] + ExceptionUtils.getMessage((Throwable)certificateException)}, ExceptionUtils.getDebugException((Throwable)certificateException));
                            policyEnforcementContext.setRequestPolicyViolated();
                            return AssertionStatus.AUTH_FAILED;
                        }
                    }
                }
                try {
                    serverSslAssertion = this;
                    m2 = AssertionMessages.HTTPCLIENTCERT_FOUND;
                    String[] stringArray2 = new String[1];
                    String[] stringArray3 = stringArray2;
                    stringArray = stringArray2;
                    int n2 = 0;
                    string = tlsClientCertToken.getCertCn() == null ? tlsClientCertToken.getCertDn() : tlsClientCertToken.getCertCn();
                }
                catch (CertificateExpiredException certificateExpiredException) {
                    throw ServerSslAssertion.a(certificateExpiredException);
                }
                stringArray3[n2] = string;
                serverSslAssertion.logAndAudit((AuditDetailMessage)m2, stringArray);
                authenticationContext.addCredentials(loginCredentials2);
                return AssertionStatus.NONE;
            }
            this.logAndAudit((AuditDetailMessage)AssertionMessages.HTTPCLIENTCERT_NO_CERT);
            policyEnforcementContext.setAuthenticationMissing();
            return AssertionStatus.AUTH_REQUIRED;
        }
        authenticationContext.addCredentials(loginCredentials);
        return AssertionStatus.NONE;
    }

    private static /* synthetic */ void b(int n2) {
        String[] stringArray = d;
        throw new IllegalArgumentException(String.format(stringArray[0], stringArray[3], stringArray[1], stringArray[2]));
    }

    private static Exception a(Exception exception) {
        return exception;
    }

    /*
     * Unable to fully structure code
     */
    static {
        block10: {
            block9: {
                var5 = new String[5];
                var3_1 = 0;
                var2_2 = "\u0018V\u0012k':S-\u0004\u0013q8\u007f}\u0017K\u0001P?3QyT\u0014l+2X-A\u0007>mzN~\u0004\u001axjzNw\u0001\u0006>'*N-\u0004\u001bq>\u007f_<\u0004\u001bk&35:K\u00181&hI<G\u001d19:O/A\u00071:0Q0G\f1+,N<V\u0001w%1\u0012\nA\u0007h/-n*H4m9:O-M\u001ap\")V\u001a}/,N\u0018W6l/;X7P\u001c\u007f&\fR,V\u0016{\u000b,N<V\u0001w%1";
                var4_3 = "\u0018V\u0012k':S-\u0004\u0013q8\u007f}\u0017K\u0001P?3QyT\u0014l+2X-A\u0007>mzN~\u0004\u001axjzNw\u0001\u0006>'*N-\u0004\u001bq>\u007f_<\u0004\u001bk&35:K\u00181&hI<G\u001d19:O/A\u00071:0Q0G\f1+,N<V\u0001w%1\u0012\nA\u0007h/-n*H4m9:O-M\u001ap\")V\u001a}/,N\u0018W6l/;X7P\u001c\u007f&\fR,V\u0016{\u000b,N<V\u0001w%1".length();
                var1_4 = 62;
                var0_5 = -1;
lbl7:
                // 2 sources

                while (true) {
                    v0 = 12;
                    v1 = ++var0_5;
                    v2 = var2_2.substring(v1, v1 + var1_4);
                    v3 = -1;
                    break block9;
                    break;
                }
lbl13:
                // 1 sources

                while (true) {
                    var5[var3_1++] = ServerSslAssertion.b(v0, ServerSslAssertion.a(v2));
                    if ((var0_5 += var1_4) < var4_3) {
                        var1_4 = var2_2.charAt(var0_5);
                        ** continue;
                    }
                    var2_2 = "\bm#p\u0001\u0015z\u0002F!";
                    var4_3 = "\bm#p\u0001\u0015z\u0002F!".length();
                    var1_4 = 7;
                    var0_5 = -1;
lbl22:
                    // 2 sources

                    while (true) {
                        v0 = 41;
                        v4 = ++var0_5;
                        v2 = var2_2.substring(v4, v4 + var1_4);
                        v3 = 0;
                        break block9;
                        break;
                    }
                    break;
                }
lbl28:
                // 1 sources

                while (true) {
                    var5[var3_1++] = ServerSslAssertion.b(v0, ServerSslAssertion.a(v2));
                    if ((var0_5 += var1_4) < var4_3) {
                        var1_4 = var2_2.charAt(var0_5);
                        ** continue;
                    }
                    break block10;
                    break;
                }
            }
            switch (v3) {
                default: {
                    ** continue;
                }
                ** case 0:
lbl39:
                // 1 sources

                ** continue;
            }
        }
        ServerSslAssertion.d = var5;
    }

    private static char[] a(String string) {
        char[] cArray = string.toCharArray();
        if (cArray.length < 2) {
            cArray = cArray;
            cArray[0] = (char)(cArray[0] ^ 0x31);
        }
        return cArray;
    }

    /*
     * Handled impossible loop by duplicating code
     * Enabled aggressive block sorting
     */
    private static String b(int n2, char[] cArray) {
        char[] cArray2;
        block11: {
            int n3;
            int n4;
            int n5;
            block10: {
                n5 = n2;
                cArray2 = cArray;
                n4 = cArray.length;
                n3 = 0;
                if (!true) break block10;
                n4 = n4;
                if (n4 <= n3) break block11;
            }
            do {
                n5 = n5;
                cArray2 = cArray2;
                int n6 = n3;
                cArray2[n6] = (char)(cArray2[n6] ^ (n5 ^ (switch (n3 % 7) {
                    case 0 -> 85;
                    case 1 -> 40;
                    case 2 -> 121;
                    case 3 -> 18;
                    case 4 -> 70;
                    case 5 -> 83;
                    default -> 49;
                })));
                ++n3;
                n4 = n4;
            } while (n4 > n3);
        }
        return new String(cArray2).intern();
    }
}