CVE-2025-63675: Netinvent Cryptidy RCE Vulnerability

CVE-2025-63675 Overview

CVE-2025-63675 is an insecure deserialization vulnerability in the cryptidy Python library through version 1.2.4 that allows remote code execution via untrusted data. The vulnerability exists because the library uses pickle.loads to deserialize data in the aes_decrypt_message function within symmetric_encryption.py, enabling attackers to execute arbitrary code when malicious serialized objects are processed.

Critical Impact

Attackers can achieve remote code execution by supplying crafted pickle payloads to applications using the cryptidy library's AES decryption functionality, potentially leading to full system compromise.

Affected Products

• netinvent cryptidy versions through 1.2.4
• Python applications utilizing cryptidy for symmetric encryption operations
• Systems processing untrusted encrypted data through the cryptidy library

Discovery Timeline

• 2025-10-31 - CVE-2025-63675 published to NVD
• 2025-12-08 - Last updated in NVD database

Technical Details for CVE-2025-63675

Vulnerability Analysis

This vulnerability is classified as CWE-502 (Deserialization of Untrusted Data), a well-known security weakness in Python applications. The cryptidy library's aes_decrypt_message function in symmetric_encryption.py uses Python's native pickle.loads function to deserialize decrypted message content. Python's pickle module is inherently unsafe when used with untrusted data, as it can execute arbitrary code during the deserialization process.

When an application using cryptidy decrypts data from an untrusted source, the pickle deserialization occurs automatically as part of the decryption workflow. An attacker who can supply encrypted content to the target application—even without knowing the encryption key—may be able to exploit race conditions or key compromise scenarios. More critically, if the attacker has access to the encryption key or can manipulate the encrypted data stream, they can craft malicious pickle payloads that execute arbitrary Python code upon deserialization.

Root Cause

The root cause of this vulnerability is the use of Python's pickle.loads function to deserialize data received from potentially untrusted sources. The vulnerable code path exists in symmetric_encryption.py at lines 220-238, where the aes_decrypt_message function processes decrypted content through pickle deserialization without any validation or sandboxing.

Python's pickle module documentation explicitly warns against loading data from untrusted sources, as the deserialization process can instantiate arbitrary objects and execute code defined in the __reduce__ method of serialized classes. This design flaw allows attackers to create serialized payloads that execute system commands, establish reverse shells, or perform other malicious actions when deserialized.

Attack Vector

The attack vector is network-based and requires user interaction where the victim application must process attacker-controlled encrypted data. An attacker can exploit this vulnerability through several scenarios:

1. Man-in-the-Middle Attacks: Intercepting and replacing encrypted communications between systems using cryptidy
2. Data Injection: Supplying malicious encrypted payloads through API endpoints, file uploads, or message queues that use cryptidy for decryption
3. Compromised Key Scenarios: When encryption keys are shared or compromised, attackers can craft properly encrypted malicious payloads

The attack does not require authentication and can be executed remotely. Technical details of the vulnerable code can be reviewed in the GitHub Cryptidy Code Review.

Detection Methods for CVE-2025-63675

Indicators of Compromise

• Unusual process spawning from Python applications using cryptidy, particularly shell processes or network connections
• Unexpected system calls or file system modifications originating from the application's process tree
• Network connections to unknown external hosts from processes that should only perform local cryptographic operations
• Error logs indicating pickle deserialization failures with unusual object types

Detection Strategies

• Monitor for pickle.loads calls in application logs that process data from external or untrusted sources
• Implement application-level logging to track decryption operations and flag anomalous payload sizes or structures
• Deploy runtime application self-protection (RASP) solutions to detect and block suspicious deserialization patterns
• Use static code analysis tools to identify usage of cryptidy versions 1.2.4 and earlier in codebases

Monitoring Recommendations

• Enable verbose logging for applications using cryptidy to capture decryption operation metadata
• Configure SIEM rules to alert on process execution chains originating from Python applications that handle encrypted data
• Monitor software composition analysis (SCA) tools for alerts on vulnerable cryptidy versions in development and production environments
• Implement network segmentation monitoring to detect unexpected outbound connections from affected applications

How to Mitigate CVE-2025-63675

Immediate Actions Required

• Audit all applications for usage of netinvent cryptidy versions through 1.2.4
• Review input sources for cryptidy decryption operations and implement additional validation layers
• Consider replacing cryptidy with alternative encryption libraries that do not use pickle for serialization
• Isolate applications using vulnerable cryptidy versions in network segments with restricted outbound access

Patch Information

No vendor patch information is currently available. Organizations should monitor the GitHub Cryptidy Analysis repository for security updates and alternative recommendations. Until a patch is released, consider implementing workarounds or migrating to secure alternatives.

Workarounds

• Replace pickle serialization with safer alternatives such as JSON for data that does not require complex object serialization
• Implement input validation and integrity checks before decrypted data reaches deserialization functions
• Deploy application sandboxing using containers or virtual environments to limit the impact of potential code execution
• Use network-level controls to restrict what compromised applications can access if exploitation occurs

Organizations should implement secure deserialization practices using JSON or other safe serialization formats. For applications requiring pickle functionality, consider implementing signature verification on serialized data before deserialization.