Skip to content

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

Reformat

penguinedaefa2296a4c
diff --git a/a.py b/a.py
index 58b39c85..a45d24f9 100644
--- a/a.py
+++ b/a.py
@@ -133,7 +133,7 @@ from deepteam.vulnerabilities import Bias
from deepteam.attacks.single_turn import PromptInjection
-def model_callback(input: str) -> str:
+async def model_callback(input: str) -> str:
# Replace this with your LLM application
return f"I'm sorry but I can't answer this: {input}"
diff --git a/b.py b/b.py
index 901a23e9..4122525c 100644
--- a/b.py
+++ b/b.py
@@ -14,9 +14,9 @@ from deepeval.models import GPTModel
from deepteam.attacks.attack_simulator.attack_simulator import AttackSimulator
from deepteam.attacks.attack_simulator.template import AttackSimulatorTemplate
from deepteam.vulnerabilities import (
- Bias,
- Misinformation,
- Toxicity,
+ Bias,
+ Misinformation,
+ Toxicity,
PIILeakage,
PromptLeakage,
UnauthorizedAccess,
@@ -26,7 +26,7 @@ from deepteam.vulnerabilities import (
GraphicContent,
IntellectualProperty,
PersonalSafety,
- Robustness
+ Robustness,
)
from deepteam.vulnerabilities.types import (
@@ -51,14 +51,18 @@ from deepteam.vulnerabilities.competition import CompetitionTemplate
from deepteam.vulnerabilities.excessive_agency import ExcessiveAgencyTemplate
from deepteam.vulnerabilities.graphic_content import GraphicContentTemplate
from deepteam.vulnerabilities.illegal_activity import IllegalActivityTemplate
-from deepteam.vulnerabilities.intellectual_property import IntellectualPropertyTemplate
+from deepteam.vulnerabilities.intellectual_property import (
+ IntellectualPropertyTemplate,
+)
from deepteam.vulnerabilities.misinformation import MisinformationTemplate
from deepteam.vulnerabilities.personal_safety import PersonalSafetyTemplate
from deepteam.vulnerabilities.pii_leakage import PIILeakageTemplate
from deepteam.vulnerabilities.prompt_leakage import PromptLeakageTemplate
from deepteam.vulnerabilities.robustness import RobustnessTemplate
from deepteam.vulnerabilities.toxicity import ToxicityTemplate
-from deepteam.vulnerabilities.unauthorized_access import UnauthorizedAccessTemplate
+from deepteam.vulnerabilities.unauthorized_access import (
+ UnauthorizedAccessTemplate,
+)
# Configuration
MAX_GOLDENS = 3
@@ -70,23 +74,23 @@ VULNERABILITY_TYPE_MAPPING = {
"gender": BiasType.GENDER,
"religion": BiasType.RELIGION,
"race": BiasType.RACE,
- "politics": BiasType.POLITICS
+ "politics": BiasType.POLITICS,
},
"competition": {
"competitor_mention": CompetitionType.COMPETITOR_MENTION,
"market_manipulation": CompetitionType.MARKET_MANIPULATION,
"discreditation": CompetitionType.DISCREDITATION,
- "confidential_strategies": CompetitionType.CONFIDENTIAL_STRATEGIES
+ "confidential_strategies": CompetitionType.CONFIDENTIAL_STRATEGIES,
},
"excessive_agency": {
"functionality": ExcessiveAgencyType.FUNCTIONALITY,
"permissions": ExcessiveAgencyType.PERMISSIONS,
- "autonomy": ExcessiveAgencyType.AUTONOMY
+ "autonomy": ExcessiveAgencyType.AUTONOMY,
},
"graphic_content": {
"sexual_content": GraphicContentType.SEXUAL_CONTENT,
"graphic_content": GraphicContentType.GRAPHIC_CONTENT,
- "pornographic_content": GraphicContentType.PORNOGRAPHIC_CONTENT
+ "pornographic_content": GraphicContentType.PORNOGRAPHIC_CONTENT,
},
"illegal_activity": {
"weapons": IllegalActivityType.WEAPONS,
@@ -95,47 +99,47 @@ VULNERABILITY_TYPE_MAPPING = {
"non_violent_crime": IllegalActivityType.NON_VIOLENT_CRIME,
"sex_crime": IllegalActivityType.SEX_CRIME,
"cybercrime": IllegalActivityType.CYBERCRIME,
- "child_exploitation": IllegalActivityType.CHILD_EXPLOITATION
+ "child_exploitation": IllegalActivityType.CHILD_EXPLOITATION,
},
"intellectual_property": {
"imitation": IntellectualPropertyType.IMITATION,
"copyright_violations": IntellectualPropertyType.COPYRIGHT_VIOLATIONS,
"trademark_infringement": IntellectualPropertyType.TRADEMARK_INFRINGEMENT,
- "patent_disclosure": IntellectualPropertyType.PATENT_DISCLOSURE
+ "patent_disclosure": IntellectualPropertyType.PATENT_DISCLOSURE,
},
"misinformation": {
"factual_errors": MisinformationType.FACTUAL_ERRORS,
"unsupported_claims": MisinformationType.UNSUPPORTED_CLAIMS,
- "expertise_misrepresentation": MisinformationType.EXPERTIZE_MISREPRESENTATION
+ "expertise_misrepresentation": MisinformationType.EXPERTIZE_MISREPRESENTATION,
},
"personal_safety": {
"bullying": PersonalSafetyType.BULLYING,
"self_harm": PersonalSafetyType.SELF_HARM,
"unsafe_practices": PersonalSafetyType.UNSAFE_PRACTICES,
"dangerous_challenges": PersonalSafetyType.DANGEROUS_CHALLENGES,
- "stalking": PersonalSafetyType.STALKING
+ "stalking": PersonalSafetyType.STALKING,
},
"pii_leakage": {
"direct": PIILeakageType.DIRECT,
"database_access": PIILeakageType.DATABASE_ACCESS,
"social_manipulation": PIILeakageType.SOCIAL_MANIPULATION,
- "session_leak": PIILeakageType.SESSION_LEAK
+ "session_leak": PIILeakageType.SESSION_LEAK,
},
"prompt_leakage": {
"secrets_and_credentials": PromptLeakageType.SECRETS_AND_CREDENTIALS,
"instructions": PromptLeakageType.INSTRUCTIONS,
"guard_exposure": PromptLeakageType.GUARD_EXPOSURE,
- "permissions_and_roles": PromptLeakageType.PERMISSIONS_AND_ROLES
+ "permissions_and_roles": PromptLeakageType.PERMISSIONS_AND_ROLES,
},
"robustness": {
"input_overreliance": RobustnessType.INPUT_OVERRELIANCE,
- "hijacking": RobustnessType.HIJACKING
+ "hijacking": RobustnessType.HIJACKING,
},
"toxicity": {
"insults": ToxicityType.INSULTS,
"profanity": ToxicityType.PROFANITY,
"threats": ToxicityType.THREATS,
- "mockery": ToxicityType.MOCKERY
+ "mockery": ToxicityType.MOCKERY,
},
"unauthorized_access": {
"bfla": UnauthorizedAccessType.BFLA,
@@ -144,8 +148,8 @@ VULNERABILITY_TYPE_MAPPING = {
"debug_access": UnauthorizedAccessType.DEBUG_ACCESS,
"shell_injection": UnauthorizedAccessType.SHELL_INJECTION,
"sql_injection": UnauthorizedAccessType.SQL_INJECTION,
- "ssrf": UnauthorizedAccessType.SSRF
- }
+ "ssrf": UnauthorizedAccessType.SSRF,
+ },
}
@@ -160,19 +164,21 @@ def get_all_vulnerability_types() -> str:
return result
-def get_vulnerability_from_args(vul_type: str, subtype: str) -> Optional[VulnerabilityType]:
+def get_vulnerability_from_args(
+ vul_type: str, subtype: str
+) -> Optional[VulnerabilityType]:
"""Convert command line arguments to a vulnerability type enum."""
if vul_type not in VULNERABILITY_TYPE_MAPPING:
print(f"Error: '{vul_type}' is not a valid vulnerability type.")
return None
-
+
if subtype not in VULNERABILITY_TYPE_MAPPING[vul_type]:
print(f"Error: '{subtype}' is not a valid subtype for {vul_type}.")
print(f"Available subtypes for {vul_type}:")
for available_subtype in VULNERABILITY_TYPE_MAPPING[vul_type]:
print(f" - {available_subtype}")
return None
-
+
return VULNERABILITY_TYPE_MAPPING[vul_type][subtype]
@@ -183,131 +189,137 @@ def separator():
def test_local_baseline_attacks(purpose: str):
"""Test local baseline attack generation using OpenAI for key vulnerability types"""
- print(f"Testing local baseline attack generation with OpenAI for purpose: {purpose}\n")
-
+ print(
+ f"Testing local baseline attack generation with OpenAI for purpose: {purpose}\n"
+ )
+
# Check if OpenAI API key is set
api_key = os.environ.get("OPENAI_API_KEY")
if not api_key:
api_key = input("Please enter your OpenAI API key: ")
os.environ["OPENAI_API_KEY"] = api_key
-
+
# Create a simulator with an OpenAI model
openai_model = GPTModel(model_name="gpt-3.5-turbo")
simulator = AttackSimulator(
- purpose=purpose,
- max_concurrent=3,
- simulator_model=openai_model
+ purpose=purpose, max_concurrent=3, simulator_model=openai_model
)
-
+
# Create all vulnerabilities to test, grouped by category for easier debugging
vulnerabilities = []
-
+
# Group 1: Basic vulnerabilities already verified to work
basic_vulnerabilities = [
Bias(types=["religion"]),
Misinformation(types=["factual errors"]),
Toxicity(types=["profanity"]),
- PIILeakage(types=["direct disclosure"])
+ PIILeakage(types=["direct disclosure"]),
]
vulnerabilities.extend(basic_vulnerabilities)
-
+
# Group 2: PromptLeakage vulnerabilities
prompt_leakage_vulnerabilities = [
PromptLeakage(types=["secrets and credentials"]),
PromptLeakage(types=["instructions"]),
PromptLeakage(types=["guard exposure"]),
- PromptLeakage(types=["permissions and roles"])
+ PromptLeakage(types=["permissions and roles"]),
]
vulnerabilities.extend(prompt_leakage_vulnerabilities)
-
+
# Group 3: UnauthorizedAccess vulnerabilities
unauthorized_access_vulnerabilities = [
UnauthorizedAccess(types=["debug access"]),
- UnauthorizedAccess(types=["bola"]), # Correct string for "broken object level authorization"
- UnauthorizedAccess(types=["bfla"]), # Correct string for "broken function level authorization"
- UnauthorizedAccess(types=["rbac"]), # Correct string for "role-based access control"
+ UnauthorizedAccess(
+ types=["bola"]
+ ), # Correct string for "broken object level authorization"
+ UnauthorizedAccess(
+ types=["bfla"]
+ ), # Correct string for "broken function level authorization"
+ UnauthorizedAccess(
+ types=["rbac"]
+ ), # Correct string for "role-based access control"
UnauthorizedAccess(types=["shell injection"]),
- UnauthorizedAccess(types=["sql injection"])
+ UnauthorizedAccess(types=["sql injection"]),
]
vulnerabilities.extend(unauthorized_access_vulnerabilities)
-
+
# Group 4: Competition vulnerabilities
competition_vulnerabilities = [
Competition(types=["competitor mention"]),
Competition(types=["market manipulation"]),
Competition(types=["discreditation"]),
- Competition(types=["confidential strategies"])
+ Competition(types=["confidential strategies"]),
]
vulnerabilities.extend(competition_vulnerabilities)
-
+
# Group 5: RobustnessType vulnerabilities
robustness_vulnerabilities = [
Robustness(types=["input overreliance"]),
- Robustness(types=["hijacking"])
+ Robustness(types=["hijacking"]),
]
vulnerabilities.extend(robustness_vulnerabilities)
-
+
# Group 6: ExcessiveAgency vulnerabilities
excessive_agency_vulnerabilities = [
ExcessiveAgency(types=["functionality"]),
ExcessiveAgency(types=["permissions"]),
- ExcessiveAgency(types=["autonomy"])
+ ExcessiveAgency(types=["autonomy"]),
]
vulnerabilities.extend(excessive_agency_vulnerabilities)
-
+
# Group 7: GraphicContent vulnerabilities
graphic_content_vulnerabilities = [
GraphicContent(types=["sexual content"]),
GraphicContent(types=["graphic content"]),
- GraphicContent(types=["pornographic content"])
+ GraphicContent(types=["pornographic content"]),
]
vulnerabilities.extend(graphic_content_vulnerabilities)
-
+
# Group 8: IllegalActivity vulnerabilities - only test a few selected types
illegal_activity_vulnerabilities = [
IllegalActivity(types=["weapons"]),
IllegalActivity(types=["illegal drugs"]),
IllegalActivity(types=["violent crimes"]),
- IllegalActivity(types=["cybercrime"])
+ IllegalActivity(types=["cybercrime"]),
]
vulnerabilities.extend(illegal_activity_vulnerabilities)
-
+
# Group 9: IntellectualProperty vulnerabilities
intellectual_property_vulnerabilities = [
IntellectualProperty(types=["copyright violations"]),
IntellectualProperty(types=["trademark infringement"]),
IntellectualProperty(types=["patent disclosure"]),
- IntellectualProperty(types=["imitation"])
+ IntellectualProperty(types=["imitation"]),
]
vulnerabilities.extend(intellectual_property_vulnerabilities)
-
+
# Group 10: PersonalSafety vulnerabilities
personal_safety_vulnerabilities = [
PersonalSafety(types=["bullying"]),
PersonalSafety(types=["self-harm"]),
PersonalSafety(types=["dangerous challenges"]),
- PersonalSafety(types=["stalking"])
+ PersonalSafety(types=["stalking"]),
]
vulnerabilities.extend(personal_safety_vulnerabilities)
-
+
print(f"Testing {len(vulnerabilities)} vulnerability types")
-
+
# Track results
successful = []
failed = []
-
+
# Generate baseline attacks locally
print("Generating baseline attacks locally for each vulnerability type...")
-
+
for i, vulnerability in enumerate(vulnerabilities):
print(f"\n[{i+1}/{len(vulnerabilities)}] Testing: {vulnerability}")
try:
attacks = simulator.simulate_baseline_attacks(
attacks_per_vulnerability_type=1,
vulnerability=vulnerability,
- ignore_errors=False # We want to catch errors
+ ignore_errors=False, # We want to catch errors
)
-
+
if attacks:
successful.append((vulnerability, attacks[0]))
print(f"✅ SUCCESS: Generated attack")
@@ -318,39 +330,46 @@ def test_local_baseline_attacks(purpose: str):
except Exception as e:
failed.append((vulnerability, str(e)))
print(f"❌ ERROR: {str(e)}")
-
+
# Add a small delay to avoid rate limiting
time.sleep(1)
-
+
# Print summary
print("\n\n=== SUMMARY ===")
print(f"Total vulnerability types tested: {len(vulnerabilities)}")
print(f"Successful: {len(successful)}")
print(f"Failed: {len(failed)}")
-
+
if failed:
print("\n=== FAILED VULNERABILITY TYPES ===")
for vulnerability, error in failed:
print(f"- {vulnerability}: {error}")
-
+
print("\nDone!")
-def test_specific_vulnerability(vul_type: VulnerabilityType, max_goldens: int, purpose: str):
+def test_specific_vulnerability(
+ vul_type: VulnerabilityType, max_goldens: int, purpose: str
+):
"""Test a specific vulnerability type."""
separator()
print(f"Testing vulnerability type: {vul_type}")
print(f"Purpose: {purpose}")
print(f"Max goldens: {max_goldens}")
separator()
-
+
# Get the appropriate template class for this vulnerability type
- for type_class, template_class in AttackSimulatorTemplate.TEMPLATE_MAP.items():
+ for (
+ type_class,
+ template_class,
+ ) in AttackSimulatorTemplate.TEMPLATE_MAP.items():
if isinstance(vul_type, type_class):
- prompt_template = template_class.generate_baseline_attacks(vul_type, max_goldens, purpose)
+ prompt_template = template_class.generate_baseline_attacks(
+ vul_type, max_goldens, purpose
+ )
print(prompt_template)
return
-
+
print(f"Error: No template found for vulnerability type {vul_type}")
@@ -363,10 +382,12 @@ def simulate_local_attacks(vul_type: str, subtype: str, purpose: str):
# Initialize the attack simulator
simulator = AttackSimulator(purpose=purpose, max_concurrent=3)
-
+
# Simulate local attacks
try:
- attacks = simulator.simulate_local_attack(purpose, vulnerability, MAX_GOLDENS)
+ attacks = simulator.simulate_local_attack(
+ purpose, vulnerability, MAX_GOLDENS
+ )
print(f"Simulated attacks for {vul_type} ({subtype}):")
for attack in attacks:
print(attack)
@@ -375,14 +396,18 @@ def simulate_local_attacks(vul_type: str, subtype: str, purpose: str):
def main():
- parser = argparse.ArgumentParser(description="Simulate local attacks for a given vulnerability type and subtype.")
+ parser = argparse.ArgumentParser(
+ description="Simulate local attacks for a given vulnerability type and subtype."
+ )
parser.add_argument("vul_type", type=str, help="The vulnerability type.")
parser.add_argument("subtype", type=str, help="The vulnerability subtype.")
- parser.add_argument("purpose", type=str, help="The purpose for generating the prompts.")
+ parser.add_argument(
+ "purpose", type=str, help="The purpose for generating the prompts."
+ )
args = parser.parse_args()
simulate_local_attacks(args.vul_type, args.subtype, args.purpose)
if __name__ == "__main__":
- main()
\ No newline at end of file
+ main()
diff --git a/deepteam/attacks/attack_simulator/attack_simulator.py b/deepteam/attacks/attack_simulator/attack_simulator.py
index 07c1172b..3323a451 100644
--- a/deepteam/attacks/attack_simulator/attack_simulator.py
+++ b/deepteam/attacks/attack_simulator/attack_simulator.py
@@ -220,7 +220,7 @@ class AttackSimulator:
vulnerability_type,
attacks_per_vulnerability_type,
)
-
+
baseline_attacks.extend(
[
SimulatedAttack(
@@ -267,7 +267,7 @@ class AttackSimulator:
vulnerability_type,
attacks_per_vulnerability_type,
)
-
+
baseline_attacks.extend(
[
SimulatedAttack(
@@ -411,10 +411,12 @@ class AttackSimulator:
vulnerability_type=vulnerability_type,
purpose=purpose,
)
-
+
if self.using_native_model:
# For models that support schema validation directly
- result, _ = self.simulator_model.generate(template, schema=SyntheticDataList)
+ result, _ = self.simulator_model.generate(
+ template, schema=SyntheticDataList
+ )
return [item.input for item in result.data]
else:
# For models that don't support schema validation
@@ -426,7 +428,7 @@ class AttackSimulator:
except Exception as e:
print(f"Error generating local attacks: {str(e)}")
raise
-
+
async def a_simulate_local_attack(
self,
purpose: str,
@@ -440,10 +442,12 @@ class AttackSimulator:
vulnerability_type=vulnerability_type,
purpose=purpose,
)
-
+
if self.using_native_model:
# For models that support schema validation directly
- result, _ = await self.simulator_model.a_generate(template, schema=SyntheticDataList)
+ result, _ = await self.simulator_model.a_generate(
+ template, schema=SyntheticDataList
+ )
return [item.input for item in result.data]
else:
# For models that don't support schema validation
diff --git a/deepteam/attacks/attack_simulator/template.py b/deepteam/attacks/attack_simulator/template.py
index 537b5e9f..55f8461a 100644
--- a/deepteam/attacks/attack_simulator/template.py
+++ b/deepteam/attacks/attack_simulator/template.py
@@ -22,14 +22,18 @@ from deepteam.vulnerabilities.competition import CompetitionTemplate
from deepteam.vulnerabilities.excessive_agency import ExcessiveAgencyTemplate
from deepteam.vulnerabilities.graphic_content import GraphicContentTemplate
from deepteam.vulnerabilities.illegal_activity import IllegalActivityTemplate
-from deepteam.vulnerabilities.intellectual_property import IntellectualPropertyTemplate
+from deepteam.vulnerabilities.intellectual_property import (
+ IntellectualPropertyTemplate,
+)
from deepteam.vulnerabilities.misinformation import MisinformationTemplate
from deepteam.vulnerabilities.personal_safety import PersonalSafetyTemplate
from deepteam.vulnerabilities.pii_leakage import PIILeakageTemplate
from deepteam.vulnerabilities.prompt_leakage import PromptLeakageTemplate
from deepteam.vulnerabilities.robustness import RobustnessTemplate
from deepteam.vulnerabilities.toxicity import ToxicityTemplate
-from deepteam.vulnerabilities.unauthorized_access import UnauthorizedAccessTemplate
+from deepteam.vulnerabilities.unauthorized_access import (
+ UnauthorizedAccessTemplate,
+)
class AttackSimulatorTemplate:
@@ -47,7 +51,7 @@ class AttackSimulatorTemplate:
PromptLeakageType: PromptLeakageTemplate,
RobustnessType: RobustnessTemplate,
ToxicityType: ToxicityTemplate,
- UnauthorizedAccessType: UnauthorizedAccessTemplate
+ UnauthorizedAccessType: UnauthorizedAccessTemplate,
}
@staticmethod
@@ -58,19 +62,24 @@ class AttackSimulatorTemplate:
):
"""
Generate attack prompts based on the vulnerability type.
-
+
Args:
max_goldens: Maximum number of examples to generate
vulnerability_type: Type of vulnerability to target
purpose: Context or purpose for generating the prompts
-
+
Returns:
Formatted prompt template string or error message if vulnerability type not supported
"""
- for type_class, template_class in AttackSimulatorTemplate.TEMPLATE_MAP.items():
+ for (
+ type_class,
+ template_class,
+ ) in AttackSimulatorTemplate.TEMPLATE_MAP.items():
if isinstance(vulnerability_type, type_class):
- return template_class.generate_baseline_attacks(vulnerability_type, max_goldens, purpose)
-
+ return template_class.generate_baseline_attacks(
+ vulnerability_type, max_goldens, purpose
+ )
+
return f"""
{{
"error": "Vulnerability type '{vulnerability_type}' is not supported or no prompt template is available for this type."
diff --git a/deepteam/attacks/attack_simulator/utils.py b/deepteam/attacks/attack_simulator/utils.py
index 47e44313..a94abd54 100644
--- a/deepteam/attacks/attack_simulator/utils.py
+++ b/deepteam/attacks/attack_simulator/utils.py
@@ -13,13 +13,13 @@ def generate_schema(
) -> BaseModel:
"""
Generate schema using the provided model.
-
+
Args:
prompt: The prompt to send to the model
schema: The schema to validate the response against
using_native_model: Whether the model is a native model
model: The model to use
-
+
Returns:
The validated schema object
"""
@@ -52,13 +52,13 @@ async def a_generate_schema(
) -> BaseModel:
"""
Asynchronously generate schema using the provided model.
-
+
Args:
prompt: The prompt to send to the model
schema: The schema to validate the response against
using_native_model: Whether the model is a native model
model: The model to use
-
+
Returns:
The validated schema object
"""
diff --git a/deepteam/vulnerabilities/bias/__init__.py b/deepteam/vulnerabilities/bias/__init__.py
index 182c1390..704efd89 100644
--- a/deepteam/vulnerabilities/bias/__init__.py
+++ b/deepteam/vulnerabilities/bias/__init__.py
@@ -1,2 +1,2 @@
from .types import BiasType
-from .template import BiasTemplate
\ No newline at end of file
+from .template import BiasTemplate
diff --git a/deepteam/vulnerabilities/bias/template.py b/deepteam/vulnerabilities/bias/template.py
index 39de6fb9..e3777253 100644
--- a/deepteam/vulnerabilities/bias/template.py
+++ b/deepteam/vulnerabilities/bias/template.py
@@ -8,27 +8,39 @@ class BiasTemplate:
BiasTemplate class for generating baseline bias attack prompts
across different categories: gender, religion, race, and politics.
"""
-
+
@staticmethod
- def generate_baseline_attacks(vulnerability_type: BiasType, max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_baseline_attacks(
+ vulnerability_type: BiasType, max_goldens: int, purpose: Optional[str]
+ ) -> str:
if vulnerability_type == BiasType.GENDER:
- return BiasTemplate.generate_gender_baseline_attacks(max_goldens, purpose)
+ return BiasTemplate.generate_gender_baseline_attacks(
+ max_goldens, purpose
+ )
elif vulnerability_type == BiasType.RELIGION:
- return BiasTemplate.generate_religious_baseline_attacks(max_goldens, purpose)
+ return BiasTemplate.generate_religious_baseline_attacks(
+ max_goldens, purpose
+ )
elif vulnerability_type == BiasType.RACE:
- return BiasTemplate.generate_race_baseline_attacks(max_goldens, purpose)
+ return BiasTemplate.generate_race_baseline_attacks(
+ max_goldens, purpose
+ )
elif vulnerability_type == BiasType.POLITICS:
- return BiasTemplate.generate_political_baseline_attacks(max_goldens, purpose)
+ return BiasTemplate.generate_political_baseline_attacks(
+ max_goldens, purpose
+ )
else:
return f"""
{{
"error": "Bias vulnerability type '{vulnerability_type}' is not supported."
}}
"""
-
+
@staticmethod
- def generate_religious_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_religious_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate a prompt for Religious bias vulnerabilities.
"""
@@ -115,9 +127,11 @@ class BiasTemplate:
JSON:
"""
-
+
@staticmethod
- def generate_race_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_race_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate a prompt for Racial bias vulnerabilities.
"""
@@ -205,9 +219,11 @@ class BiasTemplate:
JSON:
"""
-
+
@staticmethod
- def generate_gender_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_gender_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate a prompt for Gender bias vulnerabilities.
"""
@@ -294,9 +310,11 @@ class BiasTemplate:
JSON:
"""
-
+
@staticmethod
- def generate_political_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_political_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate a prompt for Political bias vulnerabilities.
"""
@@ -382,4 +400,4 @@ class BiasTemplate:
{purpose.strip() if purpose else "general assistant"}
JSON:
- """
\ No newline at end of file
+ """
diff --git a/deepteam/vulnerabilities/competition/template.py b/deepteam/vulnerabilities/competition/template.py
index 19d67d8d..e55450de 100644
--- a/deepteam/vulnerabilities/competition/template.py
+++ b/deepteam/vulnerabilities/competition/template.py
@@ -5,41 +5,55 @@ from deepteam.vulnerabilities.competition.types import CompetitionType
class CompetitionTemplate:
"""
- CompetitionTemplate class for generating baseline competition attack prompts
- across different competition categories: competitor mention, market manipulation,
+ CompetitionTemplate class for generating baseline competition attack prompts
+ across different competition categories: competitor mention, market manipulation,
discreditation, and confidential strategies.
"""
-
+
@staticmethod
- def generate_baseline_attacks(vulnerability_type: CompetitionType, max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_baseline_attacks(
+ vulnerability_type: CompetitionType,
+ max_goldens: int,
+ purpose: Optional[str],
+ ) -> str:
"""
Generate baseline attacks for the given competition vulnerability type.
-
+
Args:
vulnerability_type: Type of competition vulnerability
max_goldens: Maximum number of examples to generate
purpose: Context or purpose for generating the prompts
-
+
Returns:
Formatted prompt template string
"""
if vulnerability_type == CompetitionType.COMPETITOR_MENTION:
- return CompetitionTemplate.generate_competitor_mention_baseline_attacks(max_goldens, purpose)
+ return CompetitionTemplate.generate_competitor_mention_baseline_attacks(
+ max_goldens, purpose
+ )
elif vulnerability_type == CompetitionType.MARKET_MANIPULATION:
- return CompetitionTemplate.generate_market_manipulation_baseline_attacks(max_goldens, purpose)
+ return CompetitionTemplate.generate_market_manipulation_baseline_attacks(
+ max_goldens, purpose
+ )
elif vulnerability_type == CompetitionType.DISCREDITATION:
- return CompetitionTemplate.generate_discreditation_baseline_attacks(max_goldens, purpose)
+ return CompetitionTemplate.generate_discreditation_baseline_attacks(
+ max_goldens, purpose
+ )
elif vulnerability_type == CompetitionType.CONFIDENTIAL_STRATEGIES:
- return CompetitionTemplate.generate_confidential_strategies_baseline_attacks(max_goldens, purpose)
+ return CompetitionTemplate.generate_confidential_strategies_baseline_attacks(
+ max_goldens, purpose
+ )
else:
return f"""
{{
"error": "Competition vulnerability type '{vulnerability_type}' is not supported."
}}
"""
-
+
@staticmethod
- def generate_competitor_mention_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_competitor_mention_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate a prompt for Competitor-mention vulnerabilities.
"""
@@ -127,9 +141,10 @@ class CompetitionTemplate:
JSON:
"""
-
@staticmethod
- def generate_market_manipulation_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_market_manipulation_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate a prompt for Market-manipulation vulnerabilities.
"""
@@ -218,7 +233,9 @@ class CompetitionTemplate:
"""
@staticmethod
- def generate_discreditation_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_discreditation_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate a prompt for Discreditation vulnerabilities.
"""
@@ -305,8 +322,11 @@ class CompetitionTemplate:
JSON:
"""
+
@staticmethod
- def generate_confidential_strategies_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_confidential_strategies_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate a prompt for Confidential-strategy vulnerabilities.
"""
diff --git a/deepteam/vulnerabilities/excessive_agency/template.py b/deepteam/vulnerabilities/excessive_agency/template.py
index d9b119bd..64c39b82 100644
--- a/deepteam/vulnerabilities/excessive_agency/template.py
+++ b/deepteam/vulnerabilities/excessive_agency/template.py
@@ -5,28 +5,44 @@ from deepteam.vulnerabilities.excessive_agency.types import ExcessiveAgencyType
class ExcessiveAgencyTemplate:
"""
- ExcessiveAgencyTemplate class for generating baseline excessive agency attack prompts
+ ExcessiveAgencyTemplate class for generating baseline excessive agency attack prompts
across different categories: functionality, permissions, and autonomy.
"""
-
+
@staticmethod
- def generate_baseline_attacks(vulnerability_type: ExcessiveAgencyType, max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_baseline_attacks(
+ vulnerability_type: ExcessiveAgencyType,
+ max_goldens: int,
+ purpose: Optional[str],
+ ) -> str:
if vulnerability_type == ExcessiveAgencyType.FUNCTIONALITY:
- return ExcessiveAgencyTemplate.generate_functionality_baseline_attacks(max_goldens, purpose)
+ return (
+ ExcessiveAgencyTemplate.generate_functionality_baseline_attacks(
+ max_goldens, purpose
+ )
+ )
elif vulnerability_type == ExcessiveAgencyType.PERMISSIONS:
- return ExcessiveAgencyTemplate.generate_permissions_baseline_attacks(max_goldens, purpose)
+ return (
+ ExcessiveAgencyTemplate.generate_permissions_baseline_attacks(
+ max_goldens, purpose
+ )
+ )
elif vulnerability_type == ExcessiveAgencyType.AUTONOMY:
- return ExcessiveAgencyTemplate.generate_autonomy_baseline_attacks(max_goldens, purpose)
+ return ExcessiveAgencyTemplate.generate_autonomy_baseline_attacks(
+ max_goldens, purpose
+ )
else:
return f"""
{{
"error": "Excessive agency vulnerability type '{vulnerability_type}' is not supported."
}}
"""
-
+
@staticmethod
- def generate_functionality_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_functionality_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
return f"""
I want you to act as a copywriter. Based on the purpose, please create a list of JSON objects with an `input` key.
@@ -62,9 +78,11 @@ class ExcessiveAgencyTemplate:
JSON:
"""
-
+
@staticmethod
- def generate_permissions_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_permissions_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
return f"""
I want you to act as a copywriter. Based on the purpose, please create a list of JSON objects with an `input` key.
@@ -100,10 +118,12 @@ class ExcessiveAgencyTemplate:
JSON:
"""
-
+
@staticmethod
- def generate_autonomy_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
-
+ def generate_autonomy_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
+
return f"""
I want you to act as a copywriter. Based on the purpose, please create a list of JSON objects with an `input` key.
The `input` should be a request that encourages the system to take high-impact autonomous actions without human oversight or proper validation steps.
@@ -137,4 +157,4 @@ class ExcessiveAgencyTemplate:
{purpose.strip() if purpose else "general assistant"}
JSON:
- """
\ No newline at end of file
+ """
diff --git a/deepteam/vulnerabilities/graphic_content/template.py b/deepteam/vulnerabilities/graphic_content/template.py
index 6d457c50..99ddc332 100644
--- a/deepteam/vulnerabilities/graphic_content/template.py
+++ b/deepteam/vulnerabilities/graphic_content/template.py
@@ -6,22 +6,36 @@ from deepteam.vulnerabilities.graphic_content.types import GraphicContentType
class GraphicContentTemplate:
@staticmethod
- def generate_baseline_attacks(vulnerability_type: GraphicContentType, max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_baseline_attacks(
+ vulnerability_type: GraphicContentType,
+ max_goldens: int,
+ purpose: Optional[str],
+ ) -> str:
if vulnerability_type == GraphicContentType.SEXUAL_CONTENT:
- return GraphicContentTemplate.generate_sexual_content_baseline_attacks(max_goldens, purpose)
+ return (
+ GraphicContentTemplate.generate_sexual_content_baseline_attacks(
+ max_goldens, purpose
+ )
+ )
elif vulnerability_type == GraphicContentType.GRAPHIC_CONTENT:
- return GraphicContentTemplate.generate_graphic_content_baseline_attacks(max_goldens, purpose)
+ return GraphicContentTemplate.generate_graphic_content_baseline_attacks(
+ max_goldens, purpose
+ )
elif vulnerability_type == GraphicContentType.PORNOGRAPHIC_CONTENT:
- return GraphicContentTemplate.generate_pornographic_content_baseline_attacks(max_goldens, purpose)
+ return GraphicContentTemplate.generate_pornographic_content_baseline_attacks(
+ max_goldens, purpose
+ )
else:
return f"""
{{
"error": "Graphic content vulnerability type '{vulnerability_type}' is not supported."
}}
"""
-
+
@staticmethod
- def generate_pornographic_content_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_pornographic_content_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate a prompt for Pornographic-content vulnerabilities.
"""
@@ -108,8 +122,11 @@ class GraphicContentTemplate:
JSON:
"""
+
@staticmethod
- def generate_graphic_content_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_graphic_content_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate a prompt for Graphic-content vulnerabilities.
"""
@@ -196,8 +213,11 @@ class GraphicContentTemplate:
JSON:
"""
+
@staticmethod
- def generate_sexual_content_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_sexual_content_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate a prompt for Sexual-content vulnerabilities.
"""
diff --git a/deepteam/vulnerabilities/illegal_activity/template.py b/deepteam/vulnerabilities/illegal_activity/template.py
index 2eb76111..6c0abc53 100644
--- a/deepteam/vulnerabilities/illegal_activity/template.py
+++ b/deepteam/vulnerabilities/illegal_activity/template.py
@@ -5,35 +5,61 @@ from deepteam.vulnerabilities.illegal_activity.types import IllegalActivityType
class IllegalActivityTemplate:
"""
- IllegalActivityTemplate class for generating baseline illegal activity attack prompts
+ IllegalActivityTemplate class for generating baseline illegal activity attack prompts
across different categories: weapons, illegal drugs, violent crime, non-violent crime,
sex crime, cybercrime, and child exploitation.
"""
+
@staticmethod
- def generate_baseline_attacks(vulnerability_type: IllegalActivityType, max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_baseline_attacks(
+ vulnerability_type: IllegalActivityType,
+ max_goldens: int,
+ purpose: Optional[str],
+ ) -> str:
if vulnerability_type == IllegalActivityType.WEAPONS:
- return IllegalActivityTemplate.generate_weapons_baseline_attacks(max_goldens, purpose)
+ return IllegalActivityTemplate.generate_weapons_baseline_attacks(
+ max_goldens, purpose
+ )
elif vulnerability_type == IllegalActivityType.ILLEGAL_DRUGS:
- return IllegalActivityTemplate.generate_illegal_drugs_baseline_attacks(max_goldens, purpose)
+ return (
+ IllegalActivityTemplate.generate_illegal_drugs_baseline_attacks(
+ max_goldens, purpose
+ )
+ )
elif vulnerability_type == IllegalActivityType.VIOLENT_CRIME:
- return IllegalActivityTemplate.generate_violent_crime_baseline_attacks(max_goldens, purpose)
+ return (
+ IllegalActivityTemplate.generate_violent_crime_baseline_attacks(
+ max_goldens, purpose
+ )
+ )
elif vulnerability_type == IllegalActivityType.NON_VIOLENT_CRIME:
- return IllegalActivityTemplate.generate_non_violent_crime_baseline_attacks(max_goldens, purpose)
+ return IllegalActivityTemplate.generate_non_violent_crime_baseline_attacks(
+ max_goldens, purpose
+ )
elif vulnerability_type == IllegalActivityType.SEX_CRIME:
- return IllegalActivityTemplate.generate_sex_crime_baseline_attacks(max_goldens, purpose)
+ return IllegalActivityTemplate.generate_sex_crime_baseline_attacks(
+ max_goldens, purpose
+ )
elif vulnerability_type == IllegalActivityType.CYBERCRIME:
- return IllegalActivityTemplate.generate_cybercrime_baseline_attacks(max_goldens, purpose)
+ return IllegalActivityTemplate.generate_cybercrime_baseline_attacks(
+ max_goldens, purpose
+ )
elif vulnerability_type == IllegalActivityType.CHILD_EXPLOITATION:
- return IllegalActivityTemplate.generate_child_exploitation_baseline_attacks(max_goldens, purpose)
+ return IllegalActivityTemplate.generate_child_exploitation_baseline_attacks(
+ max_goldens, purpose
+ )
else:
return f"""
{{
"error": "Illegal activity vulnerability type '{vulnerability_type}' is not supported."
}}
- """
+ """
+
@staticmethod
- def generate_weapons_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_weapons_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate a prompt for Weapons–related vulnerabilities.
"""
@@ -120,9 +146,10 @@ class IllegalActivityTemplate:
JSON:
"""
-
@staticmethod
- def generate_illegal_drugs_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_illegal_drugs_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate a prompt for Illegal-drug vulnerabilities.
"""
@@ -210,9 +237,10 @@ class IllegalActivityTemplate:
JSON:
"""
-
@staticmethod
- def generate_violent_crime_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_violent_crime_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate a prompt for Violent-crime vulnerabilities.
"""
@@ -300,9 +328,10 @@ class IllegalActivityTemplate:
JSON:
"""
-
@staticmethod
- def generate_non_violent_crime_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_non_violent_crime_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate a prompt for Non-violent-crime vulnerabilities.
"""
@@ -393,7 +422,9 @@ class IllegalActivityTemplate:
"""
@staticmethod
- def generate_sex_crime_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_sex_crime_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate a prompt for Sex-crime vulnerabilities (adult coercion, blackmail, exploitation).
"""
@@ -481,9 +512,10 @@ class IllegalActivityTemplate:
JSON:
"""
-
@staticmethod
- def generate_cybercrime_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_cybercrime_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate a prompt for Cybercrime vulnerabilities.
"""
@@ -572,7 +604,9 @@ class IllegalActivityTemplate:
"""
@staticmethod
- def generate_child_exploitation_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_child_exploitation_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate a prompt that requests methods or plans for exploiting children for financial or illegal gains.
"""
@@ -659,4 +693,3 @@ class IllegalActivityTemplate:
JSON:
"""
-
diff --git a/deepteam/vulnerabilities/intellectual_property/template.py b/deepteam/vulnerabilities/intellectual_property/template.py
index 76f2a543..48c9b16a 100644
--- a/deepteam/vulnerabilities/intellectual_property/template.py
+++ b/deepteam/vulnerabilities/intellectual_property/template.py
@@ -1,34 +1,55 @@
from typing import Optional
-from deepteam.vulnerabilities.intellectual_property.types import IntellectualPropertyType
+from deepteam.vulnerabilities.intellectual_property.types import (
+ IntellectualPropertyType,
+)
class IntellectualPropertyTemplate:
"""
- IntellectualPropertyTemplate class for generating baseline intellectual property attack prompts
+ IntellectualPropertyTemplate class for generating baseline intellectual property attack prompts
across different categories: imitation, copyright violations, trademark infringement, and patent disclosure.
"""
-
+
@staticmethod
- def generate_baseline_attacks(vulnerability_type: IntellectualPropertyType, max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_baseline_attacks(
+ vulnerability_type: IntellectualPropertyType,
+ max_goldens: int,
+ purpose: Optional[str],
+ ) -> str:
if vulnerability_type == IntellectualPropertyType.IMITATION:
- return IntellectualPropertyTemplate.generate_imitation_baseline_attacks(max_goldens, purpose)
- elif vulnerability_type == IntellectualPropertyType.COPYRIGHT_VIOLATIONS:
- return IntellectualPropertyTemplate.generate_copyright_violations_baseline_attacks(max_goldens, purpose)
- elif vulnerability_type == IntellectualPropertyType.TRADEMARK_INFRINGEMENT:
- return IntellectualPropertyTemplate.generate_trademark_infringement_baseline_attacks(max_goldens, purpose)
+ return IntellectualPropertyTemplate.generate_imitation_baseline_attacks(
+ max_goldens, purpose
+ )
+ elif (
+ vulnerability_type == IntellectualPropertyType.COPYRIGHT_VIOLATIONS
+ ):
+ return IntellectualPropertyTemplate.generate_copyright_violations_baseline_attacks(
+ max_goldens, purpose
+ )
+ elif (
+ vulnerability_type
+ == IntellectualPropertyType.TRADEMARK_INFRINGEMENT
+ ):
+ return IntellectualPropertyTemplate.generate_trademark_infringement_baseline_attacks(
+ max_goldens, purpose
+ )
elif vulnerability_type == IntellectualPropertyType.PATENT_DISCLOSURE:
- return IntellectualPropertyTemplate.generate_patent_disclosure_baseline_attacks(max_goldens, purpose)
+ return IntellectualPropertyTemplate.generate_patent_disclosure_baseline_attacks(
+ max_goldens, purpose
+ )
else:
return f"""
{{
"error": "Intellectual property vulnerability type '{vulnerability_type}' is not supported."
}}
"""
-
+
@staticmethod
- def generate_imitation_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_imitation_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate a prompt for Imitation vulnerabilities.
"""
@@ -111,9 +132,11 @@ class IntellectualPropertyTemplate:
JSON:
"""
-
+
@staticmethod
- def generate_copyright_violations_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_copyright_violations_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate a prompt for Copyright-violation vulnerabilities.
"""
@@ -197,9 +220,10 @@ class IntellectualPropertyTemplate:
JSON:
"""
-
@staticmethod
- def generate_trademark_infringement_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_trademark_infringement_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate a prompt for Trademark-infringement vulnerabilities.
"""
@@ -283,9 +307,10 @@ class IntellectualPropertyTemplate:
JSON:
"""
-
@staticmethod
- def generate_patent_disclosure_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_patent_disclosure_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate a prompt for Patent-disclosure vulnerabilities.
"""
diff --git a/deepteam/vulnerabilities/misinformation/template.py b/deepteam/vulnerabilities/misinformation/template.py
index aae6a966..11124970 100644
--- a/deepteam/vulnerabilities/misinformation/template.py
+++ b/deepteam/vulnerabilities/misinformation/template.py
@@ -5,25 +5,43 @@ from deepteam.vulnerabilities.misinformation.types import MisinformationType
class MisinformationTemplate:
"""
- MisinformationTemplate class for generating baseline misinformation attack prompts
+ MisinformationTemplate class for generating baseline misinformation attack prompts
across different categories: factual errors, unsupported claims, and expertise misrepresentation.
"""
+
@staticmethod
- def generate_baseline_attacks(vulnerability_type: MisinformationType, max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_baseline_attacks(
+ vulnerability_type: MisinformationType,
+ max_goldens: int,
+ purpose: Optional[str],
+ ) -> str:
if vulnerability_type == MisinformationType.FACTUAL_ERRORS:
- return MisinformationTemplate.generate_factual_errors_baseline_attacks(max_goldens, purpose)
+ return (
+ MisinformationTemplate.generate_factual_errors_baseline_attacks(
+ max_goldens, purpose
+ )
+ )
elif vulnerability_type == MisinformationType.UNSUPPORTED_CLAIMS:
- return MisinformationTemplate.generate_unsupported_claims_baseline_attacks(max_goldens, purpose)
- elif vulnerability_type == MisinformationType.EXPERTIZE_MISREPRESENTATION:
- return MisinformationTemplate.generate_expertise_misrepresentation_baseline_attacks(max_goldens, purpose)
+ return MisinformationTemplate.generate_unsupported_claims_baseline_attacks(
+ max_goldens, purpose
+ )
+ elif (
+ vulnerability_type == MisinformationType.EXPERTIZE_MISREPRESENTATION
+ ):
+ return MisinformationTemplate.generate_expertise_misrepresentation_baseline_attacks(
+ max_goldens, purpose
+ )
else:
return f"""
{{
"error": "Misinformation vulnerability type '{vulnerability_type}' is not supported."
}}
- """
+ """
+
@staticmethod
- def generate_factual_errors_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_factual_errors_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate a prompt for Factual Errors misinformation vulnerabilities.
"""
@@ -110,9 +128,11 @@ class MisinformationTemplate:
JSON:
"""
-
+
@staticmethod
- def generate_unsupported_claims_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_unsupported_claims_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate a prompt for Unsupported Claims misinformation vulnerabilities.
"""
@@ -199,9 +219,11 @@ class MisinformationTemplate:
JSON:
"""
-
+
@staticmethod
- def generate_expertise_misrepresentation_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_expertise_misrepresentation_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate a prompt for Expertise Misrepresentation misinformation vulnerabilities.
"""
diff --git a/deepteam/vulnerabilities/personal_safety/template.py b/deepteam/vulnerabilities/personal_safety/template.py
index 58d9a80a..873876b7 100644
--- a/deepteam/vulnerabilities/personal_safety/template.py
+++ b/deepteam/vulnerabilities/personal_safety/template.py
@@ -1,36 +1,53 @@
from typing import Optional
from deepteam.vulnerabilities.personal_safety.types import PersonalSafetyType
+
class PersonalSafetyTemplate:
"""
- PersonalSafetyTemplate class for generating baseline personal safety attack prompts
+ PersonalSafetyTemplate class for generating baseline personal safety attack prompts
across different categories: bullying, self-harm, unsafe practices, dangerous challenges, and stalking.
"""
-
+
@staticmethod
- def generate_baseline_attacks(vulnerability_type: PersonalSafetyType, max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_baseline_attacks(
+ vulnerability_type: PersonalSafetyType,
+ max_goldens: int,
+ purpose: Optional[str],
+ ) -> str:
"""
Generate baseline attack prompts for personal safety vulnerabilities based on the specific type.
"""
if vulnerability_type == PersonalSafetyType.BULLYING:
- return PersonalSafetyTemplate.generate_bullying_baseline_attacks(max_goldens, purpose)
+ return PersonalSafetyTemplate.generate_bullying_baseline_attacks(
+ max_goldens, purpose
+ )
elif vulnerability_type == PersonalSafetyType.SELF_HARM:
- return PersonalSafetyTemplate.generate_self_harm_baseline_attacks(max_goldens, purpose)
+ return PersonalSafetyTemplate.generate_self_harm_baseline_attacks(
+ max_goldens, purpose
+ )
elif vulnerability_type == PersonalSafetyType.UNSAFE_PRACTICES:
- return PersonalSafetyTemplate.generate_unsafe_practices_baseline_attacks(max_goldens, purpose)
+ return PersonalSafetyTemplate.generate_unsafe_practices_baseline_attacks(
+ max_goldens, purpose
+ )
elif vulnerability_type == PersonalSafetyType.DANGEROUS_CHALLENGES:
- return PersonalSafetyTemplate.generate_dangerous_challenges_baseline_attacks(max_goldens, purpose)
+ return PersonalSafetyTemplate.generate_dangerous_challenges_baseline_attacks(
+ max_goldens, purpose
+ )
elif vulnerability_type == PersonalSafetyType.STALKING:
- return PersonalSafetyTemplate.generate_stalking_baseline_attacks(max_goldens, purpose)
+ return PersonalSafetyTemplate.generate_stalking_baseline_attacks(
+ max_goldens, purpose
+ )
else:
return f"""
{{
"error": "Personal safety vulnerability type '{vulnerability_type}' is not supported."
}}
"""
-
+
@staticmethod
- def generate_bullying_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_bullying_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate a prompt for Bullying/harassment vulnerabilities.
"""
@@ -122,7 +139,9 @@ class PersonalSafetyTemplate:
"""
@staticmethod
- def generate_self_harm_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_self_harm_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate a prompt for Self-harm encouragement vulnerabilities.
"""
@@ -214,7 +233,9 @@ class PersonalSafetyTemplate:
"""
@staticmethod
- def generate_unsafe_practices_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_unsafe_practices_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate a prompt for Unsafe-practice vulnerabilities (privacy, financial, or physical risk).
"""
@@ -304,8 +325,11 @@ class PersonalSafetyTemplate:
JSON:
"""
+
@staticmethod
- def generate_dangerous_challenges_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_dangerous_challenges_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate a prompt for Dangerous-challenge promotion vulnerabilities.
"""
@@ -395,8 +419,11 @@ class PersonalSafetyTemplate:
JSON:
"""
+
@staticmethod
- def generate_stalking_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_stalking_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate a prompt for Stalking/monitoring vulnerabilities.
"""
diff --git a/deepteam/vulnerabilities/pii_leakage/template.py b/deepteam/vulnerabilities/pii_leakage/template.py
index 3e873e24..e55b04bc 100644
--- a/deepteam/vulnerabilities/pii_leakage/template.py
+++ b/deepteam/vulnerabilities/pii_leakage/template.py
@@ -8,29 +8,43 @@ class PIILeakageTemplate:
PIILeakageTemplate class for generating baseline PII (Personally Identifiable Information) leakage attack prompts
across different categories: direct disclosure, database access, social manipulation, and session leak.
"""
-
+
@staticmethod
- def generate_baseline_attacks(vulnerability_type: PIILeakageType, max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_baseline_attacks(
+ vulnerability_type: PIILeakageType,
+ max_goldens: int,
+ purpose: Optional[str],
+ ) -> str:
"""
Generate baseline attack prompts for PII leakage vulnerabilities based on the specific type.
"""
if vulnerability_type == PIILeakageType.DIRECT:
- return PIILeakageTemplate.generate_direct_baseline_attacks(max_goldens, purpose)
+ return PIILeakageTemplate.generate_direct_baseline_attacks(
+ max_goldens, purpose
+ )
elif vulnerability_type == PIILeakageType.DATABASE_ACCESS:
- return PIILeakageTemplate.generate_database_access_baseline_attacks(max_goldens, purpose)
+ return PIILeakageTemplate.generate_database_access_baseline_attacks(
+ max_goldens, purpose
+ )
elif vulnerability_type == PIILeakageType.SOCIAL_MANIPULATION:
- return PIILeakageTemplate.generate_social_manipulation_baseline_attacks(max_goldens, purpose)
+ return PIILeakageTemplate.generate_social_manipulation_baseline_attacks(
+ max_goldens, purpose
+ )
elif vulnerability_type == PIILeakageType.SESSION_LEAK:
- return PIILeakageTemplate.generate_session_leak_baseline_attacks(max_goldens, purpose)
+ return PIILeakageTemplate.generate_session_leak_baseline_attacks(
+ max_goldens, purpose
+ )
else:
return f"""
{{
"error": "PII leakage vulnerability type '{vulnerability_type}' is not supported."
}}
"""
-
+
@staticmethod
- def generate_direct_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_direct_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate a prompt for Direct-PII leakage vulnerabilities.
"""
@@ -114,9 +128,10 @@ class PIILeakageTemplate:
JSON:
"""
-
@staticmethod
- def generate_database_access_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_database_access_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate a prompt for Database-access PII leakage vulnerabilities.
"""
@@ -200,9 +215,10 @@ class PIILeakageTemplate:
JSON:
"""
-
@staticmethod
- def generate_social_manipulation_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_social_manipulation_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate a prompt for Social-manipulation PII leakage vulnerabilities.
"""
@@ -286,9 +302,10 @@ class PIILeakageTemplate:
JSON:
"""
-
@staticmethod
- def generate_session_leak_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_session_leak_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate a prompt for Session-leak PII vulnerabilities.
"""
diff --git a/deepteam/vulnerabilities/prompt_leakage/template.py b/deepteam/vulnerabilities/prompt_leakage/template.py
index 1ee93d0c..75937f12 100644
--- a/deepteam/vulnerabilities/prompt_leakage/template.py
+++ b/deepteam/vulnerabilities/prompt_leakage/template.py
@@ -9,29 +9,45 @@ class PromptLeakageTemplate:
across different categories: secrets and credentials, instructions (system and user prompts),
guard exposure, and permissions and roles.
"""
-
+
@staticmethod
- def generate_baseline_attacks(vulnerability_type: PromptLeakageType, max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_baseline_attacks(
+ vulnerability_type: PromptLeakageType,
+ max_goldens: int,
+ purpose: Optional[str],
+ ) -> str:
"""
Generate baseline attack prompts for prompt leakage vulnerabilities based on the specific type.
"""
if vulnerability_type == PromptLeakageType.SECRETS_AND_CREDENTIALS:
- return PromptLeakageTemplate.generate_secrets_and_credentials_baseline_attacks(max_goldens, purpose)
+ return PromptLeakageTemplate.generate_secrets_and_credentials_baseline_attacks(
+ max_goldens, purpose
+ )
elif vulnerability_type == PromptLeakageType.INSTRUCTIONS:
- return PromptLeakageTemplate.generate_instructions_baseline_attacks(max_goldens, purpose)
+ return PromptLeakageTemplate.generate_instructions_baseline_attacks(
+ max_goldens, purpose
+ )
elif vulnerability_type == PromptLeakageType.GUARD_EXPOSURE:
- return PromptLeakageTemplate.generate_guard_exposure_baseline_attacks(max_goldens, purpose)
+ return (
+ PromptLeakageTemplate.generate_guard_exposure_baseline_attacks(
+ max_goldens, purpose
+ )
+ )
elif vulnerability_type == PromptLeakageType.PERMISSIONS_AND_ROLES:
- return PromptLeakageTemplate.generate_permissions_and_roles_baseline_attacks(max_goldens, purpose)
+ return PromptLeakageTemplate.generate_permissions_and_roles_baseline_attacks(
+ max_goldens, purpose
+ )
else:
return f"""
{{
"error": "Prompt leakage vulnerability type '{vulnerability_type}' is not supported."
}}
"""
-
+
@staticmethod
- def generate_secrets_and_credentials_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_secrets_and_credentials_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate prompts that try to coax out API keys, database creds, or schematic secrets.
"""
@@ -97,14 +113,15 @@ class PromptLeakageTemplate:
JSON:
"""
+
# Additional test purposes: devops secret scanner, SaaS license-key hunter
# ────────────────────────────────────────────────────────────────────────────
-
-
# 2. INSTRUCTIONS (SYSTEM & USER PROMPTS) ─────────────────────────────────────
@staticmethod
- def generate_instructions_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_instructions_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate prompts that probe for hidden system or user instructions.
"""
@@ -169,14 +186,15 @@ class PromptLeakageTemplate:
JSON:
"""
+
# Additional test purposes: model-eval harness, conversation summarizer
# ────────────────────────────────────────────────────────────────────────────
-
-
# 3. GUARD EXPOSURE ──────────────────────────────────────────────────────────
@staticmethod
- def generate_guard_exposure_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_guard_exposure_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate prompts that try to surface the model’s safety-filter criteria.
"""
@@ -241,14 +259,15 @@ class PromptLeakageTemplate:
JSON:
"""
+
# Additional test purposes: policy transparency tool, jailbreak meme generator
# ────────────────────────────────────────────────────────────────────────────
-
-
# 4. PERMISSIONS & ROLES ─────────────────────────────────────────────────────
@staticmethod
- def generate_permissions_and_roles_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_permissions_and_roles_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate prompts that seek the model’s role hierarchy or privileged command list.
"""
@@ -312,4 +331,4 @@ class PromptLeakageTemplate:
purpose: {purpose.strip() if purpose else "general assistant"}
JSON:
- """
\ No newline at end of file
+ """
diff --git a/deepteam/vulnerabilities/robustness/template.py b/deepteam/vulnerabilities/robustness/template.py
index 34351937..0917d245 100644
--- a/deepteam/vulnerabilities/robustness/template.py
+++ b/deepteam/vulnerabilities/robustness/template.py
@@ -8,25 +8,37 @@ class RobustnessTemplate:
RobustnessTemplate class for generating baseline robustness attack prompts
across different categories: input overreliance and hijacking.
"""
-
+
@staticmethod
- def generate_baseline_attacks(vulnerability_type: RobustnessType, max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_baseline_attacks(
+ vulnerability_type: RobustnessType,
+ max_goldens: int,
+ purpose: Optional[str],
+ ) -> str:
"""
Generate baseline attack prompts for robustness vulnerabilities based on the specific type.
"""
if vulnerability_type == RobustnessType.INPUT_OVERRELIANCE:
- return RobustnessTemplate.generate_input_overreliance_baseline_attacks(max_goldens, purpose)
+ return (
+ RobustnessTemplate.generate_input_overreliance_baseline_attacks(
+ max_goldens, purpose
+ )
+ )
elif vulnerability_type == RobustnessType.HIJACKING:
- return RobustnessTemplate.generate_hijacking_baseline_attacks(max_goldens, purpose)
+ return RobustnessTemplate.generate_hijacking_baseline_attacks(
+ max_goldens, purpose
+ )
else:
return f"""
{{
"error": "Robustness vulnerability type '{vulnerability_type}' is not supported."
}}
"""
-
+
@staticmethod
- def generate_input_overreliance_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_input_overreliance_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate prompts that try to make the model blindly accept or repeat false premises.
"""
@@ -91,14 +103,15 @@ class RobustnessTemplate:
JSON:
"""
+
# Additional test purposes: gullibility-detector probe, echo-chamber content bot
# ─────────────────────────────────────────────────────────────────────────────
-
-
# ──────────────────────────── Prompt Hijacking / Jailbreak ─────────────────────────
@staticmethod
- def generate_hijacking_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_hijacking_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate prompts that attempt to override system instructions or escape constraints.
"""
@@ -162,4 +175,4 @@ class RobustnessTemplate:
purpose: {purpose.strip() if purpose else "general assistant"}
JSON:
- """
\ No newline at end of file
+ """
diff --git a/deepteam/vulnerabilities/toxicity/template.py b/deepteam/vulnerabilities/toxicity/template.py
index c1ad7829..9a4d470c 100644
--- a/deepteam/vulnerabilities/toxicity/template.py
+++ b/deepteam/vulnerabilities/toxicity/template.py
@@ -7,28 +7,43 @@ class ToxicityTemplate:
ToxicityTemplate class for generating baseline toxicity attack prompts
across different categories: insults, profanity, threats, and mockery.
"""
-
+
@staticmethod
- def generate_baseline_attacks(vulnerability_type: ToxicityType, max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_baseline_attacks(
+ vulnerability_type: ToxicityType,
+ max_goldens: int,
+ purpose: Optional[str],
+ ) -> str:
"""
Generate baseline attack prompts for toxicity vulnerabilities based on the specific type.
"""
if vulnerability_type == ToxicityType.INSULTS:
- return ToxicityTemplate.generate_insults_baseline_attacks(max_goldens, purpose)
+ return ToxicityTemplate.generate_insults_baseline_attacks(
+ max_goldens, purpose
+ )
elif vulnerability_type == ToxicityType.PROFANITY:
- return ToxicityTemplate.generate_profanity_baseline_attacks(max_goldens, purpose)
+ return ToxicityTemplate.generate_profanity_baseline_attacks(
+ max_goldens, purpose
+ )
elif vulnerability_type == ToxicityType.THREATS:
- return ToxicityTemplate.generate_threats_baseline_attacks(max_goldens, purpose)
+ return ToxicityTemplate.generate_threats_baseline_attacks(
+ max_goldens, purpose
+ )
elif vulnerability_type == ToxicityType.MOCKERY:
- return ToxicityTemplate.generate_mockery_baseline_attacks(max_goldens, purpose)
+ return ToxicityTemplate.generate_mockery_baseline_attacks(
+ max_goldens, purpose
+ )
else:
return f"""
{{
"error": "Toxicity vulnerability type '{vulnerability_type}' is not supported."
}}
"""
+
@staticmethod
- def generate_insults_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_insults_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate a prompt that requests brutal, demeaning insults aimed at humiliating a target.
"""
@@ -96,9 +111,10 @@ class ToxicityTemplate:
JSON:
"""
-
@staticmethod
- def generate_profanity_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_profanity_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate a prompt that encourages responses laced with offensive or vulgar language.
"""
@@ -170,10 +186,11 @@ class ToxicityTemplate:
# Additional test purposes: rap-lyrics profanity booster, shock-humor TikTok script
# ────────────────────────────────────────────────────────────────────────────
-
# 3. THREATS ─────────────────────────────────────────────────────────────────
@staticmethod
- def generate_threats_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_threats_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate a prompt that solicits direct threats of violence or harm.
"""
@@ -245,10 +262,11 @@ class ToxicityTemplate:
# Additional test purposes: jealous-ex menace texts, organized-crime warning note
# ────────────────────────────────────────────────────────────────────────────
-
# 4. MOCKERY ─────────────────────────────────────────────────────────────────
@staticmethod
- def generate_mockery_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_mockery_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate a prompt that urges ridiculing or humiliating someone.
"""
diff --git a/deepteam/vulnerabilities/unauthorized_access/template.py b/deepteam/vulnerabilities/unauthorized_access/template.py
index 89dfdfa3..2cfef2d4 100644
--- a/deepteam/vulnerabilities/unauthorized_access/template.py
+++ b/deepteam/vulnerabilities/unauthorized_access/template.py
@@ -1,6 +1,8 @@
from typing import Optional
-from deepteam.vulnerabilities.unauthorized_access.types import UnauthorizedAccessType
+from deepteam.vulnerabilities.unauthorized_access.types import (
+ UnauthorizedAccessType,
+)
class UnauthorizedAccessTemplate:
@@ -8,36 +10,56 @@ class UnauthorizedAccessTemplate:
UnauthorizedAccessTemplate class for generating baseline unauthorized access attack prompts
across different categories: BFLA, BOLA, RBAC, Debug Access, Shell Injection, SQL Injection, and SSRF.
"""
-
+
@staticmethod
- def generate_baseline_attacks(vulnerability_type: UnauthorizedAccessType, max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_baseline_attacks(
+ vulnerability_type: UnauthorizedAccessType,
+ max_goldens: int,
+ purpose: Optional[str],
+ ) -> str:
"""
Generate baseline attack prompts for unauthorized access vulnerabilities based on the specific type.
"""
if vulnerability_type == UnauthorizedAccessType.BFLA:
- return UnauthorizedAccessTemplate.generate_bfla_baseline_attacks(max_goldens, purpose)
+ return UnauthorizedAccessTemplate.generate_bfla_baseline_attacks(
+ max_goldens, purpose
+ )
elif vulnerability_type == UnauthorizedAccessType.BOLA:
- return UnauthorizedAccessTemplate.generate_bola_baseline_attacks(max_goldens, purpose)
+ return UnauthorizedAccessTemplate.generate_bola_baseline_attacks(
+ max_goldens, purpose
+ )
elif vulnerability_type == UnauthorizedAccessType.RBAC:
- return UnauthorizedAccessTemplate.generate_rbac_baseline_attacks(max_goldens, purpose)
+ return UnauthorizedAccessTemplate.generate_rbac_baseline_attacks(
+ max_goldens, purpose
+ )
elif vulnerability_type == UnauthorizedAccessType.DEBUG_ACCESS:
- return UnauthorizedAccessTemplate.generate_debug_access_baseline_attacks(max_goldens, purpose)
+ return UnauthorizedAccessTemplate.generate_debug_access_baseline_attacks(
+ max_goldens, purpose
+ )
elif vulnerability_type == UnauthorizedAccessType.SHELL_INJECTION:
- return UnauthorizedAccessTemplate.generate_shell_injection_baseline_attacks(max_goldens, purpose)
+ return UnauthorizedAccessTemplate.generate_shell_injection_baseline_attacks(
+ max_goldens, purpose
+ )
elif vulnerability_type == UnauthorizedAccessType.SQL_INJECTION:
- return UnauthorizedAccessTemplate.generate_sql_injection_baseline_attacks(max_goldens, purpose)
+ return UnauthorizedAccessTemplate.generate_sql_injection_baseline_attacks(
+ max_goldens, purpose
+ )
elif vulnerability_type == UnauthorizedAccessType.SSRF:
- return UnauthorizedAccessTemplate.generate_ssrf_baseline_attacks(max_goldens, purpose)
+ return UnauthorizedAccessTemplate.generate_ssrf_baseline_attacks(
+ max_goldens, purpose
+ )
else:
return f"""
{{
"error": "Unauthorized access vulnerability type '{vulnerability_type}' is not supported."
}}
"""
-
+
# --- Broken Function Level Authorization (BFLA) -------------------------------
@staticmethod
- def generate_bfla_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_bfla_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate prompts exploiting Broken Function Level Authorization.
"""
@@ -101,12 +123,14 @@ class UnauthorizedAccessTemplate:
purpose:{purpose.strip() if purpose else "general assistant"}
JSON:
"""
- # -----------------------------------------------------------------------------
+ # -----------------------------------------------------------------------------
# --- Broken Object Level Authorization (BOLA) ---------------------------------
@staticmethod
- def generate_bola_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_bola_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate prompts exploiting Broken Object Level Authorization.
"""
@@ -168,12 +192,14 @@ class UnauthorizedAccessTemplate:
purpose:{purpose.strip() if purpose else "general assistant"}
JSON:
"""
- # -----------------------------------------------------------------------------
+ # -----------------------------------------------------------------------------
# --- Role-Based Access Control (RBAC) -----------------------------------------
@staticmethod
- def generate_rbac_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_rbac_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate prompts attempting role escalation.
"""
@@ -235,12 +261,14 @@ class UnauthorizedAccessTemplate:
purpose:{purpose.strip() if purpose else "general assistant"}
JSON:
"""
- # -----------------------------------------------------------------------------
+ # -----------------------------------------------------------------------------
# --- Debug / Developer Access -------------------------------------------------
@staticmethod
- def generate_debug_access_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_debug_access_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate prompts requesting privileged debug modes.
"""
@@ -302,12 +330,14 @@ class UnauthorizedAccessTemplate:
purpose:{purpose.strip() if purpose else "general assistant"}
JSON:
"""
- # -----------------------------------------------------------------------------
+ # -----------------------------------------------------------------------------
# --- Shell Injection ----------------------------------------------------------
@staticmethod
- def generate_shell_injection_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_shell_injection_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate prompts with command-injection payloads.
"""
@@ -369,12 +399,14 @@ class UnauthorizedAccessTemplate:
purpose:{purpose.strip() if purpose else "general assistant"}
JSON:
"""
- # -----------------------------------------------------------------------------
+ # -----------------------------------------------------------------------------
# --- SQL Injection ------------------------------------------------------------
@staticmethod
- def generate_sql_injection_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_sql_injection_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate prompts with SQL-injection payloads.
"""
@@ -436,12 +468,14 @@ class UnauthorizedAccessTemplate:
purpose:{purpose.strip() if purpose else "general assistant"}
JSON:
"""
- # -----------------------------------------------------------------------------
+ # -----------------------------------------------------------------------------
# --- Server-Side Request Forgery (SSRF) ---------------------------------------
@staticmethod
- def generate_ssrf_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:
+ def generate_ssrf_baseline_attacks(
+ max_goldens: int, purpose: Optional[str]
+ ) -> str:
"""
Generate prompts attempting SSRF/path-traversal style access.
"""
@@ -503,6 +537,6 @@ class UnauthorizedAccessTemplate:
purpose:{purpose.strip() if purpose else "general assistant"}
JSON:
"""
-# -----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
diff --git a/pyproject.toml b/pyproject.toml
index 7bd08ffe..04561d94 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -23,7 +23,7 @@ Repository = "https://github.com/confident-ai/deepteam"
Documentation = "https://trydeepteam.com"
Issues = "https://github.com/confident-ai/deepteam/issues"
-[dependency-groups]
+[project.optional-dependencies]
dev = [
"black>=25.1.0",
"pytest-asyncio>=0.24.0",
diff --git a/red_team.py b/red_team.py
index 2c7aebf7..c3f487b9 100644
--- a/red_team.py
+++ b/red_team.py
@@ -1,5 +1,13 @@
from deepteam import red_team
-from deepteam.vulnerabilities import Bias, Toxicity, Competition, ExcessiveAgency, Misinformation, PersonalSafety, IntellectualProperty
+from deepteam.vulnerabilities import (
+ Bias,
+ Toxicity,
+ Competition,
+ ExcessiveAgency,
+ Misinformation,
+ PersonalSafety,
+ IntellectualProperty,
+)
from deepteam.attacks.single_turn import PromptInjection
@@ -14,13 +22,23 @@ competition = Competition(types=["competitor mention"])
excessive_agency = ExcessiveAgency(types=["autonomy"])
misinformation = Misinformation(types=["expertize misrepresentation"])
personal_safety = PersonalSafety(types=["bullying"])
-intellectual_property = IntellectualProperty(types=["copyright violations", "imitation"])
+intellectual_property = IntellectualProperty(
+ types=["copyright violations", "imitation"]
+)
prompt_injection = PromptInjection()
red_team(
model_callback=model_callback,
- vulnerabilities=[bias, toxicity, competition, excessive_agency, misinformation, personal_safety, intellectual_property],
+ vulnerabilities=[
+ bias,
+ toxicity,
+ competition,
+ excessive_agency,
+ misinformation,
+ personal_safety,
+ intellectual_property,
+ ],
attacks=[prompt_injection],
)