JotaDeveloper » spring security

Spring Security 2, la configuración a la medida con DAO Hibernate IV

Jota — Tue, 23 Jun 2009 16:08:12 +0000

Más filtros de los que explicamos en el artículo anterior se puede usar en Spring Security, donde vimos los filtros esenciales para la configuración de nuestra capa de seguridad.

AnonymousProcessingFilter

Este filtro es muy util, nos permite darle acceso a un usuarios anónimos a secciones del sistema, digamos que la pagina de registro debe ser de acceso anónimo, en el FilterChainProxy agregamos otra linea donde colocamos el recurso y le asignamos el filtro, ese recurso sera accesible siempre y cuando en el FilterSecurityInterceptor también podemos hacer uso del Rol que indicamos que seran Roles para identificar al usuario anónimo.

 id="anonymousProcessingFilter"
		class="org.springframework.security.providers.anonymous.AnonymousProcessingFilter">
		 name="key">
			>MU7kyU0he1MvXEDZ9Mdj7MVvkXOXJ8uRgtg/Xb/3eJyW0HZa3csBoyvinGEC4vmi>
		>
		 name="userAttribute">
			>anonymousUser,ENCUESTAME_ANONYMOUS
			>
		>
	>

ExceptionTranslationFilter

Maneja cualquier AccessDeniedException y AuthenticationException arrojados dentro de la cadena de filtro. Este filtro es necesario, ya que proporciona el puente entre las excepciones de Java y las respuestas HTTP. Sólo se ocupan de mantener la interfaz de usuario. Este filtro no hace ninguna garantía real de la ejecución. Para utilizar este filtro, es necesario especificar las siguientes propiedades:

authenticationEntryPoint indica que el controlador debe comenzar el proceso de autenticación si un AuthenticationException se detecta. Tenga en cuenta que esto también puede cambiar el actual protocolo de http a https para un inicio de sesión SSL.
portResolver (opcional) Se utiliza para determinar el “verdadero” puerto por la que fue recibida la petición.

 id="exceptionTranslationFilter"
		class="org.springframework.security.ui.ExceptionTranslationFilter">
		 name="authenticationEntryPoint">
			 local="authenticationEntryPoint" />
		>
	>

BasicProcessingFilterEntryPoint

Este filtro es responsable de la tramitación de cualquier solicitud que tiene un encabezado de petición HTTP Authorization con un sistema de autenticación Basica y una codificación username:password simbólico. Por ejemplo, para autenticar el usuario “Aladdin”, con contraseña “ábrete Sésamo” el siguiente encabezado se mostrara como el siguiente ejemplo, (Autorización: Básica QWxhZGRpbjpvcGVuIHNlc2FtZQ == ). Si la autorización es satisfactoria, el objetoAuthentication se colocará en el SecurityContextHolder.

 id="authenticationEntryPoint" class="org.springframework.security.ui.basicauth.BasicProcessingFilterEntryPoint">
  		 name="realmName">>EmForge>>
>

LogoutFilter

Se necesita una forma de cerrar sesión, el LogoutFilter es la solución perfecta, indicamos en el constructor del bean el lugar donde seremos dirigidos cuando cerremos la sesión, y una lista de beans o manejadores de Cerrar sesión, por defecto se debe usar el SecurityContextLogoutHandler, aunque puedes personalizar el tuyo propio.

 id="logoutFilter" class="org.springframework.security.ui.logout.LogoutFilter">
	  value="/pages/index.me" />
		>
			>
				
				
					class="org.springframework.security.ui.logout.SecurityContextLogoutHandler" />
			>
		>

AuthenticationProcessingFilterEntryPoint

AuthenticationProcessingFilterEntryPoint, es el bean que nos redirecionará a la pantalla de la aplicación donde se inicia sesión, o a donde nosotros queramos por eso la propiedad loginFormUrl. En el caso en que los credenciales no sean correctos se utliza el objeto AccessDeniedHandlerImpl, y en su propiedad errorPage se le especifica a que camino se debe dirigir la aplicación en caso de error.

 id="formEntryPoint" class="org.springframework.security.ui.webapp.AuthenticationProcessingFilterEntryPoint">
      	 name="loginFormUrl" value="/login.faces"/>
   	>

Estos son los filtros más usados y que podemos aplicar a nuestra seguridad, junto con los explicados anteriormente son una magnifica opción para crear nuestra seguridad, y como ven, con muy poca programación. En el siguiente artículo veremos la integración del OPENID en Spring Security.

Spring Security 2, la configuración a la medida con DAO Hibernate III

Jota — Mon, 25 May 2009 15:32:11 +0000

El dia de hoy vamos a continuar con los Filtros, es la parte central de la seguridad de Spring, y por eso la hace tan flexible, porque esta completamente separada del modelo de Negocio, eso es lo que lo hace tan genial, pues si el dia de mañana se te ocurre cambiar toda la seguridad, tu sistema no sufrirá grandes cambios.

Los filtros se encargan de la seguridad de la aplicación. Existen tres filtros fundamentales se encadenan juntos mediante un objeto llamado “filterChainProxy”, que crea e inicializa los tres filtros; como se ve en el siguiente diagrama.

