Auditoría de Usuarios con Spring Security y Data JPA

Clase 22 de 23 • Curso de Java Spring Security: Autenticación y Seguridad Web

Contenido del curso

Introducción

Configuración de seguridad

Autenticación con BD

Seguridad con JWT

Próximos pasos

Tomar examen

Resumen

¿Cómo auditar usuarios en registros con Spring Security?

En el mundo del desarrollo de software, auditar cambios en bases de datos es crucial para garantizar la integridad y seguridad de la información. Anteriormente, en Platzi, aprendimos a auditar fechas de creación y modificación en nuestras aplicaciones con Spring Data JPA. Ahora, gracias al curso de Spring Security, daremos un paso más allá, implementando una auditoría más detallada que incluye el usuario que realiza cambios en los registros de nuestra base de datos.

¿Cómo se configura la entidad para auditar usuarios?

Para poder auditar no solo la fecha de creación y modificación, sino también el usuario, debes realizar algunos ajustes en tu entidad. Aquí te explicamos cómo hacerlo utilizando una entidad llamada PizzaEntity.

Anotaciones y Extensiones:
- Asegúrate de que PizzaEntity tenga la anotación @EntityListener. Esta debe incluir dos listeners:
  - AuditPizzaListener: Tu propia implementación de auditoría.
  - AuditingEntityListener: Proporcionada por Spring para la auditoría estándar.

@EntityListeners({AuditingEntityListener.class, AuditPizzaListener.class})
public class PizzaEntity extends AuditableEntity {
    // atributos
}

Nuevas columnas:
- Agrega dos campos adicionales en la clase para almacenar los usuarios que crean y modifican registros:

@Column(name = "created_by")
private String createdBy;

@Column(name = "modified_by")
private String modifiedBy;

Anotaciones para Auditoría:
- Usa las anotaciones @CreatedBy y @LastModifiedBy para indicarle a Spring cuál atributo debe auditar para el creador y modificador respectivamente.

@CreatedDate
private Date createdDate;

@CreatedBy
private String createdBy;

@LastModifiedDate
private Date lastModifiedDate;

@LastModifiedBy
private String modifiedBy;

¿Cómo se obtiene el usuario autenticado para auditoría?

El siguiente paso es capturar el usuario autenticado al momento de crear o modificar un registro. Para ello, crea una clase en el paquete de audit:

Clase de Auditoría del Usuario:

@Service
public class AuditUsername implements AuditorAware<String> {

    @Override
    public Optional<String> getCurrentAuditor() {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        if (auth == null || !auth.isAuthenticated()) {
            return Optional.empty();
        }
        return Optional.of(auth.getName());
    }
}

Validaciones de Seguridad:
- Asegúrate de validar si la autenticación es nula o si no está autenticado antes de capturar el usuario.

¿Cómo se prueba la auditoría de usuario?

Luego de implementar estos cambios, es vital verificar que todo funcione correctamente:

Generación de JSON Web Token:
- Usa una herramienta como Postman para generar un JSON Web Token (JWT) con credenciales válidas.
Pruebas de Creación y Modificación:
- Realiza operaciones en la base de datos autenticándote con el token generado.
- Prueba la creación de un nuevo registro y verifica que CreatedBy contenga el usuario correcto.
- Realiza una modificación y comprueba que ModifiedBy se actualice correctamente.
Verificación en MySQL:
- Ejecuta consultas en tu base de datos MySQL para comprobar que los cambios se reflejan correctamente en los registros.

¿Por qué es importante una auditoría detallada?

Implementar una auditoría que incluye usuarios no solo aporta un plus de seguridad a tu aplicación, sino que también permite rastrear acciones específicas en caso de errores o accesos no deseados. Incrementa la transparencia y la confiabilidad del sistema, aspectos esenciales en entornos de producción. Además, optimiza el monitoreo de actividades y facilita la identificación de patrones inusuales o potencialmente peligrosos. ¿Te animas a implementarlo? ¡Asegúrate de probar y depurar tu código a fondo!

¡Sigue adelante con este conocimiento y aplica estas técnicas para mejorar la seguridad y robustez de tus proyectos con Spring!

Comentarios

Brayan Estiben Rodallega Saavedra

student•

Genial! Importante tener presente esta información, gracias! 🙂👍

ANDRES ALFONSO MIRA MEJIA

student•

✅

Victor Jesús Rivas Seíjas

student•

Guía de como utilizar OpenApi con JWT

Alexander Coronell

student•

AuditableEntity

package com.platzi.pizzeria.persistence.audit;

import jakarta.persistence.Column;
import jakarta.persistence.MappedSuperclass;
import org.springframework.data.annotation.CreatedBy;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedBy;
import org.springframework.data.annotation.LastModifiedDate;

