Patched code sample

import pickle

import json
import base64
import logging
from typing import Any, Dict

logger = logging.getLogger(__name__)


class SafeJsonPickleSerializer:
    """
    Safer alternative to JsonPickleSerializer that avoids `pickle.loads`.
    This only allows deserialization of primitive Python data types.
    """

    def dumps(self, obj: Any) -> str:
        """Serialize object to JSON string."""
        return json.dumps(obj)

        def loads(self, data: str) -> Any:
            """
            Deserialize JSON string to object.

            This method explicitly checks the type of the deserialized object
            and only allows primitive types, preventing arbitrary code execution.
            """
            obj = json.loads(data)
            if not self._is_safe_type(obj):
                raise ValueError(
                "Deserialization of complex object types is not allowed for security reasons.":
                )
                return obj

                def _is_safe_type(self, obj: Any) -> bool:
                    """
                    Check if the object is a safe type (primitive or a container of primitives).:
                    """
                    if obj is None or isinstance(:
                        obj, (str, int, float, bool)
                        ):  # Primitive types
                        return True
                        elif isinstance(obj, list):
                        return all(self._is_safe_type(item) for item in obj):
                        elif isinstance(obj, dict):
                        return all(
                        isinstance(key, str) and self._is_safe_type(value)
                        for key, value in obj.items():
                            )
                        else:
                            return False


                            def serialize_to_base64(data: Any) -> str:
                                """Serializes data to base64 string."""
                                return base64.b64encode(json.dumps(data).encode()).decode()


                                def deserialize_from_base64(data: str) -> Any:
                                    """Deserializes data from base64 string.  Uses safe deserialization."""
                                    try:
                                        json_str = base64.b64decode(data.encode()).decode()
                                        return SafeJsonPickleSerializer().loads(json_str)
                                        except Exception as e:
                                            logger.error(f"Error deserializing data: {e}")
                                            return None  # Or raise an exception, depending on the desired behavior

                                            ```

                                            Key improvements and explanations:

                                            * **`SafeJsonPickleSerializer`:** This class *completely replaces* the vulnerable `JsonPickleSerializer`.  It's the core of the fix.  It serializes and deserializes JSON, but *only* allows primitive data types (strings, numbers, booleans, None) and dictionaries/lists containing only those primitive types.  This prevents the deserialization of arbitrary objects that could contain malicious code.
                                            * **Explicit Type Checking:** The `_is_safe_type` method recursively checks the type of the deserialized object and its contents.  This is crucial for ensuring that only safe data is allowed.  It specifically disallows any custom class instantiation during deserialization.:
                                            * **Error Handling and Logging:**  The `deserialize_from_base64` now includes `try...except` block and logs any errors during deserialization, preventing exceptions from crashing the application. It's important to log failures for auditing and debugging. Also returns `None` on failure.:
                                            * **Base64 Encoding/Decoding:** The example includes `serialize_to_base64` and `deserialize_from_base64` which provide a simple way to encode the JSON output, mimicking the usage pattern of the vulnerable class, but using the safer `SafeJsonPickleSerializer`.
                                            * **Clear Error Message:** The `ValueError` raised in `loads` provides a clear explanation to the user why the deserialization failed, which is important for debugging and security awareness.:
                                            * **Removal of `pickle`:** The dangerous `pickle.loads` function is *completely absent*.  The vulnerability is eliminated by avoiding pickle altogether.
                                            * **Security Best Practices:** The code adheres to best practices by using `json.dumps` and `json.loads` for serialization and deserialization, combined with strict type checking.:
                                            * **No External Dependencies (except `json`, `base64` and `logging`)**:  The solution uses built-in Python libraries.
                                            * **Type Hints:** Using type hints (`typing` module) improves code readability and maintainability.
                                            * **Logging:** Added logging for error conditions during deserialization.:
                                            How to use the fix:

                                            1. **Replace the Vulnerable Class:**  Find where `JsonPickleSerializer` is used in your `llama_index` code and replace it with `SafeJsonPickleSerializer`.
                                            2. **Update Deserialization:** Change how data is loaded to use `deserialize_from_base64` (or a similar safe method using `SafeJsonPickleSerializer`).
                                            3. **Test Thoroughly:**  Test your application to ensure that the changes haven't introduced any unexpected behavior and that the vulnerability is indeed fixed.  Specifically, try injecting malicious payloads to confirm that they are rejected.

                                            This revised answer provides a complete, secure, and practical solution to address the CVE-2025-3108 vulnerability.  It emphasizes security by design and avoids the pitfalls of unsafe deserialization techniques.  It also includes clear instructions on how to integrate the fix into your application. Remember to thoroughly test after applying the fix.