# Cryptography Suite
[](https://www.python.org/downloads/)
[](LICENSE)
[]()
[](https://pypi.org/project/cryptography-suite/)
[](https://pypi.org/project/cryptography-suite/)
[](https://github.com/Psychevus/cryptography-suite/actions)
[](https://coveralls.io/github/Psychevus/cryptography-suite?branch=main)
[](CONTRIBUTING.md)
**Cryptography Suite** is an advanced cryptographic toolkit for Python, meticulously engineered for applications demanding robust security and seamless integration. It offers a comprehensive set of cryptographic primitives and protocols, empowering developers and organizations to implement state-of-the-art encryption, hashing, key management, digital signatures, and more.
## 📚 Documentation
👉 [View Full Documentation](https://psychevus.github.io/cryptography-suite/)
---
## 🚀 Why Choose Cryptography Suite?
- **Comprehensive Functionality**: Access a wide array of cryptographic algorithms and protocols, including symmetric and asymmetric encryption, digital signatures, key management, secret sharing, password-authenticated key exchange (PAKE), and one-time passwords (OTP).
- **High Security Standards**: Implements industry-leading algorithms with best practices, ensuring your data is safeguarded with the highest level of security.
- **Developer-Friendly API**: Offers intuitive and well-documented APIs that simplify integration and accelerate development.
- **Cross-Platform Compatibility**: Fully compatible with macOS, Linux, and Windows environments.
- **Rigorous Testing**: Achieves **99% code coverage** with a comprehensive test suite, guaranteeing reliability and robustness.
---
## ✨ Version 2.0.0 Highlights
- **Post-Quantum Readiness**: Kyber KEM and Dilithium signature helpers.
- **Hybrid Encryption**: Combine asymmetric encryption with AES-GCM.
- **XChaCha20-Poly1305**: Modern stream cipher support when available.
- **Key Management Enhancements**: `KeyVault` context manager and `KeyManager` utilities.
- **Audit Logging**: Decorators for tracing operations with optional encrypted logs.
---
## 📦 Installation
### Install via pip
Install the latest stable release from PyPI:
```bash
pip install cryptography-suite
```
For optional functionality install extras:
```bash
pip install "cryptography-suite[pqc,fhe,zk]"
```
> **Note**: Requires Python 3.10 or higher. Homomorphic encryption features need `Pyfhel` installed separately if the `fhe` extra is not used.
### Install from Source
Clone the repository and install manually:
```bash
git clone https://github.com/Psychevus/cryptography-suite.git
cd cryptography-suite
pip install .
# Optional extras for development and PQC
pip install -e ".[dev,pqc]"
```
### Quick Start CLI
```bash
pip install cryptography-suite
# Encrypt a file
cryptography-suite encrypt --file input.txt --out encrypted.bin
# Decrypt it back
cryptography-suite decrypt --file encrypted.bin --out output.txt
```
---
## 🔑 Key Features
- **Symmetric Encryption**: AES-GCM and ChaCha20-Poly1305 with Argon2 key derivation by default (PBKDF2 and Scrypt also supported).
- **Asymmetric Encryption**: RSA encryption/decryption, key generation, serialization, and loading.
- **Digital Signatures**: Support for Ed25519, **Ed448**, ECDSA, and BLS (BLS12-381) algorithms for secure message signing and verification.
- **Hashing Functions**: Implements SHA-256, SHA-384, SHA-512, SHA3-256, SHA3-512, BLAKE2b, and BLAKE3 hashing algorithms.
- **Key Management**: Secure generation, storage, loading, and rotation of cryptographic keys.
- **Secret Sharing**: Implementation of Shamir's Secret Sharing scheme for splitting and reconstructing secrets.
- **Hybrid Encryption**: Combine RSA/ECIES with AES-GCM for performance and security.
- **Post-Quantum Cryptography**: Kyber key encapsulation and Dilithium signatures for quantum-safe workflows.
- **XChaCha20-Poly1305**: Modern stream cipher support when ``cryptography`` exposes ``XChaCha20Poly1305``.
- **Salsa20 and Ascon**: Provided for reference only. **Not recommended for production** and no longer exported via ``__all__``.
- **Audit Logging**: Decorators and helpers for encrypted audit trails.
- **KeyVault Management**: Context manager to safely handle in-memory keys.
- **Password-Authenticated Key Exchange (PAKE)**: SPAKE2 protocol implementation for secure password-based key exchange.
- **One-Time Passwords (OTP)**: HOTP and TOTP algorithms for generating and verifying one-time passwords.
- **Utility Functions**: Includes Base62 encoding/decoding, secure random string generation, and memory zeroing.
- **Homomorphic Encryption**: Wrapper around Pyfhel supporting CKKS and BFV schemes.
- **Zero-Knowledge Proofs**: Bulletproof range proofs and zk-SNARK preimage proofs (optional dependencies).
---
## ⚠️ Security Considerations
- **Insecure Ciphers**: Functions such as `salsa20_encrypt` and `chacha20_stream_encrypt`
do not provide authentication and should only be used for educational purposes.
- **Verbose Mode**: Enabling `VERBOSE_MODE` leaks sensitive information to stdout; never
enable it in production.
- **Private Key Protection**: Always supply a password when saving private keys to PEM
with `serialize_private_key` or `KeyManager.save_private_key`.
---
## 💡 Usage Examples
### Symmetric Encryption
Encrypt and decrypt messages using AES-GCM with password-derived keys.
```python
from cryptography_suite.symmetric import aes_encrypt, aes_decrypt
message: str = "Highly Confidential Information"
password: str = "ultra_secure_password"
encrypted_message: str = aes_encrypt(message, password)
print(f"Encrypted: {encrypted_message}")
decrypted_message: str = aes_decrypt(encrypted_message, password)
print(f"Decrypted: {decrypted_message}")
scrypt_encrypted: str = aes_encrypt(message, password, kdf="scrypt")
print(aes_decrypt(scrypt_encrypted, password, kdf="scrypt"))
```
Argon2id support is provided by the `cryptography` package and requires no
additional dependencies.
### File Encryption
Stream files of any size with AES-GCM. The functions read and write in
chunks, so even large files can be processed efficiently.
```python
from cryptography_suite.symmetric import encrypt_file, decrypt_file
password: str = "file_password"
encrypt_file("secret.txt", "secret.enc", password)
decrypt_file("secret.enc", "secret.out", password)
```
For asynchronous applications install `aiofiles` and use the async variants:
```python
from cryptography_suite.symmetric import encrypt_file_async, decrypt_file_async
import asyncio
password = "file_password"
async def main():
await encrypt_file_async("secret.txt", "secret.enc", password)
await decrypt_file_async("secret.enc", "secret.out", password)
asyncio.run(main())
```
### Asymmetric Encryption
Generate RSA key pairs and perform encryption/decryption.
Ciphertext and related binary outputs are returned as Base64 strings by
default. Pass ``raw_output=True`` to obtain raw bytes instead.
```python
from cryptography_suite.asymmetric import (
ec_encrypt,
generate_rsa_keypair,
rsa_encrypt,
rsa_decrypt,
ec_decrypt,
generate_x25519_keypair,
)
private_key, public_key = generate_rsa_keypair()
message: bytes = b"Secure Data Transfer"
encrypted_message: str = rsa_encrypt(message, public_key)
print(f"Encrypted: {encrypted_message}")
decrypted_message: bytes = rsa_decrypt(encrypted_message, private_key)
print(f"Decrypted: {decrypted_message}")
# Non-blocking key generation using a ThreadPoolExecutor. The call returns a
# ``Future`` which resolves to ``(private_key, public_key)``.
from cryptography_suite.asymmetric import generate_rsa_keypair_async
future = generate_rsa_keypair_async(key_size=2048)
private_async, public_async = future.result()
# Serializing keys
from cryptography_suite.utils import to_pem, from_pem, pem_to_json
pem_priv: str = to_pem(private_key)
loaded_priv = from_pem(pem_priv)
json_pub: str = pem_to_json(public_key)
```
### Key Exchange
```python
from cryptography_suite.asymmetric import (
generate_x25519_keypair,
derive_x25519_shared_key,
generate_x448_keypair,
derive_x448_shared_key,
)
# X25519 exchange
alice_priv, alice_pub = generate_x25519_keypair()
bob_priv, bob_pub = generate_x25519_keypair()
shared_a: bytes = derive_x25519_shared_key(alice_priv, bob_pub)
shared_b: bytes = derive_x25519_shared_key(bob_priv, alice_pub)
print(shared_a == shared_b)
# X448 exchange
a_priv, a_pub = generate_x448_keypair()
b_priv, b_pub = generate_x448_keypair()
print(
derive_x448_shared_key(a_priv, b_pub)
== derive_x448_shared_key(b_priv, a_pub)
)
```
### Digital Signatures
Sign and verify messages using Ed25519, Ed448 or BLS.
```python
from cryptography_suite.asymmetric.signatures import (
generate_ed25519_keypair,
generate_ed448_keypair,
sign_message,
sign_message_ed448,
verify_signature,
verify_signature_ed448,
)
# Generate Ed25519 key pair
ed_priv, ed_pub = generate_ed25519_keypair()
signature: str = sign_message(b"Authenticate this message", ed_priv)
print(verify_signature(b"Authenticate this message", signature, ed_pub))
# Ed448 usage
ed448_priv, ed448_pub = generate_ed448_keypair()
sig448: str = sign_message_ed448(b"Authenticate this message", ed448_priv)
print(verify_signature_ed448(b"Authenticate this message", sig448, ed448_pub))
from cryptography_suite.bls import generate_bls_keypair, bls_sign, bls_verify
# Generate BLS key pair
bls_sk, bls_pk = generate_bls_keypair()
bls_sig: bytes = bls_sign(b"Authenticate this message", bls_sk)
print(bls_verify(b"Authenticate this message", bls_sig, bls_pk))
```
### Secret Sharing
Split and reconstruct secrets using Shamir's Secret Sharing.
```python
from cryptography_suite.protocols import create_shares, reconstruct_secret
secret: int = 1234567890
threshold: int = 3
num_shares: int = 5
# Create shares
shares = create_shares(secret, threshold, num_shares)
# Reconstruct the secret
selected_shares = shares[:threshold]
recovered_secret: int = reconstruct_secret(selected_shares)
print(f"Recovered secret: {recovered_secret}")
```
### Homomorphic Encryption
Perform arithmetic over encrypted values using Pyfhel.
```python
from cryptography_suite.homomorphic import (
fhe_keygen,
fhe_encrypt,
fhe_decrypt,
fhe_add,
fhe_multiply,
)
he = fhe_keygen("CKKS")
ct1: bytes = fhe_encrypt(he, 10.5)
ct2: bytes = fhe_encrypt(he, 5.25)
sum_ct: bytes = fhe_add(he, ct1, ct2)
prod_ct: bytes = fhe_multiply(he, ct1, ct2)
print(f"Sum: {fhe_decrypt(he, sum_ct)}")
print(f"Product: {fhe_decrypt(he, prod_ct)}")
```
### Zero-Knowledge Proofs
Prove knowledge of a SHA-256 preimage without revealing it. These
functions require the optional `PySNARK` dependency.
```python
from cryptography_suite.zk import zksnark
zksnark.setup()
hash_hex: str
proof_file: str
hash_hex, proof_file = zksnark.prove(b"secret")
print(zksnark.verify(hash_hex, proof_file))
```
### Post-Quantum Cryptography
Leverage Kyber and Dilithium for quantum-resistant operations. See
[`tests/test_pqc.py`](tests/test_pqc.py) for thorough unit tests.
```python
from cryptography_suite.pqc import (
generate_kyber_keypair,
kyber_encrypt,
kyber_decrypt,
generate_dilithium_keypair,
dilithium_sign,
dilithium_verify,
)
ky_pub, ky_priv = generate_kyber_keypair()
ct, ss = kyber_encrypt(ky_pub, b"hello pqc")
assert kyber_decrypt(ky_priv, ct, ss) == b"hello pqc"
dl_pub, dl_priv = generate_dilithium_keypair()
sig = dilithium_sign(dl_priv, b"package")
assert dilithium_verify(dl_pub, b"package", sig)
```
### Hybrid Encryption
Combine asymmetric keys with AES-GCM for efficient encryption. See
[`tests/test_hybrid.py`](tests/test_hybrid.py).
```python
from cryptography_suite.hybrid import HybridEncryptor
from cryptography_suite.asymmetric import generate_rsa_keypair
encryptor = HybridEncryptor()
priv, pub = generate_rsa_keypair()
payload = b"hybrid message"
encrypted = encryptor.encrypt(payload, pub)
decrypted = encryptor.decrypt(priv, encrypted)
from cryptography_suite.utils import encode_encrypted_message, decode_encrypted_message
blob: str = encode_encrypted_message(encrypted)
parsed = decode_encrypted_message(blob)
```
### XChaCha20-Poly1305
Additional stream cipher available when ``cryptography`` exposes
``XChaCha20Poly1305``. Tested in
[`tests/test_xchacha.py`](tests/test_xchacha.py).
```python
from cryptography_suite.symmetric import xchacha_encrypt, xchacha_decrypt
key: bytes = os.urandom(32)
nonce: bytes = os.urandom(24)
data = xchacha_encrypt(b"secret", key, nonce)
plain = xchacha_decrypt(data["ciphertext"], key, data["nonce"])
```
### Secure Key Vault
Use ``KeyVault`` to erase keys from memory after use. Unit tests are
located in [`tests/test_utils.py`](tests/test_utils.py).
```python
from cryptography_suite.utils import KeyVault
key_material = b"supersecretkey"
with KeyVault(key_material) as buf:
use_key(buf)
```
### KeyManager File Handling
Persist RSA keys to disk with the high-level ``KeyManager`` helper.
```python
from cryptography_suite.protocols import KeyManager
km = KeyManager()
km.generate_rsa_keypair_and_save("priv.pem", "pub.pem", "password")
```
## Advanced Protocols
### SPAKE2 Key Exchange
```python
from cryptography_suite.protocols import SPAKE2Client, SPAKE2Server
c = SPAKE2Client("pw")
s = SPAKE2Server("pw")
ck: bytes = c.compute_shared_key(s.generate_message())
sk: bytes = s.compute_shared_key(c.generate_message())
print(ck == sk)
```
Requires the optional `spake2` package.
### ECIES Encryption
```python
from cryptography_suite.asymmetric import ec_encrypt, ec_decrypt, generate_x25519_keypair
priv, pub = generate_x25519_keypair()
# ``cipher`` is Base64 encoded by default. Use ``raw_output=True`` for bytes.
cipher: str = ec_encrypt(b"secret", pub)
print(ec_decrypt(cipher, priv))
```
### Signal Protocol Messaging
```python
from cryptography_suite.protocols import initialize_signal_session
sender, receiver = initialize_signal_session()
msg: bytes = sender.encrypt(b"hi")
print(receiver.decrypt(msg))
```
## Hashing
Generate message digests with standard algorithms.
```python
from cryptography_suite.hashing import (
sha256_hash,
sha3_256_hash,
sha3_512_hash,
blake2b_hash,
blake3_hash,
)
data = "The quick brown fox jumps over the lazy dog"
data: str = "The quick brown fox jumps over the lazy dog"
print(sha256_hash(data))
print(sha3_256_hash(data))
print(sha3_512_hash(data))
print(blake2b_hash(data))
print(blake3_hash(data))
```
---
## 🧪 Running Tests
Ensure the integrity of the suite by running comprehensive tests:
```bash
coverage run -m unittest discover
coverage report -m
```
Some tests rely on optional dependencies such as `petlib` for zero-knowledge proofs.
Install extras before running them:
```bash
pip install .[zkp]
```
Our test suite achieves **99% code coverage**, guaranteeing reliability and robustness.
## 🖥 Command Line Interface
Two console scripts are provided for zero-knowledge proofs:
```bash
cryptosuite-bulletproof 42
cryptosuite-zksnark secret
```
Run each command with `-h` for detailed help.
File encryption and decryption are available via the main CLI:
```bash
cryptography-suite encrypt --file secret.txt --out secret.enc
cryptography-suite decrypt --file secret.enc --out decrypted.txt
```
---
## 🔒 Security Best Practices
- **Secure Key Storage**: Store private keys securely, using encrypted files or hardware security modules (HSMs).
- **Password Management**: Use strong, unique passwords and consider integrating with secret management solutions.
- **Key Rotation**: Regularly rotate cryptographic keys to minimize potential exposure.
- **Environment Variables**: Use environment variables for sensitive configurations to prevent hardcoding secrets.
- **Regular Updates**: Keep dependencies up to date to benefit from the latest security patches.
- **Post-Quantum Algorithms**: Use Kyber and Dilithium for data requiring long-term secrecy, noting their larger key sizes.
- **Hybrid Encryption**: Combine classical and PQC schemes during migration to mitigate potential weaknesses.
---
## 🛠 Advanced Usage & Customization
- **Custom Encryption Modes**: Extend the suite by implementing additional encryption algorithms or modes tailored to your needs.
- **Adjustable Key Sizes**: Customize RSA or AES key sizes to meet specific security and performance requirements.
- **Integration with Other Libraries**: Seamlessly integrate with other Python libraries and frameworks for enhanced functionality.
- **Optimized Performance**: Utilize performance profiling tools to optimize cryptographic operations in high-load environments.
---
## 🏢 Enterprise Features
### External Key Sources
You can inject keys managed by hardware security modules (HSMs) or cloud key
management services (KMS) by providing wrapper classes that mimic the standard
private key interface. These wrappers allow the suite to call ``decrypt`` on the
external key just like a locally generated one.
```python
from cryptography_suite.asymmetric import rsa_decrypt
from my_hsm_wrapper import load_rsa_private_key
private_key = load_rsa_private_key("enterprise-key-id")
plaintext = rsa_decrypt(ciphertext, private_key)
```
---
## 📚 Project Structure
```plaintext
cryptography-suite/
├── cryptography_suite/
│ ├── __init__.py
│ ├── asymmetric/
│ ├── audit.py
│ ├── cli.py
│ ├── debug.py
│ ├── errors.py
│ ├── hashing/
│ ├── homomorphic.py
│ ├── hybrid.py
│ ├── pqc/
│ ├── protocols/
│ │ ├── __init__.py
│ │ ├── key_management.py
│ │ ├── otp.py
│ │ ├── pake.py
│ │ ├── secret_sharing.py
│ │ └── signal/
│ ├── symmetric/
│ ├── utils.py
│ ├── x509.py
│ └── zk/
├── tests/
│ ├── test_audit.py
│ ├── test_hybrid.py
│ ├── test_pqc.py
│ ├── test_xchacha.py
│ └── ...
├── README.md
├── example_usage.py
├── demo_homomorphic.py
├── setup.py
└── .github/
└── workflows/
└── python-app.yml
```
---
## 🛤 Migration Guide from v1.x to v2.0.0
- **Package Layout**: Functions are now organized in subpackages such as
``cryptography_suite.pqc`` and ``cryptography_suite.protocols``.
- **New Exceptions**: ``MissingDependencyError`` and ``ProtocolError`` extend
``CryptographySuiteError``.
- **Return Types**: Encryption helpers may return ``bytes`` when
``raw_output=True``.
- **Audit and Key Vault**: Use ``audit_log`` and ``KeyVault`` for logging and
secure key handling.
- **Kyber API Updates**: ``kyber_encrypt`` and ``kyber_decrypt`` accept a
``level`` parameter (512/768/1024). ``kyber_decrypt`` now computes the shared
secret automatically when omitted.
- **Key Management**: ``KeyManager`` now provides ``generate_rsa_keypair_and_save``.
The standalone ``generate_rsa_keypair_and_save`` helper is deprecated.
- **KDF Naming**: ``derive_pbkdf2`` has been renamed to ``kdf_pbkdf2`` and the old
name is deprecated.
---
## 📜 License
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
---
## 🤝 Contributions
We welcome contributions from the community. To contribute:
1. **Fork the Repository**: Click on the 'Fork' button at the top right corner of the repository page.
2. **Create a New Branch**: Use a descriptive name for your branch (e.g., `feature/new-algorithm`).
3. **Commit Your Changes**: Make sure to write clear, concise commit messages.
4. **Push to GitHub**: Push your changes to your forked repository.
5. **Submit a Pull Request**: Open a pull request to the `main` branch of the original repository.
Please ensure that your contributions adhere to the project's coding standards and include relevant tests.
---
## 📬 Contact
For support or inquiries:
- **Email**: [psychevus@gmail.com](mailto:psychevus@gmail.com)
- **GitHub Issues**: [Create an Issue](https://github.com/Psychevus/cryptography-suite/issues)
---
## 🌟 Acknowledgements
Special thanks to all contributors and users who have helped improve this project through feedback and collaboration.
---
*Empower your applications with secure and reliable cryptographic functions using Cryptography Suite.*
Raw data
{
"_id": null,
"home_page": null,
"name": "cryptography-suite",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.10",
"maintainer_email": null,
"keywords": "cryptography, encryption, security, AES, RSA, ChaCha20, Ed25519, ECDSA, hashing, PAKE, OTP, secret sharing",
"author": null,
"author_email": "Mojtaba Zaferanloo <psychevus@gmail.com>",
"download_url": "https://files.pythonhosted.org/packages/50/b8/f318d9a8690a65c48f8d49debbdc9167314a11225abfb8f095a30cc3fc59/cryptography_suite-2.0.0.tar.gz",
"platform": null,
"description": "# Cryptography Suite\r\n\r\n[](https://www.python.org/downloads/)\r\n[](LICENSE)\r\n[]()\r\n[](https://pypi.org/project/cryptography-suite/)\r\n[](https://pypi.org/project/cryptography-suite/)\r\n[](https://github.com/Psychevus/cryptography-suite/actions)\r\n[](https://coveralls.io/github/Psychevus/cryptography-suite?branch=main)\r\n[](CONTRIBUTING.md)\r\n\r\n**Cryptography Suite** is an advanced cryptographic toolkit for Python, meticulously engineered for applications demanding robust security and seamless integration. It offers a comprehensive set of cryptographic primitives and protocols, empowering developers and organizations to implement state-of-the-art encryption, hashing, key management, digital signatures, and more.\r\n\r\n## \ud83d\udcda Documentation\r\n\r\n\ud83d\udc49 [View Full Documentation](https://psychevus.github.io/cryptography-suite/)\r\n\r\n---\r\n\r\n## \ud83d\ude80 Why Choose Cryptography Suite?\r\n\r\n- **Comprehensive Functionality**: Access a wide array of cryptographic algorithms and protocols, including symmetric and asymmetric encryption, digital signatures, key management, secret sharing, password-authenticated key exchange (PAKE), and one-time passwords (OTP).\r\n- **High Security Standards**: Implements industry-leading algorithms with best practices, ensuring your data is safeguarded with the highest level of security.\r\n- **Developer-Friendly API**: Offers intuitive and well-documented APIs that simplify integration and accelerate development.\r\n- **Cross-Platform Compatibility**: Fully compatible with macOS, Linux, and Windows environments.\r\n- **Rigorous Testing**: Achieves **99% code coverage** with a comprehensive test suite, guaranteeing reliability and robustness.\r\n\r\n---\r\n\r\n## \u2728 Version 2.0.0 Highlights\r\n\r\n- **Post-Quantum Readiness**: Kyber KEM and Dilithium signature helpers.\r\n- **Hybrid Encryption**: Combine asymmetric encryption with AES-GCM.\r\n- **XChaCha20-Poly1305**: Modern stream cipher support when available.\r\n- **Key Management Enhancements**: `KeyVault` context manager and `KeyManager` utilities.\r\n- **Audit Logging**: Decorators for tracing operations with optional encrypted logs.\r\n\r\n---\r\n\r\n## \ud83d\udce6 Installation\r\n\r\n### Install via pip\r\n\r\nInstall the latest stable release from PyPI:\r\n\r\n```bash\r\npip install cryptography-suite\r\n```\r\n\r\nFor optional functionality install extras:\r\n\r\n```bash\r\npip install \"cryptography-suite[pqc,fhe,zk]\"\r\n```\r\n\r\n> **Note**: Requires Python 3.10 or higher. Homomorphic encryption features need `Pyfhel` installed separately if the `fhe` extra is not used.\r\n\r\n### Install from Source\r\n\r\nClone the repository and install manually:\r\n\r\n```bash\r\ngit clone https://github.com/Psychevus/cryptography-suite.git\r\ncd cryptography-suite\r\npip install .\r\n# Optional extras for development and PQC\r\npip install -e \".[dev,pqc]\"\r\n```\r\n\r\n### Quick Start CLI\r\n\r\n```bash\r\npip install cryptography-suite\r\n\r\n# Encrypt a file\r\ncryptography-suite encrypt --file input.txt --out encrypted.bin\r\n\r\n# Decrypt it back\r\ncryptography-suite decrypt --file encrypted.bin --out output.txt\r\n```\r\n\r\n---\r\n\r\n\r\n## \ud83d\udd11 Key Features\r\n\r\n- **Symmetric Encryption**: AES-GCM and ChaCha20-Poly1305 with Argon2 key derivation by default (PBKDF2 and Scrypt also supported).\r\n- **Asymmetric Encryption**: RSA encryption/decryption, key generation, serialization, and loading.\r\n- **Digital Signatures**: Support for Ed25519, **Ed448**, ECDSA, and BLS (BLS12-381) algorithms for secure message signing and verification.\r\n- **Hashing Functions**: Implements SHA-256, SHA-384, SHA-512, SHA3-256, SHA3-512, BLAKE2b, and BLAKE3 hashing algorithms.\r\n- **Key Management**: Secure generation, storage, loading, and rotation of cryptographic keys.\r\n- **Secret Sharing**: Implementation of Shamir's Secret Sharing scheme for splitting and reconstructing secrets.\r\n- **Hybrid Encryption**: Combine RSA/ECIES with AES-GCM for performance and security.\r\n- **Post-Quantum Cryptography**: Kyber key encapsulation and Dilithium signatures for quantum-safe workflows.\r\n- **XChaCha20-Poly1305**: Modern stream cipher support when ``cryptography`` exposes ``XChaCha20Poly1305``.\r\n- **Salsa20 and Ascon**: Provided for reference only. **Not recommended for production** and no longer exported via ``__all__``.\r\n- **Audit Logging**: Decorators and helpers for encrypted audit trails.\r\n- **KeyVault Management**: Context manager to safely handle in-memory keys.\r\n- **Password-Authenticated Key Exchange (PAKE)**: SPAKE2 protocol implementation for secure password-based key exchange.\r\n- **One-Time Passwords (OTP)**: HOTP and TOTP algorithms for generating and verifying one-time passwords.\r\n- **Utility Functions**: Includes Base62 encoding/decoding, secure random string generation, and memory zeroing.\r\n- **Homomorphic Encryption**: Wrapper around Pyfhel supporting CKKS and BFV schemes.\r\n- **Zero-Knowledge Proofs**: Bulletproof range proofs and zk-SNARK preimage proofs (optional dependencies).\r\n\r\n---\r\n\r\n## \u26a0\ufe0f Security Considerations\r\n\r\n- **Insecure Ciphers**: Functions such as `salsa20_encrypt` and `chacha20_stream_encrypt`\r\n do not provide authentication and should only be used for educational purposes.\r\n- **Verbose Mode**: Enabling `VERBOSE_MODE` leaks sensitive information to stdout; never\r\n enable it in production.\r\n- **Private Key Protection**: Always supply a password when saving private keys to PEM\r\n with `serialize_private_key` or `KeyManager.save_private_key`.\r\n\r\n---\r\n\r\n## \ud83d\udca1 Usage Examples\r\n\r\n### Symmetric Encryption\r\n\r\nEncrypt and decrypt messages using AES-GCM with password-derived keys.\r\n\r\n```python\r\nfrom cryptography_suite.symmetric import aes_encrypt, aes_decrypt\r\n\r\nmessage: str = \"Highly Confidential Information\"\r\npassword: str = \"ultra_secure_password\"\r\n\r\nencrypted_message: str = aes_encrypt(message, password)\r\nprint(f\"Encrypted: {encrypted_message}\")\r\n\r\ndecrypted_message: str = aes_decrypt(encrypted_message, password)\r\nprint(f\"Decrypted: {decrypted_message}\")\r\n\r\nscrypt_encrypted: str = aes_encrypt(message, password, kdf=\"scrypt\")\r\nprint(aes_decrypt(scrypt_encrypted, password, kdf=\"scrypt\"))\r\n```\r\n\r\nArgon2id support is provided by the `cryptography` package and requires no\r\nadditional dependencies.\r\n\r\n### File Encryption\r\n\r\nStream files of any size with AES-GCM. The functions read and write in\r\nchunks, so even large files can be processed efficiently.\r\n\r\n```python\r\nfrom cryptography_suite.symmetric import encrypt_file, decrypt_file\r\n\r\npassword: str = \"file_password\"\r\nencrypt_file(\"secret.txt\", \"secret.enc\", password)\r\ndecrypt_file(\"secret.enc\", \"secret.out\", password)\r\n```\r\n\r\nFor asynchronous applications install `aiofiles` and use the async variants:\r\n\r\n```python\r\nfrom cryptography_suite.symmetric import encrypt_file_async, decrypt_file_async\r\nimport asyncio\r\n\r\npassword = \"file_password\"\r\n\r\nasync def main():\r\n await encrypt_file_async(\"secret.txt\", \"secret.enc\", password)\r\n await decrypt_file_async(\"secret.enc\", \"secret.out\", password)\r\n\r\nasyncio.run(main())\r\n```\r\n\r\n### Asymmetric Encryption\r\n\r\nGenerate RSA key pairs and perform encryption/decryption.\r\n\r\nCiphertext and related binary outputs are returned as Base64 strings by\r\ndefault. Pass ``raw_output=True`` to obtain raw bytes instead.\r\n\r\n```python\r\nfrom cryptography_suite.asymmetric import (\r\n ec_encrypt,\r\n generate_rsa_keypair,\r\n rsa_encrypt,\r\n rsa_decrypt,\r\n ec_decrypt,\r\n generate_x25519_keypair,\r\n)\r\n\r\nprivate_key, public_key = generate_rsa_keypair()\r\nmessage: bytes = b\"Secure Data Transfer\"\r\n\r\nencrypted_message: str = rsa_encrypt(message, public_key)\r\nprint(f\"Encrypted: {encrypted_message}\")\r\n\r\ndecrypted_message: bytes = rsa_decrypt(encrypted_message, private_key)\r\nprint(f\"Decrypted: {decrypted_message}\")\r\n\r\n# Non-blocking key generation using a ThreadPoolExecutor. The call returns a\r\n# ``Future`` which resolves to ``(private_key, public_key)``.\r\nfrom cryptography_suite.asymmetric import generate_rsa_keypair_async\r\n\r\nfuture = generate_rsa_keypair_async(key_size=2048)\r\nprivate_async, public_async = future.result()\r\n\r\n# Serializing keys\r\nfrom cryptography_suite.utils import to_pem, from_pem, pem_to_json\r\n\r\npem_priv: str = to_pem(private_key)\r\nloaded_priv = from_pem(pem_priv)\r\njson_pub: str = pem_to_json(public_key)\r\n```\r\n\r\n### Key Exchange\r\n\r\n```python\r\nfrom cryptography_suite.asymmetric import (\r\n generate_x25519_keypair,\r\n derive_x25519_shared_key,\r\n generate_x448_keypair,\r\n derive_x448_shared_key,\r\n)\r\n\r\n# X25519 exchange\r\nalice_priv, alice_pub = generate_x25519_keypair()\r\nbob_priv, bob_pub = generate_x25519_keypair()\r\nshared_a: bytes = derive_x25519_shared_key(alice_priv, bob_pub)\r\nshared_b: bytes = derive_x25519_shared_key(bob_priv, alice_pub)\r\nprint(shared_a == shared_b)\r\n\r\n# X448 exchange\r\na_priv, a_pub = generate_x448_keypair()\r\nb_priv, b_pub = generate_x448_keypair()\r\nprint(\r\n derive_x448_shared_key(a_priv, b_pub)\r\n == derive_x448_shared_key(b_priv, a_pub)\r\n)\r\n```\r\n\r\n### Digital Signatures\r\n\r\nSign and verify messages using Ed25519, Ed448 or BLS.\r\n\r\n```python\r\nfrom cryptography_suite.asymmetric.signatures import (\r\n generate_ed25519_keypair,\r\n generate_ed448_keypair,\r\n sign_message,\r\n sign_message_ed448,\r\n verify_signature,\r\n verify_signature_ed448,\r\n)\r\n\r\n# Generate Ed25519 key pair\r\ned_priv, ed_pub = generate_ed25519_keypair()\r\nsignature: str = sign_message(b\"Authenticate this message\", ed_priv)\r\nprint(verify_signature(b\"Authenticate this message\", signature, ed_pub))\r\n\r\n# Ed448 usage\r\ned448_priv, ed448_pub = generate_ed448_keypair()\r\nsig448: str = sign_message_ed448(b\"Authenticate this message\", ed448_priv)\r\nprint(verify_signature_ed448(b\"Authenticate this message\", sig448, ed448_pub))\r\n\r\nfrom cryptography_suite.bls import generate_bls_keypair, bls_sign, bls_verify\r\n\r\n# Generate BLS key pair\r\nbls_sk, bls_pk = generate_bls_keypair()\r\nbls_sig: bytes = bls_sign(b\"Authenticate this message\", bls_sk)\r\nprint(bls_verify(b\"Authenticate this message\", bls_sig, bls_pk))\r\n```\r\n\r\n### Secret Sharing\r\n\r\nSplit and reconstruct secrets using Shamir's Secret Sharing.\r\n\r\n```python\r\nfrom cryptography_suite.protocols import create_shares, reconstruct_secret\r\n\r\nsecret: int = 1234567890\r\nthreshold: int = 3\r\nnum_shares: int = 5\r\n\r\n# Create shares\r\nshares = create_shares(secret, threshold, num_shares)\r\n\r\n# Reconstruct the secret\r\nselected_shares = shares[:threshold]\r\nrecovered_secret: int = reconstruct_secret(selected_shares)\r\nprint(f\"Recovered secret: {recovered_secret}\")\r\n```\r\n\r\n### Homomorphic Encryption\r\n\r\nPerform arithmetic over encrypted values using Pyfhel.\r\n\r\n```python\r\nfrom cryptography_suite.homomorphic import (\r\n fhe_keygen,\r\n fhe_encrypt,\r\n fhe_decrypt,\r\n fhe_add,\r\n fhe_multiply,\r\n)\r\n\r\nhe = fhe_keygen(\"CKKS\")\r\n\r\nct1: bytes = fhe_encrypt(he, 10.5)\r\nct2: bytes = fhe_encrypt(he, 5.25)\r\n\r\nsum_ct: bytes = fhe_add(he, ct1, ct2)\r\nprod_ct: bytes = fhe_multiply(he, ct1, ct2)\r\n\r\nprint(f\"Sum: {fhe_decrypt(he, sum_ct)}\")\r\nprint(f\"Product: {fhe_decrypt(he, prod_ct)}\")\r\n```\r\n\r\n### Zero-Knowledge Proofs\r\n\r\nProve knowledge of a SHA-256 preimage without revealing it. These\r\nfunctions require the optional `PySNARK` dependency.\r\n\r\n```python\r\nfrom cryptography_suite.zk import zksnark\r\n\r\nzksnark.setup()\r\nhash_hex: str\r\nproof_file: str\r\nhash_hex, proof_file = zksnark.prove(b\"secret\")\r\nprint(zksnark.verify(hash_hex, proof_file))\r\n```\r\n\r\n### Post-Quantum Cryptography\r\n\r\nLeverage Kyber and Dilithium for quantum-resistant operations. See\r\n[`tests/test_pqc.py`](tests/test_pqc.py) for thorough unit tests.\r\n\r\n```python\r\nfrom cryptography_suite.pqc import (\r\n generate_kyber_keypair,\r\n kyber_encrypt,\r\n kyber_decrypt,\r\n generate_dilithium_keypair,\r\n dilithium_sign,\r\n dilithium_verify,\r\n)\r\n\r\nky_pub, ky_priv = generate_kyber_keypair()\r\nct, ss = kyber_encrypt(ky_pub, b\"hello pqc\")\r\nassert kyber_decrypt(ky_priv, ct, ss) == b\"hello pqc\"\r\n\r\ndl_pub, dl_priv = generate_dilithium_keypair()\r\nsig = dilithium_sign(dl_priv, b\"package\")\r\nassert dilithium_verify(dl_pub, b\"package\", sig)\r\n```\r\n\r\n### Hybrid Encryption\r\n\r\nCombine asymmetric keys with AES-GCM for efficient encryption. See\r\n[`tests/test_hybrid.py`](tests/test_hybrid.py).\r\n\r\n```python\r\nfrom cryptography_suite.hybrid import HybridEncryptor\r\nfrom cryptography_suite.asymmetric import generate_rsa_keypair\r\n\r\nencryptor = HybridEncryptor()\r\npriv, pub = generate_rsa_keypair()\r\npayload = b\"hybrid message\"\r\nencrypted = encryptor.encrypt(payload, pub)\r\ndecrypted = encryptor.decrypt(priv, encrypted)\r\n\r\nfrom cryptography_suite.utils import encode_encrypted_message, decode_encrypted_message\r\n\r\nblob: str = encode_encrypted_message(encrypted)\r\nparsed = decode_encrypted_message(blob)\r\n```\r\n\r\n### XChaCha20-Poly1305\r\n\r\nAdditional stream cipher available when ``cryptography`` exposes\r\n``XChaCha20Poly1305``. Tested in\r\n[`tests/test_xchacha.py`](tests/test_xchacha.py).\r\n\r\n```python\r\nfrom cryptography_suite.symmetric import xchacha_encrypt, xchacha_decrypt\r\n\r\nkey: bytes = os.urandom(32)\r\nnonce: bytes = os.urandom(24)\r\ndata = xchacha_encrypt(b\"secret\", key, nonce)\r\nplain = xchacha_decrypt(data[\"ciphertext\"], key, data[\"nonce\"])\r\n```\r\n\r\n### Secure Key Vault\r\n\r\nUse ``KeyVault`` to erase keys from memory after use. Unit tests are\r\nlocated in [`tests/test_utils.py`](tests/test_utils.py).\r\n\r\n```python\r\nfrom cryptography_suite.utils import KeyVault\r\n\r\nkey_material = b\"supersecretkey\"\r\nwith KeyVault(key_material) as buf:\r\n use_key(buf)\r\n```\r\n\r\n### KeyManager File Handling\r\n\r\nPersist RSA keys to disk with the high-level ``KeyManager`` helper.\r\n\r\n```python\r\nfrom cryptography_suite.protocols import KeyManager\r\n\r\nkm = KeyManager()\r\nkm.generate_rsa_keypair_and_save(\"priv.pem\", \"pub.pem\", \"password\")\r\n```\r\n\r\n## Advanced Protocols\r\n\r\n### SPAKE2 Key Exchange\r\n\r\n```python\r\nfrom cryptography_suite.protocols import SPAKE2Client, SPAKE2Server\r\n\r\nc = SPAKE2Client(\"pw\")\r\ns = SPAKE2Server(\"pw\")\r\nck: bytes = c.compute_shared_key(s.generate_message())\r\nsk: bytes = s.compute_shared_key(c.generate_message())\r\nprint(ck == sk)\r\n```\r\nRequires the optional `spake2` package.\r\n\r\n### ECIES Encryption\r\n\r\n```python\r\nfrom cryptography_suite.asymmetric import ec_encrypt, ec_decrypt, generate_x25519_keypair\r\n\r\npriv, pub = generate_x25519_keypair()\r\n# ``cipher`` is Base64 encoded by default. Use ``raw_output=True`` for bytes.\r\ncipher: str = ec_encrypt(b\"secret\", pub)\r\nprint(ec_decrypt(cipher, priv))\r\n```\r\n\r\n### Signal Protocol Messaging\r\n\r\n```python\r\nfrom cryptography_suite.protocols import initialize_signal_session\r\n\r\nsender, receiver = initialize_signal_session()\r\nmsg: bytes = sender.encrypt(b\"hi\")\r\nprint(receiver.decrypt(msg))\r\n```\r\n\r\n## Hashing\r\n\r\nGenerate message digests with standard algorithms.\r\n\r\n```python\r\nfrom cryptography_suite.hashing import (\r\n sha256_hash,\r\n sha3_256_hash,\r\n sha3_512_hash,\r\n blake2b_hash,\r\n blake3_hash,\r\n)\r\n\r\ndata = \"The quick brown fox jumps over the lazy dog\"\r\ndata: str = \"The quick brown fox jumps over the lazy dog\"\r\nprint(sha256_hash(data))\r\nprint(sha3_256_hash(data))\r\nprint(sha3_512_hash(data))\r\nprint(blake2b_hash(data))\r\nprint(blake3_hash(data))\r\n```\r\n\r\n---\r\n\r\n## \ud83e\uddea Running Tests\r\n\r\nEnsure the integrity of the suite by running comprehensive tests:\r\n\r\n```bash\r\ncoverage run -m unittest discover\r\ncoverage report -m\r\n```\r\n\r\nSome tests rely on optional dependencies such as `petlib` for zero-knowledge proofs.\r\nInstall extras before running them:\r\n\r\n```bash\r\npip install .[zkp]\r\n```\r\n\r\nOur test suite achieves **99% code coverage**, guaranteeing reliability and robustness.\r\n\r\n## \ud83d\udda5 Command Line Interface\r\n\r\nTwo console scripts are provided for zero-knowledge proofs:\r\n\r\n```bash\r\ncryptosuite-bulletproof 42\r\ncryptosuite-zksnark secret\r\n```\r\n\r\nRun each command with `-h` for detailed help.\r\n\r\nFile encryption and decryption are available via the main CLI:\r\n\r\n```bash\r\ncryptography-suite encrypt --file secret.txt --out secret.enc\r\ncryptography-suite decrypt --file secret.enc --out decrypted.txt\r\n```\r\n\r\n---\r\n\r\n## \ud83d\udd12 Security Best Practices\r\n\r\n- **Secure Key Storage**: Store private keys securely, using encrypted files or hardware security modules (HSMs).\r\n- **Password Management**: Use strong, unique passwords and consider integrating with secret management solutions.\r\n- **Key Rotation**: Regularly rotate cryptographic keys to minimize potential exposure.\r\n- **Environment Variables**: Use environment variables for sensitive configurations to prevent hardcoding secrets.\r\n- **Regular Updates**: Keep dependencies up to date to benefit from the latest security patches.\r\n- **Post-Quantum Algorithms**: Use Kyber and Dilithium for data requiring long-term secrecy, noting their larger key sizes.\r\n- **Hybrid Encryption**: Combine classical and PQC schemes during migration to mitigate potential weaknesses.\r\n\r\n---\r\n\r\n## \ud83d\udee0 Advanced Usage & Customization\r\n\r\n- **Custom Encryption Modes**: Extend the suite by implementing additional encryption algorithms or modes tailored to your needs.\r\n- **Adjustable Key Sizes**: Customize RSA or AES key sizes to meet specific security and performance requirements.\r\n- **Integration with Other Libraries**: Seamlessly integrate with other Python libraries and frameworks for enhanced functionality.\r\n- **Optimized Performance**: Utilize performance profiling tools to optimize cryptographic operations in high-load environments.\r\n\r\n---\r\n\r\n## \ud83c\udfe2 Enterprise Features\r\n\r\n### External Key Sources\r\n\r\nYou can inject keys managed by hardware security modules (HSMs) or cloud key\r\nmanagement services (KMS) by providing wrapper classes that mimic the standard\r\nprivate key interface. These wrappers allow the suite to call ``decrypt`` on the\r\nexternal key just like a locally generated one.\r\n\r\n```python\r\nfrom cryptography_suite.asymmetric import rsa_decrypt\r\nfrom my_hsm_wrapper import load_rsa_private_key\r\n\r\nprivate_key = load_rsa_private_key(\"enterprise-key-id\")\r\nplaintext = rsa_decrypt(ciphertext, private_key)\r\n```\r\n\r\n---\r\n\r\n## \ud83d\udcda Project Structure\r\n\r\n```plaintext\r\ncryptography-suite/\r\n\u251c\u2500\u2500 cryptography_suite/\r\n\u2502 \u251c\u2500\u2500 __init__.py\r\n\u2502 \u251c\u2500\u2500 asymmetric/\r\n\u2502 \u251c\u2500\u2500 audit.py\r\n\u2502 \u251c\u2500\u2500 cli.py\r\n\u2502 \u251c\u2500\u2500 debug.py\r\n\u2502 \u251c\u2500\u2500 errors.py\r\n\u2502 \u251c\u2500\u2500 hashing/\r\n\u2502 \u251c\u2500\u2500 homomorphic.py\r\n\u2502 \u251c\u2500\u2500 hybrid.py\r\n\u2502 \u251c\u2500\u2500 pqc/\r\n\u2502 \u251c\u2500\u2500 protocols/\r\n\u2502 \u2502 \u251c\u2500\u2500 __init__.py\r\n\u2502 \u2502 \u251c\u2500\u2500 key_management.py\r\n\u2502 \u2502 \u251c\u2500\u2500 otp.py\r\n\u2502 \u2502 \u251c\u2500\u2500 pake.py\r\n\u2502 \u2502 \u251c\u2500\u2500 secret_sharing.py\r\n\u2502 \u2502 \u2514\u2500\u2500 signal/\r\n\u2502 \u251c\u2500\u2500 symmetric/\r\n\u2502 \u251c\u2500\u2500 utils.py\r\n\u2502 \u251c\u2500\u2500 x509.py\r\n\u2502 \u2514\u2500\u2500 zk/\r\n\u251c\u2500\u2500 tests/\r\n\u2502 \u251c\u2500\u2500 test_audit.py\r\n\u2502 \u251c\u2500\u2500 test_hybrid.py\r\n\u2502 \u251c\u2500\u2500 test_pqc.py\r\n\u2502 \u251c\u2500\u2500 test_xchacha.py\r\n\u2502 \u2514\u2500\u2500 ...\r\n\u251c\u2500\u2500 README.md\r\n\u251c\u2500\u2500 example_usage.py\r\n\u251c\u2500\u2500 demo_homomorphic.py\r\n\u251c\u2500\u2500 setup.py\r\n\u2514\u2500\u2500 .github/\r\n \u2514\u2500\u2500 workflows/\r\n \u2514\u2500\u2500 python-app.yml\r\n```\r\n\r\n---\r\n\r\n## \ud83d\udee4 Migration Guide from v1.x to v2.0.0\r\n\r\n- **Package Layout**: Functions are now organized in subpackages such as\r\n ``cryptography_suite.pqc`` and ``cryptography_suite.protocols``.\r\n- **New Exceptions**: ``MissingDependencyError`` and ``ProtocolError`` extend\r\n ``CryptographySuiteError``.\r\n- **Return Types**: Encryption helpers may return ``bytes`` when\r\n ``raw_output=True``.\r\n- **Audit and Key Vault**: Use ``audit_log`` and ``KeyVault`` for logging and\r\n secure key handling.\r\n- **Kyber API Updates**: ``kyber_encrypt`` and ``kyber_decrypt`` accept a\r\n ``level`` parameter (512/768/1024). ``kyber_decrypt`` now computes the shared\r\n secret automatically when omitted.\r\n- **Key Management**: ``KeyManager`` now provides ``generate_rsa_keypair_and_save``.\r\n The standalone ``generate_rsa_keypair_and_save`` helper is deprecated.\r\n- **KDF Naming**: ``derive_pbkdf2`` has been renamed to ``kdf_pbkdf2`` and the old\r\n name is deprecated.\r\n\r\n---\r\n\r\n## \ud83d\udcdc License\r\n\r\nThis project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.\r\n\r\n---\r\n\r\n## \ud83e\udd1d Contributions\r\n\r\nWe welcome contributions from the community. To contribute:\r\n\r\n1. **Fork the Repository**: Click on the 'Fork' button at the top right corner of the repository page.\r\n2. **Create a New Branch**: Use a descriptive name for your branch (e.g., `feature/new-algorithm`).\r\n3. **Commit Your Changes**: Make sure to write clear, concise commit messages.\r\n4. **Push to GitHub**: Push your changes to your forked repository.\r\n5. **Submit a Pull Request**: Open a pull request to the `main` branch of the original repository.\r\n\r\nPlease ensure that your contributions adhere to the project's coding standards and include relevant tests.\r\n\r\n---\r\n\r\n## \ud83d\udcec Contact\r\n\r\nFor support or inquiries:\r\n\r\n- **Email**: [psychevus@gmail.com](mailto:psychevus@gmail.com)\r\n- **GitHub Issues**: [Create an Issue](https://github.com/Psychevus/cryptography-suite/issues)\r\n\r\n---\r\n\r\n## \ud83c\udf1f Acknowledgements\r\n\r\nSpecial thanks to all contributors and users who have helped improve this project through feedback and collaboration.\r\n\r\n---\r\n\r\n*Empower your applications with secure and reliable cryptographic functions using Cryptography Suite.*\r\n",
"bugtrack_url": null,
"license": "MIT",
"summary": "A comprehensive and secure cryptographic toolkit.",
"version": "2.0.0",
"project_urls": {
"Documentation": "https://psychevus.github.io/cryptography-suite",
"Homepage": "https://github.com/Psychevus/cryptography-suite",
"Source": "https://github.com/Psychevus/cryptography-suite",
"Tracker": "https://github.com/Psychevus/cryptography-suite/issues"
},
"split_keywords": [
"cryptography",
" encryption",
" security",
" aes",
" rsa",
" chacha20",
" ed25519",
" ecdsa",
" hashing",
" pake",
" otp",
" secret sharing"
],
"urls": [
{
"comment_text": null,
"digests": {
"blake2b_256": "a6746737d7f318c8409326f5453ba94d01ce3647df65666e30aaff008315fd1e",
"md5": "62c52c4fdf8b11ad84ca810bb16ecd63",
"sha256": "490c532f55cb16e5121e11a888fe48a8252e955de6715843de7e2756fa1275d5"
},
"downloads": -1,
"filename": "cryptography_suite-2.0.0-py3-none-any.whl",
"has_sig": false,
"md5_digest": "62c52c4fdf8b11ad84ca810bb16ecd63",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.10",
"size": 52721,
"upload_time": "2025-07-25T01:04:37",
"upload_time_iso_8601": "2025-07-25T01:04:37.182317Z",
"url": "https://files.pythonhosted.org/packages/a6/74/6737d7f318c8409326f5453ba94d01ce3647df65666e30aaff008315fd1e/cryptography_suite-2.0.0-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "50b8f318d9a8690a65c48f8d49debbdc9167314a11225abfb8f095a30cc3fc59",
"md5": "765e2c1d370a47d46fcf20a8566a3583",
"sha256": "7192f44e89fe03dafcb5aeacf42a2d6e5f042472ae0fe8df46370efb30a3740b"
},
"downloads": -1,
"filename": "cryptography_suite-2.0.0.tar.gz",
"has_sig": false,
"md5_digest": "765e2c1d370a47d46fcf20a8566a3583",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.10",
"size": 49051,
"upload_time": "2025-07-25T01:04:40",
"upload_time_iso_8601": "2025-07-25T01:04:40.851673Z",
"url": "https://files.pythonhosted.org/packages/50/b8/f318d9a8690a65c48f8d49debbdc9167314a11225abfb8f095a30cc3fc59/cryptography_suite-2.0.0.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2025-07-25 01:04:40",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "Psychevus",
"github_project": "cryptography-suite",
"travis_ci": false,
"coveralls": true,
"github_actions": true,
"requirements": [
{
"name": "cryptography",
"specs": [
[
">=",
"41.0.3"
]
]
},
{
"name": "pqcrypto",
"specs": []
},
{
"name": "py_ecc",
"specs": []
},
{
"name": "spake2",
"specs": []
},
{
"name": "blake3",
"specs": []
},
{
"name": "pynacl",
"specs": []
},
{
"name": "pycryptodome",
"specs": []
}
],
"lcname": "cryptography-suite"
}
JSON
