En nuestro caso, usaremos Spring 2.5 y Hibernate 3.3 y MySQL, donde es necesario ya tengas armado los beans de conexión a la base de datos. El siguiente código es un array de cadenas, si en nuestro caso tenemos segmentado los xml de spring, los añadiremos de la siguiente manera.

// array de string para agregar todos tus archivos de configuración de spring
private static final String[] SPRING_CONFIG_FILES =
new String[]{"source/spring/config/xxxxxx-db-context.xml", "source/spring/config/xxxxxxx-param-context.xml"};

A continuación, el código necesario para generar nuestra base de datos, el FileSystemXmlApplicationContext carga el Contexto de la Aplicación, y una vez teniendo el contexto obtenemos el SessionFactory, que en nuestro caso usamos Anotaciones, creamos el bean en base a la clase AnnotationSessionFactoryBean , esto es importante pues en base a esta clase usaremos los metodos dropDatabaseSchema(); para borrar el actual schema (tablas, relaciones , etc) y luego ejecutamos createDatabaseSchema(); para crear el nuevo schema.

// carga el application context de Spring
 FileSystemXmlApplicationContext appContext = new FileSystemXmlApplicationContext(SPRING_CONFIG_FILES);
// Obtiene el bean del session factory
 AnnotationSessionFactoryBean annotationSF = (AnnotationSessionFactoryBean)  appContext.getBean("&sessionFactory");
// si quieres eliminar el schema de la base de datos
 annotationSF.dropDatabaseSchema();
// para crear nuevamente el schema de la base de datos
 annotationSF.createDatabaseSchema();

Los archivos de configuración de Spring, deben lucir de la siguiente manera, hay que destacar el hibernate.dialect donde indicamos el dialecto que usaremos para crear el schema, en el caso de MySQL puede ser MySAM o InnoDB, luego el parametro hibernate.hbm2ddl.delimiter que también indicamos el tipo de tablas que usaremos en mi caso usaré type=InnoDB.

<bean id="dataSource"
        class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="${datasource.classname}" />
        <property name="url" value="${datasource.urldb}" />
        <property name="username" value="${datasource.userbd}" />
        <property name="password" value="${datasource.pass}" />
    </bean>
 
    <bean id="sessionFactory"
        class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="annotatedClasses">
          <list>
              <value>Clase1</value>
              <value>Clase2</value>
          </list>
        </property>
        <property name="hibernateProperties">
           <props>
                <!-- <prop key="hibernate.hbm2ddl.auto">update</prop> -->
                <prop key="hibernate.dialect">${datasource.dialect}
                </prop>
                <prop key="hibernate.show_sql">${datasource.showsql}</prop>
                <prop key="hibernate.hbm2ddl.delimiter">${datasource.delimited}</prop>
            </props>
        </property>
      </bean>

Hace poco el equipo de Spring Source liberó Spring 3.0 RC1 y viene con muchas nuevas características interesantes, para mi una de las mas interesantes es que ya viene con soporte para Java 6 y completamente basado en Java 5, ya era hora !. Me tomado el permiso de pegar la traducción que hizo Dos Ideas.