El filtro AuthenticationProcessingFilter maneja la petición o requerimiento (request) que chequea la autenticación -Authentication Request Check- (“el login de la aplicación”). Para ello usa el AuthenticationManager que vimos en el articulo anterior.
El filtro HttpSessionContextIntegrationFilter mantiene el objeto Authentication entre varios requests y se lo pasa al AuthenticationManager y al AccessDecisionManager cuando sea necesario.
El filtro ExceptonTranslationFilter verifica la existencia de autenticación , maneja las excepciones de seguridad y ejecuta la acción apropiada. El ExceptonTranslationFilter depende del filtro siguiente, FilterSecurityInterceptor.
FilterSecurityInterceptor controla el acceso restricto a recursos determinados , y el chequeo de autorización. Conoce qué recursos son seguros y qué roles tienen acceso a ellos. FilterSecurityInterceptor usa el AuthenticationManager y el AccessDecisionManager para hacer su trabajo.

Cuando inicias, todo esto es una maraña de filtros sin sentido, pero vamos a profundizar un poco para que te quede más claro la funcion y configuración de cada uno de ellos.

AuthenticationProcessingFilter

El primer filtro donde pasa el RequestHTTP. Este filtro se especializa en manejar el request de autentificación, valida el usuario y la contraseña, más alla de esto solo debes conocer otros parametros imporantes.

authenticationFailureUrl: En el caso de fallo, algún lugar debe de ir cuando no se logea el usuario.
defaultTargetUrl: Es el URL por defecto, generalmente es la raiz.
filterProcessesUrl: Es a quien le encarga la responsbilidad de verificar si el usuario se logea o no..

 id="authenticationProcessingFilter"
		class="org.springframework.security.ui.webapp.AuthenticationProcessingFilter">
		 name="authenticationManager">
			 bean="authenticationManager" />
		>
		 name="authenticationFailureUrl">
			>/login.me>
		>
		 name="defaultTargetUrl">
			>/>
		>
		 name="filterProcessesUrl">
			>/j_spring_security_check>
		>
	>

HttpSessionContextIntegrationFilter

El HttpSessionContextIntegrationFilter es fácil de configurar. Su única función, es propagar por el Contexto de Seguridad la autenticación a través de todas las solicitudes. No necesita propiedades ni nada en especial.

 id="httpSessionContextIntegrationFilter"
		class="org.springframework.security.context.HttpSessionContextIntegrationFilter" />

ExceptionTranslationFilter

El filtro ExceptionTranslationFilter intercepta cualquier error de autenticación o autorización, por ejemplo UsernameNotFoundException o DataAccessException.

Si la excepción fue causada por una excepción de autorización lanzada por el filtro FilterSecurityInterceptor (puede ser porque no tiene permisos para acceder a un Recurso Web, una imagen o un URL), el filtro lanzará un HTTP 403 al navegador, el cual mostrará una página de acceso no autorizado.

 id="formExceptionTranslationFilter"
		class="org.springframework.security.ui.ExceptionTranslationFilter">
		 name="authenticationEntryPoint">
			 local="formEntryPoint" />
		>
	>
 
 id="formEntryPoint"
		class="org.springframework.security.ui.webapp.AuthenticationProcessingFilterEntryPoint">
		 name="loginFormUrl" value="/login.me" />
	>

FilterSecurityInterceptor

