/*
 * Decompiled with CFR 0.152.
 * 
 * Could not load the following classes:
 *  com.l7tech.common.http.HttpConstants
 *  com.l7tech.common.http.prov.apache.components.HttpComponentsClient
 *  com.l7tech.gateway.common.audit.AssertionMessages
 *  com.l7tech.gateway.common.audit.AuditDetailMessage
 *  com.l7tech.kerberos.KerberosClient
 *  com.l7tech.kerberos.KerberosException
 *  com.l7tech.kerberos.KerberosGSSAPReqTicket
 *  com.l7tech.kerberos.KerberosServiceTicket
 *  com.l7tech.message.HttpRequestKnob
 *  com.l7tech.message.HttpResponseKnob
 *  com.l7tech.message.Message
 *  com.l7tech.message.TcpKnob
 *  com.l7tech.policy.assertion.AssertionStatus
 *  com.l7tech.policy.assertion.PolicyAssertionException
 *  com.l7tech.policy.assertion.credential.CredentialFinderException
 *  com.l7tech.policy.assertion.credential.LoginCredentials
 *  com.l7tech.policy.assertion.credential.http.HttpNegotiate
 *  com.l7tech.security.token.SecurityToken
 *  com.l7tech.security.token.http.HttpNegotiateToken
 *  com.l7tech.util.ArrayUtils
 *  com.l7tech.util.ExceptionUtils
 *  com.l7tech.util.HexUtils
 *  com.l7tech.util.Pair
 */
package com.l7tech.server.policy.assertion.credential.http;

import com.l7tech.common.http.HttpConstants;
import com.l7tech.common.http.prov.apache.components.HttpComponentsClient;
import com.l7tech.gateway.common.audit.AssertionMessages;
import com.l7tech.gateway.common.audit.AuditDetailMessage;
import com.l7tech.kerberos.KerberosClient;
import com.l7tech.kerberos.KerberosException;
import com.l7tech.kerberos.KerberosGSSAPReqTicket;
import com.l7tech.kerberos.KerberosServiceTicket;
import com.l7tech.message.HttpRequestKnob;
import com.l7tech.message.HttpResponseKnob;
import com.l7tech.message.Message;
import com.l7tech.message.TcpKnob;
import com.l7tech.policy.assertion.AssertionStatus;
import com.l7tech.policy.assertion.PolicyAssertionException;
import com.l7tech.policy.assertion.credential.CredentialFinderException;
import com.l7tech.policy.assertion.credential.LoginCredentials;
import com.l7tech.policy.assertion.credential.http.HttpNegotiate;
import com.l7tech.security.token.SecurityToken;
import com.l7tech.security.token.http.HttpNegotiateToken;
import com.l7tech.server.message.PolicyEnforcementContext;
import com.l7tech.server.policy.assertion.credential.http.ServerHttpCredentialSource;
import com.l7tech.util.ArrayUtils;
import com.l7tech.util.ExceptionUtils;
import com.l7tech.util.HexUtils;
import com.l7tech.util.Pair;
import java.io.IOException;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Collections;
import java.util.Map;
import java.util.logging.Level;

