Diagrama de temas
-
PROGRAMACIÓN IV V. - P1111-TEÓRICO-PRACTICO-N0075-06-N01
PRIMER NIVEL
NELSON ESTEBAN SALGADO REYES
—
-
Estructuras de control
-
11. Estructuras de control
Las estructuras de control determinan el flujo de ejecución de un programa y son fundamentales en ciberseguridad, ya que controlan decisiones como permitir o denegar accesos. En programación orientada a objetos, se aplican dentro de métodos que gestionan comportamientos de entidades como usuarios o sistemas de autenticación.
Las son fundamentales para implementar lógica de negocio robusta y segura en aplicaciones Java . El control del flujo es clave para garantizar la correcta toma de decisiones en sistemas críticos .
11.1 CONDICIONALES
Las sentencias condicionales permiten que un programa tome decisiones en función de condiciones lógicas. En sistemas reales como un sistema de acceso seguro estas estructuras determinan si un usuario entra o queda fuera.
Las estructuras condicionales son la base de la toma de decisiones en programación . En POO, estas decisiones se encapsulan dentro de métodos que definen el comportamiento de los objetos .
a) Sentencia if (si)
Es la estructura condicional más simple. Ejecuta un bloque de código solo si la condición es verdadera.
Sintaxis:
if (condición) {
// código a ejecutar
}
La figura 1 muestra el flujo de la sentencia de control condicional if
Figura 1
Sentencia condicional if (si)
Nota. Autor: Héctor Avalos Silva Ejemplo (Sistema de acceso)
public class AccesoSimple {
public void verificarUsuario(String usuario) {
if (usuario.equals("admin")) {
System.out.println("Usuario válido");
}
}
}
Análisis:
- Solo actúa si se cumple la condición.
- No hay alternativa si falla.
- Útil para validaciones básicas.
En ciberseguridad sirve para verificaciones rápidas, pero por sí sola es insuficiente.
b) Sentencia if-else
Permite definir dos caminos, uno si la condición es verdadera y otro si es falsa.
Sintaxis:
if (condición) {
// verdadero
} else {
// falso
}
El flujo de la sentencia de control if-else se muestra en la figura 2.
Figura 2
Sentencia de control condicional if-else
Nota. Autor: Héctor Avalos Silva Ejemplo (Autenticación)
public class Autenticacion {
public void login(String usuario, String clave) {
if (usuario.equals("admin") && clave.equals("1234")) {
System.out.println("Acceso concedido");
} else {
System.out.println("Acceso denegado");
}
}
}
Análisis:
- Define claramente acceso permitido o rechazado.
- Es la base de cualquier sistema de autenticación.
Este tipo de control es esencial para implementar reglas de negocio seguras .
c) Sentencia if-else if-else
Permite evaluar múltiples condiciones en secuencia. Solo se ejecuta el primer bloque cuya condición sea verdadera.
Sintaxis:
if (condición1) {
// código
} else if (condición2) {
// código
} else {
// código por defecto
}
Ejemplo (Niveles de acceso)
public class ControlRoles {
public void verificarRol(String rol) {
if (rol.equals("ADMIN")) {
System.out.println("Acceso total al sistema");
} else if (rol.equals("USER")) {
System.out.println("Acceso limitado");
} else if (rol.equals("GUEST")) {
System.out.println("Acceso restringido");
} else {
System.out.println("Rol no válido");
}
}
}
Análisis:
- Evalúa múltiples escenarios.
- Muy útil en sistemas con jerarquías de permisos.
- Evita múltiples if independientes (mejor rendimiento y claridad).
Estructuras claras y organizadas mejoran la legibilidad y mantenibilidad del código .
d) Sentencia switch
Se utiliza cuando se evalúa una misma variable contra múltiples valores posibles. Es más limpia que múltiples if-else en ciertos casos.
Sintaxis:
switch (variable) {
case valor1:
// código
break;
case valor2:
// código
break;
default:
// código por defecto
}
La figura 3 muestra el flujo de ejecución que puede seguir una sentencia de control switch.
Figura 3
Sentencia de control condicional múltiple switch
Nota. Autor: Héctor Avalos Silva Ejemplo (Estados de acceso)
public class EstadoAcceso {
public void evaluarEstado(int estado) {
switch (estado) {
case 1:
System.out.println("Acceso concedido");
break;
case 2:
System.out.println("Acceso denegado");
break;
case 3:
System.out.println("Cuenta bloqueada");
break;
default:
System.out.println("Estado desconocido");
}
}
}
Análisis:
- Más ordenado cuando hay múltiples valores posibles.
- Reduce complejidad visual.
- Evita errores en cadenas largas de condiciones.
En ciberseguridad switch es útil para manejar estados del sistema (activo, bloqueado, suspendido, etc.).
Tabla 1
Tabla comparativa de estructuras de control
Estructura
Uso principal
Ventaja clave
if
Validación simple
Simplicidad
if-else
Decisión binaria
Claridad
if-else if-else
Múltiples condiciones
Flexibilidad
Switch
Evaluar una variable
Orden y limpieza
Nota. Autor: Héctor Avalos Silva 11.2 BUCLES
Los bucles permiten repetir un bloque de código mientras se cumpla una condición. En ciberseguridad, son útiles para monitorear sistemas, validar múltiples intentos de acceso o procesar registros de auditoría.
El uso adecuado de estructuras iterativas mejora la eficiencia y el control en aplicaciones orientadas a objetos .
a) Bucle while (mientras)
Ejecuta un bloque de código mientras una condición sea verdadera. Si la condición es falsa desde el inicio, no se ejecuta nunca.
Sintaxis:
while (condicion) {
// código
}
El flujo de ejecución de la sentencia while se muestra en la figura 4
Figura 4
Sentencia de control while
Nota. Autor: Héctor Avalos Silva Ejemplo (Control de intentos de acceso)
public class AccesoSeguro {
public void login() {
int intentos = 0;
while (intentos < 3) {
System.out.println("Intento #" + (intentos + 1));
intentos++;
}
System.out.println("Cuenta bloqueada");
}
}
Análisis:
- Controla repetición basada en condición.
- Ideal cuando no se sabe exactamente cuántas veces se repetirá.
- Muy usado en validaciones de seguridad.
Si la condición nunca cambia el bucle es infinito.
b) Bucle do-while (hacer – mientras)
Ejecuta el bloque al menos una vez, y luego evalúa la condición.
Sintaxis:
do {
// código
} while (condicion);
La figura 5 muestra el flujo de ejecución de la sentencia while.
Figur 5a
Sentencia de control do-while
Nota. Autor: Héctor Avalos Silva Ejemplo (Ingreso de credenciales)
import java.util.Scanner;
public class Login {
public void autenticar() {
Scanner sc = new Scanner(System.in);
String clave;
do {
System.out.print("Ingrese clave: ");
clave = sc.nextLine();
} while (!clave.equals("1234"));
System.out.println("Acceso concedido");
sc.close();
}
}
Análisis:
Garantiza al menos una ejecución.
Útil para entradas de usuario.
Muy común en interfaces de autenticación.
c) Bucle for
Se utiliza cuando se conoce el número de iteraciones. Integra inicialización, condición y actualización en una sola línea.
Sintaxis:
for (inicializacion; condicion; actualizacion) {
// código
}
La figura 6 muestra la estructura básica de la sentencia for.
Figura 6
Sentencia de control repetitiva for
Nota. Autor: Héctor Avalos Silva Ejemplo (Auditoría de intentos)
public class Auditoria {
public void revisarIntentos() {
for (int i = 1; i <= 5; i++) {
System.out.println("Revisando intento #" + i);
}
}
}
Análisis:
- Más compacto y organizado.
- Ideal para conteos definidos.
- Muy usado en análisis de logs.
El uso adecuado del for mejora la claridad y control del flujo en aplicaciones Java .
d) Bucle for-each (enhanced for)
Diseñado para recorrer colecciones o arreglos sin necesidad de índices.
Sintaxis:
for (Tipo variable : coleccion) {
// código
}
Ejemplo (Procesamiento de registros de seguridad)
public class Monitor {
public void mostrarEventos(String[] eventos) {
for (String evento : eventos) {
System.out.println("Evento: " + evento);
}
}
}
Análisis:
- Simplifica la iteración.
- Reduce errores (no hay índices).
- Ideal para listas de eventos o usuarios.
Este tipo de estructura mejora la legibilidad y reduce errores comunes en iteraciones .
Se muestra en la tabla 2 una comparativa entre las sentencias de control repetitivas.
Tabla 2
Tabla comparativa de sentencias de control repetitivas
Estructura
Característica clave
Uso típico
while
Condición al inicio
Validaciones dinámicas
do-while
Ejecuta al menos una vez
Entrada de datos
for
Iteraciones definidas
Contadores, auditorías
for-each
Recorre colecciones
Procesamiento de datos
Nota. Autor: Héctor Avalos Silva Errores comunes y peligros reales en ciberseguridad:
- Bucles infinitos pueden colgar el sistema
- No validar condiciones provoca vulnerabilidades
- Iteraciones excesivas es similar a ataques de denegación de servicio (DoS)
- Mala gestión de intentos facilita ataques de fuerza bruta
Las estructuras repetitivas son el motor de los procesos automatizados en software. En ciberseguridad, su uso correcto permite controlar accesos, detectar patrones y responder a amenazas.
Un sistema seguro:
- Usa while para controlar intentos
- Usa do-while para interacción con el usuario
- Usa for para auditoría
- Usa for-each para monitoreo de eventos
Sin control sobre la repetición, no hay control sobre el sistema.
Las estructuras de control son fundamentales para implementar lógica de seguridad, ya que permiten tomar decisiones y repetir procesos como autenticación y auditoría. En sistemas de acceso seguro, su correcto uso garantiza robustez y refuerza principios de encapsulamiento y control de estado en la programación orientada a objetos .
Para mejorar el conocimiento sobre el tema de estructuras de control, accede al siguiente video:
Aprende más
Video que ilustra el flujo de ejecución de sentencias de control dentro de un programa. ¡Accede aquí!
12. Modularidad
La modularidad consiste en dividir el sistema en partes independientes con responsabilidades específicas, lo que en ciberseguridad permite aislar fallos, reducir vulnerabilidades y facilitar auditorías. Además, mejora la organización, reutilización y escalabilidad del software .
En un sistema de acceso seguro, la modularidad permite separar claramente componentes como:
- Autenticación
- Control de intentos
- Auditoría
- Gestión de usuarios
12.1 SEPARACIÓN DE RESPONSABILIDADES
La separación de responsabilidades (principio SRP - Single Responsibility Principle) establece que cada clase debe tener una única razón para cambiar. En sistemas de seguridad, esto evita errores críticos y reduce la superficie de ataque.
Las responsabilidades permiten mejorar la claridad lógica del sistema .
Ejemplo: Diseño incorrecto (sin separación)
public class SistemaAcceso {
public void login(String usuario, String clave) {
if (usuario.equals("admin") && clave.equals("1234")) {
System.out.println("Acceso concedido");
} else {
System.out.println("Acceso denegado");
}
// Control de intentos mezclado
// Auditoría mezclada
}
}
Problemas:
- Una sola clase hace todo.
- Difícil de mantener y escalar.
- Riesgo alto de errores de seguridad.
Ejemplo: Diseño modular con separación de responsabilidades
public class Autenticador {
public boolean autenticar(String usuario, String clave) {
return usuario.equals("admin") && clave.equals("1234");
}
}
public class ControlAcceso {
private int intentos = 0;
private final int MAX_INTENTOS = 3;
public boolean permitirAcceso(boolean autenticado) {
if (autenticado) {
intentos = 0;
return true;
} else {
intentos++;
return intentos < MAX_INTENTOS;
}
}
}
public class Auditoria {
public void registrarEvento(String mensaje) {
System.out.println("LOG: " + mensaje);
}
}
public class SistemaPrincipal {
public static void main(String[] args) {
Autenticador auth = new Autenticador();
ControlAcceso control = new ControlAcceso();
Auditoria log = new Auditoria();
boolean autenticado = auth.autenticar("admin", "1234");
if (control.permitirAcceso(autenticado)) {
log.registrarEvento("Acceso concedido");
} else {
log.registrarEvento("Acceso denegado o bloqueado");
}
}
}
Análisis:
- Cada clase tiene una única responsabilidad.
- El sistema es más claro, escalable y seguro.
- Permite aplicar pruebas unitarias por separado.
Este enfoque coincide con las buenas prácticas de diseño orientado a objetos descritas por Hernández Bejarano y Baquero Rey (2023) y con la importancia de la cohesión y bajo acoplamiento .
12.2 MANTENIBILIDAD DEL SOFTWARE
La es la capacidad de modificar un sistema de forma eficiente y segura, siendo crucial en sistemas de acceso, ya que permite adaptarse a nuevas amenazas sin generar vulnerabilidades, apoyándose en un buen diseño orientado a objetos .
a) Tipos de mantenimiento del software en sistemas de acceso
La mantenibilidad se expresa mediante cuatro tipos de mantenimiento: correctivo, adaptativo, perfectivo y preventivo, los cuales permiten corregir errores, adaptarse a cambios, mejorar el sistema y prevenir fallos. En sistemas de autenticación, estos procesos son esenciales para garantizar su continuidad y seguridad .
b) Principios de mantenibilidad aplicados a sistemas de accesos seguros
Para asegurar la mantenibilidad, se deben aplicar principios como evitar valores hardcodeados, centralizar configuraciones, eliminar duplicación de código y aplicar encapsulamiento. La centralización de parámetros de seguridad permite modificar políticas sin afectar la lógica del sistema:
// Clase que centraliza configuraciones de seguridad
public class SeguridadConfig {
// Número máximo de intentos permitidos antes de bloquear la cuenta
public static final int MAX_INTENTOS = 3;
}
Asimismo, la lógica de autenticación debe concentrarse en un único componente para evitar inconsistencias y facilitar cambios:
// Servicio encargado de la autenticación de usuarios
public class AutenticacionService {
private UsuarioRepository repository;
public AutenticacionService(UsuarioRepository repository) {
this.repository = repository;
}
public boolean login(String usuario, String clave) {
Usuario user = repository.buscarPorNombre(usuario);
if (user == null) {
return false;
}
if (user.getIntentosFallidos() >= SeguridadConfig.MAX_INTENTOS) {
System.out.println("Cuenta bloqueada por seguridad");
return false;
}
if (user.validarClave(clave)) {
user.resetIntentos();
return true;
} else {
user.incrementarIntentos();
return false;
}
}
}
El encapsulamiento protege los datos sensibles y permite modificar mecanismos de seguridad sin afectar otras partes del sistema:
// Clase que representa al usuario del sistema
public class Usuario {
private String nombre;
private String claveHash;
private int intentosFallidos;
public Usuario(String nombre, String claveHash) {
this.nombre = nombre;
this.claveHash = claveHash;
this.intentosFallidos = 0;
}
public boolean validarClave(String claveIngresada) {
String hashIngresado = HashUtil.hash(claveIngresada);
return this.claveHash.equals(hashIngresado);
}
public void incrementarIntentos() {
intentosFallidos++;
}
public void resetIntentos() {
intentosFallidos = 0;
}
public int getIntentosFallidos() {
return intentosFallidos;
}
}
Estas prácticas favorecen la reutilización, coherencia y control del sistema, alineándose con principios del desarrollo orientado a objetos .
c) Relación entre mantenibilidad y ciberseguridad
La mantenibilidad es clave en la ciberseguridad porque permite corregir vulnerabilidades y adaptar el sistema sin introducir errores. Un buen diseño reduce fallos y facilita la implementación de nuevas medidas de seguridad, asegurando sistemas de acceso más robustos, confiables y sostenibles .
La modularidad no es solo una buena práctica: en ciberseguridad es una necesidad. Separar responsabilidades permite construir sistemas más seguros, comprensibles y resistentes a fallos. Por otro lado, la mantenibilidad garantiza que el sistema pueda adaptarse a nuevas amenazas sin colapsar.
Un sistema de acceso seguro mal diseñado es una vulnerabilidad en sí mismo. Uno bien estructurado es una defensa activa.
El contenido del siguiente enlace refuerza tus conocimientos sobre mantenibilidad del software:
Aprende más
El documento presenta algunos desafíos del proceso de mantenimiento, métricas asociadas a la mantenibilidad de los productos y algunas recomendaciones para conseguir su correcta especificación ¡Accede aquí!
Profundiza más
El recurso explica el uso de estructuras de control en sistemas de autenticación seguros, destacando su papel en decisiones críticas como validación de accesos y control de intentos. Además, muestra mediante un caso práctico cómo una mala implementación puede generar vulnerabilidades, mientras que un buen diseño fortalece la seguridad del sistema. ¡Accede aquí!
Profundiza más
Este recurso analiza un sistema de autenticación bancaria con problemas de diseño que afectan la mantenibilidad y la seguridad. Luego presenta una solución modular basada en programación orientada a objetos, destacando cómo la separación de responsabilidades permite mejorar la seguridad, facilitar cambios y garantizar la evolución del sistema. ¡Accede aquí!