Carlos Fernández García

Esta aplicación web, desarrollada con Java 21 y desplegada en Tomcat 10, utiliza Spring Framework 6.2.5 junto con Spring Security 6.4.4 para ofrecer un sistema completo de autenticación y autorización basado en roles. Está configurada como un Dynamic Web Module 6.0, lo que permite una integración eficiente con servidores de aplicaciones compatibles con Jakarta EE 10.

El sistema permite crear cuentas de usuario que se activan automáticamente al ser registradas. Los usuarios pueden iniciar sesión y acceder a una zona privada con funcionalidades específicas. Por otro lado, los administradores disponen de un área de gestión donde pueden desactivar o eliminar cuentas de usuario, garantizando así el control total del acceso, salvo sobre otras cuentas con rol administrador.

La aplicación diferencia claramente las vistas y funcionalidades accesibles por cada tipo de rol (usuario o administrador), aplicando filtros y restricciones a través de Spring Security. Toda la lógica del sistema se organiza mediante Spring MVC, mientras que el acceso a datos se gestiona con Hibernate y una base de datos MySQL.

En conjunto, se trata de una solución moderna, segura y escalable para proyectos que requieren gestión de usuarios, control de acceso por rol y administración desde un entorno web estructurado.

Ejercicio 1

Este ejercicio consiste en configurar una aplicación web basada en Spring MVC con soporte para persistencia JPA mediante Hibernate, gestión de transacciones, resolución de vistas con JSP, y acceso a una base de datos MySQL usando un pool de conexiones proporcionado por C3P0. La clase centraliza la configuración mediante anotaciones y beans definidos en Java en lugar de archivos XML. Se espera que el alumno entienda cómo se integran los distintos componentes de una aplicación empresarial moderna usando Spring Framework.


package es.pulsoft.seguridad.config;

import java.util.Properties; // Importa la clase Properties para gestionar configuraciones

import javax.sql.DataSource; // Interfaz para representar el origen de datos (base de datos)

import org.springframework.beans.factory.annotation.Autowired; // Permite inyección automática de dependencias
import org.springframework.context.annotation.Bean; // Marca un método que devuelve un bean gestionado por Spring
import org.springframework.context.annotation.ComponentScan; // Habilita el escaneo de componentes en un paquete
import org.springframework.context.annotation.Configuration; // Indica que esta clase contiene configuración
import org.springframework.context.annotation.PropertySource; // Define el archivo de propiedades a utilizar
import org.springframework.core.env.Environment; // Permite acceder a las propiedades del entorno
import org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor; // Traduce excepciones JPA a Spring
import org.springframework.orm.jpa.JpaTransactionManager; // Gestiona las transacciones JPA
import org.springframework.orm.jpa.JpaVendorAdapter; // Adaptador para el proveedor JPA
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean; // Crea el EntityManagerFactory
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter; // Adaptador específico para Hibernate
import org.springframework.transaction.annotation.EnableTransactionManagement; // Habilita las transacciones con anotaciones
import org.springframework.web.servlet.config.annotation.EnableWebMvc; // Activa Spring MVC
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry; // Configura rutas de recursos estáticos
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer; // Permite personalizar configuración MVC
import org.springframework.web.servlet.view.InternalResourceViewResolver; // Configura el motor de vistas con JSP

import com.mchange.v2.c3p0.ComboPooledDataSource; // Implementación de DataSource con conexión en pool (C3P0)

import jakarta.persistence.EntityManagerFactory; // Interfaz para crear EntityManagers

@Configuration // Marca esta clase como una clase de configuración
@EnableWebMvc // Activa la configuración necesaria para aplicaciones web con Spring MVC
@ComponentScan(basePackages = "es.pulsoft.seguridad") // Indica a Spring que escanee ese paquete para detectar componentes
@PropertySource("classpath:persistencia-mysql.properties") // Carga el archivo de propiedades desde el classpath
@EnableTransactionManagement // Activa la gestión de transacciones mediante anotaciones
public class App implements WebMvcConfigurer {

    @Autowired
    private Environment env; // Permite acceder a las propiedades definidas en el archivo persistencia-mysql.properties

    // Configura el resolver de vistas, que resuelve a archivos JSP en una ruta específica
    @Bean
    public InternalResourceViewResolver internalResourceViewResolver() {
        InternalResourceViewResolver resolver = new InternalResourceViewResolver();
        resolver.setPrefix("/WEB-INF/views/"); // Carpeta donde están las vistas
        resolver.setSuffix(".jsp"); // Extensión que tendrán las vistas
        return resolver;
    }

    // Configura el origen de datos usando C3P0 para conexión a la base de datos
    @Bean
    public DataSource dataSource() {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        try {
            dataSource.setDriverClass(env.getProperty("hibernate.connection.driver_class")); // Clase del driver JDBC
        } catch (Exception e) {
            throw new RuntimeException(e); // Lanza excepción si falla al configurar el driver
        }
        dataSource.setJdbcUrl(env.getProperty("hibernate.connection.url")); // URL de la base de datos
        dataSource.setUser(env.getProperty("hibernate.connection.username")); // Usuario
        dataSource.setPassword(env.getProperty("hibernate.connection.password")); // Contraseña

        dataSource.setMinPoolSize(getIntProperty("hibernate.c3p0.min_size")); // Tamaño mínimo del pool
        dataSource.setMaxPoolSize(getIntProperty("hibernate.c3p0.max_size")); // Tamaño máximo del pool
        dataSource.setMaxIdleTime(getIntProperty("hibernate.c3p0.timeout")); // Tiempo máximo en que una conexión puede estar inactiva

        return dataSource;
    }