import java.time.LocalDateTime;

@MappedSuperclass
public class AuditableEntity {
    @Column(name = "created_date")
    @CreatedDate
    private LocalDateTime createdDate;

    @Column(name = "modified_date")
    @LastModifiedDate
    private LocalDateTime modifiedDate;

    @Column(name = "created_by")
    @CreatedBy
    private String createdBy;

    @Column(name = "modified_by")
    @LastModifiedBy
    private String modifiedBy;
}

AuditUsername

package com.platzi.pizzeria.persistence.audit;

import org.springframework.data.domain.AuditorAware;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Service;

import java.util.Optional;

@Service
public class AuditUsername implements AuditorAware<String> {
    @Override
    public Optional<String> getCurrentAuditor() {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();

        if(authentication == null || !authentication.isAuthenticated()) {
            return null;
        }

        String username = authentication.getPrincipal().toString();

        return Optional.of(username);
    }
}

Dimas Arley Lopez Espinosa

student•

Hola alejando.. gracias por tu curso, tengo otra pregunta, tengo un proyecto que ya tiene su base de datos y esta siendo utilizada por un proyecto viejo el cual esta en producción, por lo tanto no puedo hacer demasiadas modificaciones en la DB, la pregunta es, al crear mi clase AuditableEntity, como hago para aplicarla en cada entidad en razón a que cada una ya tiene previamente creadas estas columnas?, es decir si extiendo mi clase auditable en cada entidad no quedarian repetidas las columnas dos veces? (createdDate, modifiedDate, createdBy, modifiedBy)

Dimas Arley Lopez Espinosa

student•

Hola Alejandro espero estés muy bien, genial el curso y esta es la segunda vez que lo veo.. tengo un dilema, estoy migrando un software a nuevas tecnologías y quiero implementar esta auditoria, pero las tablas cuando las crearon les incluyeron por defecto estos campos, es decir ya lo tiene la entidad, y segundo, algunas tablas las crearon con el nombre en inglés y otras con el nombre en español, la pregunta es en ese caso tendria que hacer dos veces cada clase de auditoria una en ingles y otra en español, y lo mejor sería hablar con el cliente para ver si las puedo estandarizar todas?

Gracias

Will Carlo

student••

yo te recomiendo manejar todo en inglés, y crea una clase AuditableEntity, ahí ya colocas lo que necesites, como el createdBy, createdAt, updatedBy, updatedAt, etc.

@MappedSuperclass
@Getter @Setter
@EntityListeners(AuditingEntityListener.class)public class AuditableEntity {    
@Column(name = "created_by", updatable = false)    
@CreatedBy    
private String createdBy;  
  
@Column(name = "created_at", updatable = false)    
@CreatedDate    
private LocalDateTime createdAt;    
  
@Column(name = "updated_by")    
@LastModifiedBy    
private String updatedBy;    
  
@Column(name = "updated_at")   
@LastModifiedDate    private LocalDateTime updatedAt;
}

y ya en el resto de entitys heredas la AuditableEntity

@Getter @Setter
@NoArgsConstructor 
@AllArgsConstructor
@Entity @Table(name = "products")
public class ProductEntity extends AuditableEntity implements Serializable {
@Id    
@GeneratedValue(strategy = GenerationType.IDENTITY) 
@Column(name = "id", nullable = false)    
private Integer id;    
  
@Column(nullable = false, length = 150)    private String name;
}

así cuando arranques el programa crearás los campos de auditoria según el entity personalizado que creaste, peeero si la quires en español, crea los atributos de AuditableEntity en español y listo

Luis Manuel Cacuango Gonza

student••

Auditusername

package com.luigi.pizza.persistence.audit;

import org.springframework.data.domain.AuditorAware;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Service;

import java.util.Optional;

@Service
public class AuditUsername implements AuditorAware<String> {

    @Override
    public Optional<String> getCurrentAuditor() {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        if (authentication == null || !authentication.isAuthenticated()) {
            return Optional.empty(); // Mejor que devolver null
        }
        return Optional.ofNullable(authentication.getName());  // Mejor usar .getName()
    }
}

Omar Stiven Rivera Rocha

student•

Hola Alejandro ¿cómo estás?

He estado construyendo mi api de base de datos de películas y aún me falta terminar el módulo de seguridad, me he centrado por el momento en terminar los CRUD. He querido aplicar lo visto desde el primer curso que tienes, pero me han resultado errores con el Mapstruct, cuando hago uso del resto de los Mapstructs ya hechos, y me sale por ejemplo:

