enum qtn_flags { QTN_FLAG_DOWNLOAD = 0x0001, QTN_FLAG_SANDBOX = 0x0002, QTN_FLAG_HARD = 0x0004, QTN_FLAG_USER_APPROVED = 0x0040, };

#define qtn_proc_alloc _qtn_proc_alloc #define qtn_proc_apply_to_self _qtn_proc_apply_to_self #define qtn_proc_free _qtn_proc_free #define qtn_proc_init _qtn_proc_init #define qtn_proc_init_with_self _qtn_proc_init_with_self #define qtn_proc_set_flags _qtn_proc_set_flags #define qtn_file_alloc _qtn_file_alloc #define qtn_file_init_with_path _qtn_file_init_with_path #define qtn_file_free _qtn_file_free #define qtn_file_apply_to_path _qtn_file_apply_to_path #define qtn_file_set_flags _qtn_file_set_flags #define qtn_file_get_flags _qtn_file_get_flags #define qtn_proc_set_identifier _qtn_proc_set_identifier

typedef struct _qtn_proc *qtn_proc_t; typedef struct _qtn_file *qtn_file_t;

int qtn_proc_apply_to_self(qtn_proc_t); void qtn_proc_init(qtn_proc_t); int qtn_proc_init_with_self(qtn_proc_t); int qtn_proc_set_flags(qtn_proc_t, uint32_t flags); qtn_proc_t qtn_proc_alloc(); void qtn_proc_free(qtn_proc_t); qtn_file_t qtn_file_alloc(void); void qtn_file_free(qtn_file_t qf); int qtn_file_set_flags(qtn_file_t qf, uint32_t flags); uint32_t qtn_file_get_flags(qtn_file_t qf); int qtn_file_apply_to_path(qtn_file_t qf, const char *path); int qtn_file_init_with_path(qtn_file_t qf, const char path); int qtn_proc_set_identifier(qtn_proc_t qp, const char bundleid);

int main() {

qtn_proc_t qp = qtn_proc_alloc(); qtn_proc_set_identifier(qp, “xyz.hacktricks.qa”); qtn_proc_set_flags(qp, QTN_FLAG_DOWNLOAD | QTN_FLAG_USER_APPROVED); qtn_proc_apply_to_self(qp); qtn_proc_free(qp);

FILE *fp; fp = fopen(“thisisquarantined.txt”, “w+”); fprintf(fp, “Hello Quarantine\n”); fclose(fp);

return 0;

}

</details>

