com.payneteasy.superfly.security.SuperflyMultiMockAuthenticationProvider Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of superfly-spring-security Show documentation
Module for Spring Security which enables application to use Superfly authentication/authorization declaratively through Spring Security
There is a newer version: 1.7-32
Show newest version
package com.payneteasy.superfly.security;

import java.util.Collections;
import java.util.Map;

import com.payneteasy.superfly.security.processor.AuthenticationPostProcessor;
import com.payneteasy.superfly.security.processor.IdAuthenticationPostProcessor;
import org.springframework.beans.factory.annotation.Required;
import org.springframework.security.authentication.AuthenticationProvider;
import org.springframework.security.authentication.AuthenticationServiceException;
import org.springframework.security.authentication.BadCredentialsException;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;

import com.payneteasy.superfly.api.SSOAction;
import com.payneteasy.superfly.api.SSORole;
import com.payneteasy.superfly.api.SSOUser;
import com.payneteasy.superfly.security.authentication.CheckHOTPToken;
import com.payneteasy.superfly.security.authentication.CompoundAuthentication;
import com.payneteasy.superfly.security.authentication.HOTPCheckedToken;
import com.payneteasy.superfly.security.authentication.SSOUserAndSelectedRoleAuthenticationToken;
import com.payneteasy.superfly.security.authentication.SSOUserAuthenticationToken;
import com.payneteasy.superfly.security.authentication.UsernamePasswordAuthRequestInfoAuthenticationToken;
import com.payneteasy.superfly.security.authentication.UsernamePasswordCheckedToken;
import com.payneteasy.superfly.security.exception.BadOTPValueException;
import com.payneteasy.superfly.security.mapbuilder.ActionsMapBuilder;

/**
 * {@link AuthenticationProvider} which may be used for rapid development using
 * local mode (with no interaction with Superfly server).
 *
 * @author Roman Puchkovskiy
 */
public class SuperflyMultiMockAuthenticationProvider extends
		AbstractRoleTransformingAuthenticationProvider {
	
	private String username;
	private String password;
	private String hotp;
	private ActionsMapBuilder actionsMapBuilder;
	private boolean enabled = true;
	private AuthenticationPostProcessor authenticationPostProcessor = new IdAuthenticationPostProcessor();
	
	private Map cachedMap = null;
	
	public void setUsername(String username) {
		this.username = username;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	public void setHotp(String hotp) {
		this.hotp = hotp;
	}

	@Required
	public void setActionsMapBuilder(ActionsMapBuilder actionsMapBuilder) {
		this.actionsMapBuilder = actionsMapBuilder;
	}

	public void setEnabled(boolean enabled) {
		this.enabled = enabled;
	}

	public void setAuthenticationPostProcessor(
			AuthenticationPostProcessor authenticationPostProcessor) {
		this.authenticationPostProcessor = authenticationPostProcessor;
	}

	public Authentication authenticate(Authentication authentication)
			throws AuthenticationException {
		if (enabled) {
			Authentication auth;
			CompoundAuthentication compound = null;
			if (authentication instanceof CompoundAuthentication) {
				compound = (CompoundAuthentication) authentication;
				auth = compound.getCurrentAuthenticationRequest();
			} else {
				auth = authentication;
			}
			if (auth instanceof UsernamePasswordAuthRequestInfoAuthenticationToken) {
				if (username.equals(auth.getName()) && password.equals(auth.getCredentials())) {
					CompoundAuthentication newCompound = new CompoundAuthentication();
					newCompound.addReadyAuthentication(new UsernamePasswordCheckedToken(createSSOUser(auth.getName())));
					return newCompound;
				} else {
					throw new BadCredentialsException("Bad username/password");
				}
			} else if (auth instanceof CheckHOTPToken) {
				CheckHOTPToken token = (CheckHOTPToken) auth;
				if (hotp.equals(token.getCredentials())) {
					if (token.getSsoUser().getActionsMap().size() == 1) {
						return new SSOUserAuthenticationToken(token.getSsoUser(), token.getSsoUser().getActionsMap().keySet().iterator().next(),
								token.getCredentials(), token.getDetails(), roleNameTransformers, roleSource);
					}
                    if (compound == null) {
                        throw new IllegalStateException("CompoundAuthentication cannot be null here");
                    }
					CompoundAuthentication newCompound = new CompoundAuthentication(compound.getReadyAuthentications(), auth);
					newCompound.addReadyAuthentication(new HOTPCheckedToken(token.getSsoUser()));
					return newCompound;
				} else {
					throw new BadOTPValueException("Bad HOTP");
				}
			} else if (auth instanceof SSOUserAndSelectedRoleAuthenticationToken) {
				SSOUserAndSelectedRoleAuthenticationToken token = (SSOUserAndSelectedRoleAuthenticationToken) auth;
				final SSOUserAuthenticationToken ssoUserAuthenticationToken = new SSOUserAuthenticationToken(
						token.getSsoUser(), token.getSsoRole(),
						token.getCredentials(), token.getDetails(), roleNameTransformers, roleSource);
				return authenticationPostProcessor.postProcess(ssoUserAuthenticationToken);
			}
		}
		return null;
	}

	protected SSOUser createSSOUser(String username) {
		return new SSOUser(username, getActionsMap(), Collections.emptyMap());
	}
	
	private Map getActionsMap() {
		if (cachedMap == null) {
			try {
				cachedMap = actionsMapBuilder.build();
			} catch (Exception e) {
				throw new AuthenticationServiceException("Could not obtain roles and actions", e);
			}
		}
		return cachedMap;
	}

	public boolean supports(Class authentication) {
		if (!enabled) {
			return false;
		}
		return (UsernamePasswordAuthRequestInfoAuthenticationToken.class.isAssignableFrom(authentication)
				|| CheckHOTPToken.class.isAssignableFrom(authentication)
				|| SSOUserAndSelectedRoleAuthenticationToken.class.isAssignableFrom(authentication)
				|| CompoundAuthentication.class.isAssignableFrom(authentication));
	}

}