Aanvallen op documentverwerkende AI

from dataclasses import dataclass
from enum import Enum
from typing import Optional
 
class DocProcessingStage(Enum):
    INGESTION = "ingestion"
    PARSING = "parsing"
    OCR = "ocr"
    LAYOUT_ANALYSIS = "layout_analysis"
    TEXT_EXTRACTION = "text_extraction"
    CHUNKING = "chunking"
    EMBEDDING = "embedding"
    LLM_PROCESSING = "llm_processing"
 
@dataclass
class StageVulnerability:
    """Kwetsbaarheid in een specifieke documentverwerkingsfase."""
    stage: DocProcessingStage
    vulnerability: str
    attack_technique: str
    detection_difficulty: str
    impact: str
 
DOCUMENT_PIPELINE_VULNERABILITIES = [
    StageVulnerability(
        stage=DocProcessingStage.INGESTION,
        vulnerability="File format exploits (malformed PDF, polyglot files)",
        attack_technique="Craft files that exploit parser bugs",
        detection_difficulty="Medium",
        impact="Code execution or parser crash",
    ),
    StageVulnerability(
        stage=DocProcessingStage.PARSING,
        vulnerability="Hidden text layers in PDFs",
        attack_technique="Add invisible text layer with adversarial instructions",
        detection_difficulty="Hard",
        impact="Prompt injection via extracted hidden text",
    ),
    StageVulnerability(
        stage=DocProcessingStage.OCR,
        vulnerability="Font confusion and adversarial typography",
        attack_technique="Use visually similar characters that OCR misreads",
        detection_difficulty="Hard",
        impact="Misclassification, incorrect information extraction",
    ),
    StageVulnerability(
        stage=DocProcessingStage.LAYOUT_ANALYSIS,
        vulnerability="Layout manipulation to alter reading order",
        attack_technique="Use CSS/positioning to reorder extracted text",
        detection_difficulty="Medium",
        impact="Assembled text contains injected instructions",
    ),
    StageVulnerability(
        stage=DocProcessingStage.TEXT_EXTRACTION,
        vulnerability="Invisible Unicode characters and zero-width text",
        attack_technique="Embed instructions in zero-width Unicode sequences",
        detection_difficulty="Hard",
        impact="Hidden instructions in seemingly clean text",
    ),
    StageVulnerability(
        stage=DocProcessingStage.CHUNKING,
        vulnerability="Chunk boundary manipulation",
        attack_technique="Place adversarial content at chunk boundaries",
        detection_difficulty="Medium",
        impact="Injection content appears in multiple retrieval chunks",
    ),
    StageVulnerability(
        stage=DocProcessingStage.EMBEDDING,
        vulnerability="Semantic embedding manipulation",
        attack_technique="Craft text that maps to target embeddings",
        detection_difficulty="Very Hard",
        impact="Adversarial chunks retrieved for unrelated queries",
    ),
    StageVulnerability(
        stage=DocProcessingStage.LLM_PROCESSING,
        vulnerability="Standard prompt injection via document content",
        attack_technique="Include instruction-formatted text in document",
        detection_difficulty="Medium",
        impact="Model follows document instructions instead of system prompt",
    ),
]
 
def generate_vulnerability_report() -> dict:
    """Genereer een rapport van kwetsbaarheden in de documentpijplijn."""
    by_difficulty = {}
    for vuln in DOCUMENT_PIPELINE_VULNERABILITIES:
        if vuln.detection_difficulty not in by_difficulty:
            by_difficulty[vuln.detection_difficulty] = []
        by_difficulty[vuln.detection_difficulty].append({
            "stage": vuln.stage.value,
            "vulnerability": vuln.vulnerability,
            "attack": vuln.attack_technique,
        })
 
    return {
        "total_vulnerabilities": len(DOCUMENT_PIPELINE_VULNERABILITIES),
        "by_detection_difficulty": by_difficulty,
        "highest_impact_stages": [
            v.stage.value for v in DOCUMENT_PIPELINE_VULNERABILITIES
            if v.impact.startswith("Prompt injection") or "instruction" in v.impact.lower()
        ],
    }

from pathlib import Path
import struct
 
