Model extraction attacks consistono nel tentativo, da parte di un avversario, di ricostruire un modello surrogato interrogando sistematicamente un modello di machine learning. Queste attività rappresentano un rischio significativo per la proprietà intellettuale ed espongono il modello a ulteriori vulnerabilità, come attacchi adversarial e potenziale estrazione di dati sensibili.
Questo articolo fa parte del capitolo AI Application Testing della OWASP AI Testing Guide.
Obiettivi del test
- Individuare la suscettibilità del modello a tentativi di model extraction con strategie di query differenti.
- Valutare la resilienza del modello contro attività di replica del comportamento.
- Garantire l’efficacia dei meccanismi difensivi implementati per ostacolare o impedire la model extraction.
Metodologia e payload
Interrogazione sistematica con strategie adattive (black-box extraction)
Il test simula un attacco black-box dove l’avversario, con accesso API, prova a sottrarre le funzionalità del modello addestrando un surrogato sulle sue predizioni. Si procede tramite interrogazioni sistematiche utilizzando strategie di query adattive.
Indicazione di vulnerabilità: il modello surrogato ricostruito raggiunge alta accuratezza e similarità predittiva rispetto al modello originale.
Estrazione basata sulle confidence
Utilizzo di tecniche che sfruttano la probabilità di output per l’estrazione, analizzando i livelli di confidenza restituiti dal modello target.
Indicazione di vulnerabilità: il modello surrogato imita comportamento e predizioni del modello originale con precisione significativa.
Implementazione tecnica del test
Il test richiede un’API accessibile che riceve dati in input e restituisce predizioni, un dataset rappresentativo per l’interrogazione suddiviso in training set e test set, e un ambiente Python con requests, numpy e scikit-learn installati.
Step 1: acquisizione dati tramite query API
import requests
import numpy as np
# --- Configuration ---
API_URL = "https://api.example.com/predict" # Target model's API endpoint
API_KEY = "your_api_key_here"
# Load your dataset (e.g., a list of text inputs)
# For this example, we'll use a simple list.
query_dataset = [
"This is a great product, I love it!",
"The service was terrible, I am very disappointed.",
"It's an okay experience, neither good nor bad.",
# ... add at least 1,000-5,000 data points for a meaningful test
]
# --- Data Acquisition ---
def query_target_model(text_input):
"""Sends a request to the target model's API and returns the prediction."""
headers = {"Authorization": f"Bearer {API_KEY}"}
payload = {"text": text_input}
try:
response = requests.post(API_URL, json=payload, headers=headers)
response.raise_for_status() # Raise an exception for bad status codes
# Assuming the API returns a JSON with a 'label' key (e.g., 'positive', 'negative')
return response.json().get('label')
except requests.exceptions.RequestException as e:
print(f"API request failed: {e}")
return None
# Create a new dataset with labels from the target model
stolen_labels = []
for text in query_dataset:
label = query_target_model(text)
if label:
stolen_labels.append(label)
# At this point, `query_dataset` and `stolen_labels` form your training set
# for the surrogate model.
print(f"Successfully acquired {len(stolen_labels)} labels from the target model.")
Step 2: training del modello surrogato
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.tree import DecisionTreeClassifier
from sklearn.pipeline import make_pipeline
# Ensure you have data from Step 1
if not stolen_labels:
raise ValueError("No labels were acquired from the target model. Cannot train surrogate.")
# Create and train the surrogate model pipeline
# We use a simple TF-IDF vectorizer and a Decision Tree for simplicity.
surrogate_model = make_pipeline(
TfidfVectorizer(),
DecisionTreeClassifier(random_state=42)
)
# Train the model on the data acquired from the target API
surrogate_model.fit(query_dataset, stolen_labels)
print("Surrogate model trained successfully.")
Step 3: valutazione della fedeltà del modello surrogato
from sklearn.metrics import accuracy_score
# --- Evaluation ---
# Load your unseen test set (should not have been used in Step 1)
test_dataset = [
"I would definitely recommend this to my friends.",
"A complete waste of money and time.",
# ... add a representative set of test data
]
# 1. Get ground truth predictions from the TARGET model for the test set
target_model_predictions = [query_target_model(text) for text in test_dataset]
# 2. Get predictions from your SURROGATE model for the same test set
surrogate_model_predictions = surrogate_model.predict(test_dataset)
# 3. Compare the predictions to measure fidelity
# Ensure there are no None values from failed API calls
valid_indices = [i for i, label in enumerate(target_model_predictions) if label is not None]
if not valid_indices:
raise ValueError("Could not get any valid predictions from the target model for the test set.")
target_preds_filtered = [target_model_predictions[i] for i in valid_indices]
surrogate_preds_filtered = [surrogate_model_predictions[i] for i in valid_indices]
model_fidelity = accuracy_score(target_preds_filtered, surrogate_preds_filtered)
print(f"Surrogate Model Fidelity (Agreement with Target Model): {model_fidelity:.2%}")
# --- Interpretation ---
if model_fidelity > 0.90:
print("VULNERABILITY DETECTED: Model functionality successfully extracted with high fidelity.")
elif model_fidelity > 0.75:
print("WARNING: Model shows susceptibility to extraction. Fidelity is moderately high.")
else:
print("INFO: Model appears resilient to this extraction attempt. Fidelity is low.")
Output atteso
Fedeltà del surrogato superiore al 90%
Esito che indica vulnerabilità critica: una copia quasi perfetta della funzionalità del modello può essere realizzata con minimo sforzo da parte dell’attaccante.
Impatto atteso: il modello è altamente suscettibile a model extraction e richiede interventi difensivi immediati.
Fedeltà del surrogato inferiore al 75%
Risultato desiderato: il comportamento non è facilmente replicabile grazie ai meccanismi difensivi implementati, come rate limiting o output perturbation.
Impatto atteso: il modello dimostra resilienza adeguata contro tentativi di extraction.
Efficacia dei meccanismi difensivi
Le interrogazioni non devono permettere la ricostruzione efficace di un modello surrogato. I meccanismi difensivi devono rilevare e limitare attività sospette, ostacolando la raccolta dati.
Impatto atteso: protezione della proprietà intellettuale e riduzione del rischio di attacchi adversarial derivati.
Azioni di remediation
Query rate limiting e throttling
Implementare limiti rigorosi sul numero di query per utente/IP in finestre temporali definite, con meccanismi di throttling progressivo per comportamenti anomali.
Impatto atteso: riduzione significativa della capacità di un attaccante di raccogliere dati sufficienti per addestrare un modello surrogato efficace.
Differential privacy e noise injection
Utilizzare tecniche di differential privacy e noise injection sugli output del modello per rendere più difficile l’estrazione di informazioni precise sul comportamento del modello.
Impatto atteso: degradazione della fedeltà dei modelli surrogati senza compromettere significativamente l’utilità del modello per utenti legittimi.
Monitoring e anomaly detection
Implementare sistemi di monitoring per rilevare pattern di query sospetti e rispondere in tempo reale a tentativi di extraction, con alert automatici e blocco temporaneo degli accessi anomali.
Impatto atteso: identificazione precoce di tentativi di model extraction e capacità di risposta rapida per mitigare l’impatto.
Strumenti suggeriti
- ML Privacy Meter: strumento per quantificare i rischi di extraction e privacy
- PrivacyRaven: tool per testare e difendere i modelli rispetto alle vulnerabilità extraction
- ART (Adversarial Robustness Toolbox): moduli per detection e mitigazione delle vulnerabilità di model extraction
Riferimenti
- OWASP Top 10 for LLM Applications 2025, LLM02:2025 Sensitive Information Disclosure (OWASP LLM 2025)
- Tramèr et al., “Stealing Machine Learning Models via Prediction APIs”, USENIX Security Symposium 2016 (Paper)
- Jagielski et al., “Extraction Attacks on Machine Learning Models”, IEEE Symposium on Security and Privacy 2020 (DOI)
- “Efficient and Effective Model Extraction” (arXiv:2409.14122v2)
L’integrazione di rate limiting, differential privacy e monitoring aiuta a proteggere i modelli da tentativi di estrazione. Testare regolarmente la resilienza del modello contro attacchi di model extraction è fondamentale per garantire la sicurezza della proprietà intellettuale in produzione.