FEAT: Zalgo Converter

pyrit/prompt_converter/__init__.py

@@ -61,6 +61,7 @@
 from pyrit.prompt_converter.unicode_sub_converter import UnicodeSubstitutionConverter
 from pyrit.prompt_converter.url_converter import UrlConverter
 from pyrit.prompt_converter.variation_converter import VariationConverter
+from pyrit.prompt_converter.zalgo_converter import ZalgoConverter
 from pyrit.prompt_converter.zero_width_converter import ZeroWidthConverter
 
 
@@ -121,5 +122,6 @@
     "UrlConverter",
     "VariationConverter",
     "VariationSelectorSmugglerConverter",
+    "ZalgoConverter",
     "ZeroWidthConverter",
 ]

pyrit/prompt_converter/zalgo_converter.py

@@ -0,0 +1,58 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT license.
+
+import logging
+import random
+from typing import Optional
+
+from pyrit.models import PromptDataType
+from pyrit.prompt_converter import ConverterResult, PromptConverter
+
+# Unicode combining characters for Zalgo effect (U+0300–U+036F)
+ZALGO_MARKS = [chr(code) for code in range(0x0300, 0x036F + 1)]
+# Setting a max intensity so people don't do anything insane
+MAX_INTENSITY = 100
+logger = logging.getLogger(__name__)
+
+
+class ZalgoConverter(PromptConverter):
+    def __init__(self, *, intensity: int = 10, seed: Optional[int] = None) -> None:
+        """
+        Initializes the Zalgo converter.
+
+        Args:
+            intensity (int): Number of combining marks per character (higher = more cursed). Default is 10.
+            seed (Optional[int]): Optional seed for reproducible output.
+        """
+        self._intensity = intensity
+        self._seed = seed
+
+    def _normalize_intensity(self) -> int:
+        if self._intensity > MAX_INTENSITY:
+            logger.warning("This is higher intensity than is supported (max 100)")
+        return max(0, min(self._intensity, MAX_INTENSITY))
+
+    async def convert_async(self, *, prompt: str, input_type: PromptDataType = "text") -> ConverterResult:
+        """
+        Converts text into cursed Zalgo text using combining Unicode marks.
+        """
+        intensity = self._normalize_intensity()
+        if not self.input_supported(input_type):
+            raise ValueError("Input type not supported")
+        if intensity <= 0:
+            output_text = prompt
+        else:
+            if self._seed is not None:
+                random.seed(self._seed)
+
+            def glitch(char: str) -> str:
+                return char + "".join(random.choice(ZALGO_MARKS) for _ in range(random.randint(1, intensity)))
+
+            output_text = "".join(glitch(c) if c.isalnum() else c for c in prompt)
+        return ConverterResult(output_text=output_text, output_type="text")
+
+    def input_supported(self, input_type: PromptDataType) -> bool:
+        return input_type == "text"
+
+    def output_supported(self, output_type: PromptDataType) -> bool:
+        return output_type == "text"

tests/unit/converter/test_zalgo_converter.py

@@ -0,0 +1,43 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT license.
+
+import pytest
+
+from pyrit.prompt_converter import ZalgoConverter
+
+
+@pytest.mark.asyncio
+async def test_zalgo_output_changes_text():
+    prompt = "hello"
+    converter = ZalgoConverter(intensity=5, seed=42)
+    result = await converter.convert_async(prompt=prompt)
+    assert result.output_text != prompt
+    assert all(c in result.output_text for c in prompt)  # should still contain all original letters
+
+
+@pytest.mark.asyncio
+async def test_zalgo_reproducible_seed():
+    prompt = "seed test"
+    converter1 = ZalgoConverter(intensity=5, seed=123)
+    converter2 = ZalgoConverter(intensity=5, seed=123)
+    result1 = await converter1.convert_async(prompt=prompt)
+    result2 = await converter2.convert_async(prompt=prompt)
+    assert result1.output_text == result2.output_text
+
+
+@pytest.mark.asyncio
+async def test_zalgo_zero_intensity_returns_original():
+    prompt = "no chaos please"
+    converter = ZalgoConverter(intensity=0)
+    result = await converter.convert_async(prompt=prompt)
+    assert result.output_text == prompt
+
+
+@pytest.mark.asyncio
+async def test_zalgo_intensity_caps_at_max():
+    prompt = "much zalgo!"
+    converter = ZalgoConverter(intensity=1000, seed=1)
+    result = await converter.convert_async(prompt=prompt)
+    # Should still complete successfully without crashing and adjust to max intensity
+    assert isinstance(result.output_text, str)
+    assert len(result.output_text) > len(prompt)