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

1 Comment

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
<beans:bean id="jasyptPasswordEncryptor"
		class="org.jasypt.util.password.StrongPasswordEncryptor" />
 
//
<beans:bean id="passwordEncoder" class="org.jasypt.spring.security2.PasswordEncoder">
		<beans:property name="passwordEncryptor">
			<beans:ref bean="jasyptPasswordEncryptor" />
		</beans:property>
	</beans:bean>
 
<authentication-provider user-service-ref="userService">
		<password-encoder ref="passwordEncoder">
		</password-encoder>

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

Configuración Spring Security 2.0 con JDBC

5 Comments

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

<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>/WEB-INF/applicationContext-security.xml</param-value>
  </context-param>
<filter>
    <filter-name>springSecurityFilterChain</filter-name>
    <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>springSecurityFilterChain</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
  <filter-mapping>

applicationContext-security.xml

 
   <!--  CONFIGURACION VALIDA PARA SPRING SECURITY 2.0 con JDBC
          Author: www.jotadeveloper.com
           http://blog.jotadeveloper.com/2008/11/21/configuracion-spring-security-20-con-jdbc/
 -->
<?xml version="1.0" encoding="UTF-8"?>
<beans:beans 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">
 
   <!--  CONFIGURACION VALIDA PARA SPRING SECURITY 2.0 con JDBC   -->
 
  <http auto-config="true" access-denied-page="/web/error.do">
   	<intercept-url pattern="/" access="IS_AUTHENTICATED_ANONYMOUSLY" />
		<intercept-url pattern="/login.do" access="IS_AUTHENTICATED_ANONYMOUSLY" />
		<intercept-url pattern="/j_spring_security_switch_user"
			access="ROLE_SUPERVISOR" />
		<intercept-url pattern="/web/css/**" access="ROLE_WEBMASTER" />
		<intercept-url pattern="/templates/**" access="ROLE_WEBMASTER" />
		<intercept-url pattern="/web/error/**" access="ROLE_USER" />
 
    <form-login login-page="/login.do" default-target-url='/web/index.do'
			authentication-failure-url="/login.do?login_error=1"  />
    <logout logout-success-url="/" invalidate-session="true"/>
      </http>
 
  <authentication-provider user-service-ref="userService" />
 
  <!-- MYSQL -->
 
  <beans:bean id="securityDataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <beans:property name="driverClassName" value="org.gjt.mm.mysql.Driver" />
    <beans:property name="url" value="jdbc:mysql://localhost/test" />
    <beans:property name="username" value="root" />
    <beans:property name="password" value="" />
  </beans:bean>
  <jdbc-user-service 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 = ? " />
 
 
</beans:beans>

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

4 Comments

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.

<?xml version="1.0" encoding="UTF-8"?>
<beans 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">
 
 
	<s:http>
		<s:intercept-url pattern="/" access="IS_AUTHENTICATED_ANONYMOUSLY" />
		<s:intercept-url pattern="/j_spring_security_switch_user"
			access="ROLE_SUPERVISOR" />
		<s:intercept-url pattern="/web/**" access="ROLE_USER" />
		<s:intercept-url pattern="/web/templates/**" access="ROLE_ADMIN" />
		<s:intercept-url pattern="/"
			access="IS_AUTHENTICATED_ANONYMOUSLY" />
		<s:intercept-url pattern="/login.do"
			access="IS_AUTHENTICATED_ANONYMOUSLY" />
		<s:form-login login-page="/login.do" default-target-url='/web/index.do'
			authentication-failure-url="/login.do?login_error=1" />
			 <s:logout
		logout-success-url="/" />
		<s:http-basic />
		<s:anonymous />
		<s:logout />
	</s:http>
 
	<s:ldap-server id="ldapServer" url="ldap://localhost:389/ou=system"
		manager-dn="uid=admin,ou=system" manager-password="test" />
 
	<!--  grop srch base was groups -->
	<s:ldap-authentication-provider
		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" />
 
	<!-- sAMAccountName java.naming.referrel follow -->
 
	<bean id="contextSource"
		class="org.springframework.security.ldap.DefaultSpringSecurityContextSource">
		<constructor-arg value="ldap://localhost:389/ou=system" />
		<property name="userDn" value="uid=admin,ou=system" />
		<property name="password" value="test" />
	</bean>
 
	<bean id="ldapAuthenticationProvider"
		class="org.springframework.security.providers.ldap.LdapAuthenticationProvider">
		<constructor-arg>
			<bean
				class="org.springframework.security.providers.ldap.authenticator.BindAuthenticator">
				<constructor-arg ref="contextSource" />
				<property name="userSearch" ref="userSearch" />
			</bean>
		</constructor-arg>
		<constructor-arg>
			<bean
				class="org.springframework.security.ldap.populator.DefaultLdapAuthoritiesPopulator">
				<constructor-arg ref="contextSource" />
				<constructor-arg value="cn=users,dc=development,dc=somecompany,dc=com" />
				<property name="convertToUpperCase" value="true" />
				<property name="defaultRole" value="Authenticated" />
				<property name="rolePrefix" value="" />
				<property name="searchSubtree" value="true" />
				<property name="groupSearchFilter" value="(memberUid={0})" />
				<property name="groupRoleAttribute" value="cn" />
			</bean>
		</constructor-arg>
	</bean>
 
	<bean id="userSearch"
		class="org.springframework.security.ldap.search.FilterBasedLdapUserSearch">
		<constructor-arg index="0" value="ou=Users" />
		<constructor-arg index="1" value="(sAMAccountName={0})" />
		<constructor-arg index="2" ref="contextSource" />
		<property name="searchSubtree" value="true" />
	</bean>
 
 
</beans>

Pydev, Phyton en Eclipse

No Comments

Phyton es un lenguaje de programación interpretado, segun la Wikipedia se compara con Perl y es su fiel competencia, Phyton es usado como lenguaje de Programacion del buscador Google y tambien Youtube fue escrito en Phyton.

Los que programan en Phyton o los que piensan programar, o incluso los que aun no han probado, como yo, existe un plug in para Eclipse, todavia hay bugs para la version 3.4, pero puedes usarlo bien en la 3.3 donde se dice es bastante estable.

http://pydev.sourceforge.net/index.html

Java Visual Virtual Machine, monitorea tus Threads

No Comments

Java Visual Virtual Machine, es una nueva herramienta que viene con la versión JDK 1.6.0_10 en adelante, si estas trabajando con Threads te va ser muy util, mejora bastante al antiguo jconsole.exe.

Puedes monitorear el hilo principal, el consumo del CPU y de Memoria, entre otras cosas, una herramienta muy completa para los que desarrollan en Java.

https://visualvm.dev.java.net/