From 8625e2a113478a1e3143d42a4e08c6d5438c5b9f Mon Sep 17 00:00:00 2001 From: Translator Date: Tue, 24 Sep 2024 15:18:13 +0000 Subject: [PATCH] Translated ['macos-hardening/macos-security-and-privilege-escalation/mac --- .../macos-sandbox/README.md | 229 ++++++++++++++---- .../macos-security-protections/macos-sip.md | 74 +++--- 2 files changed, 228 insertions(+), 75 deletions(-) diff --git a/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-sandbox/README.md b/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-sandbox/README.md index a820851cb..b6a9c2712 100644 --- a/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-sandbox/README.md +++ b/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-sandbox/README.md @@ -1,8 +1,8 @@ # macOS Sandbox {% 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) +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)
@@ -19,18 +19,20 @@ Learn & practice GCP Hacking: mach #Check mac-ports (got from launchd with an api) -sbtool file /tmp #Check file access -sbtool inspect #Gives you an explaination of the sandbox profile -sbtool all +{% code title="trace.sb" %} +```scheme +(version 1) +(trace /tmp/trace.out) ``` -### Custom SBPL nelle app dell'App Store +{% endcode %} + +E poi esegui semplicemente qualcosa utilizzando quel profilo: +```bash +sandbox-exec -f /tmp/trace.sb /bin/ls +``` +In `/tmp/trace.out` potrai vedere ogni controllo della sandbox eseguito ogni volta che è stato chiamato (quindi, molti duplicati). + +È anche possibile tracciare la sandbox utilizzando il parametro **`-t`**: `sandbox-exec -t /path/trace.out -p "(version 1)" /bin/ls` + +#### Via API + +La funzione `sandbox_set_trace_path` esportata da `libsystem_sandbox.dylib` consente di specificare un nome file di traccia in cui verranno scritti i controlli della sandbox.\ +È anche possibile fare qualcosa di simile chiamando `sandbox_vtrace_enable()` e poi ottenendo i log di errore dal buffer chiamando `sandbox_vtrace_report()`. + +### Ispezione della Sandbox + +`libsandbox.dylib` esporta una funzione chiamata sandbox\_inspect\_pid che fornisce un elenco dello stato della sandbox di un processo (inclusi le estensioni). Tuttavia, solo i binari della piattaforma possono utilizzare questa funzione. + +### Profili Sandbox di MacOS e iOS + +MacOS memorizza i profili della sandbox di sistema in due posizioni: **/usr/share/sandbox/** e **/System/Library/Sandbox/Profiles**. + +E se un'applicazione di terze parti porta il diritto _**com.apple.security.app-sandbox**_, il sistema applica il profilo **/System/Library/Sandbox/Profiles/application.sb** a quel processo. + +In iOS, il profilo predefinito si chiama **container** e non abbiamo la rappresentazione testuale SBPL. In memoria, questa sandbox è rappresentata come un albero binario di Permesso/Nego per ciascuna autorizzazione della sandbox. + +### SBPL personalizzato nelle app dell'App Store Potrebbe essere possibile per le aziende far funzionare le loro app **con profili Sandbox personalizzati** (invece di quello predefinito). Devono utilizzare il diritto **`com.apple.security.temporary-exception.sbpl`** che deve essere autorizzato da Apple. @@ -264,17 +278,140 @@ Potrebbe essere possibile per le aziende far funzionare le loro app **con profil ``` Questo **valuterà la stringa dopo questo diritto** come un profilo Sandbox. +### Compilazione e decompilazione di un profilo Sandbox + +Lo strumento **`sandbox-exec`** utilizza le funzioni `sandbox_compile_*` da `libsandbox.dylib`. Le principali funzioni esportate sono: `sandbox_compile_file` (si aspetta un percorso di file, parametro `-f`), `sandbox_compile_string` (si aspetta una stringa, parametro `-p`), `sandbox_compile_name` (si aspetta un nome di un contenitore, parametro `-n`), `sandbox_compile_entitlements` (si aspetta un plist di diritti). + +Questa versione invertita e [**open source dello strumento sandbox-exec**](https://newosxbook.com/src.jl?tree=listings\&file=/sandbox\_exec.c) consente di far scrivere a **`sandbox-exec`** in un file il profilo sandbox compilato. + +Inoltre, per confinare un processo all'interno di un contenitore, potrebbe chiamare `sandbox_spawnattrs_set[container/profilename]` e passare un contenitore o un profilo preesistente. + +## Debug e Bypass Sandbox + +Su macOS, a differenza di iOS dove i processi sono sandboxati fin dall'inizio dal kernel, **i processi devono optare per la sandbox da soli**. Ciò significa che su macOS, un processo non è limitato dalla sandbox fino a quando non decide attivamente di entrarvi, anche se le app dell'App Store sono sempre sandboxate. + +I processi sono automaticamente sandboxati dal userland quando iniziano se hanno il diritto: `com.apple.security.app-sandbox`. Per una spiegazione dettagliata di questo processo controlla: + +{% content-ref url="macos-sandbox-debug-and-bypass/" %} +[macos-sandbox-debug-and-bypass](macos-sandbox-debug-and-bypass/) +{% endcontent-ref %} + +## **Estensioni Sandbox** + +Le estensioni consentono di dare ulteriori privilegi a un oggetto e vengono attivate chiamando una delle funzioni: + +* `sandbox_issue_extension` +* `sandbox_extension_issue_file[_with_new_type]` +* `sandbox_extension_issue_mach` +* `sandbox_extension_issue_iokit_user_client_class` +* `sandbox_extension_issue_iokit_registry_rentry_class` +* `sandbox_extension_issue_generic` +* `sandbox_extension_issue_posix_ipc` + +Le estensioni sono memorizzate nel secondo slot di etichetta MACF accessibile dalle credenziali del processo. Il seguente **`sbtool`** può accedere a queste informazioni. + +Nota che le estensioni sono solitamente concesse dai processi autorizzati, ad esempio, `tccd` concederà il token di estensione di `com.apple.tcc.kTCCServicePhotos` quando un processo tenta di accedere alle foto ed è stato autorizzato in un messaggio XPC. Poi, il processo dovrà consumare il token di estensione affinché venga aggiunto ad esso.\ +Nota che i token di estensione sono lunghi esadecimali che codificano i permessi concessi. Tuttavia, non hanno il PID autorizzato hardcoded, il che significa che qualsiasi processo con accesso al token potrebbe essere **consumato da più processi**. + +Nota che le estensioni sono molto correlate ai diritti, quindi avere determinati diritti potrebbe automaticamente concedere determinate estensioni. + +### **Controlla i privilegi PID** + +[**Secondo questo**](https://www.youtube.com/watch?v=mG715HcDgO8\&t=3011s), le funzioni **`sandbox_check`** (è un `__mac_syscall`), possono controllare **se un'operazione è consentita o meno** dalla sandbox in un certo PID, audit token o ID unico. + +Il [**tool sbtool**](http://newosxbook.com/src.jl?tree=listings\&file=sbtool.c) (trovalo [compilato qui](https://newosxbook.com/articles/hitsb.html)) può controllare se un PID può eseguire determinate azioni: +```bash +sbtool mach #Check mac-ports (got from launchd with an api) +sbtool file /tmp #Check file access +sbtool inspect #Gives you an explanation of the sandbox profile and extensions +sbtool all +``` +### \[un]suspend + +È anche possibile sospendere e riattivare il sandbox utilizzando le funzioni `sandbox_suspend` e `sandbox_unsuspend` da `libsystem_sandbox.dylib`. + +Nota che per chiamare la funzione di sospensione vengono controllati alcuni diritti per autorizzare il chiamante a chiamarla come: + +* com.apple.private.security.sandbox-manager +* com.apple.security.print +* com.apple.security.temporary-exception.audio-unit-host + +## mac\_syscall + +Questa chiamata di sistema (#381) si aspetta un primo argomento stringa che indicherà il modulo da eseguire, e poi un codice nel secondo argomento che indicherà la funzione da eseguire. Poi il terzo argomento dipenderà dalla funzione eseguita. + +La funzione `___sandbox_ms` chiama `mac_syscall` indicando nel primo argomento `"Sandbox"` proprio come `___sandbox_msp` è un wrapper di `mac_set_proc` (#387). Poi, alcuni dei codici supportati da `___sandbox_ms` possono essere trovati in questa tabella: + +* **set\_profile (#0)**: Applica un profilo compilato o nominato a un processo. +* **platform\_policy (#1)**: Applica controlli di policy specifici per la piattaforma (varia tra macOS e iOS). +* **check\_sandbox (#2)**: Esegue un controllo manuale di un'operazione sandbox specifica. +* **note (#3)**: Aggiunge una notazione a un Sandbox +* **container (#4)**: Attacca un'annotazione a un sandbox, tipicamente per il debug o identificazione. +* **extension\_issue (#5)**: Genera una nuova estensione per un processo. +* **extension\_consume (#6)**: Consuma un'estensione data. +* **extension\_release (#7)**: Rilascia la memoria legata a un'estensione consumata. +* **extension\_update\_file (#8)**: Modifica i parametri di un'estensione di file esistente all'interno del sandbox. +* **extension\_twiddle (#9)**: Regola o modifica un'estensione di file esistente (es. TextEdit, rtf, rtfd). +* **suspend (#10)**: Sospende temporaneamente tutti i controlli del sandbox (richiede diritti appropriati). +* **unsuspend (#11)**: Riprende tutti i controlli del sandbox precedentemente sospesi. +* **passthrough\_access (#12)**: Consente l'accesso diretto a una risorsa, bypassando i controlli del sandbox. +* **set\_container\_path (#13)**: (solo iOS) Imposta un percorso di contenitore per un gruppo di app o ID di firma. +* **container\_map (#14)**: (solo iOS) Recupera un percorso di contenitore da `containermanagerd`. +* **sandbox\_user\_state\_item\_buffer\_send (#15)**: (iOS 10+) Imposta i metadati in modalità utente nel sandbox. +* **inspect (#16)**: Fornisce informazioni di debug su un processo sandboxed. +* **dump (#18)**: (macOS 11) Dump del profilo attuale di un sandbox per analisi. +* **vtrace (#19)**: Traccia le operazioni del sandbox per monitoraggio o debug. +* **builtin\_profile\_deactivate (#20)**: (macOS < 11) Disattiva profili nominati (es. `pe_i_can_has_debugger`). +* **check\_bulk (#21)**: Esegue più operazioni `sandbox_check` in una singola chiamata. +* **reference\_retain\_by\_audit\_token (#28)**: Crea un riferimento per un token di audit da utilizzare nei controlli del sandbox. +* **reference\_release (#29)**: Rilascia un riferimento di token di audit precedentemente mantenuto. +* **rootless\_allows\_task\_for\_pid (#30)**: Verifica se `task_for_pid` è consentito (simile ai controlli `csr`). +* **rootless\_whitelist\_push (#31)**: (macOS) Applica un file di manifest di Protezione Integrità di Sistema (SIP). +* **rootless\_whitelist\_check (preflight) (#32)**: Controlla il file di manifest SIP prima dell'esecuzione. +* **rootless\_protected\_volume (#33)**: (macOS) Applica protezioni SIP a un disco o partizione. +* **rootless\_mkdir\_protected (#34)**: Applica protezione SIP/DataVault a un processo di creazione di directory. + +## Sandbox.kext + +Nota che in iOS l'estensione del kernel contiene **tutti i profili hardcoded** all'interno del segmento `__TEXT.__const` per evitare che vengano modificati. Le seguenti sono alcune funzioni interessanti dall'estensione del kernel: + +* **`hook_policy_init`**: Collega `mpo_policy_init` ed è chiamato dopo `mac_policy_register`. Esegue la maggior parte delle inizializzazioni del Sandbox. Inizializza anche SIP. +* **`hook_policy_initbsd`**: Imposta l'interfaccia sysctl registrando `security.mac.sandbox.sentinel`, `security.mac.sandbox.audio_active` e `security.mac.sandbox.debug_mode` (se avviato con `PE_i_can_has_debugger`). +* **`hook_policy_syscall`**: È chiamato da `mac_syscall` con "Sandbox" come primo argomento e codice che indica l'operazione nel secondo. Viene utilizzato uno switch per trovare il codice da eseguire in base al codice richiesto. + +### MACF Hooks + +**`Sandbox.kext`** utilizza più di un centinaio di hook tramite MACF. La maggior parte degli hook controllerà solo alcuni casi banali che consentono di eseguire l'azione, altrimenti chiameranno **`cred_sb_evalutate`** con le **credenziali** da MACF e un numero corrispondente all'**operazione** da eseguire e un **buffer** per l'output. + +Un buon esempio di ciò è la funzione **`_mpo_file_check_mmap`** che ha agganciato **`mmap`** e che inizierà a controllare se la nuova memoria sarà scrivibile (e se non lo è, consentirà l'esecuzione), poi controllerà se è utilizzata per la cache condivisa dyld e, se sì, consentirà l'esecuzione, e infine chiamerà **`cred_sb_evalutate`** per eseguire ulteriori controlli di autorizzazione. + +Inoltre, tra i centinaia di hook utilizzati dal Sandbox, ce ne sono 3 in particolare che sono molto interessanti: + +* `mpo_proc_check_for`: Applica il profilo se necessario e se non era stato precedentemente applicato. +* `mpo_vnode_check_exec`: Chiamato quando un processo carica il binario associato, quindi viene eseguito un controllo del profilo e anche un controllo che vieta le esecuzioni SUID/SGID. +* `mpo_cred_label_update_execve`: Questo viene chiamato quando l'etichetta viene assegnata. Questo è il più lungo poiché viene chiamato quando il binario è completamente caricato ma non è ancora stato eseguito. Eseguirà azioni come la creazione dell'oggetto sandbox, l'attacco della struttura sandbox alle credenziali kauth, la rimozione dell'accesso alle porte mach... + +Nota che **`cred_sb_evalutate`** è un wrapper su **`sb_evaluate`** e questa funzione ottiene le credenziali passate e poi esegue la valutazione utilizzando la funzione **`eval`** che di solito valuta il **profilo della piattaforma** che è per impostazione predefinita applicato a tutti i processi e poi il **profilo del processo specifico**. Nota che il profilo della piattaforma è uno dei principali componenti di **SIP** in macOS. + +## Sandboxd + +Il Sandbox ha anche un demone utente in esecuzione che espone il servizio XPC Mach `com.apple.sandboxd` e lega la porta speciale 14 (`HOST_SEATBELT_PORT`) che l'estensione del kernel utilizza per comunicare con esso. Espone alcune funzioni utilizzando MIG. + +## References + +* [**\*OS Internals Volume III**](https://newosxbook.com/home.html) + {% hint style="success" %} -Impara e pratica il hacking AWS:[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)\ -Impara e pratica il hacking GCP: [**HackTricks Training GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte) +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)
-Supporta HackTricks +Support HackTricks -* Controlla i [**piani di abbonamento**](https://github.com/sponsors/carlospolop)! -* **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** -* **Condividi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos su github. +* 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 %} diff --git a/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-sip.md b/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-sip.md index abff5783f..734be5c9c 100644 --- a/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-sip.md +++ b/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-sip.md @@ -1,8 +1,8 @@ # macOS SIP {% 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) +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)
@@ -15,7 +15,6 @@ Learn & practice GCP Hacking: {% endhint %} - ## **Informazioni di base** **La Protezione dell'Integrità del Sistema (SIP)** in macOS è un meccanismo progettato per impedire anche agli utenti più privilegiati di apportare modifiche non autorizzate a cartelle di sistema chiave. Questa funzione gioca un ruolo cruciale nel mantenere l'integrità del sistema limitando azioni come l'aggiunta, la modifica o la cancellazione di file in aree protette. Le cartelle principali protette da SIP includono: @@ -25,7 +24,7 @@ Learn & practice GCP Hacking:
-### Stato SIP +### Stato di SIP Puoi controllare se SIP è abilitato sul tuo sistema con il seguente comando: ```bash @@ -77,7 +80,7 @@ Se desideri mantenere SIP abilitato ma rimuovere le protezioni di debug, puoi fa ```bash csrutil enable --without debug ``` -### Altre Restrizioni +### Other Restrictions * **Disabilita il caricamento di estensioni del kernel non firmate** (kexts), garantendo che solo le estensioni verificate interagiscano con il kernel di sistema. * **Previene il debugging** dei processi di sistema macOS, proteggendo i componenti core del sistema da accessi e modifiche non autorizzate. @@ -85,20 +88,34 @@ csrutil enable --without debug [**Scopri di più sulle informazioni SIP in questo talk**](https://www.slideshare.net/i0n1c/syscan360-stefan-esser-os-x-el-capitan-sinking-the-ship)**.** -## Bypass SIP +### **SIP related Entitlements** -Il bypass di SIP consente a un attaccante di: +* `com.apple.rootless.xpc.bootstrap`: Controlla launchd +* `com.apple.rootless.install[.heritable]`: Accesso al file system +* `com.apple.rootless.kext-management`: `kext_request` +* `com.apple.rootless.datavault.controller`: Gestisci UF\_DATAVAULT +* `com.apple.rootless.xpc.bootstrap`: Capacità di configurazione XPC +* `com.apple.rootless.xpc.effective-root`: Root tramite launchd XPC +* `com.apple.rootless.restricted-block-devices`: Accesso a dispositivi a blocchi raw +* `com.apple.rootless.internal.installer-equivalent`: Accesso illimitato al file system +* `com.apple.rootless.restricted-nvram-variables[.heritable]`: Accesso completo a NVRAM +* `com.apple.rootless.storage.label`: Modifica file limitati da com.apple.rootless xattr con l'etichetta corrispondente +* `com.apple.rootless.volume.VM.label`: Mantieni lo swap VM sul volume -* **Accedere ai Dati Utente**: Leggere dati sensibili dell'utente come email, messaggi e cronologia di Safari da tutti gli account utente. +## SIP Bypasses + +Evitare SIP consente a un attaccante di: + +* **Accedere ai dati dell'utente**: Leggere dati sensibili dell'utente come email, messaggi e cronologia di Safari da tutti gli account utente. * **Bypass TCC**: Manipolare direttamente il database TCC (Trasparenza, Consenso e Controllo) per concedere accesso non autorizzato alla webcam, al microfono e ad altre risorse. -* **Stabilire Persistenza**: Posizionare malware in posizioni protette da SIP, rendendolo resistente alla rimozione, anche da privilegi di root. Questo include anche la possibilità di manomettere lo strumento di rimozione malware (MRT). -* **Caricare Estensioni del Kernel**: Sebbene ci siano ulteriori misure di sicurezza, bypassare SIP semplifica il processo di caricamento di estensioni del kernel non firmate. +* **Stabilire persistenza**: Posizionare malware in posizioni protette da SIP, rendendolo resistente alla rimozione, anche da privilegi di root. Questo include anche la possibilità di manomettere lo strumento di rimozione malware (MRT). +* **Caricare estensioni del kernel**: Sebbene ci siano ulteriori misure di sicurezza, bypassare SIP semplifica il processo di caricamento di estensioni del kernel non firmate. -### Pacchetti Installer +### Installer Packages -**I pacchetti installer firmati con il certificato di Apple** possono bypassare le sue protezioni. Ciò significa che anche i pacchetti firmati da sviluppatori standard verranno bloccati se tentano di modificare le directory protette da SIP. +**I pacchetti di installazione firmati con il certificato di Apple** possono bypassare le sue protezioni. Ciò significa che anche i pacchetti firmati da sviluppatori standard verranno bloccati se tentano di modificare directory protette da SIP. -### File SIP Inesistente +### Inexistent SIP file Una potenziale falla è che se un file è specificato in **`rootless.conf` ma attualmente non esiste**, può essere creato. Il malware potrebbe sfruttare questo per **stabilire persistenza** sul sistema. Ad esempio, un programma malevolo potrebbe creare un file .plist in `/System/Library/LaunchDaemons` se è elencato in `rootless.conf` ma non presente. @@ -110,11 +127,11 @@ L'attributo **`com.apple.rootless.install.heritable`** consente di bypassare SIP #### [CVE-2019-8561](https://objective-see.org/blog/blog\_0x42.html) -È stato scoperto che era possibile **scambiare il pacchetto installer dopo che il sistema aveva verificato la sua firma** e poi, il sistema avrebbe installato il pacchetto malevolo invece di quello originale. Poiché queste azioni venivano eseguite da **`system_installd`**, ciò avrebbe consentito di bypassare SIP. +È stato scoperto che era possibile **scambiare il pacchetto di installazione dopo che il sistema aveva verificato la sua firma** e poi, il sistema avrebbe installato il pacchetto malevolo invece di quello originale. Poiché queste azioni venivano eseguite da **`system_installd`**, ciò avrebbe consentito di bypassare SIP. #### [CVE-2020–9854](https://objective-see.org/blog/blog\_0x4D.html) -Se un pacchetto veniva installato da un'immagine montata o da un'unità esterna, l'**installer** avrebbe **eseguito** il binario da **quella file system** (invece che da una posizione protetta da SIP), facendo eseguire a **`system_installd`** un binario arbitrario. +Se un pacchetto veniva installato da un'immagine montata o da un'unità esterna, l'**installer** **eseguiva** il binario da **quella file system** (invece che da una posizione protetta da SIP), facendo eseguire a **`system_installd`** un binario arbitrario. #### CVE-2021-30892 - Shrootless @@ -124,7 +141,7 @@ Il demone **`system_installd`** installerà pacchetti che sono stati firmati da I ricercatori hanno scoperto che durante l'installazione di un pacchetto firmato da Apple (.pkg file), **`system_installd`** **esegue** qualsiasi **script post-install** incluso nel pacchetto. Questi script vengono eseguiti dalla shell predefinita, **`zsh`**, che esegue automaticamente **comandi dal file** **`/etc/zshenv`**, se esiste, anche in modalità non interattiva. Questo comportamento potrebbe essere sfruttato dagli attaccanti: creando un file `/etc/zshenv` malevolo e aspettando che **`system_installd` invochi `zsh`**, potrebbero eseguire operazioni arbitrarie sul dispositivo. -Inoltre, è stato scoperto che **`/etc/zshenv` potrebbe essere utilizzato come una tecnica di attacco generale**, non solo per un bypass di SIP. Ogni profilo utente ha un file `~/.zshenv`, che si comporta allo stesso modo di `/etc/zshenv` ma non richiede permessi di root. Questo file potrebbe essere utilizzato come meccanismo di persistenza, attivandosi ogni volta che `zsh` si avvia, o come meccanismo di elevazione dei privilegi. Se un utente admin si eleva a root usando `sudo -s` o `sudo `, il file `~/.zshenv` verrebbe attivato, elevandosi effettivamente a root. +Inoltre, è stato scoperto che **`/etc/zshenv` potrebbe essere utilizzato come una tecnica di attacco generale**, non solo per un bypass di SIP. Ogni profilo utente ha un file `~/.zshenv`, che si comporta allo stesso modo di `/etc/zshenv` ma non richiede permessi di root. Questo file potrebbe essere utilizzato come meccanismo di persistenza, attivandosi ogni volta che `zsh` si avvia, o come meccanismo di elevazione dei privilegi. Se un utente admin si eleva a root usando `sudo -s` o `sudo `, il file `~/.zshenv` verrebbe attivato, elevando effettivamente a root. #### [**CVE-2022-22583**](https://perception-point.io/blog/technical-analysis-cve-2022-22583/) @@ -132,7 +149,7 @@ In [**CVE-2022-22583**](https://perception-point.io/blog/technical-analysis-cve- #### [fsck\_cs utility](https://www.theregister.com/2016/03/30/apple\_os\_x\_rootless/) -È stata identificata una vulnerabilità in cui **`fsck_cs`** è stato indotto a corrompere un file cruciale, a causa della sua capacità di seguire **link simbolici**. In particolare, gli attaccanti hanno creato un link da _`/dev/diskX`_ al file `/System/Library/Extensions/AppleKextExcludeList.kext/Contents/Info.plist`. Eseguire **`fsck_cs`** su _`/dev/diskX`_ ha portato alla corruzione di `Info.plist`. L'integrità di questo file è vitale per il SIP (Protezione dell'Integrità di Sistema) del sistema operativo, che controlla il caricamento delle estensioni del kernel. Una volta corrotto, la capacità di SIP di gestire le esclusioni del kernel è compromessa. +È stata identificata una vulnerabilità in cui **`fsck_cs`** è stato indotto a corrompere un file cruciale, a causa della sua capacità di seguire **link simbolici**. In particolare, gli attaccanti hanno creato un link da _`/dev/diskX`_ al file `/System/Library/Extensions/AppleKextExcludeList.kext/Contents/Info.plist`. Eseguire **`fsck_cs`** su _`/dev/diskX`_ ha portato alla corruzione di `Info.plist`. L'integrità di questo file è vitale per la SIP (Protezione dell'Integrità di Sistema) del sistema operativo, che controlla il caricamento delle estensioni del kernel. Una volta corrotto, la capacità di SIP di gestire le esclusioni del kernel è compromessa. I comandi per sfruttare questa vulnerabilità sono: ```bash @@ -166,7 +183,7 @@ Inoltre, all'interno di `InstallESD.dmg`, c'è un `BaseSystem.dmg`, che funge da #### [systemmigrationd (2023)](https://www.youtube.com/watch?v=zxZesAN-TEk) -In questo intervento di [**DEF CON 31**](https://www.youtube.com/watch?v=zxZesAN-TEk), viene mostrato come **`systemmigrationd`** (che può bypassare SIP) esegue uno **script bash** e uno **script perl**, che possono essere abusati tramite variabili d'ambiente **`BASH_ENV`** e **`PERL5OPT`**. +In questo intervento da [**DEF CON 31**](https://www.youtube.com/watch?v=zxZesAN-TEk), viene mostrato come **`systemmigrationd`** (che può bypassare SIP) esegue uno **script bash** e uno **script perl**, che possono essere abusati tramite variabili d'ambiente **`BASH_ENV`** e **`PERL5OPT`**. #### CVE-2023-42860 @@ -174,7 +191,7 @@ Come [**dettagliato in questo post del blog**](https://blog.kandji.io/apple-miti ```bash /usr/bin/chflags -h norestricted "${SHARED_SUPPORT_PATH}/SharedSupport.dmg" ``` -e era possibile creare un symlink in `${SHARED_SUPPORT_PATH}/SharedSupport.dmg` che avrebbe permesso a un utente di **rimuovere le restrizioni da qualsiasi file, eludendo la protezione SIP**. +and it was possible to creare un symlink in `${SHARED_SUPPORT_PATH}/SharedSupport.dmg` che consentirebbe a un utente di **rimuovere le restrizioni da qualsiasi file, eludendo la protezione SIP**. ### **com.apple.rootless.install** @@ -188,13 +205,13 @@ In questo caso specifico, il servizio XPC di sistema situato in `/System/Library ## Sealed System Snapshots -I Sealed System Snapshots sono una funzionalità introdotta da Apple in **macOS Big Sur (macOS 11)** come parte del meccanismo di **Protezione dell'Integrità di Sistema (SIP)** per fornire un ulteriore livello di sicurezza e stabilità del sistema. Sono essenzialmente versioni di sola lettura del volume di sistema. +Sealed System Snapshots sono una funzionalità introdotta da Apple in **macOS Big Sur (macOS 11)** come parte del meccanismo di **Protezione dell'Integrità di Sistema (SIP)** per fornire un ulteriore livello di sicurezza e stabilità del sistema. Sono essenzialmente versioni di sola lettura del volume di sistema. Ecco uno sguardo più dettagliato: -1. **Sistema Immutabile**: I Sealed System Snapshots rendono il volume di sistema macOS "immutabile", il che significa che non può essere modificato. Questo previene qualsiasi cambiamento non autorizzato o accidentale al sistema che potrebbe compromettere la sicurezza o la stabilità del sistema. +1. **Sistema Immutabile**: Sealed System Snapshots rendono il volume di sistema macOS "immutabile", il che significa che non può essere modificato. Questo previene qualsiasi cambiamento non autorizzato o accidentale al sistema che potrebbe compromettere la sicurezza o la stabilità del sistema. 2. **Aggiornamenti del Software di Sistema**: Quando installi aggiornamenti o upgrade di macOS, macOS crea un nuovo snapshot di sistema. Il volume di avvio di macOS utilizza quindi **APFS (Apple File System)** per passare a questo nuovo snapshot. L'intero processo di applicazione degli aggiornamenti diventa più sicuro e affidabile poiché il sistema può sempre tornare allo snapshot precedente se qualcosa va storto durante l'aggiornamento. -3. **Separazione dei Dati**: In concomitanza con il concetto di separazione dei volumi Dati e Sistema introdotto in macOS Catalina, la funzionalità Sealed System Snapshot garantisce che tutti i tuoi dati e le impostazioni siano memorizzati su un volume separato "**Dati**". Questa separazione rende i tuoi dati indipendenti dal sistema, semplificando il processo di aggiornamenti di sistema e migliorando la sicurezza del sistema. +3. **Separazione dei Dati**: Insieme al concetto di separazione dei volumi Dati e Sistema introdotto in macOS Catalina, la funzionalità Sealed System Snapshot garantisce che tutti i tuoi dati e le impostazioni siano memorizzati su un volume separato "**Dati**". Questa separazione rende i tuoi dati indipendenti dal sistema, semplificando il processo di aggiornamenti di sistema e migliorando la sicurezza del sistema. Ricorda che questi snapshot sono gestiti automaticamente da macOS e non occupano spazio aggiuntivo sul tuo disco, grazie alle capacità di condivisione dello spazio di APFS. È anche importante notare che questi snapshot sono diversi dagli **snapshot di Time Machine**, che sono backup accessibili dall'utente dell'intero sistema. @@ -241,7 +258,7 @@ Il comando **`diskutil apfs list`** elenca i **dettagli dei volumi APFS** e il l Nell'output precedente è possibile vedere che **le posizioni accessibili all'utente** sono montate sotto `/System/Volumes/Data`. -Inoltre, **lo snapshot del volume di sistema macOS** è montato in `/` ed è **sigillato** (firmato crittograficamente dal sistema operativo). Quindi, se SIP viene eluso e modificato, il **sistema operativo non si avvierà più**. +Inoltre, **lo snapshot del volume di sistema macOS** è montato in `/` ed è **sigillato** (firmato crittograficamente dal sistema operativo). Quindi, se SIP viene eluso e viene modificato, il **sistema operativo non si avvierà più**. È anche possibile **verificare che il sigillo sia abilitato** eseguendo: ```bash @@ -254,8 +271,8 @@ mount /dev/disk3s1s1 on / (apfs, sealed, local, read-only, journaled) ``` {% hint style="success" %} -Impara e pratica AWS Hacking:[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)\ -Impara e pratica GCP Hacking: [**HackTricks Training GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte) +Impara e pratica AWS Hacking:[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)\ +Impara e pratica GCP Hacking: [**HackTricks Training GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte)
@@ -263,8 +280,7 @@ Impara e pratica GCP Hacking: {% endhint %} -