• Completamente basado en Java 5. Esta la primer versión de Spring que necesita Java 5 o superior para funcionar, y que utiliza la sintáxis de Java 5 en todo el API de Spring, y también en su implementación. Por ejemplo, el API del BeanFactory retorna instancias tipadas con generics cuando es posible, y un ApplicationListener puede declarar tipos de eventos específicos con generics. En comparación, Spring 2.5 (la versión actual de Spring) todavía es compatible con el JDK 1.4, aunque mucha funcionalidad de alto nivel se construía en Java 5.
• Lenguaje de expresiones de Spring (SpEL – Spring Expression Language). Un parser de expresiones para usar en la definición de los beans, que permite referenciar a estructuras anidadas (por ejemplo, propiedades de otros beans), y también a estructuras del sistema (por ejemplo, variables de entorno) usando la sintáxis común #{…} en el valor de las propiedaes de un bean. Esto también sirve como base para otras características basadas en expresiones en otros proyectos de Spring.
• Soporte extendido para componentes basados en anotaciones. Se incluye el concepto de clases de configuración y métodos de factory anotados – ¡las características fundamentales del proyecto Spring JavaConfig finalmente están disponibles en Spring!. Sprint también permite inyectar valores de configuración a través de expresiones @Value, y referirse a valores de la configuración usando expresiones dinámicas #{…} o estáticas ${…}.
• Modelo de estereotipos. Permite crear anotaciones “de atajo” a través del uso de meta-anotaciones. Por ejemplo, para determinar scopes predeterminados o características de transacción predeterminadas en estereotipos propios. Imaginen una anotación propia @MiServicio que indica @Service, @Scope(“request”) y @Transactional(readOnly=true) usando una única anotación. Este es el principio de No Repetirse aplicado al uso de anotaciones de componentes.
• Anotaciones de inyección de dependencias estándar. Spring 3.0 provee un soporte inicial para el JSR-330 specification for Dependency Injection in Java- inyección a través de anotaciones usando javax.inject.Inject y sus calificadores asociados y modelo de proveedores, como una forma alternativa a la anotación @Autowired propia de Spring. Tengan en cuenta que el JSR-330 todavía no está terminado; el soporte para javax.inject en Spring se irá completando a medida que madure la especificación.
• Modelo de validaciones declarativo basado en anotaciones de restricciones. Configuración al estilo de Spring de un proveedor de JSR-303 Bean Validation (como ser, Hibernate Validator 4.0). Spring 3.0 viene con una opción para hacer validaciones basadas en anotaciones en Spring MVC, exponiendo una vista unificada cuando no se cumplen las restricciones. Tengan en cuenta que el JSR-303 está próximo a terminarse, aunque todavía puede tener modificaciones.
• Soporte para REST extendido. Soporte nativo para REST en Spring MVC, como ser mapeos de peticiones REST, extracción de variables URI a través de parámetros @PathVariable, y resolución de vistas guiadas por la negociación del contenido. Imaginen Spring MVC 2.5 con soporte de primera clase para REST – y manteniendo en enfoque de MVC. Hay soporte para el lado del cliente de REST a través de la clase RestTemplate.
• Mapeo Objeto/XML (OXM). Tal como se usaba en Spring Web Services, ahora dentro del núcleo de Spring Framework. Abstracciones para el marshalling y unmarshalling con soporte directo para JAXB 2, Castor, etc. Se provee opciones de integración para soporte de contenidos XML en Spring MVC y Spring JMS.
• Soporte para Portlet 2.0. Spring MVC soporta completamente los entorno de Portlet 2.0 y el nuevo modelo de recursos y eventos de Portlet 2.0. Se incluyen facilidades de mapeo para peticiones de portlet típicas: @ActionMapping, @RenderMapping, @ResourceMapping, @EventMapping.
• Nuevo sistema de scheduling. Nuevos mecanismos de TaskScheduler y Trigger con soporte estilo cron, alineados con el mecanismo de Spring TaskExecutor. Spring 3.0 provee un namespace que soporta anotaciones @Async y @Scheduled. Esto se puede ejecutar sobre pooles nativos de hilos o en pooles manejados por Servidores de Aplicaciones, incluyendo soporte para los servidores de aplicaciones Java EE más populares.
• Y por último, soporte inicial para Java EE 6. Spring 3.0 soporte el uso de JSF 2.0 y JPA 2.0 dentro de Spring, junto al soporte de JSR-303 y JSR-330. Se irá incluyendo soporte para otras tecnologías de Java EE 6 (como Servlet 3.0) a medida que se vayan concretando los productos.

Con la compra de la compañía SpringSource, dedicada a la creación de aplicaciones y desarrollador de java, VMware planea crear una arquitectura de cloud computing y extender su soporte de código abierto.

