Ver la versión completa : Explotación de Windows, pasado, presente y futuro
Windows, uno de los sistemas operativos más extendidos en ordenadores personales del momento. Empezamos una serie de artículos donde iremos viendo la evolución tanto de los métodos para explotar fallos encontrados en el sistema, como de las protecciones para prevenir estos fallos y evitar sus consecuencias.
Esta saga de artículos está basada en otra recopilación, pero modificada y adaptada a otro estilo. ¿Preparados para recordar tiempos pasados? ¡Seguro que a más de uno le saldrá la vena romántica!
Aviso que puede que me deje cosas, algunas importantes. Por ello, lo digo de antemano y pido disculpas desde ya. Ahora, ¡a disfrutarlo!
Nos centraremos en el sistema operativo de Microsoft, pero para ello tendremos que tratar temas que no están exclusivamente relacionados con él. Para comenzar vamos a ver una breve historia de los buffer overflow (https://secure.wikimedia.org/wikipedia/es/wiki/Desbordamiento_de_b%C3%BAfer), y lo que han significado desde sus inicios.
Hace algún tiempo, en 1988, el gusano Morris (https://secure.wikimedia.org/wikipedia/es/wiki/Gusano_Morris) empezó a extenderse por Internet, y tuvo mucha cobertura en los medios de comunicación de la época. Fue el primer gusano conocido en explotar vulnerabilidades de desbordamiento de buffer para propagarse, concretamente explotaba fallos conocidos en Unix sendmail, Finger y rsh/rexec, además de contraseñas débiles.
Poco después, en 1996, Elias Levy (Aleph One) escribió Smashing The Stack For Fun And Profit (http://www.phrack.org/issues.html?id=14&issue=49) para Phrack (http://www.phrack.org/) issue #49, documento mítico y de referencia para muchos.
Por otro lado, tres años más tarde Matt Conover escribía el primer artículo (http://www.w00w00.org/files/articles/heaptut.txt) detallado acerca de heap overflow (https://secure.wikimedia.org/wikipedia/en/wiki/Heap_overflow). Al año siguiente, Solar Designer publicaría el primer exploit genérico para Windows basado en un heap overflow (Netscape exploit (http://www.openwall.com/articles/JPEG-COM-Marker-Vulnerability)).
En esta época, los sistemas operativos contaban con pocas protecciones de memoria y una pobre validación en la entrada de datos. El uso de una función vulnerable era suficiente para abusar de la memoria (normalmente en la pila) y tomar el control del flujo del programa, con lo que un atacante podría ejecutar su propio código.
Era algo que traía de cabeza a los desarrolladores de sistemas operativos. En 1996, Casper Dik escribió un parche (http://seclists.org/bugtraq/1996/Nov/57) que modificaba en tiempo de ejecución la imagen del kernel para que la pila no tuviese permisos de ejecución en Solaris 2.4 a 2.5.1. Poco después Solar Designer escribió algo parecido para Linux (http://marc.info/?m=87602167420762).
Cerca del año 2000, Solar Designer volvía con algo nuevo, ataques return-to-libc (https://secure.wikimedia.org/wikipedia/en/wiki/Return-to-libc_attack). Se trataba de usar funciones cargadas en memoria para saltar la protección que hacía la pila no ejecutable, así podía usar funciones como system() (para ejecutar un comando), pero por otro lado tenía el inconveniente de que no podría usar shellcodes (https://secure.wikimedia.org/wikipedia/es/wiki/Shellcode) avanzados.
Nos quedamos en el año 2000 con:
stack overflows (https://secure.wikimedia.org/wikipedia/en/wiki/Stack_buffer_overflow) básicos / intermedios.
heap overflows (https://secure.wikimedia.org/wikipedia/en/wiki/Heap_overflow) básicos.
ataques format string (https://secure.wikimedia.org/wikipedia/en/wiki/Format_string_attack) básicos / intermedios.
protecciones de memoria básicas.
bypass de protecciones de memoria básicos.
¡En el próximo artículo entraremos de lleno en el año 2000!
Sobre las referencias y fuentes, están todas an el tercer post (última parte), así como la recopilación original.
Continuamos con esta serie de artículos, y nos metemos en el año 2000. Empezamos con Windows 2000, a partir del cual vienen cosas muy interesantes.
Podríamos llamar a esta época la edad de oro de los desarrolladores de exploits ya que, desgraciadamente, Microsoft olvidó implementar una protección contra buffer overflow en sus sistemas. Los ataques clásicos funcionaban genial, y vemos en muy contadas ocasiones vulnerabilidades complejas, aunque la explotación en sí no era complicada.
Debido a estas pobres protecciones nos encontramos con virus (gusanos) de los que se habló bastante en su momento, y tuvieron una fuerte repercusión.
Por ejemplo, el gusano Sasser (https://secure.wikimedia.org/wikipedia/en/wiki/Sasser_%28computer_worm%29), que explotaba un fallo en LSASS; SQL Slammer (https://secure.wikimedia.org/wikipedia/en/wiki/SQL_Slammer), que utilizaba otro fallo en SQL Server; u el conocidísimo Blaster (https://secure.wikimedia.org/wikipedia/es/wiki/Blaster) que explotaba un fallo en el servicio DCOM RPC, y además incluía un mensaje dedicado:
billy gates why do you make this possible ? Stop making money
and fix your software!!
También tenemos exploits clásicos y muy funcionales:
DCOM RCP exploit (http://www.exploit-db.com/exploits/103) por flashsky (de xfocus).
MS Windows (RPC DCOM) exploit (http://www.exploit-db.com/exploits/66) por HD Moore (Metasploit).
Kill Bill exploit (http://www.phreedom.org/solar/exploits/msasn1-bitstring/) por Alexander Sotirov.
MS Windows Plug-and-Play exploit (http://www.exploit-db.com/exploits/1149) por houseofdabus.
Además nos encontramos con algunas herramientas gráficas, como el conocido SMBdie (http://packetstormsecurity.org/0208-exploits/SMBdie.zip) que podía producir un cuelgue inmediato en cualquier sistema vulnerable.
http://4.bp.blogspot.com/_EjEMMY_-ciA/TKNSBfiGM-I/AAAAAAAAA3M/WvG5Aj-8tcs/s320/smbdie.png (http://4.bp.blogspot.com/_EjEMMY_-ciA/TKNSBfiGM-I/AAAAAAAAA3M/WvG5Aj-8tcs/s1600/smbdie.png)
Acerca de stack overflows clásicos hay algunos papers muy buenos y muy bien documentados:
Win32 Buffer Overflows (Location, Exploitation and Prevention) (http://www.phrack.com/issues.html?issue=55&id=15#article) por dark spyrit en 1999.
S.K Chong Win32 Stack Based Buffer Overflow Walkthrough (http://www.scan-associates.net/papers/win32_bo_walkthrough.txt) en 2002.
Las series de Nish Bhalla’s de Writing Stack Based Overflows (http://www.packetstormsecurity.org/papers/win/) on Windows en 2005.
También tenemos algunos sobre heap overflows clásicos:
Third Generation Exploitation, Smashing the Heap under Win2k (http://www.blackhat.com/presentations/win-usa-02/halvarflake-winsec02.ppt) por Halvar Flake en 2002.
Exploiting the MSRPC Heap Overflow (http://freeworld.thc.org/root/docs/exploit_writing/msrpcheap.pdf) (parte 2 (http://freeworld.thc.org/root/docs/exploit_writing/msrpcheap2.pdf)) por Dave Aitel en 2003.
El detallado trabajo (https://www.blackhat.com/presentations/win-usa-04/bh-win-04-litchfield/bh-win-04-litchfield.ppt) de David Litchfield en la Black Hat 2004.
Si cambiamos de área, hay un extenso trabajo en cuanto a vulnerabilidades basadas en el propio kernel de Windows (ya no tan clásicas):
El primer paper importante sobre este tema viene de la mano de un grupo Polaco llamado Sec-Labs, cerca del año 2003 (whitepaper (http://www.artofhacking.com/tucops/hack/windows/live/aoh_win32dcv.htm), exploit (http://www.securityfocus.com/bid/8329/info)).
Windows Local Kernel Exploitation (http://www.packetstormsecurity.org/hitb04/hitb04-sk-chong.pdf) por S.K Chong en 2004 (basado en el trabajo de Sec-Labs).
How to exploit Windows kernel memory pool (http://packetstormsecurity.nl/Xcon2005/Xcon2005_SoBeIt.pdf) en 2005 por SoBeIt.
Remote Windows Kernel Exploitation, Step into the Ring 0 (http://research.eeye.com/html/papers/download/StepIntoTheRing.pdf) por Eeye Security en 2005.
Exploiting 802.11 Wireless Driver Vulnerabilities on Windows (http://www.uninformed.org/?v=6&a=2&t=pdf) por Johnny Cache, HD Moore y Matt Miller en 2006.
Attacking the Windows Kernel (https://www.blackhat.com/presentations/bh-usa-07/Lindsay/Whitepaper/bh-usa-07-lindsay-WP.pdf) por Jonathan Lindsay en BH US 2007.
Remote and Local Exploitation of Network Drivers (http://www.blackhat.com/presentations/bh-usa-07/Bulygin/Presentation/bh-usa-07-bulygin.pdf) por Yuriy Bulygin en BH US 2007.
Exploiting Common Flaws In Drivers (http://www.reversemode.com/index.php?option=com_content&task=view&id=38&Itemid=1), por Rubén Santamarta (@reversemode (https://twitter.com/reversemode)) en 2007.
I2OMGMT Driver Impersonation Attack por Justin Seitz (http://www.immunityinc.com/downloads/DriverImpersonationAttack_i2omgmt.pdf) en 2008, donde habla de un nuevo tipo de ataques en el kernel y el fallo en i2omgmt.sys, reportado por iDefense y descubierto por Rubén.
Real World Kernel Pool Exploitation (http://sebug.net/paper/Meeting-Documents/syscanhk/KernelPool.pdf) por Kostya Kortchinsky en 2008, donde habla sobre como escribió el exploit para ms08-001 (https://www.microsoft.com/technet/security/bulletin/ms08-001.mspx).
There's a party at ring0... (...and you're invited) (http://www.cr0.org/paper/to-jt-party-at-ring0.pdf) por Tavis Ormandy y Julien Tinnes.
GDT and LDT in Windows kernel vulnerability exploitation (http://vexillium.org/dl.php?call_gate_exploitation.pdf) por Matthew “j00ru” Jurczyk y Gynvael Coldwind (Hispasec).
Después de todo esto, volvemos al área de trabajo del usuario con ¡protecciones de memoria!
Debido a todos los abusos del sistema que hemos visto antes (tanto gusanos, como ténicas de explotación), Microsoft decide implementar protecciones de memoria. A partir de Windows XP SP2 (Windows XP Tablet PC Edition 2005), Windows Server 2003 SP1 (nivel de SO) y Visual Studio 2003 (nivel de compilador) estas protecciones empiezan a ser utilizadas.
Vamos a ver un resumen de ellas:
DEP (Data Execution Prevention), una medida implementada en los sistemas modernos de Microsoft que está pensada para evitar que las aplicaciones ejecuten código de una región de memoria no ejecutable. Ayuda a prevenir algunos exploits que almacenan código gracias a, por ejemplo, un buffer overflow. Puede ser implementada mediante hardware (CPUs que permiten marcar páginas de memoria como no ejecutables) o vía software (para CPUs que no tienen soporte). Más información sobre DEP aquí (http://support.microsoft.com/kb/875352).
/GS (Buffer Security Check), es una opción de compilación añadida desde Visual Studio 2003 para prevenir buffer overruns que sobreescriben la dirección de retorno. La protección se basa en poner una cookie entre el buffer y la dirección de retorno, de forma que si se sobreescribe esta cookie la comprobación falle y se termine el proceso. Información más detallada aquí (http://msdn.microsoft.com/en-us/library/Aa290051).
/SAFESEH (Image has Safe Exception Handlers), otra opción de compilación añadida en Visual Studio 2005. Información detallada aquí (http://msdn.microsoft.com/en-us/library/9a89h429%28VS.80%29.aspx).
ASLR (Address Space Layout Randomization), implementado en Windows Vista, Server 2008 y Windows 7. Se basa en hacer aleatorias las direcciones clave de la memoria (ejecutables, DLLs, heap, stack), de forma que nunca sean las mismas. Hay mucha información sobre esta medida, teneis más aquí (https://secure.wikimedia.org/wikipedia/en/wiki/Address_space_layout_randomization) y aquí (http://blogs.msdn.com/michael_howard/archive/2006/05/26/address-space-layout-randomization-in-windows-vista.aspx).
SEHOP, usado en los sistemas Windows más modernos (como 2008 y 7). La idea detrás de esta medida viene del artículo de Matt Miller, Preventing the Exploitation of Structured Exception Handler (SEH) Overwrites with SEHOP (http://blogs.technet.com/srd/archive/2009/02/02/preventing-the-exploitation-of-seh-overwrites-with-sehop.aspx).
Heap Protections, Microsoft también ha introducido algunas protecciones nuevas de heap, como heap meta cookie, safe unlinking ...
Por último, se me hace difícil terminar esta parte sin hacer referencia a EMET (http://blogs.technet.com/b/srd/archive/2010/09/02/enhanced-mitigation-experience-toolkit-emet-v2-0-0.aspx) (ya en su versión 2.0), un toolkit del cual Fermín J.Serna (@fjserna (https://twitter.com/fjserna)) tiene cierta culpa y que permite a los usuarios implementar estas tecnologías en aplicaciones arbitrarias (especialmente de terceros), lo que ayuda a evitar que sean explotadas. Podeis ver la presentación que hizo Fermín en la RootedCON 2010 sobre el toolkit aquí (http://www.slideshare.net/rootedcon/fermin-j-serna-exploits-mitigations-emet-rootedcon-2010), y aquí (http://blogs.technet.com/b/srd/archive/2010/09/10/use-emet-2-0-to-block-the-adobe-0-day-exploit.aspx) un ejemplo de como EMET 2.0 puede bloquear un exploit para Adobe Reader.
http://blogs.technet.com/cfs-filesystemfile.ashx/__key/CommunityServer-Blogs-Components-WeblogFiles/00-00-00-61-47/1803.EMT-v2-GUI.png (http://blogs.technet.com/cfs-filesystemfile.ashx/__key/CommunityServer-Blogs-Components-WeblogFiles/00-00-00-61-47/1803.EMT-v2-GUI.png)
Dentro de poco la tercera y última entrega, donde veremos la respuesta de los investigadores de seguridad a estas protecciones, e intentaremos hacer una predicción de lo que nos espera en este campo de la seguridad.
En la última entrega de la serie vamos a ver explotación avanzada de Windows, saltando los filtros y las protecciones que nombramos en la entrega anterior.
Desde el 2005 en adelante la explotación se volvió cada vez más difícil, y el número de investigadores que pudieron hacer exploits fiables para los sistemas operativos modernos de Microsoft fue bastante bajo.
Por norma general, estos trabajos son más complejos, y el contenido mucho más avanzado.
Vamos a ver los más importantes contra estas protecciones.
Third Generation Exploitation (Smashing the Heap under Win2k) (http://www.blackhat.com/presentations/win-usa-02/halvarflake-winsec02.ppt) por Halvar Flake en 2002.
Creating Arbitrary Shellcode In Unicode Expanded Strings (http://www.net-security.org/dl/articles/unicodebo.pdf) por Chris Anley, fue el primer artículo acerca de shellcodes basadas en Unicode. El método explicado es lo suficientemente bueno como para hacer (pobres) shellcodes en ASCII.
Advanced Windows Exploitation (http://www.immunityinc.com/downloads/immunity_win32_exploitation.final2.ppt) por Dave Aitel en 2003, donde se habla de temas no tan clásicos, y la labor se empieza a hacer más complicada.
Defeating the Stack Based Buffer Overflow Prevention Mechanism of Microsoft Windows 2003 Server (http://www.ngssoftware.com/papers/defeating-w2k3-stack-protection.pdf) por David Litchfield es el primer paper donde se abusa de la protección SEH y se expone un método genérico para saltar /GS. Probablemente sea uno de los aportes más importantes.
Windows Heap Exploitation (Win2KSP0 through WinXPSP2) (http://cybertech.net/~sh0ksh0k/projects/winheap/XPSP2%20Heap%20Exploitation.ppt) por Matt Conover.
Safely Searching Process Virtual Address Space (http://www.hick.org/code/skape/papers/egghunt-shellcode.pdf) por Matt Miller en 2004 es el primer artículo donde se habla de "egg-hunter (https://secure.wikimedia.org/wikipedia/en/wiki/Shellcode#Staged)" shellcode.
En 2004 Skylined escribe un exploit para IE (http://www.exploit-db.com/exploits/612) donde usa una tecnología llamada Heap Spray (http://sf-freedom.blogspot.com/2006/06/heap-spraying-introduction.html).
Bypassing Windows Hardware-enforced Data Execution Prevention (http://www.uninformed.org/?v=2&a=4&t=pdf) por skape (Matt Miller) y Skywing (Ken Johnson) en 2005, donde se salta la protección mediante un ataque del estilo return-to-libc.
Exploiting Freelist[0] On XP Service Pack 2 (http://www.orkspace.net/secdocs/Windows/Protection/Bypass/Exploiting%20Freelist%5B0%5D%20On%20XP%20Service%2 0Pack%202.pdf) por Brett Moore en 2005.
Kernel-mode Payloads on Windows (http://www.uninformed.org/?v=3&a=4&t=pdf) por bugcheck y skape (Matt Miller) en 2005, un paper donde se explica como portar exploits al área del kernel (kernel-land).
Exploiting 802.11 Wireless Driver Vulnerabilities on Windows (http://www.uninformed.org/?v=6&a=2&t=pdf) por Johnny Cache, HD Moore y Matt Miller.
Heap Feng Shui in JavaScript (http://www.blackhat.com/presentations/bh-europe-07/Sotirov/Presentation/bh-eu-07-sotirov-apr19.pdf) por Alexander Sotirov en 2007.
Understanding and bypassing Windows Heap Protection (http://kkamagui.springnote.com/pages/1350732/attachments/579350) por Nicolas Waisman en 2007.
Heaps About Heaps (http://www.insomniasec.com/publications/Heaps_About_Heaps.ppt) por Brett Moore en 2008, un extenso trabajo sobre heap.
Bypassing Browser Memory Protections (http://taossa.com/archive/bh08sotirovdowd.pdf) por Alexander Sotirov y Mark Dowd en 2008, un gran trabajo centrado en saltar protecciones de memoria de los navegadores en Vista.
Attacking the Vista Heap (http://www.ruxcon.org.au/files/2008/hawkes_ruxcon.pdf) por Ben Hawkes en 2008, donde se habla de internals en el heap de Vista y como saltar sus protecciones.
Return-oriented Programming: Exploitation without Code Injection (http://cseweb.ucsd.edu/~hovav/dist/blackhat08.pdf) por Hovav Shacham y otros en 2008.
Token Kidnapping (http://www.argeniss.com/research/TokenKidnapping.pdf) por Cesar Cerrudo en 2008.
Defeating DEP, the Immunity Debugger way (http://www.immunityinc.com/downloads/DEPLIB.pdf) por Pablo Solé en 2008 es la primera automatización de ROP.
Practical Windows XP/2003 Heap Exploitation (http://www.blackhat.com/presentations/bh-usa-09/MCDONALD/BHUSA09-McDonald-WindowsHeap-PAPER.pdf) por John McDonald y Chris Valasek en 2009.
Interpreter Exploitation: Pointer Inference and JIT Spraying (http://www.semantiscope.com/research/BHDC2010/BHDC-2010-Paper.pdf) (slides (http://www.semantiscope.com/research/BHDC2010/BHDC-2010-Slides-v2.pdf)) por Dionysus Blazakis en 2010, un método de explotación genérico para saltar DEP y ASLR juntos.
Releasing a 0day at RootedCON: The Case of Consona/SupportSoft (http://wintercore.com/downloads/rootedcon_0day_english.pdf) por Rubén Santamarta donde se vió como saltar el filtro de XSS en IE y el modo protegido. No está relacionado directamente con explotación, pero es muy útil para combinarlo con otras técnicas.
Viendo la evolución y la cantidad de trabajos buenos que se han publicado en los últimos años se podría hacer una pequeña predicción de un futuro próximo.
La explotación no está muriendo ni va a morir.
Se está volviendo más difícil, y no será "solo por diversión" como antes.
Escribir exploits fiables llevará más y más tiempo, lo que equivale a dinero. El desarrollo de exploits es un área de trabajo aceptable en seguridad.
Si lees y entiendes todos los paper de estas entregas, posiblemente podrás formar parte de este futuro :)
Publicado por Alberto Ortega en http://www.securitybydefault.com/2010/09/explotacion-de-windows-pasado-presente.html