El FilterSecurityInterceptor, es donde protegeremos todos nuestros recursos, donde decidimos que ROL entra a ciertos recursos, cuales pueden ser accedido por usuarios anónimos, todo esto se configura en el objectDefinitionSource. Necesitamos 2 referencias para configurar este Filtro, el authenticationManager y el bean accessDecisionManager que miraremos en el siguiente artículo.

 id="filterInvocationInterceptor"
		class="org.springframework.security.intercept.web.FilterSecurityInterceptor">
		 name="authenticationManager" ref="authenticationManager" />
		 name="accessDecisionManager" ref="voteAccessDecisionManager" />
		 name="objectDefinitionSource">
			>
				CONVERT_URL_TO_LOWERCASE_BEFORE_COMPARISON
				PATTERN_TYPE_APACHE_ANT
				/=ENCUESTAME_ANONYMOUS
				/pages/**=ENCUESTAME_USER
				/pages/admon/**=ENCUESTAME_ADMIN
				/user/**=ENCUESTAME_ANONYMOUS,ENCUESTAME_USER,ENCUESTAME_ADMIN				           
         >
		>
	>

FilterChainProxy

El filtro inicializador, su función principal es indicar o personalizar, que recursos ejecutaran los filtros deseados en filterInvocationDefinitionSource, por ejemplo, si tenemos un sevlet /uploadFile y solo nos interesa aplicar algunos filtros

 id="springSecurityFilterChain" class="org.springframework.security.util.FilterChainProxy">
       name="filterInvocationDefinitionSource">
         >
		   CONVERT_URL_TO_LOWERCASE_BEFORE_COMPARISON
		    PATTERN_TYPE_APACHE_ANT
               /**=httpSessionContextIntegrationFilter,logoutFilter,basicProcessingFilter,authenticationProcessingFilter....
              /uploadFile= basicProcessingFilter,OtroFiltroPersonalizado
         >
      >
    >

En el siguiente artículo, veremos una extensión de los diferentes filtros opcionales que podemos integrar en nuestra seguridad, ¿preguntas?

Spring Security 2, la configuración a la medida con DAO Hibernate II

Jota — Wed, 13 May 2009 06:24:10 +0000

Siguiendo con el articulo anterior, voy a explicar los diferentes Filtros de Seguridad y las Configuraciones Personales que podemos aplicar en nuestra Seguridad. El siguiente gráfico explica el ciclo de vida de la autentificación en Spring.

En el post anterior, vimos el Bean del Formulario de logeo, donde se creo el objeto Authentication que se pasa al AuthenticationManager.

UsernamePasswordAuthenticationToken authReq = new UsernamePasswordAuthenticationToken(userName, password);
.......
Authentication auth = getAuthenticationManager().authenticate(authReq);

AuthenticationManager

El bean AuthenticationManager es del tipo ProviderManager, lo que significa que actúa de proxy con AuthenticationProvider. En Spring, el AuthenticationProvider es el encargado de validar la combinación nombre de usuario/contraseña por medio del objeto Authentication y retornar los roles asociados a dicho usuario. Esta clase tan sólo delega la autenticación en una lista de proveedores configurable, cada uno de los cuales implementa el interfaz AuthenticationProvider. Hay muchos tipos de AuthenticationProvider( JDBC, Hibernate, LDAP, RememberMe, OpenID). Usted puede indicar cuales quiere usar son los proveedores de autentificación que desee usar, en nuestro caso, usaremos un DAO Hibernate personalizado.

<bean id="authenticationManager" class="paquete.MiAuthenticationManager">
	<property name="providerString" value="userDaoProvider" />
bean>

public class MiAuthenticationManager extends ProviderManager {
protected String providerString;
public void setProviderString(String providerString) {
		this.providerString = providerString;
	}
 /**
  * Agrega al Manejador de Proveedores un listado
  */ 
public void afterPropertiesSet() throws Exception {
		if (providerString != null) {			
			List<authenticationprovider> providers = new LinkedList();
			String[] names = providerString.split(",");	
			for (String providerUnit : names) {
				AuthenticationProvider provider = (AuthenticationProvider) applicationContext
						.getBean(providerUnit.trim());
				if (provider == null) {
 
					throw new EnMeExpcetion("AuthenticationProvider "
							+ providerUnit + " don't exist");
				}				
				providers.add(provider);
			}
			setProviders(providers);
		}
		super.afterPropertiesSet();
	}
}
 
authenticationprovider>

DaoAuthenticationProvider

DaoAuthenticationProvider, es el comúnmente usado puesto que es el que permite acceder a la información almacenada en una base de datos. El proveedor DaoAuthenticationProvider merece una mención especial. Esta implementación delega a su vez en un objeto de tipo UserDetailsService, un interfaz que define un objeto de acceso a datos con un único método loadUserByUsername que permite obtener la información de un usuario a partir de su nombre de usuario.

<bean id="userDaoProvider"
		class="org.springframework.security.providers.dao.DaoAuthenticationProvider">
		<property name="userDetailsService" ref="dbUserService" />		
	bean>

Si deseas agregarle encriptación a la contraseña del usuario, agregale una propiedad más al userDaoProvider, este artículo que escribi tiempo atrás te ayudará a poner una mejor seguridad que el tipico MD5.

UserDetailsService, un Dao Personalizado

Si no queremos que Spring acceda a la bases de datos directamente podemos configurar un Dao personalizado por medio de una Implementación UserDetailsService, , un interfaz que define un objeto de acceso a datos con un único método loadUserByUsername que permite obtener la información de un usuario a partir de su nombre de usuario.

 
<bean id="dbUserService" class="paquete.MiUserServiceImp">
		<property name="userDao" ref="userDao" />		
	bean>

public class MiUserServiceImp implements UserDetailsService {
         ......
        public UserDetails loadUserByUsername(String username)
			throws UsernameNotFoundException, DataAccessException {		
		SecUsers user = userDao.getUser(username);
		if (user == null) {
			log.info("no encontrado...");
			throw new UsernameNotFoundException("username");
		}		
		return convertToUserDetails(user);
	}
 
         ......
 
    protected UserDetails convertToUserDetails(SecUsers user){
         //lista de permisos, 
         List<string> listPermissions = new ArrayListstring><string>();
        ...........
        GrantedAuthority[] authorities = new GrantedAuthority[listPermissions
				.size()];
		int i = 0;
		for (String permission : listPermissions) {
			authorities[i++] = new GrantedAuthorityImpl(permission.trim());
		}
 
		User userDetails = new User(user.getUsername(), user.getPassword(),
				user.isStatus() == null ? false : user.isStatus(), true, 
				true, 
				true,
				authorities);
		log.info("userDetails "+userDetails);
		return userDetails;
    }
}
string>

