M2Crypto

0.47.0 · maintenance · verified Thu Apr 16

M2Crypto is a comprehensive cryptography and SSL toolkit for Python, acting as a wrapper around the well-established OpenSSL library via SWIG. It provides functionalities for RSA, DSA, DH, HMACs, message digests, symmetric ciphers including AES, and TLS for client and server implementations. The library is currently in maintenance mode, with its developers recommending migration to more modern alternatives like PyCA/cryptography. The latest version, 0.47.0, was released on February 8, 2026. While not on a fixed schedule, releases appear periodically.

Common errors

```
error: command 'swig.exe' failed: None
```
cause SWIG (Simplified Wrapper and Interface Generator) is not installed or not in the system's PATH, or an incompatible version is being used.

fix Install SWIG on your system (e.g., `sudo apt-get install swig` or via Chocolatey on Windows: `choco install -y swig`). For M2Crypto 0.47.0+, ensure SWIG 4.0+ is installed, especially for Python 3.12+.
```
error: subprocess-exited-with-error
... running setup.py install for M2Crypto ... error
```
cause This generic error during `pip install` typically indicates missing OpenSSL development headers, SWIG, or C/C++ build tools required to compile M2Crypto's C extensions.

fix Install necessary build tools (e.g., `build-essential` on Debian/Ubuntu, C++ Build Tools on Windows), OpenSSL development headers (e.g., `libssl-dev` or `openssl-devel`), and SWIG before running `pip install M2Crypto`.
```
ImportError: No module named M2Crypto
```
cause The M2Crypto library was not successfully installed, or the Python interpreter cannot find it in its `sys.path`. This can happen if the installation failed silently or if C extensions were not built.

fix Verify successful installation by trying `pip show M2Crypto`. If not installed, re-attempt installation after ensuring all system dependencies (OpenSSL-dev, SWIG) are met. If installed, check your Python environment's `sys.path`.
```
AttributeError: module 'M2Crypto' has no attribute 'X509'
```
cause This error can occur if you're attempting to access a submodule (like X509) using `M2Crypto.X509` without it being explicitly imported into the `M2Crypto` namespace, or in older versions/specific installation contexts.

fix Use explicit imports for the required modules, e.g., `from M2Crypto import X509`. This ensures the module is loaded and its attributes are directly available.
```
SyntaxError: invalid syntax (when trying to run an application using M2Crypto)
```
cause While M2Crypto 0.47.0 supports Python 3.6+, older versions of M2Crypto (or legacy code written for Python 2) might be incompatible with the Python interpreter version being used.

fix Ensure that the version of M2Crypto installed is compatible with your Python interpreter version. If using older code, consider porting it to use a modern M2Crypto version compatible with your Python 3 environment, or migrate to `cryptography`.

Warnings

deprecated M2Crypto is officially in maintenance mode. Developers recommend migrating to actively developed and more modern alternatives like PyCA/cryptography for new projects or existing applications.
Fix: For new projects, consider PyCA/cryptography (`pip install cryptography`). For existing projects, consult M2Crypto's documentation on migration paths.
breaking Version 0.47.0 (and newer) no longer includes SWIG generated files in the distribution. This means `swig` must be installed on your system when installing M2Crypto, with SWIG 4.0+ being required for Python 3.12+.
Fix: Ensure SWIG (version 4.0 or newer for Python 3.12+) is installed globally or in your build environment before running `pip install M2Crypto`.
breaking All support for Python's `asyncore` module, `contrib/dispatcher.py`, `M2Crypto/SSL/ssl_dispatcher.py`, and `ZServerSSL` has been removed in M2Crypto 0.47.0 to align with its removal in Python 3.12+.
Fix: Applications relying on `asyncore` or related M2Crypto modules for asynchronous SSL operations must refactor their code to use more modern asynchronous frameworks (e.g., `asyncio`) or different SSL libraries if targeting M2Crypto 0.47.0+ with Python 3.12+.
gotcha Installation of M2Crypto often requires system-level development headers for OpenSSL and the SWIG utility, which can be challenging, especially on Windows or minimal Linux environments.
Fix: Install `openssl-devel` (or equivalent) and `swig` via your system's package manager before attempting `pip install M2Crypto`. On Windows, manual compilation or pre-built wheels from other projects might be necessary if `pip install` fails.
gotcha M2Crypto, due to its direct interfacing with OpenSSL's C API, can encounter memory leaks or segmentation faults if objects are not freed correctly across the Python/C boundary, or due to incompatibilities with different OpenSSL versions.
Fix: Handle M2Crypto objects carefully, ensuring proper lifecycle management. Keep OpenSSL and M2Crypto versions compatible. Regularly test your application for memory leaks, especially when dealing with high-volume cryptographic operations.

Install

pip install M2Crypto Basic installation
sudo apt-get install python3-dev libssl-dev swig pip install M2Crypto Debian/Ubuntu with build dependencies
sudo yum install python3-devel openssl-devel swig pip install M2Crypto RHEL/CentOS with build dependencies

Imports

RSA
wrong:
```
import M2Crypto.RSA
```
correct:
```
from M2Crypto import RSA
```
Many M2Crypto modules are designed to be imported directly from the M2Crypto package, rather than as submodules, to ensure attributes are correctly resolved.
SSL
wrong:
```
import M2Crypto.SSL
```
correct:
```
from M2Crypto import SSL
```
Similar to RSA, direct import from M2Crypto is the standard and recommended practice.
X509
wrong:
```
import M2Crypto.X509
```
correct:
```
from M2Crypto import X509
```
Older patterns like `import M2Crypto` followed by `M2Crypto.X509` may lead to 'M2Crypto has no attributes' errors in some contexts, especially when not fully installed or with specific runtime environments.

Quickstart

This quickstart demonstrates basic RSA key generation, encryption, and decryption using M2Crypto. It generates a 2048-bit RSA key pair, encrypts a simple message using PKCS1 OAEP padding with the public key, and then decrypts it using the private key. Note that messages should be bytes for cryptographic operations.

from M2Crypto import RSA

# Generate RSA key pairs
rsa_key = RSA.gen_key(2048, 65537)

# Message to encrypt
message = b"Hello, M2Crypto!"

# Encrypt a message using the public key
ciphertext = rsa_key.public_encrypt(message, RSA.pkcs1_oaep_padding)
print(f"Ciphertext: {ciphertext.hex()}")

# Decrypt the message using the private key
decrypted = rsa_key.private_decrypt(ciphertext, RSA.pkcs1_oaep_padding)
print(f"Decrypted: {decrypted.decode()}")

view raw JSON →