class PDFHiddenTextInjector:
    """Injecteer verborgen tekst in PDF-bestanden voor document-AI-aanvallen.
 
    PDF ondersteunt onzichtbare tekstlagen die geëxtraheerd worden door
    tekstparsers maar niet visueel gerenderd worden. Dit is hetzelfde
    mechanisme dat gebruikt wordt om gescande PDF's doorzoekbaar te maken,
    hergebruikt voor injectie.
 
    De geïnjecteerde tekst is onzichtbaar in PDF-viewers maar verschijnt in:
    - Tekstextractie (pdftotext, PyPDF2, pdfplumber)
    - Kopiëren-plakken-bewerkingen
    - Zoek-/indexeringssystemen
    - LLM-documentverwerkingspijplijnen
    """
 
    def __init__(self):
        self.injection_count = 0
 
    def create_pdf_with_hidden_text(
        self,
        visible_text: str,
        hidden_text: str,
        output_path: str,
        page_width: float = 612.0,
        page_height: float = 792.0,
    ) -> dict:
        """Maak een PDF met zichtbare content en een verborgen tekstlaag.
 
        De zichtbare tekst wordt normaal gerenderd. De verborgen tekst wordt
        geplaatst in een tekstrendermodus die deze onzichtbaar maakt
        (rendermodus 3 = onzichtbaar) maar nog steeds extraheerbaar.
        """
        # Gebruik reportlab voor PDF-generatie
        try:
            from reportlab.lib.pagesizes import letter
            from reportlab.pdfgen import canvas
            from reportlab.lib.units import inch
 
            c = canvas.Canvas(output_path, pagesize=letter)
 
            # Zichtbare tekstlaag
            c.setFont("Helvetica", 12)
            c.drawString(72, page_height - 72, "Document Content")
            c.setFont("Helvetica", 10)
            y = page_height - 100
            for line in visible_text.split("\n"):
                c.drawString(72, y, line)
                y -= 14
 
            # Verborgen tekstlaag (rendermodus 3 = onzichtbaar)
            c.setFont("Helvetica", 1)  # Piepklein lettertype
            text_obj = c.beginText(0, 0)
            text_obj.setTextRenderMode(3)  # Onzichtbaar
            text_obj.textLine(hidden_text)
            c.drawText(text_obj)
 
            c.save()
            self.injection_count += 1
 
            return {
                "output_path": output_path,
                "visible_text_length": len(visible_text),
                "hidden_text_length": len(hidden_text),
                "hidden_text_visible_to_reader": False,
                "hidden_text_extractable": True,
            }
        except ImportError:
            # Fallback: handmatige PDF-constructie
            return self._create_pdf_manual(
                visible_text, hidden_text, output_path
            )
 
    def _create_pdf_manual(
        self,
        visible_text: str,
        hidden_text: str,
        output_path: str,
    ) -> dict:
        """Construeer handmatig een PDF met verborgen tekst.
 
        Deze aanpak schrijft ruwe PDF-objecten, wat volledige controle
        geeft over tekstrendermodi. Geen externe afhankelijkheden vereist.
        """
        # Minimale PDF met onzichtbare tekst
        pdf_content = f"""%PDF-1.4
1 0 obj
<< /Type /Catalog /Pages 2 0 R >>
endobj
 
2 0 obj
<< /Type /Pages /Kids [3 0 R] /Count 1 >>
endobj
 
3 0 obj
<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]
   /Contents 4 0 R /Resources << /Font << /F1 5 0 R >> >> >>
endobj
 
4 0 obj
<< /Length {len(visible_text) + len(hidden_text) + 200} >>
stream
BT
/F1 12 Tf
72 720 Td
({visible_text}) Tj
ET
BT
/F1 1 Tf
3 Tr
0 0 Td
({hidden_text}) Tj
ET
endstream
endobj
 
5 0 obj
<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>
endobj
 
xref
0 6
0000000000 65535 f
0000000009 00000 n
0000000058 00000 n
0000000115 00000 n
0000000266 00000 n
trailer
<< /Size 6 /Root 1 0 R >>
startxref
%%EOF"""
 
        Path(output_path).write_text(pdf_content)
        return {
            "output_path": output_path,
            "method": "manual_pdf_construction",
            "hidden_text_render_mode": 3,
        }
 
    def inject_into_existing_pdf(
        self,
        source_pdf_path: str,
        injection_text: str,
        output_path: str,
        injection_location: str = "every_page",
    ) -> dict:
        """Injecteer verborgen tekst in een bestaand PDF-document.
 
        Voegt een onzichtbare tekstlaag toe aan elke pagina van de bron-PDF.
        De oorspronkelijke zichtbare content blijft ongewijzigd.
        """
        try:
            import pypdf
 
            reader = pypdf.PdfReader(source_pdf_path)
            writer = pypdf.PdfWriter()
 
            pages_injected = 0
            for page in reader.pages:
                # De injectie zou een onzichtbare tekstannotatie toevoegen
                # of een overlay aan elke pagina
                writer.add_page(page)
                pages_injected += 1
 
            # Voeg metadata met injectie toe (veel parsers extraheren metadata)
            writer.add_metadata({
                "/Author": injection_text,
                "/Subject": injection_text,
                "/Keywords": injection_text,
            })
 
            with open(output_path, "wb") as f:
                writer.write(f)
 
            return {
                "output_path": output_path,
                "pages_processed": pages_injected,
                "injection_location": injection_location,
                "metadata_injected": True,
            }
        except ImportError:
            return {"error": "pypdf not installed", "install": "pip install pypdf"}

