En el desarrollo de software actual, no basta con que las aplicaciones funcionen: deben ser seguras, trazables y robustas frente a amenazas cada vez más avanzadas. La programación orientada a objetos permite estructurar estos sistemas de forma modular y mantenible. Al integrar elementos como persistencia, auditoría, trazabilidad y patrones de diseño, se logran aplicaciones más seguras, confiables y controlables ante riesgos.

Persistencia

La persistencia en POO es la capacidad de guardar información de forma permanente para su posterior recuperación. En ciberseguridad, es clave porque permite registrar actividades, detectar comportamientos sospechosos y realizar auditorías. Se implementa mediante clases que gestionan el almacenamiento de datos, favoreciendo un diseño modular y mantenible .

La figura 1 presenta una visión general de la persistencia en ciberseguridad dentro de un sistema informático. Se distinguen los componentes persistencia de datos y de eventos.

13.1 Persistencia de datos

La persistencia de datos consiste en almacenar información estructurada en medios permanentes como archivos o bases de datos. En sistemas de acceso seguro, esto implica gestionar usuarios, contraseñas (en forma de hash), roles y permisos.

El uso de POO permite separar la lógica de negocio de la lógica de persistencia, lo cual mejora la seguridad y escalabilidad del sistema .

La figura 2 ilustra cómo los datos persistentes deben ser protegidos, monitoreados y auditados para garantizar su seguridad frente a amenazas.

Ejemplo: Persistencia de usuarios en un sistema de acceso seguro

a) Clase Usuario

//Clase Usuario representa un usuario del sistema

class Usuario {

private String username;

private String passwordHash

private String rol;

 

public Usuario(String username, String passwordHash, String rol) {

this.username = username;

this.passwordHash = passwordHash;

this.rol = rol;

}

 

public String getUsername() {

return username;

}

 

public String getPasswordHash() {

return passwordHash;

}

 

public String getRol() {

return rol;

}

}

Esta clase representa la entidad principal del sistema. El uso de hash de contraseña evita almacenar credenciales en texto plano .

b) Repositorio de usuarios (persistencia en archivo)

import java.io.*;

 

// Clase que gestiona la persistencia de usuarios en archivo

class UsuarioRepository {

 

private static final String FILE = "usuarios.txt";

public void guardarUsuario(Usuario usuario) {

 

// Bloque try-with-resources para asegurar el cierre automático del archivo

try (BufferedWriter bw = new BufferedWriter(new FileWriter(FILE, true))) {

 

// Escribe los datos del usuario separados por comas

bw.write(usuario.getUsername() + "," +

usuario.getPasswordHash() + "," +

usuario.getRol());

 

bw.newLine();

 

} catch (IOException e) {

 

e.printStackTrace();

}

}

 

// Método que busca un usuario en el archivo por su nombre

public Usuario buscarUsuario(String username) {

 

// Bloque try-with-resources para lectura del archivo

try (BufferedReader br = new BufferedReader(new FileReader(FILE))) {

 

String linea;

 

// Itera sobre cada línea del archivo

while ((linea = br.readLine()) != null) {

 

// Divide la línea en partes usando la coma como separador

String[] datos = linea.split(",");

 

// Verifica si el username coincide con el buscado

if (datos[0].equals(username)) {

 

// Retorna un nuevo objeto Usuario con los datos encontrados

return new Usuario(datos[0], datos[1], datos[2]);

}

}

 

// Manejo de errores de lectura

} catch (IOException e) {

 

e.printStackTrace();

}

return null;

}

}

Aquí se aplica el patrón Repository, que encapsula el acceso a datos y permite cambiar fácilmente el mecanismo de almacenamiento .

c) Servicio de autenticación

// Clase que gestiona la lógica de autenticación

class AuthService {

 

private UsuarioRepository repo;

 

public AuthService(UsuarioRepository repo) {

 

this.repo = repo;

}

 

public boolean login(String username, String passwordHash) {

 

Usuario usuario = repo.buscarUsuario(username);

 

if (usuario == null) {

return false;

}

 

return usuario.getPasswordHash().equals(passwordHash);

}

}

Este servicio separa la lógica de autenticación del almacenamiento, cumpliendo el principio de responsabilidad única .

13.2 Persistencia de eventos

La persistencia de eventos consiste en registrar cada acción relevante del sistema como un evento inmutable.

En ciberseguridad, esto es esencial para auditoría de accesos, detección de ataques (fuerza bruta, accesos no autorizados), análisis forense.

