io.undertow.security.api.AuthenticationMechanism Java Examples

@Override
public AuthenticationMechanism create(String mechanismName,IdentityManager identityManager, FormParserFactory formParserFactory, Map<String, String> properties) {
    String realm = properties.get(REALM);
    String silent = properties.get(SILENT);
    String charsetString = properties.get(CHARSET);
    Charset charset = charsetString == null ? StandardCharsets.UTF_8 : Charset.forName(charsetString);
    Map<Pattern, Charset> userAgentCharsets = new HashMap<>();
    String userAgentString = properties.get(USER_AGENT_CHARSETS);
    if(userAgentString != null) {
        String[] parts = userAgentString.split(",");
        if(parts.length % 2 != 0) {
            throw UndertowMessages.MESSAGES.userAgentCharsetMustHaveEvenNumberOfItems(userAgentString);
        }
        for(int i = 0; i < parts.length; i += 2) {
            Pattern pattern = Pattern.compile(parts[i]);
            Charset c = Charset.forName(parts[i + 1]);
            userAgentCharsets.put(pattern, c);
        }
    }

    return new BasicAuthenticationMechanism(realm, mechanismName, silent != null && silent.equals("true"), identityManager, charset, userAgentCharsets);
}
 

@Override
public AuthenticationMechanism create(String mechanismName, IdentityManager identityManager, FormParserFactory formParserFactory, Map<String, String> properties) {
    String realm = properties.get(REALM);
    String silent = properties.get(SILENT);
    String charsetString = properties.get(CHARSET);
    Charset charset = charsetString == null ? StandardCharsets.UTF_8 : Charset.forName(charsetString);
    Map<Pattern, Charset> userAgentCharsets = new HashMap<>();
    String userAgentString = properties.get(USER_AGENT_CHARSETS);
    if(userAgentString != null) {
        String[] parts = userAgentString.split(",");
        if(parts.length % 2 != 0) {
            throw UndertowMessages.MESSAGES.userAgentCharsetMustHaveEvenNumberOfItems(userAgentString);
        }
        for(int i = 0; i < parts.length; i += 2) {
            Pattern pattern = Pattern.compile(parts[i]);
            Charset c = Charset.forName(parts[i + 1]);
            userAgentCharsets.put(pattern, c);
        }
    }

    return new BasicAuthenticationMechanism(realm, mechanismName, silent != null && silent.equals("true"), identityManager, charset, userAgentCharsets);
}
 

@Override
public AuthenticationMechanism create(String mechanismName, FormParserFactory formParserFactory, Map<String, String> properties) {
    String realm = properties.get(REALM);
    String silent = properties.get(SILENT);
    String charsetString = properties.get(CHARSET);
    Charset charset = charsetString == null ? StandardCharsets.UTF_8 : Charset.forName(charsetString);
    Map<Pattern, Charset> userAgentCharsets = new HashMap<>();
    String userAgentString = properties.get(USER_AGENT_CHARSETS);
    if(userAgentString != null) {
        String[] parts = userAgentString.split(",");
        if(parts.length % 2 != 0) {
            throw UndertowMessages.MESSAGES.userAgentCharsetMustHaveEvenNumberOfItems(userAgentString);
        }
        for(int i = 0; i < parts.length; i += 2) {
            Pattern pattern = Pattern.compile(parts[i]);
            Charset c = Charset.forName(parts[i + 1]);
            userAgentCharsets.put(pattern, c);
        }
    }

    return new com.networknt.oauth.security.LightBasicAuthenticationMechanism(realm, mechanismName, silent != null && silent.equals("true"), identityManager, charset, userAgentCharsets);
}
 

@Override
@Deprecated
public List<AuthenticationMechanism> getAuthenticationMechanisms() {
    List<AuthenticationMechanism> ret = new LinkedList<>();
    Node<AuthenticationMechanism> cur = authMechanisms;
    while (cur != null) {
        ret.add(cur.item);
        cur = cur.next;
    }
    return Collections.unmodifiableList(ret);
}
 

@Override
@Deprecated
public List<AuthenticationMechanism> getAuthenticationMechanisms() {
    List<AuthenticationMechanism> ret = new LinkedList<>();
    Node<AuthenticationMechanism> cur = authMechanisms;
    while (cur != null) {
        ret.add(cur.item);
        cur = cur.next;
    }
    return Collections.unmodifiableList(ret);
}
 