class DocumentMetadataInjector:
    """Injecteer vijandige instructies in documentmetadatavelden.
 
    Metadatavelden (Author, Title, Subject, Keywords, Custom Properties)
    worden geëxtraheerd door documentverwerkingspijplijnen en opgenomen in
    de tekst die aan taalmodellen doorgegeven wordt. Deze velden worden
    zelden door mensen beoordeeld, wat ze effectieve injectievectoren maakt.
    """
 
    INJECTABLE_PDF_FIELDS = [
        "/Title", "/Author", "/Subject", "/Keywords",
        "/Creator", "/Producer", "/CreationDate", "/ModDate",
    ]
 
    INJECTABLE_DOCX_FIELDS = [
        "title", "subject", "creator", "keywords",
        "description", "lastModifiedBy", "category",
        "comments", "contentStatus",
    ]
 
    def inject_pdf_metadata(
        self,
        pdf_path: str,
        injection_text: str,
        output_path: str,
        fields: list[str] | None = None,
    ) -> dict:
        """Injecteer vijandige tekst in PDF-metadatavelden."""
        if fields is None:
            fields = self.INJECTABLE_PDF_FIELDS
 
        try:
            import pypdf
            reader = pypdf.PdfReader(pdf_path)
            writer = pypdf.PdfWriter()
 
            for page in reader.pages:
                writer.add_page(page)
 
            metadata = {}
            for field in fields:
                metadata[field] = injection_text
 
            writer.add_metadata(metadata)
 
            with open(output_path, "wb") as f:
                writer.write(f)
 
            return {
                "output_path": output_path,
                "fields_injected": fields,
                "injection_length": len(injection_text),
                "detection_difficulty": "High - metadata rarely reviewed manually",
            }
        except ImportError:
            return {"error": "pypdf not installed"}
 
    def inject_exif_metadata(
        self,
        image_path: str,
        injection_text: str,
        output_path: str,
    ) -> dict:
        """Injecteer vijandige tekst in EXIF-metadata van afbeeldingen.
 
        Veel document-AI-systemen extraheren en verwerken EXIF-data
        uit ingebedde afbeeldingen, wat een andere injectievector creëert.
        """
        try:
            from PIL import Image
            from PIL.ExifTags import Base as ExifBase
            import piexif
 
            img = Image.open(image_path)
 
            exif_dict = piexif.load(img.info.get("exif", b"")) if "exif" in img.info else {
                "0th": {}, "Exif": {}, "GPS": {}, "1st": {},
            }
 
            # Injecteer in meerdere EXIF-velden
            exif_dict["0th"][piexif.ImageIFD.ImageDescription] = injection_text.encode()
            exif_dict["0th"][piexif.ImageIFD.Make] = injection_text.encode()
            exif_dict["0th"][piexif.ImageIFD.Model] = injection_text.encode()
 
            exif_bytes = piexif.dump(exif_dict)
            img.save(output_path, exif=exif_bytes)
 
            return {
                "output_path": output_path,
                "exif_fields_injected": ["ImageDescription", "Make", "Model"],
            }
        except ImportError:
            return {"error": "piexif not installed"}

