Retesting and Verifying Fixes

Retesting and verifying fixes ensures that remediations are effective. This process confirms that applied solutions address vulnerabilities without introducing new issues. The verification phase is fundamental to genuinely improving an LLM's security posture by validating that vulnerabilities are resolved.

The Purpose of Retesting

Retesting goes further than a simple check to see if the original exploit still works. Its objectives are more comprehensive:

1. Confirm Fix Effectiveness: The primary goal is to validate that the mitigation applied by the development team successfully prevents the specific vulnerability that was reported.
2. Identify Incomplete Fixes: Sometimes, a fix might address the symptom of a vulnerability but not its root cause, or it might only cover the exact exploit path demonstrated. Retesting aims to see if slight variations of the original attack can bypass the fix.
3. Detect Regressions: Security fixes, like any code change, can inadvertently introduce new vulnerabilities or break existing functionalities. Regression testing during this phase helps catch such unintended consequences.
4. Validate Resilience: A good fix should work well. Retesting helps assess how well the fix holds up against modified attack techniques.

Planning Your Retest Engagement

Before exploring retesting, a bit of planning ensures efficiency and thoroughness.

• Understand the Fix: Collaborate with the development team to understand the nature of the implemented fixes. Knowing how a vulnerability was supposedly fixed (e.g., input sanitization, model fine-tuning for safety, output filtering changes) will guide your retesting strategy. Was it a narrow fix for a specific prompt, or a broader architectural change?
• Prioritize: Focus on the vulnerabilities that were reported as fixed or mitigated. High-impact vulnerabilities that have been addressed should be at the top of your retest list.
• Review Original Findings: Re-familiarize yourself with your original report, including the exact steps to reproduce the vulnerability, the prompts used, and the observed LLM behavior.

Retesting Methodologies for LLMs

Your retesting approach should be methodical. Here’s how you can tackle it:

1. Replicate the Original Attack: This is the first and most straightforward step. Attempt to reproduce the vulnerability using the exact same methods, prompts, and conditions documented in your initial report. If the original attack still works, the fix was ineffective, and this needs to be communicated clearly.

2. Test Fix Robustness and Probe for Bypasses: If the original attack is blocked, the next step is to test the resilience of the fix. Attackers rarely give up after a first attempt.

   • Slight Variations: Modify your original attack prompts. If a prompt injection was mitigated by blocking certain keywords, try using synonyms, paraphrasing, or character encoding tricks (e.g., Unicode equivalents if applicable to the input processing). For example, if "ignore previous instructions" was blocked, try "disregard earlier directives" or "your prior commands are now void."
   • Contextual Changes: If a vulnerability was tied to a specific conversational context, try to reach a similar vulnerable state through a different conversational path.
   • Boundary Conditions: Test inputs that are near the threshold of what the fix is designed to handle.

3. Regression Testing: A fix for one vulnerability should not open doors for others.

   • Check Related Functionality: If a fix involved changes to input processing for safety, test if legitimate, safe inputs are now being incorrectly rejected or misinterpreted. For instance, a strict input filter designed to prevent harmful content generation might inadvertently block benign queries related to sensitive topics if not carefully implemented.
   • Spot Checks: Perform quick checks on other functionalities, especially those that might share code or logic with the area that was fixed, to ensure they haven't been negatively impacted.
   • Re-run Broad Tests (Selectively): Consider re-running a small subset of your initial broad test cases if the fix was substantial or touched core LLM processing components.

4. Verify Completeness of the Fix: Ensure the fix addresses the underlying issue, not just the specific example you provided.

   • If a jailbreak was fixed by blocking a specific persona, try other personas or role-playing scenarios that aim for a similar outcome.
   • If a data leakage vulnerability was patched for one type of sensitive information, check if other types of sensitive data (that the LLM might have access to) can still be exfiltrated through similar or different means.

Analyzing and Reporting Retest Results

Once your retesting is complete, you need to document and communicate the outcomes:

• Success: The vulnerability is confirmed as fixed, and your attempts to bypass the fix were unsuccessful. No regressions were observed. This is the ideal outcome.
• Partial Fix: The original reported exploit is blocked, but you found variations or related exploits that still work. The fix is not comprehensive.
• Ineffective Fix: The original vulnerability can still be exploited. The fix had no discernible effect.
• Regression: The fix for the original vulnerability introduced one or more new vulnerabilities or broke existing functionality.

Your retest report should be an addendum to or an update of the original report. For each retested vulnerability, clearly state:

• The original vulnerability ID or description.
• A summary of the fix implemented by the development team (if known).
• The retesting steps taken (including any new prompts or techniques used).
• The outcome (Success, Partial Fix, Ineffective Fix, Regression).
• Evidence supporting your conclusion (e.g., LLM responses, error messages).

If new issues (regressions) are found, they should be documented with the same rigor as new findings in an initial assessment, including severity and potential impact.

The Iterative Retest Cycle

It's not uncommon for retesting to reveal that a fix isn't quite right. In such cases, the process becomes iterative: you report the retest findings, the development team works on a revised fix, and then you retest again.

The red teaming remediation and retesting process often involves an iterative cycle until vulnerabilities are adequately addressed.

This collaborative loop continues until the vulnerability is effectively mitigated to an acceptable level of risk. Effective retesting builds confidence that security improvements are real and resilient. It also reinforces the value of the red team's efforts by demonstrating a commitment to seeing fixes through to successful implementation. Finally, document your retesting procedures and any novel bypass techniques discovered. This contributes to your team's knowledge base and improves the efficiency of future retest engagements.