private AuthenticationState transition() {
    if (currentMethod != null) {
        final AuthenticationMechanism mechanism = currentMethod.item;
        currentMethod = currentMethod.next;
        AuthenticationMechanismOutcome outcome = mechanism.authenticate(exchange, SecurityContextImpl.this);
        if(UndertowLogger.SECURITY_LOGGER.isDebugEnabled()) {
            UndertowLogger.SECURITY_LOGGER.debugf("Authentication outcome was %s with method %s for %s", outcome, mechanism, exchange.getRequestURI());
            if(UndertowLogger.SECURITY_LOGGER.isTraceEnabled()) {
                UndertowLogger.SECURITY_LOGGER.tracef("Contents of exchange after authentication attempt is %s", exchange);
            }
        }

        if (outcome == null) {
            throw UndertowMessages.MESSAGES.authMechanismOutcomeNull();
        }

        switch (outcome) {
            case AUTHENTICATED:
                // TODO - Should verify that the mechanism did register an authenticated Account.
                return AuthenticationState.AUTHENTICATED;
            case NOT_AUTHENTICATED:
                // A mechanism attempted to authenticate but could not complete, this now means that
                // authentication is required and challenges need to be sent.
                setAuthenticationRequired();
                return AuthenticationState.ATTEMPTED;
            case NOT_ATTEMPTED:
                // Time to try the next mechanism.
                return transition();
            default:
                throw new IllegalStateException();
        }

    } else {
        // Reached the end of the mechanisms and no mechanism authenticated for us to reach this point.
        return AuthenticationState.ATTEMPTED;
    }
}
 

@Override
public void addAuthenticationMechanism(final AuthenticationMechanism handler) {
    // TODO - Do we want to change this so we can ensure the mechanisms are not modifiable mid request?
    if(authMechanisms == null) {
        authMechanisms = new Node<>(handler);
    } else {
        Node<AuthenticationMechanism> cur = authMechanisms;
        while (cur.next != null) {
            cur = cur.next;
        }
        cur.next = new Node<>(handler);
    }
}
 

private AuthenticationState transition() {
    if (currentMethod != null) {
        final AuthenticationMechanism mechanism = currentMethod.item;
        currentMethod = currentMethod.next;
        ChallengeResult result = mechanism.sendChallenge(exchange, SecurityContextImpl.this);
        if(result == null) {
            throw UndertowMessages.MESSAGES.sendChallengeReturnedNull(mechanism);
        }
        if (result.isChallengeSent()) {
            challengeSent = true;
            Integer desiredCode = result.getDesiredResponseCode();
            if (desiredCode != null && (chosenStatusCode == null || chosenStatusCode.equals(StatusCodes.OK))) {
                chosenStatusCode = desiredCode;
                if (chosenStatusCode.equals(StatusCodes.OK) == false) {
                    if(!exchange.isResponseStarted()) {
                        exchange.setStatusCode(chosenStatusCode);
                    }
                }
            }
        }

        // We always transition so we can reach the end of the list and hit the else.
        return transition();

    } else {
        if(!exchange.isResponseStarted()) {
            // Iterated all mechanisms, if OK it will not be set yet.
            if (chosenStatusCode == null) {
                if (challengeSent == false) {
                    // No mechanism generated a challenge so send a 403 as our challenge - i.e. just rejecting the request.
                    exchange.setStatusCode(StatusCodes.FORBIDDEN);
                }
            } else if (chosenStatusCode.equals(StatusCodes.OK)) {
                exchange.setStatusCode(chosenStatusCode);
            }
        }

        return AuthenticationState.CHALLENGE_SENT;
    }
}
 

@Override
protected List<AuthenticationMechanism> getTestMechanisms() {
    ArrayList<AuthenticationMechanism> mechanisms = new ArrayList<>(super.getTestMechanisms());
    mechanisms.add(BasicAuthenticationTestCase.getTestMechanism());

    return mechanisms;
}
 

@Override
protected List<AuthenticationMechanism> getTestMechanisms() {
    List<DigestQop> qopList = Collections.emptyList();
    AuthenticationMechanism mechanism = new DigestAuthenticationMechanism(Collections.singletonList(DigestAlgorithm.MD5),
            qopList, REALM_NAME, "/", new SimpleNonceManager());

    return Collections.singletonList(mechanism);
}
 