Vamos a dejar la explicación de los Filtros, para una tercera parte, ya se hizo largo .

Spring Security 2, la configuración a la medida con DAO Hibernate I

Jota — Mon, 11 May 2009 15:38:48 +0000

Uno de los aspectos que toda aplicación debe considerar es la seguridad, entendiendo como tal la necesidad de saber que el usuario es quien dice ser (autenticación), y permitirle acceso sólo a aquellos recursos necesarios (autorización). En un princio el framework se llamaba Acegi Security e inicio en el 2003, 5 años después en Abril del 2008 se incorporó al portafolio de Spring Framework como un súbmodulo. Spring trae por defecto ciertas caracteristicas que a la hora de querer integrarlas en nuestros sistemas avanzados no encajan a la perfección y por lo general se necesitan modificaciones a las clases principales.

Anteriormente hemos visto configuraciones mucho más sencillas :

Creo que una de las configuraciones más complejas es fusionando con el framework Hibernate y esto nos permite no anclarnos a las tablas que ya Spring Security trae por defecto, asi poder personalizar nuestra seguridad de una mejor manera.

En nuestro caso vamos a trabajar con Spring Framework, y lo ideal es separar nuestra aplicación en 3 capas:

Capa de Presentación: En esta capa vamos a programar el formulario, el típico formulario con el nombre de usuario y la contraseña, podemos integrar OPEN ID, e incluso la funcionalidad de Recordar la Sessión por medio de un Cookie.
Filtros de Seguridad: Aqui aplicaremos toda la configuración de Spring Security, aplicaremos todos los filtros y las clases que vamos a modificar algunas clases de Spring que se comuniquen con nuestros servicios en la capa de negocio.
Servicios en la Capa de Negocio: En esta capa colocaremos nuestros Beans de Spring que a su vez acceden a otra capa en la cual no vamos a entrar en detalle, la de acceso a datos.

Iniciemos con la capa de presentación y el formulario para logearse, en su forma más sencilla, aqui se pueden agregar validadores y mensajes de error, etc.

	 :inputText id="j_username"  value="#{loginForm.userName}" size="40" required="true"/>
	 :inputSecret id="j_password" value="#{loginForm.userPassword}" size="40" required="true"/>
	 :commandButton action="#{loginForm.login}"  value="Iniciar Sesión"/>

Ahora necesitamos nuestro Bean LoginForm, este puedes colocarlo como un ManageBean o un Bean de Spring, como mas te parezca, en mi caso use Spring.

public class LoginForm{
 
        //Bean Personalizado del Manejador de Autentificación
	private AuthenticationManager authenticationManager;
	private String userName;
	private String userPassword;
	private Application app;
 
 
	public String getUserName() {
		return userName;
	}
 
	public void setUserName(String userName) {
		this.userName = userName;
	}
 
	public String getUserPassword() {
		return userPassword;
	}
 
	public void setUserPassword(String userPassword) {
		this.userPassword = userPassword;
	}
 
	public AuthenticationManager getAuthenticationManager() {
		return authenticationManager;
	}
 
	public void setAuthenticationManager(
			AuthenticationManager authenticationManager) {
		this.authenticationManager = authenticationManager;
	}
 
	/**
	 * 
 
	/**
	 * Ejecuta un envio a un url definido por la navegación JSF
	 * @param viewId
	 */
	protected void forward(String viewId) {
    	ViewHandler viewHandler = getApplication().getViewHandler();
	    FacesContext facesCtx = getFacesContext();
	    UIViewRoot view = viewHandler.createView(facesCtx, viewId);
	    facesCtx.setViewRoot(view);
	    facesCtx.renderResponse();
	}
 
	/**
	 * Obtiene el contexto de la Aplicación
	 * @return
	 */
	protected Application getApplication() {
		if (app == null) {
			ApplicationFactory appFactory = (ApplicationFactory) FactoryFinder.getFactory(FactoryFinder.APPLICATION_FACTORY);
	        app = appFactory.getApplication();
		} 
		return app;
	}
 
	/**
	 * Obtiene el Contexto de JSF
	 * @return
	 */
	protected FacesContext getFacesContext() {
		return FacesContext.getCurrentInstance();
	}
 
	/**
	 * Obtiene la Petición del HttpServletRequest
	 * @return
	 */
	protected HttpServletRequest getRequest() {
		ExternalContext context = 
			FacesContext.getCurrentInstance().getExternalContext();
	    HttpServletRequest request = 
	    	(HttpServletRequest) context.getRequest();	    
	    return request;
	}
 
