diff --git a/src/pentesting-ci-cd/supabase-security.md b/src/pentesting-ci-cd/supabase-security.md index 72ecf9652..8fa887aa0 100644 --- a/src/pentesting-ci-cd/supabase-security.md +++ b/src/pentesting-ci-cd/supabase-security.md @@ -4,7 +4,7 @@ ## Informações Básicas -De acordo com sua [**página de aterrissagem**](https://supabase.com/): Supabase é uma alternativa de código aberto ao Firebase. Comece seu projeto com um banco de dados Postgres, Autenticação, APIs instantâneas, Funções Edge, assinaturas em tempo real, Armazenamento e embeddings vetoriais. +As per their [**landing page**](https://supabase.com/): Supabase é uma alternativa open source ao Firebase. Inicie seu projeto com um banco Postgres, Authentication, instant APIs, Edge Functions, Realtime subscriptions, Storage, e Vector embeddings. ### Subdomínio @@ -13,37 +13,37 @@ Basicamente, quando um projeto é criado, o usuário receberá um subdomínio su ## **Configuração do banco de dados** > [!TIP] -> **Esses dados podem ser acessados a partir de um link como `https://supabase.com/dashboard/project//settings/database`** +> **This data can be accessed from a link like `https://supabase.com/dashboard/project//settings/database`** -Este **banco de dados** será implantado em alguma região da AWS, e para se conectar a ele, seria possível fazer isso conectando-se a: `postgres://postgres.jnanozjdybtpqgcwhdiz:[YOUR-PASSWORD]@aws-0-us-west-1.pooler.supabase.com:5432/postgres` (isso foi criado em us-west-1).\ -A senha é uma **senha que o usuário colocou** anteriormente. +Esse **banco de dados** será implantado em alguma região AWS, e para se conectar a ele é possível conectar-se através de: `postgres://postgres.jnanozjdybtpqgcwhdiz:[YOUR-PASSWORD]@aws-0-us-west-1.pooler.supabase.com:5432/postgres` (isso foi criado em us-west-1).\ +A senha é uma **senha que o usuário colocou** previamente. -Portanto, como o subdomínio é conhecido e é usado como nome de usuário e as regiões da AWS são limitadas, pode ser possível tentar **forçar a senha**. +Portanto, como o subdomínio é conhecido e é usado como nome de usuário e as regiões AWS são limitadas, pode ser possível tentar **brute force the password**. Esta seção também contém opções para: - Redefinir a senha do banco de dados -- Configurar o pooling de conexões -- Configurar SSL: Rejeitar conexões em texto simples (por padrão, estão habilitadas) -- Configurar o tamanho do disco -- Aplicar restrições e proibições de rede +- Configurar connection pooling +- Configurar SSL: Rejeitar conexões em plain-text (por padrão elas estão habilitadas) +- Configurar tamanho do disco +- Aplicar restrições e bans de rede ## Configuração da API > [!TIP] -> **Esses dados podem ser acessados a partir de um link como `https://supabase.com/dashboard/project//settings/api`** +> **This data can be accessed from a link like `https://supabase.com/dashboard/project//settings/api`** -A URL para acessar a API do supabase em seu projeto será como: `https://jnanozjdybtpqgcwhdiz.supabase.co`. +A URL para acessar a API do supabase no seu projeto será algo como: `https://jnanozjdybtpqgcwhdiz.supabase.co`. -### chaves da API anon +### anon api keys -Ele também gerará uma **chave da API anon** (`role: "anon"`), como: `eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImpuYW5vemRyb2J0cHFnY3doZGl6Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3MTQ5OTI3MTksImV4cCI6MjAzMDU2ODcxOX0.sRN0iMGM5J741pXav7UxeChyqBE9_Z-T0tLA9Zehvqk` que a aplicação precisará usar para contatar a chave da API exposta em nosso exemplo em +Também será gerada uma **anon API key** (`role: "anon"`), como: `eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImpuYW5vemRyb2J0cHFnY3doZGl6Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3MTQ5OTI3MTksImV4cCI6MjAzMDU2ODcxOX0.sRN0iMGM5J741pXav7UxeChyqBE9_Z-T0tLA9Zehvqk` que a aplicação precisará usar para contatar a API exposta em nosso exemplo em -É possível encontrar a API REST para contatar esta API na [**docs**](https://supabase.com/docs/reference/self-hosting-auth/returns-the-configuration-settings-for-the-gotrue-server), mas os endpoints mais interessantes seriam: +É possível encontrar a REST API para contatar essa API na [**docs**](https://supabase.com/docs/reference/self-hosting-auth/returns-the-configuration-settings-for-the-gotrue-server), mas os endpoints mais interessantes seriam:
-Cadastro (/auth/v1/signup) +Signup (/auth/v1/signup) ``` POST /auth/v1/signup HTTP/2 Host: id.io.net @@ -72,7 +72,7 @@ Priority: u=1, i
-Login (/auth/v1/token?grant_type=password) +Entrar (/auth/v1/token?grant_type=password) ``` POST /auth/v1/token?grant_type=password HTTP/2 Host: hypzbtgspjkludjcnjxl.supabase.co @@ -99,61 +99,171 @@ Priority: u=1, i ```
-Então, sempre que você descobrir um cliente usando supabase com o subdomínio que lhe foi concedido (é possível que um subdomínio da empresa tenha um CNAME sobre seu subdomínio supabase), você pode tentar **criar uma nova conta na plataforma usando a API supabase**. +Então, sempre que você descobrir um cliente usando supabase com o subdomínio que lhe foi concedido (é possível que um subdomínio da empresa tenha um CNAME sobre o subdomínio supabase deles), você pode tentar **criar uma nova conta na plataforma usando a API do supabase**. -### chaves de api secret / service_role +### secret / service_role api keys -Uma chave de API secreta também será gerada com **`role: "service_role"`**. Esta chave de API deve ser secreta porque será capaz de contornar **Row Level Security**. +Uma chave API secreta também será gerada com **`role: "service_role"`**. Essa chave API deve ser mantida em segredo porque será capaz de contornar o **Row Level Security**. -A chave de API se parece com isso: `eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImpuYW5vemRyb2J0cHFnY3doZGl6Iiwicm9sZSI6InNlcnZpY2Vfcm9sZSIsImlhdCI6MTcxNDk5MjcxOSwiZXhwIjoyMDMwNTY4NzE5fQ.0a8fHGp3N_GiPq0y0dwfs06ywd-zhTwsm486Tha7354` +A chave API se parece com isto: `eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImpuYW5vemRyb2J0cHFnY3doZGl6Iiwicm9sZSI6InNlcnZpY2Vfcm9sZSIsImlhdCI6MTcxNDk5MjcxOSwiZXhwIjoyMDMwNTY4NzE5fQ.0a8fHGp3N_GiPq0y0dwfs06ywd-zhTwsm486Tha7354` ### JWT Secret -Um **JWT Secret** também será gerado para que a aplicação possa **criar e assinar tokens JWT personalizados**. +Um **Segredo JWT** também será gerado para que a aplicação possa **criar e assinar tokens JWT personalizados**. -## Autenticação +## Authentication -### Inscrições +### Signups > [!TIP] -> Por **padrão**, o supabase permitirá que **novos usuários criem contas** em seu projeto usando os endpoints de API mencionados anteriormente. +> Por **padrão** o supabase permitirá que **novos usuários criem contas** no seu projeto usando os endpoints de API mencionados anteriormente. -No entanto, essas novas contas, por padrão, **precisarão validar seu endereço de e-mail** para poder fazer login na conta. É possível habilitar **"Permitir logins anônimos"** para permitir que as pessoas façam login sem verificar seu endereço de e-mail. Isso pode conceder acesso a **dados inesperados** (eles recebem os papéis `public` e `authenticated`).\ -Isso é uma ideia muito ruim porque o supabase cobra por usuário ativo, então as pessoas poderiam criar usuários e fazer login e o supabase cobrará por esses: +No entanto, essas novas contas, por padrão, **precisarão validar seu endereço de email** para conseguir fazer login na conta. É possível habilitar **"Allow anonymous sign-ins"** para permitir que pessoas façam login sem verificar seu email. Isso pode conceder acesso a **dados inesperados** (eles recebem os papéis `public` e `authenticated`).\ +Isso é uma péssima ideia porque o supabase cobra por usuário ativo, então pessoas poderiam criar usuários e fazer login e o supabase cobraria por esses:
-### Senhas e sessões +#### Auth: Server-side signup enforcement -É possível indicar o comprimento mínimo da senha (por padrão), requisitos (nenhum por padrão) e proibir o uso de senhas vazadas.\ -É recomendado **melhorar os requisitos, pois os padrões são fracos**. +Esconder o botão de cadastro no frontend não é suficiente. Se o **Auth server ainda permite signups**, um atacante pode chamar a API diretamente com a `anon` key pública e criar usuários arbitrários. -- Sessões de Usuário: É possível configurar como as sessões de usuário funcionam (timeouts, 1 sessão por usuário...) -- Proteção contra Bots e Abusos: É possível habilitar Captcha. +Teste rápido (a partir de um cliente não autenticado): +```bash +curl -X POST \ +-H "apikey: " \ +-H "Authorization: Bearer " \ +-H "Content-Type: application/json" \ +-d '{"email":"attacker@example.com","password":"Sup3rStr0ng!"}' \ +https://.supabase.co/auth/v1/signup +``` +Endurecimento esperado: +- Desative cadastros por email/senha no Dashboard: Authentication → Providers → Email → Disable sign ups (invite-only), ou defina a configuração equivalente do GoTrue. +- Verifique que a API agora retorna 4xx para a chamada anterior e que nenhum novo usuário é criado. +- Se você depende de invites ou SSO, garanta que todos os outros providers estejam desativados, a menos que sejam explicitamente necessários. -### Configurações SMTP +## RLS and Views: Write bypass via PostgREST -É possível definir um SMTP para enviar e-mails. +Using a Postgres VIEW to “hide” sensitive columns and exposing it via PostgREST can change how privileges are evaluated. In PostgreSQL: +- Ordinary views execute with the privileges of the view owner by default (definer semantics). In PG ≥15 you can opt into `security_invoker`. +- Row Level Security (RLS) applies on base tables. Table owners bypass RLS unless `FORCE ROW LEVEL SECURITY` is set on the table. +- Updatable views can accept INSERT/UPDATE/DELETE that are then applied to the base table. Without `WITH CHECK OPTION`, writes that don’t match the view predicate may still succeed. -### Configurações Avançadas +Padrão de risco observado no mundo real: +- A reduced-column view is exposed through Supabase REST and granted to `anon`/`authenticated`. +- PostgREST allows DML on the updatable view and the operation is evaluated with the view owner’s privileges, effectively bypassing the intended RLS policies on the base table. +- Result: low-privileged clients can mass-edit rows (e.g., profile bios/avatars) they should not be able to modify. -- Definir tempo de expiração para tokens de acesso (3600 por padrão) -- Definir para detectar e revogar tokens de atualização potencialmente comprometidos e timeout -- MFA: Indicar quantos fatores MFA podem ser registrados de uma vez por usuário (10 por padrão) -- Máximo de Conexões Diretas ao Banco de Dados: Número máximo de conexões usadas para autenticação (10 por padrão) -- Duração Máxima da Solicitação: Tempo máximo permitido para uma solicitação de autenticação durar (10s por padrão) +Illustrative write via view (attempted from a public client): +```bash +curl -X PATCH \ +-H "apikey: " \ +-H "Authorization: Bearer " \ +-H "Content-Type: application/json" \ +-H "Prefer: return=representation" \ +-d '{"bio":"pwned","avatar_url":"https://i.example/pwn.png"}' \ +"https://.supabase.co/rest/v1/users_view?id=eq." +``` +Hardening checklist for views and RLS: +- Prefer exposing base tables with explicit, least-privilege grants and precise RLS policies. +- If you must expose a view: +- Make it non-updatable (e.g., include expressions/joins) or deny `INSERT/UPDATE/DELETE` on the view to all untrusted roles. +- Enforce `ALTER VIEW SET (security_invoker = on)` so the invoker’s privileges are used instead of the owner’s. +- On base tables, use `ALTER TABLE FORCE ROW LEVEL SECURITY;` so even owners are subject to RLS. +- If allowing writes via an updatable view, add `WITH [LOCAL|CASCADED] CHECK OPTION` and complementary RLS on base tables to ensure only allowed rows can be written/changed. +- In Supabase, avoid granting `anon`/`authenticated` any write privileges on views unless you have verified end-to-end behavior with tests. -## Armazenamento +Detection tip: +- From `anon` and an `authenticated` test user, attempt all CRUD operations against every exposed table/view. Any successful write where you expected denial indicates a misconfiguration. + +### Sondagem CRUD via OpenAPI a partir das roles anon/auth + +PostgREST exposes an OpenAPI document that you can use to enumerate all REST resources, then automatically probe allowed operations from low-privileged roles. + +Recupere o OpenAPI (works with the public anon key): +```bash +curl -s https://.supabase.co/rest/v1/ \ +-H "apikey: " \ +-H "Authorization: Bearer " \ +-H "Accept: application/openapi+json" | jq '.paths | keys[]' +``` +Padrão de sondagem (exemplos): +- Ler um único registro (esperar 401/403/200 dependendo do RLS): +```bash +curl -s "https://.supabase.co/rest/v1/?select=*&limit=1" \ +-H "apikey: " \ +-H "Authorization: Bearer " +``` +- Teste se UPDATE está bloqueado (use um filtro inexistente para evitar alterar dados durante os testes): +```bash +curl -i -X PATCH \ +-H "apikey: " \ +-H "Authorization: Bearer " \ +-H "Content-Type: application/json" \ +-H "Prefer: return=minimal" \ +-d '{"__probe":true}' \ +"https://.supabase.co/rest/v1/?id=eq.00000000-0000-0000-0000-000000000000" +``` +- Teste INSERT está bloqueado: +```bash +curl -i -X POST \ +-H "apikey: " \ +-H "Authorization: Bearer " \ +-H "Content-Type: application/json" \ +-H "Prefer: return=minimal" \ +-d '{"__probe":true}' \ +"https://.supabase.co/rest/v1/" +``` +- Testar se DELETE está bloqueado: +```bash +curl -i -X DELETE \ +-H "apikey: " \ +-H "Authorization: Bearer " \ +"https://.supabase.co/rest/v1/?id=eq.00000000-0000-0000-0000-000000000000" +``` +Recommendations: +- Automatize as sondagens anteriores para tanto `anon` quanto um usuário minimamente `authenticated` e integre-as no CI para detectar regressões. +- Trate every exposed table/view/function como uma superfície de primeira classe. Don’t assume uma view “inherits” the same RLS posture as its base tables. + +### Passwords & sessions + +É possível indicar o tamanho mínimo da senha (por padrão), requisitos (nenhum por padrão) e proibir o uso de leaked passwords.\ +Recomenda-se **melhorar os requisitos, pois os padrões são fracos**. + +- User Sessions: É possível configurar como as user sessions funcionam (timeouts, 1 session per user...) +- Bot and Abuse Protection: É possível habilitar Captcha. + +### SMTP Settings + +É possível configurar um SMTP para enviar e-mails. + +### Advanced Settings + +- Definir tempo de expiração para access tokens (3600 por padrão) +- Configurar para detectar e revogar refresh tokens potencialmente comprometidos e timeout +- MFA: Indicar quantos fatores MFA podem ser registrados ao mesmo tempo por usuário (10 por padrão) +- Max Direct Database Connections: Número máximo de conexões diretas usadas para autenticação (10 por padrão) +- Max Request Duration: Tempo máximo permitido para uma requisição de Auth durar (10s por padrão) + +## Storage > [!TIP] -> O supabase permite **armazenar arquivos** e torná-los acessíveis por meio de uma URL (ele usa buckets S3). +> Supabase permite **armazenar arquivos** e torná-los acessíveis por meio de uma URL (usa S3 buckets). -- Definir o limite de tamanho do arquivo de upload (o padrão é 50MB) -- A conexão S3 é dada com uma URL como: `https://jnanozjdybtpqgcwhdiz.supabase.co/storage/v1/s3` -- É possível **solicitar uma chave de acesso S3** que é formada por um `access key ID` (por exemplo, `a37d96544d82ba90057e0e06131d0a7b`) e uma `secret access key` (por exemplo, `58420818223133077c2cec6712a4f909aec93b4daeedae205aa8e30d5a860628`) +- Defina o limite de tamanho de arquivo para upload (padrão 50MB) +- A conexão S3 é fornecida com uma URL como: `https://jnanozjdybtpqgcwhdiz.supabase.co/storage/v1/s3` +- É possível **solicitar S3 access key** que são formadas por um `access key ID` (e.g. `a37d96544d82ba90057e0e06131d0a7b`) e um `secret access key` (e.g. `58420818223133077c2cec6712a4f909aec93b4daeedae205aa8e30d5a860628`) -## Funções Edge +## Edge Functions -É possível **armazenar segredos** no supabase também, que serão **acessíveis por funções edge** (elas podem ser criadas e excluídas pela web, mas não é possível acessar seu valor diretamente). +Também é possível **armazenar segredos** no supabase que serão **acessíveis por edge functions** (eles podem ser criados e deletados pela web, mas não é possível acessar seus valores diretamente). + +## References + +- [Building Hacker Communities: Bug Bounty Village, getDisclosed’s Supabase Misconfig, and the LHE Squad (Ep. 133) – YouTube](https://youtu.be/NI-eXMlXma4) +- [Critical Thinking Podcast – Episode 133 page](https://www.criticalthinkingpodcast.io/episode-133-building-hacker-communities-bug-bounty-village-getdisclosed-and-the-lhe-squad/) +- [Supabase: Row Level Security (RLS)](https://supabase.com/docs/guides/auth/row-level-security) +- [PostgreSQL: Row Security Policies](https://www.postgresql.org/docs/current/ddl-rowsecurity.html) +- [PostgreSQL: CREATE VIEW (security_invoker, check option)](https://www.postgresql.org/docs/current/sql-createview.html) +- [PostgREST: OpenAPI documentation](https://postgrest.org/en/stable/references/api.html#openapi-documentation) {{#include ../banners/hacktricks-training.md}}