private AuthenticationState transition() {
    if (currentMethod != null) {
        final AuthenticationMechanism mechanism = currentMethod.item;
        currentMethod = currentMethod.next;
        ChallengeResult result = mechanism.sendChallenge(exchange, SecurityContextImpl.this);
        if(result == null) {
            throw UndertowMessages.MESSAGES.sendChallengeReturnedNull(mechanism);
        }
        if (result.isChallengeSent()) {
            challengeSent = true;
            Integer desiredCode = result.getDesiredResponseCode();
            if (desiredCode != null && (chosenStatusCode == null || chosenStatusCode.equals(StatusCodes.OK))) {
                chosenStatusCode = desiredCode;
                if (chosenStatusCode.equals(StatusCodes.OK) == false) {
                    if(!exchange.isResponseStarted()) {
                        exchange.setStatusCode(chosenStatusCode);
                    }
                }
            }
        }

        // We always transition so we can reach the end of the list and hit the else.
        return transition();

    } else {
        if(!exchange.isResponseStarted()) {
            // Iterated all mechanisms, if OK it will not be set yet.
            if (chosenStatusCode == null) {
                if (challengeSent == false) {
                    // No mechanism generated a challenge so send a 403 as our challenge - i.e. just rejecting the request.
                    exchange.setStatusCode(StatusCodes.FORBIDDEN);
                }
            } else if (chosenStatusCode.equals(StatusCodes.OK)) {
                exchange.setStatusCode(chosenStatusCode);
            }
        }

        return AuthenticationState.CHALLENGE_SENT;
    }
}
 

private AuthenticationState transition() {
    if (currentMethod != null) {
        final AuthenticationMechanism mechanism = currentMethod.item;
        currentMethod = currentMethod.next;
        AuthenticationMechanismOutcome outcome = mechanism.authenticate(exchange, SecurityContextImpl.this);
        if(UndertowLogger.SECURITY_LOGGER.isDebugEnabled()) {
            UndertowLogger.SECURITY_LOGGER.tracef("Authentication outcome was %s with method %s for %s", outcome, mechanism, exchange.getRequestURI());
            if(UndertowLogger.SECURITY_LOGGER.isTraceEnabled()) {
                UndertowLogger.SECURITY_LOGGER.tracef("Contents of exchange after authentication attempt is %s", exchange);
            }
        }

        if (outcome == null) {
            throw UndertowMessages.MESSAGES.authMechanismOutcomeNull();
        }

        switch (outcome) {
            case AUTHENTICATED:
                // TODO - Should verify that the mechanism did register an authenticated Account.
                return AuthenticationState.AUTHENTICATED;
            case NOT_AUTHENTICATED:
                // A mechanism attempted to authenticate but could not complete, this now means that
                // authentication is required and challenges need to be sent.
                setAuthenticationRequired();
                return AuthenticationState.ATTEMPTED;
            case NOT_ATTEMPTED:
                // Time to try the next mechanism.
                return transition();
            default:
                throw new IllegalStateException();
        }

    } else {
        // Reached the end of the mechanisms and no mechanism authenticated for us to reach this point.
        return AuthenticationState.ATTEMPTED;
    }
}
 

@Override
protected List<AuthenticationMechanism> getTestMechanisms() {
    ArrayList<AuthenticationMechanism> mechanisms = new ArrayList<>(super.getTestMechanisms());
    mechanisms.add(DigestAuthenticationAuthTestCase.getTestMechanism());

    return mechanisms;
}
 

@Override
public void addAuthenticationMechanism(final AuthenticationMechanism handler) {
    // TODO - Do we want to change this so we can ensure the mechanisms are not modifiable mid request?
    if(authMechanisms == null) {
        authMechanisms = new Node<>(handler);
    } else {
        Node<AuthenticationMechanism> cur = authMechanisms;
        while (cur.next != null) {
            cur = cur.next;
        }
        cur.next = new Node<>(handler);
    }
}
 

@Override
protected List<AuthenticationMechanism> getTestMechanisms() {
    List<AuthenticationMechanism> ret = new ArrayList<>();
    ret.add(new CachedAuthenticatedSessionMechanism());
    ret.add(new FormAuthenticationMechanism("test", "/login", "/error"));
    return ret;
}
 