Cannot invoke "com.movie.moviedb.persistence.mapper.GenreMapper.toGenre(com.movie.moviedb.persistence.entity.GenreEntity)" because "this.genreMapper" is null

Al parecer no encuentra la instancia, pero no hallo más forma de hacer que entre al contexto de la App. Hasta le he colocado @Component, y nada.

@Mapper(componentModel = "spring")
@Component
public interface GenreMapper {
    @Mappings({
            @Mapping(source = "idGenre", target = "id"),
    })
    Genre toGenre(GenreEntity genre);
    List<Genre> toGenres(List<GenreEntity> genres);

    @InheritInverseConfiguration
    @Mappings({
            @Mapping(target = "movies", ignore = true),
    })
    GenreEntity toGenreEntity(Genre genre);
}

@Mapper(componentModel = "spring", uses = {GenreMapper.class,DirectorMapper.class,  ActorRoleMapper.class})
@Component
public interface MovieMapper {
    @Mappings({
            @Mapping(source = "idMovie", target = "id"),
    })
    Movie toMovie(MovieEntity actor);
    List<Movie> toMovies(List<MovieEntity> actors);

    @InheritInverseConfiguration
    @Mappings({
            @Mapping(target = "qualifications", ignore = true),
            @Mapping(target = "actors", ignore = true),
    })
    MovieEntity toMovieEntity(Movie actor);
}
```@Mapper(componentModel = "spring", uses = {GenreMapper.class,DirectorMapper.class,  ActorRoleMapper.class})

@Component

public interface MovieMapper {

&#x20;   @Mappings({

&#x20;           @Mapping(source = "idMovie", target = "id"),

&#x20;   })

&#x20;   Movie toMovie(MovieEntity actor);

&#x20;   List\<Movie> toMovies(List\<MovieEntity> actors);



&#x20;   @InheritInverseConfiguration

&#x20;   @Mappings({

&#x20;           @Mapping(target = "qualifications", ignore = true),

&#x20;           @Mapping(target = "actors", ignore = true),

&#x20;   })

&#x20;   MovieEntity toMovieEntity(Movie actor);

}



Este es el link a mi repositorio: 



Gracias ;)

Omar Stiven Rivera Rocha

student•

Se me repitió el código del MovieMapper, disculpas por eso.

Luis Alfonso Sarmiento Heredia

student•

Buenos dias con todos no se si alguien me puede orientar para poder enviar el token generado pero en el body mas no en el header de antemano agradezco su comprension que tengan un buen dia

J. Sebastián Botello. H.

student•

Podrías llamar desde el controller el servicio que genera el token y crear un objeto que responda con el nuevo token.

Normalmente los controller llaman los componentes de tipo servicio entonces no abría problema

String accessToken = jwtUtils.createAccessToken(authCredentials.getEmail(), Roles.USER);

Riccieri Riquelmi Alvarado Palacios

student•

Porque cuando da 403 0 401 no muestra error, sino que la respuesta de la peticion solo está vacia? Hay alguna forma para amanejar esas excepciones?

Ricardo Rendon

student•

Porque si hago un update de una pizza que tiene un usuario que la creo este no persiste, igualmente pasa con las fechas de creación y de actualización, se borran y quedan en null y solo quedan los datos de actualización.

Ivan Molero Delgado

student•

Hola Ricardo, a mi me funcionó poner el campo de la fecha de creación como updatable=false, con eso tiene, puedes hacer lo mismo en el de usuario, los datos de actualización si deben ser actualizables.

package com.platzi.pizzeria.persistence.audit;

import jakarta.persistence.Column;
import jakarta.persistence.MappedSuperclass;
import org.springframework.data.annotation.CreatedBy;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedBy;
import org.springframework.data.annotation.LastModifiedDate;

import java.time.LocalDateTime;

@MappedSuperclass
public class AuditableEntity {
    @Column(name = "created_date")
    @CreatedDate
    private LocalDateTime createdDate;

    @Column(name = "modified_date")
    @LastModifiedDate
    private LocalDateTime modifiedDate;

    @Column(name = "created_by")
    @CreatedBy
    private String createdBy;

    @Column(name = "modified_by")
    @LastModifiedBy
    private String modifiedBy;
}

package com.platzi.pizzeria.persistence.audit;

import org.springframework.data.domain.AuditorAware;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Service;

import java.util.Optional;

@Service
public class AuditUsername implements AuditorAware<String> {
    @Override
    public Optional<String> getCurrentAuditor() {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();

        if(authentication == null || !authentication.isAuthenticated()) {
            return null;
        }

        String username = authentication.getPrincipal().toString();

        return Optional.of(username);
    }
}

@MappedSuperclass
@Getter @Setter
@EntityListeners(AuditingEntityListener.class)public class AuditableEntity {    
@Column(name = "created_by", updatable = false)    
@CreatedBy    
private String createdBy;  
  
@Column(name = "created_at", updatable = false)    
@CreatedDate    
private LocalDateTime createdAt;    
  
@Column(name = "updated_by")    
@LastModifiedBy    
private String updatedBy;    
  
@Column(name = "updated_at")   
@LastModifiedDate    private LocalDateTime updatedAt;
}

@Getter @Setter
@NoArgsConstructor 
@AllArgsConstructor
@Entity @Table(name = "products")
public class ProductEntity extends AuditableEntity implements Serializable {
@Id    
@GeneratedValue(strategy = GenerationType.IDENTITY) 
@Column(name = "id", nullable = false)    
private Integer id;    
  
@Column(nullable = false, length = 150)    private String name;
}

package com.luigi.pizza.persistence.audit;

import org.springframework.data.domain.AuditorAware;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Service;

import java.util.Optional;

@Service
public class AuditUsername implements AuditorAware<String> {

    @Override
    public Optional<String> getCurrentAuditor() {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        if (authentication == null || !authentication.isAuthenticated()) {
            return Optional.empty(); // Mejor que devolver null
        }
        return Optional.ofNullable(authentication.getName());  // Mejor usar .getName()
    }
}

@Mapper(componentModel = "spring")
@Component
public interface GenreMapper {
    @Mappings({
            @Mapping(source = "idGenre", target = "id"),
    })
    Genre toGenre(GenreEntity genre);
    List<Genre> toGenres(List<GenreEntity> genres);

    @InheritInverseConfiguration
    @Mappings({
            @Mapping(target = "movies", ignore = true),
    })
    GenreEntity toGenreEntity(Genre genre);
}

@Mapper(componentModel = "spring", uses = {GenreMapper.class,DirectorMapper.class,  ActorRoleMapper.class})
@Component
public interface MovieMapper {
    @Mappings({
            @Mapping(source = "idMovie", target = "id"),
    })
    Movie toMovie(MovieEntity actor);
    List<Movie> toMovies(List<MovieEntity> actors);

    @InheritInverseConfiguration
    @Mappings({
            @Mapping(target = "qualifications", ignore = true),
            @Mapping(target = "actors", ignore = true),
    })
    MovieEntity toMovieEntity(Movie actor);
}
```@Mapper(componentModel = "spring", uses = {GenreMapper.class,DirectorMapper.class,  ActorRoleMapper.class})