	/**
	 * Obtiene la Respuesta del HttpServletResponse	
	 * @return
	 */
	protected HttpServletResponse getResponse() {
		ExternalContext context = 
			FacesContext.getCurrentInstance().getExternalContext();
		HttpServletResponse response = 
	    	(HttpServletResponse) context.getResponse();
 
	    return response;
	}
 
 
	public String login() {
		HttpServletRequest request = getRequest();
	    try {
 
 
               /**
                 * Obtenemos del Formulario los Datos, por mayor seguridad podriamos agregar filtros contra XSS e Inyección HQL
                 * Creamos un token para Spring
                 */
	    	String userName = getUserName();
	    	String password = getUserPassword();
 
	    	/**
                 * Creamos un token para Spring
                 */
	    	UsernamePasswordAuthenticationToken authReq = new UsernamePasswordAuthenticationToken(userName, password);
 
               /**
                 * Le agregamos al token el request de HttpServletRequest
                 */
	    	authReq.setDetails(new WebAuthenticationDetails(request));			    	
	    	HttpSession session = request.getSession();
 
 
               /**
                 * Asignamos la sesión el atributo UserName
                 * Obtenemos el manager auth y le asignamos el token
                 */
	    	session.setAttribute(AuthenticationProcessingFilter.SPRING_SECURITY_LAST_USERNAME_KEY, userName);
	    	Authentication auth = getAuthenticationManager().authenticate(authReq);	    	
 
                  /**
                 * Obtenemos el Contexto de Spring Security
                 * Le asignamos el Autentication Manager al Contexto de Seguridad
                 */	
 
	    	SecurityContext secCtx = SecurityContextHolder.getContext();	    	
	    	secCtx.setAuthentication(auth);
	    	session.setAttribute(HttpSessionContextIntegrationFilter.SPRING_SECURITY_CONTEXT_KEY, secCtx);   			    	
 
	    	String urlKey = AbstractProcessingFilter.SPRING_SECURITY_SAVED_REQUEST_KEY;	   
	    	SavedRequest savedRequest = (SavedRequest)session.getAttribute(urlKey);
	    	session.removeAttribute(urlKey);
 
	    	String target = "/index.jsf";
	    	/**
                  * Si perdiste la sesión en una página en particular, este parametro te ayudara a regresar a donde perdiste la sesión
                 */
	    	if (savedRequest != null) {	    		
		    	String targetUrl = null;
	    		targetUrl = savedRequest.getFullRequestUrl();	    		
	    		FacesContext.getCurrentInstance().getExternalContext().redirect(targetUrl);	    		
	    		return null;	    		
	    	} else {
	    		.................		  
	    	}
	    	/**
                 * Si no existiera un SavedRequest, entonces te enviaria a la pagina de inicio
                  */
	    	forward(target);
 
	    } catch (BadCredentialsException e) {
	    	...............	    	
	    	return null;
	    } catch (AuthenticationException e) {
	    	............
	    	return null;
	    } catch (IOException ioException) {
	       ..............
	    }
 
	return "index";
	}	
    }
}

Y como lo vamos a integrar con Spring, la declaración del Bean en el contexto

    id="loginForm" class="org.xxx.LoginForm" scope="request">
		 name="authenticationManager" ref="authenticationManager" />
	>

En la parte II miraremos los Filtros de Seguridad.

La Seguridad Perfecta con Spring y el dropDownMenu de RichFaces

Jota — Sun, 07 Dec 2008 13:04:17 +0000

Bueno, sigo con la seguridad de Spring 2.0 o el conocido como el antiguo Acegi Security, ahora voy a proponer una alternativa para generar una seguridad con un componente de RichFaces, el dropDownMenu. ToolBar y menuItem.

Primero te recomiendo sigas la configuración de Spring con JDBC, o con LDAP, como tu lo desees, porque de todas formas todos los Roles ( o Permisos) quedan almacenados en la misma variable de Spring. También si deseas integrarlo con Facelest, aqui tenes los pasos a seguir.

Lo primero que hay que hacer, es construir el menú, para eso usamos un Tool Bar:

>
 
 >
 name="label">
        >
 value="#{initParam['rootimages']}/images/icons/contexthelp.png" />
	 value="JotaDeveloper" />
	>
>
	 submitMode="ajax" value="Articulos">>
	 submitMode="ajax" value="Tutoriales">>
	 submitMode="ajax" value="Ayuda">>
>
>

El código es bien sencillo, no hace falta explicar mucho, solo que para poder colocar un dropDownMenu , es necesario el toolBar, y para el menuItem , debe estar dentro de un dropDownMenu.

Depues de esto, y espero que hayas leido los 3 articulos que sugerí anteriormente, vamos a crear un Bean, donde tendremos la logica de nuestra seguridad con el dropDownMenu.

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
 
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.security.Authentication;
import org.springframework.security.GrantedAuthority;
import org.springframework.security.context.SecurityContext;
import org.springframework.security.context.SecurityContextHolder;
import org.springframework.security.ui.WebAuthenticationDetails;
 
public class JotaDeveloperMenuBean {
 
	// Un objeto Booleano por cada elemento del Menu
	private Boolean rootJotaDeveloper;
	private Boolean rootTutoriales;
	private Boolean rootArticulos;
	private Boolean rootAyuda;
 
	// Objetos Spring Security
	private Object seguridadAcegi;
	// El GrantedAuthority es un Array con todos los Roles que recupera de la BD
	private GrantedAuthority[] listaAutoridades;
	private SecurityContext contexto;
	private Authentication autenticacion;
	private List<String> ListAutoridades = new ArrayList<String>();
	private String nombreUsuario;
	private Boolean estaAutenticado;
	private WebAuthenticationDetails webAu;
 