E **rimuovi** quell'attributo con:
```bash
xattr -d com.apple.quarantine portada.png
#You can also remove this attribute from every file with
find . -iname '*' -print0 | xargs -0 xattr -d com.apple.quarantine

E trova tutti i file in quarantena con:

find / -exec ls -ld {} \; 2>/dev/null | grep -E "[x\-]@ " | awk '{printf $9; printf "\n"}' | xargs -I {} xattr -lv {} | grep "com.apple.quarantine"

Le informazioni di quarantine sono anche memorizzate in un database centrale gestito da LaunchServices in ~/Library/Preferences/com.apple.LaunchServices.QuarantineEventsV2, che permette alla GUI di ottenere dati sull’origine dei file. Inoltre queste informazioni possono essere sovrascritte da applicazioni interessate a nascondere la loro origine. Inoltre, questo può essere fatto dalle LaunchServices APIS.

libquarantine.dylib

Questa libreria esporta diverse funzioni che consentono di manipolare i campi degli extended attribute.

Le API qtn_file_* gestiscono le policy di quarantine dei file, le API qtn_proc_* sono applicate ai processi (i file creati dal processo). Le funzioni non esportate __qtn_syscall_quarantine* sono quelle che applicano le policy e che chiamano mac_syscall con “Quarantine” come primo argomento, il quale invia le richieste a Quarantine.kext.

Quarantine.kext

L’estensione kernel è disponibile solo tramite la kernel cache on the system; tuttavia, puoi scaricare il Kernel Debug Kit from https://developer.apple.com/, che conterrà una versione simbolicata dell’estensione.

Questo Kext aggancerà, tramite MACF, diverse chiamate per intercettare tutti gli eventi del ciclo di vita dei file: creazione, apertura, rinomina, hard link… persino setxattr per impedirne l’impostazione dell’extended attribute com.apple.quarantine.

Usa inoltre un paio di MIB:

• security.mac.qtn.sandbox_enforce: Applica la quarantine anche nella Sandbox
• security.mac.qtn.user_approved_exec: I processi in quarantine possono eseguire solo file approvati

Provenance xattr (Ventura e successivi)

macOS 13 Ventura ha introdotto un meccanismo di provenance separato che viene popolato la prima volta che a un’app in quarantena viene permesso di avviarsi. Vengono creati due artefatti:

• L’xattr com.apple.provenance sulla directory del bundle .app (valore binario a dimensione fissa contenente una chiave primaria e flag).
• Una riga nella tabella provenance_tracking all’interno del database ExecPolicy in /var/db/SystemPolicyConfiguration/ExecPolicy/ che memorizza il cdhash dell’app e i metadati.

Utilizzo pratico:

# Inspect provenance xattr (if present)
xattr -p com.apple.provenance /Applications/Some.app | hexdump -C

# Observe Gatekeeper/provenance events in real time
log stream --style syslog --predicate 'process == "syspolicyd"'

# Retrieve historical Gatekeeper decisions for a specific bundle
log show --last 2d --style syslog --predicate 'process == "syspolicyd" && eventMessage CONTAINS[cd] "GK scan"'

XProtect

XProtect è una funzione anti-malware integrata in macOS. XProtect controlla ogni applicazione al primo avvio o quando viene modificata rispetto al suo database di malware noti e tipi di file non sicuri. Quando scarichi un file tramite alcune app, come Safari, Mail o Messages, XProtect scansiona automaticamente il file. Se corrisponde a un malware noto nel suo database, XProtect impedisce l’esecuzione del file e ti avverte della minaccia.

Il database di XProtect viene aggiornato regolarmente da Apple con nuove definizioni di malware, e questi aggiornamenti vengono scaricati e installati automaticamente sul tuo Mac. Ciò garantisce che XProtect sia sempre aggiornato rispetto alle minacce note più recenti.

Tuttavia, vale la pena notare che XProtect non è una soluzione antivirus completa. Controlla soltanto una lista specifica di minacce conosciute e non esegue scansioni in tempo reale come fanno la maggior parte dei software antivirus.

Puoi ottenere informazioni sull’ultimo aggiornamento di XProtect eseguendo:

system_profiler SPInstallHistoryDataType 2>/dev/null | grep -A 4 "XProtectPlistConfigData" | tail -n 5

XProtect si trova in una posizione protetta da SIP in /Library/Apple/System/Library/CoreServices/XProtect.bundle e all’interno del bundle puoi trovare le informazioni che XProtect usa:

• XProtect.bundle/Contents/Resources/LegacyEntitlementAllowlist.plist: Permette al codice con quei cdhash di usare entitlements legacy.
• XProtect.bundle/Contents/Resources/XProtect.meta.plist: Elenco di plugin e estensioni il cui caricamento è vietato tramite BundleID e TeamID oppure che indicano una versione minima.
• XProtect.bundle/Contents/Resources/XProtect.yara: Regole Yara per rilevare malware.
• XProtect.bundle/Contents/Resources/gk.db: Database SQLite3 con hash di applicazioni bloccate e TeamID.

Nota che esiste un’altra App in /Library/Apple/System/Library/CoreServices/XProtect.app relativa a XProtect che non è coinvolta nel processo di Gatekeeper.

XProtect Remediator: Su macOS moderni, Apple include scanner on-demand (XProtect Remediator) che vengono eseguiti periodicamente tramite launchd per rilevare e rimediare a famiglie di malware. Puoi osservare queste scansioni nei unified logs:

log show --last 2h --predicate 'subsystem == "com.apple.XProtectFramework" || category CONTAINS "XProtect"' --style syslog

Non Gatekeeper

Caution

Nota che Gatekeeper non viene eseguito ogni volta che esegui un’applicazione; solo AppleMobileFileIntegrity (AMFI) verificherà le firme del codice eseguibile quando esegui un’app che è già stata eseguita e verificata da Gatekeeper.

Quindi, in passato era possibile eseguire un’app per metterla in cache con Gatekeeper, poi modificare file non eseguibili dell’applicazione (come Electron asar o file NIB) e se non erano presenti altre protezioni, l’applicazione veniva eseguita con le aggiunte maligne.

Tuttavia, ora questo non è possibile perché macOS impedisce la modifica dei file all’interno dei bundle delle applicazioni. Quindi, se provi l’attacco Dirty NIB, scoprirai che non è più possibile abusarne perché dopo aver eseguito l’app per metterla in cache con Gatekeeper, non potrai modificare il bundle. E se cambi, ad esempio, il nome della directory Contents in NotCon (come indicato nell’exploit), e poi esegui il main binary dell’app per metterla in cache con Gatekeeper, verrà generato un errore e non verrà eseguita.

Bypass di Gatekeeper

Qualsiasi metodo per bypassare Gatekeeper (riuscire a far scaricare qualcosa all’utente ed eseguirlo quando Gatekeeper dovrebbe impedirlo) è considerato una vulnerabilità in macOS. Di seguito alcuni CVE assegnati a tecniche che in passato permettevano di bypassare Gatekeeper:

CVE-2021-1810

È stato osservato che se per l’estrazione viene usata Archive Utility, i file con percorsi che superano i 886 caratteri non ricevono l’attributo esteso com.apple.quarantine. Questa situazione permette involontariamente a quei file di circumventare i controlli di sicurezza di Gatekeeper.

Consulta il report originale per maggiori informazioni.

CVE-2021-30990

Quando un’applicazione viene creata con Automator, le informazioni su cosa deve eseguire sono all’interno di application.app/Contents/document.wflow e non nell’eseguibile. L’eseguibile è solo un binario Automator generico chiamato Automator Application Stub.

Perciò, era possibile far puntare application.app/Contents/MacOS/Automator\ Application\ Stub con un collegamento simbolico a un altro Automator Application Stub presente nel sistema ed eseguirà ciò che c’è dentro document.wflow (il tuo script) senza attivare Gatekeeper perché l’eseguibile reale non ha lo xattr di quarantine.

Esempio di percorso previsto: /System/Library/CoreServices/Automator\ Application\ Stub.app/Contents/MacOS/Automator\ Application\ Stub

Consulta il report originale per maggiori informazioni.

CVE-2022-22616

In questo bypass è stato creato un file zip con un’applicazione iniziando la compressione da application.app/Contents invece che da application.app. Di conseguenza, l’attributo quarantine è stato applicato a tutti i file in application.app/Contents ma non a application.app, che è ciò che Gatekeeper controllava, quindi Gatekeeper veniva bypassato perché quando application.app veniva avviata non aveva l’attributo di quarantine.

zip -r test.app/Contents test.zip

Check the original report per maggiori informazioni.

CVE-2022-32910

Anche se i componenti sono diversi, lo sfruttamento di questa vulnerabilità è molto simile a quello precedente. In questo caso verrà generato un Apple Archive da application.app/Contents, quindi application.app non riceverà l’attributo quarantine quando viene decompresso da Archive Utility.

aa archive -d test.app/Contents -o test.app.aar

Consulta il original report per maggiori informazioni.

CVE-2022-42821

L’ACL writeextattr può essere usata per impedire a chiunque di scrivere un attributo in un file:

touch /tmp/no-attr
chmod +a "everyone deny writeextattr" /tmp/no-attr
xattr -w attrname vale /tmp/no-attr
xattr: [Errno 13] Permission denied: '/tmp/no-attr'

Inoltre, il formato di file AppleDouble copia un file includendo i suoi ACEs.

Nel source code è possibile vedere che la rappresentazione testuale della ACL memorizzata dentro l’xattr chiamato com.apple.acl.text verrà impostata come ACL nel file decompressato. Quindi, se hai compresso un’applicazione in un file zip con il formato di file AppleDouble con una ACL che impedisce che altri xattr vengano scritti su di essa… la quarantine xattr non è stata impostata nell’applicazione:

chmod +a "everyone deny write,writeattr,writeextattr" /tmp/test
ditto -c -k test test.zip
python3 -m http.server
# Download the zip from the browser and decompress it, the file should be without a quarantine xattr

Consulta il original report per maggiori informazioni.

Nota che questo può anche essere sfruttato con AppleArchives:

mkdir app
touch app/test
chmod +a "everyone deny write,writeattr,writeextattr" app/test
aa archive -d app -o test.aar

CVE-2023-27943

Si è scoperto che Google Chrome non impostava il quarantine attribute sui file scaricati a causa di alcuni problemi interni di macOS.

CVE-2023-27951

I formati AppleDouble memorizzano gli attributi di un file in un file separato che inizia con ._, questo aiuta a copiare gli attributi dei file tra macchine macOS. Tuttavia, è stato osservato che dopo la decompressione di un file AppleDouble, il file che inizia con ._ non riceveva il quarantine attribute.

mkdir test
echo a > test/a
echo b > test/b
echo ._a > test/._a
aa archive -d test/ -o test.aar

# If you downloaded the resulting test.aar and decompress it, the file test/._a won't have a quarantitne attribute

Essendo possibile creare un file a cui non viene impostato l’attributo quarantine, era possible to bypass Gatekeeper. Il trucco era create a DMG file application usando la convenzione di nome AppleDouble (iniziarlo con ._) e creare un visible file as a sym link to this hidden file senza l’attributo quarantine.
Quando il dmg file is executed, poiché non ha l’attributo quarantine, esso bypass Gatekeeper.

# Create an app bundle with the backdoor an call it app.app

echo "[+] creating disk image with app"
hdiutil create -srcfolder app.app app.dmg

echo "[+] creating directory and files"
mkdir
mkdir -p s/app
cp app.dmg s/app/._app.dmg
ln -s ._app.dmg s/app/app.dmg

echo "[+] compressing files"
aa archive -d s/ -o app.aar

[CVE-2023-41067]

Un bypass di Gatekeeper risolto in macOS Sonoma 14.0 permetteva ad app appositamente create di essere eseguite senza richiesta. I dettagli sono stati divulgati pubblicamente dopo la patch e il problema è stato sfruttato attivamente nel mondo reale prima della correzione. Assicurarsi che sia installato Sonoma 14.0 o successivo.

[CVE-2024-27853]

Un bypass di Gatekeeper in macOS 14.4 (rilasciato marzo 2024) dovuto alla gestione da parte di libarchive di ZIP maligni permetteva alle app di eludere la valutazione. Aggiornare a 14.4 o successivo, dove Apple ha risolto il problema.

CVE-2024-44128

Un Automator Quick Action workflow incorporato in un’app scaricata poteva attivarsi senza la valutazione di Gatekeeper, perché i workflow venivano trattati come dati ed eseguiti dall’helper di Automator al di fuori del normale percorso del prompt di notarizzazione. Una .app appositamente creata che include una Quick Action che esegue uno shell script (es., dentro Contents/PlugIns/*.workflow/Contents/document.wflow) poteva quindi eseguirsi immediatamente al lancio. Apple ha aggiunto un dialogo di consenso aggiuntivo e ha corretto il percorso di valutazione in Ventura 13.7, Sonoma 14.7 e Sequoia 15.

Third‑party unarchivers mis‑propagating quarantine (2023–2024)

Diverse vulnerabilità in popolari tool di estrazione (es., The Unarchiver) facevano sì che i file estratti dagli archivi non ricevessero l’xattr com.apple.quarantine, permettendo opportunità di bypass di Gatekeeper. Affidarsi sempre a macOS Archive Utility o a tool patchati durante i test e verificare gli xattr dopo l’estrazione.

uchg (da questo talk)

• Crea una directory contenente un’app.
• Aggiungi uchg all’app.
• Comprimi l’app in un file tar.gz.
• Invia il file tar.gz a una vittima.
• La vittima apre il file tar.gz ed esegue l’app.
• Gatekeeper non controlla l’app.

Prevent Quarantine xattr

In un bundle “.app”, se l’xattr di quarantine non viene aggiunto, all’esecuzione Gatekeeper non verrà attivato.

Riferimenti

• Apple Platform Security: Informazioni sul contenuto di sicurezza di macOS Sonoma 14.4 (includes CVE-2024-27853) – https://support.apple.com/en-us/HT214084
• Eclectic Light: Come macOS ora traccia la provenienza delle app – https://eclecticlight.co/2023/05/10/how-macos-now-tracks-the-provenance-of-apps/
• Apple: Informazioni sul contenuto di sicurezza di macOS Sonoma 14.7 / Ventura 13.7 (CVE-2024-44128) – https://support.apple.com/en-us/121234
• MacRumors: macOS 15 Sequoia rimuove il bypass Gatekeeper “Control‑click ‘Open’” – https://www.macrumors.com/2024/06/11/macos-sequoia-removes-open-anyway/

Tip

Impara e pratica il hacking AWS:HackTricks Training AWS Red Team Expert (ARTE)
Impara e pratica il hacking GCP: HackTricks Training GCP Red Team Expert (GRTE) Impara e pratica il hacking Azure: HackTricks Training Azure Red Team Expert (AzRTE)

Supporta HackTricks

• Controlla i piani di abbonamento!
• Unisciti al 💬 gruppo Discord o al gruppo telegram o seguici su Twitter 🐦 @hacktricks_live.
• Condividi trucchi di hacking inviando PR ai HackTricks e HackTricks Cloud repos github.