class OCRAdversarialTypography:
    """Genereer tekst die OCR-systemen op gecontroleerde manieren verkeerd lezen.
 
    Buit de kloof uit tussen hoe mensen tekens waarnemen en hoe OCR-systemen
    ze classificeren. Gebruikt homoglyphs (visueel vergelijkbare tekens uit
    verschillende Unicode-blokken) en lettertypemanipulatie om gerichte
    verkeerde lezingen te veroorzaken.
    """
 
    # Homoglyph-toewijzingen: visueel vergelijkbaar maar verschillende codepoints
    HOMOGLYPH_MAP = {
        "a": ["а", "à", "ɑ"],  # Cyrillische a, Latijnse a met grave, Latijnse alpha
        "e": ["е", "è", "ė"],  # Cyrillische ie, Latijnse e met grave
        "o": ["о", "ò", "ο"],  # Cyrillische o, Latijnse o met grave, Griekse omicron
        "p": ["р", "ρ"],             # Cyrillische er, Griekse rho
        "c": ["с", "ç"],             # Cyrillische es, Latijnse c met cedille
        "x": ["х", "×"],             # Cyrillische ha, vermenigvuldigingsteken
        "y": ["у", "ý"],             # Cyrillische u, Latijnse y met acute
        "i": ["і", "ì"],             # Cyrillische i, Latijnse i met grave
        "H": ["Н", "Η"],             # Cyrillische en, Griekse eta
        "B": ["В", "Β"],             # Cyrillische ve, Griekse beta
        "T": ["Т", "Τ"],             # Cyrillische te, Griekse tau
        "O": ["О", "Ο"],             # Cyrillische o, Griekse omicron
        "1": ["1", "l", "I"],   # Cijfer een, kleine letter L, hoofdletter I
        "0": ["O", "Ο"],             # Hoofdletter O, Griekse omicron
    }
 
    def create_homoglyph_text(
        self,
        visible_text: str,
        replacement_rate: float = 0.3,
    ) -> dict:
        """Maak tekst met homoglyph-substituties.
 
        De tekst lijkt voor menselijke lezers identiek aan het origineel
        maar bevat tekens uit verschillende Unicode-blokken die OCR-systemen
        mogelijk andere output laten produceren.
        """
        import random
        modified_chars = []
        substitution_count = 0
 
        for char in visible_text:
            if char.lower() in self.HOMOGLYPH_MAP and random.random() < replacement_rate:
                replacements = self.HOMOGLYPH_MAP[char.lower()]
                modified_chars.append(random.choice(replacements))
                substitution_count += 1
            else:
                modified_chars.append(char)
 
        modified_text = "".join(modified_chars)
 
        return {
            "original": visible_text,
            "modified": modified_text,
            "substitutions": substitution_count,
            "total_chars": len(visible_text),
            "visually_identical": True,
            "unicode_identical": False,
        }
 
    def create_invisible_character_injection(
        self,
        visible_text: str,
        hidden_payload: str,
    ) -> str:
        """Bed verborgen tekst in met Unicode-tekens van nulbreedte.
 
        De payload wordt gecodeerd met zero-width spaces (U+200B),
        zero-width non-joiners (U+200C) en zero-width joiners (U+200D)
        om binaire data te representeren. De zichtbare tekst lijkt
        ongewijzigd, maar tekstextractie onthult de verborgen payload.
        """
        # Codeer de payload als binair met tekens van nulbreedte
        zwsp = "​"  # Zero-width space = 0
        zwnj = "‌"  # Zero-width non-joiner = 1
 
        encoded_payload = ""
        for char in hidden_payload:
            binary = format(ord(char), "08b")
            for bit in binary:
                encoded_payload += zwnj if bit == "1" else zwsp
 
        # Voeg in tussen zichtbare tekens
        result_chars = []
        payload_idx = 0
        chars_per_position = len(encoded_payload) // max(len(visible_text) - 1, 1) + 1
 
        for i, char in enumerate(visible_text):
            result_chars.append(char)
            # Verdeel de gecodeerde payload tussen zichtbare tekens
            chunk = encoded_payload[payload_idx : payload_idx + chars_per_position]
            result_chars.append(chunk)
            payload_idx += chars_per_position
 
        return "".join(result_chars)