Este enfoque se relaciona con el patrón Event Sourcing, donde el estado del sistema se reconstruye a partir de eventos .

La figura 3 ilustra cómo los eventos del sistema son capturados, almacenados, monitoreados y protegidos, permitiendo auditoría, trazabilidad y detección de amenazas.

Ejemplo: Registro de eventos de seguridad

a) Clase Evento de Seguridad

import java.time.LocalDateTime;

 

// Clase que representa un evento de seguridad (auditoría)

class EventoSeguridad {

 

private String usuario;

// Atributo que almacena el tipo de acción (LOGIN_EXITOSO, LOGIN_FALLIDO)

private String accion;

private String ip;

private LocalDateTime fecha;

 

// Constructor que inicializa los atributos del evento

public EventoSeguridad(String usuario, String accion, String ip) {

this.usuario = usuario;

this.accion = accion;

this.ip = ip;

this.fecha = LocalDateTime.now();

}

 

public String serializar() {

 

return fecha + "|" + usuario + "|" + accion + "|" + ip;

}

}

Los eventos son inmutables, lo que garantiza la integridad de la información registrada .

b) Almacenamiento de eventos

import java.io.*;

 

// Clase que gestiona la persistencia de eventos de seguridad

class EventStore {

 

private static final String FILE = "eventos.log";

 

public void guardarEvento(EventoSeguridad evento) {

 

// Bloque try-with-resources para escritura segura

try (BufferedWriter bw = new BufferedWriter(new FileWriter(FILE, true))) {

 

// Escribe el evento serializado en el archivo

bw.write(evento.serializar());

bw.newLine();

 

} catch (IOException e) {

e.printStackTrace();

}

}

}

Este componente permite mantener un historial completo de actividades, fundamental para auditoría y monitoreo.

Integración de los componentes de persistencia de datos y eventos

// Clase que integra autenticación y auditoría

class SistemaAccesoSeguro {

 

// Servicio de autenticación

private AuthService authService;

 

// Sistema de almacenamiento de eventos

private EventStore eventStore;

 

// Constructor que recibe las dependencias

public SistemaAccesoSeguro(AuthService authService, EventStore eventStore) {

this.authService = authService;

this.eventStore = eventStore;

}

 

// Método que gestiona un intento de inicio de sesión

public void intentarLogin(String username, String passwordHash, String ip) {

 

// Llama al servicio de autenticación

boolean autenticado = authService.login(username, passwordHash);

 

if (autenticado) {

System.out.println("Acceso concedido");

// Registra evento de login exitoso

eventStore.guardarEvento(

new EventoSeguridad(username, "LOGIN_EXITOSO", ip)

);

 

} else {

 

System.out.println("Acceso denegado");

 

// Registra evento de login fallido

eventStore.guardarEvento(

new EventoSeguridad(username, "LOGIN_FALLIDO", ip)

);

}

}

}

// Clase principal del sistema

public class SistemaSeguro {

 

public static void main(String[] args) {

 

// Crea instancia del repositorio de usuarios

UsuarioRepository repo = new UsuarioRepository();

 

// Crea instancia del servicio de autenticación

AuthService authService = new AuthService(repo);

 

// Crea instancia del almacén de eventos

EventStore eventStore = new EventStore();

 

Usuario usuario = new Usuario("admin", "123hash", "ADMIN");

 

repo.guardarUsuario(usuario);

 

SistemaAccesoSeguro sistema =

new SistemaAccesoSeguro(authService, eventStore);

 

sistema.intentarLogin("admin", "123hash", "192.168.1.1");

sistema.intentarLogin("admin", "incorrecto", "192.168.1.2");

}

}

Análisis del enfoque de ciberseguridad

El sistema permite registrar accesos y eventos, identificar fallos y mantener trazabilidad, lo que facilita detectar ataques y analizar incidentes. La persistencia de estos datos permite reconstruir comportamientos, garantizar la integridad de la información y realizar auditorías confiables .

La tabla 1 resume características de aspectos sobre la persistencia de datos, objetos y eventos.

Invito a revisar el siguiente video a fin de reforzar el tema de persistencia:

En el contexto de la ciberseguridad, la auditoría y la trazabilidad son mecanismos esenciales para garantizar la transparencia, el control y la seguridad de los sistemas informáticos. Desde la programación orientada a objetos, estos conceptos se implementan mediante clases que permiten registrar, almacenar y analizar eventos del sistema, manteniendo una estructura organizada y reutilizable.