@Component

public interface MovieMapper {

&#x20;   @Mappings({

&#x20;           @Mapping(source = "idMovie", target = "id"),

&#x20;   })

&#x20;   Movie toMovie(MovieEntity actor);

&#x20;   List\<Movie> toMovies(List\<MovieEntity> actors);



&#x20;   @InheritInverseConfiguration

&#x20;   @Mappings({

&#x20;           @Mapping(target = "qualifications", ignore = true),

&#x20;           @Mapping(target = "actors", ignore = true),

&#x20;   })

&#x20;   MovieEntity toMovieEntity(Movie actor);

}



Este es el link a mi repositorio: 



Gracias ;)

Auditoría de Usuarios con Spring Security y Data JPA

Introducción

Protección de aplicaciones con Spring Security

Configuración de Spring Security: Autorización y Autenticación

Configuración de Spring Security en Proyectos Java con Gradle

Autenticación Básica con Spring Security por Defecto

Configuración de seguridad

Configuración de Seguridad con Spring Security y Basic Authentication

Funcionamiento del Basic Authentication Filter en Spring Security

Deshabilitar protección CSRF en APIs REST con Spring Security

Configuración de CORS en Spring Security para APIs y Frontend

Configuración de Reglas de Acceso en Spring Security

Creación de usuarios personalizados en Spring Security

Creación y Gestión de Roles y Permisos en Aplicaciones Web

Autenticación con BD

Creación y Gestión de Usuarios en Base de Datos con Spring Security

Implementación de User Detail Service en Spring Security con MySQL

Asignación de Roles y Permisos en Spring Security

Permisos Específicos con Authorities en Spring Security

Seguridad de Métodos en Spring Security: Control de Accesos por Roles

Seguridad con JWT

Creación y Uso de JSON Web Tokens en Java con Auth0

Implementación de Autenticación con JSON Web Tokens en Spring Boot

Validación de JSON Web Tokens con Auth0 en Java

Creación de Filtro de Seguridad JWT en Spring Security

Implementación de JSON Web Token en Spring Security

Próximos pasos

Auditoría de Usuarios con Spring Security y Data JPA

Configuración y Personalización de Spring Security