    // Método auxiliar que convierte una propiedad a entero
    private int getIntProperty(String propName) {
        return Integer.parseInt(env.getProperty(propName));
    }

    // Configura la fábrica de EntityManager (JPA) y propiedades de Hibernate
    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactory(DataSource dataSource) {
        LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
        em.setDataSource(dataSource); // Establece el DataSource configurado anteriormente
        em.setPackagesToScan("es.pulsoft.seguridad.entidad"); // Indica el paquete donde están las entidades JPA

        JpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter(); // Adaptador para Hibernate
        em.setJpaVendorAdapter(vendorAdapter);

        Properties props = new Properties();
        props.setProperty("hibernate.dialect", env.getProperty("hibernate.dialect")); // Dialecto SQL de Hibernate
        props.setProperty("hibernate.hbm2ddl.auto", env.getProperty("hibernate.hbm2ddl.auto", "update")); // Modo de generación de tablas
        props.setProperty("hibernate.show_sql", env.getProperty("hibernate.show_sql")); // Muestra las sentencias SQL
        props.setProperty("hibernate.format_sql", env.getProperty("hibernate.format_sql")); // Formatea las sentencias SQL

        em.setJpaProperties(props); // Establece las propiedades de Hibernate
        return em;
    }

    // Configura el gestor de transacciones de JPA
    @Bean
    public JpaTransactionManager transactionManager(EntityManagerFactory emf) {
        return new JpaTransactionManager(emf);
    }

    // Bean que traduce excepciones de JPA a excepciones específicas de Spring
    @Bean
    public PersistenceExceptionTranslationPostProcessor exceptionTranslation() {
        return new PersistenceExceptionTranslationPostProcessor();
    }