Por sí sola, SpringSource desarrolla aplicaciones basada en tecnología de código abierto, y la compañía está al frente de varias comunidades ‘open-source’. Entre las aplicaciones destaca Spring Framework, un modelo de programación Java para empresa que VMware dice que ofrece soporte a a cerca de la mitad de todos los proyectos Java empresariales. El Spring Framework lo utilizan cerca de dos millones de desarrolladores de todo el mundo como un entorno de programación ligero para realizar portabilidad de aplicaciones entre entornos de código abierto y aplicaciones comerciales.

Via MuyComputerPro y OjoInternet

El equipo de Spring coronó hace unos años Java, .NET y ahora la siguiente cúspide es Python, el día 1 de Julio se liberó la primera versíon del framework para Python de Spring.

El comunicado dice lo siguiente

Estoy complacido de anunciar que la GA de Spring Python 1.0.0 está disponible. Spring Python toma los conceptos implementados por el Framework Spring y los aplica a Python.

Esta es una ocasión histórica ya que la primera extensión en vivo de SpringSource ha alcanzado un lanzamiento 1.0 estable. El trunk ha sido actualizado para soportar nuevas características, mientras que también se prepara para cualquier actualización portada.

Desde que la concepción de este proyecto comenzó en 2006, la comunidad nos ha proporcionado con excelente retroalimentación mediante el proceso de desarrollo. Aliento a cualquier interesado a involucrarse probando la nueva funcionalidad y proporcionándonos retroalimentación en el foro de la comunidad y en el JIRA mientras nos movemos hacia la nueva funcionalidad de objetivo para la versión 1.1.

Greg Turnquist
Líder del proyecto Spring Python

Descarga el Codigo | Documentación | Python API Doc | Blog

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.

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

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.

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

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.

<bean id="authenticationEntryPoint" class="org.springframework.security.ui.basicauth.BasicProcessingFilterEntryPoint">
  		<property name="realmName"><value>EmForge</value></property>
</bean>

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.

<bean id="logoutFilter" class="org.springframework.security.ui.logout.LogoutFilter">
	 <constructor-arg value="/pages/index.me" />
		<constructor-arg>
			<list>
				<!--  <ref bean="rememberMeServices"/>  -->
				<bean
					class="org.springframework.security.ui.logout.SecurityContextLogoutHandler" />
			</list>
		</constructor-arg>

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.

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

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.

]]> http://blog.jotadeveloper.com/2009/06/23/spring-security-2-la-configuracion-a-la-medida-con-dao-hibernate-iv/feed/ 5 http://blog.jotadeveloper.com/2009/05/26/integrando-flex-con-spring/ http://blog.jotadeveloper.com/2009/05/26/integrando-flex-con-spring/#comments Tue, 26 May 2009 00:55:53 +0000 Jota http://blog.jotadeveloper.com/?p=1735 Presentacion en SpringLive2009 en el aula magna de la UNMSM en Lima, Perú, excelente introducción a las dos tecnologías.
Integrando Flex Y Spring
View more OpenOffice presentations from ricdex.
]]> http://blog.jotadeveloper.com/2009/05/26/integrando-flex-con-spring/feed/ 0 http://blog.jotadeveloper.com/2009/05/25/spring-security-2-la-configuracion-a-la-medida-con-dao-hibernate-iii/ http://blog.jotadeveloper.com/2009/05/25/spring-security-2-la-configuracion-a-la-medida-con-dao-hibernate-iii/#comments Mon, 25 May 2009 15:32:11 +0000 Jota http://blog.jotadeveloper.com/?p=1723 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.



1. 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.
2. El filtro HttpSessionContextIntegrationFilter mantiene el objeto Authentication entre varios requests y se lo pasa al AuthenticationManager y al AccessDecisionManager cuando sea necesario.
3. 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.
4. 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..

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

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.

<bean 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.

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

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.