	/**
	 * Constructor que accede a toda la información de Spring Security
	 */
 
	public JotaDeveloperMenuBean() {
		this.seguridadAcegi = SecurityContextHolder.getContext()
				.getAuthentication().getPrincipal();
		this.contexto = SecurityContextHolder.getContext();
		this.autenticacion = SecurityContextHolder.getContext()
				.getAuthentication();
		this.listaAutoridades = SecurityContextHolder.getContext()
				.getAuthentication().getAuthorities();
		convertirArrayAuthoritiesToListAuthorities();
		this.nombreUsuario = this.autenticacion.getName();
		this.estaAutenticado = this.autenticacion.isAuthenticated();
	}
 
	/**
	 * Este metodo convierte el Array de Roles poco manejable en un List
	 */
	private void convertirArrayAuthoritiesToListAuthorities() {
		int it_cont;
		for (it_cont = 0; it_cont < listaAutoridades.length; it_cont++) {
			String ROL = listaAutoridades[it_cont].toString();
			ListAutoridades.add(ROL);
		}
	}
 
	/**
	 * Comprueba si existe determinado Rol en la Lista de Autoridades del
	 * Usuario Logeado
	 * 
	 * @param cadena
	 *            ROL
	 * @return El resultado de la Busqueda
	 */
	private Boolean comprobarRol(String cadena) {
		Integer id = ListAutoridades.indexOf(cadena);
		// Si el Id es -1, el valor no fue encontrado.
		if (id != -1) {
			return false;
		} else {
			return true;
		}
	}
 
	/**
	 * Los Getters que va leer cada elemento del Menu
	 */
 
	public Boolean getRootJotaDeveloper() {
		return rootJotaDeveloper = comprobarRol("ROLE_ROOT_JOTADEVELOPER");
	}
 
	public Boolean getRootTutoriales() {
		return rootTutoriales = comprobarRol("ROLE_ROOT_TUTORIALES");
	}
 
	public Boolean getRootAyuda() {
		return rootArticulos = comprobarRol("ROLE_ROOT_AYUDA");
	}
 
	public Boolean getRootArticulos() {
		return rootAyuda = comprobarRol("ROLE_ROOT_ARTICULOS");
	}
 
}

Despues de esto y incluir el Bean el el ManageBean de faces-config.xml, solo agregamos a la propiedad disabled del MenuItem el get del Bean.

>
 ifAllGranted="ROLE_ROOT_JOTADEVELOPER">
 >
 name="label">
        >
 value="#{initParam['rootimages']}/images/icons/contexthelp.png" />
	 value="JotaDeveloper" />
	>
>
	 submitMode="ajax" value="Articulos" disabled="#{jotaDeveloperMenuBean.rootArticulos}">>
	 submitMode="ajax" value="Tutoriales" disabled="#{jotaDeveloperMenuBean.rootTutoriales}">>
	 submitMode="ajax" value="Ayuda" disabled="#{jotaDeveloperMenuBean.rootAyuda}">>
>
>
>

El resultado de todo esto, es que cuando inices sesión, el GrantedAuthority que genera en la sesión del usuario Spring Security, lo convertimos en un List, luego cada elemente del menu que tu crees, va preguntarle al List si existe, si Existe, regresa True, sino, False, y apareceran los menus cuales el usuario no tenga permiso desactivados, ademas de eso, no podra acceder via URL, si has configurado correctamente el security.xml del Spring Security.

Encriptación de Contraseñas con Jasypt y Spring Security 2

Jota — Sat, 29 Nov 2008 04:24:34 +0000

Continuando el artículo anterior, vamos hacer uso de una libreria muy poderosa de la familia Apache, se llama, Jasypt y la puedes encontrar aqui. Esta herramienta que se integra perfectamente con Spring Security 2.0 y con Hibernate, pero en este ejemplo, no la voy a integrar aun con Hibernate.

Puedes encriptar contraseñas con MD5, SHA-1 y personalizar tu encriptación, solo voy a tocar los temas mas sencillos.

Para iniciar un ejemplo de código para cada una de estas dos formas de encriptar una contraseña, claro, puede encriptar lo que necesites, en mi caso, para hacerlo compatible con Spring, el password.

 
import org.jasypt.util.digest.Digester;
import org.jasypt.util.password.BasicPasswordEncryptor;
import org.jasypt.util.password.ConfigurablePasswordEncryptor;
import org.jasypt.util.password.StrongPasswordEncryptor;
 
//Para una encriptacion sencilla en MD5
BasicPasswordEncryptor passwordEncryptor = new BasicPasswordEncryptor();
String encryptedPassword = passwordEncryptor.encryptPassword("jotadeveloper");
 
//Para una encriptacion mas fuerte en SHA-1
StrongPasswordEncryptor passwordEncryptor2 = new StrongPasswordEncryptor();
String encryptedPassword2 = passwordEncryptor2.encryptPassword("jotadeveloper");
 
