Skip to content

0x800_conclusion.md

Latest commit

 

History

History
99 lines (75 loc) · 6.29 KB

0x800_conclusion.md

File metadata and controls

99 lines (75 loc) · 6.29 KB
Raw

0x800 — Conclusión

Erickson cierra el libro con una idea que vale más que todo el código que aparece en él:

Hacking no es un conjunto de técnicas — es una mentalidad de cuestionar las reglas y entender por qué existen.

Las técnicas envejecen rápido. El stack overflow del libro de 2008 ya no funciona en una distro moderna sin trabajo extra. Pero el patrón de razonamiento — "el programa asume X; ¿qué pasa si rompo X?" — es atemporal. La misma curiosidad que en 2008 encontraba strcpy sin bounds en demonios C, en 2026 encuentra prompt injections en pipelines de LLMs y type confusion en V8.

Mapa mental que me llevo del libro

                  ┌─────────────────────┐
                  │    Programación     │  ← entender memoria, punteros, syscalls
                  └──────────┬──────────┘
                             │
                  ┌──────────▼──────────┐
                  │     Exploitation    │  ← cualquier "input" mal validado puede convertirse en código
                  └──────────┬──────────┘
                             │
        ┌────────────────────┼────────────────────┐
        │                    │                    │
┌───────▼─────┐    ┌─────────▼──────┐    ┌────────▼──────┐
│ Networking  │    │   Shellcode    │    │  Cryptology   │
│ aprovechar  │    │ payload mínimo │    │  cuándo NO se │
│ los proto-  │    │ que abre shell │    │ puede romper, │
│ colos       │    │ o C2 channel   │    │ y cuándo sí   │
└─────────────┘    └────────────────┘    └───────────────┘
        │                    │                    │
        └────────────────────┼────────────────────┘
                             │
                  ┌──────────▼──────────┐
                  │   Countermeasures   │  ← cada defensa rompe una técnica anterior
                  └─────────────────────┘  ← y cada técnica nueva esquiva una defensa

Lo que el libro deja fuera (cosas que aprendí después)

El libro es de 2008. Estos campos crecieron mucho desde entonces y conviene anotarlos para el siguiente paso:

En binarios

  • ROP / JOP / SROP / Ret2dlresolve — explotación moderna sin shellcode.
  • Heap exploitation post-glibc 2.26 — tcache poisoning, House of Botcake, House of Force (parcheado en 2.29).
  • Use-after-free / type confusion en C++ — vtable hijacking, V8/JavaScriptCore exploits.
  • CFI (Control Flow Integrity) — clang -fsanitize=cfi, __cfi_check. Parcialmente esquivable con tipos compatibles.
  • CET (Indirect Branch Tracking + Shadow Stack) — hardware Intel Tiger Lake+ que rompe la mayoría de ROP clásico.
  • Sanitizers — ASan, UBSan, MSan, TSan. Ahora más útiles que GDB para encontrar bugs.

En web

  • IDOR, SSRF, XSS, CSRF, prototype pollution, deserialización (PHP/Java/Python).
  • OAuth bugs — redirect_uri abierto, code injection, PKCE bypass.
  • HTTP smuggling (CL.TE, TE.CL, H2.CL) — atacar la capa de proxies.
  • Cache poisoning — envenenar CDN/Varnish con headers raros.
  • GraphQL — introspection, query batching, resolver IDOR.

En cloud / infra

  • SSRF → IMDSv1 → AWS credentials. Los compromises grandes de Capital One, Tesla, etc.
  • Container escapes — runc CVE-2019-5736, cgroups release_agent, mount manipulation.
  • Kubernetes RBAC misconfig — service accounts con cluster-admin, secrets leakeados.
  • CI/CD attacks — runner ephemeral compromise, dependency confusion (typosquatting npm/pypi).

En IA / LLMs

  • Prompt injection — directo (en el input) e indirecto (en una página que el modelo lee).
  • Tool use exploitation — abusar de herramientas con privilegios excesivos.
  • Data exfiltration via markdown image rendering (zero-click).
  • OWASP Top 10 for LLMs y ASI01-ASI10 (agentic).

Todo esto sigue la misma idea del libro: encontrar dónde el sistema asume algo que no debería.

Proyectos para seguir aprendiendo

Recurso Para qué
PortSwigger Web Academy Web hacking, gratis y muy bueno.
HackTheBox / TryHackMe Máquinas vulnerables guiadas.
pwn.college Binary exploitation moderno (post-libro).
PicoCTF / Google CTF Retos por categorías.
Bug Bounty (HackerOne, Bugcrowd, Intigriti, Immunefi) Aplicar lo aprendido en programas reales.
CVE-2024-X writeups Ver cómo se encuentran y reportan vulnerabilidades reales.
Phrack Lectura clásica de exploitation. Buscar especialmente el texto de Aleph One sobre stack smashing.

Cómo seguir trabajando este repo

  • Por capítulo: releer el libro un capítulo a la vez, anotar en capitulos/<x>.md lo que añadiste a tu mental model, y subir nuevos codigo/<seccion>/*.c para los ejemplos que hagas.
  • Por bug class: dedicar una semana a un bug class moderno (HTTP smuggling, prototype pollution, V8 type confusion) y construir un mini-laboratorio en codigo/extra/<bug-class>/.
  • Por target: elegir un programa real con bugs históricos (sudo CVE-2021-3156, glibc CVE-2023-4911, etc.) y reproducir el exploit en una VM. Anotar en casos-reales/.

Cierre

El propósito del libro no es enseñar exploits. Es enseñar a leer un sistema con la sospecha sana de que sus diseñadores son humanos y los humanos se equivocan. La diferencia entre un usuario y un hacker es esa sospecha aplicada con paciencia: leer el código, leer el manual, probar el caso que el autor no probó, y no rendirse hasta entender exactamente qué pasa.

Si te crees todo lo que te dice un sistema, eres su usuario. Si dudas un poco, eres su tester. Si dudas mucho y persistes, eres su hacker.

— fin del libro —