/**
 * @see io.undertow.server.security.AuthenticationTestBase#getTestMechanisms()
 */
@Override
protected List<AuthenticationMechanism> getTestMechanisms() {
    AuthenticationMechanism mechanism = getTestMechanism();

    return Collections.singletonList(mechanism);
}
 

@Override
public AuthenticationMechanism create(String mechanismName, IdentityManager identityManager, FormParserFactory formParserFactory, Map<String, String> properties) {
    boolean saveOriginal = true;
    if(properties.containsKey(SAVE_ORIGINAL_REQUEST)) {
        saveOriginal = Boolean.parseBoolean(properties.get(SAVE_ORIGINAL_REQUEST));
    }
    return new ServletFormAuthenticationMechanism(formParserFactory, mechanismName, properties.get(LOGIN_PAGE), properties.get(ERROR_PAGE), identityManager, saveOriginal);
}
 

@Override
public AuthenticationMechanism create(String mechanismName, IdentityManager identityManager, FormParserFactory formParserFactory,  Map<String, String> properties) {
    boolean saveOriginal = true;
    if(properties.containsKey(SAVE_ORIGINAL_REQUEST)) {
        saveOriginal = Boolean.parseBoolean(properties.get(SAVE_ORIGINAL_REQUEST));
    }
    return new ServletFormAuthenticationMechanism( formParserFactory, mechanismName, properties.get(LOGIN_PAGE), properties.get(ERROR_PAGE), identityManager,  saveOriginal);
}
 

private AuthenticationMechanism mechanism(final boolean opera, final boolean digest) {
    if (digest) {
        return opera ? fakeRealmdigestMechanism : digestMechanism;
    } else {
        return opera ? fakeRealmBasicMechanism : basicMechanism;
    }
}
 

public AuthenticationMechanismsHandler(final List<AuthenticationMechanism> authenticationHandlers) {
    this.authenticationMechanisms = authenticationHandlers.toArray(new AuthenticationMechanism[authenticationHandlers.size()]);
}
 

public void setAuthenticationMechanisms(List<AuthenticationMechanism> authenticationMechanisms) {
    this.authenticationMechanisms = authenticationMechanisms;
}
 

public AuthenticationMechanism getJaspiAuthenticationMechanism() {
    return jaspiAuthenticationMechanism;
}
 

public DeploymentInfo setJaspiAuthenticationMechanism(AuthenticationMechanism jaspiAuthenticationMechanism) {
    this.jaspiAuthenticationMechanism = jaspiAuthenticationMechanism;
    return this;
}
 

@Override
public AuthenticationMechanism create(String mechanismName, IdentityManager identityManager, FormParserFactory formParserFactory, Map<String, String> properties) {
    return authenticationMechanism;
}
 

@Override
public List<AuthenticationMechanism> getAuthenticationMechanisms() {
    return authenticationMechanisms;
}
 

@Override
protected List<AuthenticationMechanism> getTestMechanisms() {
    AuthenticationMechanism mechanism = new ClientCertAuthenticationMechanism();

    return Collections.singletonList(mechanism);
}
 

public AuthenticationMechanismsHandler(final HttpHandler next, final List<AuthenticationMechanism> authenticationMechanisms) {
    this.next = next;
    this.authenticationMechanisms = authenticationMechanisms.toArray(new AuthenticationMechanism[authenticationMechanisms.size()]);
}
 

@Override
public AuthenticationMechanism create(String mechanismName, IdentityManager identityManager, FormParserFactory formParserFactory,
                Map<String,String> properties) {
    String forceRenegotiation = properties.get(ClientCertAuthenticationMechanism.FORCE_RENEGOTIATION);
    return new DatawaveAuthenticationMechanism(mechanismName, (forceRenegotiation == null) || "true".equals(forceRenegotiation), identityManager);
}
 

@Override
@Deprecated
public AuthenticationMechanism create(String mechanismName, FormParserFactory formParserFactory, Map<String,String> properties) {
    return create(mechanismName, identityManager, formParserFactory, properties);
}
 

public ImmediateAuthenticationMechanismFactory(AuthenticationMechanism authenticationMechanism) {
    this.authenticationMechanism = authenticationMechanism;
}