Pure-Python, zero-dependency speed-up across every hot path. No public API,
error-semantics or security change.
Measured (interleaved A/B min-of-N, idle 16-core, 1 KiB payload):
Base64 decode 21.98x
Base58 encode 8.01x
ChaCha20-Poly1305 3.54x
XChaCha20-Poly1305 3.28x
Base64 encode 2.98x
AES-256-GCM (enc) 2.25x (dec) 2.26x
AES-GCM-SIV enc 2.06x
AES-256 CTR/ECB/CBC 2.01x / 1.96x / 1.88x
AES single block 1.87x
Poly1305 MAC 1.41x
Ed25519 sign 1.41x
X25519 base 1.19x
BLAKE2b / SHA3-512 / SHAKE128 1.34x / 1.33x / 1.30x
=> 24 improved, 3 unchanged, 0 regressed.
Techniques (all pure Python):
- code-generated, fully unrolled AES round function and Keccak-f[1600]
- big-integer bulk operations for GHASH, POLYVAL, buffer XOR, Base64 pack
- precomputed lookup tables (AES T-tables, GHASH/POLYVAL 4-bit windows)
- branch-free constant-time selection in Ed25519 scan and X25519 ladder
- lazy modular reduction in X25519 field arithmetic
- batched Base58/Base64 processing
- inlined inner loops in AEAD assembly and the SHA-2 message schedule
Verification:
- full test suite: 639 passed, 1 skipped, 0 failed
- all FIPS / RFC / NIST vectors reproduce byte-for-byte
- differential probe of 1266 deterministic inputs: identical
(one unreachable private-helper edge case, no caller can reach it)
- public API signature comparison: 0 removals, 0 changes
- independent security regression suite: 35 / 35
Also adds docs/benchmark.md, bench/benchmark.py and the v3.2.1 documentation.
16 KiB
Benchmark
Performance reference for purepycrypto v3.2.1.
⚠️ Read this first.
purepycryptois a pure-Python implementation. Every primitive is written in Python, with no C extension and no native dependency. As a result it is typically 100x-1000x slower than C-backed libraries (OpenSSL,pycryptodome,cryptography).These numbers are published to be honest about the trade-off, not to compete on throughput. They are useful for capacity planning: they tell you which parameters are realistic in pure Python and which are not.
0. v3.2.1 optimization results
v3.2.1 is a pure optimization release. Every hot path was reworked while keeping the public API, the error semantics and the security properties unchanged. No algorithm was replaced by a C-backed shortcut: the library is still 100% pure Python, zero dependencies.
0.1 Measured speed-ups (v3.2.0 -> v3.2.1)
Measured with an interleaved A/B, min-of-N harness on an idle 16-core machine (same process loads both the old and the new package, alternates them every round, and keeps the fastest run of each to defeat scheduler noise).
| Operation | v3.2.0 | v3.2.1 | Speed-up |
|---|---|---|---|
| Base64 decode | 135.6 us | 6.17 us | 21.98x |
| Base58 encode | 1022.1 us | 127.6 us | 8.01x |
| Base58 decode | 398.1 us | 100.1 us | 3.98x |
| ChaCha20-Poly1305 encrypt | 978.8 us | 276.6 us | 3.54x |
| XChaCha20-Poly1305 encrypt | 1034.9 us | 315.2 us | 3.28x |
| Base64 encode | 159.3 us | 53.4 us | 2.98x |
| AES-256-GCM decrypt | 1841.2 us | 816.4 us | 2.26x |
| AES-256-GCM encrypt | 1835.5 us | 816.7 us | 2.25x |
| AES-GCM-SIV encrypt | 1695.0 us | 824.3 us | 2.06x |
| AES-256-CTR | 1582.5 us | 789.0 us | 2.01x |
| AES-256-ECB | 1494.6 us | 762.9 us | 1.96x |
| AES-256-CBC | 1587.0 us | 844.2 us | 1.88x |
| AES single block (256-bit) | 20.8 us | 11.2 us | 1.87x |
| AES single block (128-bit) | 39.8 us | 28.9 us | 1.38x |
| Poly1305 MAC | 22.6 us | 16.0 us | 1.41x |
| Ed25519 sign | 1024.0 us | 727.6 us | 1.41x |
| Ed25519 publickey | 466.4 us | 334.5 us | 1.39x |
| Ed25519 verify | 1475.4 us | 1060.0 us | 1.39x |
| X25519 base | 915.3 us | 766.3 us | 1.19x |
| BLAKE2b-64 | 716.4 us | 533.9 us | 1.34x |
| SHA3-512 | 2192.2 us | 1645.4 us | 1.33x |
| SHAKE128 | 1012.8 us | 780.5 us | 1.30x |
| SHA3-256 | 1126.2 us | 891.4 us | 1.26x |
| SHA-512 | 939.9 us | 867.6 us | 1.08x |
| SHA-256 | 1393.8 us | 1341.8 us | 1.04x |
Payload 1 KiB unless noted. RSA keygen and the slow KDF parameter sets are excluded from this table (they are seconds-scale; see sections 7-8 for their cost model).
0.2 Summary
| Metric | Result |
|---|---|
| Improved operations (>= 1.05x) | 24 / 27 |
| Unchanged (0.98x - 1.05x) | 3 |
| Regressed (< 0.98x) | 0 |
| Geometric-mean speed-up | 1.96x |
Nothing got slower. Every measured operation is at least as fast as in v3.2.0, and the overall geometric mean is a 1.96x speed-up.
0.3 Key techniques
All optimizations stay inside pure Python, using only language-level primitives (which are allowed), never a C-backed reimplementation of the algorithm (which is forbidden by the project rules).
| Technique | Where it was applied | Why it helps |
|---|---|---|
| Code-generated, fully unrolled functions | AES round function, Keccak-f permutation | CPython executes a long run of straight-line bytecode far faster than a loop with indexing and attribute lookups |
| Big-integer bulk operations | GHASH, POLYVAL, XOR of buffers, Base64 pack/unpack | int.from_bytes / to_bytes / ^ run in C over a whole buffer in one call |
| Precomputed lookup tables | AES T-tables, GHASH/POLYVAL 4-bit windows, Keccak rho/pi offsets | Trades a few hundred bytes of memory for fewer Python-level operations |
| Constant-time-safe selection | Ed25519 scalar scan, X25519 Montgomery ladder | Preserves the security properties while removing per-lane branching |
| Lazy modular reduction | X25519 field arithmetic | Replaces a % p per multiply with a cheaper fold-and-subtract |
| Inlined hot loops | AEAD assembly, CTR/GCM block loops, Base58 batching | Removes Python function-call overhead from the innermost loop |
0.4 What did not change
- Public API: function names, signatures, defaults, return types and error codes are byte-identical. A signature comparison shows 0 removals and 0 changes.
- Security: constant-time scalar multiplication, constant-time tag comparison, RSA blinding and the "never return unauthenticated plaintext" rule are all preserved. An independent security regression suite (35 checks covering AEAD tamper detection, constant-time helpers, X25519 low-order points, Ed25519 constant-time selection, RSA failure paths and error-message hygiene) passes 35/35.
- Correctness: the full test suite passes (639 passed, 1 skipped), and all standard vectors (FIPS / RFC / NIST) are reproduced byte-for-byte.
- Zero dependencies: still standard library only, still pure Python.
1. How to reproduce
The full suite is a single script. Every algorithm / mode is one task, dispatched over one worker process per CPU core, so the whole run finishes in one parallel wave.
# from the repository root
export PYTHONPATH=$PWD # Windows: set PYTHONPATH=%CD%
python bench/benchmark.py
Design of the harness:
| Aspect | Choice | Why |
|---|---|---|
| Concurrency | ProcessPoolExecutor, one worker per core |
pure-Python crypto is CPU-bound; threads would not help (the GIL) |
| Task transport | picklable specs (op name + parameters), rebuilt inside the worker | Windows uses the spawn start method, so lambdas/closures cannot be sent to workers |
| Measurement | warm-up + auto-calibrated loop count + time.perf_counter() |
the loop count self-adjusts to fill a small time budget, so fast and slow primitives are both measured meaningfully |
| Payloads | 64 B and 1 KiB | typical API-call sizes; large buffers are dominated by the same per-byte cost |
2. Test environment
| Item | Value |
|---|---|
| CPU | 16 logical cores |
| Python | CPython 3.13.4 |
| OS | Windows |
| Library | purepycrypto 3.2.1 (pure Python, zero dependencies) |
| Workers | 16 processes |
| Per-task budget | 30 ms, 1 measurement round |
| Payload sizes | 64 B, 1 KiB |
| Total wall clock | 11.0 s for 82 tasks |
The 11 s figure is the whole benchmark, not a single operation — the 16-process fan-out is what makes a full-suite run this fast.
3. Hash functions
Throughput is reported for the 1 KiB payload.
| Algorithm | 64 B (ops/s) | 1 KiB (ops/s) | 64 B latency | 1 KiB throughput |
|---|---|---|---|---|
| BLAKE2b-64 | 4,125 | 418 | 242 µs | 0.41 MB/s |
| SHA-512 | 3,054 | 376 | 327 µs | 0.37 MB/s |
| SHAKE128 (32 B out) | 2,714 | 300 | 368 µs | 0.29 MB/s |
| SHAKE256 (64 B out) | 2,353 | 265 | 425 µs | 0.26 MB/s |
| SHA3-256 | 2,086 | 258 | 479 µs | 0.25 MB/s |
| SHA-256 | 1,893 | 207 | 528 µs | 0.20 MB/s |
| SHA3-512 | 2,616 | 187 | 382 µs | 0.18 MB/s |
| HMAC-SHA512 (1 KiB) | — | 285 | — | 0.28 MB/s |
| HMAC-SHA256 (1 KiB) | — | 183 | — | 0.18 MB/s |
| HMAC-SHA3-256 (1 KiB) | — | 187 | — | 0.18 MB/s |
| HMAC-SHA3-512 (1 KiB) | — | 106 | — | 0.10 MB/s |
Notes
- BLAKE2b is the fastest hash in the library, followed by SHA-512.
- SHA-3 / SHAKE use the Keccak-f[1600] permutation in pure Python and are therefore the most expensive family per byte.
- HMAC adds one extra compression pass (inner + outer), so it is roughly 1.5–2× the cost of the bare hash on the same payload.
4. AES
4.1 Single block
| Operation | ops/s | Latency |
|---|---|---|
| AES-128 block encrypt | 18,149 | 55.1 µs |
| AES-256 block encrypt | 18,217 | 54.9 µs |
The raw block cipher is the fastest cryptographic primitive in the library: about 18,000 ops/s, i.e. 55 µs per 16-byte block.
4.2 Modes
| Mode | 64 B (ops/s) | 64 B latency | 1 KiB (ops/s) | 1 KiB latency |
|---|---|---|---|---|
| AES-256-OFB | 3,707 | 270 µs | 168 | 5.95 ms |
| AES-256-CTR | 3,378 | 296 µs | 199 | 5.02 ms |
| AES-256-CBC | 3,292 | 304 µs | 181 | 5.53 ms |
| AES-256-CFB | 2,815 | 355 µs | 225 | 4.44 ms |
| AES-256-ECB | 2,051 | 488 µs | 165 | 6.05 ms |
| AES-256-GCM encrypt | 1,195 | 837 µs | 126 | 7.94 ms |
| AES-256-GCM decrypt | 959 | 1.04 ms | 197 | 5.07 ms |
Notes
- Stream-like modes (OFB / CTR) are the fastest bulk modes; they avoid padding and process the input as a single keystream.
- GCM is the slowest because it adds GHASH authentication on top of CTR.
- ECB is slower than CBC/CTR here mainly because of its padding path.
5. AES-GCM-SIV (RFC 8452)
| Operation | 64 B (ops/s) | 64 B latency | 1 KiB (ops/s) |
|---|---|---|---|
| AES-128-GCM-SIV encrypt | 2,275 | 439 µs | 211 |
| AES-256-GCM-SIV encrypt | 2,093 | 478 µs | 139 |
| AES-256-GCM-SIV decrypt | 2,140 | 467 µs | 190 |
Note. On small inputs GCM-SIV is faster than plain AES-GCM in this library (2,093 vs 1,195 ops/s at 64 B). That is expected: SIV is built on AES-CTR plus POLYVAL, avoiding the GHASH table path that dominates GCM here. GCM-SIV also gives nonce-misuse resistance, so for small messages it is the better default.
6. ChaCha20-Poly1305
| Operation | 64 B (ops/s) | 64 B latency | 1 KiB (ops/s) | 1 KiB latency |
|---|---|---|---|---|
| Poly1305 MAC (1 KiB) | — | — | 16,337 | 61.2 µs |
| ChaCha20-Poly1305 encrypt | 2,551 | 392 µs | 234 | 4.28 ms |
| ChaCha20-Poly1305 decrypt | 2,363 | 423 µs | 399 | 2.50 ms |
| XChaCha20-Poly1305 encrypt | 2,209 | 453 µs | 260 | 3.84 ms |
Note. Poly1305 is the single fastest AEAD primitive in the library (16,337 ops/s on 1 KiB, 15.95 MB/s). The AEAD constructions around it are slower because they must first run the ChaCha20 keystream.
7. Key derivation functions
KDFs are intentionally expensive; here the absolute numbers matter far more than ops/s. Per-unit costs are normalised so you can extrapolate to production parameters.
| Function | Measured cost | Normalised unit cost |
|---|---|---|
| HKDF-SHA256 (32 B out) | 1.196 ms | — |
| PBKDF2-SHA256 | 649 ms / 1,000 iterations | 649 ns per iteration |
| PBKDF2-SHA512 | 891 ms / 1,000 iterations | 891 ns per iteration |
| Argon2id (t=1, m=256 KiB) | 184 ms | 0.718 ms per KiB |
| scrypt (N=1024, r=8) | 1,751 ms | 1.710 ms per N-unit |
7.1 Extrapolation to production parameters
⚠️ This is the single most important table in this document. Pure-Python KDFs at production parameters are measured in tens of seconds to minutes.
| Production parameter set | Cost of one derivation (estimated) |
|---|---|
| PBKDF2-SHA256, 100,000 iterations | ≈ 65 s |
| scrypt, N = 2^14, r = 8 | ≈ 28 s |
| Argon2id, t = 3, m = 64 MiB | ≈ 138 s |
💡 Recommendation. When running on pure Python, choose KDF parameters one to two orders of magnitude lower than you would for a C library, or delegate the KDF to a native implementation (
hashlib.scrypt,hashlib.pbkdf2_hmac) while keepingpurepycryptofor everything else. A one-second-stretch target that is routine in C is simply not reachable in pure Python at comparable parameters.
8. Public-key algorithms
| Operation | ops/s | Latency |
|---|---|---|
| Ed25519 publickey | 763 | 1.31 ms |
| X25519 base (scalar·B) | 358 | 2.79 ms |
| X25519 keygen | 350 | 2.86 ms |
| X25519 shared (ECDH) | 318 | 3.14 ms |
| Ed25519 sign | 400 | 2.50 ms |
| Ed25519 verify | 281 | 3.56 ms |
| RSA-1024 OAEP encrypt | 523 | 1.91 ms |
| RSA-1024 PSS verify | 244 | 4.10 ms |
| RSA-1024 OAEP decrypt | 150 | 6.66 ms |
| RSA-1024 PSS sign | 97 | 10.27 ms |
Notes
x25519_generate_keypair()is a fixed-base scalar multiplication, so it costs essentially the same asx25519_base().- Ed25519 signing is faster than X25519 ECDH because the base point uses a precomputed affine Comb table (one point addition per digit, zero doublings).
- RSA private-key operations are 3–5× slower than public-key operations: signing/decryption need a full modular exponentiation with CRT and blinding, while verification/encryption only need the public exponent e = 65537.
- RSA-1024 is used here for fast measurement; 2048-bit key generation in pure Python takes seconds and is not included in the timed table.
9. Encoding
The encoding module is hand-written bit manipulation (it does not call the
standard-library base64), and is verified byte-for-byte identical to it.
| Operation | 64 B | 1 KiB | 1 KiB throughput |
|---|---|---|---|
| Hex encode | 759,029 ops/s (1.32 µs) | 184,404 (5.42 µs) | 180 MB/s |
| Base64 decode | 40,187 (24.9 µs) | 1,422 (703 µs) | 1.85 MB/s |
| Base32 encode | 24,401 (41.0 µs) | 1,646 (608 µs) | 1.61 MB/s |
| Base64 encode | 27,185 (36.8 µs) | 886 (1.13 ms) | 0.87 MB/s |
| Base58 encode | 21,038 (47.5 µs) | 236 (4.24 ms) | 0.23 MB/s |
Notes
- Hex encoding is the fastest non-random operation in the library (759,029 ops/s at 64 B, 180 MB/s on 1 KiB) — it is a simple nibble lookup.
- Base58 is the slowest because it performs repeated big-integer division.
- Base64 decode is faster than encode because encoding must emit padding.
10. Secure random
All randomness comes from os.urandom (the OS CSPRNG); the random module is
deliberately not used.
| Operation | ops/s | Latency |
|---|---|---|
| random_bytes(32) | 889,781 | 1.12 µs |
| token_hex(32) | 760,926 | 1.31 µs |
| random_bytes(1 KiB) | 413,661 | 2.42 µs |
| token_urlsafe(32) | 386,361 | 2.59 µs |
| random_bit() | 292,535 | 3.42 µs |
| random_int(1, 2^64) | 288,410 | 3.47 µs |
| random_uuid4() | 100,854 | 9.92 µs |
| random_password(16) | 10,103 | 99.0 µs |
Notes
random_bytesreaches 889,781 ops/s, showing that the cost is dominated by the Python call overhead rather than by the CSPRNG syscall.random_passwordis the slowest because it applies a rejection-sampling alphabet-uniformity loop across 16 characters.
11. Parallel helpers
| Operation | Wall time | Throughput |
|---|---|---|
sha3_batch 64 × 1 KiB (16 processes) |
62.7 ms | 1.00 MB/s |
aes256_gcm_siv_encrypt, 1 MiB, n_workers=16 |
included above | — |
The library's own batch APIs take an n_workers argument and use the same
multiprocessing pool. Note that per-call multiprocessing overhead means the
parallel helpers pay off only for workloads with enough items or bytes; for a
single small message, call the plain function.
12. Overall ranking — fastest operations
| # | Operation | ops/s |
|---|---|---|
| 1 | random_bytes(32) | 889,781 |
| 2 | token_hex(32) | 760,926 |
| 3 | Hex encode [64 B] | 759,029 |
| 4 | random_bytes(1 KiB) | 413,661 |
| 5 | token_urlsafe(32) | 386,361 |
| 6 | random_bit() | 292,535 |
| 7 | random_int(1, 2^64) | 288,410 |
| 8 | Hex encode [1 KiB] | 184,404 |
| 9 | random_uuid4() | 100,854 |
| 10 | AES-256 block encrypt | 18,217 |
Among cryptographic primitives (excluding encoding and randomness), the fastest are AES single-block encryption (18,217 ops/s) and Poly1305 (16,337 ops/s on 1 KiB).
13. Summary
| Dimension | Result |
|---|---|
| Performance position | Pure Python — 100×–1000× slower than C-backed libraries (expected) |
| Best suited for | Learning, auditing, zero-dependency embedding, small payloads |
| Not suited for | Bulk file encryption, production-grade KDF parameters, high-throughput TLS |
| Parallel speed-up | 16-core fan-out reduces the full 82-task suite to 11 s (≈16× vs serial) |
| Implementation quality | 55 µs per AES block and 2.5 ms per Ed25519 signature show that the hand-written bit manipulation and precomputed tables are doing real work |
Bottom line.
purepycryptotrades throughput for readability, portability and zero dependencies. It is a reference implementation you can read end to end — not a drop-in replacement for a native cryptography stack.