hacktricks/src/network-services-pentesting/pentesting-web/README.md

# 80,443 - Metodologia Pentestingu Web

{{#include ../../banners/hacktricks-training.md}}

## Podstawowe informacje

Usługa internetowa jest najbardziej **powszechną i rozległą usługą** i istnieje wiele **różnych typów podatności**.

**Domyślny port:** 80 (HTTP), 443(HTTPS)
```bash
PORT    STATE SERVICE
80/tcp  open  http
443/tcp open  ssl/https
```

```bash
nc -v domain.com 80 # GET / HTTP/1.0
openssl s_client -connect domain.com:443 # GET / HTTP/1.0
```
### Web API Guidance

{{#ref}}
web-api-pentesting.md
{{#endref}}

## Podsumowanie metodologii

> W tej metodologii zakładamy, że będziesz atakować domenę (lub subdomenę) i tylko to. Dlatego powinieneś zastosować tę metodologię do każdej odkrytej domeny, subdomeny lub adresu IP z nieokreślonym serwerem webowym w zakresie.

- [ ] Zacznij od **identyfikacji** **technologii** używanych przez serwer webowy. Szukaj **sztuczek**, które warto mieć na uwadze podczas reszty testu, jeśli uda ci się pomyślnie zidentyfikować technologię.
- [ ] Czy istnieje jakakolwiek **znana luka** w wersji technologii?
- [ ] Używasz jakiejś **znanej technologii**? Jakieś **przydatne sztuczki** do wydobycia większej ilości informacji?
- [ ] Czy jest jakiś **specjalistyczny skaner** do uruchomienia (jak wpscan)?
- [ ] Uruchom **skanery ogólnego przeznaczenia**. Nigdy nie wiesz, czy znajdą coś interesującego.
- [ ] Zacznij od **wstępnych kontroli**: **robots**, **sitemap**, **błąd 404** i **skanowanie SSL/TLS** (jeśli HTTPS).
- [ ] Zacznij **spiderować** stronę internetową: Czas na **znalezienie** wszystkich możliwych **plików, folderów** i **parametrów używanych.** Sprawdź również **specjalne znaleziska**.
- [ ] _Zauważ, że za każdym razem, gdy nowy katalog zostanie odkryty podczas brute-forcingu lub spiderowania, powinien być on spiderowany._
- [ ] **Brute-Forcing katalogów**: Spróbuj przeprowadzić brute force na wszystkich odkrytych folderach w poszukiwaniu nowych **plików** i **katalogów**.
- [ ] _Zauważ, że za każdym razem, gdy nowy katalog zostanie odkryty podczas brute-forcingu lub spiderowania, powinien być on poddany brute force._
- [ ] **Sprawdzanie kopii zapasowych**: Sprawdź, czy możesz znaleźć **kopie zapasowe** **odkrytych plików**, dodając powszechne rozszerzenia kopii zapasowych.
- [ ] **Brute-Force parametrów**: Spróbuj **znaleźć ukryte parametry**.
- [ ] Gdy już **zidentyfikujesz** wszystkie możliwe **punkty końcowe** akceptujące **wejście użytkownika**, sprawdź wszelkiego rodzaju **luki** związane z tym.
- [ ] [Postępuj zgodnie z tą listą kontrolną](../../pentesting-web/web-vulnerabilities-methodology.md)

## Wersja serwera (Vulnerable?)

### Identyfikacja

Sprawdź, czy istnieją **znane luki** dla wersji serwera, która działa.\
**Nagłówki HTTP i ciasteczka odpowiedzi** mogą być bardzo przydatne do **identyfikacji** **technologii** i/lub **wersji** używanej. **Skanowanie Nmap** może zidentyfikować wersję serwera, ale mogą być również przydatne narzędzia [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech)lub [**https://builtwith.com/**](https://builtwith.com)**:**
```bash
whatweb -a 1 <URL> #Stealthy
whatweb -a 3 <URL> #Aggresive
webtech -u <URL>
webanalyze -host https://google.com -crawl 2
```
Search **for** [**vulnerabilities of the web application** **version**](../../generic-hacking/search-exploits.md)

### **Sprawdź, czy istnieje jakiś WAF**

- [**https://github.com/EnableSecurity/wafw00f**](https://github.com/EnableSecurity/wafw00f)
- [**https://github.com/Ekultek/WhatWaf.git**](https://github.com/Ekultek/WhatWaf.git)
- [**https://nmap.org/nsedoc/scripts/http-waf-detect.html**](https://nmap.org/nsedoc/scripts/http-waf-detect.html)

### Sztuczki technologii webowych

Kilka **sztuczek** do **znajdowania luk** w różnych znanych **technologiach**:

- [**AEM - Adobe Experience Cloud**](aem-adobe-experience-cloud.md)
- [**Apache**](apache.md)
- [**Artifactory**](artifactory-hacking-guide.md)
- [**Buckets**](buckets/index.html)
- [**CGI**](cgi.md)
- [**Drupal**](drupal/index.html)
- [**Flask**](flask.md)
- [**Git**](git.md)
- [**Golang**](golang.md)
- [**GraphQL**](graphql.md)
- [**H2 - Java SQL database**](h2-java-sql-database.md)
- [**IIS tricks**](iis-internet-information-services.md)
- [**Microsoft SharePoint**](microsoft-sharepoint.md)
- [**JBOSS**](jboss.md)
- [**Jenkins**](<[https:/github.com/carlospolop/hacktricks/blob/master/network-services-pentesting/pentesting-web/broken-reference/README.md](https:/github.com/HackTricks-wiki/hacktricks-cloud/tree/master/pentesting-ci-cd/jenkins-security)/>)
- [**Jira**](jira.md)
- [**Joomla**](joomla.md)
- [**JSP**](jsp.md)
- [**Laravel**](laravel.md)
- [**Moodle**](moodle.md)
- [**Nginx**](nginx.md)
- [**PHP (php ma wiele interesujących sztuczek, które mogą być wykorzystane)**](php-tricks-esp/index.html)
- [**Python**](python.md)
- [**Spring Actuators**](spring-actuators.md)
- [**Symphony**](symphony.md)
- [**Tomcat**](tomcat/index.html)
- [**VMWare**](vmware-esx-vcenter....md)
- [**Web API Pentesting**](web-api-pentesting.md)
- [**WebDav**](put-method-webdav.md)
- [**Werkzeug**](werkzeug.md)
- [**Wordpress**](wordpress.md)
- [**Electron Desktop (XSS do RCE)**](electron-desktop-apps/index.html)

_Pamiętaj, że **ta sama domena** może używać **różnych technologii** w różnych **portach**, **folderach** i **subdomenach**._\
Jeśli aplikacja webowa korzysta z jakiejkolwiek znanej **technologii/platformy wymienionej wcześniej** lub **jakiejkolwiek innej**, nie zapomnij **poszukać w Internecie** nowych sztuczek (i daj mi znać!).

### Przegląd kodu źródłowego

Jeśli **kod źródłowy** aplikacji jest dostępny na **github**, oprócz przeprowadzenia **własnego testu White box** aplikacji, istnieje **kilka informacji**, które mogą być **przydatne** dla obecnego **testowania Black-Box**:

- Czy istnieje plik **Change-log lub Readme lub Version** lub cokolwiek z **informacjami o wersji dostępnymi** przez sieć?
- Jak i gdzie są przechowywane **dane uwierzytelniające**? Czy istnieje jakiś (dostępny?) **plik** z danymi uwierzytelniającymi (nazwy użytkowników lub hasła)?
- Czy **hasła** są w **czystym tekście**, **szyfrowane** czy jaki **algorytm haszujący** jest używany?
- Czy używa jakiegoś **klucza głównego** do szyfrowania czegoś? Jaki **algorytm** jest używany?
- Czy możesz **uzyskać dostęp do któregokolwiek z tych plików**, wykorzystując jakąś lukę?
- Czy w **github** są jakieś **interesujące informacje** (rozwiązane i nierozwiązane) **problemy**? Lub w **historii commitów** (może jakieś **hasło wprowadzone w starym commicie**)?

{{#ref}}
code-review-tools.md
{{#endref}}

### Automatyczne skanery

#### Automatyczne skanery ogólnego przeznaczenia
```bash
nikto -h <URL>
whatweb -a 4 <URL>
wapiti -u <URL>
W3af
zaproxy #You can use an API
nuclei -ut && nuclei -target <URL>

# https://github.com/ignis-sec/puff (client side vulns fuzzer)
node puff.js -w ./wordlist-examples/xss.txt -u "http://www.xssgame.com/f/m4KKGHi2rVUN/?query=FUZZ"
```
#### Skanery CMS

Jeśli używany jest CMS, nie zapomnij **uruchomić skanera**, może znajdziesz coś interesującego:

[**Clusterd**](https://github.com/hatRiot/clusterd)**:** [**JBoss**](jboss.md)**, ColdFusion, WebLogic,** [**Tomcat**](tomcat/index.html)**, Railo, Axis2, Glassfish**\
[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** strony internetowe pod kątem problemów z bezpieczeństwem. (GUI)\
[**VulnX**](https://github.com/anouarbensaad/vulnx)**:** [**Joomla**](joomla.md)**,** [**Wordpress**](wordpress.md)**,** [**Drupal**](drupal/index.html)**, PrestaShop, Opencart**\
**CMSMap**: [**(W)ordpress**](wordpress.md)**,** [**(J)oomla**](joomla.md)**,** [**(D)rupal**](drupal/index.html) **lub** [**(M)oodle**](moodle.md)\
[**droopscan**](https://github.com/droope/droopescan)**:** [**Drupal**](drupal/index.html)**,** [**Joomla**](joomla.md)**,** [**Moodle**](moodle.md)**, Silverstripe,** [**Wordpress**](wordpress.md)
```bash
cmsmap [-f W] -F -d <URL>
wpscan --force update -e --url <URL>
joomscan --ec -u <URL>
joomlavs.rb #https://github.com/rastating/joomlavs
```
> W tym momencie powinieneś już mieć pewne informacje o serwerze WWW używanym przez klienta (jeśli podano jakiekolwiek dane) oraz kilka sztuczek, które warto mieć na uwadze podczas testu. Jeśli masz szczęście, być może znalazłeś nawet CMS i uruchomiłeś jakiś skaner.

## Krok po kroku Odkrywanie Aplikacji Webowej

> Od tego momentu zaczniemy interakcję z aplikacją webową.

### Wstępne kontrole

**Domyślne strony z interesującymi informacjami:**

- /robots.txt
- /sitemap.xml
- /crossdomain.xml
- /clientaccesspolicy.xml
- /.well-known/
- Sprawdź również komentarze na stronach głównych i podrzędnych.

**Wymuszanie błędów**

Serwery WWW mogą **zachowywać się nieprzewidywalnie**, gdy wysyłane są do nich dziwne dane. Może to otworzyć **luki** lub **ujawnienie wrażliwych informacji**.

- Uzyskaj dostęp do **fałszywych stron** jak /whatever_fake.php (.aspx,.html,.itd)
- **Dodaj "\[]", "]]" i "\[\["** w **wartościach cookie** i **wartościach parametrów**, aby stworzyć błędy
- Generuj błąd, podając dane jako **`/~randomthing/%s`** na **końcu** **URL**
- Spróbuj **różnych metod HTTP** jak PATCH, DEBUG lub błędnych jak FAKE

#### **Sprawdź, czy możesz przesyłać pliki (**[**PUT verb, WebDav**](put-method-webdav.md)**)**

Jeśli odkryjesz, że **WebDav** jest **włączony**, ale nie masz wystarczających uprawnień do **przesyłania plików** w folderze głównym, spróbuj:

- **Brute Force** poświadczeń
- **Przesyłać pliki** za pomocą WebDav do **pozostałych** **znalezionych folderów** na stronie internetowej. Możesz mieć uprawnienia do przesyłania plików w innych folderach.

### **Luki w SSL/TLS**

- Jeśli aplikacja **nie wymusza użycia HTTPS** w żadnej części, to jest **vulnerable to MitM**
- Jeśli aplikacja **wysyła wrażliwe dane (hasła) używając HTTP**. To jest poważna luka.

Użyj [**testssl.sh**](https://github.com/drwetter/testssl.sh), aby sprawdzić **luki** (w programach Bug Bounty prawdopodobnie tego rodzaju luki nie będą akceptowane) i użyj [**a2sv**](https://github.com/hahwul/a2sv), aby ponownie sprawdzić luki:
```bash
./testssl.sh [--htmlfile] 10.10.10.10:443
#Use the --htmlfile to save the output inside an htmlfile also

# You can also use other tools, by testssl.sh at this momment is the best one (I think)
sslscan <host:port>
sslyze --regular <ip:port>
```
Informacje o lukach SSL/TLS:

- [https://www.gracefulsecurity.com/tls-ssl-vulnerabilities/](https://www.gracefulsecurity.com/tls-ssl-vulnerabilities/)
- [https://www.acunetix.com/blog/articles/tls-vulnerabilities-attacks-final-part/](https://www.acunetix.com/blog/articles/tls-vulnerabilities-attacks-final-part/)

### Spidering

Uruchom jakiś rodzaj **spidera** w sieci. Celem spidera jest **znalezienie jak największej liczby ścieżek** z testowanej aplikacji. Dlatego należy wykorzystać przeszukiwanie sieci i zewnętrzne źródła, aby znaleźć jak najwięcej ważnych ścieżek.

- [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML spider, LinkFinder w plikach JS i zewnętrzne źródła (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com).
- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HML spider, z LinkFinder dla plików JS i Archive.org jako zewnętrzne źródło.
- [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): HTML spider, wskazuje również "soczyste pliki".
- [**evine** ](https://github.com/saeeddhqan/evine)(go): Interaktywny CLI HTML spider. Również przeszukuje Archive.org.
- [**meg**](https://github.com/tomnomnom/meg) (go): To narzędzie nie jest spiderem, ale może być przydatne. Możesz po prostu wskazać plik z hostami i plik ze ścieżkami, a meg pobierze każdą ścieżkę na każdym hoście i zapisze odpowiedź.
- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML spider z możliwościami renderowania JS. Wygląda jednak na to, że nie jest utrzymywany, wersja skompilowana jest stara, a obecny kod nie kompiluje się.
- [**gau**](https://github.com/lc/gau) (go): HTML spider, który korzysta z zewnętrznych dostawców (wayback, otx, commoncrawl).
- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Ten skrypt znajdzie adresy URL z parametrami i je wypisze.
- [**galer**](https://github.com/dwisiswant0/galer) (go): HTML spider z możliwościami renderowania JS.
- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider, z możliwościami beautify JS, zdolny do wyszukiwania nowych ścieżek w plikach JS. Warto również rzucić okiem na [JSScanner](https://github.com/dark-warlord14/JSScanner), który jest wrapperem LinkFinder.
- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Do wyodrębniania punktów końcowych zarówno w źródle HTML, jak i w osadzonych plikach javascript. Przydatne dla łowców błędów, zespołów red, ninja infosec.
- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Skrypt w pythonie 2.7 używający Tornado i JSBeautifier do parsowania względnych adresów URL z plików JavaScript. Przydatne do łatwego odkrywania żądań AJAX. Wygląda na to, że nie jest utrzymywany.
- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Dany plik (HTML) wyodrębni z niego adresy URL, używając sprytnych wyrażeń regularnych do znajdowania i wyodrębniania względnych adresów URL z brzydkich (minifikowanych) plików.
- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, kilka narzędzi): Zbiera interesujące informacje z plików JS, używając kilku narzędzi.
- [**subjs**](https://github.com/lc/subjs) (go): Znajduje pliki JS.
- [**page-fetch**](https://github.com/detectify/page-fetch) (go): Ładuje stronę w bezgłowym przeglądarku i wypisuje wszystkie załadowane adresy URL.
- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Narzędzie do odkrywania treści, łączące kilka opcji poprzednich narzędzi.
- [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): Rozszerzenie Burp do znajdowania ścieżek i parametrów w plikach JS.
- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Narzędzie, które, podając URL .js.map, uzyska zbeatyfikowany kod JS.
- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): To narzędzie służy do odkrywania punktów końcowych dla danego celu.
- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Odkrywa linki z maszyny wayback (również pobierając odpowiedzi w wayback i szukając więcej linków).
- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Przeszukuje (nawet wypełniając formularze) i również znajduje wrażliwe informacje, używając specyficznych wyrażeń regularnych.
- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite to zaawansowany wielofunkcyjny GUI web security Crawler/Spider zaprojektowany dla profesjonalistów w dziedzinie cyberbezpieczeństwa.
- [**jsluice**](https://github.com/BishopFox/jsluice) (go): To pakiet Go i [narzędzie wiersza poleceń](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) do wyodrębniania adresów URL, ścieżek, sekretów i innych interesujących danych z kodu źródłowego JavaScript.
- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge to proste **rozszerzenie Burp Suite** do **wyodrębniania parametrów i punktów końcowych** z żądania w celu stworzenia niestandardowej listy słów do fuzzingu i enumeracji.
- [**katana**](https://github.com/projectdiscovery/katana) (go): Świetne narzędzie do tego.
- [**Crawley**](https://github.com/s0rg/crawley) (go): Wypisuje każdy link, który jest w stanie znaleźć.

### Brute Force katalogów i plików

Rozpocznij **brute-forcing** od folderu głównego i upewnij się, że brute-forcesz **wszystkie** **znalezione katalogi** przy użyciu **tej metody** oraz wszystkie katalogi **odkryte** przez **Spidering** (możesz to robić **rekursywnie** i dodając na początku używanej listy słów nazwy znalezionych katalogów).\
Narzędzia:

- **Dirb** / **Dirbuster** - Wbudowane w Kali, **stare** (i **wolne**) ale funkcjonalne. Umożliwia auto-podpisane certyfikaty i wyszukiwanie rekurencyjne. Zbyt wolne w porównaniu do innych opcji.
- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: Nie pozwala na auto-podpisane certyfikaty, ale** umożliwia wyszukiwanie rekurencyjne.
- [**Gobuster**](https://github.com/OJ/gobuster) (go): Umożliwia auto-podpisane certyfikaty, **nie ma** **wyszukiwania** **rekurencyjnego**.
- [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- Szybki, wspiera wyszukiwanie rekurencyjne.**
- [**wfuzz**](https://github.com/xmendez/wfuzz) `wfuzz -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt https://domain.com/api/FUZZ`
- [**ffuf** ](https://github.com/ffuf/ffuf)- Szybki: `ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ`
- [**uro**](https://github.com/s0md3v/uro) (python): To nie jest spider, ale narzędzie, które, podając listę znalezionych adresów URL, usunie "zduplikowane" adresy URL.
- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Rozszerzenie Burp do tworzenia listy katalogów z historii burp różnych stron.
- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Usuwa adresy URL z zduplikowanymi funkcjonalnościami (na podstawie importów js).
- [**Chamaleon**](https://github.com/iustin24/chameleon): Używa wapalyzer do wykrywania używanych technologii i wybierania list słów do użycia.

**Zalecane słowniki:**

- [https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt](https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt)
- [**Dirsearch** wbudowany słownik](https://github.com/maurosoria/dirsearch/blob/master/db/dicc.txt)
- [http://gist.github.com/jhaddix/b80ea67d85c13206125806f0828f4d10](http://gist.github.com/jhaddix/b80ea67d85c13206125806f0828f4d10)
- [Assetnote wordlists](https://wordlists.assetnote.io)
- [https://github.com/danielmiessler/SecLists/tree/master/Discovery/Web-Content](https://github.com/danielmiessler/SecLists/tree/master/Discovery/Web-Content)
- raft-large-directories-lowercase.txt
- directory-list-2.3-medium.txt
- RobotsDisallowed/top10000.txt
- [https://github.com/random-robbie/bruteforce-lists](https://github.com/random-robbie/bruteforce-lists)
- [https://github.com/google/fuzzing/tree/master/dictionaries](https://github.com/google/fuzzing/tree/master/dictionaries)
- [https://github.com/six2dez/OneListForAll](https://github.com/six2dez/OneListForAll)
- [https://github.com/random-robbie/bruteforce-lists](https://github.com/random-robbie/bruteforce-lists)
- [https://github.com/ayoubfathi/leaky-paths](https://github.com/ayoubfathi/leaky-paths)
- _/usr/share/wordlists/dirb/common.txt_
- _/usr/share/wordlists/dirb/big.txt_
- _/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt_

_Note, że za każdym razem, gdy nowy katalog zostanie odkryty podczas brute-forcingu lub spideringu, powinien być Brute-Forced._

### Co sprawdzić w każdym znalezionym pliku

- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Znajdź uszkodzone linki w HTML, które mogą być podatne na przejęcia.
- **Kopie zapasowe plików**: Gdy znajdziesz wszystkie pliki, poszukaj kopii zapasowych wszystkich plików wykonywalnych ("_.php_", "_.aspx_"...). Typowe warianty nazewnictwa kopii zapasowej to: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp i file.old._ Możesz również użyć narzędzia [**bfac**](https://github.com/mazen160/bfac) **lub** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.**
- **Odkryj nowe parametry**: Możesz użyć narzędzi takich jak [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **i** [**Param Miner**](https://github.com/PortSwigger/param-miner) **do odkrywania ukrytych parametrów. Jeśli możesz, spróbuj wyszukiwać** ukryte parametry w każdym wykonywalnym pliku webowym.
- _Arjun wszystkie domyślne listy słów:_ [https://github.com/s0md3v/Arjun/tree/master/arjun/db](https://github.com/s0md3v/Arjun/tree/master/arjun/db)
- _Param-miner “params” :_ [https://github.com/PortSwigger/param-miner/blob/master/resources/params](https://github.com/PortSwigger/param-miner/blob/master/resources/params)
- _Assetnote “parameters_top_1m”:_ [https://wordlists.assetnote.io/](https://wordlists.assetnote.io)
- _nullenc0de “params.txt”:_ [https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773](https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773)
- **Komentarze:** Sprawdź komentarze wszystkich plików, możesz znaleźć **dane uwierzytelniające** lub **ukrytą funkcjonalność**.
- Jeśli grasz w **CTF**, "powszechnym" trikiem jest **ukrywanie** **informacji** w komentarzach po **prawej** stronie **strony** (używając **setek** **spacji**, aby nie widzieć danych, gdy otworzysz kod źródłowy w przeglądarce). Inną możliwością jest użycie **wielu nowych linii** i **ukrycie informacji** w komentarzu na **dole** strony internetowej.
- **Klucze API**: Jeśli **znajdziesz jakikolwiek klucz API**, istnieje przewodnik, który wskazuje, jak używać kluczy API różnych platform: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**](<https://github.com/l4yton/RegHex)/>)**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird)
- Klucze API Google: Jeśli znajdziesz jakikolwiek klucz API wyglądający jak **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik, możesz użyć projektu [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner), aby sprawdzić, do jakich API klucz ma dostęp.
- **S3 Buckets**: Podczas spideringu sprawdź, czy jakikolwiek **subdomen** lub jakikolwiek **link** jest związany z jakimś **S3 bucket**. W takim przypadku, [**sprawdź** **uprawnienia** bucketu](buckets/index.html).

### Specjalne znaleziska

**Podczas** wykonywania **spideringu** i **brute-forcingu** możesz znaleźć **interesujące** **rzeczy**, na które musisz **zwrócić uwagę**.

**Interesujące pliki**

- Szukaj **linków** do innych plików w **plikach CSS**.
- [Jeśli znajdziesz plik _**.git**_, można wyodrębnić pewne informacje](git.md).
- Jeśli znajdziesz _**.env**_, można znaleźć takie informacje jak klucze API, hasła do baz danych i inne informacje.
- Jeśli znajdziesz **punkty końcowe API**, [powinieneś je również przetestować](web-api-pentesting.md). To nie są pliki, ale prawdopodobnie "wyglądają jak" one.
- **Pliki JS**: W sekcji spideringu wspomniano o kilku narzędziach, które mogą wyodrębnić ścieżki z plików JS. Również, warto **monitorować każdy znaleziony plik JS**, ponieważ w niektórych przypadkach zmiana może wskazywać, że potencjalna luka została wprowadzona w kodzie. Możesz użyć na przykład [**JSMon**](https://github.com/robre/jsmon)**.**
- Powinieneś również sprawdzić odkryte pliki JS za pomocą [**RetireJS**](https://github.com/retirejs/retire.js/) lub [**JSHole**](https://github.com/callforpapers-source/jshole), aby sprawdzić, czy są podatne.
- **Deobfuscator i Unpacker JavaScript:** [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator)
- **Beautifier JavaScript:** [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org)
- **Deobfuskacja JsFuck** (javascript z znakami:"\[]!+" [https://enkhee-osiris.github.io/Decoder-JSFuck/](https://enkhee-osiris.github.io/Decoder-JSFuck/))
- [**TrainFuck**](https://github.com/taco-c/trainfuck)**:** `+72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.`
- W wielu przypadkach będziesz musiał **zrozumieć wyrażenia regularne** używane. To będzie przydatne: [https://regex101.com/](https://regex101.com) lub [https://pythonium.net/regex](https://pythonium.net/regex).
- Możesz również **monitorować pliki, w których wykryto formularze**, ponieważ zmiana w parametrze lub pojawienie się nowego formularza może wskazywać na potencjalnie nową podatną funkcjonalność.

**403 Forbidden/Basic Authentication/401 Unauthorized (obejście)**

{{#ref}}
403-and-401-bypasses.md
{{#endref}}

**502 Proxy Error**

Jeśli jakakolwiek strona **odpowiada** tym **kodem**, prawdopodobnie jest to **źle skonfigurowany proxy**. **Jeśli wyślesz żądanie HTTP takie jak: `GET https://google.com HTTP/1.1`** (z nagłówkiem hosta i innymi typowymi nagłówkami), **proxy** spróbuje **uzyskać dostęp** do _**google.com**_ **i znajdziesz** SSRF.

**NTLM Authentication - ujawnienie informacji**

Jeśli działający serwer prosi o uwierzytelnienie i jest **Windows** lub znajdziesz logowanie proszące o twoje **dane uwierzytelniające** (i pytające o **nazwa domeny**), możesz wywołać **ujawnienie informacji**.\
**Wyślij** nagłówek: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` i z powodu tego, jak działa **uwierzytelnianie NTLM**, serwer odpowie wewnętrznymi informacjami (wersja IIS, wersja Windows...) w nagłówku "WWW-Authenticate".\
Możesz **zautomatyzować** to, używając **pluginu nmap** "_http-ntlm-info.nse_".

**HTTP Redirect (CTF)**

Możliwe jest **umieszczenie treści** wewnątrz **przekierowania**. Ta treść **nie będzie widoczna dla użytkownika** (ponieważ przeglądarka wykona przekierowanie), ale coś może być **ukryte** w środku.

### Sprawdzanie luk w aplikacjach webowych

Teraz, gdy przeprowadzono kompleksową enumerację aplikacji webowej, czas sprawdzić wiele możliwych luk. Możesz znaleźć listę kontrolną tutaj:

{{#ref}}
../../pentesting-web/web-vulnerabilities-methodology.md
{{#endref}}

Więcej informacji o lukach webowych znajdziesz na:

- [https://six2dez.gitbook.io/pentest-book/others/web-checklist](https://six2dez.gitbook.io/pentest-book/others/web-checklist)
- [https://kennel209.gitbooks.io/owasp-testing-guide-v4/content/en/web_application_security_testing/configuration_and_deployment_management_testing.html](https://kennel209.gitbooks.io/owasp-testing-guide-v4/content/en/web_application_security_testing/configuration_and_deployment_management_testing.html)
- [https://owasp-skf.gitbook.io/asvs-write-ups/kbid-111-client-side-template-injection](https://owasp-skf.gitbook.io/asvs-write-ups/kbid-111-client-side-template-injection)

### Monitorowanie stron pod kątem zmian

Możesz użyć narzędzi takich jak [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io), aby monitorować strony pod kątem modyfikacji, które mogą wprowadzać luki.

### HackTricks Automatyczne Komendy
```
Protocol_Name: Web    #Protocol Abbreviation if there is one.
Port_Number:  80,443     #Comma separated if there is more than one.
Protocol_Description: Web         #Protocol Abbreviation Spelled out

Entry_1:
Name: Notes
Description: Notes for Web
Note: |
https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/index.html

Entry_2:
Name: Quick Web Scan
Description: Nikto and GoBuster
Command: nikto -host {Web_Proto}://{IP}:{Web_Port} &&&& gobuster dir -w {Small_Dirlist} -u {Web_Proto}://{IP}:{Web_Port} && gobuster dir -w {Big_Dirlist} -u {Web_Proto}://{IP}:{Web_Port}

Entry_3:
Name: Nikto
Description: Basic Site Info via Nikto
Command: nikto -host {Web_Proto}://{IP}:{Web_Port}

Entry_4:
Name: WhatWeb
Description: General purpose auto scanner
Command: whatweb -a 4 {IP}

Entry_5:
Name: Directory Brute Force Non-Recursive
Description:  Non-Recursive Directory Brute Force
Command: gobuster dir -w {Big_Dirlist} -u {Web_Proto}://{IP}:{Web_Port}

Entry_6:
Name: Directory Brute Force Recursive
Description: Recursive Directory Brute Force
Command: python3 {Tool_Dir}dirsearch/dirsearch.py -w {Small_Dirlist} -e php,exe,sh,py,html,pl -f -t 20 -u {Web_Proto}://{IP}:{Web_Port} -r 10

Entry_7:
Name: Directory Brute Force CGI
Description: Common Gateway Interface Brute Force
Command: gobuster dir -u {Web_Proto}://{IP}:{Web_Port}/ -w /usr/share/seclists/Discovery/Web-Content/CGIs.txt -s 200

Entry_8:
Name: Nmap Web Vuln Scan
Description: Tailored Nmap Scan for web Vulnerabilities
Command: nmap -vv --reason -Pn -sV -p {Web_Port} --script=`banner,(http* or ssl*) and not (brute or broadcast or dos or external or http-slowloris* or fuzzer)` {IP}

Entry_9:
Name: Drupal
Description: Drupal Enumeration Notes
Note: |
git clone https://github.com/immunIT/drupwn.git for low hanging fruit and git clone https://github.com/droope/droopescan.git for deeper enumeration

Entry_10:
Name: WordPress
Description: WordPress Enumeration with WPScan
Command: |
?What is the location of the wp-login.php? Example: /Yeet/cannon/wp-login.php
wpscan --url {Web_Proto}://{IP}{1} --enumerate ap,at,cb,dbe && wpscan --url {Web_Proto}://{IP}{1} --enumerate u,tt,t,vp --passwords {Big_Passwordlist} -e

Entry_11:
Name: WordPress Hydra Brute Force
Description: Need User (admin is default)
Command: hydra -l admin -P {Big_Passwordlist} {IP} -V http-form-post '/wp-login.php:log=^USER^&pwd=^PASS^&wp-submit=Log In&testcookie=1:S=Location'

Entry_12:
Name: Ffuf Vhost
Description: Simple Scan with Ffuf for discovering additional vhosts
Command: ffuf -w {Subdomain_List}:FUZZ -u {Web_Proto}://{Domain_Name} -H "Host:FUZZ.{Domain_Name}" -c -mc all {Ffuf_Filters}
```
{{#include ../../banners/hacktricks-training.md}}