Autor: ciberkaos

  • 2.1.1 – Cifrado Simétrico con Clave Compartida

    2.1.1 – Cifrado Simétrico con Clave Compartida

    Qué es el Cifrado Simétrico

    El cifrado simétrico utiliza una única clave secreta para dos operaciones:

    • Cifrar (convertir texto legible en ilegible)
    • Descifrar (recuperar el texto original)

    Si dos personas comparten la misma clave, ambas pueden leer el mensaje.
    Si un atacante consigue la clave, el cifrado deja de proteger.

    Conceptos esenciales:

    • Texto plano: información legible.
    • Texto cifrado: datos transformados matemáticamente.
    • Clave: secreto que controla la transformación.
    • Algoritmo: función matemática que aplica el cifrado.

    El cifrado simétrico es muy rápido, por eso se usa en:

    • HTTPS / TLS (Internet)
    • Discos cifrados (BitLocker, LUKS)
    • VPN
    • Bases de datos
    • WiFi WPA2/WPA3

    El problema central no es el algoritmo.
    El problema siempre es: cómo compartes la clave sin que te la roben.

    Resultado esperado

    El alumno puede explicar:

    • Qué es una clave simétrica
    • Qué ocurre si se pierde
    • Por qué el cifrado depende del secreto

    ────────────────────────────────

    Tipos de Cifrado Simétrico

    1. Cifradores de Bloque

    Trabajan sobre bloques fijos de datos (por ejemplo 128 bits).

    Ejemplos:

    • AES (estándar actual)
    • DES (obsoleto)
    • 3DES (en retirada)
    • Blowfish
    • Twofish

    2. Cifradores de Flujo

    Cifran byte a byte como un flujo continuo.

    Ejemplos:

    • RC4 (inseguro, obsoleto)
    • ChaCha20 (moderno, muy rápido)

    3. Modos de Operación (muy importante)

    Un cifrador de bloque necesita un modo:

    • ECB → inseguro (filtra patrones)
    • CBC → clásico, seguro si se usa bien
    • CFB / OFB → variantes de flujo
    • CTR → moderno
    • GCM → autenticado (integridad + cifrado)

    AES + GCM es el estándar moderno (TLS 1.3).

    ────────────────────────────────

    Preparación del Entorno

    Requisitos:

    • Linux / macOS / WSL
    • OpenSSL
    • Terminal

    Acción

    openssl version

    Si aparece una versión → listo.

    ────────────────────────────────

    Crear un Archivo en Texto Plano

    echo"Las credenciales del sistema son supersecretas." > secreto.txtcat secreto.txt

    Explicación

    Este archivo representa:

    • contraseñas
    • tokens
    • datos personales
    • secretos de API

    Ahora mismo es completamente vulnerable.

    ────────────────────────────────

    La Clave Simétrica

    Explicación ampliada

    Una clave débil rompe todo el sistema.
    Ejemplo de malas claves:

    • 123456
    • password
    • admin2026

    Buenas claves:

    • largas
    • aleatorias
    • no reutilizadas

    Generar clave fuerte

    openssl rand -base6432

    Esto genera una clave criptográficamente segura.

    ────────────────────────────────

    Cifrado con AES-256-CBC

    openssl enc -aes-256-cbc-salt-in secreto.txt -out secreto.enc

    El sistema pedirá contraseña.

    Qué significa cada parámetro

    • aes-256 → clave de 256 bits
    • cbc → modo de bloque
    • salt → evita ataques de diccionario
    • in → archivo original
    • out → archivo cifrado

    Resultado

    cat secreto.enc

    Contenido ilegible → cifrado correcto.

    ────────────────────────────────

    Qué ocurre sin la clave correcta

    openssl enc -aes-256-cbc-d-in secreto.enc

    Resultado:

    • error
    • texto corrupto

    Explicación

    El cifrado moderno no puede romperse sin la clave.
    No existe “probar hasta acertar” en tiempo humano si la clave es fuerte.

    ────────────────────────────────

    Descifrado correcto

    openssl enc -aes-256-cbc -d -in secreto.enc -out secreto_descifrado.txt
    diff secreto.txt secreto_descifrado.txt

    Sin diferencias → integridad correcta.

    ────────────────────────────────

    AES-GCM (Cifrado Autenticado)

    CBC cifra, pero no protege contra manipulación.
    GCM cifra y detecta modificaciones.

    openssl enc -aes-256-gcm-salt-in secreto.txt -out secreto_gcm.enc

    Si alguien modifica el archivo → el descifrado falla.

    Este es el modo usado en:

    • TLS 1.3
    • HTTPS moderno
    • VPN modernas

    ────────────────────────────────

    TEMA 10 — Comparación de Algoritmos

    AlgoritmoEstadoUso
    DESRotoHistórico
    3DESEn retiradaSistemas legacy
    AESEstándarUniversal
    ChaCha20ModernoTLS móvil, Wireguard
    BlowfishAntiguoPoco usado

    Mensaje clave: AES y ChaCha20 dominan el mundo real.

    ────────────────────────────────

    El Problema del Intercambio de Claves

    Para descifrar necesitas:

    1. Archivo cifrado
    2. Clave secreta

    Si envías ambos por el mismo canal → seguridad = 0

    Por eso el mundo real usa:

    • Criptografía asimétrica
    • Intercambio Diffie-Hellman
    • TLS

    El cifrado simétrico siempre vive acompañado del asimétrico.

    ────────────────────────────────

    OWASP A02: Fallos Criptográficos

    Errores comunes reales:

    • Guardar datos sin cifrar
    • Usar ECB
    • Claves en el código
    • Claves débiles
    • Reutilizar claves
    • No usar cifrado autenticado
    • No cifrar en tránsito

    El cifrado no falla por matemáticas.
    Falla por humanos.

    ────────────────────────────────

    Para probar:

    Ver algoritmos disponibles

    openssl enc -ciphers

    Ver cabecera binaria

    xxd secreto.enc | head

  • 2.1.2 – [Reto] PROTOCOLO DE SEGURIDAD DE LA FEDERACIÓN

    2.1.2 – [Reto] PROTOCOLO DE SEGURIDAD DE LA FEDERACIÓN

    Academia de la Flota Estelar — División de Seguridad Informática
    Nivel: Cadete Técnico
    Sistema: USS Horizon
    Estado de la misión: ACTIVA


    Año estelar 78241.7

    La USS Horizon ha detectado interceptaciones de comunicaciones por parte de una facción hostil. El Comando de Seguridad ordena activar cifrado simétrico de grado Federación para proteger:

    • Credenciales del sistema
    • Comunicaciones internas
    • Datos de navegación
    • Protocolos de defensa

    Tu misión como oficial técnico es implementar cifrado AES-256 y validar la seguridad del sistema.


    OBJETIVOS DE LA MISIÓN

    El cadete será capaz de:

    • Comprender el cifrado simétrico
    • Generar claves seguras
    • Cifrar información sensible
    • Verificar resistencia ante ataques
    • Usar AES correctamente
    • Entender el problema del intercambio de claves
    • Aplicar cifrado autenticado moderno (GCM)

    FASE 1 — COMPRENDER LA AMENAZA

    Informe del Comando

    Las transmisiones sin cifrar pueden ser interceptadas mediante sondas de escucha.
    Cualquier mensaje en texto plano es vulnerable.

    Conceptos clave

    • Texto plano → mensaje legible
    • Texto cifrado → mensaje ilegible
    • Clave → secreto que controla el cifrado
    • Algoritmo → transformación matemática

    El cifrado simétrico usa una única clave compartida.

    Si el enemigo obtiene la clave → seguridad comprometida.


    FASE 2 — PREPARAR EL SISTEMA

    Verificar módulo criptográfico OpenSSL.

    openssl version

    Si responde con versión → módulo activo.


    FASE 3 — CREAR MENSAJE SENSIBLE

    Simular credenciales del sistema de la nave.

    echo "Credenciales núcleo warp: acceso nivel comandante." > mensaje.txt
    cat mensaje.txt

    Observación: mensaje totalmente legible → inseguro.


    FASE 4 — GENERAR CLAVE SEGURA

    Las claves débiles destruyen la seguridad.
    La Flota exige entropía alta.

    Generar clave criptográfica:

    openssl rand -base64 32

    Guardar la clave en gestor seguro (NO en el archivo).


    FASE 5 — CIFRADO AES-256-CBC

    Activar cifrado simétrico estándar de la Federación.

    openssl enc -aes-256-cbc -salt -in mensaje.txt -out mensaje.enc

    Introducir clave cuando se solicite.

    Verificar resultado:

    cat mensaje.enc

    Resultado esperado: datos ilegibles → cifrado activo.


    FASE 6 — INTERCEPCIÓN ENEMIGA

    Simular intento de descifrado sin clave correcta.

    openssl enc -aes-256-cbc -d -in mensaje.enc

    Resultado:

    • Error de descifrado
    • Texto corrupto

    Conclusión: sin clave → imposible recuperar datos.


    FASE 7 — DESCIFRADO AUTORIZADO

    Recuperar mensaje con clave correcta.

    openssl enc -aes-256-cbc -d -in mensaje.enc -out mensaje_recuperado.txt
    diff mensaje.txt mensaje_recuperado.txt

    Resultado: archivos idénticos → integridad confirmada.


    FASE 8 — CIFRADO MODERNO (AES-GCM)

    El modo CBC cifra pero no detecta manipulación.
    El Comando exige cifrado autenticado.

    openssl enc -aes-256-gcm -salt -in mensaje.txt -out mensaje_gcm.enc

    Si el archivo es alterado → el descifrado fallará.

    Este modo protege:

    • Confidencialidad
    • Integridad
    • Autenticidad

    FASE 9 — ANÁLISIS TÉCNICO

    Tipos de cifrado simétrico

    Cifradores de bloque

    • AES (estándar Federación)
    • DES (obsoleto)
    • 3DES (retirada progresiva)

    Cifradores de flujo

    • ChaCha20 (uso en comunicaciones rápidas)
    • RC4 (inseguro, prohibido)

    Modos de operación

    • ECB → inseguro (filtra patrones)
    • CBC → clásico
    • CTR → moderno
    • GCM → cifrado autenticado (recomendado)

    FASE 10 — EL TALÓN DE AQUILES

    Para descifrar se necesitan:

    1. Archivo cifrado
    2. Clave secreta

    Problema crítico: ¿cómo compartir la clave sin ser interceptada?

    La Flota resuelve esto con:

    • Criptografía asimétrica
    • Intercambio Diffie-Hellman
    • Protocolos TLS

    El cifrado simétrico nunca viaja solo.


    FASE 11 — ERRORES CRÍTICOS (INFORME OWASP)

    Fallos detectados en sistemas comprometidos:

    • Datos sin cifrar
    • Uso de ECB
    • Claves en código fuente
    • Claves débiles
    • Reutilización de claves
    • No usar cifrado autenticado
    • Envío de claves por canales inseguros

    La criptografía no falla por matemáticas.
    Falla por mala ingeniería.


    FASE 12 — EXPERIMENTOS OPCIONALES

    Ver algoritmos disponibles:

    openssl enc -ciphers

    Inspeccionar binario cifrado:

    xxd mensaje.enc | head

    INFORME FINAL DE MISIÓN

    El cadete ha:

    • Aplicado cifrado simétrico real
    • Usado AES correctamente
    • Comprobado resistencia sin clave
    • Entendido intercambio de claves
    • Diferenciado CBC vs GCM
    • Identificado errores criptográficos reales

    La frontera entre matemática y seguridad… apenas comienza.

  • 2.1.3 – [Reto] Cifrado Asimétrico con Clave Pública y Privada

    2.1.3 – [Reto] Cifrado Asimétrico con Clave Pública y Privada

    La criptografía asimétrica es uno de esos inventos humanos que parecen ciencia ficción pero sostienen la realidad cotidiana. Cada vez que abres una web HTTPS, envías un mensaje seguro, firmas un documento digital o te conectas por SSH, estás usando matemáticas diseñadas para resolver un problema aparentemente imposible: compartir secretos sin compartir el secreto.

    En el cifrado simétrico ya viste que dos partes pueden proteger información usando una misma clave. Rápido, eficaz… pero con un punto débil crítico: ¿cómo intercambias esa clave sin que alguien la intercepte? Aquí entra la criptografía de clave pública, una idea brillante basada en funciones matemáticas fáciles de calcular pero extremadamente difíciles de invertir. Gracias a ello, cada entidad puede tener dos claves: una pública que puede compartir con el mundo y una privada que jamás debe revelar. Lo que una cifra, solo la otra puede descifrar; lo que una firma, la otra puede verificar.

    Este modelo no solo permite cifrar mensajes. Permite algo mucho más profundo: crear confianza en sistemas donde las partes no se conocen previamente. De aquí nacen las firmas digitales, los certificados, las autoridades de certificación y, en última instancia, el funcionamiento seguro de Internet mediante TLS. Sin criptografía asimétrica no existirían el comercio electrónico, la identidad digital, ni la mayoría de servicios que hoy consideramos normales.

    En este tema no solo aprenderás comandos. Comprenderás cómo se construye un canal seguro desde cero: cómo se generan identidades criptográficas, cómo se cifra para un destinatario concreto, cómo se garantiza que un mensaje no ha sido alterado, y cómo una infraestructura de certificados permite confiar en claves públicas desconocidas. Es el paso donde la seguridad deja de ser “ocultar datos” y se convierte en demostrar identidad, integridad y autenticidad en un entorno hostil.

    Limitación del cifrado simétrico:

    • Necesita compartir clave secreta
    • Si se intercepta → seguridad rota

    Problema fundamental:

    ¿Cómo compartir un secreto sin compartirlo?

    Solución matemática:
    Criptografía de clave pública

    Cada usuario posee:

    • Clave pública → se puede compartir
    • Clave privada → nunca se revela

    Lo cifrado con una solo puede descifrarse con la otra.

    Resultado esperado:
    El alumno comprende la diferencia simétrico vs asimétrico.


    Conceptos Fundamentales

    Conceptos clave:

    • Par de claves (Key Pair)
    • Clave pública
    • Clave privada
    • Cifrado
    • Descifrado
    • Firma digital
    • Verificación
    • No repudio
    • Confianza
    • Certificados

    Idea central:
    La clave pública cifra o verifica
    La clave privada descifra o firma


    Fundamento Matemático (Nivel Conceptual)

    La criptografía asimétrica usa funciones:

    • Fáciles de calcular
    • Extremadamente difíciles de invertir

    Ejemplo conceptual:

    Multiplicar primos grandes → fácil
    Factorizar resultado → extremadamente difícil

    Este principio sostiene:

    • RSA
    • Diffie-Hellman
    • ECC

    Algoritmos Asimétricos Principales

    RSA

    Basado en factorización de números grandes.
    Usado para:

    • Cifrado
    • Firma digital
    • TLS clásico

    Diffie-Hellman

    Permite generar una clave compartida sin enviarla.
    Base del intercambio seguro.

    ECC (Elliptic Curve Cryptography)

    Versión moderna y eficiente.
    Usada en:

    • TLS moderno
    • Blockchain
    • SSH moderno
    • Certificados

    Resultado esperado:
    El alumno distingue funciones de cada algoritmo.


    Generación de Claves (Práctica)

    Objetivo: crear identidad criptográfica.

    Ejemplo:

    openssl genrsa -out privada.pem 2048
    openssl rsa -in privada.pem -pubout -out publica.pem

    Conceptos enseñados:

    • Tamaño de clave
    • Seguridad vs rendimiento
    • Protección de clave privada

    Cifrado con Clave Pública

    Escenario:

    Alice quiere enviar mensaje seguro a Bob.

    Proceso:

    1. Bob genera claves
    2. Bob comparte clave pública
    3. Alice cifra con clave pública de Bob
    4. Solo Bob puede descifrar

    Concepto:
    Cualquiera puede cifrar, solo el dueño puede leer


    Firma Digital

    Proceso:

    1. Emisor firma con su clave privada
    2. Receptor verifica con clave pública

    Garantiza:

    • Autoría
    • Integridad
    • No repudio

    Uso real:

    • Software firmado
    • Certificados
    • Emails seguros
    • Blockchain
    • Documentos legales

    Intercambio de Claves Seguro (Diffie-Hellman)

    El mayor avance criptográfico.

    Permite:

    • Generar clave simétrica
    • Sin transmitirla
    • Incluso con atacante escuchando

    Esto es lo que hace TLS.

    Concepto clave:
    El asimétrico no cifra grandes datos, crea la clave simétrica.


    Criptografía Híbrida (Cómo funciona TLS)

    En el mundo real:

    1. Asimétrico → intercambia clave
    2. Simétrico → cifra datos (rápido)

    Esto es:

    • HTTPS
    • VPN
    • SSH
    • TLS
    • Internet seguro

    Certificados Digitales

    Problema:

    ¿Cómo sé que una clave pública es auténtica?

    Solución:

    Autoridades de Certificación (CA)

    Un certificado vincula:

    • Identidad
    • Clave pública
    • Firma de una CA

    Conceptos:

    • X.509
    • Cadena de confianza
    • Root CA
    • Certificado autofirmado
    • Validación

    Ataques contra Criptografía Asimétrica

    • Robo de clave privada
    • MITM
    • Certificados falsos
    • Claves débiles
    • Mala implementación
    • RNG débil
    • Padding attacks (conceptual)

    Mensaje:
    La criptografía no falla por matemáticas → falla por humanos.


    OWASP y Criptografía

    Relación directa con:

    OWASP A02 — Cryptographic Failures

    Errores reales:

    • Claves expuestas
    • Sin validación de certificados
    • Uso de RSA débil
    • Sin forward secrecy
    • Mala generación de claves

    Recomendaciones

    • Generar par de claves
    • Cifrar mensaje con clave pública
    • Firmar archivo
    • Verificar firma
    • Crear certificado autofirmado
    • Simular TLS
    • MITM conceptual
    • Ver handshake TLS con Wireshark

    Conexión con el Mundo Real

    Esto protege:

    • HTTPS
    • SSH
    • VPN
    • Git firmado
    • Docker firmado
    • Identidad digital
    • Blockchain
    • Infraestructura crítica

    Sin criptografía asimétrica → Internet no existiría.


    Comparativa — Clave Simétrica vs Clave Asimétrica

    PropiedadCriptografía SimétricaCriptografía Asimétrica
    Nº de clavesUna sola clave secreta compartidaDos claves: pública y privada
    Distribución de clavesProblema crítico (debe compartirse en secreto)La pública se puede compartir libremente
    VelocidadMuy rápida (apta para grandes volúmenes de datos)Mucho más lenta
    Uso principalCifrado de datosIntercambio de claves, firma digital, autenticación
    Seguridad depende deMantener la clave secretaProteger la clave privada
    Tamaño de clave típico128 / 192 / 256 bits (AES)2048+ bits RSA / 256 bits ECC
    Cifrado de grandes datosExcelenteIneficiente
    Integridad / autenticidadNecesita mecanismos extra (HMAC, GCM)Incluido mediante firma digital
    No repudioNoSí (firma digital)
    Complejidad matemáticaModeradaAlta
    Resistencia si interceptan el mensajeSegura si no tienen la claveSegura si no tienen la privada
    Ejemplos de algoritmosAES, ChaCha20, BlowfishRSA, ECC, Diffie-Hellman
    Uso en el mundo realDiscos cifrados, VPN, WiFi, bases de datosTLS, certificados, firmas, SSH
    Papel en TLS/HTTPSCifra el tráficoIntercambia la clave simétrica
    Escalabilidad (muchos usuarios)Mala (cada pareja necesita clave distinta)Buena (cada usuario tiene su par de claves)
    Si roban la clavePueden leer todoSolo compromete esa identidad
    Caso de uso idealProteger datos rápidamenteEstablecer confianza entre desconocidos

    TLS = combinación de ambas (criptografía híbrida)

    Simétrica = rapidez para proteger datos

    Asimétrica = confianza e identidad


    MISIÓN DE LA FLOTA ESTELAR

    CANAL SEGURO — CRIPTOGRAFÍA ASIMÉTRICA + FIRMA + CERTIFICADOS (OpenSSL)

    Unidad: USS Horizon — División de Comunicaciones Seguras
    Nivel: Cadete Técnico
    Objetivo general: establecer un canal de comunicación confiable usando clave pública/privada, firma digital, y certificado.



    PARTE 1 — “IDENTIDAD CRIPTOGRÁFICA” (Par de claves)

    FASE 1 — Crear carpeta de misión

    mkdir-p mision_canal_seguro && cd mision_canal_seguro

    FASE 2 — Generar clave privada del oficial Bob (2048 bits)

    Narrativa: Bob es el oficial de comunicaciones. Su clave privada es el “código genético” de su identidad.

    openssl genrsa -out bob_privada.pem 2048

    Comprobación rápida (sin mostrarla entera):

    openssl rsa -in bob_privada.pem -check-noout

    FASE 3 — Obtener la clave pública de Bob

    Narrativa: esta es la clave que Bob puede compartir con toda la Flota.

    openssl rsa -in bob_privada.pem -pubout-out bob_publica.pem

    Verla en modo humano:

    openssl rsa -pubin-in bob_publica.pem -text-noout

    ✅ Resultado esperado: los alumnos ven que la pública se puede inspeccionar sin revelar la privada.


    PARTE 2 — “CIFRADO CON CLAVE PÚBLICA” (Confidencialidad)

    FASE 4 — Crear mensaje secreto de Alice

    echo "Coordenadas del punto de encuentro: Sector 7G. Acceso nivel Alfa." > mensaje_alice.txt
    cat mensaje_alice.txt

    FASE 5 — Cifrar para Bob usando su clave pública

    IMPORTANTE (realidad): RSA no se usa para cifrar grandes datos. Aquí lo usamos con un mensaje pequeño para entender el concepto.

    openssl pkeyutl -encrypt -pubin -inkey bob_publica.pem -in mensaje_alice.txt -out mensaje_para_bob.bin

    Ver que es ilegible:

    xxd mensaje_para_bob.bin | head

    ✅ Resultado: datos binarios “ruido”.

    FASE 6 — Descifrar con la clave privada de Bob

    openssl pkeyutl -decrypt -inkey bob_privada.pem -in mensaje_para_bob.bin -out mensaje_descifrado.txt
    cat mensaje_descifrado.txt

    ✅ Resultado esperado: el texto original vuelve intacto.

    Aprendizaje clave:

    • Cualquiera con la pública puede cifrar para Bob
    • Solo Bob con la privada puede leerlo

    PARTE 3 — “FIRMA DIGITAL” (Integridad + Autoría)

    Ahora el enemigo puede intentar modificar mensajes. La Flota exige que cada mensaje vaya firmado.

    FASE 7 — Alice firma un mensaje

    Primero Alice genera sus claves (identidad propia):

    openssl genrsa -out alice_privada.pem 2048
    openssl rsa -in alice_privada.pem -pubout -out alice_publica.pem

    Mensaje oficial:

    openssl dgst -sha256 -sign alice_privada.pem -out orden.firma orden.txt

    FASE 8 — Crear el hash y firmarlo (firma con clave privada)

    openssl dgst -sha256-sign alice_privada.pem -out orden.firma orden.txt

    ✅ “orden.firma” es la firma digital.

    FASE 9 — Verificar la firma con la clave pública

    openssl dgst -sha256-verify alice_publica.pem -signature orden.firma orden.txt

    ✅ Resultado esperado: Verified OK

    FASE 10 — Simular sabotaje (modificación del mensaje)

    echo "Orden de misión: desactivar escudos y abrir bahía de carga." > orden.txt
    openssl dgst -sha256 -verify alice_publica.pem -signature orden.firma orden.txt

    ✅ Resultado esperado: Verification failure

    Aprendizaje clave:

    • La firma no cifra (no oculta).
    • La firma garantiza que el mensaje no fue modificado y que viene de quien dice venir.

    PARTE 4 — “CERTIFICADOS” (Confianza en la clave pública)

    Aquí está la pregunta mortal:
    ¿cómo sabe Bob que la clave pública de Alice es realmente de Alice y no del enemigo?

    Respuesta: certificados.

    Vamos a simular una mini-PKI de la Flota (una CA).


    FASE 11 — Crear la CA de la Flota Estelar

    CA = Autoridad de Certificación (el “notario” criptográfico).

    Clave privada de la CA:

    openssl genrsa -out starfleet_ca_privada.pem 4096

    Certificado autofirmado de la CA (válido 365 días):

    openssl req -x509 -new -key starfleet_ca_privada.pem -sha256 -days 365 -out starfleet_ca.crt \
    -subj "/C=ES/O=Starfleet Academy/OU=Security Division/CN=Starfleet Root CA"

    Ver certificado:

    openssl x509 -in starfleet_ca.crt -text-noout | head -n40

    FASE 12 — Alice solicita un certificado (CSR)

    CSR = Certificate Signing Request (petición de certificado).

    openssl req -x509 -new -key starfleet_ca_privada.pem -sha256 -days 365 -out starfleet_ca.crt \
    -subj "/C=ES/O=Starfleet Academy/OU=Security Division/CN=Starfleet Root CA"

    FASE 13 — La CA firma el certificado de Alice

    openssl x509 -req -in alice.csr -CA starfleet_ca.crt -CAkey starfleet_ca_privada.pem \
    -CAcreateserial -out alice_cert.crt -days 365 -sha256

    Ver contenido:

    openssl x509 -in alice_cert.crt -text-noout | head -n60

    FASE 14 — Verificar que el certificado de Alice “cuelga” de la CA

    openssl verify -CAfile starfleet_ca.crt alice_cert.crt

    ✅ Resultado esperado: alice_cert.crt: OK

    Aprendizaje clave:

    • Ahora Bob no confía “porque sí” en la clave pública de Alice.
    • Confía porque la CA de la Flota la certifica.

    PARTE 5 — “HÍBRIDO” (Cómo funciona Internet de verdad)

    Verdad del universo:
    El asimétrico es lento para datos grandes.
    Se usa para intercambiar/validar una clave simétrica, y luego se cifra todo con AES/ChaCha20.

    Mini-demostración conceptual (sin meternos aún en DH real)

    1. Alice y Bob se validan con certificados (asimétrico)
    2. Se acuerda una clave de sesión (simétrica)
    3. Todo el tráfico va con AES-GCM / ChaCha20-Poly1305

    Eso es TLS.


    INFORME FINAL (lo que tienes que entregar)

    1. Capturas o salida de:
    • creación de claves
    • cifrado/descifrado RSA
    • firma y verificación (OK)
    • verificación fallida tras manipulación
    • creación de CA
    • emisión del certificado de Alice
    • verificación openssl verify
    1. Explicación breve:
    • diferencia cifrado vs firma
    • por qué se necesitan certificados
    • por qué TLS es híbrido

    OPCIONALES (Modo “Cadete con rango”)

    A) Ver handshake TLS real con Wireshark (si tienes tiempo)

    • abrir un sitio HTTPS
    • filtrar tls y ver certificados, cipher suite, etc.

    B) Pasar a ECC

    • generar claves con curvas elípticas y comparar tamaños

    C) Forward secrecy (conceptual)

    • por qué DH/ECDHE evita que roben sesiones antiguas si se filtra una clave

    Registro del Capitán:

    “Cadete, hoy no solo has cifrado un mensaje. Has creado confianza en un universo hostil.
    La seguridad no es ocultar información: es demostrar identidad, detectar manipulación y sobrevivir a la interceptación.”

  • [Reto] – Aletheia un Sistema de Auditoría y Análisis Forense Automatizado

    [Reto] – Aletheia un Sistema de Auditoría y Análisis Forense Automatizado

    El término aletheia proviene del griego antiguo αλήθεια y significa «verdad», pero con un matiz profundo que va más allá de una simple correspondencia con la realidad; se refiere al «desocultamiento del ser» o al proceso de hacer evidente lo que estaba oculto.

    En entornos profesionales de administración de sistemas, auditoría y ciberseguridad, el análisis de evidencias no se realiza en el equipo personal del analista.
    Los datos —logs, resultados de auditoría, informes técnicos o documentación sensible— se envían a servidores dedicados, diseñados para procesar información de forma controlada, trazable y reproducible.

    El proyecto Aletheia plantea la construcción de uno de estos servidores.

    Aletheia es una máquina independiente dentro de la red cuya función no es almacenar información ni ofrecer servicios al usuario final, sino transformar evidencias técnicas en conocimiento estructurado.
    Para ello, integra un motor de inteligencia artificial local, accesible únicamente desde el propio servidor, que actúa como sistema de análisis y apoyo a la toma de decisiones.

    A diferencia de soluciones basadas en la nube, este servidor:

    • no envía información a terceros,
    • no depende de conectividad externa,
    • y permite mantener control total sobre los datos analizados.

    Durante el desarrollo del proyecto, el alumnado diseñará y desplegará un servicio capaz de:

    • recibir archivos y evidencias técnicas,
    • procesarlos de forma segura y estática,
    • analizarlos desde una perspectiva de auditoría o forense,
    • y generar informes claros, coherentes y reutilizables.

    El objetivo no es “usar IA”, sino integrarla como parte de una arquitectura real de sistemas, entendiendo su papel como herramienta de análisis, no como sustituto del criterio técnico.

    Este proyecto reproduce un escenario habitual en organizaciones reales, donde la inteligencia no reside en el usuario final, sino en la infraestructura que da soporte al análisis.

    Fase 1 — Puesta a punto del servidor

    Requisitos mínimos de la VM

    1. Crea una VM en VirtualBox:
      • Ubuntu Server 22.04/24.04 (64-bit)
      • 4 vCPU
      • 8 GB RAM
      • 40 GB disco
      • Red: Adaptador puente

    Instala Ubuntu Server y crea un usuario (no root), por ejemplo: alumno.


    1) Actualiza el sistema

    sudo apt update && sudo apt -y upgrade
    sudo reboot
    

    2) Instala herramientas base

    Instalar utilidades básicas:

    • curl
    • unzip
    • jq
    • python3
    sudo apt -y install curl unzip jq ca-certificates gnupg python3 python3-venv python3-pip
    

    3) Configura hostname (opcional pero recomendado)

    sudo hostnamectl set-hostname forense-ai
    

    Comprueba:

    hostnamectl
    

    4) Comprueba IP del servidor

    ip a
    

    Fase 2 — Instalar y probar Ollama

    5) Instala Ollama

    curl -fsSL https://ollama.com/install.sh | sh
    

    6) Comprueba que el servicio está activo

    sudo systemctl status ollama --no-pager
    

    7) Descarga un modelo ligero (recomendado para VM)

    ollama pull phi3
    

    8) Prueba que responde

    ollama run phi3 "Resume en 5 líneas qué es una auditoría de sistemas."
    

    Si esto funciona, ya tienes “motor IA” listo.

    Fase 3 — Instalar Apache + PHP (interfaz web)

    9) Instala Apache y PHP

    sudo apt -y install apache2 php libapache2-mod-php
    

    10) Habilita y arranca Apache

    sudo systemctl enable --now apache2
    

    11) Abre el firewall (solo si lo estás usando)

    Si tienes UFW activo:

    sudo ufw allow 'Apache'
    sudo ufw status
    

    12) Comprueba acceso web

    Desde tu PC (host), abre:

    • http://IP_DEL_SERVIDOR/

    Debes ver la página por defecto de Apache.


    Fase 4 — Crear la estructura del servicio “Forense-AI”

    13) Crea carpetas del proyecto

    sudo mkdir -p /var/www/forense-ai/{uploads,results,scripts,logs}
    sudo chown -R www-data:www-data /var/www/forense-ai
    sudo chmod -R 750 /var/www/forense-ai
    

    14) Crea un VirtualHost

    sudo nano /etc/apache2/sites-available/forense-ai.conf
    

    Pega esto:

    <VirtualHost *:80>
        ServerName forense-ai.local
        DocumentRoot /var/www/forense-ai
    
        <Directory /var/www/forense-ai>
            Options -Indexes
            AllowOverride All
            Require all granted
        </Directory>
    
        ErrorLog ${APACHE_LOG_DIR}/forense-ai_error.log
        CustomLog ${APACHE_LOG_DIR}/forense-ai_access.log combined
    </VirtualHost>
    

    Activa el sitio:

    sudo a2ensite forense-ai
    sudo a2dissite 000-default
    sudo systemctl reload apache2
    

    Fase 5 — Servicio web: formulario de subida + análisis

    15) Instala herramientas para extraer texto de PDF

    sudo apt -y install poppler-utils
    

    (trae pdftotext)

    16) Crea el formulario web index.php

    sudo nano /var/www/forense-ai/index.php
    

    Contenido:

    <?php
    $maxSize = 8 * 1024 * 1024; // 8 MB
    $allowed = ['txt','log','pdf'];
    
    function safe_name($name) {
      $name = preg_replace('/[^a-zA-Z0-9._-]/', '_', $name);
      return $name;
    }
    
    ?>
    <!doctype html>
    <html>
    <head>
      <meta charset="utf-8">
      <title>Forense-AI</title>
      <style>
        body { font-family: Arial, sans-serif; margin: 40px; max-width: 900px; }
        .box { padding: 16px; border: 1px solid #ccc; border-radius: 8px; }
        input, textarea, select { width: 100%; padding: 8px; margin-top: 8px; }
        button { padding: 10px 14px; margin-top: 12px; }
        .small { color: #555; font-size: 0.9em; }
      </style>
    </head>
    <body>
      <h1>Forense-AI — Analizador de evidencias</h1>
      <div class="box">
        <form action="process.php" method="post" enctype="multipart/form-data">
          <label>Evidencia (TXT/LOG/PDF, máx 8 MB)</label>
          <input type="file" name="evidence" required>
    
          <label>Tipo de análisis</label>
          <select name="mode">
            <option value="audit">Auditoría (hallazgos y riesgos)</option>
            <option value="forensic">Forense (línea temporal y eventos)</option>
            <option value="summary">Resumen ejecutivo</option>
          </select>
    
          <label>Contexto (opcional)</label>
          <textarea name="context" rows="4" placeholder="Ej: Esto es un auth.log de un servidor SSH expuesto a Internet..."></textarea>
    
          <button type="submit">Subir y analizar</button>
          <p class="small">El análisis se realiza localmente en el servidor (Ollama). No se envía nada a Internet.</p>
        </form>
      </div>
    </body>
    </html>
    

    17) Crea el script de procesamiento process.php

    sudo nano /var/www/forense-ai/process.php
    

    Contenido:

    <?php
    $uploadDir = __DIR__ . "/uploads/";
    $resultDir = __DIR__ . "/results/";
    $logDir    = __DIR__ . "/logs/";
    
    $maxSize = 8 * 1024 * 1024;
    $allowed = ['txt','log','pdf'];
    
    function safe_name($name) {
      return preg_replace('/[^a-zA-Z0-9._-]/', '_', $name);
    }
    
    function ext($name) {
      $p = pathinfo($name);
      return strtolower($p['extension'] ?? '');
    }
    
    function run_cmd($cmd) {
      $output = [];
      $ret = 0;
      exec($cmd . " 2>&1", $output, $ret);
      return [$ret, implode("\n", $output)];
    }
    
    if (!isset($_FILES['evidence'])) {
      http_response_code(400);
      exit("No file uploaded");
    }
    
    $f = $_FILES['evidence'];
    if ($f['error'] !== UPLOAD_ERR_OK) {
      http_response_code(400);
      exit("Upload error");
    }
    
    if ($f['size'] > $maxSize) {
      http_response_code(400);
      exit("File too large");
    }
    
    $original = $f['name'];
    $extension = ext($original);
    
    if (!in_array($extension, $allowed, true)) {
      http_response_code(400);
      exit("Invalid extension");
    }
    
    $mode = $_POST['mode'] ?? 'audit';
    $context = trim($_POST['context'] ?? '');
    
    $base = date("Ymd_His") . "_" . safe_name($original);
    $dest = $uploadDir . $base;
    
    if (!move_uploaded_file($f['tmp_name'], $dest)) {
      http_response_code(500);
      exit("Failed to save upload");
    }
    
    // Extraer texto
    $textFile = $dest . ".txt";
    if ($extension === 'pdf') {
      // pdftotext
      [$ret, $out] = run_cmd("pdftotext " . escapeshellarg($dest) . " " . escapeshellarg($textFile));
      if ($ret !== 0) {
        http_response_code(500);
        exit("pdftotext failed:\n" . htmlspecialchars($out));
      }
    } else {
      // Copiar tal cual
      copy($dest, $textFile);
    }
    
    // Leer texto (limitamos por tamaño para no petar memoria)
    $raw = file_get_contents($textFile);
    if ($raw === false) {
      http_response_code(500);
      exit("Cannot read extracted text");
    }
    $raw = substr($raw, 0, 50000); // 50k chars (suficiente para práctica)
    
    $promptBase = "Eres un analista de ciberseguridad. Responde en español con formato claro.\n";
    if ($mode === 'audit') {
      $task = "Analiza la evidencia como auditoría. Devuelve: 1) Resumen, 2) Hallazgos (con evidencias), 3) Riesgos, 4) Recomendaciones priorizadas.";
    } elseif ($mode === 'forensic') {
      $task = "Analiza la evidencia con enfoque forense. Devuelve: 1) Resumen, 2) Línea temporal aproximada, 3) Eventos relevantes, 4) Hipótesis, 5) Próximos pasos.";
    } else {
      $task = "Resume la evidencia para un responsable no técnico. Devuelve un resumen ejecutivo y 5 puntos clave.";
    }
    
    $contextPart = $context ? "\nContexto aportado por el usuario:\n" . $context . "\n" : "";
    
    $prompt = $promptBase . $task . $contextPart . "\nEVIDENCIA (texto):\n" . $raw . "\n";
    
    // Llamar a Ollama
    $model = "phi3";
    $cmd = "ollama run " . escapeshellarg($model) . " " . escapeshellarg($prompt);
    
    [$ret, $analysis] = run_cmd($cmd);
    if ($ret !== 0) {
      http_response_code(500);
      exit("Ollama failed:\n" . htmlspecialchars($analysis));
    }
    
    $reportName = basename($dest) . "_informe.md";
    $reportPath = $resultDir . $reportName;
    
    $report = "# Informe Forense-AI\n\n"
            . "- Archivo: **" . htmlspecialchars($original) . "**\n"
            . "- Fecha: **" . date("Y-m-d H:i:s") . "**\n"
            . "- Modo: **" . htmlspecialchars($mode) . "**\n\n"
            . "---\n\n"
            . $analysis . "\n";
    
    file_put_contents($reportPath, $report);
    
    // Log básico
    file_put_contents($logDir . "activity.log",
      date("c") . " file=" . $base . " mode=" . $mode . " ip=" . ($_SERVER['REMOTE_ADDR'] ?? 'unknown') . "\n",
      FILE_APPEND
    );
    
    header("Location: result.php?f=" . urlencode($reportName));
    

    18) Crea la página de resultados result.php

    sudo nano /var/www/forense-ai/result.php
    

    Contenido:

    <?php
    $resultDir = __DIR__ . "/results/";
    $f = $_GET['f'] ?? '';
    $f = basename($f); // evita traversal
    $path = $resultDir . $f;
    
    if (!$f || !file_exists($path)) {
      http_response_code(404);
      exit("Report not found");
    }
    
    $txt = file_get_contents($path);
    ?>
    <!doctype html>
    <html>
    <head>
      <meta charset="utf-8">
      <title>Resultado — Forense-AI</title>
      <style>
        body { font-family: Arial, sans-serif; margin: 40px; max-width: 900px; }
        pre { white-space: pre-wrap; border: 1px solid #ccc; padding: 16px; border-radius: 8px; }
        a { display:inline-block; margin-top: 12px; }
      </style>
    </head>
    <body>
      <h1>Informe generado</h1>
      <a href="download.php?f=<?php echo urlencode($f); ?>">Descargar informe</a>
      <pre><?php echo htmlspecialchars($txt); ?></pre>
      <a href="index.php">⬅ Volver</a>
    </body>
    </html>
    

    19) Crea el descargador download.php

    sudo nano /var/www/forense-ai/download.php
    

    Contenido:

    <?php
    $resultDir = __DIR__ . "/results/";
    $f = $_GET['f'] ?? '';
    $f = basename($f);
    $path = $resultDir . $f;
    
    if (!$f || !file_exists($path)) {
      http_response_code(404);
      exit("Not found");
    }
    
    header('Content-Type: text/markdown; charset=utf-8');
    header('Content-Disposition: attachment; filename="' . $f . '"');
    readfile($path);
    

    Fase 6 — Permisos y seguridad mínima del servicio

    20) Permisos finales (muy importante)

    sudo chown -R www-data:www-data /var/www/forense-ai
    sudo find /var/www/forense-ai -type d -exec chmod 750 {} \;
    sudo find /var/www/forense-ai -type f -exec chmod 640 {} \;
    sudo systemctl reload apache2
    

    21) Importante: Ollama solo local

    Comprueba que Ollama no está expuesto:

    • El servicio web llama a ollama run localmente.
    • No hace falta abrir puertos de Ollama.

    Fase 7 — Pruebas obligatorias (para entregar)

    22) Caso de prueba A (Auditoría)

    1. Sube un auth.log (o un ejemplo creado por vosotros)
    2. Modo: Auditoría
    3. Debe devolver hallazgos y recomendaciones

    23) Caso de prueba B (Forense)

    1. Sube una salida de nmap guardada como TXT
    2. Modo: Forense
    3. Debe generar hipótesis y próximos pasos

    24) Caso de prueba C (PDF)

    1. Sube un PDF técnico (manual, informe)
    2. Modo: Resumen ejecutivo
    3. Debe resumir y extraer puntos clave
  • R7 [Solución] – Guerra por el Sistema Solar: Tierra, Marte y el Cinturón” (The Expanse)

    1) Nave.java

    
    
    
    
    
    /**
     * Representa una nave espacial dentro del universo de The Expanse.
     * 
     * Conceptos que se trabajan aquí:
     * - Encapsulamiento (atributos privados + getters/setters)
     * - Constructor completo
     * - toString() para imprimir bonito el objeto
     */
    public class Nave {
    
        // -------------------------
        // Atributos (siempre privados)
        // -------------------------
        private String nombre;
        private String faccion; // "Tierra", "Marte", "Cinturon"
        private int misiles;
        private boolean necesitaReparacion;
    
        // -------------------------
        // Constructores
        // -------------------------
    
        /**
         * Constructor completo exigido por el enunciado.
         */
        public Nave(String nombre, String faccion, int misiles, boolean necesitaReparacion) {
            this.nombre = nombre;
            this.faccion = faccion;
            this.misiles = misiles;
            this.necesitaReparacion = necesitaReparacion;
        }
    
        /**
         * Constructor opcional de conveniencia (por si quieres crear naves “rápido”).
         * Por ejemplo: misiles = 0 y no necesita reparación por defecto.
         */
        public Nave(String nombre, String faccion) {
            this(nombre, faccion, 0, false);
        }
    
        // -------------------------
        // Getters y Setters
        // -------------------------
        public String getNombre() {
            return nombre;
        }
    
        public void setNombre(String nombre) {
            this.nombre = nombre;
        }
    
        public String getFaccion() {
            return faccion;
        }
    
        public void setFaccion(String faccion) {
            this.faccion = faccion;
        }
    
        public int getMisiles() {
            return misiles;
        }
    
        public void setMisiles(int misiles) {
            this.misiles = misiles;
        }
    
        public boolean isNecesitaReparacion() {
            return necesitaReparacion;
        }
    
        public void setNecesitaReparacion(boolean necesitaReparacion) {
            this.necesitaReparacion = necesitaReparacion;
        }
    
        // -------------------------
        // toString() (muy útil para listar)
        // -------------------------
        @Override
        public String toString() {
            return "Nave{" +
                    "nombre='" + nombre + '\'' +
                    ", faccion='" + faccion + '\'' +
                    ", misiles=" + misiles +
                    ", necesitaReparacion=" + (necesitaReparacion ? "Sí" : "No") +
                    '}';
        }
    }
    

    2) Flota.java

    
    
    
    
    
    import java.util.ArrayList;
    import java.util.Scanner;
    
    /**
     * Flota = conjunto de naves.
     *
     * Conceptos que se trabajan:
     * - ArrayList con objetos (ArrayList<Nave>)
     * - Métodos para recorrer y filtrar
     * - Métodos con Scanner para crear objetos desde teclado
     */
    public class Flota {
    
        // Lista privada: nadie fuera debería tocarla directamente
        private ArrayList<Nave> naves;
    
        // -------------------------
        // Constructor
        // -------------------------
        public Flota() {
            // Inicializamos la lista vacía (obligatorio)
            this.naves = new ArrayList<>();
        }
    
        // -------------------------
        // Agregar nave ya creada
        // -------------------------
        public void agregarNave(Nave nave) {
            if (nave == null) {
                System.out.println("No se puede añadir una nave nula.");
                return;
            }
            naves.add(nave);
            System.out.println("✅ Nave añadida a la flota: " + nave.getNombre());
        }
    
        // -------------------------
        // Crear nave por teclado
        // -------------------------
        public void crearNaveDesdeTeclado(Scanner sc) {
            System.out.println("=== CREAR NUEVA NAVE ===");
    
            // Nombre
            System.out.print("Nombre de la nave: ");
            String nombre = sc.nextLine().trim();
    
            // Facción (validada)
            String faccion = leerFaccionValida(sc);
    
            // Misiles (entero >= 0)
            int misiles = leerEnteroNoNegativo(sc, "Número de misiles: ");
    
            // Reparación (S/N)
            boolean necesitaReparacion = leerBooleanSN(sc, "¿Necesita reparación? (S/N): ");
    
            // Creamos el objeto Nave con los datos recogidos
            Nave nave = new Nave(nombre, faccion, misiles, necesitaReparacion);
    
            // La añadimos al ArrayList
            naves.add(nave);
    
            System.out.println("✅ Nave creada y añadida: " + nave);
        }
    
        // -------------------------
        // Número de naves
        // -------------------------
        public int getNumeroNaves() {
            return naves.size();
        }
    
        // -------------------------
        // Listar todas
        // -------------------------
        public void listarTodas() {
            System.out.println("=== LISTADO COMPLETO DE NAVES ===");
    
            if (naves.isEmpty()) {
                System.out.println("La flota está vacía.");
                return;
            }
    
            for (Nave n : naves) {
                System.out.println(n); // llama a toString()
            }
        }
    
        // -------------------------
        // Listar naves para reparar
        // -------------------------
        public void listarNavesParaReparar() {
            System.out.println("=== NAVES QUE NECESITAN REPARACIÓN ===");
    
            boolean hay = false;
    
            for (Nave n : naves) {
                if (n.isNecesitaReparacion()) {
                    System.out.println(n);
                    hay = true;
                }
            }
    
            if (!hay) {
                System.out.println("No hay naves marcadas para reparación.");
            }
        }
    
        // -------------------------
        // Total de misiles
        // -------------------------
        public int getTotalMisiles() {
            int total = 0;
            for (Nave n : naves) {
                total += n.getMisiles();
            }
            return total;
        }
    
        // -------------------------
        // Listar por facción
        // -------------------------
        public void listarPorFaccion(String faccion) {
            System.out.println("=== NAVES DE LA FACCIÓN: " + faccion + " ===");
    
            boolean hay = false;
    
            for (Nave n : naves) {
                // equalsIgnoreCase = compara ignorando mayúsculas/minúsculas
                if (n.getFaccion().equalsIgnoreCase(faccion)) {
                    System.out.println(n);
                    hay = true;
                }
            }
    
            if (!hay) {
                System.out.println("No se encontraron naves de esa facción.");
            }
        }
    
        // -------------------------
        // Contar por facción
        // -------------------------
        public int contarPorFaccion(String faccion) {
            int contador = 0;
    
            for (Nave n : naves) {
                if (n.getFaccion().equalsIgnoreCase(faccion)) {
                    contador++;
                }
            }
    
            return contador;
        }
    
        // ==========================================================
        // Métodos auxiliares (para que el código quede limpio y robusto)
        // ==========================================================
    
        /**
         * Pide al usuario una facción válida: Tierra / Marte / Cinturon.
         */
        private String leerFaccionValida(Scanner sc) {
            while (true) {
                System.out.print("Facción (Tierra/Marte/Cinturon): ");
                String faccion = sc.nextLine().trim();
    
                if (esFaccionValida(faccion)) {
                    // Normalizamos para que quede bonito y consistente
                    return normalizarFaccion(faccion);
                }
    
                System.out.println("❌ Facción no válida. Usa: Tierra, Marte o Cinturon.");
            }
        }
    
        private boolean esFaccionValida(String faccion) {
            String f = faccion.trim().toLowerCase();
            return f.equals("tierra") || f.equals("marte") || f.equals("cinturon");
        }
    
        private String normalizarFaccion(String faccion) {
            String f = faccion.trim().toLowerCase();
            if (f.equals("tierra")) return "Tierra";
            if (f.equals("marte")) return "Marte";
            return "Cinturon";
        }
    
        /**
         * Lee un entero >= 0, repitiendo hasta que sea válido.
         */
        private int leerEnteroNoNegativo(Scanner sc, String mensaje) {
            while (true) {
                System.out.print(mensaje);
                String linea = sc.nextLine().trim();
    
                try {
                    int valor = Integer.parseInt(linea);
                    if (valor < 0) {
                        System.out.println("❌ No puede ser negativo.");
                    } else {
                        return valor;
                    }
                } catch (NumberFormatException e) {
                    System.out.println("❌ Introduce un número entero válido.");
                }
            }
        }
    
        /**
         * Lee una respuesta tipo S/N y la convierte a boolean.
         * S -> true, N -> false
         */
        private boolean leerBooleanSN(Scanner sc, String mensaje) {
            while (true) {
                System.out.print(mensaje);
                String resp = sc.nextLine().trim().toLowerCase();
    
                if (resp.equals("s") || resp.equals("si") || resp.equals("sí")) return true;
                if (resp.equals("n") || resp.equals("no")) return false;
    
                System.out.println("❌ Respuesta no válida. Escribe S o N.");
            }
        }
    }
    

    3) ControlFlota.java (main + menú)

    
    
    
    
    
    import java.util.Scanner;
    
    /**
     * Controlador principal.
     *
     * Conceptos que se trabajan:
     * - Menú por consola repetitivo (do-while)
     * - switch para ejecutar opciones
     * - Reutilización de Scanner y validación de enteros
     */
    public class ControlFlota {
    
        public static void main(String[] args) {
    
            Scanner sc = new Scanner(System.in);
            Flota flota = new Flota();
    
            // Naves iniciales opcionales (ambiente The Expanse)
            flota.agregarNave(new Nave("Rocinante", "Cinturon", 24, false));
            flota.agregarNave(new Nave("Donnager", "Marte", 60, true));
            flota.agregarNave(new Nave("Agatha King", "Tierra", 40, true));
    
            int opcion;
    
            do {
                mostrarMenu();
                opcion = leerEnteroSeguro(sc);
    
                switch (opcion) {
    
                    case 1:
                        // Crear nave desde teclado
                        flota.crearNaveDesdeTeclado(sc);
                        break;
    
                    case 2:
                        // Crear nave desde el main (valores fijos)
                        Nave n = new Nave("Nauvoo", "Cinturon", 80, false);
                        flota.agregarNave(n);
                        System.out.println("Nave creada desde main y añadida: " + n);
                        break;
    
                    case 3:
                        flota.listarTodas();
                        break;
    
                    case 4:
                        flota.listarNavesParaReparar();
                        break;
    
                    case 5:
                        System.out.println("Número total de naves: " + flota.getNumeroNaves());
                        break;
    
                    case 6:
                        System.out.println("Misiles totales en la flota: " + flota.getTotalMisiles());
                        break;
    
                    case 7:
                        System.out.print("Introduce la facción (Tierra/Marte/Cinturon): ");
                        String fac = sc.nextLine().trim();
                        flota.listarPorFaccion(fac);
                        break;
    
                    case 8:
                        System.out.print("Introduce la facción (Tierra/Marte/Cinturon): ");
                        String fac2 = sc.nextLine().trim();
                        int num = flota.contarPorFaccion(fac2);
                        System.out.println("Número de naves de la facción " + fac2 + ": " + num);
                        break;
    
                    case 0:
                        System.out.println("Saliendo del sistema de control de flota...");
                        break;
    
                    default:
                        System.out.println("Opción no válida.");
                }
    
                System.out.println(); // línea en blanco para separar “vueltas” del menú
    
            } while (opcion != 0);
    
            sc.close();
        }
    
        // -------------------------
        // Menú
        // -------------------------
        private static void mostrarMenu() {
            System.out.println("=== CONTROL DE FLOTA - GUERRA DEL SISTEMA SOLAR ===");
            System.out.println("1. Añadir nave (datos por teclado)");
            System.out.println("2. Añadir nave (creada en el main)");
            System.out.println("3. Listar todas las naves");
            System.out.println("4. Listar naves que necesitan reparación");
            System.out.println("5. Mostrar número total de naves");
            System.out.println("6. Mostrar número total de misiles");
            System.out.println("7. Listar naves por facción");
            System.out.println("8. Contar naves por facción");
            System.out.println("0. Salir");
            System.out.print("Elige una opción: ");
        }
    
        /**
         * Lee un entero de forma segura usando nextLine() + parseInt.
         * Ventaja: evita problemas típicos de Scanner con nextInt() y saltos de línea.
         */
        private static int leerEnteroSeguro(Scanner sc) {
            while (true) {
                try {
                    return Integer.parseInt(sc.nextLine().trim());
                } catch (NumberFormatException e) {
                    System.out.print("Introduce un número válido: ");
                }
            }
        }
    }
    

  • Etica para Ingenieros – 11 Mapa conceptual

    MAPA CONCEPTUAL — Ética para ingenieros


    🌍 INGENIERÍA

    ➜ no es solo técnica

    ➜ es una PROFESIÓN SOCIAL

    • Basada en conocimiento especializado
    • Reconocida socialmente
    • Con poder transformador
    • Fundada en la confianza pública

    ⬇️
    ➡️ Toda profesión genera responsabilidades éticas


    🧱 1. LA INGENIERÍA COMO PROFESIÓN SOCIAL (Cap. 1)

    • Actúa dentro de la sociedad
    • Produce efectos colectivos
    • No es neutral ni individual

    ➡️ El ingeniero:

    • No trabaja solo para un cliente
    • Trabaja indirectamente para la sociedad
    • Tiene responsabilidad pública

    🌐 2. TECNOLOGÍA Y SOCIEDAD (Cap. 2)

    La tecnología:

    • No es una herramienta aislada
    • Es un sistema social

    Influye en:

    • Economía
    • Política
    • Cultura
    • Formas de vida

    ❌ Mito: “la tecnología es neutral”
    ✅ Realidad: la tecnología incorpora valores

    ➡️ Diseñar tecnología = diseñar sociedad


    🧪 3. FENÓMENO TECNOCIENTÍFICO (Cap. 3)

    Tecnociencia =

    • Ciencia + Tecnología + Organización + Poder

    Características:

    • Orientada a la aplicación
    • Condicionada por intereses
    • Generadora de impactos sociales

    ❌ Ingeniero = ejecutor neutral
    ✅ Ingeniero = actor moral

    ➡️ Toda decisión técnica contiene una decisión ética


    ⚠️ 4. SOCIEDAD DEL RIESGO (Cap. 5)

    La sociedad actual:

    • Produce riesgos tecnológicos
    • Vive con incertidumbre

    Riesgos:

    • Globales
    • Complejos
    • A veces irreversibles
    • Desigualmente repartidos

    ➡️ El ingeniero:

    • No solo gestiona riesgos
    • Contribuye a crearlos

    ➡️ El riesgo es:

    • Técnico ❌
    • Ético y social ✅

    🧭 5. VIRTUD DE LA PRUDENCIA (Cap. 6)

    La prudencia NO es:

    • Miedo
    • Inmovilismo

    La prudencia ES:

    • Juicio racional
    • Reconocimiento de límites
    • Deliberación antes de actuar

    Exige:

    • Anticipar consecuencias
    • Pensar a largo plazo
    • Saber decir “no”

    ➡️ Prudencia = forma concreta de la responsabilidad


    🧠 6. DECISIÓN RACIONAL Y ÉTICA (Cap. 7)

    La ética:

    • Se concreta en decisiones

    Decisión ética:

    • No es automática
    • No es solo técnica
    • Es deliberativa

    Incluye:

    • Análisis de alternativas
    • Evaluación de consecuencias
    • Conflictos de valores
    • Justificación racional

    ➡️ No decidir = decidir
    ➡️ Toda decisión implica responsabilidad


    ⚖️ 7. PRINCIPIO DE RESPONSABILIDAD (Cap. 8)

    Responsabilidad ampliada:

    • Por acción
    • Por omisión
    • Individual y colectiva
    • Presente y futura

    El ingeniero responde ante:

    • Clientes
    • Empresas
    • Sociedad
    • Generaciones futuras

    Principio de precaución:

    • No todo lo posible es aceptable
    • La incertidumbre no exime de responsabilidad

    ➡️ A mayor poder técnico → mayor responsabilidad ética


    🏢 8. ORGANIZACIONES Y CÓDIGOS PROFESIONALES (Cap. 9)

    La ingeniería se ejerce en:

    • Empresas
    • Instituciones
    • Administraciones

    Riesgos:

    • Dilución de responsabilidad
    • Obediencia acrítica
    • Presión económica

    Códigos profesionales:

    • Expresan valores colectivos
    • Orientan la conducta
    • No sustituyen al juicio moral

    ➡️ Ética = coherencia entre:

    • Individuo
    • Profesión
    • Organización

    🎯 CONCEPTO CENTRAL DEL LIBRO

    La ingeniería construye el mundo en que vivimos,
    y por eso no puede renunciar a la responsabilidad moral sobre ese mundo.


    🧠 IDEAS CLAVE TRANSVERSALES

    • No existe neutralidad técnica
    • La ética no es un añadido, es parte de la profesión
    • La responsabilidad aumenta con el poder técnico
    • El ingeniero es agente moral
    • El riesgo es ético y social
    • La prudencia guía la acción
    • Decidir es asumir consecuencias
    • La ética sostiene la confianza social

    🧩 SÍNTESIS FINAL (MAPA EN UNA FRASE)

    Ingeniería → Tecnología → Sociedad → Riesgo → Decisión → Responsabilidad → Ética

  • Etica para Ingenieros – 10 Conclusiones finales

    📘 Ética para ingenieros — Resumen total y conclusiones

    1️⃣ Qué tipo de libro es y qué pretende

    Ética para ingenieros no es un manual de normas ni un código de conducta, sino una obra de reflexión ética profunda que busca responder a una pregunta central:

    ¿Qué significa ser ingeniero en una sociedad tecnológicamente avanzada y moralmente vulnerable?

    El libro no se limita a decir qué está bien o mal, sino que:

    • Analiza el contexto social de la ingeniería
    • Explica por qué la ética es inseparable de la técnica
    • Fundamenta la responsabilidad moral del ingeniero
    • Ofrece criterios para decidir éticamente en situaciones reales

    Su objetivo final es formar ingenieros responsables, no solo técnicamente competentes.


    2️⃣ Idea central que recorre todo el libro

    La ingeniería es una profesión social con un enorme poder transformador, y ese poder exige una responsabilidad ética proporcional.

    No existe:

    • Ingeniería neutral
    • Técnica sin valores
    • Decisión puramente técnica

    Cada decisión de ingeniería:

    • Incorpora valores
    • Produce consecuencias sociales
    • Afecta a personas presentes y futuras

    3️⃣ Grandes ejes conceptuales del libro

    El libro se articula alrededor de cinco grandes ejes éticos, que se van construyendo progresivamente.


    🧱 1. La ingeniería como profesión social

    La ingeniería:

    • No es solo una actividad técnica
    • Es una profesión socialmente reconocida
    • Basada en la confianza pública

    Esto implica que el ingeniero:

    • No trabaja solo para un cliente o empresa
    • Trabaja indirectamente para la sociedad
    • Tiene deberes que van más allá del contrato laboral

    ➡️ Ser ingeniero implica una responsabilidad pública.


    🌍 2. Tecnología, sociedad y poder

    La tecnología:

    • No es una simple herramienta
    • Es un sistema que configura la sociedad

    Influye en:

    • Economía
    • Política
    • Cultura
    • Relaciones humanas
    • Formas de vida

    Por tanto:

    • No es neutral
    • No es inevitable
    • No es ajena a valores

    ➡️ Diseñar tecnología es, en parte, diseñar sociedad.


    🧪 3. La tecnociencia y la falsa neutralidad

    Vivimos en una era de tecnociencia, donde:

    • Ciencia y tecnología están entrelazadas
    • La investigación responde a intereses económicos y políticos
    • Las decisiones técnicas ya contienen decisiones morales

    El libro desmonta definitivamente la idea de que:

    “La técnica solo ejecuta; otros deciden”

    ➡️ El ingeniero es un actor moral, no un mero ejecutor.


    ⚠️ 4. La sociedad del riesgo

    El progreso tecnológico genera:

    • Beneficios
    • Pero también riesgos creados por la propia acción humana

    Estos riesgos son:

    • Globales
    • Complejos
    • A veces irreversibles
    • Distribuidos de forma desigual

    El ingeniero:

    • No solo gestiona riesgos
    • Contribuye a producirlos

    ➡️ El riesgo no es solo un problema técnico, sino ético y social.


    🧭 5. Prudencia, decisión y responsabilidad

    Ante la incertidumbre, el libro propone tres pilares éticos fundamentales:

    🔹 Prudencia

    • Reconocer límites del conocimiento
    • Deliberar antes de actuar
    • Saber decir “no” cuando es necesario

    🔹 Decisión racional

    • Integrar técnica y valores
    • Justificar las decisiones
    • Asumir consecuencias

    🔹 Responsabilidad

    • Por acción y por omisión
    • Individual y colectiva
    • Presente y futura

    ➡️ La ética del ingeniero se concreta en cómo decide y de qué se hace responsable.


    4️⃣ El papel de las organizaciones y los códigos

    El libro no idealiza la realidad profesional:

    • El ingeniero trabaja en organizaciones
    • Hay presiones económicas, jerárquicas y temporales
    • Existe riesgo de diluir la responsabilidad

    Los códigos profesionales:

    • Son necesarios
    • Expresan valores colectivos
    • Orientan la conducta

    Pero:

    • No sustituyen al juicio moral personal
    • No eliminan los dilemas éticos

    ➡️ La ética requiere coherencia entre individuo, profesión y organización.


    5️⃣ Conceptos clave del libro (para memorizar)

    • Ingeniería como profesión social
    • No neutralidad tecnológica
    • Tecnociencia
    • Sociedad del riesgo
    • Responsabilidad ampliada
    • Prudencia
    • Decisión racional y deliberativa
    • Responsabilidad por acción y omisión
    • Justicia en la distribución del riesgo
    • Códigos profesionales
    • Ética organizacional
    • Confianza y legitimidad social

    6️⃣ Mensajes finales del libro

    El libro deja varios mensajes contundentes:

    • La excelencia técnica no basta
    • La ética no frena el progreso, lo orienta
    • No todo lo técnicamente posible es éticamente aceptable
    • La ignorancia voluntaria no exime de responsabilidad
    • La obediencia no justifica decisiones injustas
    • El ingeniero debe pensar en las consecuencias de su trabajo
    • La confianza social depende de la responsabilidad profesional

    7️⃣ ¿Qué debemos concluir tras leer este libro?

    Tras su lectura, la conclusión fundamental es clara:

    Ser ingeniero no es solo saber hacer cosas, sino hacerse cargo de lo que esas cosas provocan en el mundo.

    Un buen ingeniero es:

    • Competente técnicamente
    • Prudente en la acción
    • Responsable en la decisión
    • Honesto en la información
    • Consciente del impacto social de su trabajo

    El libro nos obliga a aceptar que:

    • La ética no es opcional
    • No es una asignatura “blanda”
    • Es parte esencial del ejercicio profesional

    8️⃣ Conclusión final (frase síntesis)

    La ingeniería construye el mundo en que vivimos; por eso, no puede renunciar a la responsabilidad moral sobre ese mundo.

  • Etica para ingenieros – 9 Códigos profesionales y ética organizacional

    Capítulo 9 — Códigos profesionales y ética organizacional

    (Resumen muy extenso y desarrollado)

    El Capítulo 9 funciona como culminación práctica de toda la obra. Tras haber fundamentado la ética de la ingeniería en la responsabilidad, la prudencia y la decisión racional, los autores analizan ahora cómo se articula esa ética en la realidad profesional concreta, marcada por organizaciones, empresas, administraciones y marcos institucionales.

    La pregunta central del capítulo es:

    ¿Cómo puede sostenerse la ética del ingeniero cuando este trabaja dentro de organizaciones complejas que imponen objetivos, normas y presiones propias?


    1️⃣ La ingeniería como práctica institucionalizada

    El capítulo parte de una constatación básica:

    • El ingeniero rara vez actúa de manera individual
    • Su trabajo se desarrolla casi siempre en:
      • Empresas
      • Administraciones públicas
      • Instituciones
      • Grandes organizaciones tecnológicas

    Esto implica que:

    • Las decisiones técnicas están condicionadas
    • Existen jerarquías, objetivos económicos y plazos
    • La autonomía profesional es real pero limitada

    ➡️ La ética del ingeniero debe enfrentarse al marco organizacional, no ignorarlo.


    2️⃣ El riesgo de dilución de la responsabilidad

    Uno de los problemas centrales que analiza el capítulo es la dilución de la responsabilidad.

    En las organizaciones:

    • Las decisiones se fragmentan
    • Las tareas se especializan
    • La responsabilidad se reparte

    Esto favorece actitudes como:

    • “Yo solo hago mi parte”
    • “La decisión viene de arriba”
    • “El sistema es así”

    Los autores advierten con claridad:

    La responsabilidad compartida no significa responsabilidad inexistente.

    Cada ingeniero sigue siendo moralmente responsable de:

    • Sus decisiones
    • Sus informes
    • Sus silencios
    • Sus omisiones

    3️⃣ Códigos profesionales: qué son y para qué sirven

    El capítulo introduce los códigos profesionales o deontológicos como uno de los principales instrumentos éticos de la profesión.

    Un código profesional es:

    • Un conjunto de principios y normas
    • Elaborado por la propia profesión
    • Que orienta el ejercicio responsable

    Sus funciones principales son:

    • Expresar los valores de la profesión
    • Orientar la conducta en situaciones conflictivas
    • Proteger a la sociedad
    • Proteger la integridad del profesional

    ➡️ No son simples reglamentos, sino expresiones del compromiso ético colectivo de la profesión.


    4️⃣ Alcance y límites de los códigos deontológicos

    Los autores analizan con realismo los límites de los códigos profesionales.

    Un código:

    • No sustituye al juicio moral personal
    • No resuelve automáticamente los dilemas
    • No puede prever todas las situaciones

    Además:

    • Puede ser interpretado de forma interesada
    • Puede quedar subordinado a la lógica empresarial
    • Puede convertirse en un documento meramente formal

    Por ello:

    El código es una guía, no un sustituto de la conciencia ética.


    5️⃣ Ética organizacional y cultura ética

    El capítulo amplía la reflexión hacia la ética de las organizaciones.

    Las organizaciones:

    • No son moralmente neutras
    • Generan culturas internas
    • Premian ciertos comportamientos y castigan otros

    Una organización puede:

    • Fomentar la responsabilidad y la transparencia
    • O incentivar la obediencia ciega, el silencio y la competitividad extrema

    La ética profesional del ingeniero:

    • Se ve profundamente afectada por la cultura organizacional
    • Puede fortalecerse o erosionarse según el entorno

    6️⃣ Conflictos entre ética profesional y objetivos organizativos

    El capítulo analiza uno de los conflictos más frecuentes:

    • Ética profesional vs. objetivos empresariales
    • Responsabilidad social vs. rentabilidad
    • Seguridad vs. reducción de costes
    • Transparencia vs. imagen corporativa

    En estos conflictos:

    • El ingeniero se encuentra bajo presión
    • Puede sufrir aislamiento o represalias
    • Puede verse tentado a ceder

    Los autores subrayan que:

    La ética profesional exige, en ocasiones, resistir presiones organizativas.


    7️⃣ Lealtad profesional y lealtad ética

    Un punto especialmente relevante del capítulo es la distinción entre:

    • Lealtad a la empresa
    • Lealtad a la profesión
    • Lealtad a la sociedad

    La lealtad profesional:

    • No puede confundirse con obediencia incondicional
    • Tiene límites éticos claros

    Cuando una organización exige actuaciones:

    • Injustas
    • Peligrosas
    • Engañosas

    El ingeniero:

    • Tiene el deber de cuestionar
    • Advertir
    • Y, en casos extremos, negarse a colaborar

    8️⃣ El papel del ingeniero como agente ético dentro de la organización

    El capítulo no presenta al ingeniero como una víctima pasiva del sistema, sino como un agente moral activo.

    El ingeniero puede:

    • Introducir criterios éticos en las decisiones
    • Favorecer la deliberación
    • Hacer visibles los riesgos
    • Defender estándares profesionales

    Esto requiere:

    • Coraje moral
    • Prudencia
    • Apoyo institucional
    • Códigos profesionales sólidos

    9️⃣ Ética organizacional y responsabilidad social

    Los autores conectan la ética organizacional con la responsabilidad social.

    Las organizaciones tecnológicas:

    • Influyen en la sociedad
    • Generan impactos amplios
    • No pueden limitarse al beneficio económico

    La ética profesional del ingeniero:

    • Es un elemento clave de la responsabilidad social corporativa
    • No puede delegarse solo en departamentos formales

    ➡️ La ética debe integrarse en la práctica cotidiana, no quedarse en declaraciones institucionales.


    🔟 Cierre del libro: ética, profesión y sociedad

    El capítulo 9 cierra el libro retomando sus ideas centrales:

    • La ingeniería es una profesión socialmente poderosa
    • Ese poder exige responsabilidad
    • La ética es parte esencial de la identidad profesional
    • Ni los códigos ni las organizaciones sustituyen al juicio moral del ingeniero

    El mensaje final es claro:

    La ética de la ingeniería solo es posible si se sostiene simultáneamente en la conciencia personal, la profesión y las instituciones.


    🧠 Ideas clave del Capítulo 9 (síntesis final)

    • La ingeniería se ejerce en organizaciones, no en el vacío
    • La estructura organizativa puede diluir la responsabilidad
    • Los códigos profesionales expresan valores colectivos
    • Los códigos orientan, pero no sustituyen al juicio moral
    • La cultura organizacional influye decisivamente en la conducta ética
    • La lealtad a la empresa tiene límites éticos
    • El ingeniero es un agente moral dentro de la organización
    • La ética profesional es parte de la responsabilidad social
    • La ética requiere coherencia entre individuo, profesión y organización
  • Etica para ingenieros – 8 El principio de responsabilidad

    (Resumen muy extenso y desarrollado)

    El Capítulo 8 profundiza en el concepto que atraviesa toda la ética de la ingeniería: la responsabilidad. Tras analizar la sociedad del riesgo (cap. 5), la prudencia (cap. 6) y la decisión racional (cap. 7), los autores se centran ahora en responder a una pregunta decisiva:

    ¿De qué es responsable el ingeniero y hasta dónde llega esa responsabilidad?

    Este capítulo sostiene que el desarrollo tecnocientífico ha ampliado enormemente el alcance de la acción humana, y que a mayor poder técnico, mayor exigencia de responsabilidad ética.


    1️⃣ El nuevo alcance de la acción técnica

    El capítulo comienza señalando que la acción técnica contemporánea:

    • Tiene un alcance sin precedentes
    • Afecta a grandes colectivos
    • Produce efectos a largo plazo
    • Puede generar daños irreversibles

    La ingeniería actual:

    • Ya no actúa solo en el presente
    • Interviene en el futuro
    • Condiciona la vida de generaciones que no pueden participar en la decisión

    ➡️ Esto obliga a repensar el concepto clásico de responsabilidad, limitado tradicionalmente al daño inmediato y visible.


    2️⃣ El principio de responsabilidad como exigencia ética central

    Los autores adoptan y desarrollan el principio de responsabilidad como núcleo de la ética de la ingeniería.

    Este principio implica que:

    • El ingeniero debe responder por las consecuencias previsibles de su acción
    • No basta con cumplir órdenes o normas
    • No basta con actuar conforme a la legalidad vigente

    La responsabilidad ética exige:

    • Reflexión
    • Anticipación
    • Asunción consciente de consecuencias

    3️⃣ Responsabilidad por acción y por omisión

    Uno de los puntos clave del capítulo es la ampliación del concepto de responsabilidad.

    El ingeniero es responsable:

    • Por lo que hace
    • Por lo que permite
    • Por lo que omite, cuando podría haber actuado razonablemente

    La omisión:

    • No es neutral
    • Puede causar tanto daño como la acción directa

    Ejemplo conceptual:

    • No advertir de un riesgo conocido
    • No oponerse a una decisión peligrosa
    • Callar por miedo o comodidad

    ➡️ La responsabilidad ética incluye el deber de advertir y de resistir decisiones irresponsables.


    4️⃣ Responsabilidad y previsión razonable

    El capítulo aclara que:

    • No se puede exigir al ingeniero prever todo
    • No se le puede responsabilizar de consecuencias absolutamente imprevisibles

    La responsabilidad se vincula a:

    • Consecuencias razonablemente previsibles
    • Riesgos conocidos o sospechados
    • Información disponible en el momento de decidir

    Esto introduce un criterio clave:

    La ignorancia culpable no exime de responsabilidad.

    El ingeniero tiene el deber de:

    • Informarse
    • Consultar
    • Actualizar conocimientos
    • No decidir desde la negligencia

    5️⃣ Responsabilidad en contextos de incertidumbre

    Uno de los retos centrales del capítulo es abordar la responsabilidad en un contexto de incertidumbre estructural.

    Los autores subrayan que:

    • La incertidumbre no elimina la responsabilidad
    • La falta de certeza no justifica la irresponsabilidad

    En ingeniería:

    • Muchas decisiones se toman sin garantías absolutas
    • Pero sí con grados de probabilidad y riesgo

    La responsabilidad ética exige:

    • Prudencia
    • Precaución
    • Honestidad sobre los límites del conocimiento

    6️⃣ Responsabilidad hacia terceros y generaciones futuras

    El capítulo amplía el horizonte moral de la responsabilidad:

    El ingeniero es responsable no solo ante:

    • Clientes
    • Empresas
    • Superiores jerárquicos

    Sino también ante:

    • Usuarios
    • Ciudadanos
    • Colectivos vulnerables
    • Generaciones futuras

    Esta ampliación es clave porque:

    • Muchas decisiones técnicas afectan a personas ausentes
    • Que no pueden consentir ni defenderse

    ➡️ La responsabilidad ética trasciende el contrato profesional inmediato.


    7️⃣ Responsabilidad individual y responsabilidad colectiva

    Los autores analizan una tensión central en la práctica profesional:

    • Las decisiones son colectivas
    • Pero la responsabilidad no desaparece

    El hecho de trabajar en:

    • Empresas
    • Administraciones
    • Equipos técnicos

    No exime al ingeniero de responsabilidad personal.

    La responsabilidad es:

    • Compartida
    • Pero no diluida

    Cada profesional debe:

    • Asumir su parte
    • No esconderse en la estructura organizativa

    8️⃣ Responsabilidad, poder y legitimidad social

    El capítulo subraya que:

    • La sociedad concede poder a los ingenieros
    • A cambio exige responsabilidad

    La legitimidad social de la ingeniería:

    • Depende de que ese poder se ejerza éticamente
    • Se rompe cuando se percibe irresponsabilidad, negligencia o ocultación

    Por eso:

    La responsabilidad ética es condición de la confianza social.

    Sin responsabilidad:

    • Aparece desconfianza
    • Rechazo social
    • Crisis de legitimidad de la tecnología

    9️⃣ El principio de precaución

    El capítulo introduce la relación entre responsabilidad y principio de precaución.

    Cuando:

    • Los riesgos son graves
    • Las consecuencias pueden ser irreversibles
    • El conocimiento es limitado

    La responsabilidad exige:

    • Extremar la prudencia
    • Evitar decisiones precipitadas
    • No trasladar el riesgo injustamente a otros

    El principio de precaución:

    • No implica paralizar la innovación
    • Implica no actuar de forma temeraria

    🔟 Responsabilidad como núcleo de la identidad profesional

    El capítulo concluye afirmando que:

    • La responsabilidad no es una carga externa
    • Es parte esencial de ser ingeniero

    Un buen ingeniero:

    • No es solo técnicamente competente
    • Es moralmente responsable

    La responsabilidad:

    • Da sentido al ejercicio profesional
    • Justifica la autonomía técnica
    • Fundamenta la confianza social

    🧠 Ideas clave del Capítulo 8 (síntesis final)

    • El poder técnico amplía el alcance de la responsabilidad
    • El ingeniero responde por acción y por omisión
    • La responsabilidad se basa en previsión razonable, no en omnisciencia
    • La incertidumbre no elimina la exigencia ética
    • La responsabilidad se extiende a terceros y generaciones futuras
    • La organización no exime de responsabilidad personal
    • La responsabilidad es condición de la confianza social
    • El principio de precaución es una expresión de la responsabilidad
    • La responsabilidad es núcleo de la identidad profesional del ingeniero
  • Etica para ingenieros – 7 Decisión racional y ética

    Capítulo 7 — Decisión racional y ética

    (Resumen muy extenso y desarrollado)

    El Capítulo 7 aborda directamente el núcleo práctico de la ética de la ingeniería: la toma de decisiones. Tras haber analizado la sociedad del riesgo (cap. 5) y la virtud de la prudencia (cap. 6), los autores se preguntan ahora:

    ¿Cómo debe decidir racionalmente un ingeniero cuando se enfrenta a dilemas éticos reales?

    Este capítulo rechaza tanto la improvisación moral como la aplicación mecánica de reglas, y propone una concepción racional, deliberativa y responsable de la decisión ética en contextos tecnocientíficos complejos.


    1️⃣ La decisión como núcleo de la acción profesional

    El capítulo parte de una idea fundamental:

    La ética profesional se concreta en decisiones.

    No basta con:

    • Tener buenos principios
    • Conocer códigos deontológicos
    • Afirmar valores generales

    La ética se pone a prueba cuando:

    • Hay que elegir entre alternativas
    • Existen consecuencias negativas inevitables
    • Hay intereses contrapuestos
    • La información es incompleta

    La ingeniería es, por tanto, una actividad decisional, no solo ejecutiva.


    2️⃣ El carácter racional de la decisión ética

    Los autores subrayan que la decisión ética:

    • No es arbitraria
    • No es puramente emocional
    • No es subjetiva

    Es una decisión racional, pero no en el sentido estrecho del cálculo técnico.

    La racionalidad ética:

    • Integra datos técnicos
    • Considera valores morales
    • Evalúa consecuencias
    • Atiende a las personas afectadas

    ➡️ Decidir éticamente es deliberar racionalmente sobre lo que debe hacerse, no solo sobre lo que puede hacerse.


    3️⃣ Límites del modelo puramente técnico de decisión

    El capítulo critica los modelos de decisión basados exclusivamente en:

    • Optimización
    • Eficiencia
    • Coste-beneficio
    • Maximización de resultados

    Estos modelos:

    • Son necesarios
    • Pero insuficientes

    Porque:

    • No captan valores como justicia, dignidad o responsabilidad
    • Tienden a reducir los problemas morales a cifras
    • Pueden legitimar decisiones injustas si son “eficientes”

    ➡️ La racionalidad técnica no agota la racionalidad ética.


    4️⃣ Decisiones en contextos de incertidumbre

    Uno de los aspectos centrales del capítulo es la toma de decisiones bajo incertidumbre.

    En ingeniería:

    • No se conocen todas las consecuencias
    • No se pueden prever todos los riesgos
    • No existe certeza absoluta

    Los autores señalan que:

    • La falta de certeza no justifica la irresponsabilidad
    • Decidir sin garantías no equivale a decidir sin criterios

    Aquí se conecta directamente con la prudencia:

    • La decisión racional reconoce los límites del conocimiento
    • Pero no renuncia a actuar responsablemente

    5️⃣ Conflictos de valores y dilemas éticos

    El capítulo analiza la existencia de conflictos reales de valores, que dan lugar a dilemas éticos.

    Ejemplos conceptuales:

    • Seguridad vs. coste
    • Eficiencia vs. equidad
    • Innovación vs. precaución
    • Beneficio privado vs. interés público

    En estos casos:

    • No hay soluciones perfectas
    • Toda decisión implica algún daño o renuncia

    La ética no consiste en:

    • Eliminar el conflicto
      Sino en:

    Justificar racionalmente por qué se elige una opción y no otra.


    6️⃣ La deliberación ética como proceso

    Los autores proponen entender la decisión ética como un proceso deliberativo, no como un acto instantáneo.

    Este proceso incluye:

    1. Análisis de la situación
    2. Identificación de alternativas
    3. Evaluación de consecuencias previsibles
    4. Consideración de los valores implicados
    5. Atención a las personas afectadas
    6. Asunción de responsabilidades

    La deliberación:

    • Reduce la arbitrariedad
    • Aumenta la calidad moral de la decisión
    • Hace explícitos los criterios utilizados

    7️⃣ Dimensión colectiva de la decisión

    El capítulo insiste en que:

    • Muchas decisiones en ingeniería no son individuales
    • Se toman en equipos, empresas e instituciones

    Esto introduce una dimensión ética adicional:

    • Responsabilidad compartida
    • Necesidad de diálogo
    • Importancia del contraste de puntos de vista

    La decisión racional exige:

    • Escuchar a otros profesionales
    • Considerar opiniones discrepantes
    • Evitar el aislamiento decisional

    ➡️ La deliberación colectiva es una exigencia ética en contextos complejos.


    8️⃣ Decisión ética y responsabilidad

    Decidir implica siempre asumir responsabilidad.

    Los autores subrayan que:

    • No decidir también es una forma de decidir
    • La pasividad puede tener consecuencias graves

    El ingeniero es responsable:

    • De lo que hace
    • De lo que permite
    • De lo que omite cuando podría actuar

    La decisión ética:

    • No elimina el riesgo
    • Pero asume conscientemente sus consecuencias

    9️⃣ Justificación pública de las decisiones

    Un aspecto especialmente relevante del capítulo es la idea de justificación pública.

    Las decisiones éticas:

    • Deben poder explicarse
    • Deben ser defendibles racionalmente
    • Deben resistir el escrutinio social

    Esto implica:

    • Transparencia
    • Argumentación
    • Honestidad

    La legitimidad ética de una decisión:

    No depende solo del resultado, sino de la calidad del proceso que la ha generado.


    🔟 Decisión racional como competencia ética del ingeniero

    El capítulo concluye afirmando que:

    • Saber decidir éticamente es una competencia profesional
    • No es solo una cualidad personal

    Por ello:

    • Debe enseñarse
    • Practicarse
    • Evaluarse

    La ética profesional no es:

    • Un código aprendido de memoria
    • Sino una capacidad de juicio racional en situaciones complejas

    🧠 Ideas clave del Capítulo 7 (síntesis final)

    • La ética profesional se concreta en decisiones
    • Decidir éticamente es un acto racional y deliberativo
    • La racionalidad técnica es necesaria pero insuficiente
    • La incertidumbre no elimina la responsabilidad
    • Los dilemas éticos implican conflictos reales de valores
    • La deliberación mejora la calidad moral de las decisiones
    • La decisión ética tiene una dimensión colectiva
    • La responsabilidad incluye acción y omisión
    • Las decisiones deben poder justificarse públicamente
    • La capacidad de decidir éticamente es una competencia profesional