    // Configura rutas para recursos estáticos como CSS y JS
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/css/**")
            .addResourceLocations("classpath:/css/"); // Ruta de recursos CSS
        registry.addResourceHandler("/js/**")
            .addResourceLocations("classpath:/js/"); // Ruta de recursos JavaScript
    }
}

Ejercicio 2

Este ejercicio configura el inicializador del servlet para una aplicación Spring, extendiendo `AbstractAnnotationConfigDispatcherServletInitializer`. La clase define las configuraciones de raíz y de servlet necesarias para el funcionamiento de la aplicación web, incluyendo el mapeo de rutas y la configuración de los servicios y la capa MVC mediante las clases de configuración correspondientes.

Ejercicio 3

Este ejercicio se encarga de inicializar la configuración de seguridad de la aplicación web utilizando Spring Security. Al extender `AbstractSecurityWebApplicationInitializer`, la clase asegura que la configuración de seguridad de Spring se registre correctamente en el contenedor de servlet al momento de iniciar la aplicación.

Ejercicio 4

Este ejercicio configura la seguridad web de la aplicación utilizando Spring Security. Se encarga de definir un `PasswordEncoder` con BCrypt, configurar un `UserDetailsService` para la gestión de usuarios a través de JDBC y establecer un filtro de seguridad que defina qué recursos son accesibles y qué roles requieren permisos específicos. La configuración también incluye la gestión de sesiones, el login, y el manejo de errores de acceso denegado.


package es.pulsoft.seguridad.config;

import javax.sql.DataSource; // Fuente de datos para la gestión de usuarios

import org.springframework.beans.factory.annotation.Autowired; // Para la inyección de dependencias
import org.springframework.context.annotation.Bean; // Para la creación de beans
import org.springframework.context.annotation.ComponentScan; // Para el escaneo de componentes
import org.springframework.context.annotation.Configuration; // Para marcar la clase como configuración

import org.springframework.security.config.annotation.web.builders.HttpSecurity; // Configuración de seguridad HTTP
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity; // Habilita seguridad web
import org.springframework.security.core.userdetails.UserDetailsService; // Para la gestión de usuarios
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder; // Implementación de bcrypt para cifrado de contraseñas
import org.springframework.security.crypto.password.PasswordEncoder; // Interfaz para el cifrado de contraseñas
import org.springframework.security.provisioning.JdbcUserDetailsManager; // Para gestionar usuarios desde la base de datos
import org.springframework.security.web.SecurityFilterChain; // Para configurar los filtros de seguridad HTTP

@Configuration // Indica que esta clase es de configuración
@EnableWebSecurity // Habilita la seguridad web en la aplicación
@ComponentScan // Escanea los componentes de Spring dentro del paquete
public class SeguridadAppConfig {

    @Autowired
    private DataSource seguridadDataSource; // Fuente de datos para usuarios y roles

    // Definir el PasswordEncoder como un bean
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder(); // Retorna un codificador de contraseñas BCrypt
    }

    // Crear un UserDetailsService con el JdbcUserDetailsManager
    @Bean
    public UserDetailsService userDetailsService() {
        JdbcUserDetailsManager userDetailsManager = new JdbcUserDetailsManager(seguridadDataSource); // Gestiona los usuarios desde la base de datos
        userDetailsManager.setDataSource(seguridadDataSource); // Configura la fuente de datos
        return userDetailsManager; // Retorna el servicio de detalles del usuario
    }

    // Configuración de seguridad
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
        .authorizeHttpRequests(auth -> auth // Configura las reglas de autorización
            .requestMatchers("/milogin", "/css/**", "/js/**", "/public/**", "/crearcuenta", 
                             "/cambiopassword", "/usuarios/cambiar", "/usuarios/cambiar/**", 
                             "/WEB-INF/views/milogin.jsp", "/usuarios/guardar").permitAll() // Permite el acceso sin autenticación a las rutas especificadas
            .requestMatchers("/WEB-INF/views/public/**").permitAll() // Permite el acceso a vistas públicas
            .requestMatchers("/administradores").hasRole("ADMIN") // Solo accesible por administradores
            .anyRequest().authenticated() // Requiere autenticación para cualquier otra solicitud
        )
        .formLogin(form -> form // Configura el login
            .loginPage("/milogin") // Página de login personalizada
            .loginProcessingUrl("/login") // URL para procesar el login
            .defaultSuccessUrl("/inicio", true) // Página de inicio tras un login exitoso
            .permitAll() // Permite el acceso al login para todos
        )
        .logout(logout -> logout.permitAll()) // Permite el logout para todos
        .exceptionHandling(exceptions -> exceptions // Configura el manejo de excepciones
            .accessDeniedPage("/error403") // Página de error para acceso denegado
        );

        return http.build(); // Devuelve la configuración de seguridad
    }
}

Ejercicio 5

Este ejercicio configura los niveles de log para diferentes componentes en la aplicación utilizando Logback y SLF4J. Se establece el nivel de log a DEBUG para varios paquetes importantes, como Spring Security, Spring Web y el paquete de la aplicación. Esto permite obtener más información detallada durante el desarrollo y la depuración.

Ejercicio 6

Este filtro intercepta las solicitudes HTTP entrantes y salientes, mostrando información de depuración en la consola, como la URL de la solicitud, el método HTTP, la cadena de consulta, el estado de la respuesta y la ubicación (si está presente) después de procesar la solicitud.


package es.pulsoft.seguridad.config;

import java.io.IOException; // Excepción relacionada con la entrada/salida
import org.springframework.stereotype.Component; // Indica que esta clase es un componente de Spring
import jakarta.servlet.Filter; // Interfaz para crear filtros en la aplicación web
import jakarta.servlet.FilterChain; // Interfaz para la cadena de filtros
import jakarta.servlet.ServletException; // Excepción relacionada con la ejecución de servlets
import jakarta.servlet.ServletRequest; // Interfaz para representar la solicitud HTTP
import jakarta.servlet.ServletResponse; // Interfaz para representar la respuesta HTTP
import jakarta.servlet.http.HttpServletRequest; // Extensión para solicitudes HTTP
import jakarta.servlet.http.HttpServletResponse; // Extensión para respuestas HTTP

@Component // Marca la clase como un componente gestionado por Spring
public class RedirectDebugFilter implements Filter {

    // Este método se ejecuta en cada solicitud HTTP para interceptarla y procesarla
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) 
            throws IOException, ServletException {
        
        // Convierte la solicitud y respuesta genéricas a HTTP (para acceder a detalles específicos)
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        HttpServletResponse httpResponse = (HttpServletResponse) response;

        // Imprime información de la solicitud entrante
        System.out.println("\n=== Solicitud Entrante ===");
        System.out.println("URL: " + httpRequest.getRequestURL()); // Muestra la URL solicitada
        System.out.println("Método: " + httpRequest.getMethod()); // Muestra el método HTTP (GET, POST, etc.)
        System.out.println("Query: " + httpRequest.getQueryString()); // Muestra la cadena de consulta (si existe)
        
        // Continúa con la cadena de filtros (deja pasar la solicitud)
        chain.doFilter(request, response);
        
        // Imprime información de la respuesta saliente después de que se haya procesado la solicitud
        System.out.println("=== Respuesta Saliente ===");
        System.out.println("Status: " + httpResponse.getStatus()); // Muestra el estado de la respuesta HTTP
        System.out.println("Location: " + httpResponse.getHeader("Location")); // Muestra la cabecera de ubicación (si existe)
    }
}

Ejercicio 7

Este filtro intercepta las solicitudes HTTP entrantes, mostrando información de depuración en la consola, como la URL de la solicitud, el método HTTP, la cadena de consulta, y los encabezados (headers) de la solicitud.


package es.pulsoft.seguridad.config;

import java.io.IOException; // Excepción relacionada con la entrada/salida
import java.util.Collections; // Utilidades para colecciones
import java.util.Enumeration; // Interfaz para enumerar los elementos en una colección

import org.springframework.stereotype.Component; // Marca la clase como un componente gestionado por Spring

import jakarta.servlet.Filter; // Interfaz para crear filtros en la aplicación web
import jakarta.servlet.FilterChain; // Interfaz para la cadena de filtros
import jakarta.servlet.ServletException; // Excepción relacionada con la ejecución de servlets
import jakarta.servlet.ServletRequest; // Interfaz para representar la solicitud HTTP
import jakarta.servlet.ServletResponse; // Interfaz para representar la respuesta HTTP
import jakarta.servlet.http.HttpServletRequest; // Extensión para solicitudes HTTP

@Component // Marca la clase como un componente gestionado por Spring
public class RedirectDebugFilter2 implements Filter {

    // Este método se ejecuta en cada solicitud HTTP para interceptarla y procesarla
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) 
            throws IOException, ServletException {
        
        // Convierte la solicitud genérica a HTTP (para acceder a detalles específicos)
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        
        // Imprime información de la solicitud entrante
        System.out.println("\n===== [DEBUG] Solicitud HTTP =====");
        System.out.println("URL: " + httpRequest.getRequestURL()); // Muestra la URL solicitada
        System.out.println("Método: " + httpRequest.getMethod()); // Muestra el método HTTP (GET, POST, etc.)
        System.out.println("Query: " + httpRequest.getQueryString()); // Muestra la cadena de consulta (si existe)
        
        // Imprime los encabezados de la solicitud HTTP
        Enumeration<String> headerNames = httpRequest.getHeaderNames();
        while(headerNames.hasMoreElements()) {
            String headerName = headerNames.nextElement();
            // Muestra cada nombre de encabezado y sus valores
            System.out.println("Header: " + headerName + " = " + 
                Collections.list(httpRequest.getHeaders(headerName)));
        }
        
        // Continúa con la cadena de filtros (deja pasar la solicitud)
        chain.doFilter(request, response);
    }
}

Ejercicio 8

Esta clase representa la entidad `Users` que se mapea a la tabla `users` en la base de datos. Almacena la información del usuario como nombre de usuario, contraseña, estado habilitado y su lista de autoridades (roles).


package es.pulsoft.seguridad.entidad;

import java.util.List;

import jakarta.persistence.CascadeType;  // Define el tipo de cascada entre entidades relacionadas
import jakarta.persistence.Column;       // Marca los atributos que se mapean a columnas de la tabla
import jakarta.persistence.Entity;       // Marca la clase como una entidad JPA
import jakarta.persistence.FetchType;    // Indica la estrategia de carga de relaciones (LAZY, EAGER)
import jakarta.persistence.Id;           // Marca el campo como clave primaria
import jakarta.persistence.OneToMany;    // Define la relación uno a muchos entre entidades
import jakarta.persistence.Table;        // Especifica el nombre de la tabla en la base de datos

@Entity
@Table(name="users") // Mapea esta clase a la tabla "users"
public class Users {

	@Id // Clave primaria
	@Column(name="username") // Mapea al campo "username" en la base de datos
	private String username;

	@Column(name="password") // Mapea al campo "password"
	private String password;
	
	@Column(name="enabled") // Indica si el usuario está habilitado o no
	private boolean enabled;

	@OneToMany(mappedBy = "username", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
	// Relación uno a muchos con la entidad Authority (carga perezosa y en cascada)
	private List<Authority> authorities;
	
	// Constructor vacío requerido por JPA
	public Users() {
		
	}

	// Constructor con username y password, se habilita automáticamente
	public Users(String username, String password) {
		this.username = username;
		this.password = password;
		this.enabled = true;
	}
	
	// Constructor con username, password y estado habilitado
	public Users(String username, String password, boolean enabled) {
		this.username = username;
		this.password = password;
		this.enabled = enabled;
	}

	// Getters y setters
	
	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

	public String getPassword() {
		return password;
	}

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

	public boolean isEnabled() {
		return enabled;
	}

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

	public List<Authority> getAuthorities() {
		return authorities;
	}

	public void setAuthorities(List<Authority> authorities) {
		this.authorities = authorities;
	}
}

Ejercicio 9

Clase que representa una autoridad o rol asignado a un usuario. Está mapeada a la tabla "authorities" y utiliza una clave primaria compuesta formada por los campos "username" y "authority", definida en la clase AuthorityId.

Ejercicio 10

Clase que representa la clave primaria compuesta de la entidad Authority. Está formada por los campos "username" y "authority". Implementa Serializable, y se sobrescriben los métodos equals y hashCode para garantizar el correcto comportamiento en colecciones y frameworks JPA.

Ejercicio 11

Controlador principal de la aplicación que gestiona las vistas asociadas al inicio, login, administración, usuarios, errores, registro y cambio de contraseña. Utiliza el servicio UsersService para obtener las listas de usuarios por rol y mostrarlas en la vista de inicio.

Ejercicio 12

Controlador encargado de gestionar las operaciones relacionadas con los usuarios. Incluye funcionalidades para crear cuentas, activar/desactivar usuarios, borrar, cambiar contraseñas y mostrar información de usuarios. Utiliza los servicios UsersService y AuthorityService, y codifica las contraseñas con PasswordEncoder.


package es.pulsoft.seguridad.controlador;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

import es.pulsoft.seguridad.entidad.Authority;
import es.pulsoft.seguridad.entidad.Users;
import es.pulsoft.seguridad.service.AuthorityService;
import es.pulsoft.seguridad.service.UsersService;
import jakarta.servlet.http.HttpSession;

@Controller
@RequestMapping("/usuarios")
public class UsersController {

	@Autowired
	private UsersService usersService;

	@Autowired
	private AuthorityService authorityService;

	@Autowired
	private PasswordEncoder encoder;

	@PostMapping("/guardar")
	public String saveOrUpdate(@RequestParam("username") String usuario,
							   @RequestParam("password") String password,
							   @RequestParam("confirmPassword") String confirmPassword,
							   HttpSession httpSession) {

		Users user = usersService.getUser(usuario);
		if (user != null) {
			httpSession.setAttribute("error", "El usuario ya existe");
			return "crearcuenta";
		} else {
			if (password.equals(confirmPassword)) {
				user = new Users(usuario, password);
				Authority authority = new Authority(usuario);
				user.setPassword(encoder.encode(user.getPassword()));
				usersService.addUser(user);
				authorityService.addUser(authority);
				httpSession.setAttribute("success", "Usuario " + user.getUsername() + " creado con exito");
				return "redirect:/milogin";
			} else {
				httpSession.setAttribute("error", "Las contraseñas no coinciden");
				return "crearcuenta";
			}
		}
	}

	@PostMapping("/activar")
	public String active(@RequestParam("username") String usuario,
						 @RequestParam("password") String password,
						 HttpSession httpSession) {

		Users user = usersService.getUser(usuario);
		if (user != null) {
			if (user.isEnabled()) {
				user.setEnabled(false);
				usersService.addUser(user);
				httpSession.setAttribute("success", "Usuario " + user.getUsername() + " desactivado con exito");
			} else {
				user.setEnabled(true);
				usersService.addUser(user);
				httpSession.setAttribute("success", "Usuario " + user.getUsername() + " activado con exito");
			}
		}

		return "redirect:/inicio";
	}

	@PostMapping("/borrar")
	public String delete(@RequestParam("username") String username, HttpSession httpSession) {

		if (username != null && !username.isBlank()) {
			Users user = usersService.getUser(username);
			if (user != null) {
				authorityService.deleteAuthority(username, "ROLE_USER");
				usersService.deleteUser(username);
				httpSession.setAttribute("success", "Usuario " + user.getUsername() + " borrado con éxito");
			} else {
				httpSession.setAttribute("error", "Usuario no encontrado");
			}
		} else {
			httpSession.setAttribute("error", "Nombre de usuario inválido");
		}

		return "redirect:/inicio";
	}

	@GetMapping("/cambiar")
	public String mostrarFormularioCambio(HttpSession session, Model model) {
		return "cambiopassword";
	}

	@PostMapping("/cambiar")
	public String update(@RequestParam("username") String username,
						 @RequestParam("password") String password,
						 @RequestParam("passwordNuevo") String passwordNuevo,
						 @RequestParam("passwordConfirmar") String passwordConfirmar,
						 HttpSession httpSession) {

		Users user = usersService.getUser(username);
		if (user == null) {
			httpSession.setAttribute("error", "Usuario no encontrado");
			return "redirect:/cambiopassword";
		} else if (!encoder.matches(password, user.getPassword())) {
			httpSession.setAttribute("error", "Password incorrecto");
			return "redirect:/cambiopassword";
		} else if (encoder.matches(passwordNuevo, user.getPassword())) {
			httpSession.setAttribute("error", "El password nuevo no puede ser igual que el antiguo");
			return "redirect:/cambiopassword";
		} else if (!passwordNuevo.equals(passwordConfirmar)) {
			httpSession.setAttribute("error", "El password nuevo no coincide con la confirmación");
			return "redirect:/cambiopassword";
		} else {
			httpSession.setAttribute("success", "Cambio de password correcto");
			user.setPassword(encoder.encode(passwordNuevo));
			usersService.addUser(user);
			return "redirect:/miLogin";
		}
	}

	@RequestMapping("/mostrarUsuario")
	public String mostrarUsuario(Model modelo,
								 @RequestParam("username") String username,
								 @RequestParam("password") String password,
								 @RequestParam("enabled") boolean enabled) {

		Users usuario = new Users(username, password, enabled);
		modelo.addAttribute("usuario", usuario);

		return "mostrarusuario";
	}
}

Ejercicio 13

Clase UsersRepository --------------------- Implementa la capa de acceso a datos para la entidad Users utilizando EntityManager. Funcionalidades: - Buscar un usuario por su nombre de usuario. - Guardar o actualizar un usuario. - Buscar usuarios por rol. - Eliminar un usuario si no tiene el rol ROLE_ADMIN. Esta clase permite controlar de forma personalizada las operaciones sobre la tabla de usuarios, incluyendo validaciones para evitar la eliminación de administradores.

package es.pulsoft.seguridad.repository;



import java.util.List;

import org.springframework.stereotype.Repository;

import es.pulsoft.seguridad.entidad.Users;
import jakarta.persistence.EntityManager;
import jakarta.persistence.PersistenceContext;

@Repository
public class UsersRepository {

    @PersistenceContext
    private EntityManager entityManager;

    // Buscar un usuario por su nombre de usuario
    public Users findByUsername(String username) {
        // Usamos entityManager.find() para obtener el usuario por su clave primaria
        return entityManager.find(Users.class, username);
    }

    // Guardar o actualizar un usuario
    public void saveOrUpdate(Users user) {
        // Verificamos que el usuario y su nombre no sean nulos antes de continuar
        if (user != null && user.getUsername() != null) {
            // merge inserta o actualiza dependiendo si existe el usuario
            entityManager.merge(user);
        }
    }

    // Buscar usuarios por rol
    public List<Users> findByRole(String rol) {
        // Consulta JPQL que obtiene usuarios según el rol especificado
        return entityManager.createQuery(
            "SELECT u FROM Users u JOIN u.authorities a WHERE a.authority = :rol", 
            Users.class)
            .setParameter("rol", rol) // Asignamos el parámetro del rol
            .getResultList();         // Ejecutamos la consulta y obtenemos los resultados
    }

    // Eliminar un usuario por su nombre de usuario
    public void delete(String username) {
        // Buscamos el usuario por nombre
        Users user = entityManager.find(Users.class, username);

        if (user != null) {
            // Comprobamos si el usuario tiene el rol ROLE_ADMIN
            boolean isAdmin = user.getAuthorities().stream()
                .anyMatch(authority -> "ROLE_ADMIN".equals(authority.getAuthority()));

            // Solo eliminamos si no es administrador
            if (!isAdmin) {
                entityManager.remove(user);
            }
        }
    }
}

Ejercicio 14

Clase AuthorityRepository ------------------------- Esta clase proporciona acceso a la tabla Authority de la base de datos, gestionando los roles o autoridades asignadas a los usuarios. Funcionalidades: - Buscar una autoridad por nombre de usuario. - Eliminar una autoridad concreta asignada a un usuario. - Guardar o actualizar una autoridad. - Eliminar una autoridad desde una instancia de la entidad Authority. Utiliza EntityManager con anotación @PersistenceContext para interactuar con JPA.

Ejercicio 15

Clase UsersService ------------------ Este servicio proporciona operaciones de alto nivel para gestionar usuarios. Facilita la interacción con la capa de persistencia (UsersRepository), encapsulando las operaciones CRUD relacionadas con los usuarios. Funcionalidades: - Agregar un nuevo usuario o actualizar uno existente. - Obtener un usuario por su nombre de usuario. - Obtener una lista de usuarios por su rol. - Eliminar un usuario por su nombre de usuario. Utiliza transacciones con la anotación @Transactional para garantizar la consistencia de las operaciones de escritura.

Ejercicio 16

Clase AuthorityService ---------------------- Este servicio proporciona operaciones de alto nivel para gestionar las autoridades (roles o permisos) de los usuarios. Funcionalidades: - Agregar o actualizar una autoridad para un usuario. - Eliminar una autoridad para un usuario. - Obtener una autoridad por el nombre de usuario. - Eliminar una autoridad usando un objeto Authority. Utiliza transacciones con la anotación @Transactional para asegurar que las operaciones de escritura sean consistentes.

Ejercicio 17

Crear una vista para el inicio de sesión. La vista debe mostrar un formulario donde el usuario puede ingresar su nombre de usuario y contraseña. Además, deben mostrarse los mensajes de éxito o error si existen en la sesión. También se deben incluir enlaces para crear una cuenta nueva o cambiar la contraseña en caso de que el usuario no tenga una cuenta o quiera actualizar su contraseña.

<%@ page contentType="text/html;charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>

<html>
<head>

<title>Login</title>
<link rel="stylesheet" href="${pageContext.request.contextPath}/css/estilo.css">
<!-- Vincula la hoja de estilos principal para la vista -->
<!--	<script src="${pageContext.request.contextPath}/js/script.js" defer></script> -->
</head>
<body>

	<!-- Contenedor principal del formulario de inicio de sesión -->
	<div class="login-container">
		<!-- Mostrar mensaje de éxito si hay uno en la sesión -->
		<c:if test="${not empty success}">
			<div class="success-message">${success}</div>
			<c:remove var="success" scope="session" />
		</c:if>

		<!-- Mostrar mensaje de error si hay uno en la sesión -->
		<c:if test="${not empty error}">
			<div class="error-message">${error}</div>
			<c:remove var="error" scope="session" />
		</c:if>

		<!-- Título del formulario de login -->
		<h2>Login</h2>

		<!-- Formulario de inicio de sesión -->
		<form action="${pageContext.request.contextPath}/login" method="post">
			<div>
				<!-- Campo de entrada para el nombre de usuario -->
				<label class="labelForm">Usuario:</label> 
				<input type="text" name="username" placeholder="Usuario" required>
			</div>
			<div>
				<!-- Campo de entrada para la contraseña -->
				<label class="labelForm">Contraseña:</label> 
				<input type="password" name="password" placeholder="Contraseña" required>
			</div>
			<!-- Campo oculto para el token CSRF, necesario para proteger el formulario -->
			<input type="hidden" name="${_csrf.parameterName}" value="${_csrf.token}">

			<!-- Botón de envío para el formulario -->
			<div>
				<input type="submit" value="Iniciar Sesión">
			</div>
		</form>
	</div>

	<!-- Enlace para la creación de una cuenta si el usuario aún no tiene cuenta -->
	<div class="mensaje-vista">
		<a href="${pageContext.request.contextPath}/crearcuenta">Crear cuenta</a>
	</div>

	<!-- Enlace para cambiar la contraseña en caso de que el usuario lo necesite -->
	<div class="mensaje-vista">
		<a href="${pageContext.request.contextPath}/cambiopassword">Cambiar Password</a>
	</div>
</body>
</html>

Ejercicio 18

Crear una vista para el panel de administración de usuarios que muestre dos secciones: una para administradores (ADMIN) y otra para usuarios (USER). La vista debe incluir un formulario para cerrar sesión, mostrar el nombre y rol del usuario autenticado, y mostrar mensajes de éxito o error. Los administradores pueden ver una tabla con información de otros administradores (nombre, contraseña truncada y estado de la cuenta). Los usuarios pueden ver una tabla similar con su propia información, con enlaces para acceder a detalles adicionales. Solo los usuarios con rol ADMIN pueden ver la sección de administradores.

<%@ page contentType="text/html;charset=UTF-8" language="java"%>
<%@ taglib prefix="c" uri="jakarta.tags.core"%>
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%>
<%@ taglib prefix="sec" uri="http://www.springframework.org/security/tags"%>
<html>
<head>


    <!-- Vincula las hojas de estilo necesarias para la página -->
    <link rel="stylesheet" href="${pageContext.request.contextPath}/css/estilo.css">
    <link rel="stylesheet" href="${pageContext.request.contextPath}/css/admin-panel.css">
    <title>Panel de Administración</title>
</head>
<body>
    <!-- Contenedor principal de la interfaz de administración -->
    <div class="admin-main-container">
        
        <!-- Formulario de logout, que permite al usuario cerrar sesión -->
        <form id="admin-logout-form" action="${pageContext.request.contextPath}/logout" method="post">
            <div>
                <input id="admin-logout-btn" type="submit" value="Cerrar Sesión">
            </div>
            <!-- Campo oculto para el token CSRF, para prevenir ataques -->
            <input type="hidden" name="${_csrf.parameterName}" value="${_csrf.token}">
        </form>

        <!-- Información del usuario actualmente autenticado -->
        <div id="admin-user-info-container">
            <div id="admin-user-info">
                <!-- Muestra el nombre de usuario autenticado -->
                <label id="admin-username">Nombre: <sec:authentication property="principal.username" /></label>
            </div>
            <div id="admin-roles-info">
                <!-- Muestra los roles del usuario autenticado -->
                <label id="admin-roles">Nivel: <sec:authentication property="principal.authorities" /></label>
            </div>
        </div>

        <!-- Mensajes de éxito/error para notificar al usuario -->
        <c:if test="${not empty sessionScope.success}">
            <div class="success-message">${sessionScope.success}</div>
        </c:if>

        <c:if test="${not empty sessionScope.error}">
            <div class="error-message">${sessionScope.error}</div>
        </c:if>

        <!-- Solo los usuarios con rol ADMIN pueden ver esta sección -->
        <sec:authorize access="hasRole('ADMIN')">
            <!-- Panel de administración de usuarios con rol ADMIN -->
            <div id="admin-panel-container" class="admin-section">
                <a id="admin-panel-link" href="${pageContext.request.contextPath}/administradores">Ir a zona de administradores</a>
                <h3 class="admin-section-title">Usuarios con rol ADMIN</h3>

                <!-- Tabla que muestra la información de los administradores -->
                <div class="table-container">
                    <div class="admin-table admin-admins-table">
                        <!-- Encabezados de la tabla -->
                        <div class="admin-table-row header">
                            <div class="admin-table-cell">Nombre</div>
                            <div class="admin-table-cell">Password</div>
                            <div class="admin-table-cell">Activo</div>
                        </div>

                        <!-- Itera sobre la lista de administradores y muestra su información -->
                        <c:forEach var="usuario" items="${listaAdmins}">
                            <div class="admin-table-row">
                                <div class="admin-table-cell">${usuario.username}</div>
                                <div class="admin-table-cell">${usuario.password.substring(0,30)}</div>
                                <div class="admin-table-cell">${usuario.enabled ? 'Sí' : 'No'}</div>
                            </div>
                        </c:forEach>
                    </div>
                </div>
            </div>
        </sec:authorize>

        <!-- Panel de administración de usuarios con rol USER -->
        <div id="admin-panel-container" class="admin-section">
            <a id="admin-panel-link" href="${pageContext.request.contextPath}/usuarios">Ir a zona de usuarios</a>
            <h3 class="admin-section-title">Usuarios con rol USER</h3>

            <!-- Tabla que muestra la información de los usuarios -->
            <div class="table-container">
                <div class="admin-table admin-users-table">
                    <!-- Encabezados de la tabla -->
                    <div class="admin-table-row header">
                        <div class="admin-table-cell">Nombre</div>
                        <div class="admin-table-cell">Password</div>
                        <div class="admin-table-cell">Activo</div>
                    </div>

                    <!-- Itera sobre la lista de usuarios y muestra su información -->
                    <c:forEach var="usuario" items="${listaUsers}">
                        <!-- Genera un enlace con parámetros para ver los detalles de cada usuario -->
                        <c:url var="linkUsuario" value="/usuarios/mostrarUsuario">
                            <c:param name="username" value="${usuario.username}" />
                            <c:param name="password" value="${usuario.password}" />
                            <c:param name="enabled" value="${usuario.enabled}" />
                        </c:url>

                        <!-- Fila de usuario en la tabla, que es un enlace clickable -->
                        <a href="${linkUsuario}" class="admin-table-row clickable-row">
                            <div class="admin-table-cell">${usuario.username}</div>
                            <div class="admin-table-cell">${usuario.password.substring(0, 10)}</div>
                            <div class="admin-table-cell">${usuario.enabled ? 'Sí' : 'No'}</div>
                        </a>
                    </c:forEach>
                </div>
            </div>
        </div>

    </div>
</body>
</html>

Ejercicio 19

Esta vista está diseñada para la página de administradores de la aplicación. Permite visualizar el nombre de usuario autenticado y su nivel de rol. Muestra mensajes de éxito o error si están disponibles en la sesión. Además, proporciona un formulario para cerrar sesión y un enlace para regresar a la página de inicio. La página incluye protección CSRF y un diseño estilizado a través de la hoja de estilos vinculada.

Ejercicio 20

Esta vista muestra la página para los usuarios autenticados. Permite visualizar el nombre y nivel del usuario autenticado, mostrando también mensajes de éxito o error si están disponibles en la sesión. Incluye un formulario para cerrar sesión con protección CSRF y un enlace para regresar a la página de inicio. El diseño está estilizado con una hoja de estilos vinculada.

Ejercicio 21

Esta vista permite la gestión de usuarios. Muestra mensajes de éxito o error si están disponibles en la sesión. Además, incluye formularios para activar o borrar usuarios. Los campos de usuario y contraseña son de solo lectura y se incluyen acciones de protección CSRF para seguridad. Los botones permiten activar a los usuarios desactivados o eliminar usuarios. Todo el diseño está estilizado con una hoja de estilos vinculada.

<%@ page contentType="text/html;charset=UTF-8" language="java"%>
<%@ taglib prefix="c" uri="jakarta.tags.core"%>
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%>
<%@ taglib prefix="sec" uri="http://www.springframework.org/security/tags"%>

<html>
<head>
    
    <link rel="stylesheet" href="${pageContext.request.contextPath}/css/estilo.css">
    <title>Usuarios</title>
</head>
<body>

    <!-- Mostrar mensaje de éxito si existe en la sesión -->
    <c:if test="${not empty success}">
        <div class="success-message">${success}</div>
        <c:remove var="success" scope="session" />
    </c:if>

    <!-- Mostrar mensaje de error si existe en la sesión -->
    <c:if test="${not empty error}">
        <div class="error-message">${error}</div>
        <c:remove var="error" scope="session" />
    </c:if>

    <!-- Formulario para cerrar sesión -->
    <form id="admin-logout-form" action="${pageContext.request.contextPath}/logout" method="post">
        <div>
            <input id="admin-logout-btn" type="submit" value="Cerrar Sesión">
        </div>
        <input type="hidden" name="${_csrf.parameterName}" value="${_csrf.token}">
    </form>

    <!-- URL para la acción de activar usuario -->
    <c:url var="linkActualizar" value="/usuarios/activar"></c:url>

    <!-- Formulario para activar usuario -->
    <form:form action="${linkActualizar}" method="post" class="login-container" modelAttribute="usuario">
        <div class="crear-cuenta-container">
            <%-- Caja amarilla para editar usuario --%>

            <form:label class="labelForm" path="username">Usuario:</form:label>
            <form:input path="username" readonly="true" />

            <form:label class="labelForm" path="password">Password:</form:label>
            <form:input path="password" readonly="true" />

            <div class="checkbox-wrapper">
                <form:label class="labelForm" path="enabled">Activo</form:label>
                <form:checkbox path="enabled" cssClass="checkbox-grande" />
            </div>

            <div>
                <input type="hidden" name="${_csrf.parameterName}" value="${_csrf.token}">
                <input type="submit" value="Activar" />
            </div>
        </div>
    </form:form>

    <!-- URL para la acción de borrar usuario -->
    <c:url var="linkBorrar" value="/usuarios/borrar"></c:url>

    <!-- Formulario para borrar usuario -->
    <form:form action="${linkBorrar}" method="post" modelAttribute="usuario">
        <form:hidden path="username" />
        <form:hidden path="password" />
        <div>
            <input type="hidden" name="${_csrf.parameterName}" value="${_csrf.token}">
            <input type="submit" value="Borrar" />
        </div>
    </form:form>

</body>
</html>

Ejercicio 22

Enunciado: Esta vista permite la creación de una cuenta de usuario. Muestra un formulario donde el usuario puede ingresar su nombre de usuario, contraseña y confirmar la contraseña. También incluye mensajes de éxito o error si están disponibles en la sesión y tiene protección CSRF para evitar ataques. Además, ofrece un enlace para que los usuarios que ya tienen una cuenta puedan iniciar sesión.

Ejercicio 23

Esta vista permite al usuario cambiar su contraseña. Ofrece un formulario donde se debe ingresar el nombre de usuario, la contraseña actual, la nueva contraseña y su confirmación. Además, incluye un formulario para cerrar sesión y volver a la página de login. Los mensajes de éxito o error se muestran si están disponibles en la sesión. Todos los formularios están protegidos contra ataques CSRF.

<%@ page contentType="text/html;charset=UTF-8" language="java"%>
<%@ taglib prefix="c" uri="jakarta.tags.core"%>
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%>
<%@ taglib prefix="sec" uri="http://www.springframework.org/security/tags"%>

<html>
<head>
    
    <link rel="stylesheet" href="${pageContext.request.contextPath}/css/estilo.css">
    <title>Usuarios</title>
</head>
<body>

    <form id="admin-logout-form" action="${pageContext.request.contextPath}/logout" method="post">
        <div>
            <input id="admin-logout-btn" type="submit" value="Volver Login">
        </div>
        <input type="hidden" name="${_csrf.parameterName}" value="${_csrf.token}">
    </form>

    <c:url var="linkActualizar" value="/usuarios/cambiar"></c:url>
    
    <c:if test="${not empty success}">
        <div class="success-message">${success}</div>
        <c:remove var="success" scope="session" />
    </c:if>

    <c:if test="${not empty error}">
        <div class="error-message">${error}</div>
        <c:remove var="error" scope="session" />
    </c:if>
    
    <form:form action="${linkActualizar}" method="post" class="login-container">
        <div class="crear-cuenta-container">
            <%-- ⬅️ aquí empieza la caja amarilla --%>

            <label class="labelForm">Usuario:</label>
            <input type="text" name="username" required/>

            <label class="labelForm">Password:</label>    
            <input type="password" name="password" required />
            
            <label class="labelForm">Nuevo Password:</label>
            <input type="password" name="passwordNuevo" required />
            
            <label class="labelForm">Confirmar Password:</label>
            <input type="password" name="passwordConfirmar" required/>

            <div>
                <input type="hidden" name="${_csrf.parameterName}" value="${_csrf.token}">
                <input type="submit" value="Cambiar Password" />
            </div>

        </div>
        <%-- ⬅️ aquí termina la caja amarilla --%>
    </form:form>

</body>
</html>

Ejercicio 24

Esta vista se muestra cuando el usuario intenta acceder a una página o recurso para el cual no tiene permisos. Se muestra un mensaje de error 403 indicando que el acceso ha sido denegado, y un enlace para redirigir al usuario de vuelta a la página de inicio.

PULSOFT

APP Panel de usuarios

Spring Security

Mapeo ORM de la entidades

Controladores

Repositorios

Servicios

Vistas JSP