<bean id="filterInvocationInterceptor"
		class="org.springframework.security.intercept.web.FilterSecurityInterceptor">
		<property name="authenticationManager" ref="authenticationManager" />
		<property name="accessDecisionManager" ref="voteAccessDecisionManager" />
		<property name="objectDefinitionSource">
			<value>
				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				           
         </value>
		</property>
	</bean>

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

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

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

]]> http://blog.jotadeveloper.com/2009/05/25/spring-security-2-la-configuracion-a-la-medida-con-dao-hibernate-iii/feed/ 0 http://blog.jotadeveloper.com/2009/05/13/spring-security-2-la-configuracion-a-la-medida-con-dao-hibernate-ii/ http://blog.jotadeveloper.com/2009/05/13/spring-security-2-la-configuracion-a-la-medida-con-dao-hibernate-ii/#comments Wed, 13 May 2009 06:24:10 +0000 Jota http://blog.jotadeveloper.com/?p=1649 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 ArrayList</string><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 .

]]> http://blog.jotadeveloper.com/2009/05/13/spring-security-2-la-configuracion-a-la-medida-con-dao-hibernate-ii/feed/ 0 http://blog.jotadeveloper.com/2009/05/11/spring-security-2-hibernate-dao-part/ http://blog.jotadeveloper.com/2009/05/11/spring-security-2-hibernate-dao-part/#comments Mon, 11 May 2009 15:38:48 +0000 Jota http://blog.jotadeveloper.com/?p=1617 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 :

• Configuración Spring Security 2.0 con JDBC
• Configuración Spring Security 2.04 para LDAP
• La Seguridad Perfecta con Spring y el dropDownMenu de RichFaces

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.

	<h :inputText id="j_username"  value="#{loginForm.userName}" size="40" required="true"/>
	<h :inputSecret id="j_password" value="#{loginForm.userPassword}" size="40" required="true"/>
	<h :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

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

En la parte II miraremos los Filtros de Seguridad.

]]> http://blog.jotadeveloper.com/2009/05/11/spring-security-2-hibernate-dao-part/feed/ 0 http://blog.jotadeveloper.com/2008/12/07/la-seguridad-perfecta-con-spring-y-el-dropdownmenu-de-richfaces/ http://blog.jotadeveloper.com/2008/12/07/la-seguridad-perfecta-con-spring-y-el-dropdownmenu-de-richfaces/#comments Sun, 07 Dec 2008 13:04:17 +0000 Jota http://blog.jotadeveloper.com/?p=1088 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:

<rich:toolBar>
 
<rich:dropDownMenu >
<f:facet name="label">
        <h:panelGroup>
<h:graphicImage value="#{initParam['rootimages']}/images/icons/contexthelp.png" />
	<h:outputText value="JotaDeveloper" />
	</h:panelGroup>
</f:facet>
	<rich:menuItem submitMode="ajax" value="Articulos"></rich:menuItem>
	<rich:menuItem submitMode="ajax" value="Tutoriales"></rich:menuItem>
	<rich:menuItem submitMode="ajax" value="Ayuda"></rich:menuItem>
</rich:dropDownMenu>
</rich:toolBar>

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.

<rich:toolBar>
<acegijsf:authorize ifAllGranted="ROLE_ROOT_JOTADEVELOPER">
<rich:dropDownMenu >
<f:facet name="label">
        <h:panelGroup>
<h:graphicImage value="#{initParam['rootimages']}/images/icons/contexthelp.png" />
	<h:outputText value="JotaDeveloper" />
	</h:panelGroup>
</f:facet>
	<rich:menuItem submitMode="ajax" value="Articulos" disabled="#{jotaDeveloperMenuBean.rootArticulos}"></rich:menuItem>
	<rich:menuItem submitMode="ajax" value="Tutoriales" disabled="#{jotaDeveloperMenuBean.rootTutoriales}"></rich:menuItem>
	<rich:menuItem submitMode="ajax" value="Ayuda" disabled="#{jotaDeveloperMenuBean.rootAyuda}"></rich:menuItem>
</rich:dropDownMenu>
</acegijsf:authorize>
</rich:toolBar>

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.

]]> http://blog.jotadeveloper.com/2008/12/07/la-seguridad-perfecta-con-spring-y-el-dropdownmenu-de-richfaces/feed/ 0