public class ServerHttpNegotiate
extends ServerHttpCredentialSource<HttpNegotiate> {
    private final ThreadLocal<Pair<Object, LoginCredentials>> d = new ThreadLocal();
    private static final String[] g;

    public ServerHttpNegotiate(HttpNegotiate httpNegotiate) {
        super(httpNegotiate);
    }

    @Override
    public AssertionStatus checkRequest(PolicyEnforcementContext policyEnforcementContext) throws IOException, PolicyAssertionException {
        AssertionStatus assertionStatus;
        block6: {
            assertionStatus = super.checkRequest(policyEnforcementContext);
            if (assertionStatus == AssertionStatus.NONE) {
                LoginCredentials loginCredentials = policyEnforcementContext.getDefaultAuthenticationContext().getLastCredentials();
                try {
                    if (loginCredentials == null || !(loginCredentials.getPayload() instanceof KerberosServiceTicket)) break block6;
                }
                catch (IOException iOException) {
                    throw ServerHttpNegotiate.b(iOException);
                }
                KerberosServiceTicket kerberosServiceTicket = (KerberosServiceTicket)loginCredentials.getPayload();
                try {
                    policyEnforcementContext.setVariable(HttpNegotiate.KERBEROS_REALM, this.b(kerberosServiceTicket.getClientPrincipalName()));
                    if (null != kerberosServiceTicket.getEncData()) {
                        policyEnforcementContext.setVariable(HttpNegotiate.KERBEROS_DATA, kerberosServiceTicket.getEncData());
                    }
                }
                catch (IOException iOException) {
                    throw ServerHttpNegotiate.b(iOException);
                }
            }
        }
        return assertionStatus;
    }

    @Override
    protected Map<String, String> challengeParams(Message message, Map<String, String> map) {
        return Collections.emptyMap();
    }

    @Override
    protected String scheme() {
        return HttpComponentsClient.NEGOTIATE_SCHEME;
    }

    @Override
    protected LoginCredentials findCredentials(Message message, Map<String, String> map) throws IOException, CredentialFinderException {
        HttpRequestKnob httpRequestKnob = message.getHttpRequestKnob();
        String string = httpRequestKnob.getHeaderSingleValue(HttpConstants.HEADER_AUTHORIZATION);
        Object object = httpRequestKnob.getConnectionIdentifier();
        return this.a(message, string, object, map);
    }

    @Override
    protected String realm() {
        return "";
    }

    @Override
    protected AssertionStatus checkAuthParams(Map map) {
        return AssertionStatus.NONE;
    }

    /*
     * Unable to fully structure code
     */
    private LoginCredentials a(Message var1_1, String var2_2, Object var3_3, Map<String, String> var4_4) throws IOException {
        block23: {
            block24: {
                block25: {
                    block20: {
                        block22: {
                            block21: {
                                try {
                                    if (var2_2 != null && var2_2.length() != 0) break block20;
                                }
                                catch (KerberosException v0) {
                                    throw ServerHttpNegotiate.b((Exception)v0);
                                }
                                var5_5 = this.a(var3_3);
                                try {
                                    if (var5_5 == null) break block21;
                                    this.logAndAudit((AuditDetailMessage)AssertionMessages.HTTPNEGOTIATE_USING_CONN_CREDS);
                                    break block22;
                                }
                                catch (KerberosException v1) {
                                    throw ServerHttpNegotiate.b((Exception)v1);
                                }
                            }
                            this.logAndAudit((AuditDetailMessage)AssertionMessages.HTTPCREDS_NO_AUTHN_HEADER);
                        }
                        return var5_5;
                    }
                    var5_6 = var2_2.indexOf(" ");
                    try {
                        if (var5_6 < 0) {
                            this.logAndAudit((AuditDetailMessage)AssertionMessages.HTTPCREDS_NA_AUTHN_HEADER);
                            return null;
                        }
                    }
                    catch (KerberosException v2) {
                        throw ServerHttpNegotiate.b((Exception)v2);
                    }
                    var6_7 = var2_2.substring(0, var5_6);
                    var7_8 = var2_2.substring(var5_6 + 1);
                    var8_9 = HexUtils.decodeBase64((String)var7_8, (boolean)true);
                    if (!this.scheme().equals(var6_7)) ** GOTO lbl36
                    if (var8_9.length != 0) break block23;
                    break block25;
                    catch (KerberosException v3) {
                        throw ServerHttpNegotiate.b((Exception)v3);
                    }
                }
                try {
                    block26: {
                        this.logAndAudit((AuditDetailMessage)AssertionMessages.HTTPCREDS_NA_AUTHN_HEADER);
                        if (!var6_7.equals(HttpComponentsClient.NTLM_SCHEME)) break block24;
                        break block26;
                        catch (KerberosException v4) {
                            throw ServerHttpNegotiate.b((Exception)v4);
                        }
                    }
                    var4_4.put(HttpComponentsClient.NTLM_SCHEME, var7_8);
                    this.logAndAudit((AuditDetailMessage)AssertionMessages.HTTPNEGOTIATE_NTLM_AUTH);
                }
                catch (KerberosException v5) {
                    throw ServerHttpNegotiate.b((Exception)v5);
                }
            }
            return null;
        }
        try {
            if (ArrayUtils.matchSubarrayOrPrefix((byte[])var8_9, (int)0, (int)1, (byte[])HttpComponentsClient.NTLM_MESSAGE_PREFIX, (int)0) > -1) {
                var4_4.put(HttpComponentsClient.NTLM_SCHEME, var7_8);
                this.logAndAudit((AuditDetailMessage)AssertionMessages.HTTPNEGOTIATE_NTLM_AUTH);
                return null;
            }
        }
        catch (KerberosException v6) {
            throw ServerHttpNegotiate.b((Exception)v6);
        }
        var9_10 = new KerberosGSSAPReqTicket(var8_9);
        try {
            var10_11 = new KerberosClient();
            try {
                var11_13 = KerberosClient.getKerberosAcceptPrincipal((String)var1_1.getHttpRequestKnob().getRequestURL().getProtocol(), (String)var1_1.getHttpRequestKnob().getRequestURL().getHost(), (boolean)false);
            }
            catch (KerberosException var12_14) {
                var11_13 = KerberosClient.getGSSServiceName();
            }
            var12_15 = var10_11.getKerberosServiceTicket(var11_13, this.a(var1_1), var9_10);
            var13_16 = LoginCredentials.makeLoginCredentials((SecurityToken)new HttpNegotiateToken(var12_15), ((HttpNegotiate)this.assertion).getClass());
            this.a(var3_3, var13_16);
            return var13_16;
        }
        catch (KerberosException var10_12) {
            this.logAndAudit((AuditDetailMessage)AssertionMessages.HTTPNEGOTIATE_WARNING, new String[]{var10_12.getMessage()}, ExceptionUtils.getDebugException((Throwable)var10_12));
            return null;
        }
    }

    @Override
    protected void challenge(PolicyEnforcementContext policyEnforcementContext, Map<String, String> map) {
        if (!map.containsKey(HttpComponentsClient.NTLM_SCHEME)) {
            StringBuilder stringBuilder = new StringBuilder();
            String string = this.scheme();
            if (map.containsKey(string)) {
                stringBuilder.append(string);
                stringBuilder.append(" ");
                stringBuilder.append(map.get(string));
            } else {
                stringBuilder.append(string);
            }
            String string2 = stringBuilder.toString();
            if (string2.length() > 0) {
                this.logAndAudit((AuditDetailMessage)AssertionMessages.HTTPCREDS_CHALLENGING, string2);
                HttpResponseKnob httpResponseKnob = policyEnforcementContext.getResponse().getHttpResponseKnob();
                httpResponseKnob.addChallenge(string2);
            }
        }
    }

    private void a(Object object, LoginCredentials loginCredentials) {
        this.d.set((Pair<Object, LoginCredentials>)new Pair(object, (Object)loginCredentials));
    }

    private LoginCredentials a(Object object) {
        LoginCredentials loginCredentials = null;
        Pair<Object, LoginCredentials> pair = this.d.get();
        if (pair != null) {
            if (pair.left.equals(object)) {
                loginCredentials = (LoginCredentials)pair.right;
            } else {
                this.d.set(null);
            }
        }
        return loginCredentials;
    }

    private String b(String string) {
        String string2 = "";
        int n2 = string.lastIndexOf("@");
        if (n2 > -1) {
            string2 = string.substring(n2 + 1);
        }
        return string2;
    }

    private InetAddress a(Message message) {
        InetAddress inetAddress = null;
        TcpKnob tcpKnob = (TcpKnob)message.getKnob(TcpKnob.class);
        if (tcpKnob != null) {
            try {
                inetAddress = InetAddress.getByName(tcpKnob.getRemoteAddress());
            }
            catch (UnknownHostException unknownHostException) {
                String[] stringArray = g;
                this.logger.log(Level.INFO, stringArray[1] + tcpKnob.getRemoteAddress() + stringArray[0], ExceptionUtils.getDebugException((Throwable)unknownHostException));
            }
        }
        return inetAddress;
    }

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

    /*
     * Enabled aggressive block sorting
     */
    static {
        String[] stringArray = new String[2];
        int n2 = 0;
        String string = "K0(/q\u007fnw\u0013C\u0003j*aaVL\u0018{*cwW_\tmy\"u\\_Lloo|GHLWZ\"4";
        int n3 = "K0(/q\u007fnw\u0013C\u0003j*aaVL\u0018{*cwW_\tmy\"u\\_Lloo|GHLWZ\"4".length();
        int n4 = 2;
        int n5 = -1;
        while (true) {
            int n6 = ++n5;
            stringArray[n2++] = ServerHttpNegotiate.d(119, ServerHttpNegotiate.f(string.substring(n6, n6 + n4)));
            if ((n5 += n4) >= n3) {
                g = stringArray;
                return;
            }
            n4 = string.charAt(n5);
        }
    }

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

    /*
     * Handled impossible loop by duplicating code
     * Enabled aggressive block sorting
     */
    private static String d(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 -> 27;
                    case 1 -> 105;
                    case 2 -> 125;
                    case 3 -> 117;
                    case 4 -> 100;
                    case 5 -> 68;
                    default -> 90;
                })));
                ++n3;
                n4 = n4;
            } while (n4 > n3);
        }
        return new String(cArray2).intern();
    }
}