AI Model Wiki

    Skip to main content
    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.