Skip to content

DeepTeam is a framework to red team LLMs and AI agents.

added assess method to all vulnerabilities

A-Vamshif4b2abe5c991
diff --git a/deepteam/vulnerabilities/agentic/excessive_agency/excessive_agency.py b/deepteam/vulnerabilities/agentic/excessive_agency/excessive_agency.py
index 07253841..2a09c76b 100644
--- a/deepteam/vulnerabilities/agentic/excessive_agency/excessive_agency.py
+++ b/deepteam/vulnerabilities/agentic/excessive_agency/excessive_agency.py
@@ -1,13 +1,22 @@
-from typing import List, Literal, Optional, Union
+from typing import List, Literal, Optional, Union, Dict
+import asyncio
from deepeval.models import DeepEvalBaseLLM
+from deepeval.metrics.utils import initialize_model, trimAndLoadJson
+from deepeval.utils import get_or_create_event_loop
+from deepeval.test_case import LLMTestCase
+
+from deepteam.utils import validate_model_callback_signature
from deepteam.vulnerabilities import BaseVulnerability
from deepteam.vulnerabilities.agentic.excessive_agency import (
ExcessiveAgencyType,
)
from deepteam.vulnerabilities.utils import validate_vulnerability_types
-from deepteam.metrics import ExcessiveAgencyMetric
+from deepteam.metrics import ExcessiveAgencyMetric, BaseRedTeamingMetric
+from deepteam.attacks.multi_turn.types import CallbackType
+from deepteam.attacks.attack_simulator.schema import SyntheticDataList
+from .template import ExcessiveAgencyTemplate
ExcessiveAgencyLiteral = Literal["functionality", "permissions", "autonomy"]
@@ -17,9 +26,12 @@ class ExcessiveAgency(BaseVulnerability):
def __init__(
self,
purpose: str = None,
- model: Optional[Union[str, DeepEvalBaseLLM]] = None,
async_mode: bool = True,
verbose_mode: bool = False,
+ simulator_model: Optional[
+ Union[str, DeepEvalBaseLLM]
+ ] = "gpt-3.5-turbo-0125",
+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",
types: Optional[List[ExcessiveAgencyLiteral]] = [
type.value for type in ExcessiveAgencyType
],
@@ -28,18 +40,247 @@ class ExcessiveAgency(BaseVulnerability):
self.get_name(), types=types, allowed_type=ExcessiveAgencyType
)
self.purpose = purpose
- self.model = model
self.async_mode = async_mode
self.verbose_mode = verbose_mode
+ self.simulator_model = simulator_model
+ self.evaluation_model = evaluation_model
super().__init__(types=enum_types)
+ def assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+ from deepteam.risks import getRiskCategory
+
+ if self.async_mode:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+ loop = get_or_create_event_loop()
+ return loop.run_until_complete(
+ self.a_assess(
+ model_callback=model_callback,
+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,
+ )
+ )
+ else:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = self.simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[ExcessiveAgencyType, List[RedTeamingTestCase]] = dict()
+
+ for simulated_attack in simulated_attacks:
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ target_output = model_callback(simulated_attack.input)
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric = self._get_metric(vulnerability_type)
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ results[vulnerability_type] = results.get(vulnerability_type, [])
+ results[vulnerability_type].append(red_teaming_test_case)
+
+ return results
+
+ async def a_assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+ from deepteam.risks import getRiskCategory
+
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = await self.a_simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[ExcessiveAgencyType, List[RedTeamingTestCase]] = dict()
+
+ async def process_attack(simulated_attack):
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ metric = self._get_metric(vulnerability_type)
+ target_output = await model_callback(simulated_attack.input)
+
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ return vulnerability_type, red_teaming_test_case
+
+ # Run all processing concurrently
+ all_tasks = [
+ process_attack(simulated_attack)
+ for simulated_attack in simulated_attacks
+ if simulated_attack.vulnerability_type in self.types
+ ]
+
+ for task in asyncio.as_completed(all_tasks):
+ vulnerability_type, test_case = await task
+ results.setdefault(vulnerability_type, []).append(test_case)
+
+ return results
+
+ def simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.attacks.attack_simulator import SimulatedAttack
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ ExcessiveAgencyTemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type, self.purpose
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = self.simulator_model.generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
+
+ async def a_simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.attacks.attack_simulator import SimulatedAttack
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ ExcessiveAgencyTemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type, self.purpose
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = (
+ await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = await self.simulator_model.a_generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
+
def _get_metric(
self,
type: ExcessiveAgencyType,
- ):
+ ) -> BaseRedTeamingMetric:
return ExcessiveAgencyMetric(
purpose=self.purpose,
- model=self.model,
+ model=self.evaluation_model,
async_mode=self.async_mode,
verbose_mode=self.verbose_mode,
)
diff --git a/deepteam/vulnerabilities/agentic/goal_theft/goal_theft.py b/deepteam/vulnerabilities/agentic/goal_theft/goal_theft.py
index 46f1b882..c72a9f4c 100644
--- a/deepteam/vulnerabilities/agentic/goal_theft/goal_theft.py
+++ b/deepteam/vulnerabilities/agentic/goal_theft/goal_theft.py
@@ -1,13 +1,23 @@
-from typing import List, Literal, Optional, Union
+from typing import List, Literal, Optional, Union, Dict
+import asyncio
from deepeval.models import DeepEvalBaseLLM
+from deepeval.metrics.utils import initialize_model, trimAndLoadJson
+from deepeval.utils import get_or_create_event_loop
+from deepeval.test_case import LLMTestCase
+
+from deepteam.utils import validate_model_callback_signature
from deepteam.vulnerabilities import BaseVulnerability
from deepteam.vulnerabilities.agentic.goal_theft import GoalTheftType
from deepteam.vulnerabilities.utils import validate_vulnerability_types
from deepteam.metrics.agentic.extraction_success.extraction_success import (
- ExtractionSuccessMetric,
+ ExtractionSuccessMetric,
+ BaseRedTeamingMetric
)
+from deepteam.attacks.multi_turn.types import CallbackType
+from deepteam.attacks.attack_simulator.schema import SyntheticDataList
+from .template import GoalTheftTemplate
GoalTheftLiteralType = Literal[
"escalating_probing", "cooperative_dialogue", "social_engineering"
@@ -18,9 +28,12 @@ class GoalTheft(BaseVulnerability):
def __init__(
self,
purpose: str,
- model: Optional[Union[str, DeepEvalBaseLLM]] = None,
async_mode: bool = True,
verbose_mode: bool = False,
+ simulator_model: Optional[
+ Union[str, DeepEvalBaseLLM]
+ ] = "gpt-3.5-turbo-0125",
+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",
types: Optional[List[GoalTheftLiteralType]] = [
type.value for type in GoalTheftType
],
@@ -29,18 +42,247 @@ class GoalTheft(BaseVulnerability):
self.get_name(), types=types, allowed_type=GoalTheftType
)
self.purpose = purpose
- self.model = model
self.async_mode = async_mode
self.verbose_mode = verbose_mode
+ self.simulator_model = simulator_model
+ self.evaluation_model = evaluation_model
super().__init__(types=enum_types)
+ def assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+ from deepteam.risks import getRiskCategory
+
+ if self.async_mode:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+ loop = get_or_create_event_loop()
+ return loop.run_until_complete(
+ self.a_assess(
+ model_callback=model_callback,
+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,
+ )
+ )
+ else:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = self.simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[GoalTheftType, List[RedTeamingTestCase]] = dict()
+
+ for simulated_attack in simulated_attacks:
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ target_output = model_callback(simulated_attack.input)
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric = self._get_metric(vulnerability_type)
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ results[vulnerability_type] = results.get(vulnerability_type, [])
+ results[vulnerability_type].append(red_teaming_test_case)
+
+ return results
+
+ async def a_assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+ from deepteam.risks import getRiskCategory
+
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = await self.a_simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[GoalTheftType, List[RedTeamingTestCase]] = dict()
+
+ async def process_attack(simulated_attack):
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ metric = self._get_metric(vulnerability_type)
+ target_output = await model_callback(simulated_attack.input)
+
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ return vulnerability_type, red_teaming_test_case
+
+ # Run all processing concurrently
+ all_tasks = [
+ process_attack(simulated_attack)
+ for simulated_attack in simulated_attacks
+ if simulated_attack.vulnerability_type in self.types
+ ]
+
+ for task in asyncio.as_completed(all_tasks):
+ vulnerability_type, test_case = await task
+ results.setdefault(vulnerability_type, []).append(test_case)
+
+ return results
+
+ def simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.attacks.attack_simulator import SimulatedAttack
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ GoalTheftTemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type, self.purpose
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = self.simulator_model.generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
+
+ async def a_simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.attacks.attack_simulator import SimulatedAttack
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ GoalTheftTemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type, self.purpose
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = (
+ await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = await self.simulator_model.a_generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
+
def _get_metric(
self,
type: GoalTheftType,
- ):
+ ) -> BaseRedTeamingMetric:
return ExtractionSuccessMetric(
purpose=self.purpose,
- model=self.model,
+ model=self.evaluation_model,
async_mode=self.async_mode,
verbose_mode=self.verbose_mode,
)
diff --git a/deepteam/vulnerabilities/agentic/recursive_hijacking/recursive_hijacking.py b/deepteam/vulnerabilities/agentic/recursive_hijacking/recursive_hijacking.py
index c011a480..fa11cb3e 100644
--- a/deepteam/vulnerabilities/agentic/recursive_hijacking/recursive_hijacking.py
+++ b/deepteam/vulnerabilities/agentic/recursive_hijacking/recursive_hijacking.py
@@ -1,6 +1,12 @@
-from typing import List, Literal, Optional, Union
+from typing import List, Literal, Optional, Union, Dict
+import asyncio
from deepeval.models import DeepEvalBaseLLM
+from deepeval.metrics.utils import initialize_model, trimAndLoadJson
+from deepeval.utils import get_or_create_event_loop
+from deepeval.test_case import LLMTestCase
+
+from deepteam.utils import validate_model_callback_signature
from deepteam.vulnerabilities import BaseVulnerability
from deepteam.vulnerabilities.agentic.recursive_hijacking import (
@@ -8,8 +14,12 @@ from deepteam.vulnerabilities.agentic.recursive_hijacking import (
)
from deepteam.vulnerabilities.utils import validate_vulnerability_types
from deepteam.metrics.agentic.subversion_success.subversion_success import (
- SubversionSuccessMetric,
+ SubversionSuccessMetric,
+ BaseRedTeamingMetric
)
+from deepteam.attacks.multi_turn.types import CallbackType
+from deepteam.attacks.attack_simulator.schema import SyntheticDataList
+from .template import RecursiveHijackingTemplate
RecursiveHijackingLiteralType = Literal[
"self_modifying_goals",
@@ -22,9 +32,12 @@ class RecursiveHijacking(BaseVulnerability):
def __init__(
self,
purpose: str,
- model: Optional[Union[str, DeepEvalBaseLLM]] = None,
async_mode: bool = True,
verbose_mode: bool = False,
+ simulator_model: Optional[
+ Union[str, DeepEvalBaseLLM]
+ ] = "gpt-3.5-turbo-0125",
+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",
types: Optional[List[RecursiveHijackingLiteralType]] = [
type.value for type in RecursiveHijackingType
],
@@ -33,18 +46,247 @@ class RecursiveHijacking(BaseVulnerability):
self.get_name(), types=types, allowed_type=RecursiveHijackingType
)
self.purpose = purpose
- self.model = model
self.async_mode = async_mode
self.verbose_mode = verbose_mode
+ self.simulator_model = simulator_model
+ self.evaluation_model = evaluation_model
super().__init__(types=enum_types)
+ def assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+ from deepteam.risks import getRiskCategory
+
+ if self.async_mode:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+ loop = get_or_create_event_loop()
+ return loop.run_until_complete(
+ self.a_assess(
+ model_callback=model_callback,
+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,
+ )
+ )
+ else:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = self.simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[RecursiveHijackingType, List[RedTeamingTestCase]] = dict()
+
+ for simulated_attack in simulated_attacks:
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ target_output = model_callback(simulated_attack.input)
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric = self._get_metric(vulnerability_type)
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ results[vulnerability_type] = results.get(vulnerability_type, [])
+ results[vulnerability_type].append(red_teaming_test_case)
+
+ return results
+
+ async def a_assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+ from deepteam.risks import getRiskCategory
+
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = await self.a_simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[RecursiveHijackingType, List[RedTeamingTestCase]] = dict()
+
+ async def process_attack(simulated_attack):
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ metric = self._get_metric(vulnerability_type)
+ target_output = await model_callback(simulated_attack.input)
+
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ return vulnerability_type, red_teaming_test_case
+
+ # Run all processing concurrently
+ all_tasks = [
+ process_attack(simulated_attack)
+ for simulated_attack in simulated_attacks
+ if simulated_attack.vulnerability_type in self.types
+ ]
+
+ for task in asyncio.as_completed(all_tasks):
+ vulnerability_type, test_case = await task
+ results.setdefault(vulnerability_type, []).append(test_case)
+
+ return results
+
+ def simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.attacks.attack_simulator import SimulatedAttack
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ RecursiveHijackingTemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type, self.purpose
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = self.simulator_model.generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
+
+ async def a_simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.attacks.attack_simulator import SimulatedAttack
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ RecursiveHijackingTemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type, self.purpose
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = (
+ await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = await self.simulator_model.a_generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
+
def _get_metric(
self,
type: RecursiveHijackingType,
- ):
+ ) -> BaseRedTeamingMetric:
return SubversionSuccessMetric(
purpose=self.purpose,
- model=self.model,
+ model=self.evaluation_model,
async_mode=self.async_mode,
verbose_mode=self.verbose_mode,
)
diff --git a/deepteam/vulnerabilities/agentic/robustness/robustness.py b/deepteam/vulnerabilities/agentic/robustness/robustness.py
index 244eeede..9a2cd1b7 100644
--- a/deepteam/vulnerabilities/agentic/robustness/robustness.py
+++ b/deepteam/vulnerabilities/agentic/robustness/robustness.py
@@ -1,11 +1,20 @@
-from typing import List, Literal, Optional, Union
+from typing import List, Literal, Optional, Union, Dict
+import asyncio
from deepeval.models import DeepEvalBaseLLM
+from deepeval.metrics.utils import initialize_model, trimAndLoadJson
+from deepeval.utils import get_or_create_event_loop
+from deepeval.test_case import LLMTestCase
+
+from deepteam.utils import validate_model_callback_signature
from deepteam.vulnerabilities import BaseVulnerability
from deepteam.vulnerabilities.agentic.robustness import RobustnessType
from deepteam.vulnerabilities.utils import validate_vulnerability_types
-from deepteam.metrics import HijackingMetric, OverrelianceMetric
+from deepteam.metrics import HijackingMetric, OverrelianceMetric, BaseRedTeamingMetric
+from deepteam.attacks.multi_turn.types import CallbackType
+from deepteam.attacks.attack_simulator.schema import SyntheticDataList
+from .template import RobustnessTemplate
RobustnessLiteral = Literal["input overreliance", "hijacking"]
@@ -14,9 +23,12 @@ class Robustness(BaseVulnerability):
def __init__(
self,
purpose: str,
- model: Optional[Union[str, DeepEvalBaseLLM]] = None,
async_mode: bool = True,
verbose_mode: bool = False,
+ simulator_model: Optional[
+ Union[str, DeepEvalBaseLLM]
+ ] = "gpt-3.5-turbo-0125",
+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",
types: Optional[List[RobustnessLiteral]] = [
type.value for type in RobustnessType
],
@@ -25,27 +37,256 @@ class Robustness(BaseVulnerability):
self.get_name(), types=types, allowed_type=RobustnessType
)
self.purpose = purpose
- self.model = model
self.async_mode = async_mode
self.verbose_mode = verbose_mode
+ self.simulator_model = simulator_model
+ self.evaluation_model = evaluation_model
super().__init__(types=enum_types)
+ def assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+ from deepteam.risks import getRiskCategory
+
+ if self.async_mode:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+ loop = get_or_create_event_loop()
+ return loop.run_until_complete(
+ self.a_assess(
+ model_callback=model_callback,
+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,
+ )
+ )
+ else:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = self.simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[RobustnessType, List[RedTeamingTestCase]] = dict()
+
+ for simulated_attack in simulated_attacks:
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ target_output = model_callback(simulated_attack.input)
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric = self._get_metric(vulnerability_type)
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ results[vulnerability_type] = results.get(vulnerability_type, [])
+ results[vulnerability_type].append(red_teaming_test_case)
+
+ return results
+
+ async def a_assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+ from deepteam.risks import getRiskCategory
+
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = await self.a_simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[RobustnessType, List[RedTeamingTestCase]] = dict()
+
+ async def process_attack(simulated_attack):
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ metric = self._get_metric(vulnerability_type)
+ target_output = await model_callback(simulated_attack.input)
+
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ return vulnerability_type, red_teaming_test_case
+
+ # Run all processing concurrently
+ all_tasks = [
+ process_attack(simulated_attack)
+ for simulated_attack in simulated_attacks
+ if simulated_attack.vulnerability_type in self.types
+ ]
+
+ for task in asyncio.as_completed(all_tasks):
+ vulnerability_type, test_case = await task
+ results.setdefault(vulnerability_type, []).append(test_case)
+
+ return results
+
+ def simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.attacks.attack_simulator import SimulatedAttack
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ RobustnessTemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type, self.purpose
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = self.simulator_model.generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
+
+ async def a_simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.attacks.attack_simulator import SimulatedAttack
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ RobustnessTemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type, self.purpose
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = (
+ await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = await self.simulator_model.a_generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
+
# TODO: Different metrics for different types. Forces us to use type in the `_get_metric` call.
def _get_metric(
self,
type: RobustnessType,
- ):
+ ) -> BaseRedTeamingMetric:
if type == RobustnessType.HIJACKING:
return HijackingMetric(
purpose=self.purpose,
- model=self.model,
+ model=self.evaluation_model,
async_mode=self.async_mode,
verbose_mode=self.verbose_mode,
)
if type == RobustnessType.INPUT_OVERRELIANCE:
return OverrelianceMetric(
purpose=self.purpose,
- model=self.model,
+ model=self.evaluation_model,
async_mode=self.async_mode,
verbose_mode=self.verbose_mode,
)
diff --git a/deepteam/vulnerabilities/base_vulnerability.py b/deepteam/vulnerabilities/base_vulnerability.py
index bf3400fd..a493d0fc 100644
--- a/deepteam/vulnerabilities/base_vulnerability.py
+++ b/deepteam/vulnerabilities/base_vulnerability.py
@@ -1,7 +1,6 @@
from typing import List
from enum import Enum
from abc import ABC
-
from deepteam.metrics import BaseRedTeamingMetric
@@ -28,6 +27,18 @@ class BaseVulnerability(ABC):
:return: List of string values from the Enum types.
"""
return [t.value for t in self.types]
+
+ def assess(self):
+ pass
+
+ async def a_assess(self):
+ pass
+
+ def simulate_attacks(self):
+ pass
+
+ async def a_simulate_attacks(self):
+ pass
def _get_metric(self) -> BaseRedTeamingMetric:
"""
diff --git a/deepteam/vulnerabilities/bfla/bfla.py b/deepteam/vulnerabilities/bfla/bfla.py
index 53e8406f..01e81779 100644
--- a/deepteam/vulnerabilities/bfla/bfla.py
+++ b/deepteam/vulnerabilities/bfla/bfla.py
@@ -1,11 +1,22 @@
-from typing import List, Literal, Optional, Union
+from typing import List, Literal, Optional, Union, Dict
+import asyncio
from deepeval.models import DeepEvalBaseLLM
+from deepeval.metrics.utils import initialize_model, trimAndLoadJson
+from deepeval.utils import get_or_create_event_loop
+from deepeval.test_case import LLMTestCase
+
+from deepteam.utils import validate_model_callback_signature
from deepteam.vulnerabilities import BaseVulnerability
from deepteam.vulnerabilities.bfla import BFLAType
from deepteam.vulnerabilities.utils import validate_vulnerability_types
-from deepteam.metrics import BFLAMetric
+from deepteam.metrics import BFLAMetric, BaseRedTeamingMetric
+from deepteam.attacks.multi_turn.types import CallbackType
+from deepteam.attacks.attack_simulator import SimulatedAttack
+from deepteam.attacks.attack_simulator.schema import SyntheticDataList
+from deepteam.risks import getRiskCategory
+from .template import BFLATemplate
BFLALiteral = Literal[
"privilege_escalation",
@@ -18,27 +29,255 @@ class BFLA(BaseVulnerability):
def __init__(
self,
purpose: str,
- model: Optional[Union[str, DeepEvalBaseLLM]] = None,
async_mode: bool = True,
verbose_mode: bool = False,
+ simulator_model: Optional[
+ Union[str, DeepEvalBaseLLM]
+ ] = "gpt-3.5-turbo-0125",
+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",
types: Optional[List[BFLALiteral]] = [type.value for type in BFLAType],
):
enum_types = validate_vulnerability_types(
self.get_name(), types=types, allowed_type=BFLAType
)
self.purpose = purpose
- self.model = model
self.async_mode = async_mode
self.verbose_mode = verbose_mode
+ self.simulator_model = simulator_model
+ self.evaluation_model = evaluation_model
super().__init__(types=enum_types)
+ def assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+
+ if self.async_mode:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+ loop = get_or_create_event_loop()
+ return loop.run_until_complete(
+ self.a_assess(
+ model_callback=model_callback,
+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,
+ )
+ )
+ else:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = self.simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[BFLAType, List[RedTeamingTestCase]] = dict()
+
+ for simulated_attack in simulated_attacks:
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ target_output = model_callback(simulated_attack.input)
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric = self._get_metric(vulnerability_type)
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ results[vulnerability_type] = results.get(vulnerability_type, [])
+ results[vulnerability_type].append(red_teaming_test_case)
+
+ return results
+
+ async def a_assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = await self.a_simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[BFLAType, List[RedTeamingTestCase]] = dict()
+
+ async def process_attack(simulated_attack: SimulatedAttack):
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ metric = self._get_metric(vulnerability_type)
+ target_output = await model_callback(simulated_attack.input)
+
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ return vulnerability_type, red_teaming_test_case
+
+ # Run all processing concurrently
+ all_tasks = [
+ process_attack(simulated_attack)
+ for simulated_attack in simulated_attacks
+ if simulated_attack.vulnerability_type in self.types
+ ]
+
+ for task in asyncio.as_completed(all_tasks):
+ vulnerability_type, test_case = await task
+ results.setdefault(vulnerability_type, []).append(test_case)
+
+ return results
+
+ def simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ) -> List[SimulatedAttack]:
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ BFLATemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type, self.purpose
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = self.simulator_model.generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
+
+ async def a_simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ) -> List[SimulatedAttack]:
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ BFLATemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type, self.purpose
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = (
+ await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = await self.simulator_model.a_generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
+
def _get_metric(
self,
type: BFLAType,
- ):
+ ) -> BaseRedTeamingMetric:
return BFLAMetric(
purpose=self.purpose,
- model=self.model,
+ model=self.evaluation_model,
async_mode=self.async_mode,
verbose_mode=self.verbose_mode,
)
diff --git a/deepteam/vulnerabilities/bola/bola.py b/deepteam/vulnerabilities/bola/bola.py
index 070c8169..469a344d 100644
--- a/deepteam/vulnerabilities/bola/bola.py
+++ b/deepteam/vulnerabilities/bola/bola.py
@@ -1,11 +1,22 @@
-from typing import List, Literal, Optional, Union
+from typing import List, Literal, Optional, Union, Dict
+import asyncio
from deepeval.models import DeepEvalBaseLLM
+from deepeval.metrics.utils import initialize_model, trimAndLoadJson
+from deepeval.utils import get_or_create_event_loop
+from deepeval.test_case import LLMTestCase
+
+from deepteam.utils import validate_model_callback_signature
from deepteam.vulnerabilities import BaseVulnerability
from deepteam.vulnerabilities.bola import BOLAType
from deepteam.vulnerabilities.utils import validate_vulnerability_types
-from deepteam.metrics import BOLAMetric
+from deepteam.metrics import BOLAMetric, BaseRedTeamingMetric
+from deepteam.attacks.multi_turn.types import CallbackType
+from deepteam.attacks.attack_simulator import SimulatedAttack
+from deepteam.attacks.attack_simulator.schema import SyntheticDataList
+from deepteam.risks import getRiskCategory
+from .template import BOLATemplate
BOLALiteral = Literal[
"object_access_bypass",
@@ -17,25 +28,253 @@ BOLALiteral = Literal[
class BOLA(BaseVulnerability):
def __init__(
self,
- model: Optional[Union[str, DeepEvalBaseLLM]] = None,
async_mode: bool = True,
verbose_mode: bool = False,
+ simulator_model: Optional[
+ Union[str, DeepEvalBaseLLM]
+ ] = "gpt-3.5-turbo-0125",
+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",
types: Optional[List[BOLALiteral]] = [type.value for type in BOLAType],
):
enum_types = validate_vulnerability_types(
self.get_name(), types=types, allowed_type=BOLAType
)
- self.model = model
self.async_mode = async_mode
self.verbose_mode = verbose_mode
+ self.simulator_model = simulator_model
+ self.evaluation_model = evaluation_model
super().__init__(types=enum_types)
+ def assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+
+ if self.async_mode:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+ loop = get_or_create_event_loop()
+ return loop.run_until_complete(
+ self.a_assess(
+ model_callback=model_callback,
+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,
+ )
+ )
+ else:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = self.simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[BOLAType, List[RedTeamingTestCase]] = dict()
+
+ for simulated_attack in simulated_attacks:
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ target_output = model_callback(simulated_attack.input)
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric = self._get_metric(vulnerability_type)
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ results[vulnerability_type] = results.get(vulnerability_type, [])
+ results[vulnerability_type].append(red_teaming_test_case)
+
+ return results
+
+ async def a_assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = await self.a_simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[BOLAType, List[RedTeamingTestCase]] = dict()
+
+ async def process_attack(simulated_attack: SimulatedAttack):
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ metric = self._get_metric(vulnerability_type)
+ target_output = await model_callback(simulated_attack.input)
+
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ return vulnerability_type, red_teaming_test_case
+
+ # Run all processing concurrently
+ all_tasks = [
+ process_attack(simulated_attack)
+ for simulated_attack in simulated_attacks
+ if simulated_attack.vulnerability_type in self.types
+ ]
+
+ for task in asyncio.as_completed(all_tasks):
+ vulnerability_type, test_case = await task
+ results.setdefault(vulnerability_type, []).append(test_case)
+
+ return results
+
+ def simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ) -> List[SimulatedAttack]:
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ BOLATemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = self.simulator_model.generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
+
+ async def a_simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ) -> List[SimulatedAttack]:
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ BOLATemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = (
+ await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = await self.simulator_model.a_generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
+
def _get_metric(
self,
type: BOLAType,
- ):
+ ) -> BaseRedTeamingMetric:
return BOLAMetric(
- model=self.model,
+ model=self.evaluation_model,
async_mode=self.async_mode,
verbose_mode=self.verbose_mode,
)
diff --git a/deepteam/vulnerabilities/competition/competition.py b/deepteam/vulnerabilities/competition/competition.py
index c8f545cb..8253d01c 100644
--- a/deepteam/vulnerabilities/competition/competition.py
+++ b/deepteam/vulnerabilities/competition/competition.py
@@ -1,11 +1,22 @@
-from typing import List, Literal, Optional, Union
+from typing import List, Literal, Optional, Union, Dict
+import asyncio
from deepeval.models import DeepEvalBaseLLM
+from deepeval.metrics.utils import initialize_model, trimAndLoadJson
+from deepeval.utils import get_or_create_event_loop
+from deepeval.test_case import LLMTestCase
+
+from deepteam.utils import validate_model_callback_signature
from deepteam.vulnerabilities import BaseVulnerability
from deepteam.vulnerabilities.competition import CompetitionType
from deepteam.vulnerabilities.utils import validate_vulnerability_types
-from deepteam.metrics import CompetitorsMetric
+from deepteam.metrics import CompetitorsMetric, BaseRedTeamingMetric
+from deepteam.attacks.multi_turn.types import CallbackType
+from deepteam.attacks.attack_simulator import SimulatedAttack
+from deepteam.attacks.attack_simulator.schema import SyntheticDataList
+from deepteam.risks import getRiskCategory
+from .template import CompetitionTemplate
CompetitionLiteralType = Literal[
@@ -20,9 +31,12 @@ class Competition(BaseVulnerability):
def __init__(
self,
purpose: str,
- model: Optional[Union[str, DeepEvalBaseLLM]] = None,
async_mode: bool = True,
verbose_mode: bool = False,
+ simulator_model: Optional[
+ Union[str, DeepEvalBaseLLM]
+ ] = "gpt-3.5-turbo-0125",
+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",
types: Optional[List[CompetitionLiteralType]] = [
type.value for type in CompetitionType
],
@@ -31,18 +45,243 @@ class Competition(BaseVulnerability):
self.get_name(), types=types, allowed_type=CompetitionType
)
self.purpose = purpose
- self.model = model
self.async_mode = async_mode
self.verbose_mode = verbose_mode
+ self.simulator_model = simulator_model
+ self.evaluation_model = evaluation_model
super().__init__(types=enum_types)
+ def assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+
+ if self.async_mode:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+ loop = get_or_create_event_loop()
+ return loop.run_until_complete(
+ self.a_assess(
+ model_callback=model_callback,
+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,
+ )
+ )
+ else:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = self.simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[CompetitionType, List[RedTeamingTestCase]] = dict()
+
+ for simulated_attack in simulated_attacks:
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ target_output = model_callback(simulated_attack.input)
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric = self._get_metric(vulnerability_type)
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ results[vulnerability_type] = results.get(vulnerability_type, [])
+ results[vulnerability_type].append(red_teaming_test_case)
+
+ return results
+
+ async def a_assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = await self.a_simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[CompetitionType, List[RedTeamingTestCase]] = dict()
+
+ async def process_attack(simulated_attack: SimulatedAttack):
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ metric = self._get_metric(vulnerability_type)
+ target_output = await model_callback(simulated_attack.input)
+
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ return vulnerability_type, red_teaming_test_case
+
+ # Run all processing concurrently
+ all_tasks = [
+ process_attack(simulated_attack)
+ for simulated_attack in simulated_attacks
+ if simulated_attack.vulnerability_type in self.types
+ ]
+
+ for task in asyncio.as_completed(all_tasks):
+ vulnerability_type, test_case = await task
+ results.setdefault(vulnerability_type, []).append(test_case)
+
+ return results
+
+ def simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ) -> List[SimulatedAttack]:
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ CompetitionTemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type, self.purpose
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = self.simulator_model.generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
+
+ async def a_simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ) -> List[SimulatedAttack]:
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ CompetitionTemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type, self.purpose
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = (
+ await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = await self.simulator_model.a_generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
+
def _get_metric(
self,
type: CompetitionType,
- ):
+ ) -> BaseRedTeamingMetric:
return CompetitorsMetric(
purpose=self.purpose,
- model=self.model,
+ model=self.evaluation_model,
async_mode=self.async_mode,
verbose_mode=self.verbose_mode,
)
diff --git a/deepteam/vulnerabilities/custom/custom.py b/deepteam/vulnerabilities/custom/custom.py
index b2f83289..56ae64f4 100644
--- a/deepteam/vulnerabilities/custom/custom.py
+++ b/deepteam/vulnerabilities/custom/custom.py
@@ -1,11 +1,20 @@
-from typing import List, Optional, Union
+from typing import List, Literal, Optional, Union, Dict
from enum import Enum
+import asyncio
from deepeval.models import DeepEvalBaseLLM
+from deepeval.metrics.utils import initialize_model, trimAndLoadJson
+from deepeval.utils import get_or_create_event_loop
+from deepeval.test_case import LLMTestCase
+
+from deepteam.utils import validate_model_callback_signature
from deepteam.vulnerabilities import BaseVulnerability
from deepteam.metrics import BaseRedTeamingMetric, HarmMetric
-
+from deepteam.attacks.multi_turn.types import CallbackType
+from deepteam.attacks.attack_simulator.schema import SyntheticDataList
+from deepteam.risks import getRiskCategory
+from .template import CustomVulnerabilityTemplate
class CustomVulnerability(BaseVulnerability):
"""
@@ -19,9 +28,12 @@ class CustomVulnerability(BaseVulnerability):
types: Optional[List[str]] = None,
custom_prompt: Optional[str] = None,
metric: Optional[BaseRedTeamingMetric] = None,
- model: Optional[Union[str, DeepEvalBaseLLM]] = None,
async_mode: bool = True,
verbose_mode: bool = False,
+ simulator_model: Optional[
+ Union[str, DeepEvalBaseLLM]
+ ] = "gpt-3.5-turbo-0125",
+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",
):
self.name = name
@@ -32,7 +44,8 @@ class CustomVulnerability(BaseVulnerability):
self.custom_prompt = custom_prompt
self.criteria = criteria.strip()
- self.model = model
+ self.simulator_model = simulator_model
+ self.evaluation_model = evaluation_model
self.async_mode = async_mode
self.verbose_mode = verbose_mode
if metric:
@@ -40,7 +53,7 @@ class CustomVulnerability(BaseVulnerability):
else:
self.metric = HarmMetric(
harm_category=self.criteria,
- model=self.model,
+ model=self.evaluation_model,
async_mode=self.async_mode,
verbose_mode=self.verbose_mode,
)
@@ -51,8 +64,235 @@ class CustomVulnerability(BaseVulnerability):
def get_custom_prompt(self) -> Optional[str]:
return self.custom_prompt
+
+ def assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+
+ if self.async_mode:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+ loop = get_or_create_event_loop()
+ return loop.run_until_complete(
+ self.a_assess(
+ model_callback=model_callback,
+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,
+ )
+ )
+ else:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = self.simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[str, List[RedTeamingTestCase]] = dict()
+
+ for simulated_attack in simulated_attacks:
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ target_output = model_callback(simulated_attack.input)
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric = self._get_metric(vulnerability_type)
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ results[vulnerability_type] = results.get(vulnerability_type, [])
+ results[vulnerability_type].append(red_teaming_test_case)
+
+ return results
+
+ async def a_assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = await self.a_simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[str, List[RedTeamingTestCase]] = dict()
+
+ async def process_attack(simulated_attack):
+ from deepteam.attacks.attack_simulator import SimulatedAttack
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ metric = self._get_metric(vulnerability_type)
+ target_output = await model_callback(simulated_attack.input)
+
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ return vulnerability_type, red_teaming_test_case
+
+ # Run all processing concurrently
+ all_tasks = [
+ process_attack(simulated_attack)
+ for simulated_attack in simulated_attacks
+ if simulated_attack.vulnerability_type in self.types
+ ]
+
+ for task in asyncio.as_completed(all_tasks):
+ vulnerability_type, test_case = await task
+ results.setdefault(vulnerability_type, []).append(test_case)
+
+ return results
+
+ def simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.attacks.attack_simulator import SimulatedAttack
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ CustomVulnerabilityTemplate.generate_baseline_attacks(
+ self.name, type, attacks_per_vulnerability_type, self.custom_prompt
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = self.simulator_model.generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
+
+ async def a_simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.attacks.attack_simulator import SimulatedAttack
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ CustomVulnerabilityTemplate.generate_baseline_attacks(
+ self.name, type, attacks_per_vulnerability_type, self.custom_prompt
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = (
+ await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = await self.simulator_model.a_generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
- def _get_metric(self, type: Enum) -> Optional[BaseRedTeamingMetric]:
+ def _get_metric(self, type: Enum) -> BaseRedTeamingMetric:
return self.metric
def get_criteria(self) -> str:
diff --git a/deepteam/vulnerabilities/debug_access/debug_access.py b/deepteam/vulnerabilities/debug_access/debug_access.py
index a0dadeb3..1cdfb05b 100644
--- a/deepteam/vulnerabilities/debug_access/debug_access.py
+++ b/deepteam/vulnerabilities/debug_access/debug_access.py
@@ -1,11 +1,22 @@
-from typing import List, Literal, Optional, Union
+from typing import List, Literal, Optional, Union, Dict
+import asyncio
from deepeval.models import DeepEvalBaseLLM
+from deepeval.metrics.utils import initialize_model, trimAndLoadJson
+from deepeval.utils import get_or_create_event_loop
+from deepeval.test_case import LLMTestCase
+
+from deepteam.utils import validate_model_callback_signature
from deepteam.vulnerabilities import BaseVulnerability
from deepteam.vulnerabilities.debug_access import DebugAccessType
from deepteam.vulnerabilities.utils import validate_vulnerability_types
-from deepteam.metrics import DebugAccessMetric
+from deepteam.metrics import DebugAccessMetric, BaseRedTeamingMetric
+from deepteam.attacks.multi_turn.types import CallbackType
+from deepteam.attacks.attack_simulator import SimulatedAttack
+from deepteam.attacks.attack_simulator.schema import SyntheticDataList
+from deepteam.risks import getRiskCategory
+from .template import DebugAccessTemplate
DebugAccessLiteral = Literal[
"debug_mode_bypass",
@@ -17,9 +28,12 @@ DebugAccessLiteral = Literal[
class DebugAccess(BaseVulnerability):
def __init__(
self,
- model: Optional[Union[str, DeepEvalBaseLLM]] = None,
async_mode: bool = True,
verbose_mode: bool = False,
+ simulator_model: Optional[
+ Union[str, DeepEvalBaseLLM]
+ ] = "gpt-3.5-turbo-0125",
+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",
types: Optional[List[DebugAccessLiteral]] = [
type.value for type in DebugAccessType
],
@@ -27,17 +41,242 @@ class DebugAccess(BaseVulnerability):
enum_types = validate_vulnerability_types(
self.get_name(), types=types, allowed_type=DebugAccessType
)
- self.model = model
self.async_mode = async_mode
self.verbose_mode = verbose_mode
+ self.simulator_model = simulator_model
+ self.evaluation_model = evaluation_model
super().__init__(types=enum_types)
+ def assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+
+ if self.async_mode:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+ loop = get_or_create_event_loop()
+ return loop.run_until_complete(
+ self.a_assess(
+ model_callback=model_callback,
+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,
+ )
+ )
+ else:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = self.simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[DebugAccessType, List[RedTeamingTestCase]] = dict()
+
+ for simulated_attack in simulated_attacks:
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ target_output = model_callback(simulated_attack.input)
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric = self._get_metric(vulnerability_type)
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ results[vulnerability_type] = results.get(vulnerability_type, [])
+ results[vulnerability_type].append(red_teaming_test_case)
+
+ return results
+
+ async def a_assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = await self.a_simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[DebugAccessType, List[RedTeamingTestCase]] = dict()
+
+ async def process_attack(simulated_attack: SimulatedAttack):
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ metric = self._get_metric(vulnerability_type)
+ target_output = await model_callback(simulated_attack.input)
+
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ return vulnerability_type, red_teaming_test_case
+
+ # Run all processing concurrently
+ all_tasks = [
+ process_attack(simulated_attack)
+ for simulated_attack in simulated_attacks
+ if simulated_attack.vulnerability_type in self.types
+ ]
+
+ for task in asyncio.as_completed(all_tasks):
+ vulnerability_type, test_case = await task
+ results.setdefault(vulnerability_type, []).append(test_case)
+
+ return results
+
+ def simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ) -> List[SimulatedAttack]:
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ DebugAccessTemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = self.simulator_model.generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
+
+ async def a_simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ) -> List[SimulatedAttack]:
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ DebugAccessTemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = (
+ await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = await self.simulator_model.a_generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
+
def _get_metric(
self,
type: DebugAccessType,
- ):
+ ) -> BaseRedTeamingMetric:
return DebugAccessMetric(
- model=self.model,
+ model=self.evaluation_model,
async_mode=self.async_mode,
verbose_mode=self.verbose_mode,
)
diff --git a/deepteam/vulnerabilities/graphic_content/graphic_content.py b/deepteam/vulnerabilities/graphic_content/graphic_content.py
index 32d8eb59..207cc472 100644
--- a/deepteam/vulnerabilities/graphic_content/graphic_content.py
+++ b/deepteam/vulnerabilities/graphic_content/graphic_content.py
@@ -1,11 +1,22 @@
-from typing import List, Literal, Optional, Union
+from typing import List, Literal, Optional, Union, Dict
+import asyncio
from deepeval.models import DeepEvalBaseLLM
+from deepeval.metrics.utils import initialize_model, trimAndLoadJson
+from deepeval.utils import get_or_create_event_loop
+from deepeval.test_case import LLMTestCase
+
+from deepteam.utils import validate_model_callback_signature
from deepteam.vulnerabilities import BaseVulnerability
from deepteam.vulnerabilities.graphic_content import GraphicContentType
from deepteam.vulnerabilities.utils import validate_vulnerability_types
-from deepteam.metrics import GraphicMetric
+from deepteam.metrics import GraphicMetric, BaseRedTeamingMetric
+from deepteam.attacks.multi_turn.types import CallbackType
+from deepteam.attacks.attack_simulator import SimulatedAttack
+from deepteam.attacks.attack_simulator.schema import SyntheticDataList
+from deepteam.risks import getRiskCategory
+from .template import GraphicContentTemplate
GraphicContentLiteral = Literal[
"sexual content", "graphic content", "pornographic content"
@@ -16,9 +27,12 @@ class GraphicContent(BaseVulnerability):
def __init__(
self,
graphic_category: str,
- model: Optional[Union[str, DeepEvalBaseLLM]] = None,
async_mode: bool = True,
verbose_mode: bool = False,
+ simulator_model: Optional[
+ Union[str, DeepEvalBaseLLM]
+ ] = "gpt-3.5-turbo-0125",
+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",
types: Optional[List[GraphicContentLiteral]] = [
type.value for type in GraphicContentType
],
@@ -27,18 +41,243 @@ class GraphicContent(BaseVulnerability):
self.get_name(), types=types, allowed_type=GraphicContentType
)
self.graphic_category = graphic_category
- self.model = model
self.async_mode = async_mode
self.verbose_mode = verbose_mode
+ self.simulator_model = simulator_model
+ self.evaluation_model = evaluation_model
super().__init__(types=enum_types)
+ def assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+
+ if self.async_mode:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+ loop = get_or_create_event_loop()
+ return loop.run_until_complete(
+ self.a_assess(
+ model_callback=model_callback,
+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,
+ )
+ )
+ else:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = self.simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[GraphicContentType, List[RedTeamingTestCase]] = dict()
+
+ for simulated_attack in simulated_attacks:
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ target_output = model_callback(simulated_attack.input)
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric = self._get_metric(vulnerability_type)
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ results[vulnerability_type] = results.get(vulnerability_type, [])
+ results[vulnerability_type].append(red_teaming_test_case)
+
+ return results
+
+ async def a_assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = await self.a_simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[GraphicContentType, List[RedTeamingTestCase]] = dict()
+
+ async def process_attack(simulated_attack: SimulatedAttack):
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ metric = self._get_metric(vulnerability_type)
+ target_output = await model_callback(simulated_attack.input)
+
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ return vulnerability_type, red_teaming_test_case
+
+ # Run all processing concurrently
+ all_tasks = [
+ process_attack(simulated_attack)
+ for simulated_attack in simulated_attacks
+ if simulated_attack.vulnerability_type in self.types
+ ]
+
+ for task in asyncio.as_completed(all_tasks):
+ vulnerability_type, test_case = await task
+ results.setdefault(vulnerability_type, []).append(test_case)
+
+ return results
+
+ def simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ) -> List[SimulatedAttack]:
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ GraphicContentTemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type, self.graphic_category
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = self.simulator_model.generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
+
+ async def a_simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ) -> List[SimulatedAttack]:
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ GraphicContentTemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type, self.graphic_category
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = (
+ await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = await self.simulator_model.a_generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
+
def _get_metric(
self,
type: GraphicContentType,
- ):
+ ) -> BaseRedTeamingMetric:
return GraphicMetric(
graphic_category=self.graphic_category,
- model=self.model,
+ model=self.evaluation_model,
async_mode=self.async_mode,
verbose_mode=self.verbose_mode,
)
diff --git a/deepteam/vulnerabilities/illegal_activity/illegal_activity.py b/deepteam/vulnerabilities/illegal_activity/illegal_activity.py
index a62dbb0c..80aa731b 100644
--- a/deepteam/vulnerabilities/illegal_activity/illegal_activity.py
+++ b/deepteam/vulnerabilities/illegal_activity/illegal_activity.py
@@ -1,11 +1,22 @@
-from typing import List, Literal, Optional, Union
+from typing import List, Literal, Optional, Union, Dict
+import asyncio
from deepeval.models import DeepEvalBaseLLM
+from deepeval.metrics.utils import initialize_model, trimAndLoadJson
+from deepeval.utils import get_or_create_event_loop
+from deepeval.test_case import LLMTestCase
+
+from deepteam.utils import validate_model_callback_signature
from deepteam.vulnerabilities import BaseVulnerability
from deepteam.vulnerabilities.illegal_activity import IllegalActivityType
from deepteam.vulnerabilities.utils import validate_vulnerability_types
-from deepteam.metrics import IllegalMetric
+from deepteam.metrics import IllegalMetric, BaseRedTeamingMetric
+from deepteam.attacks.multi_turn.types import CallbackType
+from deepteam.attacks.attack_simulator import SimulatedAttack
+from deepteam.attacks.attack_simulator.schema import SyntheticDataList
+from deepteam.risks import getRiskCategory
+from .template import IllegalActivityTemplate
IllegalActivityLiteral = Literal[
"weapons",
@@ -22,9 +33,12 @@ class IllegalActivity(BaseVulnerability):
def __init__(
self,
illegal_category: str,
- model: Optional[Union[str, DeepEvalBaseLLM]] = None,
async_mode: bool = True,
verbose_mode: bool = False,
+ simulator_model: Optional[
+ Union[str, DeepEvalBaseLLM]
+ ] = "gpt-3.5-turbo-0125",
+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",
types: Optional[List[IllegalActivityLiteral]] = [
type.value for type in IllegalActivityType
],
@@ -33,18 +47,243 @@ class IllegalActivity(BaseVulnerability):
self.get_name(), types=types, allowed_type=IllegalActivityType
)
self.illegal_category = illegal_category
- self.model = model
self.async_mode = async_mode
self.verbose_mode = verbose_mode
+ self.simulator_model = simulator_model
+ self.evaluation_model = evaluation_model
super().__init__(types=enum_types)
+ def assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+
+ if self.async_mode:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+ loop = get_or_create_event_loop()
+ return loop.run_until_complete(
+ self.a_assess(
+ model_callback=model_callback,
+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,
+ )
+ )
+ else:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = self.simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[IllegalActivityType, List[RedTeamingTestCase]] = dict()
+
+ for simulated_attack in simulated_attacks:
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ target_output = model_callback(simulated_attack.input)
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric = self._get_metric(vulnerability_type)
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ results[vulnerability_type] = results.get(vulnerability_type, [])
+ results[vulnerability_type].append(red_teaming_test_case)
+
+ return results
+
+ async def a_assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = await self.a_simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[IllegalActivityType, List[RedTeamingTestCase]] = dict()
+
+ async def process_attack(simulated_attack: SimulatedAttack):
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ metric = self._get_metric(vulnerability_type)
+ target_output = await model_callback(simulated_attack.input)
+
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ return vulnerability_type, red_teaming_test_case
+
+ # Run all processing concurrently
+ all_tasks = [
+ process_attack(simulated_attack)
+ for simulated_attack in simulated_attacks
+ if simulated_attack.vulnerability_type in self.types
+ ]
+
+ for task in asyncio.as_completed(all_tasks):
+ vulnerability_type, test_case = await task
+ results.setdefault(vulnerability_type, []).append(test_case)
+
+ return results
+
+ def simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ) -> List[SimulatedAttack]:
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ IllegalActivityTemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type, self.illegal_category
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = self.simulator_model.generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
+
+ async def a_simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ) -> List[SimulatedAttack]:
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ IllegalActivityTemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type, self.illegal_category
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = (
+ await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = await self.simulator_model.a_generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
+
def _get_metric(
self,
type: IllegalActivityType,
- ):
+ ) -> BaseRedTeamingMetric:
return IllegalMetric(
illegal_category=self.illegal_category,
- model=self.model,
+ model=self.evaluation_model,
async_mode=self.async_mode,
verbose_mode=self.verbose_mode,
)
diff --git a/deepteam/vulnerabilities/intellectual_property/intellectual_property.py b/deepteam/vulnerabilities/intellectual_property/intellectual_property.py
index 802e52ef..62afdbca 100644
--- a/deepteam/vulnerabilities/intellectual_property/intellectual_property.py
+++ b/deepteam/vulnerabilities/intellectual_property/intellectual_property.py
@@ -1,15 +1,24 @@
-from typing import List, Literal, Optional, Union
+from typing import List, Literal, Optional, Union, Dict
+import asyncio
from deepeval.models import DeepEvalBaseLLM
+from deepeval.metrics.utils import initialize_model, trimAndLoadJson
+from deepeval.utils import get_or_create_event_loop
+from deepeval.test_case import LLMTestCase
-from deepeval.models import DeepEvalBaseLLM
+from deepteam.utils import validate_model_callback_signature
from deepteam.vulnerabilities import BaseVulnerability
from deepteam.vulnerabilities.intellectual_property import (
IntellectualPropertyType,
)
from deepteam.vulnerabilities.utils import validate_vulnerability_types
-from deepteam.metrics import IntellectualPropertyMetric
+from deepteam.metrics import IntellectualPropertyMetric, BaseRedTeamingMetric
+from deepteam.attacks.multi_turn.types import CallbackType
+from deepteam.attacks.attack_simulator import SimulatedAttack
+from deepteam.attacks.attack_simulator.schema import SyntheticDataList
+from deepteam.risks import getRiskCategory
+from .template import IntellectualPropertyTemplate
IntellectualPropertyLiteral = Literal[
"imitation",
@@ -23,9 +32,12 @@ class IntellectualProperty(BaseVulnerability):
def __init__(
self,
purpose: str,
- model: Optional[Union[str, DeepEvalBaseLLM]] = None,
async_mode: bool = True,
verbose_mode: bool = False,
+ simulator_model: Optional[
+ Union[str, DeepEvalBaseLLM]
+ ] = "gpt-3.5-turbo-0125",
+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",
types: Optional[List[IntellectualPropertyLiteral]] = [
type.value for type in IntellectualPropertyType
],
@@ -34,18 +46,243 @@ class IntellectualProperty(BaseVulnerability):
self.get_name(), types=types, allowed_type=IntellectualPropertyType
)
self.purpose = purpose
- self.model = model
self.async_mode = async_mode
self.verbose_mode = verbose_mode
+ self.simulator_model = simulator_model
+ self.evaluation_model = evaluation_model
super().__init__(types=enum_types)
+ def assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+
+ if self.async_mode:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+ loop = get_or_create_event_loop()
+ return loop.run_until_complete(
+ self.a_assess(
+ model_callback=model_callback,
+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,
+ )
+ )
+ else:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = self.simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[IntellectualPropertyType, List[RedTeamingTestCase]] = dict()
+
+ for simulated_attack in simulated_attacks:
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ target_output = model_callback(simulated_attack.input)
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric = self._get_metric(vulnerability_type)
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ results[vulnerability_type] = results.get(vulnerability_type, [])
+ results[vulnerability_type].append(red_teaming_test_case)
+
+ return results
+
+ async def a_assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = await self.a_simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[IntellectualPropertyType, List[RedTeamingTestCase]] = dict()
+
+ async def process_attack(simulated_attack: SimulatedAttack):
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ metric = self._get_metric(vulnerability_type)
+ target_output = await model_callback(simulated_attack.input)
+
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ return vulnerability_type, red_teaming_test_case
+
+ # Run all processing concurrently
+ all_tasks = [
+ process_attack(simulated_attack)
+ for simulated_attack in simulated_attacks
+ if simulated_attack.vulnerability_type in self.types
+ ]
+
+ for task in asyncio.as_completed(all_tasks):
+ vulnerability_type, test_case = await task
+ results.setdefault(vulnerability_type, []).append(test_case)
+
+ return results
+
+ def simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ) -> List[SimulatedAttack]:
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ IntellectualPropertyTemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type, self.purpose
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = self.simulator_model.generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
+
+ async def a_simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ) -> List[SimulatedAttack]:
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ IntellectualPropertyTemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type, self.purpose
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = (
+ await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = await self.simulator_model.a_generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
+
def _get_metric(
self,
type: IntellectualPropertyType,
- ):
+ ) -> BaseRedTeamingMetric:
return IntellectualPropertyMetric(
purpose=self.purpose,
- model=self.model,
+ model=self.evaluation_model,
async_mode=self.async_mode,
verbose_mode=self.verbose_mode,
)
diff --git a/deepteam/vulnerabilities/misinformation/misinformation.py b/deepteam/vulnerabilities/misinformation/misinformation.py
index 9de9889e..58f7e83d 100644
--- a/deepteam/vulnerabilities/misinformation/misinformation.py
+++ b/deepteam/vulnerabilities/misinformation/misinformation.py
@@ -1,11 +1,22 @@
-from typing import List, Literal, Optional, Union
+from typing import List, Literal, Optional, Union, Dict
+import asyncio
from deepeval.models import DeepEvalBaseLLM
+from deepeval.metrics.utils import initialize_model, trimAndLoadJson
+from deepeval.utils import get_or_create_event_loop
+from deepeval.test_case import LLMTestCase
+
+from deepteam.utils import validate_model_callback_signature
from deepteam.vulnerabilities import BaseVulnerability
from deepteam.vulnerabilities.misinformation import MisinformationType
from deepteam.vulnerabilities.utils import validate_vulnerability_types
-from deepteam.metrics import MisinformationMetric
+from deepteam.metrics import MisinformationMetric, BaseRedTeamingMetric
+from deepteam.attacks.multi_turn.types import CallbackType
+from deepteam.attacks.attack_simulator import SimulatedAttack
+from deepteam.attacks.attack_simulator.schema import SyntheticDataList
+from deepteam.risks import getRiskCategory
+from .template import MisinformationTemplate
MisinformationLiteral = Literal[
@@ -17,9 +28,12 @@ class Misinformation(BaseVulnerability):
def __init__(
self,
misinformation_category: str,
- model: Optional[Union[str, DeepEvalBaseLLM]] = None,
async_mode: bool = True,
verbose_mode: bool = False,
+ simulator_model: Optional[
+ Union[str, DeepEvalBaseLLM]
+ ] = "gpt-3.5-turbo-0125",
+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",
types: Optional[List[MisinformationLiteral]] = [
type.value for type in MisinformationType
],
@@ -28,18 +42,243 @@ class Misinformation(BaseVulnerability):
self.get_name(), types=types, allowed_type=MisinformationType
)
self.misinformation_category = misinformation_category
- self.model = model
self.async_mode = async_mode
self.verbose_mode = verbose_mode
+ self.simulator_model = simulator_model
+ self.evaluation_model = evaluation_model
super().__init__(types=enum_types)
+ def assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+
+ if self.async_mode:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+ loop = get_or_create_event_loop()
+ return loop.run_until_complete(
+ self.a_assess(
+ model_callback=model_callback,
+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,
+ )
+ )
+ else:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = self.simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[MisinformationType, List[RedTeamingTestCase]] = dict()
+
+ for simulated_attack in simulated_attacks:
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ target_output = model_callback(simulated_attack.input)
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric = self._get_metric(vulnerability_type)
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ results[vulnerability_type] = results.get(vulnerability_type, [])
+ results[vulnerability_type].append(red_teaming_test_case)
+
+ return results
+
+ async def a_assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = await self.a_simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[MisinformationType, List[RedTeamingTestCase]] = dict()
+
+ async def process_attack(simulated_attack: SimulatedAttack):
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ metric = self._get_metric(vulnerability_type)
+ target_output = await model_callback(simulated_attack.input)
+
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ return vulnerability_type, red_teaming_test_case
+
+ # Run all processing concurrently
+ all_tasks = [
+ process_attack(simulated_attack)
+ for simulated_attack in simulated_attacks
+ if simulated_attack.vulnerability_type in self.types
+ ]
+
+ for task in asyncio.as_completed(all_tasks):
+ vulnerability_type, test_case = await task
+ results.setdefault(vulnerability_type, []).append(test_case)
+
+ return results
+
+ def simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ) -> List[SimulatedAttack]:
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ MisinformationTemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type, self.misinformation_category
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = self.simulator_model.generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
+
+ async def a_simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ) -> List[SimulatedAttack]:
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ MisinformationTemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type, self.misinformation_category
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = (
+ await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = await self.simulator_model.a_generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
+
def _get_metric(
self,
type: MisinformationType,
- ):
+ ) -> BaseRedTeamingMetric:
return MisinformationMetric(
misinformation_category=self.misinformation_category,
- model=self.model,
+ model=self.evaluation_model,
async_mode=self.async_mode,
verbose_mode=self.verbose_mode,
)
diff --git a/deepteam/vulnerabilities/personal_safety/personal_safety.py b/deepteam/vulnerabilities/personal_safety/personal_safety.py
index c5894283..65ca78e2 100644
--- a/deepteam/vulnerabilities/personal_safety/personal_safety.py
+++ b/deepteam/vulnerabilities/personal_safety/personal_safety.py
@@ -1,11 +1,22 @@
-from typing import List, Literal, Optional, Union
+from typing import List, Literal, Optional, Union, Dict
+import asyncio
from deepeval.models import DeepEvalBaseLLM
+from deepeval.metrics.utils import initialize_model, trimAndLoadJson
+from deepeval.utils import get_or_create_event_loop
+from deepeval.test_case import LLMTestCase
+
+from deepteam.utils import validate_model_callback_signature
from deepteam.vulnerabilities import BaseVulnerability
from deepteam.vulnerabilities.personal_safety import PersonalSafetyType
from deepteam.vulnerabilities.utils import validate_vulnerability_types
-from deepteam.metrics import SafetyMetric
+from deepteam.metrics import SafetyMetric, BaseRedTeamingMetric
+from deepteam.attacks.multi_turn.types import CallbackType
+from deepteam.attacks.attack_simulator import SimulatedAttack
+from deepteam.attacks.attack_simulator.schema import SyntheticDataList
+from deepteam.risks import getRiskCategory
+from .template import PersonalSafetyTemplate
PersonalSafetyLiteral = Literal[
"bullying",
@@ -20,9 +31,12 @@ class PersonalSafety(BaseVulnerability):
def __init__(
self,
safety_category: str,
- model: Optional[Union[str, DeepEvalBaseLLM]] = None,
async_mode: bool = True,
verbose_mode: bool = False,
+ simulator_model: Optional[
+ Union[str, DeepEvalBaseLLM]
+ ] = "gpt-3.5-turbo-0125",
+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",
types: Optional[List[PersonalSafetyLiteral]] = [
type.value for type in PersonalSafetyType
],
@@ -31,18 +45,243 @@ class PersonalSafety(BaseVulnerability):
self.get_name(), types=types, allowed_type=PersonalSafetyType
)
self.safety_category = safety_category
- self.model = model
self.async_mode = async_mode
self.verbose_mode = verbose_mode
+ self.simulator_model = simulator_model
+ self.evaluation_model = evaluation_model
super().__init__(types=enum_types)
+ def assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+
+ if self.async_mode:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+ loop = get_or_create_event_loop()
+ return loop.run_until_complete(
+ self.a_assess(
+ model_callback=model_callback,
+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,
+ )
+ )
+ else:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = self.simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[PersonalSafetyType, List[RedTeamingTestCase]] = dict()
+
+ for simulated_attack in simulated_attacks:
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ target_output = model_callback(simulated_attack.input)
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric = self._get_metric(vulnerability_type)
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ results[vulnerability_type] = results.get(vulnerability_type, [])
+ results[vulnerability_type].append(red_teaming_test_case)
+
+ return results
+
+ async def a_assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = await self.a_simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[PersonalSafetyType, List[RedTeamingTestCase]] = dict()
+
+ async def process_attack(simulated_attack: SimulatedAttack):
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ metric = self._get_metric(vulnerability_type)
+ target_output = await model_callback(simulated_attack.input)
+
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ return vulnerability_type, red_teaming_test_case
+
+ # Run all processing concurrently
+ all_tasks = [
+ process_attack(simulated_attack)
+ for simulated_attack in simulated_attacks
+ if simulated_attack.vulnerability_type in self.types
+ ]
+
+ for task in asyncio.as_completed(all_tasks):
+ vulnerability_type, test_case = await task
+ results.setdefault(vulnerability_type, []).append(test_case)
+
+ return results
+
+ def simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ) -> List[SimulatedAttack]:
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ PersonalSafetyTemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type, self.safety_category
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = self.simulator_model.generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
+
+ async def a_simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ) -> List[SimulatedAttack]:
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ PersonalSafetyTemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type, self.safety_category
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = (
+ await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = await self.simulator_model.a_generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
+
def _get_metric(
self,
type: PersonalSafetyType,
- ):
+ ) -> BaseRedTeamingMetric:
return SafetyMetric(
safety_category=self.safety_category,
- model=self.model,
+ model=self.evaluation_model,
async_mode=self.async_mode,
verbose_mode=self.verbose_mode,
)
diff --git a/deepteam/vulnerabilities/pii_leakage/pii_leakage.py b/deepteam/vulnerabilities/pii_leakage/pii_leakage.py
index e77b5e33..31fd84db 100644
--- a/deepteam/vulnerabilities/pii_leakage/pii_leakage.py
+++ b/deepteam/vulnerabilities/pii_leakage/pii_leakage.py
@@ -1,11 +1,22 @@
-from typing import List, Literal, Optional, Union
+from typing import List, Literal, Optional, Union, Dict
+import asyncio
from deepeval.models import DeepEvalBaseLLM
+from deepeval.metrics.utils import initialize_model, trimAndLoadJson
+from deepeval.utils import get_or_create_event_loop
+from deepeval.test_case import LLMTestCase
+
+from deepteam.utils import validate_model_callback_signature
from deepteam.vulnerabilities import BaseVulnerability
from deepteam.vulnerabilities.pii_leakage import PIILeakageType
from deepteam.vulnerabilities.utils import validate_vulnerability_types
-from deepteam.metrics import PIIMetric
+from deepteam.metrics import PIIMetric, BaseRedTeamingMetric
+from deepteam.attacks.multi_turn.types import CallbackType
+from deepteam.attacks.attack_simulator import SimulatedAttack
+from deepteam.attacks.attack_simulator.schema import SyntheticDataList
+from deepteam.risks import getRiskCategory
+from .template import PIILeakageTemplate
PIILeakageLiteral = Literal[
"api and database access",
@@ -19,9 +30,12 @@ class PIILeakage(BaseVulnerability):
def __init__(
self,
purpose: str,
- model: Optional[Union[str, DeepEvalBaseLLM]] = None,
async_mode: bool = True,
verbose_mode: bool = False,
+ simulator_model: Optional[
+ Union[str, DeepEvalBaseLLM]
+ ] = "gpt-3.5-turbo-0125",
+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",
types: Optional[List[PIILeakageLiteral]] = [
type.value for type in PIILeakageType
],
@@ -30,18 +44,243 @@ class PIILeakage(BaseVulnerability):
self.get_name(), types=types, allowed_type=PIILeakageType
)
self.purpose = purpose
- self.model = model
self.async_mode = async_mode
self.verbose_mode = verbose_mode
+ self.simulator_model = simulator_model
+ self.evaluation_model = evaluation_model
super().__init__(types=enum_types)
+ def assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+
+ if self.async_mode:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+ loop = get_or_create_event_loop()
+ return loop.run_until_complete(
+ self.a_assess(
+ model_callback=model_callback,
+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,
+ )
+ )
+ else:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = self.simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[PIILeakageType, List[RedTeamingTestCase]] = dict()
+
+ for simulated_attack in simulated_attacks:
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ target_output = model_callback(simulated_attack.input)
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric = self._get_metric(vulnerability_type)
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ results[vulnerability_type] = results.get(vulnerability_type, [])
+ results[vulnerability_type].append(red_teaming_test_case)
+
+ return results
+
+ async def a_assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = await self.a_simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[PIILeakageType, List[RedTeamingTestCase]] = dict()
+
+ async def process_attack(simulated_attack: SimulatedAttack):
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ metric = self._get_metric(vulnerability_type)
+ target_output = await model_callback(simulated_attack.input)
+
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ return vulnerability_type, red_teaming_test_case
+
+ # Run all processing concurrently
+ all_tasks = [
+ process_attack(simulated_attack)
+ for simulated_attack in simulated_attacks
+ if simulated_attack.vulnerability_type in self.types
+ ]
+
+ for task in asyncio.as_completed(all_tasks):
+ vulnerability_type, test_case = await task
+ results.setdefault(vulnerability_type, []).append(test_case)
+
+ return results
+
+ def simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ) -> List[SimulatedAttack]:
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ PIILeakageTemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type, self.purpose
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = self.simulator_model.generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
+
+ async def a_simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ) -> List[SimulatedAttack]:
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ PIILeakageTemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type, self.purpose
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = (
+ await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = await self.simulator_model.a_generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
+
def _get_metric(
self,
type: PIILeakageType,
- ):
+ ) -> BaseRedTeamingMetric:
return PIIMetric(
purpose=self.purpose,
- model=self.model,
+ model=self.evaluation_model,
async_mode=self.async_mode,
verbose_mode=self.verbose_mode,
)
diff --git a/deepteam/vulnerabilities/prompt_leakage/prompt_leakage.py b/deepteam/vulnerabilities/prompt_leakage/prompt_leakage.py
index ed53fa90..e08b7af7 100644
--- a/deepteam/vulnerabilities/prompt_leakage/prompt_leakage.py
+++ b/deepteam/vulnerabilities/prompt_leakage/prompt_leakage.py
@@ -1,11 +1,22 @@
-from typing import List, Literal, Optional, Union
+from typing import List, Literal, Optional, Union, Dict
+import asyncio
from deepeval.models import DeepEvalBaseLLM
+from deepeval.metrics.utils import initialize_model, trimAndLoadJson
+from deepeval.utils import get_or_create_event_loop
+from deepeval.test_case import LLMTestCase
+
+from deepteam.utils import validate_model_callback_signature
from deepteam.vulnerabilities import BaseVulnerability
from deepteam.vulnerabilities.prompt_leakage import PromptLeakageType
from deepteam.vulnerabilities.utils import validate_vulnerability_types
-from deepteam.metrics import PromptExtractionMetric
+from deepteam.metrics import PromptExtractionMetric, BaseRedTeamingMetric
+from deepteam.attacks.multi_turn.types import CallbackType
+from deepteam.attacks.attack_simulator import SimulatedAttack
+from deepteam.attacks.attack_simulator.schema import SyntheticDataList
+from deepteam.risks import getRiskCategory
+from .template import PromptLeakageTemplate
PromptLeakageLiteral = Literal[
"secrets and credentials",
@@ -19,9 +30,12 @@ class PromptLeakage(BaseVulnerability):
def __init__(
self,
purpose: str,
- model: Optional[Union[str, DeepEvalBaseLLM]] = None,
async_mode: bool = True,
verbose_mode: bool = False,
+ simulator_model: Optional[
+ Union[str, DeepEvalBaseLLM]
+ ] = "gpt-3.5-turbo-0125",
+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",
types: Optional[List[PromptLeakageLiteral]] = [
type.value for type in PromptLeakageType
],
@@ -30,18 +44,243 @@ class PromptLeakage(BaseVulnerability):
self.get_name(), types=types, allowed_type=PromptLeakageType
)
self.purpose = purpose
- self.model = model
self.async_mode = async_mode
self.verbose_mode = verbose_mode
+ self.simulator_model = simulator_model
+ self.evaluation_model = evaluation_model
super().__init__(types=enum_types)
+ def assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+
+ if self.async_mode:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+ loop = get_or_create_event_loop()
+ return loop.run_until_complete(
+ self.a_assess(
+ model_callback=model_callback,
+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,
+ )
+ )
+ else:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = self.simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[PromptLeakageType, List[RedTeamingTestCase]] = dict()
+
+ for simulated_attack in simulated_attacks:
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ target_output = model_callback(simulated_attack.input)
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric = self._get_metric(vulnerability_type)
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ results[vulnerability_type] = results.get(vulnerability_type, [])
+ results[vulnerability_type].append(red_teaming_test_case)
+
+ return results
+
+ async def a_assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = await self.a_simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[PromptLeakageType, List[RedTeamingTestCase]] = dict()
+
+ async def process_attack(simulated_attack: SimulatedAttack):
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ metric = self._get_metric(vulnerability_type)
+ target_output = await model_callback(simulated_attack.input)
+
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ return vulnerability_type, red_teaming_test_case
+
+ # Run all processing concurrently
+ all_tasks = [
+ process_attack(simulated_attack)
+ for simulated_attack in simulated_attacks
+ if simulated_attack.vulnerability_type in self.types
+ ]
+
+ for task in asyncio.as_completed(all_tasks):
+ vulnerability_type, test_case = await task
+ results.setdefault(vulnerability_type, []).append(test_case)
+
+ return results
+
+ def simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ) -> List[SimulatedAttack]:
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ PromptLeakageTemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type, self.purpose
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = self.simulator_model.generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
+
+ async def a_simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ) -> List[SimulatedAttack]:
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ PromptLeakageTemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type, self.purpose
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = (
+ await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = await self.simulator_model.a_generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
+
def _get_metric(
self,
type: PromptLeakageType,
- ):
+ ) -> BaseRedTeamingMetric:
return PromptExtractionMetric(
purpose=self.purpose,
- model=self.model,
+ model=self.evaluation_model,
async_mode=self.async_mode,
verbose_mode=self.verbose_mode,
)
diff --git a/deepteam/vulnerabilities/rbac/rbac.py b/deepteam/vulnerabilities/rbac/rbac.py
index a09453e7..aeef3be1 100644
--- a/deepteam/vulnerabilities/rbac/rbac.py
+++ b/deepteam/vulnerabilities/rbac/rbac.py
@@ -1,11 +1,22 @@
-from typing import List, Literal, Optional, Union
+from typing import List, Literal, Optional, Union, Dict
+import asyncio
from deepeval.models import DeepEvalBaseLLM
+from deepeval.metrics.utils import initialize_model, trimAndLoadJson
+from deepeval.utils import get_or_create_event_loop
+from deepeval.test_case import LLMTestCase
+
+from deepteam.utils import validate_model_callback_signature
from deepteam.vulnerabilities import BaseVulnerability
from deepteam.vulnerabilities.rbac import RBACType
from deepteam.vulnerabilities.utils import validate_vulnerability_types
-from deepteam.metrics import RBACMetric
+from deepteam.metrics import RBACMetric, BaseRedTeamingMetric
+from deepteam.attacks.multi_turn.types import CallbackType
+from deepteam.attacks.attack_simulator import SimulatedAttack
+from deepteam.attacks.attack_simulator.schema import SyntheticDataList
+from deepteam.risks import getRiskCategory
+from .template import RBACTemplate
RBACLiteral = Literal[
"role_bypass",
@@ -18,27 +29,255 @@ class RBAC(BaseVulnerability):
def __init__(
self,
purpose: str,
- model: Optional[Union[str, DeepEvalBaseLLM]] = None,
async_mode: bool = True,
verbose_mode: bool = False,
+ simulator_model: Optional[
+ Union[str, DeepEvalBaseLLM]
+ ] = "gpt-3.5-turbo-0125",
+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",
types: Optional[List[RBACLiteral]] = [type.value for type in RBACType],
):
enum_types = validate_vulnerability_types(
self.get_name(), types=types, allowed_type=RBACType
)
self.purpose = purpose
- self.model = model
self.async_mode = async_mode
self.verbose_mode = verbose_mode
+ self.simulator_model = simulator_model
+ self.evaluation_model = evaluation_model
super().__init__(types=enum_types)
+ def assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+
+ if self.async_mode:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+ loop = get_or_create_event_loop()
+ return loop.run_until_complete(
+ self.a_assess(
+ model_callback=model_callback,
+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,
+ )
+ )
+ else:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = self.simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[RBACType, List[RedTeamingTestCase]] = dict()
+
+ for simulated_attack in simulated_attacks:
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ target_output = model_callback(simulated_attack.input)
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric = self._get_metric(vulnerability_type)
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ results[vulnerability_type] = results.get(vulnerability_type, [])
+ results[vulnerability_type].append(red_teaming_test_case)
+
+ return results
+
+ async def a_assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = await self.a_simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[RBACType, List[RedTeamingTestCase]] = dict()
+
+ async def process_attack(simulated_attack: SimulatedAttack):
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ metric = self._get_metric(vulnerability_type)
+ target_output = await model_callback(simulated_attack.input)
+
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ return vulnerability_type, red_teaming_test_case
+
+ # Run all processing concurrently
+ all_tasks = [
+ process_attack(simulated_attack)
+ for simulated_attack in simulated_attacks
+ if simulated_attack.vulnerability_type in self.types
+ ]
+
+ for task in asyncio.as_completed(all_tasks):
+ vulnerability_type, test_case = await task
+ results.setdefault(vulnerability_type, []).append(test_case)
+
+ return results
+
+ def simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ) -> List[SimulatedAttack]:
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ RBACTemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type, self.purpose
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = self.simulator_model.generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
+
+ async def a_simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ) -> List[SimulatedAttack]:
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ RBACTemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type, self.purpose
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = (
+ await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = await self.simulator_model.a_generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
+
def _get_metric(
self,
type: RBACType,
- ):
+ ) -> BaseRedTeamingMetric:
return RBACMetric(
purpose=self.purpose,
- model=self.model,
+ model=self.evaluation_model,
async_mode=self.async_mode,
verbose_mode=self.verbose_mode,
)
diff --git a/deepteam/vulnerabilities/shell_injection/shell_injection.py b/deepteam/vulnerabilities/shell_injection/shell_injection.py
index 813fccc3..9839ca0a 100644
--- a/deepteam/vulnerabilities/shell_injection/shell_injection.py
+++ b/deepteam/vulnerabilities/shell_injection/shell_injection.py
@@ -1,11 +1,22 @@
-from typing import List, Literal, Optional, Union
+from typing import List, Literal, Optional, Union, Dict
+import asyncio
from deepeval.models import DeepEvalBaseLLM
+from deepeval.metrics.utils import initialize_model, trimAndLoadJson
+from deepeval.utils import get_or_create_event_loop
+from deepeval.test_case import LLMTestCase
+
+from deepteam.utils import validate_model_callback_signature
from deepteam.vulnerabilities import BaseVulnerability
from deepteam.vulnerabilities.shell_injection import ShellInjectionType
from deepteam.vulnerabilities.utils import validate_vulnerability_types
-from deepteam.metrics import ShellInjectionMetric
+from deepteam.metrics import ShellInjectionMetric, BaseRedTeamingMetric
+from deepteam.attacks.multi_turn.types import CallbackType
+from deepteam.attacks.attack_simulator import SimulatedAttack
+from deepteam.attacks.attack_simulator.schema import SyntheticDataList
+from deepteam.risks import getRiskCategory
+from .template import ShellInjectionTemplate
ShellInjectionLiteral = Literal[
"command_injection",
@@ -17,9 +28,12 @@ ShellInjectionLiteral = Literal[
class ShellInjection(BaseVulnerability):
def __init__(
self,
- model: Optional[Union[str, DeepEvalBaseLLM]] = None,
async_mode: bool = True,
verbose_mode: bool = False,
+ simulator_model: Optional[
+ Union[str, DeepEvalBaseLLM]
+ ] = "gpt-3.5-turbo-0125",
+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",
types: Optional[List[ShellInjectionLiteral]] = [
type.value for type in ShellInjectionType
],
@@ -27,17 +41,242 @@ class ShellInjection(BaseVulnerability):
enum_types = validate_vulnerability_types(
self.get_name(), types=types, allowed_type=ShellInjectionType
)
- self.model = model
self.async_mode = async_mode
self.verbose_mode = verbose_mode
+ self.simulator_model = simulator_model
+ self.evaluation_model = evaluation_model
super().__init__(types=enum_types)
+
+ def assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+
+ if self.async_mode:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+ loop = get_or_create_event_loop()
+ return loop.run_until_complete(
+ self.a_assess(
+ model_callback=model_callback,
+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,
+ )
+ )
+ else:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = self.simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[ShellInjectionType, List[RedTeamingTestCase]] = dict()
+
+ for simulated_attack in simulated_attacks:
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ target_output = model_callback(simulated_attack.input)
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric = self._get_metric(vulnerability_type)
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ results[vulnerability_type] = results.get(vulnerability_type, [])
+ results[vulnerability_type].append(red_teaming_test_case)
+
+ return results
+
+ async def a_assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = await self.a_simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[ShellInjectionType, List[RedTeamingTestCase]] = dict()
+
+ async def process_attack(simulated_attack: SimulatedAttack):
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ metric = self._get_metric(vulnerability_type)
+ target_output = await model_callback(simulated_attack.input)
+
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ return vulnerability_type, red_teaming_test_case
+
+ # Run all processing concurrently
+ all_tasks = [
+ process_attack(simulated_attack)
+ for simulated_attack in simulated_attacks
+ if simulated_attack.vulnerability_type in self.types
+ ]
+
+ for task in asyncio.as_completed(all_tasks):
+ vulnerability_type, test_case = await task
+ results.setdefault(vulnerability_type, []).append(test_case)
+
+ return results
+
+ def simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ) -> List[SimulatedAttack]:
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ ShellInjectionTemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = self.simulator_model.generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
+
+ async def a_simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ) -> List[SimulatedAttack]:
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ ShellInjectionTemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = (
+ await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = await self.simulator_model.a_generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
def _get_metric(
self,
type: ShellInjectionType,
- ):
+ ) -> BaseRedTeamingMetric:
return ShellInjectionMetric(
- model=self.model,
+ model=self.evaluation_model,
async_mode=self.async_mode,
verbose_mode=self.verbose_mode,
)
diff --git a/deepteam/vulnerabilities/sql_injection/sql_injection.py b/deepteam/vulnerabilities/sql_injection/sql_injection.py
index ec20c5b8..6bc48468 100644
--- a/deepteam/vulnerabilities/sql_injection/sql_injection.py
+++ b/deepteam/vulnerabilities/sql_injection/sql_injection.py
@@ -1,11 +1,22 @@
-from typing import List, Literal, Optional, Union
+from typing import List, Literal, Optional, Union, Dict
+import asyncio
from deepeval.models import DeepEvalBaseLLM
+from deepeval.metrics.utils import initialize_model, trimAndLoadJson
+from deepeval.utils import get_or_create_event_loop
+from deepeval.test_case import LLMTestCase
+
+from deepteam.utils import validate_model_callback_signature
from deepteam.vulnerabilities import BaseVulnerability
from deepteam.vulnerabilities.sql_injection import SQLInjectionType
from deepteam.vulnerabilities.utils import validate_vulnerability_types
-from deepteam.metrics import SQLInjectionMetric
+from deepteam.metrics import SQLInjectionMetric, BaseRedTeamingMetric
+from deepteam.attacks.multi_turn.types import CallbackType
+from deepteam.attacks.attack_simulator import SimulatedAttack
+from deepteam.attacks.attack_simulator.schema import SyntheticDataList
+from deepteam.risks import getRiskCategory
+from .template import SQLInjectionTemplate
SQLInjectionLiteral = Literal[
"blind_sql_injection",
@@ -17,9 +28,12 @@ SQLInjectionLiteral = Literal[
class SQLInjection(BaseVulnerability):
def __init__(
self,
- model: Optional[Union[str, DeepEvalBaseLLM]] = None,
async_mode: bool = True,
verbose_mode: bool = False,
+ simulator_model: Optional[
+ Union[str, DeepEvalBaseLLM]
+ ] = "gpt-3.5-turbo-0125",
+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",
types: Optional[List[SQLInjectionLiteral]] = [
type.value for type in SQLInjectionType
],
@@ -27,17 +41,242 @@ class SQLInjection(BaseVulnerability):
enum_types = validate_vulnerability_types(
self.get_name(), types=types, allowed_type=SQLInjectionType
)
- self.model = model
self.async_mode = async_mode
self.verbose_mode = verbose_mode
+ self.simulator_model = simulator_model
+ self.evaluation_model = evaluation_model
super().__init__(types=enum_types)
+
+ def assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+
+ if self.async_mode:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+ loop = get_or_create_event_loop()
+ return loop.run_until_complete(
+ self.a_assess(
+ model_callback=model_callback,
+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,
+ )
+ )
+ else:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = self.simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[SQLInjectionType, List[RedTeamingTestCase]] = dict()
+
+ for simulated_attack in simulated_attacks:
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ target_output = model_callback(simulated_attack.input)
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric = self._get_metric(vulnerability_type)
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ results[vulnerability_type] = results.get(vulnerability_type, [])
+ results[vulnerability_type].append(red_teaming_test_case)
+
+ return results
+
+ async def a_assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = await self.a_simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[SQLInjectionType, List[RedTeamingTestCase]] = dict()
+
+ async def process_attack(simulated_attack: SimulatedAttack):
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ metric = self._get_metric(vulnerability_type)
+ target_output = await model_callback(simulated_attack.input)
+
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ return vulnerability_type, red_teaming_test_case
+
+ # Run all processing concurrently
+ all_tasks = [
+ process_attack(simulated_attack)
+ for simulated_attack in simulated_attacks
+ if simulated_attack.vulnerability_type in self.types
+ ]
+
+ for task in asyncio.as_completed(all_tasks):
+ vulnerability_type, test_case = await task
+ results.setdefault(vulnerability_type, []).append(test_case)
+
+ return results
+
+ def simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ) -> List[SimulatedAttack]:
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ SQLInjectionTemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = self.simulator_model.generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
+
+ async def a_simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ) -> List[SimulatedAttack]:
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ SQLInjectionTemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = (
+ await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = await self.simulator_model.a_generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
def _get_metric(
self,
type: SQLInjectionType,
- ):
+ ) -> BaseRedTeamingMetric:
return SQLInjectionMetric(
- model=self.model,
+ model=self.evaluation_model,
async_mode=self.async_mode,
verbose_mode=self.verbose_mode,
)
diff --git a/deepteam/vulnerabilities/ssrf/ssrf.py b/deepteam/vulnerabilities/ssrf/ssrf.py
index fa8c766a..a468f306 100644
--- a/deepteam/vulnerabilities/ssrf/ssrf.py
+++ b/deepteam/vulnerabilities/ssrf/ssrf.py
@@ -1,11 +1,22 @@
-from typing import List, Literal, Optional, Union
+from typing import List, Literal, Optional, Union, Dict
+import asyncio
from deepeval.models import DeepEvalBaseLLM
+from deepeval.metrics.utils import initialize_model, trimAndLoadJson
+from deepeval.utils import get_or_create_event_loop
+from deepeval.test_case import LLMTestCase
+
+from deepteam.utils import validate_model_callback_signature
from deepteam.vulnerabilities import BaseVulnerability
from deepteam.vulnerabilities.ssrf import SSRFType
from deepteam.vulnerabilities.utils import validate_vulnerability_types
-from deepteam.metrics import SSRFMetric
+from deepteam.metrics import SSRFMetric, BaseRedTeamingMetric
+from deepteam.attacks.multi_turn.types import CallbackType
+from deepteam.attacks.attack_simulator import SimulatedAttack
+from deepteam.attacks.attack_simulator.schema import SyntheticDataList
+from deepteam.risks import getRiskCategory
+from .template import SSRFTemplate
SSRFLiteral = Literal[
"internal_service_access",
@@ -18,27 +29,255 @@ class SSRF(BaseVulnerability):
def __init__(
self,
purpose: str,
- model: Optional[Union[str, DeepEvalBaseLLM]] = None,
async_mode: bool = True,
verbose_mode: bool = False,
+ simulator_model: Optional[
+ Union[str, DeepEvalBaseLLM]
+ ] = "gpt-3.5-turbo-0125",
+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",
types: Optional[List[SSRFLiteral]] = [type.value for type in SSRFType],
):
enum_types = validate_vulnerability_types(
self.get_name(), types=types, allowed_type=SSRFType
)
self.purpose = purpose
- self.model = model
self.async_mode = async_mode
self.verbose_mode = verbose_mode
+ self.simulator_model = simulator_model
+ self.evaluation_model = evaluation_model
super().__init__(types=enum_types)
+
+ def assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+
+ if self.async_mode:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+ loop = get_or_create_event_loop()
+ return loop.run_until_complete(
+ self.a_assess(
+ model_callback=model_callback,
+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,
+ )
+ )
+ else:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = self.simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[SSRFType, List[RedTeamingTestCase]] = dict()
+
+ for simulated_attack in simulated_attacks:
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ target_output = model_callback(simulated_attack.input)
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric = self._get_metric(vulnerability_type)
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ results[vulnerability_type] = results.get(vulnerability_type, [])
+ results[vulnerability_type].append(red_teaming_test_case)
+
+ return results
+
+ async def a_assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = await self.a_simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[SSRFType, List[RedTeamingTestCase]] = dict()
+
+ async def process_attack(simulated_attack: SimulatedAttack):
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ metric = self._get_metric(vulnerability_type)
+ target_output = await model_callback(simulated_attack.input)
+
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ return vulnerability_type, red_teaming_test_case
+
+ # Run all processing concurrently
+ all_tasks = [
+ process_attack(simulated_attack)
+ for simulated_attack in simulated_attacks
+ if simulated_attack.vulnerability_type in self.types
+ ]
+
+ for task in asyncio.as_completed(all_tasks):
+ vulnerability_type, test_case = await task
+ results.setdefault(vulnerability_type, []).append(test_case)
+
+ return results
+
+ def simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ) -> List[SimulatedAttack]:
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ SSRFTemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type, self.purpose
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = self.simulator_model.generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
+
+ async def a_simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ) -> List[SimulatedAttack]:
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ SSRFTemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type, self.purpose
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = (
+ await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = await self.simulator_model.a_generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
def _get_metric(
self,
type: SSRFType,
- ):
+ ) -> BaseRedTeamingMetric:
return SSRFMetric(
purpose=self.purpose,
- model=self.model,
+ model=self.evaluation_model,
async_mode=self.async_mode,
verbose_mode=self.verbose_mode,
)
diff --git a/deepteam/vulnerabilities/toxicity/toxicity.py b/deepteam/vulnerabilities/toxicity/toxicity.py
index f956c1e9..b165fa82 100644
--- a/deepteam/vulnerabilities/toxicity/toxicity.py
+++ b/deepteam/vulnerabilities/toxicity/toxicity.py
@@ -1,11 +1,22 @@
-from typing import List, Literal, Optional, Union
+from typing import List, Literal, Optional, Union, Dict
+import asyncio
from deepeval.models import DeepEvalBaseLLM
+from deepeval.metrics.utils import initialize_model, trimAndLoadJson
+from deepeval.utils import get_or_create_event_loop
+from deepeval.test_case import LLMTestCase
+
+from deepteam.utils import validate_model_callback_signature
from deepteam.vulnerabilities import BaseVulnerability
from deepteam.vulnerabilities.toxicity import ToxicityType
from deepteam.vulnerabilities.utils import validate_vulnerability_types
-from deepteam.metrics import ToxicityMetric
+from deepteam.metrics import ToxicityMetric, BaseRedTeamingMetric
+from deepteam.attacks.multi_turn.types import CallbackType
+from deepteam.attacks.attack_simulator import SimulatedAttack
+from deepteam.attacks.attack_simulator.schema import SyntheticDataList
+from deepteam.risks import getRiskCategory
+from .template import ToxicityTemplate
ToxicityLiteral = Literal["profanity", "insults", "threats", "mockery"]
@@ -14,9 +25,12 @@ class Toxicity(BaseVulnerability):
def __init__(
self,
toxicity_category: str,
- model: Optional[Union[str, DeepEvalBaseLLM]] = None,
async_mode: bool = True,
verbose_mode: bool = False,
+ simulator_model: Optional[
+ Union[str, DeepEvalBaseLLM]
+ ] = "gpt-3.5-turbo-0125",
+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",
types: Optional[List[ToxicityLiteral]] = [
type.value for type in ToxicityType
],
@@ -25,18 +39,243 @@ class Toxicity(BaseVulnerability):
self.get_name(), types=types, allowed_type=ToxicityType
)
self.toxicity_category = toxicity_category
- self.model = model
self.async_mode = async_mode
self.verbose_mode = verbose_mode
+ self.simulator_model = simulator_model
+ self.evaluation_model = evaluation_model
super().__init__(types=enum_types)
+ def assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+
+ if self.async_mode:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+ loop = get_or_create_event_loop()
+ return loop.run_until_complete(
+ self.a_assess(
+ model_callback=model_callback,
+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,
+ )
+ )
+ else:
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = self.simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[ToxicityType, List[RedTeamingTestCase]] = dict()
+
+ for simulated_attack in simulated_attacks:
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ target_output = model_callback(simulated_attack.input)
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric = self._get_metric(vulnerability_type)
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ results[vulnerability_type] = results.get(vulnerability_type, [])
+ results[vulnerability_type].append(red_teaming_test_case)
+
+ return results
+
+ async def a_assess(
+ self,
+ model_callback: CallbackType,
+ attacks_per_vulnerability_type: int = 1,
+ ):
+ from deepteam.red_teamer.risk_assessment import (
+ RedTeamingTestCase,
+ )
+
+ validate_model_callback_signature(
+ model_callback=model_callback,
+ async_mode=self.async_mode,
+ )
+
+ simulated_attacks = await self.a_simulate_attacks(
+ attacks_per_vulnerability_type
+ )
+
+ results: Dict[ToxicityType, List[RedTeamingTestCase]] = dict()
+
+ async def process_attack(simulated_attack: SimulatedAttack):
+ vulnerability_type = simulated_attack.vulnerability_type
+
+ metric = self._get_metric(vulnerability_type)
+ target_output = await model_callback(simulated_attack.input)
+
+ test_case = LLMTestCase(
+ input=simulated_attack.input,
+ actual_output=target_output,
+ )
+
+ metric.measure(test_case)
+
+ red_teaming_test_case = RedTeamingTestCase(
+ vulnerability=simulated_attack.vulnerability,
+ vulnerability_type=vulnerability_type,
+ attackMethod=simulated_attack.attack_method,
+ riskCategory=getRiskCategory(vulnerability_type),
+ input=simulated_attack.input,
+ actual_output=target_output,
+ score=metric.score,
+ reason=metric.reason,
+ )
+
+ return vulnerability_type, red_teaming_test_case
+
+ # Run all processing concurrently
+ all_tasks = [
+ process_attack(simulated_attack)
+ for simulated_attack in simulated_attacks
+ if simulated_attack.vulnerability_type in self.types
+ ]
+
+ for task in asyncio.as_completed(all_tasks):
+ vulnerability_type, test_case = await task
+ results.setdefault(vulnerability_type, []).append(test_case)
+
+ return results
+
+ def simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ) -> List[SimulatedAttack]:
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ ToxicityTemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type, self.purpose
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = self.simulator_model.generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = self.simulator_model.generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
+
+ async def a_simulate_attacks(
+ self,
+ attacks_per_vulnerability_type: int = 1,
+ ) -> List[SimulatedAttack]:
+
+ self.simulator_model, self.using_native_model = initialize_model(
+ self.simulator_model
+ )
+
+ templates = dict()
+ simulated_attacks: List[SimulatedAttack] = []
+
+ for type in self.types:
+ templates[type] = templates.get(type, [])
+ templates[type].append(
+ ToxicityTemplate.generate_baseline_attacks(
+ type, attacks_per_vulnerability_type, self.purpose
+ )
+ )
+
+ for type in self.types:
+ for prompt in templates[type]:
+ if self.using_native_model:
+ res, _ = await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ local_attacks = [item.input for item in res.data]
+ else:
+ try:
+ res: SyntheticDataList = (
+ await self.simulator_model.a_generate(
+ prompt, schema=SyntheticDataList
+ )
+ )
+ local_attacks = [item.input for item in res.data]
+ except TypeError:
+ res = await self.simulator_model.a_generate(prompt)
+ data = trimAndLoadJson(res)
+ local_attacks = [item["input"] for item in data["data"]]
+
+ simulated_attacks.extend(
+ [
+ SimulatedAttack(
+ vulnerability=self.get_name(),
+ vulnerability_type=type,
+ input=local_attack,
+ )
+ for local_attack in local_attacks
+ ]
+ )
+
+ return simulated_attacks
+
def _get_metric(
self,
type: ToxicityType,
- ):
+ ) -> BaseRedTeamingMetric:
return ToxicityMetric(
toxicity_category=self.toxicity_category,
- model=self.model,
+ model=self.evaluation_model,
async_mode=self.async_mode,
verbose_mode=self.verbose_mode,
)