//Para una encriptación Personalizada
//SHA1
ConfigurablePasswordEncryptor passwordEncryptor3 = new ConfigurablePasswordEncryptor();
passwordEncryptor3.setAlgorithm("SHA-1");
passwordEncryptor3.setPlainDigest(true);
String encryptedPassword3 = passwordEncryptor3.encryptPassword("jotadeveloper");
//MD5
ConfigurablePasswordEncryptor passwordEncryptor4 = new ConfigurablePasswordEncryptor();
passwordEncryptor4.setAlgorithm("MD5");
passwordEncryptor4.setPlainDigest(true);
String encryptedPassword4 = passwordEncryptor4.encryptPassword("jotadeveloper");

Una vez has creado tu clase con al encriptación deseada, es tan sencillo como usar las funciones de arriba y guardarlo donde quieras y como quieras.
Ahora la configuración en tu security.xml de Spring Security 2.0

//En mi caso, seleccione StrongPasswordEncryptor porque voy a usar encriptacion SHA-1
 id="jasyptPasswordEncryptor"
		class="org.jasypt.util.password.StrongPasswordEncryptor" />
 
//
 id="passwordEncoder" class="org.jasypt.spring.security2.PasswordEncoder">
		 name="passwordEncryptor">
			 bean="jasyptPasswordEncryptor" />
		>
	>
 
 user-service-ref="userService">
		 ref="passwordEncoder">
		>

El código anterior, lo agregas al mismo codigo del articulo anterior y listo.

Configuración Spring Security 2.0 con JDBC

Jota — Fri, 21 Nov 2008 13:00:05 +0000

Esta configuración funciona perfectamente, con Spring Security 2.0 y JDBC, despues de varios dias probando configuraciones diferentes, puedo concluir dos cosas, que la versión de Spring Security tiene un bug en su versión 2.0.8.

Yo usé mis propias tablas, pero para los nuevos, pueden usar las que trae por defecto programadas, las que estan aabajo de este artículo, yo cree unas similares, pero en mi caso necesitaba otras moficiaciones, tablas con mas columnas para mi aplicación. El problema, es que si tu usar la nueva caracteristica de esta versión group-authorities-by-username-query vas a tener un problema, pues aunque pongas tu propia configuración necesitas tener las tablas de groups,group_authorities y group_members en tu base de datos, aunque no estén siendo usadas, porque sinó, no te funcionará. Abajo les dejo la configuración que usé.

En el web.xml

>
    >contextConfigLocation>
    >/WEB-INF/applicationContext-security.xml>
  >
