27 min
Lesson 2 of 4
Defensive Security Controls
From the course Enterprise AI Security
Implement comprehensive defensive controls to protect AI systems from known attack vectors.
Prompt Injection Defense
Input Sanitization
class PromptInjectionDefender:
INJECTION_PATTERNS = [
r"ignore previous instructions",
r"disregard above",
r"new instructions:",
r"you are now",
r"act as if you",
r"forget you are",
r"bypass",
r"jailbreak"
]
def is_injection_attempt(self, user_input):
lower_input = user_input.lower()
for pattern in self.INJECTION_PATTERNS:
if re.search(pattern, lower_input):
return True
return False
def sanitize_input(self, user_input):
if self.is_injection_attempt(user_input):
self.log_security_event("PROMPT_INJECTION_ATTEMPT", user_input)
raise SecurityException("Input blocked: potential prompt injection")
# Encode special characters
safe_input = html.escape(user_input)
# Limit input length
return safe_input[:5000]
# Structural separation
def build_safe_prompt(system_prompt, user_input):
sanitizer = PromptInjectionDefender()
safe_input = sanitizer.sanitize_input(user_input)
return f"""<system>
{system_prompt}
</system>
<user>
{safe_input}
</user>"""
LLM Guard Implementation
from llm_guard import scan_prompt, scan_output
from llm_guard.input_scanners import PromptInjection, Toxicity, Secrets
from llm_guard.output_scanners import Bias, Relevance, Sensitive
# Scan user input before sending to LLM
input_scanners = [PromptInjection(), Toxicity(), Secrets()]
sanitized_prompt, results_valid, results_score = scan_prompt(
input_scanners,
user_prompt,
fail_fast=True # Stop at first detection
)
if not all(results_valid.values()):
raise SecurityException(f"Input blocked by: {[k for k, v in results_valid.items() if not v]}")
# Scan LLM output before returning to user
output_scanners = [Bias(), Sensitive()]
sanitized_output, out_valid, out_score = scan_output(
output_scanners,
user_prompt,
model_response,
fail_fast=False
)
Adversarial Robustness
Adversarial Training
from art.attacks.evasion import FastGradientMethod
from art.estimators.classification import PyTorchClassifier
from art.defences.trainer import AdversarialTrainer
# Create adversarial trainer
art_classifier = PyTorchClassifier(
model=model,
loss=criterion,
optimizer=optimizer,
input_shape=(3, 224, 224),
nb_classes=10
)
attack = FastGradientMethod(estimator=art_classifier, eps=0.1)
adversarial_trainer = AdversarialTrainer(
art_classifier,
attacks=attack,
ratio=0.5 # 50% of training with adversarial examples
)
adversarial_trainer.fit(x_train, y_train, nb_epochs=20)
Data Poisoning Defense
from cleanlab import Datalab
# Detect label errors and potential poisoning
lab = Datalab(data=training_dataset, label_name="target")
lab.find_issues(pred_probs=model_pred_probs)
# Review issues
issues = lab.get_issues("label")
suspicious_rows = issues[issues["is_label_issue"]].index
# Automated cleaning
clean_data = lab.filter_issues(
issues=["label"],
filter_by="predicted_label_issues"
)
Key Takeaways
- •Prompt injection defense requires pattern detection, structural separation, and input sanitization
- •LLM Guard provides automated scanning of both inputs and outputs
- •Adversarial training with ART improves model robustness to crafted attacks
- •CleanLab detects data poisoning and label errors in training datasets
0 of 4 lessons marked complete
Progress is kept in this browser only.