O Mach utiliza **tarefas** como a **unidade mais pequena** para compartilhar recursos, e cada tarefa pode conter **várias threads**. Essas **tarefas e threads são mapeadas 1:1 para processos e threads POSIX**.
A comunicação entre tarefas ocorre via Comunicação Interprocesso (IPC) do Mach, utilizando canais de comunicação unidirecionais. **As mensagens são transferidas entre portas**, que atuam como **filas de mensagens** gerenciadas pelo kernel.
Os direitos de porta, que definem quais operações uma tarefa pode executar, são fundamentais para essa comunicação. Os possíveis **direitos de porta** são:
* **Direito de recebimento**, que permite receber mensagens enviadas para a porta. As portas do Mach são filas MPSC (múltiplos produtores, um único consumidor), o que significa que pode haver apenas **um direito de recebimento para cada porta** em todo o sistema (ao contrário dos pipes, onde vários processos podem ter descritores de arquivo para a extremidade de leitura de um pipe).
* Uma **tarefa com o direito de recebimento** pode receber mensagens e **criar direitos de envio**, permitindo que ela envie mensagens. Originalmente, apenas a **própria tarefa tem o direito de recebimento sobre sua porta**.
* **Direito de envio**, que permite enviar mensagens para a porta.
* **Direito de envio único**, que permite enviar uma mensagem para a porta e depois desaparece.
* **Direito de conjunto de porta**, que denota um _conjunto de porta_ em vez de uma única porta. Desenfileirar uma mensagem de um conjunto de portas desenfileira uma mensagem de uma das portas que ele contém. Os conjuntos de portas podem ser usados para ouvir várias portas simultaneamente, muito parecido com `select`/`poll`/`epoll`/`kqueue` no Unix.
* **Nome morto**, que não é um direito de porta real, mas apenas um espaço reservado. Quando uma porta é destruída, todos os direitos de porta existentes para a porta se transformam em nomes mortos.
**As tarefas podem transferir direitos de ENVIO para outras**, permitindo que elas enviem mensagens de volta. **Os direitos de ENVIO também podem ser clonados, para que uma tarefa possa duplicar e dar o direito a uma terceira tarefa**. Isso, combinado com um processo intermediário conhecido como **servidor de inicialização**, permite uma comunicação eficaz entre tarefas.
1. A tarefa **A** inicia uma **nova porta**, obtendo um **direito de RECEBIMENTO** no processo.
2. A tarefa **A**, sendo a detentora do direito de RECEBIMENTO, **gera um direito de ENVIO para a porta**.
3. A tarefa **A** estabelece uma **conexão** com o **servidor de inicialização**, fornecendo o **nome do serviço da porta** e o **direito de ENVIO** por meio de um procedimento conhecido como registro de inicialização.
4. A tarefa **B** interage com o **servidor de inicialização** para executar uma **busca de inicialização para o serviço**. Se bem-sucedido, o **servidor duplica o direito de ENVIO** recebido da Tarefa A e **o transmite para a Tarefa B**.
5. Ao adquirir um direito de ENVIO, a tarefa **B** é capaz de **formular** uma **mensagem** e enviá-la **para a tarefa A**.
O servidor de inicialização **não pode autenticar** o nome do serviço reivindicado por uma tarefa. Isso significa que uma **tarefa** poderia potencialmente **se passar por qualquer tarefa do sistema**, como falsamente **reivindicar um nome de serviço de autorização** e, em seguida, aprovar todas as solicitações.
Então, a Apple armazena os **nomes dos serviços fornecidos pelo sistema** em arquivos de configuração seguros, localizados em diretórios protegidos pelo SIP: `/System/Library/LaunchDaemons` e `/System/Library/LaunchAgents`. Ao lado de cada nome de serviço, o **binário associado também é armazenado**. O servidor de inicialização criará e manterá um **direito de RECEBIMENTO para cada um desses nomes de serviço**.
Para esses serviços predefinidos, o **processo de busca difere ligeiramente**. Quando um nome de serviço está sendo procurado, o launchd inicia o serviço dinamicamente. O novo fluxo de trabalho é o seguinte:
* A tarefa **A** (o serviço) realiza um **check-in de inicialização**. Aqui, o **servidor de inicialização cria um direito de ENVIO, o retém e transfere o direito de RECEBIMENTO para a tarefa A**.
* launchd duplica o **direito de ENVIO e o envia para a tarefa B**.
No entanto, esse processo se aplica apenas a tarefas predefinidas do sistema. As tarefas não do sistema ainda operam como descrito originalmente, o que poderia permitir a falsificação.
Observe como o **remetente****aloca** uma porta, cria um **direito de envio** para o nome `org.darlinghq.example` e o envia para o **servidor de inicialização** enquanto o remetente solicitou o **direito de envio** desse nome e o usou para **enviar uma mensagem**.
O arquivo `sender.c` é um exemplo de um processo que envia mensagens IPC para outro processo. Ele usa a função `msgsnd()` para enviar uma mensagem para a fila de mensagens IPC. A mensagem é definida como uma estrutura `msgbuf`, que contém um tipo de mensagem e um corpo de mensagem. O tipo de mensagem é usado para identificar o tipo de mensagem que está sendo enviada e o corpo da mensagem contém os dados da mensagem.
O processo `sender` primeiro obtém a chave da fila de mensagens IPC usando a função `ftok()`. Em seguida, ele cria a fila de mensagens IPC usando a função `msgget()`. Depois disso, ele preenche a estrutura `msgbuf` com o tipo de mensagem e o corpo da mensagem e envia a mensagem para a fila de mensagens IPC usando a função `msgsnd()`.
* **Porta do host**: Se um processo tem o privilégio **Enviar** sobre esta porta, ele pode obter **informações** sobre o **sistema** (por exemplo, `host_processor_info`).
* **Porta de privilégio do host**: Um processo com o direito de **Enviar** sobre esta porta pode realizar ações **privilegiadas** como carregar uma extensão do kernel. O **processo precisa ser root** para obter essa permissão.
* Além disso, para chamar a API **`kext_request`**, é necessário ter a autorização **`com.apple.private.kext`**, que é dada apenas a binários da Apple.
* **Porta do nome da tarefa:** Uma versão não privilegiada da _porta da tarefa_. Ele faz referência à tarefa, mas não permite controlá-la. A única coisa que parece estar disponível através dela é `task_info()`.
* **Porta da tarefa** (também conhecida como porta do kernel)**:** Com a permissão de Envio sobre esta porta, é possível controlar a tarefa (ler/escrever memória, criar threads...).
* Chame `mach_task_self()` para **obter o nome** desta porta para a tarefa do chamador. Esta porta é apenas **herdada** através do **`exec()`**; uma nova tarefa criada com `fork()` recebe uma nova porta de tarefa (como um caso especial, uma tarefa também recebe uma nova porta de tarefa após `exec()`ing um binário suid). A única maneira de gerar uma tarefa e obter sua porta é realizar a ["dança de troca de porta"](https://robert.sesek.com/2014/1/changes\_to\_xnu\_mach\_ipc.html) enquanto faz um `fork()`.
* Se o aplicativo tiver a autorização **`com.apple.security.get-task-allow`**, processos do **mesmo usuário podem acessar a porta da tarefa** (comumente adicionado pelo Xcode para depuração). O processo de **notarização** não permitirá isso em lançamentos de produção.
* Aplicativos com a autorização **`com.apple.system-task-ports`** podem obter a **porta da tarefa para qualquer** processo, exceto o kernel. Em versões mais antigas, era chamado de **`task_for_pid-allow`**. Isso é concedido apenas a aplicativos da Apple.
* **Root pode acessar portas de tarefas** de aplicativos **não** compilados com um tempo de execução **fortificado** (e não da Apple).
O arquivo `entitlements.plist` é um arquivo de propriedades que contém informações sobre as permissões que um processo tem no sistema. Ele é usado para especificar quais recursos um processo pode acessar e quais ações ele pode executar. O arquivo é assinado digitalmente e verificado pelo sistema operacional antes de ser executado. Se o arquivo não for assinado ou se a assinatura for inválida, o processo não será executado. O arquivo `entitlements.plist` é usado para restringir o acesso a recursos sensíveis do sistema, como a câmera, o microfone e a localização do usuário. Ele também é usado para restringir o acesso a recursos de rede, como a conexão com a Internet e a rede local.
No macOS, as **threads** podem ser manipuladas via **Mach** ou usando a **API posix `pthread`**. A thread gerada na injeção anterior foi gerada usando a API Mach, portanto, **não é compatível com posix**.
Foi possível **injetar um shellcode simples** para executar um comando porque ele **não precisava trabalhar com APIs compatíveis com posix**, apenas com Mach. **Injeções mais complexas** precisariam que a **thread** também fosse **compatível com posix**.
Portanto, para **melhorar o shellcode**, ele deve chamar **`pthread_create_from_mach_thread`**, que irá **criar um pthread válido**. Em seguida, este novo pthread pode **chamar dlopen** para **carregar nossa dylib** do sistema.
XPC, que significa Comunicação Interprocessual XNU (o kernel usado pelo macOS), é um framework para **comunicação entre processos** no macOS e iOS. O XPC fornece um mecanismo para fazer **chamadas de método assíncronas seguras entre diferentes processos** no sistema. É uma parte do paradigma de segurança da Apple, permitindo a **criação de aplicativos separados por privilégios** onde cada **componente** é executado com **apenas as permissões necessárias** para fazer seu trabalho, limitando assim o potencial de danos de um processo comprometido.
O XPC usa uma forma de Comunicação Interprocessual (IPC), que é um conjunto de métodos para diferentes programas em execução no mesmo sistema para enviar dados de ida e volta.
1.**Segurança**: Ao separar o trabalho em diferentes processos, cada processo pode receber apenas as permissões necessárias. Isso significa que mesmo que um processo seja comprometido, ele tem capacidade limitada de causar danos.
2.**Estabilidade**: O XPC ajuda a isolar falhas no componente onde elas ocorrem. Se um processo falhar, ele pode ser reiniciado sem afetar o restante do sistema.
3.**Desempenho**: O XPC permite fácil concorrência, pois diferentes tarefas podem ser executadas simultaneamente em diferentes processos.
A única **desvantagem** é que **separar um aplicativo em vários processos** fazendo com que eles se comuniquem via XPC é **menos eficiente**. Mas nos sistemas de hoje isso quase não é perceptível e os benefícios são muito melhores.
Um exemplo pode ser visto no QuickTime Player, onde um componente que usa XPC é responsável pela decodificação de vídeo. O componente é especificamente projetado para realizar tarefas computacionais, portanto, no caso de uma violação, ele não forneceria nenhum ganho útil ao atacante, como acesso a arquivos ou à rede.
Os componentes XPC de um aplicativo estão **dentro do próprio aplicativo**. Por exemplo, no Safari, você pode encontrá-los em **`/Applications/Safari.app/Contents/XPCServices`**. Eles têm a extensão **`.xpc`** (como **`com.apple.Safari.SandboxBroker.xpc`**) e também são **bundles** com o binário principal dentro dele: `/Applications/Safari.app/Contents/XPCServices/com.apple.Safari.SandboxBroker.xpc/Contents/MacOS/com.apple.Safari.SandboxBroker`
Como você pode estar pensando, um **componente XPC terá diferentes direitos e privilégios** do que os outros componentes XPC ou o binário principal do aplicativo. EXCETO se um serviço XPC for configurado com [**JoinExistingSession**](https://developer.apple.com/documentation/bundleresources/information\_property\_list/xpcservice/joinexistingsession) definido como "True" em seu arquivo **Info.plist**. Nesse caso, o serviço XPC será executado na mesma sessão de segurança do aplicativo que o chamou.
Os serviços XPC são **iniciados** pelo **launchd** quando necessário e **encerrados** assim que todas as tarefas são **concluídas** para liberar recursos do sistema. **Os componentes XPC específicos do aplicativo só podem ser utilizados pelo aplicativo**, reduzindo assim o risco associado a possíveis vulnerabilidades.
Os **serviços XPC em todo o sistema** são acessíveis a todos os usuários. Esses serviços, seja launchd ou do tipo Mach, precisam ser **definidos em arquivos plist** localizados em diretórios especificados, como **`/System/Library/LaunchDaemons`**, **`/Library/LaunchDaemons`**, **`/System/Library/LaunchAgents`** ou **`/Library/LaunchAgents`**.
Os que estão em **`LaunchDameons`** são executados pelo root. Portanto, se um processo não privilegiado puder se comunicar com um deles, poderá ser capaz de escalar privilégios.
Os aplicativos podem **se inscrever** em diferentes **mensagens de evento**, permitindo que sejam **iniciados sob demanda** quando esses eventos ocorrem. A **configuração** desses serviços é feita em arquivos **plist do launchd**, localizados nos **mesmos diretórios que os anteriores** e contendo uma chave extra **`LaunchEvent`**.
Quando um processo tenta chamar um método via uma conexão XPC, o **serviço XPC deve verificar se esse processo tem permissão para se conectar**. Aqui estão as maneiras comuns de verificar isso e as armadilhas comuns:
A Apple também permite que os aplicativos **configurem alguns direitos e como obtê-los** para que, se o processo de chamada os tiver, ele possa **chamar um método** do serviço XPC:
Este arquivo é um arquivo de propriedades do Launchd que define um serviço personalizado que será executado no sistema. O Launchd é o sistema de gerenciamento de serviços do macOS que inicia, para e monitora processos e serviços do sistema. O arquivo plist contém informações sobre o serviço, como o caminho do executável, argumentos, diretório de trabalho, variáveis de ambiente e muito mais. É possível usar o Launchd para iniciar serviços personalizados com privilégios elevados, o que pode ser útil para a escalada de privilégios.
O macOS é um sistema operacional baseado em Unix que usa o kernel XNU. O XNU é um kernel híbrido que combina um kernel Mach com componentes do kernel BSD. O macOS usa o Mach para gerenciar a memória, threads e IPC (Inter-Process Communication). O IPC é um mecanismo que permite que processos diferentes se comuniquem entre si. O IPC é usado para implementar muitos recursos do macOS, como notificações, Apple Events, XPC e outros. O IPC é uma parte importante do macOS e é frequentemente usado em exploits de escalonamento de privilégios.
O IPC é um mecanismo que permite que processos diferentes se comuniquem entre si. Existem vários tipos de IPC disponíveis no macOS, incluindo notificações, Apple Events, XPC e outros. O IPC é uma parte importante do macOS e é frequentemente usado em exploits de escalonamento de privilégios. O IPC é gerenciado pelo Mach e é implementado usando portas Mach. As portas Mach são usadas para enviar mensagens entre processos. Cada porta Mach tem um nome e um número de porta. O número da porta é usado para identificar a porta Mach e o nome da porta é usado para se conectar à porta Mach.
As portas Mach são usadas para enviar mensagens entre processos. Cada porta Mach tem um nome e um número de porta. O número da porta é usado para identificar a porta Mach e o nome da porta é usado para se conectar à porta Mach. As portas Mach são gerenciadas pelo kernel e são usadas para implementar vários recursos do macOS, como notificações, Apple Events, XPC e outros. As portas Mach são uma parte importante do macOS e são frequentemente usadas em exploits de escalonamento de privilégios.
As notificações são uma forma de IPC que permite que os aplicativos enviem mensagens para o Centro de Notificações do macOS. As notificações são implementadas usando portas Mach. Quando um aplicativo envia uma notificação, ele envia uma mensagem para a porta Mach do Centro de Notificações. O Centro de Notificações recebe a mensagem e exibe a notificação para o usuário. As notificações são uma parte importante do macOS e são frequentemente usadas em exploits de escalonamento de privilégios.
Os eventos da Apple são uma forma de IPC que permite que os aplicativos enviem mensagens uns aos outros. Os eventos da Apple são implementados usando portas Mach. Quando um aplicativo envia um evento da Apple, ele envia uma mensagem para a porta Mach do aplicativo de destino. O aplicativo de destino recebe a mensagem e executa a ação apropriada. Os eventos da Apple são uma parte importante do macOS e são frequentemente usados em exploits de escalonamento de privilégios.
O XPC é uma forma de IPC que permite que os aplicativos se comuniquem uns com os outros. O XPC é implementado usando portas Mach. Quando um aplicativo envia uma mensagem XPC, ele envia uma mensagem para a porta Mach do aplicativo de destino. O aplicativo de destino recebe a mensagem e executa a ação apropriada. O XPC é uma parte importante do macOS e é frequentemente usado em exploits de escalonamento de privilégios.
O IPC é uma parte importante do macOS e é frequentemente usado em exploits de escalonamento de privilégios. Existem vários tipos de IPC disponíveis no macOS, incluindo notificações, Apple Events, XPC e outros. O IPC é gerenciado pelo Mach e é implementado usando portas Mach. As portas Mach são usadas para enviar mensagens entre processos. Cada porta Mach tem um nome e um número de porta. O número da porta é usado para identificar a porta Mach e o nome da porta é usado para se conectar à porta Mach. As portas Mach são uma parte importante do macOS e são frequentemente usadas em exploits de escalonamento de privilégios.
O servidor XPC é responsável por criar a conexão XPC e gerenciar as mensagens recebidas do cliente XPC. O servidor XPC é iniciado pelo sistema operacional quando o cliente XPC se conecta a ele. O servidor XPC é responsável por criar a conexão XPC e gerenciar as mensagens recebidas do cliente XPC. O servidor XPC é iniciado pelo sistema operacional quando o cliente XPC se conecta a ele.
O servidor XPC é responsável por criar a conexão XPC e gerenciar as mensagens recebidas do cliente XPC. O servidor XPC é iniciado pelo sistema operacional quando o cliente XPC se conecta a ele. O servidor XPC é responsável por criar a conexão XPC e gerenciar as mensagens recebidas do cliente XPC. O servidor XPC é iniciado pelo sistema operacional quando o cliente XPC se conecta a ele.
O servidor XPC é responsável por criar a conexão XPC e gerenciar as mensagens recebidas do cliente XPC. O servidor XPC é iniciado pelo sistema operacional quando o cliente XPC se conecta a ele. O servidor XPC é responsável por criar a conexão XPC e gerenciar as mensagens recebidas do cliente XPC. O servidor XPC é iniciado pelo sistema operacional quando o cliente XPC se conecta a ele.
O servidor XPC é responsável por criar a conexão XPC e gerenciar as mensagens recebidas do cliente XPC. O servidor XPC é iniciado pelo sistema operacional quando o cliente XPC se conecta a ele. O servidor XPC é responsável por criar a conexão XPC e gerenciar as mensagens recebidas do cliente XPC. O servidor XPC é iniciado pelo sistema operacional quando o cliente XPC se conecta a ele.
O servidor XPC é responsável por criar a conexão XPC e gerenciar as mensagens recebidas do cliente XPC. O servidor XPC é iniciado pelo sistema operacional quando o cliente XPC se conecta a ele. O servidor XPC é responsável por criar a conexão XPC e gerenciar as mensagens recebidas do cliente XPC. O servidor XPC é iniciado pelo sistema operacional quando o cliente XPC se conecta a ele.
O servidor XPC é responsável por criar a conexão XPC e gerenciar as mensagens recebidas do cliente XPC. O servidor XPC é iniciado pelo sistema operacional quando o cliente XPC se conecta a ele. O servidor XPC é responsável por criar a conexão XPC e gerenciar as mensagens recebidas do cliente XPC. O servidor XPC é iniciado pelo sistema operacional quando o cliente XPC se conecta a ele.
O servidor XPC é responsável por criar a conexão XPC e gerenciar as mensagens recebidas do cliente XPC. O servidor XPC é iniciado pelo sistema operacional quando o cliente XPC se conecta a ele. O servidor XPC é responsável por criar a conexão XPC e gerenciar as mensagens recebidas do cliente XPC. O servidor XPC é iniciado pelo sistema operacional quando o cliente XPC se conecta a ele.
O servidor XPC é responsável por criar a conexão XPC e gerenciar as mensagens recebidas do cliente XPC. O servidor XPC é iniciado pelo sistema operacional quando o cliente XPC se conecta a ele. O servidor XPC é responsável por criar a conexão XPC e gerenciar as mensagens recebidas do cliente XPC. O servidor XPC é iniciado pelo sistema operacional quando o cliente XPC se conecta a ele.
O servidor XPC é responsável por criar a conexão XPC e gerenciar as mensagens recebidas do cliente XPC. O servidor XPC é iniciado pelo sistema operacional quando o cliente XPC se conecta a ele. O servidor XPC é responsável por criar a conexão XPC e gerenciar as mensagens recebidas do cliente XPC. O servidor XPC é iniciado pelo sistema operacional quando o cliente XPC se conecta a ele.
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 are a low-level IPC mechanism used by macOS and iOS. They are used to send messages between processes and to create inter-process communication channels. Mach ports are used by many macOS and iOS system services, including launchd, the kernel, and the WindowServer.
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.
Unix domain sockets are a type of IPC mechanism that allows processes to communicate with each other using the file system. They are similar to network sockets, but they are only accessible on the local machine. Unix domain sockets are commonly used by system services and daemons to communicate with each other.
Unix domain sockets are identified by a file path, which is used to create and connect to the socket. When a process creates a socket, it can specify whether the socket is a stream socket or a datagram socket. Stream sockets provide a reliable, byte-stream oriented communication channel, while datagram sockets provide an unreliable, message-oriented communication channel.
Distributed Objects is a high-level IPC mechanism provided by macOS. It allows objects to be passed between processes, and it provides a transparent mechanism for remote method invocation. Distributed Objects is built on top of Mach ports and Unix domain sockets.
Distributed Objects allows objects to be passed between processes using a proxy object. The proxy object is responsible for forwarding method invocations to the remote object, and for marshalling and unmarshalling arguments and return values. Distributed Objects provides a transparent mechanism for remote method invocation, so the caller does not need to know whether the object is local or remote.
XPC Services is a high-level IPC mechanism provided by macOS. It allows processes to communicate with each other using a message-passing model. XPC Services is built on top of Mach ports and Unix domain sockets.
XPC Services allows processes to communicate with each other using a message-passing model. A process can create an XPC service, which is a separate process that provides a specific service. The process can then send messages to the XPC service to request the service, and the XPC service can send messages back to the process to provide the service.
Inter-Process Communication is an important mechanism for macOS and iOS. It allows processes to communicate with each other and share data, which is essential for many system services and daemons. Understanding the different IPC mechanisms provided by macOS is important for both developers and security researchers.
* Você trabalha em uma **empresa de cibersegurança**? Você quer ver sua **empresa anunciada no HackTricks**? ou quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e para o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