>
    >springSecurityFilterChain>
    >org.springframework.web.filter.DelegatingFilterProxy>
  >
  >
    >springSecurityFilterChain>
    >/*>
  >
  >

applicationContext-security.xml

 
    
 version="1.0" encoding="UTF-8"?>
 xmlns="http://www.springframework.org/schema/security"
	xmlns:beans="http://www.springframework.org/schema/beans" 
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
						http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
                        http://www.springframework.org/schema/security 
                        http://www.springframework.org/schema/security/spring-security-2.0.1.xsd">
 
    
 
   auto-config="true" access-denied-page="/web/error.do">
   	 pattern="/" access="IS_AUTHENTICATED_ANONYMOUSLY" />
		 pattern="/login.do" access="IS_AUTHENTICATED_ANONYMOUSLY" />
		 pattern="/j_spring_security_switch_user"
			access="ROLE_SUPERVISOR" />		
		 pattern="/web/css/**" access="ROLE_WEBMASTER" />
		 pattern="/templates/**" access="ROLE_WEBMASTER" />
		 pattern="/web/error/**" access="ROLE_USER" />	
 
     login-page="/login.do" default-target-url='/web/index.do'
			authentication-failure-url="/login.do?login_error=1"  />
     logout-success-url="/" invalidate-session="true"/>
      >
 
   user-service-ref="userService" />
 
  
 
   id="securityDataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
     name="driverClassName" value="org.gjt.mm.mysql.Driver" />
     name="url" value="jdbc:mysql://localhost/test" />
     name="username" value="root" />
     name="password" value="" />
  >  
   id="userService" 
	data-source-ref="securityDataSource"	
	 group-authorities-by-username-query="SELECT
                      g.nombre,
                      a.rol
                    FROM
                      dbo.bm_usuario u
                      INNER JOIN dbo.bm_grupo_usuario ug ON (u.id_usuario = ug.id_usuario)
                      INNER JOIN dbo.bm_grupo g ON (ug.id_grupo = g.id_grupo)
                      INNER JOIN dbo.bm_grupos_roles ON (g.id_grupo = dbo.bm_grupos_roles.id_grupo)
                      INNER JOIN dbo.bm_roles a ON (dbo.bm_grupos_roles.id_rol = a.id_rol)
                    WHERE
                      u.nombreUsuario = ? "
		users-by-username-query="SELECT 
					  u.nombreUsuario AS Login,
					  u.password AS Password,
					  u.enabled AS Enabled
					FROM
					  dbo.bm_usuario u
					WHERE
					  u.nombreUsuario = ?"
		authorities-by-username-query="SELECT 
					   u.nombreUsuario,
					    au.rol
					FROM
					  dbo.bm_usuario_roles ua
					  INNER JOIN dbo.bm_usuario u ON (ua.id_usuario = u.id_usuario)
					  INNER JOIN dbo.bm_roles au ON (ua.id_rol = au.id_rol)
					WHERE
					  u.nombreUsuario = ? " />
 
 
>

Las tablas para que esto funcione. OJO, aviso que este SQL no es el mismo que yo usé en mi ejemplos, es similar pero para SQL Server, con algunas modfiicaciones a las tablas originales.

 <!-- SQL -->
CREATE TABLE users(
username varchar_ignorecase(50) NOT NULL PRIMARY KEY,
password varchar_ignorecase(50) NOT NULL,
enabled BOOLEAN NOT NULL);
<!--Tabla de Roles -->
CREATE TABLE authorities (
username varchar_ignorecase(50) NOT NULL,
authority varchar_ignorecase(50) NOT NULL,
constraint fk_authorities_users FOREIGN KEY(username) REFERENCES users(username));
CREATE UNIQUE INDEX ix_auth_username ON authorities (username,authority);
 
CREATE TABLE groups (
id bigint generated BY DEFAULT AS identity(start WITH 0) PRIMARY KEY,
group_name varchar_ignorecase(50) NOT NULL);
<!--Tabla de Grupos Roles-->
CREATE TABLE group_authorities (
group_id bigint NOT NULL,
authority varchar(50) NOT NULL,
constraint fk_group_authorities_group FOREIGN KEY(group_id) REFERENCES groups(id));
<!--Tabla de Grupos Usuarios-->
CREATE TABLE group_members (
id bigint generated BY DEFAULT AS identity(start WITH 0) PRIMARY KEY,
username varchar(50) NOT NULL,
group_id bigint NOT NULL,
constraint fk_group_members_group FOREIGN KEY(group_id) REFERENCES groups(id));

Configuración Spring Security 2.04 para LDAP

Jota — Mon, 17 Nov 2008 05:51:53 +0000

Por si te sirve de algo, me costo un monton, aun estoy detras de una configuración hibrida, medio LDAP medio Base de Datos, pero por ahora les dejo una configuración básica del LDAP con el Nuevo Acegi.

 version="1.0" encoding="UTF-8"?>
 xmlns="http://www.springframework.org/schema/beans"
	xmlns:s="http://www.springframework.org/schema/security" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
       http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-2.0.1.xsd">
 
 
	>
		 pattern="/" access="IS_AUTHENTICATED_ANONYMOUSLY" />
		 pattern="/j_spring_security_switch_user"
			access="ROLE_SUPERVISOR" />
		 pattern="/web/**" access="ROLE_USER" />
		 pattern="/web/templates/**" access="ROLE_ADMIN" />
		 pattern="/"
			access="IS_AUTHENTICATED_ANONYMOUSLY" />
		 pattern="/login.do"
			access="IS_AUTHENTICATED_ANONYMOUSLY" />
		 login-page="/login.do" default-target-url='/web/index.do'
			authentication-failure-url="/login.do?login_error=1" />
			 
		logout-success-url="/" />
		 />
		 />
		 />
	>
 
	 id="ldapServer" url="ldap://localhost:389/ou=system"
		manager-dn="uid=admin,ou=system" manager-password="test" />
 
	
	
		server-ref="ldapServer" user-search-filter="sAMAccountName={0}"
		user-search-base="" group-role-attribute="cn" group-search-filter="memberOf={0}"
		group-search-base="ou=groups" />
 
	
 
	 id="contextSource"
		class="org.springframework.security.ldap.DefaultSpringSecurityContextSource">
		 value="ldap://localhost:389/ou=system" />
		 name="userDn" value="uid=admin,ou=system" />
		 name="password" value="test" />
	>
 
	 id="ldapAuthenticationProvider"
		class="org.springframework.security.providers.ldap.LdapAuthenticationProvider">
		>
			
				class="org.springframework.security.providers.ldap.authenticator.BindAuthenticator">
				 ref="contextSource" />
				 name="userSearch" ref="userSearch" />
			>
		>
		>
			
				class="org.springframework.security.ldap.populator.DefaultLdapAuthoritiesPopulator">
				 ref="contextSource" />
				 value="cn=users,dc=development,dc=somecompany,dc=com" />
				 name="convertToUpperCase" value="true" />
				 name="defaultRole" value="Authenticated" />
				 name="rolePrefix" value="" />
				 name="searchSubtree" value="true" />
				 name="groupSearchFilter" value="(memberUid={0})" />
				 name="groupRoleAttribute" value="cn" />
			>
		>
	>
 
	 id="userSearch"
		class="org.springframework.security.ldap.search.FilterBasedLdapUserSearch">
		 index="0" value="ou=Users" />
		 index="1" value="(sAMAccountName={0})" />
		 index="2" ref="contextSource" />
		 name="searchSubtree" value="true" />
	>
 
 
>