# Guía rápida — Puesta en Producción Segura (PPS)

> Síntesis de 4 materiales HTML interactivos: **Unidad 1** (Fundamentos de Desarrollo Seguro), **Unidad 2** (Normativa de Seguridad en Aplicaciones), **Unidades 3 y 4** (Seguridad Web y Móvil) y un bloque adicional de **Git, DevOps, Virtualización y Unidad 5** (Diseño Seguro de Software).

## Objetivo de la asignatura
Formar en el diseño, desarrollo, verificación y despliegue seguro de aplicaciones web y móviles: desde el ciclo de vida seguro del software (SDLC) y los fundamentos de programación, pasando por normativa y catálogos de vulnerabilidades (CVE, OWASP), hasta la detección/corrección práctica de vulnerabilidades web y móviles, y el control de versiones (Git) como herramienta transversal de DevOps.

## Descripción breve
La asignatura combina teoría (SDLC, principios de seguridad, lenguajes de programación, normativa y estándares OWASP/ASVS/CVE) con práctica intensiva de pentesting ético (Burp Suite, Selenium, Metasploit, Drozer, JADX, apktool) sobre laboratorios deliberadamente vulnerables (WebGoat, Juice Shop, secDevLabs, DIVA, InsecureShop), y cierra con Git/DevOps como base de trabajo colaborativo y despliegue seguro.

## Temas principales
1. Fundamentos de desarrollo seguro y SDLC
2. Lenguajes de programación y entornos de desarrollo
3. Pruebas de software (testing, caja blanca, PHPUnit)
4. Fuentes abiertas, CVE y normativa OWASP/ASVS
5. Burp Suite y laboratorios de vulnerabilidades (secDevLabs, WebGoat)
6. Vulnerabilidades en aplicaciones web (13+ tipos) y contramedidas
7. Seguridad en aplicaciones móviles (Android/iOS, OWASP Mobile Top 10, DIVA)
8. Control de versiones con Git
9. DevOps, CI/CD, IaC y virtualización
10. Diseño seguro de software (Unidad 5) y puesta en producción

## Tecnologías principales
PHP · Python · Java · Go · JavaScript · SQL · XML · JSON · Android (Java/Kotlin) · iOS (Swift/Objective-C) · Docker · Kubernetes

## Herramientas principales
VS Code, PHPUnit, Selenium, Burp Suite, OWASP ZAP, Wappalyzer, Metasploit, Apktool, ADB, JADX, Drozer, Bytecode Viewer, Git, Jenkins, Ansible, Terraform

## Nivel aproximado
Ciclo Formativo de Grado Superior / nivel introductorio-intermedio en ciberseguridad y desarrollo seguro (encaje típico: módulo "Puesta en Producción Segura" de un CFGS de Desarrollo de Aplicaciones o Ciberseguridad).

## Resultado esperado / qué debería saber hacer al terminar
- Explicar el SDLC y aplicar principios de seguridad (defensa en profundidad, menor privilegio, validación de entradas) en cada fase.
- Diseñar pruebas de caja blanca (CFG, complejidad ciclomática) y escribir tests unitarios con PHPUnit/JUnit/PyTest.
- Buscar y entender un CVE, y usar el catálogo OWASP Top Ten / ASVS para clasificar riesgos.
- Detectar y explotar de forma ética (en laboratorio controlado) vulnerabilidades web (SQLi, XSS, IDOR, SSRF, XXE, CSRF, etc.) con Burp Suite.
- Analizar estática y dinámicamente una app Android (JADX, Drozer, apktool, ADB) e identificar fallos del OWASP Mobile Top 10.
- Usar Git de forma completa: ramas, fusiones, rebase, remotos, resolución de conflictos.
- Situar Git/testing/seguridad dentro de un flujo DevOps con CI/CD, IaC y contenedores.

---

## Mapa visual de contenidos

```text
Puesta en Producción Segura (PPS)
├── U1 · Fundamentos de Desarrollo Seguro
│   ├── SDLC y principios de seguridad
│   ├── Lenguajes (interpretados/compilados/híbridos), Go, Java
│   ├── IDEs y entornos (VS Code, PHP, Docker)
│   ├── Pruebas de software (caja blanca, CFG, complejidad ciclomática)
│   ├── PHPUnit + anexos PHP/Python/Java
│   └── Selenium (práctica de automatización)
├── U2 · Normativa de Seguridad en Aplicaciones
│   ├── Fuentes abiertas vs software propietario
│   ├── CVE / CVSS
│   ├── OWASP (comunidad, Top Ten, ASVS, Mobile Top 10)
│   ├── OWASP Top Ten 2025 (A01–A10)
│   └── Burp Suite + laboratorios secDevLabs + WebGoat
├── U3 · Seguridad Web
│   ├── Conceptos clave (AuthN/AuthZ, sesión, WAF, JWT, OAuth/OIDC)
│   ├── 23 vulnerabilidades web (CSRF, SQLi, XSS, IDOR, SSRF, XXE...)
│   ├── Formularios seguros (CSRF token, CAPTCHA, honeypot)
│   ├── Robo de sesión y contramedidas
│   ├── Almacenamiento seguro de contraseñas (bcrypt/Argon2)
│   └── Headers de seguridad HTTP + WAF
├── U4 · Seguridad Móvil
│   ├── Arquitectura Android (Dalvik/ART, APK) e iOS (Darwin/XNU, IPA)
│   ├── Permisos, firma de apps, almacenamiento seguro
│   ├── Fugas de información
│   ├── OWASP Mobile Top 10 (2024)
│   ├── DIVA (13 retos)
│   └── Prácticas 7-9 (Metasploit/Apktool, análisis estático, Drozer/JADX)
├── Git y Control de Versiones
│   ├── Conceptos (repo, staging, commit, branch, HEAD, remoto)
│   ├── Flujo de trabajo (working dir → staging → local → remoto)
│   ├── Ramas (merge, rebase, conflictos)
│   ├── Remotos (fetch, pull, push, clone)
│   └── Configuración (~/.gitconfig)
└── DevOps / U5 · Diseño Seguro y Producción
    ├── Ciclo DevOps y DevSecOps
    ├── CI/CD (Jenkins, GitHub Actions)
    ├── IaC (Ansible, Terraform)
    ├── Virtualización (hipervisores, VM vs contenedor)
    └── Puesta en producción segura (config, accesos, parches, monitoreo)
```

