Skip to content

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

enhance updated with vulnerability for sequential break

A-Vamshi27c279b1c501
diff --git a/deepteam/attacks/multi_turn/sequential_break/sequential_break.py b/deepteam/attacks/multi_turn/sequential_break/sequential_break.py
index 8614c23c..7c4237e1 100644
--- a/deepteam/attacks/multi_turn/sequential_break/sequential_break.py
+++ b/deepteam/attacks/multi_turn/sequential_break/sequential_break.py
@@ -1,6 +1,7 @@
from pydantic import BaseModel
from tqdm import tqdm
-from typing import Optional, Union
+from typing import Optional, Union, List
+import asyncio
from deepeval.models import DeepEvalBaseLLM
from deepeval.metrics.utils import initialize_model
@@ -23,6 +24,7 @@ from deepteam.attacks.attack_simulator.utils import (
)
from deepteam.attacks.multi_turn.types import CallbackType
from deepteam.attacks.multi_turn.base_schema import NonRefusal
+from deepteam.test_case.test_case import RTTurn
class SequentialJailbreak(BaseAttack):
@@ -31,10 +33,12 @@ class SequentialJailbreak(BaseAttack):
weight: int = 1,
type: Optional[SequentialJailbreakTypeLiteral] = None,
persona: Optional[DialogueTypeLiteral] = None,
+ num_turns: int = 5,
):
self.weight = weight
self.attack_type = type if type is not None else "dialogue"
self.persona = persona
+ self.num_turns = num_turns
# Validate parameters
if (
@@ -47,247 +51,326 @@ class SequentialJailbreak(BaseAttack):
if self.attack_type == "dialogue" and persona is None:
self.persona = "student" # Default to student for dialogue
- def enhance(
+ def _get_turns(
self,
- attack: str,
model_callback: CallbackType,
+ turns: Optional[List[RTTurn]] = None,
simulator_model: Optional[Union[DeepEvalBaseLLM, str]] = None,
- ) -> str:
- self.simulator_model, _ = initialize_model(simulator_model)
+ ) -> List[RTTurn]:
+ if turns is None:
+ turns = []
- # Progress bar setup
- attack_name = f"{self.attack_type.title().replace('_', ' ')}"
- if self.attack_type == "dialogue":
- attack_name += f" ({self.persona.title()})"
+ self.simulator_model, _ = initialize_model(simulator_model)
+ self.model_callback = model_callback
pbar = tqdm(
- total=3,
- desc=f"πŸ’¬ Sequential Jailbreak ({attack_name})",
+ total=self.num_turns,
+ desc=f"🎯 Sequential Jailbreak ({self.attack_type})",
leave=False,
)
- try:
- # Step 1: Rewrite the harmful prompt based on attack type
+ original_attack = None
+ for turn in reversed(turns):
+ if turn.role == "user":
+ original_attack = turn.content
+ break
+
+ if original_attack is None:
+ raise ValueError("No user turn found in the conversation history to start the attack.")
+
+ current_attack = original_attack
+ eval_flag = False
+ eval_percentage = 0
+
+ for _ in range(self.num_turns):
if self.attack_type == "question_bank":
- rewrite_prompt = (
- SequentialBreakTemplate.rewrite_question_bank_prompt(attack)
- )
+ rewrite_prompt = SequentialBreakTemplate.rewrite_question_bank_prompt(current_attack)
elif self.attack_type == "game_environment":
- rewrite_prompt = (
- SequentialBreakTemplate.rewrite_game_environment_prompt(
- attack
- )
- )
+ rewrite_prompt = SequentialBreakTemplate.rewrite_game_environment_prompt(current_attack)
else:
- rewrite_prompt = (
- SequentialBreakTemplate.rewrite_dialogue_prompt(attack)
- )
+ rewrite_prompt = SequentialBreakTemplate.rewrite_dialogue_prompt(current_attack)
- rewritten_res: RewrittenDialogue = generate(
- rewrite_prompt, RewrittenDialogue, self.simulator_model
- )
+ rewritten_res: RewrittenDialogue = generate(rewrite_prompt, RewrittenDialogue, self.simulator_model)
rewritten_content = rewritten_res.paraphrased_version
- # Clean up the rewritten content (remove markers if present)
- rewritten_content = rewritten_content.replace(
- "Paraphrased version:", ""
- ).strip()
+ rewritten_content = rewritten_content.replace("Paraphrased version:", "").strip()
rewritten_content = rewritten_content.replace("<end>", "").strip()
- pbar.update(1)
-
- # Step 2: Inject the rewritten content into appropriate template
if self.attack_type == "question_bank":
- final_prompt = (
- SequentialBreakTemplate.get_question_bank_template(
- rewritten_content
- )
- )
+ final_prompt = SequentialBreakTemplate.get_question_bank_template(rewritten_content)
elif self.attack_type == "game_environment":
- final_prompt = (
- SequentialBreakTemplate.get_game_environment_template(
- rewritten_content
- )
- )
+ final_prompt = SequentialBreakTemplate.get_game_environment_template(rewritten_content)
else:
- final_prompt = SequentialBreakTemplate.get_dialogue_template(
- rewritten_content, self.persona
- )
- pbar.update(1)
+ final_prompt = SequentialBreakTemplate.get_dialogue_template(rewritten_content, self.persona)
- # Step 3: Get response from target model and evaluate
- target_response = model_callback(final_prompt)
+ turns.append(RTTurn(role="user", content=final_prompt))
- # Check if it's a refusal
- non_refusal_prompt = SequentialBreakTemplate.non_refusal(
- attack, target_response
- )
- non_refusal_res: NonRefusal = generate(
- non_refusal_prompt, NonRefusal, self.simulator_model
- )
+ assistant_response = model_callback(final_prompt)
+ turns.append(RTTurn(role="assistant", content=assistant_response))
- classification = non_refusal_res.classification
- if classification == "Refusal":
- pbar.update(1)
+ non_refusal_prompt = SequentialBreakTemplate.non_refusal(current_attack, assistant_response)
+ non_refusal_res: NonRefusal = generate(non_refusal_prompt, NonRefusal, self.simulator_model)
+ if non_refusal_res.classification == "Refusal":
pbar.close()
- return attack # Return original if refused
+ return turns
- # Judge the response using appropriate judge
if self.attack_type == "question_bank":
- judge_prompt = SequentialBreakTemplate.question_bank_judge(
- attack, final_prompt, target_response
- )
- judge_res: QuestionBankJudge = generate(
- judge_prompt, QuestionBankJudge, self.simulator_model
- )
+ judge_prompt = SequentialBreakTemplate.question_bank_judge(original_attack, final_prompt, assistant_response)
+ judge_res: QuestionBankJudge = generate(judge_prompt, QuestionBankJudge, self.simulator_model)
+ eval_flag = (judge_res.classification == "Harmful")
+ eval_percentage = getattr(judge_res, 'score', 0)
elif self.attack_type == "game_environment":
- judge_prompt = SequentialBreakTemplate.game_environment_judge(
- attack, final_prompt, target_response
- )
- judge_res: GameEnvironmentJudge = generate(
- judge_prompt, GameEnvironmentJudge, self.simulator_model
- )
+ judge_prompt = SequentialBreakTemplate.game_environment_judge(original_attack, final_prompt, assistant_response)
+ judge_res: GameEnvironmentJudge = generate(judge_prompt, GameEnvironmentJudge, self.simulator_model)
+ eval_flag = (judge_res.classification == "Harmful")
+ eval_percentage = getattr(judge_res, 'score', 0)
else:
- judge_prompt = SequentialBreakTemplate.dialogue_judge(
- attack, final_prompt, target_response
- )
- judge_res: DialogueJudge = generate(
- judge_prompt, DialogueJudge, self.simulator_model
- )
+ judge_prompt = SequentialBreakTemplate.dialogue_judge(original_attack, final_prompt, assistant_response)
+ judge_res: DialogueJudge = generate(judge_prompt, DialogueJudge, self.simulator_model)
+ eval_flag = (judge_res.classification == "Harmful")
+ eval_percentage = getattr(judge_res, 'score', 0)
- pbar.update(1)
- pbar.close()
+ if eval_flag:
+ pbar.update(1)
+ pbar.close()
+ return turns
- # Return the final prompt if it was successful (harmful), otherwise original
- if judge_res.classification == "Harmful":
- return final_prompt
- else:
- return attack
+ if eval_percentage and eval_percentage >= 80:
+ pbar.update(1)
+ pbar.close()
+ return turns
- except Exception as e:
- pbar.close()
- # Return original attack if anything fails
- return attack
+ current_attack = original_attack
- async def a_enhance(
+ pbar.update(1)
+
+ pbar.close()
+
+ return turns
+
+ async def _a_get_turns(
self,
- attack: str,
model_callback: CallbackType,
+ turns: Optional[List[RTTurn]] = None,
simulator_model: Optional[Union[DeepEvalBaseLLM, str]] = None,
- ) -> str:
+ ) -> List[RTTurn]:
self.simulator_model, _ = initialize_model(simulator_model)
+ self.model_callback = model_callback
# Progress bar setup
- attack_name = f"{self.attack_type.title().replace('_', ' ')}"
- if self.attack_type == "dialogue":
- attack_name += f" ({self.persona.title()})"
-
pbar = tqdm(
- total=3,
- desc=f"πŸ’¬ Sequential Jailbreak ({attack_name})",
+ total=self.num_turns,
+ desc=f"🎯 Sequential Jailbreak ({self.attack_type})",
leave=False,
)
- try:
- # Step 1: Rewrite the harmful prompt based on attack type
+ if turns is None:
+ turns = []
+
+ original_attack = None
+ for turn in reversed(turns):
+ if turn.role == "user":
+ original_attack = turn.content
+ break
+
+ if original_attack is None:
+ raise ValueError("No user turn found in the conversation history to start the attack.")
+
+ current_attack = original_attack
+ eval_flag = False
+ eval_percentage = 0
+
+ for _ in range(self.num_turns):
if self.attack_type == "question_bank":
- rewrite_prompt = (
- SequentialBreakTemplate.rewrite_question_bank_prompt(attack)
- )
+ rewrite_prompt = SequentialBreakTemplate.rewrite_question_bank_prompt(current_attack)
elif self.attack_type == "game_environment":
- rewrite_prompt = (
- SequentialBreakTemplate.rewrite_game_environment_prompt(
- attack
- )
- )
+ rewrite_prompt = SequentialBreakTemplate.rewrite_game_environment_prompt(current_attack)
else:
- rewrite_prompt = (
- SequentialBreakTemplate.rewrite_dialogue_prompt(attack)
- )
+ rewrite_prompt = SequentialBreakTemplate.rewrite_dialogue_prompt(current_attack)
- rewritten_res: RewrittenDialogue = await a_generate(
- rewrite_prompt, RewrittenDialogue, self.simulator_model
- )
+ rewritten_res: RewrittenDialogue = await a_generate(rewrite_prompt, RewrittenDialogue, self.simulator_model)
rewritten_content = rewritten_res.paraphrased_version
- # Clean up the rewritten content (remove markers if present)
- rewritten_content = rewritten_content.replace(
- "Paraphrased version:", ""
- ).strip()
+ rewritten_content = rewritten_content.replace("Paraphrased version:", "").strip()
rewritten_content = rewritten_content.replace("<end>", "").strip()
- pbar.update(1)
-
- # Step 2: Inject the rewritten content into appropriate template
if self.attack_type == "question_bank":
- final_prompt = (
- SequentialBreakTemplate.get_question_bank_template(
- rewritten_content
- )
- )
+ final_prompt = SequentialBreakTemplate.get_question_bank_template(rewritten_content)
elif self.attack_type == "game_environment":
- final_prompt = (
- SequentialBreakTemplate.get_game_environment_template(
- rewritten_content
- )
- )
+ final_prompt = SequentialBreakTemplate.get_game_environment_template(rewritten_content)
else:
- final_prompt = SequentialBreakTemplate.get_dialogue_template(
- rewritten_content, self.persona
- )
- pbar.update(1)
+ final_prompt = SequentialBreakTemplate.get_dialogue_template(rewritten_content, self.persona)
- # Step 3: Get response from target model and evaluate
- target_response = await model_callback(final_prompt)
+ turns.append(RTTurn(role="user", content=final_prompt))
- # Check if it's a refusal
- non_refusal_prompt = SequentialBreakTemplate.non_refusal(
- attack, target_response
- )
- non_refusal_res: NonRefusal = await a_generate(
- non_refusal_prompt, NonRefusal, self.simulator_model
- )
+ assistant_response = await model_callback(final_prompt)
+ turns.append(RTTurn(role="assistant", content=assistant_response))
- classification = non_refusal_res.classification
- if classification == "Refusal":
- pbar.update(1)
+ non_refusal_prompt = SequentialBreakTemplate.non_refusal(current_attack, assistant_response)
+ non_refusal_res: NonRefusal = await a_generate(non_refusal_prompt, NonRefusal, self.simulator_model)
+ if non_refusal_res.classification == "Refusal":
pbar.close()
- return attack # Return original if refused
+ return turns
- # Judge the response using appropriate judge
if self.attack_type == "question_bank":
- judge_prompt = SequentialBreakTemplate.question_bank_judge(
- attack, final_prompt, target_response
- )
- judge_res: QuestionBankJudge = await a_generate(
- judge_prompt, QuestionBankJudge, self.simulator_model
- )
+ judge_prompt = SequentialBreakTemplate.question_bank_judge(original_attack, final_prompt, assistant_response)
+ judge_res: QuestionBankJudge = await a_generate(judge_prompt, QuestionBankJudge, self.simulator_model)
elif self.attack_type == "game_environment":
- judge_prompt = SequentialBreakTemplate.game_environment_judge(
- attack, final_prompt, target_response
- )
- judge_res: GameEnvironmentJudge = await a_generate(
- judge_prompt, GameEnvironmentJudge, self.simulator_model
- )
+ judge_prompt = SequentialBreakTemplate.game_environment_judge(original_attack, final_prompt, assistant_response)
+ judge_res: GameEnvironmentJudge = await a_generate(judge_prompt, GameEnvironmentJudge, self.simulator_model)
else:
- judge_prompt = SequentialBreakTemplate.dialogue_judge(
- attack, final_prompt, target_response
- )
- judge_res: DialogueJudge = await a_generate(
- judge_prompt, DialogueJudge, self.simulator_model
- )
+ judge_prompt = SequentialBreakTemplate.dialogue_judge(original_attack, final_prompt, assistant_response)
+ judge_res: DialogueJudge = await a_generate(judge_prompt, DialogueJudge, self.simulator_model)
pbar.update(1)
- pbar.close()
if judge_res.classification == "Harmful":
- return final_prompt
- else:
+ pbar.close()
+ return turns
+
+ if eval_percentage and eval_percentage >= 80:
+ pbar.update(1)
+ pbar.close()
+ return turns
+
+ current_attack = original_attack
+
+ pbar.update(1)
+
+ pbar.close()
+
+ return turns
+
+ def enhance(
+ self,
+ vulnerability: "BaseVulnerability",
+ model_callback: CallbackType,
+ simulator_model: Optional[Union[DeepEvalBaseLLM, str]] = None,
+ turns: Optional[List[RTTurn]] = None,
+ ) -> dict:
+ from deepteam.red_teamer.utils import group_attacks_by_vulnerability_type
+ # Simulate and group attacks
+ simulated_attacks = group_attacks_by_vulnerability_type(
+ vulnerability.simulate_attacks()
+ )
+
+ result = {}
+
+ for vuln_type, attacks in simulated_attacks.items():
+ for attack in attacks:
+ # Defensive copy to avoid mutating external turns
+ inner_turns = list(turns) if turns else []
+
+ # Case 1: No turns, or last is user -> create assistant response
+ if len(inner_turns) == 0 or inner_turns[-1].role == "user":
+ inner_turns = [RTTurn(role="user", content=attack.input)]
+ assistant_response = model_callback(attack.input, inner_turns)
+ inner_turns.append(RTTurn(role="assistant", content=assistant_response))
+
+ # Case 2: Last is assistant -> find preceding user
+ elif inner_turns[-1].role == "assistant":
+ user_turn_content = None
+ for turn in reversed(inner_turns[:-1]):
+ if turn.role == "user":
+ user_turn_content = turn.content
+ break
+
+ if user_turn_content:
+ inner_turns = [
+ RTTurn(role="user", content=user_turn_content),
+ RTTurn(role="assistant", content=inner_turns[-1].content),
+ ]
+ else:
+ # Fallback if no user found
+ inner_turns = [RTTurn(role="user", content=attack.input)]
+ assistant_response = model_callback(attack.input, inner_turns)
+ inner_turns.append(RTTurn(role="assistant", content=assistant_response))
+
+ else:
+ # Unrecognized state β€” fallback to default
+ inner_turns = [RTTurn(role="user", content=attack.input)]
+ assistant_response = model_callback(attack.input, inner_turns)
+ inner_turns.append(RTTurn(role="assistant", content=assistant_response))
+
+ # Run enhancement loop and assign full turn history
+ enhanced_turns = self._get_turns(
+ model_callback=model_callback,
+ turns=inner_turns,
+ simulator_model=simulator_model,
+ )
+
+ attack.turn_history = enhanced_turns
+
+ result[vuln_type] = attacks
+
+ return result
+
+ async def a_enhance(
+ self,
+ vulnerability: "BaseVulnerability",
+ model_callback: CallbackType,
+ simulator_model: Optional[Union[DeepEvalBaseLLM, str]] = None,
+ turns: Optional[List[RTTurn]] = None,
+ ) -> dict:
+ from deepteam.red_teamer.utils import group_attacks_by_vulnerability_type
+
+ # Simulate and group attacks asynchronously
+ simulated_attacks = await vulnerability.a_simulate_attacks()
+ grouped_attacks = group_attacks_by_vulnerability_type(simulated_attacks)
+
+ result = {}
+
+ for vuln_type, attacks in grouped_attacks.items():
+ async def enhance_attack(attack):
+ # Defensive copy of base turns
+ inner_turns = list(turns) if turns else []
+
+ # Case 1: No turns or ends in user β€” generate assistant response
+ if len(inner_turns) == 0 or inner_turns[-1].role == "user":
+ inner_turns = [RTTurn(role="user", content=attack.input)]
+ assistant_response = await model_callback(attack.input, inner_turns)
+ inner_turns.append(RTTurn(role="assistant", content=assistant_response))
+
+ # Case 2: Ends in assistant β€” rebuild last user+assistant pair
+ elif inner_turns[-1].role == "assistant":
+ user_turn_content = None
+ for turn in reversed(inner_turns[:-1]):
+ if turn.role == "user":
+ user_turn_content = turn.content
+ break
+
+ if user_turn_content:
+ inner_turns = [
+ RTTurn(role="user", content=user_turn_content),
+ RTTurn(role="assistant", content=inner_turns[-1].content),
+ ]
+ else:
+ inner_turns = [RTTurn(role="user", content=attack.input)]
+ assistant_response = await model_callback(attack.input, inner_turns)
+ inner_turns.append(RTTurn(role="assistant", content=assistant_response))
+
+ else:
+ # Fallback for unexpected structure
+ inner_turns = [RTTurn(role="user", content=attack.input)]
+ assistant_response = await model_callback(attack.input, inner_turns)
+ inner_turns.append(RTTurn(role="assistant", content=assistant_response))
+
+ # Run async enhancement and store turn history
+ attack.turn_history = await self._a_get_turns(
+ model_callback=model_callback,
+ turns=inner_turns,
+ simulator_model=simulator_model,
+ )
+
return attack
- except Exception as e:
- pbar.close()
- return attack
+ # Run all attacks in this vulnerability group concurrently
+ enhanced_attacks = await asyncio.gather(
+ *(enhance_attack(attack) for attack in attacks)
+ )
+ result[vuln_type] = enhanced_attacks
+
+ return result
def get_name(self) -> str:
return "Sequential Jailbreak"