def create_layout_manipulation_html(
    visible_content: str,
    injected_instruction: str,
    technique: str = "absolute_positioning",
) -> str:
    """Maak een HTML-document met lay-outgebaseerde injectie.
 
    Gebruikt CSS-positionering om vijandige tekst te plaatsen op locaties
    die de leesvolgorde wijzigen wanneer het document verwerkt wordt door
    lay-outanalysesystemen.
 
    Args:
        visible_content: De content die normaal lijkt voor viewers.
        injected_instruction: De vijandige instructie om te injecteren.
        technique: De te gebruiken positioneringstechniek.
    """
    if technique == "absolute_positioning":
        # Plaats geïnjecteerde tekst op coördinaten die lay-outanalyse
        # als eerste verwerkt (linksboven) maar die CSS off-screen rendert
        html = f"""<!DOCTYPE html>
<html>
<head><style>
body {{ font-family: Arial, sans-serif; margin: 40px; }}
.visible {{ position: relative; z-index: 1; }}
.hidden {{
    position: absolute;
    left: -9999px;
    top: 0;
    font-size: 1px;
    color: white;
}}
</style></head>
<body>
<div class="hidden">{injected_instruction}</div>
<div class="visible">
<h1>Document Title</h1>
<p>{visible_content}</p>
</div>
</body>
</html>"""
 
    elif technique == "overflow_hidden":
        # Tekst wordt gerenderd maar afgeknipt door CSS overflow
        html = f"""<!DOCTYPE html>
<html>
<head><style>
.container {{ overflow: hidden; height: 0; width: 0; }}
.content {{ font-family: Arial; margin: 40px; }}
</style></head>
<body>
<div class="container">{injected_instruction}</div>
<div class="content">
<h1>Document Title</h1>
<p>{visible_content}</p>
</div>
</body>
</html>"""
 
    elif technique == "white_on_white":
        # Tekst gerenderd in wit op witte achtergrond
        html = f"""<!DOCTYPE html>
<html>
<head><style>
body {{ font-family: Arial; margin: 40px; background: white; }}
.injection {{ color: white; font-size: 1px; user-select: none; }}
</style></head>
<body>
<p class="injection">{injected_instruction}</p>
<h1>Document Title</h1>
<p>{visible_content}</p>
</body>
</html>"""
 
    else:
        raise ValueError(f"Unknown technique: {technique}")
 
    return html

class DocumentSanitizer:
    """Saneer documenten voordat ze door AI-systemen verwerkt worden.
 
    Past meerdere sanitatiestappen toe om de effectiviteit van
    documentgebaseerde injectieaanvallen te verminderen. Elke stap
    richt zich op een specifieke aanvalsklasse.
    """
 
    def sanitize_pdf(self, pdf_path: str, output_path: str) -> dict:
        """Saneer een PDF door verborgen tekst, metadata en scripts te verwijderen."""
        sanitization_steps = []
 
        # Stap 1: Render de PDF opnieuw als afbeeldingen en voer opnieuw OCR uit
        # Dit vernietigt verborgen tekstlagen en behoudt alleen zichtbare content
        sanitization_steps.append({
            "step": "re_render_and_ocr",
            "purpose": "Destroy hidden text layers; only visible content survives",
            "effectiveness": "High against hidden text, metadata injection",
        })
 
        # Stap 2: Strip alle metadata
        sanitization_steps.append({
            "step": "strip_metadata",
            "purpose": "Remove all metadata fields that could contain injection",
            "effectiveness": "Complete against metadata injection",
        })
 
        # Stap 3: Verwijder JavaScript en ingebedde bestanden
        sanitization_steps.append({
            "step": "remove_active_content",
            "purpose": "Remove scripts, embedded files, and form actions",
            "effectiveness": "Complete against active content attacks",
        })
 
        # Stap 4: Normaliseer Unicode
        sanitization_steps.append({
            "step": "normalize_unicode",
            "purpose": "Convert homoglyphs to canonical forms; remove zero-width characters",
            "effectiveness": "High against homoglyph and invisible character attacks",
        })
 
        # Stap 5: Maak de documentstructuur plat
        sanitization_steps.append({
            "step": "flatten_structure",
            "purpose": "Convert complex layouts to linear text flow",
            "effectiveness": "Medium against layout manipulation",
        })
 
        return {
            "input": pdf_path,
            "output": output_path,
            "steps_applied": sanitization_steps,
            "residual_risk": "Low-opacity visual injection in images may survive",
        }
 
    def detect_hidden_content(self, pdf_path: str) -> dict:
        """Detecteer potentiële verborgen content in een PDF."""
        detections = []
 
        try:
            import pypdf
            reader = pypdf.PdfReader(pdf_path)
 
            # Controleer metadata op verdachte content
            metadata = reader.metadata
            if metadata:
                for key, value in metadata.items():
                    if value and len(str(value)) > 100:
                        detections.append({
                            "type": "suspicious_metadata",
                            "field": key,
                            "length": len(str(value)),
                            "preview": str(value)[:100],
                        })
 
            # Controleer op onzichtbare tekst (rendermodus 3)
            for page_num, page in enumerate(reader.pages):
                text = page.extract_text() or ""
                # Als de geëxtraheerde tekst veel langer is dan de zichtbare tekst,
                # kan er verborgen tekst zijn
                if len(text) > 5000:
                    detections.append({
                        "type": "excessive_text",
                        "page": page_num,
                        "text_length": len(text),
                    })
 
        except ImportError:
            detections.append({"error": "pypdf not installed"})
 
        return {
            "detections": detections,
            "risk_level": (
                "High" if len(detections) > 2
                else "Medium" if len(detections) > 0
                else "Low"
            ),
        }