La correcta implementación de auditoría y trazabilidad permite detectar incidentes de seguridad, reconstruir acciones realizadas por los usuarios y cumplir con normativas y estándares de seguridad

14.1 Concepto de auditoría en sistemas informáticos y la importancia de la trazabilidad de eventos

Auditoría en sistemas informáticos

La auditoría es el proceso de registrar, monitorear y analizar las acciones que ocurren dentro de un sistema. En ciberseguridad, esto incluye intentos de acceso, cambios en configuraciones, uso de recursos y actividades sospechosas.

El objetivo es garantizar que todas las acciones puedan ser revisadas posteriormente, permitiendo detectar vulnerabilidades o comportamientos anómalos .

Trazabilidad de eventos

La trazabilidad permite seguir y registrar eventos dentro de un sistema, incluyendo datos como usuario, tiempo y tipo de acción. Es clave para reconstruir incidentes y realizar análisis forense. En POO, se implementa mediante clases que gestionan eventos y separan la auditoría de la lógica del negocio, mejorando la organización y mantenibilidad del código .

La figura 4 permite tener visibilidad, control y capacidad de respuesta ante amenazas en sistemas desarrollados bajo un enfoque OO.

 

Ejemplo: Evento de auditoría

import java.time.LocalDateTime;

 

// Clase que representa un evento auditado

class EventoAuditoria {

 

private final String usuario;

private final String accion;

private final String ip;

private final LocalDateTime fecha;

 

public EventoAuditoria(String usuario, String accion, String ip) {

this.usuario = usuario;

this.accion = accion;

this.ip = ip;

this.fecha = LocalDateTime.now();

}

 

// Método que convierte el evento en formato texto

public String serializar() {

return fecha + "|" + usuario + "|" + accion + "|" + ip;

}

}

Análisis

• El evento es inmutable, lo que evita manipulación
• Se garantiza integridad de la información
• Se facilita auditoría y trazabilidad

El diseño OO permite modelar eventos como entidades claras y reutilizables .

14.2 Uso de registros para auditoría

Los registros (logs) son archivos o sistemas donde se almacenan los eventos generados por el sistema. En ciberseguridad, los logs permiten detectar intentos de intrusión, analizar fallos de autenticación y monitorear actividad del sistema.

El uso de registros estructurados mejora la capacidad de análisis y respuesta ante incidentes .

Ejemplo: Registro de auditoría

import java.io.*;

 

// Clase que gestiona los registros de auditoría

class AuditoriaLogger {

 

private static final String FILE = "auditoria.log";

 

public void registrarEvento(EventoAuditoria evento) {

 

try (BufferedWriter bw = new BufferedWriter(new FileWriter(FILE, true))) {

bw.write(evento.serializar());

 

bw.newLine();

 

} catch (IOException e) {

e.printStackTrace();

}

}

}

Integración con sistema de acceso seguro

// Sistema que integra autenticación y auditoría

class SistemaAccesoSeguroAuditoria {

 

private AuthService authService;

private AuditoriaLogger logger;

 

public SistemaAccesoSeguroAuditoria(AuthService authService, AuditoriaLogger logger) {

this.authService = authService;

this.logger = logger;

}

 

// Método de login con auditoría

public void intentarLogin(String username, String passwordHash, String ip) {

boolean autenticado = authService.login(username, passwordHash);

if (autenticado) {

System.out.println("Acceso concedido");

logger.registrarEvento(

new EventoAuditoria(username, "LOGIN_EXITOSO", ip)

);

} else {

System.out.println("Acceso denegado");

logger.registrarEvento(

new EventoAuditoria(username, "LOGIN_FALLIDO", ip)

);

}

}

}

Análisis del uso de logs en ciberseguridad

Este enfoque permite registrar accesos, detectar ataques y monitorear actividades, facilitando la respuesta a incidentes y el análisis del sistema. La auditoría y la trazabilidad son claves para garantizar control, transparencia y confiabilidad, mientras que en POO se implementan mediante clases bien estructuradas que permiten construir sistemas seguros, robustos y auditables .

La tabla 2 presenta aspectos sobre auditoria y trazabilidad enfocada en ciberseguridad.

La tabla 3 es una comparativa en varios aspectos sobre los temas persistencia, auditoría y trazabilidad enfocados en ciberseguridad.

Accede al siguiente video para reforzar el tema de auditoría y su funcionamiento: