mirror of
https://github.com/carlospolop/hacktricks
synced 2024-11-24 05:33:33 +00:00
Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
This commit is contained in:
Translator
parent
844cedaf24
commit
03f57eb4b5
5 changed files with 94 additions and 39 deletions
BIN
.gitbook/assets/image (725).png
Normal file
BIN
.gitbook/assets/image (725).png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 16 KiB |
BIN
.gitbook/assets/image (726).png
Normal file
BIN
.gitbook/assets/image (726).png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 22 KiB |
BIN
.gitbook/assets/image (727).png
Normal file
BIN
.gitbook/assets/image (727).png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 22 KiB |
BIN
.gitbook/assets/image (728).png
Normal file
BIN
.gitbook/assets/image (728).png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 57 KiB |
|
|
@ -9,7 +9,7 @@ Outras formas de apoiar o HackTricks:
|
|||
* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
||||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga**-me no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios do GitHub** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
@ -20,13 +20,13 @@ Na arquitetura ARMv8, os níveis de execução, conhecidos como Níveis de Exce
|
|||
|
||||
1. **EL0 - Modo Usuário**:
|
||||
* Este é o nível menos privilegiado e é usado para executar código de aplicativos regulares.
|
||||
* Aplicações executadas no EL0 são isoladas umas das outras e do software do sistema, aumentando a segurança e estabilidade.
|
||||
* Aplicações rodando em EL0 são isoladas umas das outras e do software do sistema, aumentando a segurança e estabilidade.
|
||||
2. **EL1 - Modo Kernel do Sistema Operacional**:
|
||||
* A maioria dos kernels de sistemas operacionais rodam neste nível.
|
||||
* A maioria dos kernels de sistemas operacionais roda neste nível.
|
||||
* EL1 tem mais privilégios que EL0 e pode acessar recursos do sistema, mas com algumas restrições para garantir a integridade do sistema.
|
||||
3. **EL2 - Modo Hipervisor**:
|
||||
* Este nível é usado para virtualização. Um hipervisor executando no EL2 pode gerenciar múltiplos sistemas operacionais (cada um em seu próprio EL1) rodando no mesmo hardware físico.
|
||||
* EL2 fornece recursos para isolamento e controle dos ambientes virtualizados.
|
||||
* Este nível é usado para virtualização. Um hipervisor rodando em EL2 pode gerenciar múltiplos sistemas operacionais (cada um em seu próprio EL1) rodando no mesmo hardware físico.
|
||||
* EL2 oferece recursos para isolamento e controle dos ambientes virtualizados.
|
||||
4. **EL3 - Modo Monitor Seguro**:
|
||||
* Este é o nível mais privilegiado e é frequentemente usado para boot seguro e ambientes de execução confiáveis.
|
||||
* EL3 pode gerenciar e controlar acessos entre estados seguros e não seguros (como boot seguro, OS confiável, etc.).
|
||||
|
|
@ -35,24 +35,24 @@ O uso desses níveis permite uma maneira estruturada e segura de gerenciar difer
|
|||
|
||||
## **Registradores (ARM64v8)**
|
||||
|
||||
ARM64 possui **31 registradores de uso geral**, rotulados de `x0` a `x30`. Cada um pode armazenar um valor de **64 bits** (8 bytes). Para operações que requerem apenas valores de 32 bits, os mesmos registradores podem ser acessados em um modo de 32 bits usando os nomes w0 a w30.
|
||||
ARM64 tem **31 registradores de uso geral**, rotulados de `x0` a `x30`. Cada um pode armazenar um valor de **64 bits** (8 bytes). Para operações que requerem apenas valores de 32 bits, os mesmos registradores podem ser acessados em um modo de 32 bits usando os nomes w0 a w30.
|
||||
|
||||
1. **`x0`** a **`x7`** - Tipicamente usados como registradores temporários e para passar parâmetros para sub-rotinas.
|
||||
* **`x0`** também carrega o dado de retorno de uma função
|
||||
2. **`x8`** - No kernel do Linux, `x8` é usado como o número da chamada de sistema para a instrução `svc`. **No macOS o x16 é o utilizado!**
|
||||
2. **`x8`** - No kernel do Linux, `x8` é usado como o número de chamada do sistema para a instrução `svc`. **No macOS o x16 é o utilizado!**
|
||||
3. **`x9`** a **`x15`** - Mais registradores temporários, frequentemente usados para variáveis locais.
|
||||
4. **`x16`** e **`x17`** - **Registradores de Chamada Intraprocedural**. Registradores temporários para valores imediatos. Também são usados para chamadas de função indiretas e stubs da Tabela de Ligação de Procedimentos (PLT).
|
||||
* **`x16`** é usado como o **número da chamada de sistema** para a instrução **`svc`** no **macOS**.
|
||||
5. **`x18`** - **Registrador da Plataforma**. Pode ser usado como um registrador de uso geral, mas em algumas plataformas, este registrador é reservado para usos específicos da plataforma: Ponteiro para o bloco de ambiente de thread atual no Windows, ou para apontar para a estrutura de tarefa em execução no kernel do Linux.
|
||||
6. **`x19`** a **`x28`** - Estes são registradores preservados pelo chamador. Uma função deve preservar os valores destes registradores para seu chamador, então eles são armazenados na pilha e recuperados antes de voltar ao chamador.
|
||||
* **`x16`** é usado como o **número de chamada do sistema** para a instrução **`svc`** no **macOS**.
|
||||
5. **`x18`** - **Registrador da Plataforma**. Pode ser usado como um registrador de uso geral, mas em algumas plataformas, este registrador é reservado para usos específicos da plataforma: Ponteiro para o bloco de ambiente de thread atual no Windows, ou para apontar para a estrutura de tarefa atualmente **executando no kernel do Linux**.
|
||||
6. **`x19`** a **`x28`** - Estes são registradores salvos pelo chamado. Uma função deve preservar os valores destes registradores para seu chamador, então eles são armazenados na pilha e recuperados antes de voltar ao chamador.
|
||||
7. **`x29`** - **Ponteiro de quadro** para acompanhar o quadro de pilha. Quando um novo quadro de pilha é criado porque uma função é chamada, o registrador **`x29`** é **armazenado na pilha** e o **novo** endereço do ponteiro de quadro é (**`sp`** endereço) é **armazenado neste registro**.
|
||||
* Este registrador também pode ser usado como um **registro de uso geral** embora geralmente seja usado como referência para **variáveis locais**.
|
||||
8. **`x30`** ou **`lr`**- **Registrador de Link**. Ele contém o **endereço de retorno** quando uma instrução `BL` (Branch with Link) ou `BLR` (Branch with Link to Register) é executada armazenando o valor de **`pc`** neste registrador.
|
||||
* Ele também pode ser usado como qualquer outro registrador.
|
||||
9. **`sp`** - **Ponteiro de pilha**, usado para acompanhar o topo da pilha.
|
||||
* o valor de **`sp`** deve sempre ser mantido com pelo menos um **alinhamento de quadword** ou uma exceção de alinhamento pode ocorrer.
|
||||
10. **`pc`** - **Contador de programa**, que aponta para a instrução atual. Este registrador só pode ser atualizado através de gerações de exceção, retornos de exceção e ramificações. As únicas instruções ordinárias que podem ler este registrador são as instruções de ramificação com link (BL, BLR) para armazenar o endereço de **`pc`** em **`lr`** (Registrador de Link).
|
||||
11. **`xzr`** - **Registrador Zero**. Também chamado de **`wzr`** na sua forma de registro de **32 bits**. Pode ser usado para obter facilmente o valor zero (operação comum) ou para realizar comparações usando **`subs`** como **`subs XZR, Xn, #10`** armazenando os dados resultantes em lugar nenhum (em **`xzr`**).
|
||||
10. **`pc`** - **Contador de programa**, que aponta para a próxima instrução. Este registrador só pode ser atualizado através de gerações de exceção, retornos de exceção e ramificações. As únicas instruções ordinárias que podem ler este registrador são as instruções de ramificação com link (BL, BLR) para armazenar o endereço de **`pc`** em **`lr`** (Registrador de Link).
|
||||
11. **`xzr`** - **Registrador Zero**. Também chamado de **`wzr`** na sua forma de registrador de **32 bits**. Pode ser usado para obter facilmente o valor zero (operação comum) ou para realizar comparações usando **`subs`** como **`subs XZR, Xn, #10`** armazenando os dados resultantes em lugar nenhum (em **`xzr`**).
|
||||
|
||||
Os registradores **`Wn`** são a versão **32 bits** do registrador **`Xn`**.
|
||||
|
||||
|
|
@ -65,36 +65,38 @@ Além disso, existem outros **32 registradores de 128 bits** que podem ser usado
|
|||
**existem centenas de registradores do sistema**, também chamados de registradores de propósito especial (SPRs), usados para **monitorar** e **controlar** o comportamento dos **processadores**.\
|
||||
Eles só podem ser lidos ou configurados usando a instrução especial dedicada **`mrs`** e **`msr`**.
|
||||
|
||||
Os registradores especiais **`TPIDR_EL0`** e **`TPIDDR_EL0`** são comuns quando se faz engenharia reversa. O sufixo `EL0` indica o **nível mínimo de exceção** do qual o registrador pode ser acessado (neste caso, EL0 é o nível regular de exceção (privilégio) com o qual programas regulares são executados).\
|
||||
Eles são frequentemente usados para armazenar o **endereço base do armazenamento local de thread** na memória. Geralmente o primeiro é legível e gravável para programas executados em EL0, mas o segundo pode ser lido de EL0 e escrito de EL1 (como kernel).
|
||||
Os registradores especiais **`TPIDR_EL0`** e **`TPIDDR_EL0`** são comuns quando se faz engenharia reversa. O sufixo `EL0` indica o **nível mínimo de exceção** do qual o registrador pode ser acessado (neste caso EL0 é o nível regular de exceção (privilégio) com o qual programas regulares rodam).\
|
||||
Eles são frequentemente usados para armazenar o **endereço base do armazenamento local de thread** na memória. Geralmente o primeiro é legível e gravável para programas rodando em EL0, mas o segundo pode ser lido de EL0 e escrito de EL1 (como kernel).
|
||||
|
||||
* `mrs x0, TPIDR_EL0 ; Lê TPIDR_EL0 em x0`
|
||||
* `msr TPIDR_EL0, X0 ; Escreve TPIDR_EL0 em x1`
|
||||
|
||||
### **PSTATE**
|
||||
|
||||
**PSTATE** é vários componentes serializados no registrador especial visível pelo sistema operacional **`SPSR_ELx`**. Estes são os campos acessíveis:
|
||||
**PSTATE** contém vários componentes do processo serializados no registrador especial visível pelo sistema operacional **`SPSR_ELx`**, sendo X o **nível de permissão da exceção disparada** (isso permite recuperar o estado do processo quando a exceção termina).\
|
||||
Estes são os campos acessíveis:
|
||||
|
||||
* As **`N`**, **`Z`**, **`C`** e **`V`** flags de condição:
|
||||
* As **flags de condição `N`**, **`Z`**, **`C`** e **`V`**:
|
||||
* **`N`** significa que a operação resultou em um valor negativo
|
||||
* **`Z`** significa que a operação resultou em zero
|
||||
* **`C`** significa que a operação teve carry
|
||||
* **`C`** significa que a operação gerou um carry
|
||||
* **`V`** significa que a operação resultou em um overflow assinado:
|
||||
* A soma de dois números positivos resulta em um valor negativo.
|
||||
* A soma de dois números negativos resulta em um valor positivo.
|
||||
* Na subtração, quando um número negativo grande é subtraído de um número positivo menor (ou vice-versa), e o resultado não pode ser representado dentro do intervalo do tamanho de bits dado.
|
||||
* A flag de **largura do registrador atual (`nRW`)**: Se a flag tiver o valor 0, o programa executará no estado de execução AArch64 assim que for retomado.
|
||||
* O **Nível de Exceção atual** (**`EL`**): Um programa regular executando em EL0 terá o valor 0
|
||||
* A flag de **passo único** (**`SS`**): Usada por depuradores para passo único configurando a flag SS para 1 dentro de **`SPSR_ELx`** através de uma exceção. O programa executará um passo e emitirá uma exceção de passo único.
|
||||
* A flag de **largura do registrador atual (`nRW`)**: Se a flag tiver o valor 0, o programa rodará no estado de execução AArch64 uma vez retomado.
|
||||
* O **Nível de Exceção atual** (**`EL`**): Um programa regular rodando em EL0 terá o valor 0
|
||||
* A flag de **passo único (`SS`)**: Usada por depuradores para passo único configurando a flag SS para 1 dentro de **`SPSR_ELx`** através de uma exceção. O programa executará um passo e emitirá uma exceção de passo único.
|
||||
* A flag de estado de exceção ilegal (**`IL`**): É usada para marcar quando um software privilegiado realiza uma transferência de nível de exceção inválida, esta flag é configurada para 1 e o processador dispara uma exceção de estado ilegal.
|
||||
* As flags **`DAIF`**: Estas flags permitem que um programa privilegiado mascare seletivamente certas exceções externas.
|
||||
* As flags de seleção do ponteiro de pilha (**`SPS`**): Programas privilegiados executando em EL1 e acima podem alternar entre usar seu próprio registrador de ponteiro de pilha e o do modelo de usuário (por exemplo, entre `SP_EL1` e `EL0`). Esta troca é realizada escrevendo no registrador especial **`SPSel`**. Isso não pode ser feito a partir de EL0.
|
||||
* Se **`A`** for 1 significa que abortos assíncronos serão disparados. O **`I`** configura para responder a **Pedidos de Interrupção** de hardware externo (IRQs). e o F está relacionado a **Pedidos de Interrupção Rápida** (FIRs).
|
||||
* As flags de seleção do ponteiro de pilha (**`SPS`**): Programas privilegiados rodando em EL1 e acima podem alternar entre usar seu próprio registrador de ponteiro de pilha e o do modelo de usuário (por exemplo, entre `SP_EL1` e `EL0`). Esta troca é realizada escrevendo no registrador especial **`SPSel`**. Isso não pode ser feito a partir de EL0.
|
||||
|
||||
<figure><img src="../../../.gitbook/assets/image (724).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
## **Convenção de Chamadas (ARM64v8)**
|
||||
|
||||
A convenção de chamadas ARM64 especifica que os **primeiros oito parâmetros** para uma função são passados nos registradores **`x0` a `x7`**. **Parâmetros adicionais** são passados na **pilha**. O valor de **retorno** é passado de volta no registrador **`x0`**, ou em **`x1`** também **se for de 128 bits**. Os registradores **`x19` a `x30`** e **`sp`** devem ser **preservados** através das chamadas de função.
|
||||
A convenção de chamadas ARM64 especifica que os **primeiros oito parâmetros** para uma função são passados nos registradores **`x0` a `x7`**. **Parâmetros adicionais** são passados na **pilha**. O valor de **retorno** é passado de volta no registrador **`x0`**, ou em **`x1`** também **se for de 128 bits**. Os registradores **`x19`** a **`x30`** e **`sp`** devem ser **preservados** através das chamadas de função.
|
||||
|
||||
Ao ler uma função em assembly, procure pelo **prólogo e epílogo da função**. O **prólogo** geralmente envolve **salvar o ponteiro de quadro (`x29`)**, **configurar** um **novo ponteiro de quadro**, e **alocar espaço na pilha**. O **epílogo** geralmente envolve **restaurar o ponteiro de quadro salvo** e **retornar** da função.
|
||||
|
||||
|
|
@ -104,7 +106,7 @@ Swift tem sua própria **convenção de chamadas** que pode ser encontrada em [*
|
|||
|
||||
## **Instruções Comuns (ARM64v8)**
|
||||
|
||||
Instruções ARM64 geralmente têm o **formato `opcode dst, src1, src2`**, onde **`opcode`** é a **operação** a ser realizada (como `add`, `sub`, `mov`, etc.), **`dst`** é o registrador **destino** onde o resultado será armazenado, e **`src1`** e **`src2`** são os registradores **fonte**. Valores imediatos também podem ser usados no lugar dos registradores fonte.
|
||||
Instruções ARM64 geralmente têm o **formato `opcode dst, src1, src2`**, onde **`opcode`** é a **operação** a ser realizada (como `add`, `sub`, `mov`, etc.), **`dst`** é o **registrador de destino** onde o resultado será armazenado, e **`src1`** e **`src2`** são os **registradores de origem**. Valores imediatos também podem ser usados no lugar de registradores de origem.
|
||||
|
||||
* **`mov`**: **Move** um valor de um **registrador** para outro.
|
||||
* Exemplo: `mov x0, x1` — Isso move o valor de `x1` para `x0`.
|
||||
|
|
@ -123,10 +125,7 @@ Instruções ARM64 geralmente têm o **formato `opcode dst, src1, src2`**, onde
|
|||
* **`mul`**: **Multiplica** os valores de **dois registradores** e armazena o resultado em um registrador.
|
||||
* Exemplo: `mul x0, x1, x2` — Isso multiplica os valores em `x1` e `x2` e armazena o resultado em `x0`.
|
||||
* **`div`**: **Divide** o valor de um registrador por outro e armazena o resultado em um registrador.
|
||||
* Exemplo: `div x0, x1, x2` — Isso divide o valor em `x1` por `x2` e armazena o resultado em `x0`.
|
||||
* **`bl`**: **Ramifica** com link, usado para **chamar** uma **sub-rotina**. Armazena o **endereço de retorno em `x30`**.
|
||||
* Exemplo: `bl myFunction` — Isso chama a função `myFunction` e armazena o endereço de retorno em `x30`.
|
||||
* **`blr`**: **
|
||||
* Exemplo: `div x0, x1,
|
||||
```armasm
|
||||
ldp x29, x30, [sp], #16 ; load pair x29 and x30 from the stack and increment the stack pointer
|
||||
```
|
||||
|
|
@ -137,20 +136,79 @@ ldp x29, x30, [sp], #16 ; load pair x29 and x30 from the stack and increment th
|
|||
## Estado de Execução AARCH32
|
||||
|
||||
Armv8-A suporta a execução de programas de 32 bits. **AArch32** pode rodar em um de **dois conjuntos de instruções**: **`A32`** e **`T32`** e pode alternar entre eles via **`interworking`**.\
|
||||
Programas privilegiados de 64 bits podem agendar a **execução de programas de 32 bits** executando uma transferência de nível de exceção para o 32 bits menos privilegiado.\
|
||||
Note que a transição de 64 bits para 32 bits ocorre com uma redução do nível de exceção (por exemplo, um programa de 64 bits em EL1 acionando um programa em EL0). Isso é feito configurando o **bit 4 do** **`SPSR_ELx`** registro especial **para 1** quando o processo de thread `AArch32` está pronto para ser executado e o restante do `SPSR_ELx` armazena o CPSR dos programas **`AArch32`**. Então, o processo privilegiado chama a instrução **`ERET`** para que o processador faça a transição para **`AArch32`**, entrando em A32 ou T32 dependendo do CPSR**.**
|
||||
Programas **privilegiados** de 64 bits podem agendar a **execução de programas de 32 bits** executando uma transferência de nível de exceção para o 32 bits menos privilegiado.\
|
||||
Note que a transição de 64 bits para 32 bits ocorre com uma diminuição do nível de exceção (por exemplo, um programa de 64 bits em EL1 acionando um programa em EL0). Isso é feito configurando o **bit 4 do** **`SPSR_ELx`** registro especial **para 1** quando o thread do processo `AArch32` está pronto para ser executado e o restante do `SPSR_ELx` armazena o CPSR dos programas **`AArch32`**. Então, o processo privilegiado chama a instrução **`ERET`** para que o processador faça a transição para **`AArch32`**, entrando em A32 ou T32 dependendo do CPSR**.**
|
||||
|
||||
O **`interworking`** ocorre usando os bits J e T do CPSR. `J=0` e `T=0` significa **`A32`** e `J=0` e `T=1` significa **T32**. Isso basicamente se traduz em configurar o **bit mais baixo para 1** para indicar que o conjunto de instruções é T32.\
|
||||
Isso é configurado durante as **instruções de ramificação de interworking**, mas também pode ser configurado diretamente com outras instruções quando o PC é definido como o registro de destino. Exemplo:
|
||||
|
||||
Outro exemplo:
|
||||
```armasm
|
||||
_start:
|
||||
.code 32 ; Begin using A32
|
||||
add r4, pc, #1 ; Here PC is already pointing to "mov r0, #0"
|
||||
bx r4 ; Swap to T32 mode: Jump to "mov r0, #0" + 1 (so T32)
|
||||
|
||||
.code 16:
|
||||
mov r0, #0
|
||||
mov r0, #8
|
||||
```
|
||||
### Registradores
|
||||
|
||||
Existem 16 registradores de 32 bits (r0-r15). **Do r0 ao r14** eles podem ser usados para **qualquer operação**, no entanto, alguns deles geralmente são reservados:
|
||||
|
||||
* **`r15`**: Contador de programa (sempre). Contém o endereço da próxima instrução. Em A32 atual + 8, em T32, atual + 4.
|
||||
* **`r11`**: Ponteiro de Quadro
|
||||
* **`r12`**: Registrador de chamada intra-procedural
|
||||
* **`r13`**: Ponteiro de Pilha
|
||||
* **`r14`**: Registrador de Link
|
||||
|
||||
Além disso, os registradores são respaldados em **`registradores bancados`**. São locais que armazenam os valores dos registradores permitindo realizar **trocas de contexto rápidas** no tratamento de exceções e operações privilegiadas para evitar a necessidade de salvar e restaurar manualmente os registradores toda vez.\
|
||||
Isso é feito **salvando o estado do processador do `CPSR` para o `SPSR`** do modo de processador para o qual a exceção é tomada. Quando a exceção retorna, o **`CPSR`** é restaurado a partir do **`SPSR`**.
|
||||
|
||||
### CPSR - Registrador de Status do Programa Atual
|
||||
|
||||
Em AArch32, o CPSR funciona de maneira semelhante ao **`PSTATE`** em AArch64 e também é armazenado em **`SPSR_ELx`** quando uma exceção é tomada para restaurar posteriormente a execução:
|
||||
|
||||
<figure><img src="../../../.gitbook/assets/image (725).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Os campos são divididos em alguns grupos:
|
||||
|
||||
* Registrador de Status do Programa de Aplicação (APSR): Flags aritméticas e acessíveis a partir do EL0
|
||||
* Registradores de Estado de Execução: Comportamento do processo (gerenciado pelo SO).
|
||||
|
||||
#### Registrador de Status do Programa de Aplicação (APSR)
|
||||
|
||||
* As flags **`N`**, **`Z`**, **`C`**, **`V`** (assim como em AArch64)
|
||||
* A flag **`Q`**: É definida como 1 sempre que ocorre **saturação de inteiro** durante a execução de uma instrução aritmética de saturação especializada. Uma vez definida como **`1`**, manterá o valor até que seja manualmente redefinida para 0. Além disso, não há nenhuma instrução que verifique seu valor implicitamente, deve ser feito lendo manualmente.
|
||||
* Flags **`GE`** (Maior ou igual): São usadas em operações SIMD (Instrução Única, Dados Múltiplos), como "adição paralela" e "subtração paralela". Essas operações permitem processar vários pontos de dados em uma única instrução.
|
||||
|
||||
Por exemplo, a instrução **`UADD8`** **adiciona quatro pares de bytes** (de dois operandos de 32 bits) em paralelo e armazena os resultados em um registrador de 32 bits. Em seguida, **define as flags `GE` no `APSR`** com base nesses resultados. Cada flag GE corresponde a uma das adições de byte, indicando se a adição para aquele par de bytes **transbordou**.
|
||||
|
||||
A instrução **`SEL`** usa essas flags GE para realizar ações condicionais.
|
||||
|
||||
#### Registradores de Estado de Execução
|
||||
|
||||
* Os bits **`J`** e **`T`**: **`J`** deve ser 0 e se **`T`** for 0, o conjunto de instruções A32 é usado, e se for 1, o T32 é usado.
|
||||
* **Registrador de Estado do Bloco IT** (`ITSTATE`): São os bits de 10-15 e 25-26. Eles armazenam condições para instruções dentro de um grupo prefixado com **`IT`**.
|
||||
* Bit **`E`**: Indica a **ordenação dos bytes** (endianness). 
|
||||
* **Bits de Máscara de Modo e Exceção** (0-4): Determinam o estado atual de execução. O **quinto** indica se o programa é executado como 32 bits (um 1) ou 64 bits (um 0). Os outros 4 representam o **modo de exceção atualmente em uso** (quando uma exceção ocorre e está sendo tratada). O número definido **indica a prioridade atual** em caso de outra exceção ser acionada enquanto esta está sendo tratada.
|
||||
|
||||
<figure><img src="../../../.gitbook/assets/image (728).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
* **`AIF`**: Certas exceções podem ser desativadas usando os bits **`A`**, `I`, `F`. Se **`A`** for 1, significa que abortos assíncronos serão acionados. O **`I`** configura para responder a **Pedidos de Interrupção de Hardware Externo** (IRQs). e o F está relacionado a **Pedidos de Interrupção Rápida** (FIRs).
|
||||
|
||||
## macOS
|
||||
|
||||
### Chamadas de sistema BSD
|
||||
### Syscalls BSD
|
||||
|
||||
Confira [**syscalls.master**](https://opensource.apple.com/source/xnu/xnu-1504.3.12/bsd/kern/syscalls.master). Chamadas de sistema BSD terão **x16 > 0**.
|
||||
Confira [**syscalls.master**](https://opensource.apple.com/source/xnu/xnu-1504.3.12/bsd/kern/syscalls.master). Syscalls BSD terão **x16 > 0**.
|
||||
|
||||
### Armadilhas Mach
|
||||
|
||||
Confira [**syscall\_sw.c**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/kern/syscall\_sw.c.auto.html). Armadilhas Mach terão **x16 < 0**, então você precisa chamar os números da lista anterior com um **menos**: **`_kernelrpc_mach_vm_allocate_trap`** é **`-10`**.
|
||||
Confira [**syscall_sw.c**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/kern/syscall_sw.c.auto.html). Armadilhas Mach terão **x16 < 0**, então você precisa chamar os números da lista anterior com um **menos**: **`_kernelrpc_mach_vm_allocate_trap`** é **`-10`**.
|
||||
|
||||
Você também pode verificar **`libsystem_kernel.dylib`** em um desmontador para descobrir como chamar essas chamadas de sistema (e BSD):
|
||||
Você também pode verificar **`libsystem_kernel.dylib`** em um desmontador para descobrir como chamar essas syscalls (e BSD):
|
||||
```bash
|
||||
# macOS
|
||||
dyldex -e libsystem_kernel.dylib /System/Volumes/Preboot/Cryptexes/OS/System/Library/dyld/dyld_shared_cache_arm64e
|
||||
|
|
@ -159,7 +217,7 @@ dyldex -e libsystem_kernel.dylib /System/Volumes/Preboot/Cryptexes/OS/System/Lib
|
|||
dyldex -e libsystem_kernel.dylib /System/Library/Caches/com.apple.dyld/dyld_shared_cache_arm64
|
||||
```
|
||||
{% hint style="success" %}
|
||||
Às vezes é mais fácil verificar o código **decompilado** de **`libsystem_kernel.dylib`** **do que** verificar o **código fonte** porque o código de várias syscalls (BSD e Mach) é gerado por scripts (verifique os comentários no código fonte), enquanto na dylib você pode encontrar o que está sendo chamado.
|
||||
Às vezes é mais fácil verificar o código **decompilado** de **`libsystem_kernel.dylib`** do que verificar o **código fonte** porque o código de vários syscalls (BSD e Mach) é gerado por scripts (verifique os comentários no código fonte), enquanto na dylib você pode encontrar o que está sendo chamado.
|
||||
{% endhint %}
|
||||
|
||||
### Shellcodes
|
||||
|
|
@ -280,12 +338,9 @@ mov x16, #59 ; Move the execve syscall number (59) into x16.
|
|||
svc #0x1337 ; Make the syscall. The number 0x1337 doesn't actually matter, because the svc instruction always triggers a supervisor call, and the exact action is determined by the value in x16.
|
||||
|
||||
```
|
||||
{% endtab %}
|
||||
{% endtabs %}
|
||||
|
||||
#### Ler com cat
|
||||
|
||||
O objetivo é executar `execve("/bin/cat", ["/bin/cat", "/etc/passwd"], NULL)`, então o segundo argumento (x1) é um array de parâmetros (o que na memória significa uma pilha dos endereços).
|
||||
O objetivo é executar `execve("/bin/cat", ["/bin/cat", "/etc/passwd"], NULL)`, então o segundo argumento (x1) é um array de parâmetros (o que na memória significa uma pilha de endereços).
|
||||
```armasm
|
||||
.section __TEXT,__text ; Begin a new section of type __TEXT and name __text
|
||||
.global _main ; Declare a global symbol _main
|
||||
|
|
@ -518,6 +573,6 @@ Outras formas de apoiar o HackTricks:
|
|||
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga**-me no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
|
|||
Loading…
Reference in a new issue