---

# Temario

## U1 — Fundamentos de Desarrollo Seguro
[Resumen UD01](https://alyraluca.github.io/cibersecurity/Puesta%20en%20Producción/produccion_tema1.html)
- **Objetivo:** Comprender el SDLC y sus principios de seguridad, los tipos de lenguajes de programación, y diseñar/ejecutar pruebas de software (incluida caja blanca).
- **Conceptos clave:** SDLC (6 fases), defensa en profundidad, menor privilegio, validación de entradas, CFG, complejidad ciclomática (CC = arcos − nodos + 2), caja blanca vs caja negra, testing vs debugging.
- **Tecnologías:** PHP, Python, Java, Go, C++.
- **Herramientas:** VS Code (+ PHP Intelephense), XAMPP/MAMP/Docker, PHPUnit, Composer, Selenium (WebDriver + IDE).
- **Archivos/formatos relevantes:** `.php`, `.py`, `.java`, `.side` (Selenium IDE).
- **Qué debería saber hacer:** Clasificar un lenguaje según su ejecución, calcular la CC de un CFG, escribir un test PHPUnit básico, y automatizar una comprobación de SQLi/autenticación débil con Selenium sobre `testphp.vulnweb.com`.

## U2 — Normativa de Seguridad en Aplicaciones
[Resumen UD02](https://alyraluca.github.io/cibersecurity/Puesta%20en%20Producción/produccion_tema2.html)
- **Objetivo:** Conocer las fuentes de referencia normativa (CVE, OWASP, ASVS) y practicar la detección de vulnerabilidades con Burp Suite.
- **Conceptos clave:** Open source vs propietario, CVE/CVSS, OWASP Top Ten 2025 (A01–A10), ASVS (3 niveles), IDOR, XXE, deserialización insegura (Pickle → RCE), JWT vs codificación vs cifrado.
- **Tecnologías:** XML, JWT, Python (Pickle), WordPress.
- **Herramientas:** Burp Suite Community (Proxy, Repeater, Decoder, Comparer, Intruder), Wappalyzer, OWASP ZAP, WPScan, searchsploit, WebGoat, Docker (para laboratorios secDevLabs).
- **Archivos/formatos relevantes:** Identificador `CVE-AAAA-NNNNN`, JWT `header.payload.signature`.
- **Qué debería saber hacer:** Interpretar un identificador CVE y su CVSS, mapear una vulnerabilidad al riesgo OWASP correspondiente, y usar Burp Repeater/Intruder para explotar IDOR, XXE o fuerza bruta en un laboratorio secDevLabs.
- **Dependencia:** U1 → U2 (la normativa se apoya en los conceptos de pruebas y desarrollo seguro de U1).

## U3 — Seguridad Web
[Resumen UD03 | UD04](https://alyraluca.github.io/cibersecurity/Puesta%20en%20Producción/produccion_tema3_tema4.html)
- **Objetivo:** Detectar, explotar (éticamente) y mitigar las vulnerabilidades web más críticas, y diseñar formularios/sesiones/contraseñas de forma segura.
- **Conceptos clave:** AuthN vs AuthZ, CSRF, Open Redirect, CORS, Race Condition, IDOR, DoS, XXE, Path Traversal, Clickjacking, SSTI, XPath Injection, CSV Injection, SQLi (Error/Blind), OS Command Injection, File Upload, XSS (Reflected/Stored), SSRF/XSPA, LFI/RFI, Session Issues, Missing Functional Level Access Control, JWT, OAuth 2.0, OIDC, SAML, salting, bcrypt/Argon2, WAF.
- **Tecnologías:** HTTP/HTTPS, SQL, XML, JSON/JWT, cookies.
- **Herramientas:** Burp Suite (práctica 6), ModSecurity/Cloudflare WAF (gratuitos), reCAPTCHA.
- **Archivos/formatos relevantes:** Headers HTTP (`CSP`, `HSTS`, `X-Frame-Options`), cookies (`HttpOnly`, `Secure`, `SameSite`).
- **Qué debería saber hacer:** Explotar y mitigar las 13 vulnerabilidades de la Práctica 6 (securizar una app web), implementar un token anti-CSRF, y aplicar cabeceras de seguridad HTTP correctamente.

## U4 — Seguridad Móvil
[Resumen UD03 | UD04](https://alyraluca.github.io/cibersecurity/Puesta%20en%20Producción/produccion_tema3_tema4.html)
- **Objetivo:** Analizar estática y dinámicamente aplicaciones Android/iOS para detectar vulnerabilidades del OWASP Mobile Top 10.
- **Conceptos clave:** Arquitectura Android (Dalvik vs ART), arquitectura iOS (Darwin/XNU), estructura APK/IPA, permisos normales/peligrosos, firma de apps (v1-v4), almacenamiento interno/externo, SharedPreferences, Android Keystore, `android:debuggable`, `android:allowBackup`, `android:exported`, OWASP Mobile Top 10 2024 (M1–M10).
- **Tecnologías:** Android (Java/Kotlin, Smali), iOS (Info.plist, Mach-O).
- **Herramientas:** Metasploit/msfvenom, Apktool, ADB, Bytecode Viewer, JADX, Drozer, dex2jar, JD-GUI, DIVA.apk, InsecureShop.apk.
- **Archivos/formatos relevantes:** `.apk`, `.ipa`, `AndroidManifest.xml`, `Info.plist`, `classes.dex`, código Smali.
- **Qué debería saber hacer:** Generar y troyanizar un APK (Práctica 7), analizarlo estáticamente con Bytecode Viewer/apktool (Práctica 8), y analizar dinámicamente InsecureShop con Drozer/JADX (Práctica 9).
- **Dependencia:** U3 → U4 (los conceptos de autenticación, sesiones y JWT de U3 se reutilizan en el contexto móvil).

## Git y Control de Versiones
- **Objetivo:** Dominar el flujo de trabajo local y remoto de Git, incluida la gestión de ramas y la resolución de conflictos.
- **Conceptos clave:** Working Directory / Staging Area / Local Repository, commit, branch, HEAD, remoto (`origin`), merge (fast-forward vs merge commit), rebase, conflicto de fusión, `.gitignore`, commit huérfano.
- **Tecnologías:** —
- **Herramientas:** Git CLI, GitHub, GitLab, Bitbucket.
- **Archivos/formatos relevantes:** `.git/`, `.gitignore`, `~/.gitconfig`.
- **Qué debería saber hacer:** Ejecutar el ciclo completo `init → add → commit → push`, crear y fusionar ramas (`merge --ff-only`/`--no-ff`), hacer rebase, resolver conflictos, gestionar remotos (`clone`, `fetch --prune`, `pull --rebase`, `push -d`) y configurar `~/.gitconfig`.

## DevOps / U5 — Diseño Seguro y Puesta en Producción
[Resumen UD05](https://alyraluca.github.io/cibersecurity/Puesta%20en%20Producción/produccion_tema5.html)
- **Objetivo:** Situar el desarrollo seguro y Git dentro de un ciclo DevOps con CI/CD, IaC y virtualización, y aplicar buenas prácticas de despliegue seguro.
- **Conceptos clave:** DevOps, DevSecOps, CI/CD, IaC, hipervisor (Tipo 1/Tipo 2), tipos de virtualización (servidor, escritorio, red, almacenamiento, aplicaciones, hardware), VM vs contenedor, RBAC, MFA, respaldo/recuperación.
- **Tecnologías:** YAML, contenedores.
- **Herramientas:** Jenkins, GitHub Actions, CircleCI, Ansible, Terraform, Puppet, Chef, Docker, Kubernetes (`kubectl`), Docker Swarm, Amazon ECS, Prometheus, ELK Stack, Grafana, VMware ESXi/Workstation, Hyper-V, KVM, VirtualBox.
- **Archivos/formatos relevantes:** Playbooks YAML (Ansible), manifiestos Kubernetes.
- **Qué debería saber hacer:** Describir un pipeline CI/CD (checkout → build → test → deploy), diferenciar VM de contenedor, y aplicar las 6 medidas de seguridad en puesta en producción (configuración, accesos, parches, monitoreo, respuesta a incidentes, respaldo).

```text
U1 → U2 → U3 → U4
                ↘
                 Git (transversal, se aprende en paralelo)
                      ↘
                       DevOps / U5 (integra todo lo anterior)
```

---

# Herramientas y tecnologías

| Herramienta / Tecnología | Categoría | Para qué sirve | Tema | URL oficial | Recursos |
|---|---|---|---|---|---|
| PHP | Lenguaje | Desarrollo web backend interpretado | U1, U3 | No indicada en el material | — |
| Python | Lenguaje | Multiparadigma, interpretado/compilable | U1 | No indicada en el material | — |
| Java | Lenguaje | Híbrido (bytecode + JVM) | U1, U4 | No indicada en el material | — |
| Go (Golang) | Lenguaje | Compilado, concurrencia nativa, microservicios | U1 | No indicada en el material | — |
| C++ | Lenguaje | Compilado, alto rendimiento | U1 | No indicada en el material | — |
| VS Code | IDE/Editor | Edición de código, extensible | U1 | No indicada en el material | — |
| IntelliJ / Eclipse / NetBeans / Visual Studio | IDE | Desarrollo Java/multilenguaje | U1 | No indicada en el material | — |
| XAMPP / MAMP | Plataforma | Entorno local PHP+MySQL | U1 | No indicada en el material | — |
| Docker | DevOps / Contenedores | Empaquetado y aislamiento de apps | U1, U2, DevOps | No indicada en el material | — |
| Composer | CLI | Gestor de dependencias PHP | U1 | No indicada en el material | — |
| PHPUnit | Testing | Framework de pruebas unitarias PHP (xUnit) | U1 | No indicada en el material | — |
| JUnit / PyTest | Testing | Framework de pruebas Java/Python | U1 | No indicada en el material | — |
| Selenium (WebDriver + IDE) | Testing / Automatización | Automatización de pruebas funcionales web | U1 | No indicada en el material | — |
| Postman / JMeter | Testing | Pruebas de APIs | U1 | No indicada en el material | — |
| GitLab CI / Jenkins | DevOps / CI | Integración continua | U1, DevOps | No indicada en el material | — |
| CVE / CVSS | Normativa | Catalogar y puntuar vulnerabilidades | U2 | No indicada en el material | — |
| Wappalyzer | Seguridad / Reconocimiento | Detectar tecnologías de una web | U2 | No indicada en el material | — |
| OWASP (Top Ten, ASVS, ZAP, Juice Shop, Dependency-Check, Cheat Sheet Series, Mobile Top 10) | Frameworks de seguridad | Estándares y herramientas de seguridad de aplicaciones | U2, U3, U4 | No indicada en el material | — |
| Burp Suite (Community) | Seguridad / Pentesting | Proxy de intercepción HTTP(S) | U2, U3 | No indicada en el material | — |
| WPScan | Seguridad | Escaneo de vulnerabilidades WordPress | U2 | No indicada en el material | — |
| WebGoat | Laboratorio vulnerable | Práctica ética de OWASP Top Ten | U2 | No indicada en el material | — |
| JWT (JSON Web Token) | Estándar / API | Transmisión segura de información firmada | U2, U3 | No indicada en el material | — |
| OAuth 2.0 / OIDC / SAML | Estándar Auth | Autorización/autenticación delegada | U3 | No indicada en el material | — |
| bcrypt / Argon2 / scrypt | Seguridad / Criptografía | Hashing seguro de contraseñas | U3 | No indicada en el material | — |
| reCAPTCHA | Seguridad | Protección anti-bots en formularios | U3 | No indicada en el material | — |
| ModSecurity / Cloudflare WAF / NAXSI | Seguridad (WAF) | Firewall de aplicaciones web | U3 | No indicada en el material | — |
| Metasploit / msfvenom | Seguridad / Explotación | Generación de payloads y explotación | U4 | No indicada en el material | — |
| Apktool | Ingeniería inversa | Descompilar/recompilar APKs a Smali | U4 | No indicada en el material | — |
| ADB (Android Debug Bridge) | CLI | Comunicación con dispositivos Android | U4 | No indicada en el material | — |
| Bytecode Viewer | Análisis estático | Visor de bytecode Smali/Java/Dalvik | U4 | No indicada en el material | — |
| JADX | Ingeniería inversa | Decompilar DEX/APK a Java legible | U4 | No indicada en el material | — |
| Drozer | Seguridad móvil | Análisis dinámico de superficie de ataque Android | U4 | No indicada en el material | — |
| dex2jar / JD-GUI | Ingeniería inversa | Convertir/decompilar bytecode Dalvik a Java | U4 | No indicada en el material | — |
| DIVA / InsecureShop | Laboratorio vulnerable | Práctica de vulnerabilidades Android | U4 | No indicada en el material | — |
| Git | Control de versiones | Rastrear cambios, trabajo colaborativo | Git | No indicada en el material | — |
| GitHub / GitLab / Bitbucket | Plataforma / Hosting | Alojamiento y colaboración de repositorios | Git | No indicada en el material | — |
| Ansible / Terraform / Puppet / Chef | IaC | Gestión de infraestructura como código | DevOps | No indicada en el material | — |
| Kubernetes / Docker Swarm / Amazon ECS | Orquestación | Gestión de clústeres de contenedores | DevOps | No indicada en el material | — |
| Prometheus / ELK Stack / Grafana | Monitorización | Métricas, logs y alertas | DevOps | No indicada en el material | — |
| VMware ESXi/Workstation, Hyper-V, KVM, VirtualBox | Virtualización | Hipervisores tipo 1 y tipo 2 | DevOps | No indicada en el material | — |

---

# Recursos

Lo único citable como "referencia nombrada" dentro del material (sin URL adjunta) son los propios proyectos y estándares mencionados: **OWASP Top Ten, OWASP ASVS, OWASP Mobile Top 10, OWASP Juice Shop, OWASP ZAP, OWASP Dependency-Check, OWASP Cheat Sheet Series, WebGoat, DIVA, InsecureShop, CVE Program, NIST SP 800-53, NIST SP 800-63, ISO 27001**.

---

# Recursos por tema

## U1 — Fundamentos de Desarrollo Seguro
### Herramientas
VS Code, PHPUnit, Composer, Selenium, XAMPP/MAMP/Docker
### Documentación / Tutoriales / Repositorios / Vídeos / Otros
⚠️ No indicados en el material original.

## U2 — Normativa de Seguridad
### Herramientas
Burp Suite, Wappalyzer, WPScan, WebGoat
### Documentación / Tutoriales / Repositorios / Vídeos / Otros
⚠️ No indicados en el material original (se citan OWASP ZAP, Juice Shop, Dependency-Check, ASVS y Cheat Sheet Series solo por nombre).

## U3 — Seguridad Web
### Herramientas
Burp Suite, reCAPTCHA, ModSecurity/Cloudflare WAF/NAXSI
### Documentación / Tutoriales / Repositorios / Vídeos / Otros
⚠️ No indicados en el material original.

## U4 — Seguridad Móvil
### Herramientas
Metasploit, Apktool, ADB, Bytecode Viewer, JADX, Drozer, dex2jar, JD-GUI
### Documentación / Tutoriales / Repositorios / Vídeos / Otros
⚠️ No indicados en el material original (DIVA e InsecureShop.apk son los "repositorios/targets" de práctica, sin URL en el HTML).

## Git
### Herramientas
Git CLI, GitHub, GitLab, Bitbucket
### Documentación / Tutoriales / Repositorios / Vídeos / Otros
⚠️ No indicados en el material original.

## DevOps / U5
### Herramientas
Jenkins, GitHub Actions, Ansible, Terraform, Docker, Kubernetes, Prometheus
### Documentación / Tutoriales / Repositorios / Vídeos / Otros
⚠️ No indicados en el material original.

---

# Checklist de conocimientos

## 🟢 Básico
- [ ] Las 6 fases del SDLC y sus objetivos
- [ ] Diferencia entre lenguaje interpretado, compilado e híbrido
- [ ] Diferencia entre testing y debugging
- [ ] Diferencia entre caja blanca y caja negra
- [ ] Qué es un IDE y qué componentes incluye
- [ ] Zonas del entorno local de Git (Working Dir, Staging, Local Repo)
- [ ] Comandos básicos de Git: `init`, `status`, `add`, `commit`, `log`
- [ ] Qué es un CVE y su estructura (`CVE-AAAA-NNNNN`)
- [ ] Qué es OWASP y qué es el OWASP Top Ten
- [ ] Diferencia entre autenticación y autorización
- [ ] Qué es HTTPS/TLS y por qué es necesario

## 🟡 Intermedio
- [ ] Calcular la complejidad ciclomática de un CFG
- [ ] Escribir un test PHPUnit con aserciones (`assertEquals`, `assertTrue`...)
- [ ] Explicar los 10 riesgos del OWASP Top Ten 2025 (A01–A10)
- [ ] Diferenciar codificación (Base64), firma (JWT/HMAC) y cifrado (AES/TLS)
- [ ] Usar Burp Suite (Repeater, Decoder, Comparer, Intruder)
- [ ] Reconocer y mitigar CSRF, XSS (reflejado/almacenado), IDOR, SQLi (error/blind)
- [ ] Configurar cookies seguras (`HttpOnly`, `Secure`, `SameSite`)
- [ ] Diferenciar Dalvik/ART y la estructura de un APK
- [ ] Gestionar ramas en Git: crear, fusionar (`--ff-only`/`--no-ff`), eliminar
- [ ] Resolver un conflicto de fusión en Git
- [ ] Configurar remotos: `clone`, `fetch --prune`, `pull --rebase`, `push -u`

## 🔴 Avanzado
- [ ] Diseñar un conjunto completo de casos de prueba de caja blanca (método del camino básico)
- [ ] Explotar de forma ética IDOR, XXE y deserialización insegura (Pickle → RCE) en laboratorio
- [ ] Aplicar los tres niveles de OWASP ASVS a una aplicación real
- [ ] Troyanizar un APK con Metasploit + Apktool y analizarlo con Bytecode Viewer
- [ ] Auditar una app Android con Drozer (superficie de ataque, ContentProviders) y JADX
- [ ] Mapear cada hallazgo de un pentest al OWASP Mobile Top 10 (M1–M10)
- [ ] Diseñar un pipeline CI/CD seguro (DevSecOps) integrando IaC y contenedores
- [ ] Decidir cuándo usar `rebase` vs `merge` en un flujo Git colaborativo sin romper ramas públicas

---

# Prácticas

## 🟢 Nivel 1 — Fundamentos

### Práctica 1 — Entorno PHP seguro con VS Code
**Objetivo:** Configurar un entorno de desarrollo PHP y aplicar validaciones básicas de seguridad.
**Qué practicar:** Validación de entradas, prevención de inyección de comandos y fuerza bruta.
**Herramientas:** VS Code, XAMPP/MAMP o Docker, PHP Intelephense.
**Tareas:**
1. Instalar PHP y configurar `php.validate.executablePath` en VS Code.
2. Crear un formulario que valide URLs contra un dominio permitido (whitelist).
3. Implementar un generador de códigos de acceso con expiración de 10 minutos (mitigación de fuerza bruta).
**Resultado esperado:** Script PHP funcional con validación de entradas, sin vulnerabilidades de inyección de comandos evidentes.
**Conceptos que refuerza:** Validación de entradas, principio de menor privilegio.

### Práctica 2 — Compilado vs interpretado: autenticación segura
**Objetivo:** Comparar Python, C++ y Java implementando un login con hashing de contraseñas.
**Qué practicar:** Compilación (`g++`), ejecución interpretada (`python3`), verificación de instalación Java.
**Herramientas:** g++, Python 3, JDK/JRE.
**Tareas:**
1. Implementar un login en los 3 lenguajes usando bcrypt para el hash de contraseña.
2. Compilar el ejemplo en C++ (`g++ -o ejecutable helloWorld.cpp`).
3. Comparar tiempos de ejecución y portabilidad.
**Resultado esperado:** Tres implementaciones equivalentes, ninguna almacena contraseñas en texto plano.
**Conceptos que refuerza:** Lenguajes compilados/interpretados/híbridos, hashing seguro.

### Práctica 3 — Automatización con Selenium
**Objetivo:** Automatizar la detección de vulnerabilidades web básicas.
**Qué practicar:** Grabación de scripts, manipulación de parámetros URL.
**Herramientas:** Selenium IDE / WebDriver.
**Tareas:**
1. Grabar un script `.side` que navegue por `testphp.vulnweb.com`.
2. Modificar el parámetro `artist=1` en la URL para detectar SQLi.
3. Probar credenciales `test/test` para autenticación débil.
**Resultado esperado:** Script Selenium reproducible que documenta 2 vulnerabilidades encontradas.
**Conceptos que refuerza:** Pruebas dinámicas, caja negra, SQLi.

### Práctica 4 — Escribir tests con PHPUnit
**Objetivo:** Crear una suite de tests unitarios básica.
**Herramientas:** PHPUnit, Composer.
**Tareas:**
1. `composer require --dev phpunit/phpunit`.
2. Crear `CalculadoraTest.php` con al menos 4 aserciones distintas.
3. Ejecutar con `vendor/bin/phpunit`.
**Resultado esperado:** Suite de tests en verde con cobertura de casos límite.
**Conceptos que refuerza:** Testing unitario, patrón xUnit.

### Práctica 5 — Analizar un CVE real
**Objetivo:** Investigar y documentar una vulnerabilidad catalogada.
**Herramientas:** Wappalyzer, buscador de CVEs.
**Tareas:**
1. Usar Wappalyzer sobre una web (propia o de prueba) para identificar tecnologías.
2. Buscar un CVE conocido de alguna de esas tecnologías.
3. Documentar impacto, CVSS y parche recomendado.
**Resultado esperado:** Ficha de vulnerabilidad con estructura similar a CVE-2022-45269 del material.
**Conceptos que refuerza:** CVE, CVSS, gestión de dependencias.

### Práctica 6 — Primeros pasos con Git
**Objetivo:** Practicar el flujo básico local de Git.
**Herramientas:** Git CLI.
**Tareas:**
1. `git init`, crear `.gitignore`.
2. Modificar archivos y usar `git add`, `git commit -m`, `git status`, `git diff --staged`.
3. Consultar el historial con `git log --oneline --graph`.
**Resultado esperado:** Repositorio local con al menos 5 commits descriptivos.
**Conceptos que refuerza:** Working Directory, Staging Area, Local Repository.

---

## 🟡 Nivel 2 — Consolidación

### Práctica — Securizar una aplicación web (basada en Práctica 6 de U3)
**Objetivo:** Corregir las 13 vulnerabilidades trabajadas en clase sobre una app vulnerable.
**Contexto:** Aplicación web de laboratorio con SQLi, XSS, IDOR, SSRF, File Upload, etc.
**Herramientas:** Burp Suite, editor de código.
**Requisitos:** Acceso a la app vulnerable y a su código fuente.
**Tareas:**
1. Reproducir cada vulnerabilidad con Burp Suite (Repeater/Intruder).
2. Aplicar la contramedida correspondiente (sentencias preparadas, output encoding, RBAC, whitelist de uploads...).
3. Volver a probar con Burp para confirmar la corrección.
**Resultado esperado:** Informe con "antes/después" de cada vulnerabilidad.
**Conceptos practicados:** SQLi, XSS, IDOR, SSRF, File Upload, CSRF, Session Issues.
**Posibles ampliaciones:** Añadir un WAF (ModSecurity) delante de la app.

### Práctica — Laboratorios secDevLabs (por riesgo OWASP)
**Objetivo:** Recorrer los 10 laboratorios de secDevLabs, uno por cada riesgo OWASP A01–A09.
**Contexto:** Entorno Docker con apps vulnerables independientes.
**Herramientas:** Burp Suite, Docker, WPScan, searchsploit.
**Requisitos:** Docker instalado, dos usuarios de prueba.
**Tareas:**
1. `ecommerce-api` → IDOR cambiando el ID de ticket.
2. `golden-hat` → identificar CVE por cabecera `Via`.
3. `misconfig-wordpress` → enumerar usuarios + fuerza bruta + directorio expuesto.
4. `vinijr-blog` → XXE leyendo `/etc/passwd`.
5. `snake-pro` → analizar JWT y tráfico HTTP sin cifrar.
6. `gossip-world` → XSS almacenado.
7. `super-recovery-password` → enumeración de usuarios por diseño inseguro.
8. `saidajaula-monster` → escalada de privilegios manipulando cookie.
9. `amarelo-designs` → RCE vía deserialización Pickle.
10. `games-irados` → comprobar ausencia de logging ante fuerza bruta.
**Resultado esperado:** Documento con una PoC por laboratorio.
**Conceptos practicados:** Los 10 riesgos OWASP 2025 con evidencia práctica.
**Posibles ampliaciones:** Repetir el ejercicio con OWASP ZAP en lugar de Burp.

### Práctica — WebGoat (Práctica 5 de U2)
**Objetivo:** Completar el laboratorio oficial de OWASP documentando cada PoC.
**Contexto:** 44 PoC distribuidas en 19 categorías (TW01–TW19).
**Herramientas:** WebGoat, Burp Suite.
**Requisitos:** WebGoat instalado localmente.
**Tareas:**
1. Instalar WebGoat.
2. Completar y documentar al menos 10 PoC de distintas categorías.
3. Redactar un informe "Test de intrusión web" con cada PoC.
**Resultado esperado:** Informe de al menos 10 puntos sobre 11 posibles según la rúbrica del material.
**Conceptos practicados:** Metodología de pentesting documentado.
**Posibles ampliaciones:** Completar las 19 categorías completas.

### Práctica — Ramas y fusión en Git
**Objetivo:** Simular un flujo de trabajo con ramas divergentes.
**Contexto:** Repositorio compartido simulado en local.
**Herramientas:** Git CLI, VS Code.
**Requisitos:** Repositorio con al menos 2 commits en `main`.
**Tareas:**
1. Crear rama `feature/login`, hacer 2 commits.
2. Volver a `main`, hacer 1 commit adicional (provocar divergencia).
3. Fusionar con `git merge --no-ff` y resolver un conflicto provocado intencionalmente.
4. Repetir el ejercicio pero usando `git rebase` en vez de merge.
**Resultado esperado:** Historial con un merge commit y, en el segundo intento, historia lineal via rebase.
**Conceptos practicados:** Fast-forward, merge commit, rebase, resolución de conflictos.
**Posibles ampliaciones:** Publicar en un remoto (GitHub) y practicar `push`, `pull --rebase`, `fetch --prune`.

### Práctica — Análisis estático de InsecureShop.apk (Práctica 9 adaptada)
**Objetivo:** Encontrar credenciales hardcodeadas y componentes exportados inseguros.
**Contexto:** InsecureShop.apk, app Android deliberadamente vulnerable.
**Herramientas:** JADX, Drozer, ADB.
**Requisitos:** Emulador/dispositivo Android con Drozer agent instalado.
**Tareas:**
1. Decompilar con `jadx-gui InsecureShop.apk` y buscar credenciales/API keys.
2. `adb forward tcp:31415 tcp:31415` + `drozer console connect`.
3. `run app.package.attacksurface com.insecureshopapp` para listar componentes exportados.
4. Lanzar una Activity exportada directamente para saltar el login.
**Resultado esperado:** Informe con al menos 2 hallazgos del OWASP Mobile Top 10.
**Conceptos practicados:** M1 (credenciales), M3 (auth/authz), análisis estático/dinámico.
**Posibles ampliaciones:** Repetir el análisis con Bytecode Viewer y comparar resultados con JADX.

---

## 🔴 Nivel 3 — Avanzado

### Proyecto 1 — Pentest completo de una app web propia
**Objetivo:** Auditar de extremo a extremo una aplicación web desarrollada por el propio alumno.
**Problema a resolver:** Detectar y corregir vulnerabilidades reales antes de un despliegue a producción.
**Tecnologías:** PHP/Python + base de datos SQL, HTTPS.
**Requisitos:** Aplicación funcional con formularios, login y al menos una API.
**Funcionalidades mínimas:**
- [ ] Pentest manual con Burp Suite cubriendo el OWASP Top Ten 2025
- [ ] Corrección de al menos 5 vulnerabilidades encontradas
- [ ] Suite de tests PHPUnit/PyTest que cubra las correcciones
**Funcionalidades opcionales:**
- [ ] Integrar un WAF (ModSecurity)
- [ ] Automatizar el pentest básico con OWASP ZAP en un pipeline CI
**Criterios de éxito:**
- [ ] Informe de pentest con hallazgos clasificados por riesgo OWASP
- [ ] Evidencia de "antes/después" de cada corrección
- [ ] Repositorio Git con historial de commits trazable de cada fix
**Conceptos que se practican:** SDLC completo, OWASP Top Ten, testing, Git.

### Proyecto 2 — Troyanización y análisis forense de un APK (Prácticas 7-9 integradas)
**Objetivo:** Recorrer el ciclo completo de creación, ocultación y detección de malware Android.
**Problema a resolver:** Entender cómo se inyecta malware en una app legítima y cómo detectarlo.
**Tecnologías:** Android, Metasploit, Smali.
**Requisitos:** Entorno de laboratorio aislado (VM), APK legítimo de prueba.
**Funcionalidades mínimas:**
- [ ] Generar payload con `msfvenom` y troyanizar un APK legítimo con Apktool
- [ ] Instalar y recibir sesión Meterpreter
- [ ] Analizar el APK resultante con Bytecode Viewer o JADX para localizar el hook malicioso
- [ ] Documentar los permisos añadidos en `AndroidManifest.xml`
**Funcionalidades opcionales:**
- [ ] Analizar con Drozer la superficie de ataque resultante
- [ ] Proponer una firma/regla de detección (YARA-like) basada en los hallazgos
**Criterios de éxito:**
- [ ] Informe técnico con evidencias de cada fase (generación, instalación, análisis)
- [ ] Explicación clara del vector de infección y cómo mitigarlo (firma de apps, permisos mínimos)
**Conceptos que se practican:** M2/M7/M9 del OWASP Mobile Top 10, ingeniería inversa, análisis estático y dinámico.

### Proyecto 3 — Flujo Git + CI/CD seguro de extremo a extremo
**Objetivo:** Montar un pipeline DevSecOps completo sobre un proyecto propio.
**Problema a resolver:** Automatizar pruebas y despliegue seguro evitando publicar vulnerabilidades.
**Tecnologías:** Git, GitHub Actions/Jenkins, Docker.
**Requisitos:** Repositorio Git con ramas `main` y `develop`, Dockerfile del proyecto.
**Funcionalidades mínimas:**
- [ ] Flujo de ramas con Pull Requests y revisión antes de fusionar a `main`
- [ ] Pipeline CI que ejecute los tests (PHPUnit/PyTest) en cada push
- [ ] Etapa de build de imagen Docker
**Funcionalidades opcionales:**
- [ ] Escaneo de dependencias con OWASP Dependency-Check en el pipeline
- [ ] Despliegue automático (CD) a un entorno de staging
**Criterios de éxito:**
- [ ] Historial de Git limpio (rebase antes de fusionar features)
- [ ] Pipeline que falla si los tests no pasan
- [ ] Documentación de la configuración `~/.gitconfig` y del pipeline usada
**Conceptos que se practican:** Git avanzado, CI/CD, DevSecOps, IaC básica.

---

# Proyecto final

## Proyecto final — "Auditoría y hardening de una aplicación web con backend móvil"
**Objetivo:** Demostrar el dominio integral de la asignatura: desarrollo seguro, normativa OWASP/CVE, pentest web y móvil, y flujo Git/DevOps.

**Problema que resuelve:** Simula el ciclo real de una empresa que desarrolla una app web (con API) y una app Android cliente, y necesita certificar que ambas son seguras antes de producción.

**Tecnologías utilizadas:** PHP o Python (backend + API), Android (cliente), Git, Docker, Burp Suite, JADX/Drozer.

**Conocimientos necesarios:** SDLC, OWASP Top Ten y ASVS, testing (PHPUnit/PyTest + caja blanca), Git avanzado, análisis estático/dinámico Android.

**Funcionalidades mínimas:**
- API REST con autenticación JWT y al menos un endpoint con control de acceso basado en roles.
- App Android cliente que consuma la API (o app de prueba tipo InsecureShop reutilizada).
- Suite de tests (PHPUnit/PyTest) con al menos 10 casos, incluyendo un caso diseñado con el método del camino básico (CFG + complejidad ciclomática).
- Informe de pentest web (Burp Suite) cubriendo mínimo 5 categorías del OWASP Top Ten 2025.
- Informe de análisis Android (JADX + Drozer) cubriendo mínimo 3 categorías del OWASP Mobile Top 10.
- Historial Git con ramas por funcionalidad, mínimo un merge y un rebase documentados.

**Funcionalidades avanzadas:**
- Pipeline CI que ejecute los tests automáticamente en cada push.
- WAF delante de la API (ModSecurity/Cloudflare).
- Certificate pinning en la app Android.

**Entregables:**
1. Repositorio Git con el código y el historial completo.
2. Informe de pentest web (formato similar al "Test de intrusión web" de WebGoat).
3. Informe de análisis móvil.
4. Documento `~/.gitconfig` y descripción del flujo de ramas usado.

**Criterios para considerar que está bien realizado:**
- Cada vulnerabilidad reportada tiene evidencia (captura/PoC) y su corrección verificada.
- Los tests cubren tanto casos válidos como casos límite (caja blanca).
- El historial de Git es legible y sigue una convención de ramas coherente.

**Posibles ampliaciones:** Añadir IaC (Ansible/Terraform) para desplegar el entorno completo de forma reproducible, o contenerizar todo el stack con Docker Compose.

---

# Ruta de aprendizaje

```text
01. Fundamentos (SDLC, principios de seguridad) — U1
       ↓
02. Lenguajes y entornos de desarrollo — U1
       ↓
03. Pruebas de software y caja blanca + PHPUnit — U1
       ↓
04. Práctica básica (Prácticas 1-6 Nivel 1)
       ↓
05. Normativa: CVE, OWASP, ASVS — U2
       ↓
06. Burp Suite + laboratorios secDevLabs/WebGoat — U2
       ↓
07. Vulnerabilidades y contramedidas web — U3
       ↓
08. Práctica intermedia (securizar app web, secDevLabs)
       ↓
09. Arquitectura y seguridad móvil — U4
       ↓
10. Prácticas 7-9 (troyanización, análisis estático/dinámico Android)
       ↓
11. Git (en paralelo desde el inicio, se consolida aquí)
       ↓
12. DevOps, CI/CD, virtualización, puesta en producción — U5
       ↓
13. Proyecto final integrador
```

**Explicación breve de cada etapa:**
1–3. Sienta las bases teóricas: ciclo de vida, lenguajes, cómo probar el software.
4. Primer contacto práctico con las herramientas (VS Code, PHPUnit, Selenium, Git).
5–6. Se aprende a "hablar el idioma" de la seguridad (CVE, OWASP) y a usar Burp Suite.
7–8. Aplicación intensiva sobre vulnerabilidades web reales en laboratorios controlados.
9–10. Traslado de los mismos principios al mundo móvil (Android/iOS).
11. Git se practica en paralelo desde el principio, pero se consolida con ejercicios de ramas/remotos.
12. Se integra todo en un contexto DevOps/DevSecOps y de despliegue seguro.
13. El proyecto final obliga a combinar desarrollo, testing, pentest web y móvil, y Git/CI-CD.

---

# Cheat Sheet de la asignatura

| Tema | Conceptos clave | Herramientas | Recursos principales | Práctica |
|---|---|---|---|---|
| U1 — Fundamentos | SDLC, defensa en profundidad, CFG, complejidad ciclomática | VS Code, PHPUnit, Selenium | ⚠️ No indicados | Entorno PHP + tests + Selenium |
| U2 — Normativa | CVE/CVSS, OWASP Top Ten 2025, ASVS (3 niveles) | Burp Suite, Wappalyzer, WebGoat | ⚠️ No indicados | Laboratorios secDevLabs |
| U3 — Web | CSRF, XSS, SQLi, IDOR, JWT, WAF, headers HTTP | Burp Suite, reCAPTCHA | ⚠️ No indicados | Securizar app web (13 vulns) |
| U4 — Móvil | Dalvik/ART, permisos, OWASP Mobile Top 10, DIVA | Metasploit, Apktool, JADX, Drozer | ⚠️ No indicados | Troyanizar + analizar APK |
| Git | Working Dir/Staging/Repo, merge, rebase, remotos | Git CLI, GitHub/GitLab | ⚠️ No indicados | Flujo completo con ramas |
| DevOps/U5 | CI/CD, IaC, virtualización, DevSecOps | Jenkins, Ansible, Docker, Kubernetes | ⚠️ No indicados | Pipeline seguro |

---