From 900f5b284cdddbbe94697cf57bc9630118da3b5e Mon Sep 17 00:00:00 2001 From: Translator Date: Tue, 24 Sep 2024 15:18:00 +0000 Subject: [PATCH] Translated ['macos-hardening/macos-security-and-privilege-escalation/mac --- .../macos-sandbox/README.md | 237 ++++++++++++++---- .../macos-security-protections/macos-sip.md | 52 ++-- 2 files changed, 221 insertions(+), 68 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 0bd4c8134..11582efed 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 dans les applications de l'App Store +{% endcode %} + +Et ensuite, exécutez simplement quelque chose en utilisant ce profil : +```bash +sandbox-exec -f /tmp/trace.sb /bin/ls +``` +Dans `/tmp/trace.out`, vous pourrez voir chaque vérification de sandbox effectuée chaque fois qu'elle a été appelée (donc, beaucoup de doublons). + +Il est également possible de tracer le sandbox en utilisant le paramètre **`-t`** : `sandbox-exec -t /path/trace.out -p "(version 1)" /bin/ls` + +#### Via API + +La fonction `sandbox_set_trace_path` exportée par `libsystem_sandbox.dylib` permet de spécifier un nom de fichier de trace où les vérifications de sandbox seront écrites.\ +Il est également possible de faire quelque chose de similaire en appelant `sandbox_vtrace_enable()` et en obtenant ensuite les journaux d'erreur du tampon en appelant `sandbox_vtrace_report()`. + +### Inspection du Sandbox + +`libsandbox.dylib` exporte une fonction appelée sandbox\_inspect\_pid qui donne une liste de l'état du sandbox d'un processus (y compris les extensions). Cependant, seules les binaires de la plateforme peuvent utiliser cette fonction. + +### Profils de Sandbox MacOS & iOS + +MacOS stocke les profils de sandbox système à deux emplacements : **/usr/share/sandbox/** et **/System/Library/Sandbox/Profiles**. + +Et si une application tierce porte le droit _**com.apple.security.app-sandbox**_, le système applique le profil **/System/Library/Sandbox/Profiles/application.sb** à ce processus. + +Dans iOS, le profil par défaut s'appelle **container** et nous n'avons pas la représentation textuelle SBPL. En mémoire, ce sandbox est représenté comme un arbre binaire Allow/Deny pour chaque permission du sandbox. + +### SBPL personnalisé dans les applications de l'App Store Il pourrait être possible pour les entreprises de faire fonctionner leurs applications **avec des profils de Sandbox personnalisés** (au lieu de celui par défaut). Elles doivent utiliser le droit **`com.apple.security.temporary-exception.sbpl`** qui doit être autorisé par Apple. @@ -262,19 +276,142 @@ Il est possible de vérifier la définition de ce droit dans **`/System/Library/ (let* ((port (open-input-string string)) (sbpl (read port))) (with-transparent-redirection (eval sbpl))))) ``` -Cela va **évaluer la chaîne après cette attribution** comme un profil Sandbox. +Ce sera **évaluer la chaîne après cette attribution** comme un profil Sandbox. + +### Compilation et décompilation d'un profil Sandbox + +L'outil **`sandbox-exec`** utilise les fonctions `sandbox_compile_*` de `libsandbox.dylib`. Les principales fonctions exportées sont : `sandbox_compile_file` (attend un chemin de fichier, param `-f`), `sandbox_compile_string` (attend une chaîne, param `-p`), `sandbox_compile_name` (attend un nom de conteneur, param `-n`), `sandbox_compile_entitlements` (attend un plist d'attributions). + +Cette version inversée et [**open source de l'outil sandbox-exec**](https://newosxbook.com/src.jl?tree=listings\&file=/sandbox\_exec.c) permet de faire écrire à **`sandbox-exec`** dans un fichier le profil sandbox compilé. + +De plus, pour confiner un processus à l'intérieur d'un conteneur, il peut appeler `sandbox_spawnattrs_set[container/profilename]` et passer un conteneur ou un profil préexistant. + +## Déboguer et contourner le Sandbox + +Sur macOS, contrairement à iOS où les processus sont sandboxés dès le départ par le noyau, **les processus doivent s'inscrire eux-mêmes dans le sandbox**. Cela signifie que sur macOS, un processus n'est pas restreint par le sandbox jusqu'à ce qu'il décide activement d'y entrer, bien que les applications de l'App Store soient toujours sandboxées. + +Les processus sont automatiquement sandboxés depuis l'espace utilisateur lorsqu'ils démarrent s'ils ont l'attribution : `com.apple.security.app-sandbox`. Pour une explication détaillée de ce processus, consultez : + +{% content-ref url="macos-sandbox-debug-and-bypass/" %} +[macos-sandbox-debug-and-bypass](macos-sandbox-debug-and-bypass/) +{% endcontent-ref %} + +## **Extensions Sandbox** + +Les extensions permettent de donner des privilèges supplémentaires à un objet et sont accordées en appelant l'une des fonctions : + +* `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` + +Les extensions sont stockées dans le deuxième emplacement d'étiquette MACF accessible depuis les informations d'identification du processus. Le **`sbtool`** suivant peut accéder à ces informations. + +Notez que les extensions sont généralement accordées par des processus autorisés, par exemple, `tccd` accordera le jeton d'extension de `com.apple.tcc.kTCCServicePhotos` lorsqu'un processus essaie d'accéder aux photos et a été autorisé dans un message XPC. Ensuite, le processus devra consommer le jeton d'extension pour qu'il soit ajouté à celui-ci.\ +Notez que les jetons d'extension sont de longs hexadécimaux qui codent les permissions accordées. Cependant, ils n'ont pas le PID autorisé codé en dur, ce qui signifie que tout processus ayant accès au jeton pourrait être **consommé par plusieurs processus**. + +Notez que les extensions sont également très liées aux attributions, donc avoir certaines attributions pourrait automatiquement accorder certaines extensions. + +### **Vérifier les privilèges PID** + +[**Selon cela**](https://www.youtube.com/watch?v=mG715HcDgO8\&t=3011s), les fonctions **`sandbox_check`** (c'est un `__mac_syscall`), peuvent vérifier **si une opération est autorisée ou non** par le sandbox dans un certain PID, jeton d'audit ou ID unique. + +L'outil [**sbtool**](http://newosxbook.com/src.jl?tree=listings\&file=sbtool.c) (trouvez-le [compilé ici](https://newosxbook.com/articles/hitsb.html)) peut vérifier si un PID peut effectuer certaines actions : +```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 + +Il est également possible de suspendre et de reprendre le sandbox en utilisant les fonctions `sandbox_suspend` et `sandbox_unsuspend` de `libsystem_sandbox.dylib`. + +Notez que pour appeler la fonction de suspension, certaines autorisations sont vérifiées afin d'autoriser l'appelant à l'appeler, comme : + +* com.apple.private.security.sandbox-manager +* com.apple.security.print +* com.apple.security.temporary-exception.audio-unit-host + +## mac\_syscall + +Cet appel système (#381) attend un premier argument de type chaîne qui indiquera le module à exécuter, puis un code dans le deuxième argument qui indiquera la fonction à exécuter. Ensuite, le troisième argument dépendra de la fonction exécutée. + +L'appel de fonction `___sandbox_ms` enveloppe `mac_syscall` en indiquant dans le premier argument `"Sandbox"`, tout comme `___sandbox_msp` est un wrapper de `mac_set_proc` (#387). Ensuite, certains des codes pris en charge par `___sandbox_ms` peuvent être trouvés dans ce tableau : + +* **set\_profile (#0)** : Appliquer un profil compilé ou nommé à un processus. +* **platform\_policy (#1)** : Appliquer des vérifications de politique spécifiques à la plateforme (varie entre macOS et iOS). +* **check\_sandbox (#2)** : Effectuer une vérification manuelle d'une opération sandbox spécifique. +* **note (#3)** : Ajoute une annotation à un Sandbox. +* **container (#4)** : Attacher une annotation à un sandbox, généralement pour le débogage ou l'identification. +* **extension\_issue (#5)** : Générer une nouvelle extension pour un processus. +* **extension\_consume (#6)** : Consommer une extension donnée. +* **extension\_release (#7)** : Libérer la mémoire liée à une extension consommée. +* **extension\_update\_file (#8)** : Modifier les paramètres d'une extension de fichier existante dans le sandbox. +* **extension\_twiddle (#9)** : Ajuster ou modifier une extension de fichier existante (par exemple, TextEdit, rtf, rtfd). +* **suspend (#10)** : Suspendre temporairement toutes les vérifications de sandbox (nécessite des autorisations appropriées). +* **unsuspend (#11)** : Reprendre toutes les vérifications de sandbox précédemment suspendues. +* **passthrough\_access (#12)** : Autoriser un accès direct en contournant les vérifications de sandbox. +* **set\_container\_path (#13)** : (iOS uniquement) Définir un chemin de conteneur pour un groupe d'applications ou un ID de signature. +* **container\_map (#14)** : (iOS uniquement) Récupérer un chemin de conteneur à partir de `containermanagerd`. +* **sandbox\_user\_state\_item\_buffer\_send (#15)** : (iOS 10+) Définir des métadonnées en mode utilisateur dans le sandbox. +* **inspect (#16)** : Fournir des informations de débogage sur un processus sandboxé. +* **dump (#18)** : (macOS 11) Dump le profil actuel d'un sandbox pour analyse. +* **vtrace (#19)** : Tracer les opérations de sandbox pour le suivi ou le débogage. +* **builtin\_profile\_deactivate (#20)** : (macOS < 11) Désactiver les profils nommés (par exemple, `pe_i_can_has_debugger`). +* **check\_bulk (#21)** : Effectuer plusieurs opérations `sandbox_check` en un seul appel. +* **reference\_retain\_by\_audit\_token (#28)** : Créer une référence pour un jeton d'audit à utiliser dans les vérifications de sandbox. +* **reference\_release (#29)** : Libérer une référence de jeton d'audit précédemment retenue. +* **rootless\_allows\_task\_for\_pid (#30)** : Vérifier si `task_for_pid` est autorisé (similaire aux vérifications `csr`). +* **rootless\_whitelist\_push (#31)** : (macOS) Appliquer un fichier manifeste de protection de l'intégrité du système (SIP). +* **rootless\_whitelist\_check (preflight) (#32)** : Vérifier le fichier manifeste SIP avant l'exécution. +* **rootless\_protected\_volume (#33)** : (macOS) Appliquer des protections SIP à un disque ou une partition. +* **rootless\_mkdir\_protected (#34)** : Appliquer une protection SIP/DataVault à un processus de création de répertoire. + +## Sandbox.kext + +Notez qu'en iOS, l'extension du noyau contient **tous les profils codés en dur** à l'intérieur du segment `__TEXT.__const` pour éviter qu'ils ne soient modifiés. Voici quelques fonctions intéressantes de l'extension du noyau : + +* **`hook_policy_init`** : Elle accroche `mpo_policy_init` et est appelée après `mac_policy_register`. Elle effectue la plupart des initialisations du Sandbox. Elle initialise également le SIP. +* **`hook_policy_initbsd`** : Elle configure l'interface sysctl en enregistrant `security.mac.sandbox.sentinel`, `security.mac.sandbox.audio_active` et `security.mac.sandbox.debug_mode` (si booté avec `PE_i_can_has_debugger`). +* **`hook_policy_syscall`** : Elle est appelée par `mac_syscall` avec "Sandbox" comme premier argument et un code indiquant l'opération dans le deuxième. Un switch est utilisé pour trouver le code à exécuter selon le code demandé. + +### MACF Hooks + +**`Sandbox.kext`** utilise plus d'une centaine de hooks via MACF. La plupart des hooks vérifieront simplement certains cas triviaux qui permettent d'effectuer l'action, sinon, elles appelleront **`cred_sb_evalutate`** avec les **identifiants** de MACF et un nombre correspondant à l'**opération** à effectuer et un **buffer** pour la sortie. + +Un bon exemple de cela est la fonction **`_mpo_file_check_mmap`** qui accroche **`mmap`** et qui commencera à vérifier si la nouvelle mémoire va être écrite (et si ce n'est pas le cas, autoriser l'exécution), puis elle vérifiera si elle est utilisée pour le cache partagé dyld et si c'est le cas, autoriser l'exécution, et enfin, elle appellera **`cred_sb_evalutate`** pour effectuer d'autres vérifications d'autorisation. + +De plus, parmi les centaines de hooks utilisés par Sandbox, il y en a 3 en particulier qui sont très intéressants : + +* `mpo_proc_check_for` : Elle applique le profil si nécessaire et s'il n'a pas été appliqué précédemment. +* `mpo_vnode_check_exec` : Appelée lorsqu'un processus charge le binaire associé, puis une vérification de profil est effectuée ainsi qu'une vérification interdisant les exécutions SUID/SGID. +* `mpo_cred_label_update_execve` : Cela est appelé lorsque l'étiquette est assignée. C'est le plus long car il est appelé lorsque le binaire est entièrement chargé mais qu'il n'a pas encore été exécuté. Il effectuera des actions telles que la création de l'objet sandbox, l'attachement de la structure sandbox aux identifiants kauth, la suppression de l'accès aux ports mach... + +Notez que **`cred_sb_evalutate`** est un wrapper autour de **`sb_evaluate`** et cette fonction obtient les identifiants passés et effectue ensuite l'évaluation en utilisant la fonction **`eval`** qui évalue généralement le **profil de plateforme** qui est par défaut appliqué à tous les processus, puis le **profil de processus spécifique**. Notez que le profil de plateforme est l'un des principaux composants du **SIP** dans macOS. + +## Sandboxd + +Sandbox dispose également d'un démon utilisateur en cours d'exécution exposant le service XPC Mach `com.apple.sandboxd` et liant le port spécial 14 (`HOST_SEATBELT_PORT`) que l'extension du noyau utilise pour communiquer avec lui. Il expose certaines fonctions en utilisant MIG. + +## References + +* [**\*OS Internals Volume III**](https://newosxbook.com/home.html) {% hint style="success" %} -Apprenez et pratiquez le hacking AWS :[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)\ -Apprenez et pratiquez le 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)
-Soutenir HackTricks +Support HackTricks -* Consultez les [**plans d'abonnement**](https://github.com/sponsors/carlospolop) ! -* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** nous sur **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** -* **Partagez des astuces de hacking en soumettant des PRs aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts 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 7b02989c0..05021884d 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,17 +15,16 @@ Learn & practice GCP Hacking: {% endhint %} - ## **Informations de base** -**La Protection de l'Intégrité du Système (SIP)** dans macOS est un mécanisme conçu pour empêcher même les utilisateurs les plus privilégiés de faire des modifications non autorisées dans des dossiers système clés. Cette fonctionnalité joue un rôle crucial dans le maintien de l'intégrité du système en restreignant des actions telles que l'ajout, la modification ou la suppression de fichiers dans des zones protégées. Les principaux dossiers protégés par le SIP incluent : +**La protection de l'intégrité du système (SIP)** dans macOS est un mécanisme conçu pour empêcher même les utilisateurs les plus privilégiés de faire des modifications non autorisées dans des dossiers système clés. Cette fonctionnalité joue un rôle crucial dans le maintien de l'intégrité du système en restreignant des actions telles que l'ajout, la modification ou la suppression de fichiers dans des zones protégées. Les principaux dossiers protégés par le SIP incluent : * **/System** * **/bin** * **/sbin** * **/usr** -Les règles qui régissent le comportement du SIP sont définies dans le fichier de configuration situé à **`/System/Library/Sandbox/rootless.conf`**. Dans ce fichier, les chemins qui sont précédés d'un astérisque (\*) sont désignés comme des exceptions aux restrictions SIP autrement strictes. +Les règles qui régissent le comportement du SIP sont définies dans le fichier de configuration situé à **`/System/Library/Sandbox/rootless.conf`**. Dans ce fichier, les chemins qui sont précédés d'un astérisque (\*) sont désignés comme des exceptions aux restrictions strictes du SIP. Considérez l'exemple ci-dessous : ```javascript @@ -52,6 +51,10 @@ Ici, le drapeau **`restricted`** indique que le répertoire `/usr/libexec` est p De plus, si un fichier contient l'attribut **`com.apple.rootless`** en tant qu'**attribut étendu**, ce fichier sera également **protégé par SIP**. +{% hint style="success" %} +Notez que le hook **Sandbox** **`hook_vnode_check_setextattr`** empêche toute tentative de modification de l'attribut étendu **`com.apple.rootless`.** +{% endhint %} + **SIP limite également d'autres actions root** telles que : * Charger des extensions de noyau non fiables @@ -59,11 +62,11 @@ De plus, si un fichier contient l'attribut **`com.apple.rootless`** en tant qu'* * Modifier les variables NVRAM * Autoriser le débogage du noyau -Les options sont maintenues dans la variable nvram en tant que bitflag (`csr-active-config` sur Intel et `lp-sip0` est lu à partir de l'arbre de périphériques démarré pour ARM). Vous pouvez trouver les drapeaux dans le code source de XNU dans `csr.sh` : +Les options sont maintenues dans la variable nvram en tant que bitflag (`csr-active-config` sur Intel et `lp-sip0` est lu à partir de l'arbre de périphériques démarré pour ARM). Vous pouvez trouver les drapeaux dans le code source XNU dans `csr.sh` :
-### Statut de SIP +### Statut SIP Vous pouvez vérifier si SIP est activé sur votre système avec la commande suivante : ```bash @@ -81,10 +84,24 @@ csrutil enable --without debug * **Interdit le chargement des extensions de noyau non signées** (kexts), garantissant que seules les extensions vérifiées interagissent avec le noyau du système. * **Empêche le débogage** des processus système macOS, protégeant les composants essentiels du système contre l'accès et la modification non autorisés. -* **Inhibe des outils** comme dtrace d'inspecter les processus système, protégeant ainsi davantage l'intégrité du fonctionnement du système. +* **Inhibe les outils** comme dtrace d'inspecter les processus système, protégeant ainsi davantage l'intégrité du fonctionnement du système. [**En savoir plus sur les informations SIP dans cette présentation**](https://www.slideshare.net/i0n1c/syscan360-stefan-esser-os-x-el-capitan-sinking-the-ship)**.** +### **Attributions liées à SIP** + +* `com.apple.rootless.xpc.bootstrap`: Contrôler launchd +* `com.apple.rootless.install[.heritable]`: Accéder au système de fichiers +* `com.apple.rootless.kext-management`: `kext_request` +* `com.apple.rootless.datavault.controller`: Gérer UF\_DATAVAULT +* `com.apple.rootless.xpc.bootstrap`: Capacités de configuration XPC +* `com.apple.rootless.xpc.effective-root`: Root via launchd XPC +* `com.apple.rootless.restricted-block-devices`: Accès aux périphériques de bloc bruts +* `com.apple.rootless.internal.installer-equivalent`: Accès illimité au système de fichiers +* `com.apple.rootless.restricted-nvram-variables[.heritable]`: Accès complet à NVRAM +* `com.apple.rootless.storage.label`: Modifier les fichiers restreints par com.apple.rootless xattr avec l'étiquette correspondante +* `com.apple.rootless.volume.VM.label`: Maintenir l'échange VM sur le volume + ## Contournements de SIP Contourner SIP permet à un attaquant de : @@ -110,7 +127,7 @@ L'attribution **`com.apple.rootless.install.heritable`** permet de contourner SI #### [CVE-2019-8561](https://objective-see.org/blog/blog\_0x42.html) -Il a été découvert qu'il était possible de **échanger le paquet d'installation après que le système ait vérifié sa signature** de code et ensuite, le système installerait le paquet malveillant au lieu de l'original. Comme ces actions étaient effectuées par **`system_installd`**, cela permettrait de contourner SIP. +Il a été découvert qu'il était possible de **changer le paquet d'installation après que le système ait vérifié sa signature** de code et ensuite, le système installerait le paquet malveillant au lieu de l'original. Comme ces actions étaient effectuées par **`system_installd`**, cela permettrait de contourner SIP. #### [CVE-2020–9854](https://objective-see.org/blog/blog\_0x4D.html) @@ -122,7 +139,7 @@ Si un paquet était installé à partir d'une image montée ou d'un disque exter Le démon **`system_installd`** installera des paquets qui ont été signés par **Apple**. -Les chercheurs ont découvert que lors de l'installation d'un paquet signé par Apple (fichier .pkg), **`system_installd`** **exécute** tous les **scripts post-installation** inclus dans le paquet. Ces scripts sont exécutés par le shell par défaut, **`zsh`**, qui exécute automatiquement des commandes à partir du fichier **`/etc/zshenv`**, s'il existe, même en mode non interactif. Ce comportement pourrait être exploité par des attaquants : en créant un fichier `/etc/zshenv` malveillant et en attendant que **`system_installd` invoque `zsh`**, ils pourraient effectuer des opérations arbitraires sur l'appareil. +Les chercheurs ont découvert que lors de l'installation d'un paquet signé par Apple (.pkg), **`system_installd`** **exécute** tous les **scripts post-installation** inclus dans le paquet. Ces scripts sont exécutés par le shell par défaut, **`zsh`**, qui exécute automatiquement des commandes à partir du fichier **`/etc/zshenv`**, s'il existe, même en mode non interactif. Ce comportement pourrait être exploité par des attaquants : en créant un fichier `/etc/zshenv` malveillant et en attendant que **`system_installd` invoque `zsh`**, ils pourraient effectuer des opérations arbitraires sur l'appareil. De plus, il a été découvert que **`/etc/zshenv` pourrait être utilisé comme une technique d'attaque générale**, pas seulement pour un contournement de SIP. Chaque profil utilisateur a un fichier `~/.zshenv`, qui se comporte de la même manière que `/etc/zshenv` mais ne nécessite pas de permissions root. Ce fichier pourrait être utilisé comme un mécanisme de persistance, se déclenchant chaque fois que `zsh` démarre, ou comme un mécanisme d'élévation de privilèges. Si un utilisateur admin s'élève à root en utilisant `sudo -s` ou `sudo `, le fichier `~/.zshenv` serait déclenché, élevant effectivement à root. @@ -132,7 +149,7 @@ Dans [**CVE-2022-22583**](https://perception-point.io/blog/technical-analysis-cv #### [fsck\_cs utility](https://www.theregister.com/2016/03/30/apple\_os\_x\_rootless/) -Une vulnérabilité a été identifiée où **`fsck_cs`** a été induit en erreur pour corrompre un fichier crucial, en raison de sa capacité à suivre des **liens symboliques**. Plus précisément, les attaquants ont créé un lien de _`/dev/diskX`_ vers le fichier `/System/Library/Extensions/AppleKextExcludeList.kext/Contents/Info.plist`. L'exécution de **`fsck_cs`** sur _`/dev/diskX`_ a conduit à la corruption de `Info.plist`. L'intégrité de ce fichier est vitale pour le SIP (Protection de l'Intégrité du Système) du système d'exploitation, qui contrôle le chargement des extensions de noyau. Une fois corrompu, la capacité de SIP à gérer les exclusions de noyau est compromise. +Une vulnérabilité a été identifiée où **`fsck_cs`** a été induit en erreur pour corrompre un fichier crucial, en raison de sa capacité à suivre **liens symboliques**. Plus précisément, les attaquants ont créé un lien de _`/dev/diskX`_ vers le fichier `/System/Library/Extensions/AppleKextExcludeList.kext/Contents/Info.plist`. L'exécution de **`fsck_cs`** sur _`/dev/diskX`_ a conduit à la corruption de `Info.plist`. L'intégrité de ce fichier est vitale pour le SIP (Protection de l'Intégrité du Système) du système d'exploitation, qui contrôle le chargement des extensions de noyau. Une fois corrompu, la capacité de SIP à gérer les exclusions de noyau est compromise. Les commandes pour exploiter cette vulnérabilité sont : ```bash @@ -141,7 +158,7 @@ fsck_cs /dev/diskX 1>&- touch /Library/Extensions/ reboot ``` -L'exploitation de cette vulnérabilité a de graves implications. Le fichier `Info.plist`, normalement responsable de la gestion des autorisations pour les extensions du noyau, devient inefficace. Cela inclut l'incapacité de mettre sur liste noire certaines extensions, telles que `AppleHWAccess.kext`. Par conséquent, avec le mécanisme de contrôle de SIP hors service, cette extension peut être chargée, accordant un accès en lecture et en écriture non autorisé à la RAM du système. +L'exploitation de cette vulnérabilité a de graves implications. Le fichier `Info.plist`, normalement responsable de la gestion des autorisations pour les extensions du noyau, devient inefficace. Cela inclut l'incapacité de mettre sur liste noire certaines extensions, telles que `AppleHWAccess.kext`. Par conséquent, avec le mécanisme de contrôle de SIP hors service, cette extension peut être chargée, accordant un accès en lecture et écriture non autorisé à la RAM du système. #### [Monter sur des dossiers protégés par SIP](https://www.slideshare.net/i0n1c/syscan360-stefan-esser-os-x-el-capitan-sinking-the-ship) @@ -182,13 +199,13 @@ et il était possible de créer un symlink dans `${SHARED_SUPPORT_PATH}/SharedSu L'attribution **`com.apple.rootless.install`** permet de contourner SIP {% endhint %} -L'attribution `com.apple.rootless.install` est connue pour contourner la Protection d'Intégrité du Système (SIP) sur macOS. Cela a été notamment mentionné en relation avec [**CVE-2022-26712**](https://jhftss.github.io/CVE-2022-26712-The-POC-For-SIP-Bypass-Is-Even-Tweetable/). +L'attribution `com.apple.rootless.install` est connue pour contourner la Protection de l'Intégrité du Système (SIP) sur macOS. Cela a été notamment mentionné en relation avec [**CVE-2022-26712**](https://jhftss.github.io/CVE-2022-26712-The-POC-For-SIP-Bypass-Is-Even-Tweetable/). Dans ce cas spécifique, le service XPC du système situé à `/System/Library/PrivateFrameworks/ShoveService.framework/Versions/A/XPCServices/SystemShoveService.xpc` possède cette attribution. Cela permet au processus associé de contourner les contraintes SIP. De plus, ce service présente notamment une méthode qui permet le déplacement de fichiers sans appliquer de mesures de sécurité. ## Instantanés de Système Scellés -Les Instantanés de Système Scellés sont une fonctionnalité introduite par Apple dans **macOS Big Sur (macOS 11)** dans le cadre de son mécanisme de **Protection d'Intégrité du Système (SIP)** pour fournir une couche de sécurité et de stabilité supplémentaire. Ils sont essentiellement des versions en lecture seule du volume système. +Les Instantanés de Système Scellés sont une fonctionnalité introduite par Apple dans **macOS Big Sur (macOS 11)** dans le cadre de son mécanisme de **Protection de l'Intégrité du Système (SIP)** pour fournir une couche de sécurité et de stabilité supplémentaire. Ils sont essentiellement des versions en lecture seule du volume système. Voici un aperçu plus détaillé : @@ -254,17 +271,16 @@ mount /dev/disk3s1s1 on / (apfs, sealed, local, read-only, journaled) ``` {% hint style="success" %} -Apprenez et pratiquez le hacking AWS :[**HackTricks Formation Expert Red Team AWS (ARTE)**](https://training.hacktricks.xyz/courses/arte)\ -Apprenez et pratiquez le hacking GCP : [**HackTricks Formation Expert Red Team GCP (GRTE)**](https://training.hacktricks.xyz/courses/grte) +Apprenez et pratiquez le hacking AWS :[**HackTricks Formation Expert Red Team AWS (ARTE)**](https://training.hacktricks.xyz/courses/arte)\ +Apprenez et pratiquez le hacking GCP : [**HackTricks Formation Expert Red Team GCP (GRTE)**](https://training.hacktricks.xyz/courses/grte)
Soutenir HackTricks -* Consultez les [**plans d'abonnement**](https://github.com/sponsors/carlospolop)! +* Consultez les [**plans d'abonnement**](https://github.com/sponsors/carlospolop) ! * **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** nous sur **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** * **Partagez des astuces de hacking en soumettant des PRs aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts github.
{% endhint %} -