1 Commits
Author SHA1 Message Date
dvs 5dfdd87c06 Release v3.2.1: performance overhaul (1.96x geometric-mean speed-up)
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.
2026-09-27 11:37:33 +08:00
21 changed files with 5816 additions and 1701 deletions
+67
View File
@@ -9,6 +9,73 @@ and the version numbers follow [Semantic Versioning](https://semver.org/lang/zh-
## [Unreleased] ## [Unreleased]
(none)
---
## [3.2.1] - 2026-09-27
### Changed — performance overhaul (pure Python, no API change)
Every hot path was reworked. The library is still **100% pure Python with zero
dependencies**; no primitive was replaced by a C-backed shortcut. The public
API, the error semantics and the security properties are unchanged.
**Measured speed-ups (v3.2.0 -> v3.2.1, interleaved A/B min-of-N on an idle
16-core machine, 1 KiB payload):**
| Operation | Speed-up |
|---|---:|
| Base64 decode | **21.98x** |
| Base58 encode / decode | **8.01x** / 3.98x |
| ChaCha20-Poly1305 / XChaCha20-Poly1305 encrypt | **3.54x** / 3.28x |
| Base64 encode | **2.98x** |
| AES-256-GCM encrypt / decrypt | **2.25x** / 2.26x |
| AES-GCM-SIV encrypt | **2.06x** |
| AES-256 CTR / ECB / CBC | **2.01x** / 1.96x / 1.88x |
| AES single block (256-bit) | 1.87x |
| Poly1305 MAC | 1.41x |
| Ed25519 sign / verify / publickey | 1.41x / 1.39x / 1.39x |
| X25519 base | 1.19x |
| BLAKE2b / SHA3-256 / SHA3-512 / SHAKE128 | 1.34x / 1.26x / 1.33x / 1.30x |
| **Geometric mean over 27 operations** | **1.96x** |
**24 improved, 3 unchanged, 0 regressed.** See [`docs/benchmark.md`](docs/benchmark.md)
for the full table and methodology.
**Techniques used (all pure-Python):**
- **Code-generated, fully unrolled functions** for the AES round function and
the Keccak-f[1600] permutation, eliminating per-round loops, indexing and
attribute lookups.
- **Big-integer bulk operations** for GHASH, POLYVAL, buffer XOR and the
Base64 pack/unpack paths (`int.from_bytes` / `to_bytes` / `^` execute in C
over a whole buffer in a single call).
- **Precomputed lookup tables**: AES T-tables, GHASH / POLYVAL 4-bit windows,
Keccak rho/pi offset tables, precomputed DER length headers.
- **Constant-time-safe selection** in the Ed25519 scalar scan and the X25519
Montgomery ladder (branch-free masking, timing proven comparable).
- **Lazy modular reduction** in X25519 field arithmetic, replacing a `% p`
per multiply with a cheaper fold.
- **Batch Base58 / Base64 processing**, removing the per-character `divmod`
(the previous Base58 hot spot).
- **Inlined inner loops** in AEAD assembly, the CTR/GCM block loops and the
message schedule of SHA-2.
### Verified — no behavior change
- Full test suite: **639 passed, 1 skipped, 0 failed**.
- Standard vectors (FIPS 180-4 / FIPS 197 / FIPS 202 / RFC 5869 / RFC 6070 /
RFC 7748 / RFC 7914 / RFC 8032 / RFC 8439 / RFC 8452 / RFC 9106 / NIST GCM)
reproduce byte-for-byte.
- Differential probe of 1266 deterministic inputs against v3.2.0: identical,
except one unreachable private helper (`der._der_len` with a **negative**
argument, which no caller can produce since every call site passes `len()`).
- Public API signature comparison: **0 removals, 0 changes**.
- Independent security regression suite: **35 / 35** (AEAD tamper detection,
constant-time comparison helpers, X25519 low-order points, Ed25519
constant-time selection, RSA failure paths, error-message hygiene).
### Changed — full English localization ### Changed — full English localization
- **Documentation, code comments and error messages are now entirely in English.** - **Documentation, code comments and error messages are now entirely in English.**
+38 -3
View File
@@ -9,7 +9,41 @@
> **Pure Python Cryptography Toolkit — a zero-dependency pure-Python cryptography library.** > **Pure Python Cryptography Toolkit — a zero-dependency pure-Python cryptography library.**
> SHA-2 / SHA-3 / SHAKE / BLAKE2b · PBKDF2 / HKDF / scrypt / Argon2id · AES (ECB/CBC/CTR/CFB/OFB/GCM) · AES-GCM-SIV · ChaCha20-Poly1305 / XChaCha20-Poly1305 · X25519 · Ed25519 · RSA-OAEP / PSS · PKCS#1 / PKCS#8 / SPKI / PEM > SHA-2 / SHA-3 / SHAKE / BLAKE2b · PBKDF2 / HKDF / scrypt / Argon2id · AES (ECB/CBC/CTR/CFB/OFB/GCM) · AES-GCM-SIV · ChaCha20-Poly1305 / XChaCha20-Poly1305 · X25519 · Ed25519 · RSA-OAEP / PSS · PKCS#1 / PKCS#8 / SPKI / PEM
Current version: **v3.2.0** (this release adds the `kdf2` / `encoding` / `rand` modules, see [§ New in v3.2.0](#-new-in-v320)). Current version: **v3.2.1** (a performance release: **1.96x** geometric-mean speed-up, see [§ Performance](#-performance-v321) and [`docs/benchmark.md`](docs/benchmark.md)).
---
## ⚡ Performance (v3.2.1)
**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. The library is still **100% pure Python, zero dependencies** — no
primitive was replaced by a C-backed shortcut.
| Operation | Speed-up vs v3.2.0 |
|---|---:|
| Base64 decode | **21.98x** |
| Base58 encode | **8.01x** |
| ChaCha20-Poly1305 encrypt | **3.54x** |
| XChaCha20-Poly1305 encrypt | **3.28x** |
| Base64 encode | **2.98x** |
| AES-256-GCM decrypt / encrypt | **2.26x** / **2.25x** |
| AES-GCM-SIV encrypt | **2.06x** |
| AES-256-CTR / ECB / CBC | **2.01x** / 1.96x / 1.88x |
| AES single block (256-bit) | 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.** Geometric-mean speed-up over 27
> measured operations: **1.96x**.
Techniques: code-generated fully-unrolled AES / Keccak round functions,
big-integer bulk operations for GHASH and POLYVAL, precomputed lookup tables,
branch-free constant-time selection, lazy modular reduction in X25519, and
batched Base58 / Base64 processing. Full data and methodology are in
[`docs/benchmark.md`](docs/benchmark.md).
--- ---
@@ -65,6 +99,7 @@ TUI hash / KDF menu crashes, TUI `x25519`/`rsa` unpacking crashes, TUI self-test
- [Three Usage Modes](#-three-usage-modes-one-command-three-forms) - [Three Usage Modes](#-three-usage-modes-one-command-three-forms)
- [Quick Start](#-quick-start) - [Quick Start](#-quick-start)
- [Unified Error System](#-unified-error-system) - [Unified Error System](#-unified-error-system)
- [Performance (v3.2.1)](#-performance-v321)
- [New in v3.2.0](#-new-in-v320) - [New in v3.2.0](#-new-in-v320)
- [Windows Multiprocessing Notes](#-windows-multiprocessing-notes-important) - [Windows Multiprocessing Notes](#-windows-multiprocessing-notes-important)
- [TUI Language Switch](#-tui-language-switch-cn--en) - [TUI Language Switch](#-tui-language-switch-cn--en)
@@ -92,7 +127,7 @@ TUI hash / KDF menu crashes, TUI `x25519`/`rsa` unpacking crashes, TUI self-test
> ⚠️ The performance and side-channel characteristics of pure Python make it **unsuitable** for high-throughput, strongly adversarial, long-running production-critical scenarios. > ⚠️ The performance and side-channel characteristics of pure Python make it **unsuitable** for high-throughput, strongly adversarial, long-running production-critical scenarios.
> Be sure to read the [Security Notes](#-security-notes) and [`docs/security.md`](docs/security.md). > Be sure to read the [Security Notes](#-security-notes) and [`docs/security.md`](docs/security.md).
Author: **Dvs(DvsXT)** · License: **MIT** · Current version: **v3.2.0** Author: **Dvs(DvsXT)** · License: **MIT** · Current version: **v3.2.1**
--- ---
@@ -799,6 +834,6 @@ This project is released under the **MIT License**. See [`LICENSE`](LICENSE) for
<div align="center"> <div align="center">
**purepycrypto v3.2.0** · Made with ❤️ by **Dvs(DvsXT)** **purepycrypto v3.2.1** · Made with ❤️ by **Dvs(DvsXT)**
</div> </div>
+466
View File
@@ -0,0 +1,466 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
purepycrypto benchmark suite
============================
Measures the throughput of every public algorithm / mode in purepycrypto.
Run it from the repository root so the package is importable:
python bench/benchmark.py
python bench/benchmark.py --budget 0.05 --repeats 3
python bench/benchmark.py --sizes 64,1024,65536
Why this design
---------------
* Pure-Python crypto is CPU-bound. On a many-core machine, **multiprocessing
is the only thing that makes a full-suite run fast**, so every task is
dispatched to a process pool with one worker per CPU core and the whole
suite completes in a single parallel wave.
* Windows uses the ``spawn`` start method, which means **lambdas and closures
cannot be pickled** and therefore cannot be sent to a worker. Every
benchmark is expressed as a *spec*: a plain, picklable dict of primitives
(operation name + parameters). Each worker rebuilds the callable locally.
* Inside a worker each task is warmed up, then the loop count is
auto-calibrated to fill a small time budget, and the reported figure is the
best of N repeats. That makes fast primitives (sub-microsecond) and slow
ones (hundreds of milliseconds) both measured meaningfully.
Output is a set of tables grouped by category, sorted by speed within each
group, plus a summary of the wall clock and any failures.
See ``docs/benchmark.md`` for the published results, environment details and
an honest discussion of the performance trade-offs.
"""
import argparse
import os
import sys
import time
from concurrent.futures import ProcessPoolExecutor, as_completed
# ---------------------------------------------------------------- defaults
DEFAULT_BUDGET = 0.03 # seconds of measurement per task
DEFAULT_REPEATS = 1 # best of N
KB = 1024
MB = 1024 * 1024
# =================================================================== timing
def _timeit(call, budget):
"""Warm up, auto-calibrate, and return (seconds_per_op, iterations)."""
call() # warm-up
n = 1
while True:
t0 = time.perf_counter()
for _ in range(n):
call()
dt = time.perf_counter() - t0
if dt >= budget or n >= (1 << 22):
break
n = max(n * 2, int(n * budget / max(dt, 1e-9)))
t0 = time.perf_counter()
for _ in range(n):
call()
return (time.perf_counter() - t0) / n, n
def _payload(size):
"""Deterministic payload, identical in every worker (no RNG involved)."""
return (b"purepycrypto-benchmark-payload-" * (size // 29 + 2))[:size]
def run_spec(args):
"""Executed inside a worker process. ``args`` = (spec, budget, repeats)."""
spec, budget, repeats = args
import purepycrypto as ppc
try:
call, unit_bytes, unit_ops = _build(ppc, spec)
# calibrate once, then take the best of `repeats` measurements
best = float("inf")
iters = 0
for _ in range(max(1, repeats)):
sec, n = _timeit(call, budget)
best = min(best, sec)
iters = n
except Exception as e: # noqa: BLE001
return {"name": spec["name"], "group": spec["group"],
"error": f"{type(e).__name__}: {e}"}
res = {"name": spec["name"], "group": spec["group"],
"sec_per_op": best, "ops_per_sec": unit_ops / best, "iters": iters}
if unit_bytes:
res["mb_per_sec"] = (unit_bytes * unit_ops) / best / MB
return res
# =================================================================== builders
def _build(ppc, spec):
"""Map a spec to (callable, unit_bytes, unit_ops)."""
op = spec["op"]
sz = spec.get("size", 0)
P = spec.get("p", {})
# ---- hashes -------------------------------------------------------
if op in ("sha256", "sha512", "sha3_256", "sha3_512", "blake2b"):
d = _payload(sz)
f = getattr(ppc, op)
fn = (lambda: f(d, 64)) if op == "blake2b" else (lambda: f(d))
return fn, sz, 1
if op in ("shake128", "shake256"):
d = _payload(sz)
f = getattr(ppc, op)
return (lambda: f(d, P["outlen"])), sz, 1
if op.startswith("hmac_"):
d = _payload(sz)
f = getattr(ppc, op)
return (lambda: f(bytes(range(min(P["klen"], 256))), d)), sz, 1
# ---- AES ----------------------------------------------------------
if op == "aes_block":
aes = ppc.AES(bytes(range(16 if P["bits"] == 128 else 32)))
return (lambda: aes.encrypt_block(bytes(range(16)))), 16, 1
if op.startswith("aes_"):
aes = ppc.AES(bytes(range(32)))
pt = _payload(sz)
n12, n8, iv = bytes(range(12)), bytes(range(8)), bytes(range(16))
modes = {
"aes_gcm_enc": lambda: aes.gcm_encrypt(n12, pt),
"aes_cbc_enc": lambda: aes.encrypt_cbc(pt, iv),
"aes_ctr_enc": lambda: aes.encrypt_ctr(pt, n8),
"aes_cfb_enc": lambda: aes.encrypt_cfb(pt, iv),
"aes_ofb_enc": lambda: aes.encrypt_ofb(pt, iv),
"aes_ecb_enc": lambda: aes.encrypt_ecb(pt),
}
if op == "aes_gcm_dec":
ct, tag = aes.gcm_encrypt(n12, pt)
return (lambda: aes.gcm_decrypt(n12, ct, tag)), sz, 1
return modes[op], sz, 1
# ---- AES-GCM-SIV --------------------------------------------------
if op in ("gcm_siv_enc", "gcm_siv_dec", "gcm_siv_enc128"):
k = bytes(range(16 if op == "gcm_siv_enc128" else 32))
n12 = bytes(range(12))
pt = _payload(sz)
enc = (ppc.aes128_gcm_siv_encrypt if op == "gcm_siv_enc128"
else ppc.aes256_gcm_siv_encrypt)
if op == "gcm_siv_dec":
ct, tag = enc(k, n12, pt)
return (lambda: ppc.aes256_gcm_siv_decrypt(k, n12, ct, tag)), sz, 1
return (lambda: enc(k, n12, pt)), sz, 1
# ---- ChaCha -------------------------------------------------------
if op in ("chacha_enc", "chacha_dec", "xchacha_enc"):
k, pt = bytes(range(32)), _payload(sz)
n12, n24 = bytes(range(12)), bytes(range(24))
if op == "chacha_dec":
ct = ppc.chacha20poly1305_encrypt(k, n12, pt)
return (lambda: ppc.chacha20poly1305_decrypt(k, n12, ct)), sz, 1
if op == "xchacha_enc":
return (lambda: ppc.xchacha20poly1305_encrypt(k, n24, pt)), sz, 1
return (lambda: ppc.chacha20poly1305_encrypt(k, n12, pt)), sz, 1
if op == "poly1305":
return (lambda: ppc.poly1305_mac(bytes(range(32)), _payload(sz))), sz, 1
# ---- KDF ----------------------------------------------------------
if op == "pbkdf2":
it, h = P["iters"], P.get("hash", "sha256")
return (lambda: ppc.pbkdf2_hmac(b"password", b"salt" * 4, it, 32, h)), None, 1
if op == "hkdf":
return (lambda: ppc.hkdf(bytes(range(32)), b"salt", b"info", 32)), None, 1
if op == "scrypt":
N, r, p = P["N"], P["r"], P["p"]
return (lambda: ppc.scrypt(b"password", b"salt" * 4, N, r, p, 32)), None, 1
if op == "argon2id":
t, m, p = P["t"], P["m"], P["p"]
return (lambda: ppc.argon2id(b"password", b"salt" * 4, t, m, p, 32)), None, 1
# ---- X25519 -------------------------------------------------------
if op == "x25519_keygen":
return (lambda: ppc.x25519_generate_keypair()), None, 1
if op == "x25519_base":
return (lambda: ppc.x25519_base(bytes(range(31)) + b"\x7f")), None, 1
if op == "x25519_shared":
a, _ = ppc.x25519_generate_keypair()
_, bp = ppc.x25519_generate_keypair()
return (lambda: ppc.x25519_shared(a, bp)), None, 1
# ---- Ed25519 ------------------------------------------------------
if op.startswith("ed25519_"):
seed = bytes(range(32))
pub = ppc.ed25519_publickey(seed)
msg = b"purepycrypto benchmark message"
sig = ppc.ed25519_sign(msg, seed)
if op == "ed25519_public":
return (lambda: ppc.ed25519_publickey(seed)), None, 1
if op == "ed25519_sign":
return (lambda: ppc.ed25519_sign(msg, seed)), None, 1
return (lambda: ppc.ed25519_verify(sig, msg, pub)), None, 1
# ---- RSA (keygen once per worker) ---------------------------------
if op.startswith("rsa_"):
pub, priv = ppc.rsa_keygen(bits=1024, parallel=False)
msg = b"benchmark"
if op == "rsa_oaep_enc":
return (lambda: ppc.rsa_oaep_encrypt(msg, pub)), None, 1
if op == "rsa_oaep_dec":
ct = ppc.rsa_oaep_encrypt(msg, pub)
return (lambda: ppc.rsa_oaep_decrypt(ct, priv)), None, 1
if op == "rsa_pss_sign":
return (lambda: ppc.rsa_pss_sign(msg, priv)), None, 1
if op == "rsa_pss_verify":
sig = ppc.rsa_pss_sign(msg, priv)
return (lambda: ppc.rsa_pss_verify(msg, sig, pub)), None, 1
# ---- Encoding -----------------------------------------------------
if op.startswith("enc_"):
d = _payload(sz)
if op == "enc_b64":
return (lambda: ppc.b64encode(d)), sz, 1
if op == "enc_b64dec":
e = ppc.b64encode(d)
return (lambda: ppc.b64decode(e)), len(e), 1
if op == "enc_b32":
return (lambda: ppc.b32encode(d)), sz, 1
if op == "enc_hex":
return (lambda: ppc.hex_encode(d)), sz, 1
if op == "enc_b58":
return (lambda: ppc.b58encode(d)), sz, 1
# ---- Random -------------------------------------------------------
if op == "rand_bytes":
return (lambda: ppc.random_bytes(sz)), None, 1
if op == "token_hex":
return (lambda: ppc.token_hex(32)), None, 1
if op == "token_urlsafe":
return (lambda: ppc.token_urlsafe(32)), None, 1
if op == "uuid4":
return (lambda: ppc.random_uuid4()), None, 1
if op == "password":
return (lambda: ppc.random_password(length=16)), None, 1
if op == "rand_int":
return (lambda: ppc.random_int(1, 1 << 64)), None, 1
if op == "rand_bit":
return (lambda: ppc.random_bit()), None, 1
if op == "random_string":
alpha = "abcdefghijklmnopqrstuvwxyz0123456789"
return (lambda: ppc.random_string(16, alpha)), None, 1
# ---- Parallel helpers ---------------------------------------------
if op == "sha3_batch":
items = [bytes(range(256)) * 4] * 64 # 64 x 1 KiB
return (lambda: ppc.sha3_batch(items)), 64 * KB, 1
raise ValueError("unknown op: " + op)
# =================================================================== spec table
GROUPS = ["Hash", "AES", "AES-GCM-SIV", "ChaCha", "KDF", "X25519",
"Ed25519", "RSA", "Encoding", "Random", "Parallel"]
def make_specs(sizes, groups=None):
"""Build the task list. ``sizes`` is a list of (label, byte-size)."""
S = []
a = S.append
# Hash
for label, size in sizes:
for op, disp in [("sha256", "SHA-256"), ("sha512", "SHA-512"),
("blake2b", "BLAKE2b-64"), ("sha3_256", "SHA3-256"),
("sha3_512", "SHA3-512")]:
a({"op": op, "size": size, "name": f"{disp} [{label}]", "group": "Hash"})
a({"op": "shake128", "size": size, "p": {"outlen": 32},
"name": f"SHAKE128-32B [{label}]", "group": "Hash"})
a({"op": "shake256", "size": size, "p": {"outlen": 64},
"name": f"SHAKE256-64B [{label}]", "group": "Hash"})
a({"op": "hmac_sha256", "size": KB, "p": {"klen": 32},
"name": "HMAC-SHA256 [1KB]", "group": "Hash"})
a({"op": "hmac_sha512", "size": KB, "p": {"klen": 64},
"name": "HMAC-SHA512 [1KB]", "group": "Hash"})
a({"op": "hmac_sha3_256", "size": KB, "p": {"klen": 32},
"name": "HMAC-SHA3-256 [1KB]", "group": "Hash"})
a({"op": "hmac_sha3_512", "size": KB, "p": {"klen": 64},
"name": "HMAC-SHA3-512 [1KB]", "group": "Hash"})
# AES
a({"op": "aes_block", "p": {"bits": 128}, "name": "AES-128 block encrypt", "group": "AES"})
a({"op": "aes_block", "p": {"bits": 256}, "name": "AES-256 block encrypt", "group": "AES"})
for label, size in sizes:
for op, disp in [("aes_gcm_enc", "AES-256-GCM enc"),
("aes_gcm_dec", "AES-256-GCM dec"),
("aes_cbc_enc", "AES-256-CBC enc"),
("aes_ctr_enc", "AES-256-CTR enc"),
("aes_cfb_enc", "AES-256-CFB enc"),
("aes_ofb_enc", "AES-256-OFB enc"),
("aes_ecb_enc", "AES-256-ECB enc")]:
a({"op": op, "size": size, "name": f"{disp} [{label}]", "group": "AES"})
# AES-GCM-SIV
for label, size in sizes:
a({"op": "gcm_siv_enc128", "size": size,
"name": f"AES-128-GCM-SIV enc [{label}]", "group": "AES-GCM-SIV"})
a({"op": "gcm_siv_enc", "size": size,
"name": f"AES-256-GCM-SIV enc [{label}]", "group": "AES-GCM-SIV"})
a({"op": "gcm_siv_dec", "size": size,
"name": f"AES-256-GCM-SIV dec [{label}]", "group": "AES-GCM-SIV"})
# ChaCha
for label, size in sizes:
a({"op": "chacha_enc", "size": size,
"name": f"ChaCha20-Poly1305 enc [{label}]", "group": "ChaCha"})
a({"op": "chacha_dec", "size": size,
"name": f"ChaCha20-Poly1305 dec [{label}]", "group": "ChaCha"})
a({"op": "xchacha_enc", "size": size,
"name": f"XChaCha20-Poly1305 enc [{label}]", "group": "ChaCha"})
a({"op": "poly1305", "size": KB, "name": "Poly1305 MAC [1KB]", "group": "ChaCha"})
# KDF
a({"op": "pbkdf2", "p": {"iters": 100},
"name": "PBKDF2-SHA256 100 iters", "group": "KDF"})
a({"op": "pbkdf2", "p": {"iters": 100, "hash": "sha512"},
"name": "PBKDF2-SHA512 100 iters", "group": "KDF"})
a({"op": "hkdf", "name": "HKDF-SHA256 (32B out)", "group": "KDF"})
a({"op": "scrypt", "p": {"N": 1024, "r": 8, "p": 1},
"name": "scrypt N=2^10 r=8 p=1", "group": "KDF"})
a({"op": "argon2id", "p": {"t": 1, "m": 256, "p": 1},
"name": "Argon2id t=1 m=256KiB p=1", "group": "KDF"})
# X25519 / Ed25519
a({"op": "x25519_keygen", "name": "X25519 keygen", "group": "X25519"})
a({"op": "x25519_base", "name": "X25519 base (scalar*B)", "group": "X25519"})
a({"op": "x25519_shared", "name": "X25519 shared (ECDH)", "group": "X25519"})
a({"op": "ed25519_public", "name": "Ed25519 publickey", "group": "Ed25519"})
a({"op": "ed25519_sign", "name": "Ed25519 sign", "group": "Ed25519"})
a({"op": "ed25519_verify", "name": "Ed25519 verify", "group": "Ed25519"})
# RSA
a({"op": "rsa_oaep_enc", "name": "RSA-1024 OAEP encrypt", "group": "RSA"})
a({"op": "rsa_oaep_dec", "name": "RSA-1024 OAEP decrypt", "group": "RSA"})
a({"op": "rsa_pss_sign", "name": "RSA-1024 PSS sign", "group": "RSA"})
a({"op": "rsa_pss_verify", "name": "RSA-1024 PSS verify", "group": "RSA"})
# Encoding
for label, size in sizes:
for op, disp in [("enc_b64", "Base64 encode"), ("enc_b64dec", "Base64 decode"),
("enc_b32", "Base32 encode"), ("enc_hex", "Hex encode"),
("enc_b58", "Base58 encode")]:
a({"op": op, "size": size, "name": f"{disp} [{label}]", "group": "Encoding"})
# Random
a({"op": "rand_bytes", "size": 32, "name": "random_bytes(32)", "group": "Random"})
a({"op": "rand_bytes", "size": KB, "name": "random_bytes(1KB)", "group": "Random"})
a({"op": "token_hex", "name": "token_hex(32)", "group": "Random"})
a({"op": "token_urlsafe", "name": "token_urlsafe(32)", "group": "Random"})
a({"op": "uuid4", "name": "random_uuid4()", "group": "Random"})
a({"op": "password", "name": "random_password(16)", "group": "Random"})
a({"op": "rand_int", "name": "random_int(1, 2^64)", "group": "Random"})
a({"op": "rand_bit", "name": "random_bit()", "group": "Random"})
a({"op": "random_string", "name": "random_string(16)", "group": "Random"})
# Parallel helpers
a({"op": "sha3_batch", "name": "sha3_batch 64x1KB", "group": "Parallel"})
if groups:
want = {g.lower() for g in groups}
S = [s for s in S if s["group"].lower() in want]
return S
# =================================================================== reporting
def report(results, wall, cores):
ok = [r for r in results if "error" not in r]
bad = [r for r in results if "error" in r]
groups = {}
for r in ok:
groups.setdefault(r["group"], []).append(r)
for g in GROUPS:
rows = groups.get(g)
if not rows:
continue
rows.sort(key=lambda r: r["sec_per_op"])
print("=" * 96)
print(f" {g}")
print("=" * 96)
print(f" {'operation':42s} {'ops/sec':>15s} {'us/op':>10s} "
f"{'MB/s':>10s} {'iters':>10s}")
print(" " + "-" * 92)
for r in rows:
mbs = f"{r['mb_per_sec']:10.2f}" if "mb_per_sec" in r else f"{'-':>10s}"
print(f" {r['name']:42s} {r['ops_per_sec']:15,.0f} "
f"{r['sec_per_op'] * 1e6:10.3f} {mbs} {r['iters']:10,d}")
print()
if bad:
print("=" * 96)
print(" FAILED")
print("=" * 96)
for r in bad:
print(f" {r['name']:42s} {r['error']}")
print()
print("=" * 96)
print(f" {len(ok)} OK | {len(bad)} failed | wall clock {wall:.2f}s | {cores} cores")
print("=" * 96)
# =================================================================== main
def main(argv=None):
ap = argparse.ArgumentParser(
description="purepycrypto benchmark suite (multiprocess)",
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
)
ap.add_argument("--budget", type=float, default=DEFAULT_BUDGET,
help="seconds of measurement per task")
ap.add_argument("--repeats", type=int, default=DEFAULT_REPEATS,
help="take the best of N measurement rounds")
ap.add_argument("--sizes", default="64,1024",
help="comma-separated payload sizes in bytes")
ap.add_argument("--workers", type=int, default=0,
help="worker processes (0 = one per CPU core)")
ap.add_argument("--groups", default="",
help="comma-separated category filter, e.g. "
"'Hash,AES,RSA' (default: all)")
args = ap.parse_args(argv)
sizes = []
for s in args.sizes.split(","):
s = s.strip()
if not s:
continue
n = int(s)
label = f"{n}B" if n < KB else (f"{n // KB}KB" if n < MB else f"{n // MB}MB")
sizes.append((label, n))
if not sizes:
ap.error("no valid --sizes given")
groups = [g.strip() for g in args.groups.split(",") if g.strip()]
specs = make_specs(sizes, groups or None)
if not specs:
ap.error("no benchmarks selected for the given --groups / --sizes")
cores = os.cpu_count() or 4
workers = args.workers or min(cores, len(specs))
print(f"[*] purepycrypto benchmark: {len(specs)} tasks / {workers} workers "
f"({cores} cores)", flush=True)
print(f"[*] budget {args.budget}s x {args.repeats} repeats, "
f"sizes {[l for l, _ in sizes]}"
+ (f", groups {groups}" if groups else "") + "\n", flush=True)
t0 = time.perf_counter()
results = []
with ProcessPoolExecutor(max_workers=workers) as ex:
futs = [ex.submit(run_spec, (s, args.budget, args.repeats)) for s in specs]
for i, f in enumerate(as_completed(futs), 1):
results.append(f.result())
print(f"\r {i}/{len(specs)}", end="", flush=True)
wall = time.perf_counter() - t0
print(f"\n[*] wall clock: {wall:.2f}s\n")
report(results, wall, cores)
return 0
if __name__ == "__main__":
sys.exit(main())
+393
View File
@@ -0,0 +1,393 @@
# Benchmark
Performance reference for `purepycrypto` **v3.2.1**.
> ⚠️ **Read this first.** `purepycrypto` is 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.
```bash
# 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 keeping `purepycrypto` for 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 as `x25519_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_bytes` reaches **889,781 ops/s**, showing that the cost is dominated
by the Python call overhead rather than by the CSPRNG syscall.
- `random_password` is 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.** `purepycrypto` trades 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.
+1 -1
View File
@@ -1 +1 @@
__version__ = "3.2.0" __version__ = "3.2.1"
+369 -210
View File
@@ -291,65 +291,133 @@ def aes_key_expansion(key: bytes):
return eK, dK, Nr return eK, dK, Nr
# ============================================================
# 7b. AES block core (fully unrolled, code-generated T-tables)
# ============================================================
#
# The hot path is *generated* once at import time, for each valid round count
# (10/12/14): the round loop is fully unrolled, every table becomes a local
# (default argument) and every round-key offset is baked into the bytecode.
# The state is carried as four 32-bit words; byte extraction uses shifts/masks;
# the block is loaded/stored with a single int<->bytes conversion.
# Measured ~1.8-1.9x faster per block than the looped reference, byte-identical
# output (FIPS-197 / NIST vectors all pass).
TD4_B3 = [(s << 24) & MASK32 for s in INV_SBOX] # byte 3 plane of TD4
TD4_B2 = [(s << 16) & MASK32 for s in INV_SBOX] # byte 2 plane
TD4_B1 = [(s << 8) & MASK32 for s in INV_SBOX] # byte 1 plane
TD4_B0 = [s for s in INV_SBOX] # byte 0 plane
# 16-bit window tables: fold two byte lookups into a single table read.
# TE23[(hi << 8) | lo] == TE2[hi] ^ TE3[lo]
# TD23[(hi << 8) | lo] == TD2[hi] ^ TD3[lo]
# Using them replaces a shift/mask/subscript chain plus an XOR by a single
# mask|mask|or|subscript, cutting the per-round bytecode count further.
TE23 = [a ^ b for a in TE2 for b in TE3]
TD23 = [a ^ b for a in TD2 for b in TD3]
def _gen_enc_core(nr):
"""Generate a fully unrolled AES encryption core: f(int128, eK) -> int128."""
L = [
"def f(x, eK, TE0=TE0, TE1=TE1, TE2=TE2, TE3=TE3,"
" TE4_0=TE4_0, TE4_1=TE4_1, TE4_2=TE4_2, TE4_3=TE4_3, TE23=TE23):",
" s0 = (x >> 96) ^ eK[0]",
" s1 = ((x >> 64) & 0xFFFFFFFF) ^ eK[1]",
" s2 = ((x >> 32) & 0xFFFFFFFF) ^ eK[2]",
" s3 = (x & 0xFFFFFFFF) ^ eK[3]",
]
cur = ("s0", "s1", "s2", "s3")
for r in range(1, nr):
nxt = ("c%d_0" % r, "c%d_1" % r, "c%d_2" % r, "c%d_3" % r)
off = 4 * r
for i in range(4):
u0 = cur[i]
u1 = cur[(i + 1) & 3]
u2 = cur[(i + 2) & 3]
u3 = cur[(i + 3) & 3]
L.append(" %s = TE0[%s >> 24] ^ TE1[(%s >> 16) & 0xFF]"
" ^ TE23[(%s & 0xFF00) | (%s & 0xFF)] ^ eK[%d]"
% (nxt[i], u0, u1, u2, u3, off + i))
cur = nxt
t0, t1, t2, t3 = cur
off = 4 * nr
L.append(" o0 = TE4_3[%s >> 24] ^ TE4_2[(%s >> 16) & 0xFF]"
" ^ TE4_1[(%s >> 8) & 0xFF] ^ TE4_0[%s & 0xFF] ^ eK[%d]" % (t0, t1, t2, t3, off))
L.append(" o1 = TE4_3[%s >> 24] ^ TE4_2[(%s >> 16) & 0xFF]"
" ^ TE4_1[(%s >> 8) & 0xFF] ^ TE4_0[%s & 0xFF] ^ eK[%d]" % (t1, t2, t3, t0, off + 1))
L.append(" o2 = TE4_3[%s >> 24] ^ TE4_2[(%s >> 16) & 0xFF]"
" ^ TE4_1[(%s >> 8) & 0xFF] ^ TE4_0[%s & 0xFF] ^ eK[%d]" % (t2, t3, t0, t1, off + 2))
L.append(" o3 = TE4_3[%s >> 24] ^ TE4_2[(%s >> 16) & 0xFF]"
" ^ TE4_1[(%s >> 8) & 0xFF] ^ TE4_0[%s & 0xFF] ^ eK[%d]" % (t3, t0, t1, t2, off + 3))
L.append(" return (o0 << 96) | (o1 << 64) | (o2 << 32) | o3")
ns = {"TE0": TE0, "TE1": TE1, "TE2": TE2, "TE3": TE3,
"TE4_0": TE4_0, "TE4_1": TE4_1, "TE4_2": TE4_2, "TE4_3": TE4_3,
"TE23": TE23}
exec(compile("\n".join(L), "<aes-enc-%d>" % nr, "exec"), ns)
return ns["f"]
def _gen_dec_core(nr):
"""Generate a fully unrolled AES decryption core: f(int128, dK) -> int128."""
L = [
"def f(x, dK, TD0=TD0, TD1=TD1, TD2=TD2, TD3=TD3,"
" TD4_B3=TD4_B3, TD4_B2=TD4_B2, TD4_B1=TD4_B1, TD4_B0=TD4_B0, TD23=TD23):",
" s0 = (x >> 96) ^ dK[0]",
" s1 = ((x >> 64) & 0xFFFFFFFF) ^ dK[1]",
" s2 = ((x >> 32) & 0xFFFFFFFF) ^ dK[2]",
" s3 = (x & 0xFFFFFFFF) ^ dK[3]",
]
cur = ("s0", "s1", "s2", "s3")
for r in range(1, nr):
nxt = ("c%d_0" % r, "c%d_1" % r, "c%d_2" % r, "c%d_3" % r)
off = 4 * r
for i in range(4):
u0 = cur[i]
u1 = cur[(i - 1) & 3]
u2 = cur[(i - 2) & 3]
u3 = cur[(i - 3) & 3]
L.append(" %s = TD0[%s >> 24] ^ TD1[(%s >> 16) & 0xFF]"
" ^ TD23[(%s & 0xFF00) | (%s & 0xFF)] ^ dK[%d]"
% (nxt[i], u0, u1, u2, u3, off + i))
cur = nxt
off = 4 * nr
for i in range(4):
a0 = cur[i]
a1 = cur[(i - 1) & 3]
a2 = cur[(i - 2) & 3]
a3 = cur[(i - 3) & 3]
L.append(" o%d = TD4_B3[%s >> 24] ^ TD4_B2[(%s >> 16) & 0xFF]"
" ^ TD4_B1[(%s >> 8) & 0xFF] ^ TD4_B0[%s & 0xFF] ^ dK[%d]"
% (i, a0, a1, a2, a3, off + i))
L.append(" return (o0 << 96) | (o1 << 64) | (o2 << 32) | o3")
ns = {"TD0": TD0, "TD1": TD1, "TD2": TD2, "TD3": TD3,
"TD4_B3": TD4_B3, "TD4_B2": TD4_B2, "TD4_B1": TD4_B1, "TD4_B0": TD4_B0,
"TD23": TD23}
exec(compile("\n".join(L), "<aes-dec-%d>" % nr, "exec"), ns)
return ns["f"]
_ENC_CORE = {10: _gen_enc_core(10), 12: _gen_enc_core(12), 14: _gen_enc_core(14)}
_DEC_CORE = {10: _gen_dec_core(10), 12: _gen_dec_core(12), 14: _gen_dec_core(14)}
def aes_encrypt_block(pt: bytes, eK, Nr: int) -> bytes: def aes_encrypt_block(pt: bytes, eK, Nr: int) -> bytes:
s0 = _ld32(pt, 0) ^ eK[0] """Encrypt one 16-byte block with the fully-unrolled T-table core."""
s1 = _ld32(pt, 4) ^ eK[1] return _ENC_CORE[Nr](int.from_bytes(pt, "big"), eK).to_bytes(16, "big")
s2 = _ld32(pt, 8) ^ eK[2]
s3 = _ld32(pt, 12) ^ eK[3]
rk = 0; r = Nr >> 1
while True:
t0 = TE0[_B(s0, 3)] ^ TE1[_B(s1, 2)] ^ TE2[_B(s2, 1)] ^ TE3[_B(s3, 0)] ^ eK[rk + 4]
t1 = TE0[_B(s1, 3)] ^ TE1[_B(s2, 2)] ^ TE2[_B(s3, 1)] ^ TE3[_B(s0, 0)] ^ eK[rk + 5]
t2 = TE0[_B(s2, 3)] ^ TE1[_B(s3, 2)] ^ TE2[_B(s0, 1)] ^ TE3[_B(s1, 0)] ^ eK[rk + 6]
t3 = TE0[_B(s3, 3)] ^ TE1[_B(s0, 2)] ^ TE2[_B(s1, 1)] ^ TE3[_B(s2, 0)] ^ eK[rk + 7]
rk += 8; r -= 1
if r == 0: break
s0 = TE0[_B(t0, 3)] ^ TE1[_B(t1, 2)] ^ TE2[_B(t2, 1)] ^ TE3[_B(t3, 0)] ^ eK[rk + 0]
s1 = TE0[_B(t1, 3)] ^ TE1[_B(t2, 2)] ^ TE2[_B(t3, 1)] ^ TE3[_B(t0, 0)] ^ eK[rk + 1]
s2 = TE0[_B(t2, 3)] ^ TE1[_B(t3, 2)] ^ TE2[_B(t0, 1)] ^ TE3[_B(t1, 0)] ^ eK[rk + 2]
s3 = TE0[_B(t3, 3)] ^ TE1[_B(t0, 2)] ^ TE2[_B(t1, 1)] ^ TE3[_B(t2, 0)] ^ eK[rk + 3]
t0, t1, t2, t3 = s0, s1, s2, s3
r0 = TE4_3[_B(t0, 3)] ^ TE4_2[_B(t1, 2)] ^ TE4_1[_B(t2, 1)] ^ TE4_0[_B(t3, 0)] ^ eK[rk + 0]
r1 = TE4_3[_B(t1, 3)] ^ TE4_2[_B(t2, 2)] ^ TE4_1[_B(t3, 1)] ^ TE4_0[_B(t0, 0)] ^ eK[rk + 1]
r2 = TE4_3[_B(t2, 3)] ^ TE4_2[_B(t3, 2)] ^ TE4_1[_B(t0, 1)] ^ TE4_0[_B(t1, 0)] ^ eK[rk + 2]
r3 = TE4_3[_B(t3, 3)] ^ TE4_2[_B(t0, 2)] ^ TE4_1[_B(t1, 1)] ^ TE4_0[_B(t2, 0)] ^ eK[rk + 3]
return _st32(r0) + _st32(r1) + _st32(r2) + _st32(r3)
def aes_decrypt_block(ct: bytes, dK, Nr: int) -> bytes: def aes_decrypt_block(ct: bytes, dK, Nr: int) -> bytes:
s0 = _ld32(ct, 0) ^ dK[0] """Decrypt one 16-byte block with the fully-unrolled T-table core."""
s1 = _ld32(ct, 4) ^ dK[1] return _DEC_CORE[Nr](int.from_bytes(ct, "big"), dK).to_bytes(16, "big")
s2 = _ld32(ct, 8) ^ dK[2]
s3 = _ld32(ct, 12) ^ dK[3]
rk = 0; r = Nr >> 1
while True:
t0 = TD0[_B(s0, 3)] ^ TD1[_B(s3, 2)] ^ TD2[_B(s2, 1)] ^ TD3[_B(s1, 0)] ^ dK[rk + 4]
t1 = TD0[_B(s1, 3)] ^ TD1[_B(s0, 2)] ^ TD2[_B(s3, 1)] ^ TD3[_B(s2, 0)] ^ dK[rk + 5]
t2 = TD0[_B(s2, 3)] ^ TD1[_B(s1, 2)] ^ TD2[_B(s0, 1)] ^ TD3[_B(s3, 0)] ^ dK[rk + 6]
t3 = TD0[_B(s3, 3)] ^ TD1[_B(s2, 2)] ^ TD2[_B(s1, 1)] ^ TD3[_B(s0, 0)] ^ dK[rk + 7]
rk += 8; r -= 1
if r == 0: break
s0 = TD0[_B(t0, 3)] ^ TD1[_B(t3, 2)] ^ TD2[_B(t2, 1)] ^ TD3[_B(t1, 0)] ^ dK[rk + 0]
s1 = TD0[_B(t1, 3)] ^ TD1[_B(t0, 2)] ^ TD2[_B(t3, 1)] ^ TD3[_B(t2, 0)] ^ dK[rk + 1]
s2 = TD0[_B(t2, 3)] ^ TD1[_B(t1, 2)] ^ TD2[_B(t0, 1)] ^ TD3[_B(t3, 0)] ^ dK[rk + 2]
s3 = TD0[_B(t3, 3)] ^ TD1[_B(t2, 2)] ^ TD2[_B(t1, 1)] ^ TD3[_B(t0, 0)] ^ dK[rk + 3]
t0, t1, t2, t3 = s0, s1, s2, s3
r0 = ((TD4[_B(t0, 3)] & 0xff000000) ^ (TD4[_B(t3, 2)] & 0x00ff0000) ^
(TD4[_B(t2, 1)] & 0x0000ff00) ^ (TD4[_B(t1, 0)] & 0x000000ff) ^ dK[rk + 0])
r1 = ((TD4[_B(t1, 3)] & 0xff000000) ^ (TD4[_B(t0, 2)] & 0x00ff0000) ^
(TD4[_B(t3, 1)] & 0x0000ff00) ^ (TD4[_B(t2, 0)] & 0x000000ff) ^ dK[rk + 1])
r2 = ((TD4[_B(t2, 3)] & 0xff000000) ^ (TD4[_B(t1, 2)] & 0x00ff0000) ^
(TD4[_B(t0, 1)] & 0x0000ff00) ^ (TD4[_B(t3, 0)] & 0x000000ff) ^ dK[rk + 2])
r3 = ((TD4[_B(t3, 3)] & 0xff000000) ^ (TD4[_B(t2, 2)] & 0x00ff0000) ^
(TD4[_B(t1, 1)] & 0x0000ff00) ^ (TD4[_B(t0, 0)] & 0x000000ff) ^ dK[rk + 3])
return _st32(r0) + _st32(r1) + _st32(r2) + _st32(r3)
# ============================================================ # ============================================================
# 8. GHASH (4-bit table + parallel) # 8. GHASH (8-bit window tables + parallel)
# ============================================================ # ============================================================
def _gf_mul_bit(x, y): def _gf_mul_bit(x, y):
"""Reference GF(2^128) multiplication (bit-wise, kept for cross-checking)."""
z = 0 z = 0
v = y v = y
for i in range(128): for i in range(128):
@@ -362,6 +430,106 @@ def _gf_mul_bit(x, y):
return z return z
def _build_ghash_tables(H):
"""Nibble tables: tables[j][n] = n * H * x^(127-4j) in GF(2^128)."""
vs = [H]
for _ in range(127):
v = vs[-1]
if v & 1:
v = (v >> 1) ^ R_CONST
else:
v >>= 1
vs.append(v)
tables = []
for j in range(32):
tbl = [0] * 16
for n in range(1, 16):
lb = n & (-n)
tbl[n] = tbl[n ^ lb] ^ vs[127 - 4 * j - (lb.bit_length() - 1)]
tables.append(tbl)
return tables
_GHASH_T8_CACHE = {} # H -> list of 16 tables of 256 entries
_GHASH_T8_CACHE_MAX = 16
def _ghash_tables8(H):
"""Byte-window tables: tables[j][b] = b * H * x^(127-8j) in GF(2^128).
A 128-bit multiply-by-H then needs only 16 table reads (one per byte of the
operand) instead of 32 nibble reads. The byte tables are derived from the
nibble tables by folding the two nibbles of each byte at build time. They
depend only on H (fixed for a given AES key), so they are cached across
calls and the one-off build cost is amortised.
"""
cached = _GHASH_T8_CACHE.get(H)
if cached is not None:
return cached
t4 = _build_ghash_tables(H)
tabs = []
for j in range(16):
hi4 = t4[2 * j + 1]
lo4 = t4[2 * j]
tabs.append([hi4[n >> 4] ^ lo4[n & 15] for n in range(256)])
if len(_GHASH_T8_CACHE) >= _GHASH_T8_CACHE_MAX:
_GHASH_T8_CACHE.pop(next(iter(_GHASH_T8_CACHE)))
_GHASH_T8_CACHE[H] = tabs
return tabs
def _ghash_init(H):
global _GHASH_H, _GHASH_TABLES
_GHASH_H = H
_GHASH_TABLES = _ghash_tables8(H)
def _ghash_step(y, blk_int):
"""One GHASH step: (y ^ blk) * H, with H's byte-window tables prebuilt."""
T = _GHASH_TABLES
b = (y ^ blk_int).to_bytes(16, "little")
return (T[0][b[0]] ^ T[1][b[1]] ^ T[2][b[2]] ^ T[3][b[3]] ^
T[4][b[4]] ^ T[5][b[5]] ^ T[6][b[6]] ^ T[7][b[7]] ^
T[8][b[8]] ^ T[9][b[9]] ^ T[10][b[10]] ^ T[11][b[11]] ^
T[12][b[12]] ^ T[13][b[13]] ^ T[14][b[14]] ^ T[15][b[15]])
def _ghash_mul_H(x):
"""Multiply x by H using the prebuilt byte-window tables."""
T = _GHASH_TABLES
b = x.to_bytes(16, "little")
return (T[0][b[0]] ^ T[1][b[1]] ^ T[2][b[2]] ^ T[3][b[3]] ^
T[4][b[4]] ^ T[5][b[5]] ^ T[6][b[6]] ^ T[7][b[7]] ^
T[8][b[8]] ^ T[9][b[9]] ^ T[10][b[10]] ^ T[11][b[11]] ^
T[12][b[12]] ^ T[13][b[13]] ^ T[14][b[14]] ^ T[15][b[15]])
def _ghash_serial(data, H):
"""Sequential GHASH over ``data`` (zero-padded to a block boundary).
The multiply-by-H is inlined into the block loop (no per-block call) and all
16 window tables are bound to locals.
"""
T = _ghash_tables8(H)
T0 = T[0]; T1 = T[1]; T2 = T[2]; T3 = T[3]
T4 = T[4]; T5 = T[5]; T6 = T[6]; T7 = T[7]
T8 = T[8]; T9 = T[9]; T10 = T[10]; T11 = T[11]
T12 = T[12]; T13 = T[13]; T14 = T[14]; T15 = T[15]
n = len(data)
r = n & 15
if r:
data = data + b"\x00" * (16 - r)
n += 16 - r
y = 0
for i in range(0, n, 16):
b = (y ^ int.from_bytes(data[i:i + 16], "big")).to_bytes(16, "little")
y = (T0[b[0]] ^ T1[b[1]] ^ T2[b[2]] ^ T3[b[3]] ^
T4[b[4]] ^ T5[b[5]] ^ T6[b[6]] ^ T7[b[7]] ^
T8[b[8]] ^ T9[b[9]] ^ T10[b[10]] ^ T11[b[11]] ^
T12[b[12]] ^ T13[b[13]] ^ T14[b[14]] ^ T15[b[15]])
return y
def _ghash_chunk_worker(args): def _ghash_chunk_worker(args):
s, e, data, H = args s, e, data, H = args
_ghash_init(H) _ghash_init(H)
@@ -406,62 +574,6 @@ def _ghash_parallel(data: bytes, H: int, n_workers: int) -> int:
return S return S
def _build_ghash_tables(H):
vs = [H]
for _ in range(127):
v = vs[-1]
if v & 1:
v = (v >> 1) ^ R_CONST
else:
v >>= 1
vs.append(v)
tables = []
for j in range(32):
tbl = [0] * 16
for n in range(16):
r = 0
for i in range(4):
if (n >> i) & 1:
r ^= vs[127 - 4*j - i]
tbl[n] = r
tables.append(tbl)
return tables
def _ghash_init(H):
global _GHASH_H, _GHASH_TABLES
_GHASH_H = H
_GHASH_TABLES = _build_ghash_tables(H)
def _ghash_step(y, blk_int):
y ^= blk_int
z = 0
T = _GHASH_TABLES
for j in range(32):
z ^= T[j][(y >> (4 * j)) & 0xF]
return z
def _ghash_mul_H(x):
z = 0
T = _GHASH_TABLES
for j in range(32):
z ^= T[j][(x >> (4 * j)) & 0xF]
return z
def _ghash_serial(data, H):
_ghash_init(H)
y = 0
for i in range(0, len(data), 16):
blk = data[i:i+16]
if len(blk) < 16:
blk = blk + b"\x00" * (16 - len(blk))
y = _ghash_step(y, int.from_bytes(blk, "big"))
return y
class AES: class AES:
"""AES block cipher (ECB/CBC/CTR/CFB/OFB/GCM). """AES block cipher (ECB/CBC/CTR/CFB/OFB/GCM).
@@ -476,13 +588,25 @@ class AES:
raise PPYC_ERR(_res[0], _res[1], _res[2]) raise PPYC_ERR(_res[0], _res[1], _res[2])
self.key = key self.key = key
self.eK, self.dK, self.Nr = _res self.eK, self.dK, self.Nr = _res
# Bind the per-round-count unrolled cores once; cache H = AES_K(0^128).
self._enc = _ENC_CORE[self.Nr]
self._dec = _DEC_CORE[self.Nr]
self._ghash_H = None
def _gcm_h(self) -> int:
"""H = AES_K(0^128) as a 128-bit int (computed once per key)."""
H = self._ghash_H
if H is None:
H = self._enc(0, self.eK)
self._ghash_H = H
return H
# ---------- Block encryption ---------- # ---------- Block encryption ----------
def encrypt_block(self, block: bytes) -> bytes: def encrypt_block(self, block: bytes) -> bytes:
return aes_encrypt_block(block, self.eK, self.Nr) return self._enc(int.from_bytes(block, "big"), self.eK).to_bytes(16, "big")
def decrypt_block(self, block: bytes) -> bytes: def decrypt_block(self, block: bytes) -> bytes:
return aes_decrypt_block(block, self.dK, self.Nr) return self._dec(int.from_bytes(block, "big"), self.dK).to_bytes(16, "big")
# ---------- ECB ---------- # ---------- ECB ----------
def encrypt_ecb(self, data: bytes, n_workers: int = None) -> bytes: def encrypt_ecb(self, data: bytes, n_workers: int = None) -> bytes:
@@ -499,10 +623,11 @@ class AES:
if pool is not None: if pool is not None:
args = [(c, self.eK, self.Nr) for c in chunks] args = [(c, self.eK, self.Nr) for c in chunks]
return b"".join(pool.imap(_aes_enc_chunk_worker, args)) return b"".join(pool.imap(_aes_enc_chunk_worker, args))
out = bytearray() enc = self._enc
for i in range(0, len(data), 16): ek = self.eK
out += aes_encrypt_block(data[i:i + 16], self.eK, self.Nr) ib = int.from_bytes
return bytes(out) return b"".join([enc(ib(data[i:i + 16], "big"), ek).to_bytes(16, "big")
for i in range(0, len(data), 16)])
def decrypt_ecb(self, data: bytes, n_workers: int = None) -> bytes: def decrypt_ecb(self, data: bytes, n_workers: int = None) -> bytes:
"""ECB decryption (PKCS#7 unpadding). """ECB decryption (PKCS#7 unpadding).
@@ -525,10 +650,12 @@ class AES:
args = [(c, self.dK, self.Nr) for c in chunks] args = [(c, self.dK, self.Nr) for c in chunks]
out = b"".join(pool.imap(_aes_dec_chunk_worker, args)) out = b"".join(pool.imap(_aes_dec_chunk_worker, args))
return _unpad_or_err(out) return _unpad_or_err(out)
out = bytearray() dec = self._dec
for i in range(0, len(data), 16): dk = self.dK
out += aes_decrypt_block(data[i:i + 16], self.dK, self.Nr) ib = int.from_bytes
return _unpad_or_err(bytes(out)) out = b"".join([dec(ib(data[i:i + 16], "big"), dk).to_bytes(16, "big")
for i in range(0, len(data), 16)])
return _unpad_or_err(out)
# ---------- CBC ---------- # ---------- CBC ----------
def encrypt_cbc(self, data: bytes, iv: bytes) -> bytes: def encrypt_cbc(self, data: bytes, iv: bytes) -> bytes:
@@ -545,14 +672,17 @@ class AES:
f"CBC IV must be 16 bytes, got {len(iv)}", f"CBC IV must be 16 bytes, got {len(iv)}",
"pass a 16 byte IV") "pass a 16 byte IV")
data = _pad_pkcs7(data) data = _pad_pkcs7(data)
out = bytearray() enc = self._enc
prev = iv ek = self.eK
ib = int.from_bytes
prev = int.from_bytes(iv, "big")
out = []
ap = out.append
for i in range(0, len(data), 16): for i in range(0, len(data), 16):
blk = _xor_bytes(data[i:i + 16], prev) c = enc(ib(data[i:i + 16], "big") ^ prev, ek)
enc = aes_encrypt_block(blk, self.eK, self.Nr) ap(c.to_bytes(16, "big"))
out += enc prev = c
prev = enc return b"".join(out)
return bytes(out)
def decrypt_cbc(self, data: bytes, iv: bytes, n_workers: int = None) -> bytes: def decrypt_cbc(self, data: bytes, iv: bytes, n_workers: int = None) -> bytes:
"""CBC decryption (PKCS#7 unpadding). """CBC decryption (PKCS#7 unpadding).
@@ -573,28 +703,24 @@ class AES:
return err(PPYC_ERR_INVALID_LENGTH, return err(PPYC_ERR_INVALID_LENGTH,
f"CBC ciphertext length must be a multiple of 16, got {len(data)}", f"CBC ciphertext length must be a multiple of 16, got {len(data)}",
"pass a 16-byte aligned ciphertext produced by this library") "pass a 16-byte aligned ciphertext produced by this library")
if n_workers and n_workers > 1 and len(data) > 64 * 1024 and _HAS_MP: dec = self._dec
chunks = self._split_chunks(data, n_workers) dk = self.dK
pool = _get_pool(n_workers) ib = int.from_bytes
if pool is not None: prev = int.from_bytes(iv, "big")
args = [(c, self.dK, self.Nr) for c in chunks] out = []
dec = b"".join(pool.imap(_aes_dec_chunk_worker, args)) ap = out.append
else:
dec = self._dec_blocks(data)
else:
dec = self._dec_blocks(data)
out = bytearray()
prev = iv
for i in range(0, len(data), 16): for i in range(0, len(data), 16):
out += _xor_bytes(dec[i:i + 16], prev) c = ib(data[i:i + 16], "big")
prev = data[i:i + 16] ap((dec(c, dk) ^ prev).to_bytes(16, "big"))
return _unpad_or_err(bytes(out)) prev = c
return _unpad_or_err(b"".join(out))
def _dec_blocks(self, data: bytes) -> bytes: def _dec_blocks(self, data: bytes) -> bytes:
out = bytearray() dec = self._dec
for i in range(0, len(data), 16): dk = self.dK
out += aes_decrypt_block(data[i:i + 16], self.dK, self.Nr) ib = int.from_bytes
return bytes(out) return b"".join([dec(ib(data[i:i + 16], "big"), dk).to_bytes(16, "big")
for i in range(0, len(data), 16)])
# ---------- CTR ---------- # ---------- CTR ----------
def encrypt_ctr(self, data: bytes, nonce: bytes, n_workers: int = None) -> bytes: def encrypt_ctr(self, data: bytes, nonce: bytes, n_workers: int = None) -> bytes:
@@ -610,15 +736,16 @@ class AES:
return err(PPYC_ERR_INVALID_NONCE_LEN, return err(PPYC_ERR_INVALID_NONCE_LEN,
f"CTR nonce must be 8 bytes, got {len(nonce)}", f"CTR nonce must be 8 bytes, got {len(nonce)}",
"pass an 8 byte nonce") "pass an 8 byte nonce")
nb = (len(data) + 15) // 16 n = len(data)
nb = (n + 15) // 16
if not (n_workers and n_workers > 1 and nb > 4096 and _HAS_MP): if not (n_workers and n_workers > 1 and nb > 4096 and _HAS_MP):
out = bytearray() if nb == 0:
for i in range(nb): return b""
ks = aes_encrypt_block(nonce + i.to_bytes(8, "big"), self.eK, self.Nr) enc = self._enc
s = i * 16 ek = self.eK
e = min(s + 16, len(data)) base = int.from_bytes(nonce, "big") << 64
out += _xor_bytes(data[s:e], ks[:e - s]) ks = b"".join([enc(base + j, ek).to_bytes(16, "big") for j in range(nb)])
return bytes(out) return (int.from_bytes(data, "big") ^ int.from_bytes(ks[:n], "big")).to_bytes(n, "big")
pool = _get_pool(n_workers) pool = _get_pool(n_workers)
if pool is None: if pool is None:
return self.encrypt_ctr(data, nonce, None) return self.encrypt_ctr(data, nonce, None)
@@ -626,10 +753,10 @@ class AES:
ranges = [] ranges = []
i = 0 i = 0
while i < nb: while i < nb:
n = min(per, nb - i) m = min(per, nb - i)
ranges.append((i, n, self.eK, self.Nr, nonce)) ranges.append((i, m, self.eK, self.Nr, nonce))
i += n i += m
ks = b"".join(pool.imap(_aes_ctr_chunk_worker, ranges))[:len(data)] ks = b"".join(pool.imap(_aes_ctr_chunk_worker, ranges))[:n]
return _xor_bytes(data, ks) return _xor_bytes(data, ks)
def decrypt_ctr(self, data: bytes, nonce: bytes, n_workers: int = None) -> bytes: def decrypt_ctr(self, data: bytes, nonce: bytes, n_workers: int = None) -> bytes:
@@ -655,15 +782,24 @@ class AES:
return err(PPYC_ERR_INVALID_IV_LEN, return err(PPYC_ERR_INVALID_IV_LEN,
f"CFB IV must be 16 bytes, got {len(iv)}", f"CFB IV must be 16 bytes, got {len(iv)}",
"pass a 16 byte IV") "pass a 16 byte IV")
out = bytearray() enc = self._enc
prev = iv ek = self.eK
for i in range(0, len(data), 16): ib = int.from_bytes
ks = aes_encrypt_block(prev, self.eK, self.Nr) prev = int.from_bytes(iv, "big")
n = len(data)
out = []
ap = out.append
for i in range(0, n, 16):
ks = enc(prev, ek)
chunk = data[i:i + 16] chunk = data[i:i + 16]
blk = _xor_bytes(chunk, ks[:len(chunk)]) if len(chunk) == 16:
out += blk c = ib(chunk, "big") ^ ks
prev = blk ap(c.to_bytes(16, "big"))
return bytes(out) prev = c
else:
kb = ks.to_bytes(16, "big")
ap(bytes(x ^ y for x, y in zip(chunk, kb)))
return b"".join(out)
def decrypt_cfb(self, data: bytes, iv: bytes) -> bytes: def decrypt_cfb(self, data: bytes, iv: bytes) -> bytes:
"""CFB decryption. """CFB decryption.
@@ -677,14 +813,24 @@ class AES:
return err(PPYC_ERR_INVALID_IV_LEN, return err(PPYC_ERR_INVALID_IV_LEN,
f"CFB IV must be 16 bytes, got {len(iv)}", f"CFB IV must be 16 bytes, got {len(iv)}",
"pass a 16 byte IV") "pass a 16 byte IV")
out = bytearray() enc = self._enc
prev = iv ek = self.eK
for i in range(0, len(data), 16): ib = int.from_bytes
ks = aes_encrypt_block(prev, self.eK, self.Nr) prev = int.from_bytes(iv, "big")
n = len(data)
out = []
ap = out.append
for i in range(0, n, 16):
ks = enc(prev, ek)
chunk = data[i:i + 16] chunk = data[i:i + 16]
out += _xor_bytes(chunk, ks[:len(chunk)]) if len(chunk) == 16:
prev = chunk c = ib(chunk, "big")
return bytes(out) ap((c ^ ks).to_bytes(16, "big"))
prev = c
else:
kb = ks.to_bytes(16, "big")
ap(bytes(x ^ y for x, y in zip(chunk, kb)))
return b"".join(out)
# ---------- OFB ---------- # ---------- OFB ----------
def encrypt_ofb(self, data: bytes, iv: bytes) -> bytes: def encrypt_ofb(self, data: bytes, iv: bytes) -> bytes:
@@ -699,13 +845,21 @@ class AES:
return err(PPYC_ERR_INVALID_IV_LEN, return err(PPYC_ERR_INVALID_IV_LEN,
f"OFB IV must be 16 bytes, got {len(iv)}", f"OFB IV must be 16 bytes, got {len(iv)}",
"pass a 16 byte IV") "pass a 16 byte IV")
out = bytearray() enc = self._enc
ks = iv ek = self.eK
for i in range(0, len(data), 16): ks = int.from_bytes(iv, "big")
ks = aes_encrypt_block(ks, self.eK, self.Nr) n = len(data)
out = []
ap = out.append
for i in range(0, n, 16):
ks = enc(ks, ek)
chunk = data[i:i + 16] chunk = data[i:i + 16]
out += _xor_bytes(chunk, ks[:len(chunk)]) if len(chunk) == 16:
return bytes(out) ap((int.from_bytes(chunk, "big") ^ ks).to_bytes(16, "big"))
else:
kb = ks.to_bytes(16, "big")
ap(bytes(x ^ y for x, y in zip(chunk, kb)))
return b"".join(out)
def decrypt_ofb(self, data: bytes, iv: bytes) -> bytes: def decrypt_ofb(self, data: bytes, iv: bytes) -> bytes:
"""OFB decryption (OFB encryption/decryption is symmetric; reuses encrypt_ofb internally). """OFB decryption (OFB encryption/decryption is symmetric; reuses encrypt_ofb internally).
@@ -732,26 +886,24 @@ class AES:
return err(PPYC_ERR_INVALID_NONCE_LEN, return err(PPYC_ERR_INVALID_NONCE_LEN,
f"GCM nonce must be 12 bytes, got {len(nonce)}", f"GCM nonce must be 12 bytes, got {len(nonce)}",
"pass a 12 byte nonce") "pass a 12 byte nonce")
H = int.from_bytes(aes_encrypt_block(b"\x00" * 16, self.eK, self.Nr), "big") H = self._gcm_h()
J0 = nonce + b"\x00\x00\x00\x01" J0 = nonce + b"\x00\x00\x00\x01"
nb = (len(plaintext) + 15) // 16 nb = (len(plaintext) + 15) // 16
ct = None
if n_workers and n_workers > 1 and nb > 4096 and _HAS_MP: if n_workers and n_workers > 1 and nb > 4096 and _HAS_MP:
pool = _get_pool(n_workers) pool = _get_pool(n_workers)
if pool is not None: if pool is not None:
per = (nb + n_workers - 1) // n_workers per = (nb + n_workers - 1) // n_workers
ranges = [] ranges = []
for k in range(n_workers): k = 0
s = k * per while k < nb:
if s >= nb: m = min(per, nb - k)
break ranges.append((2 + k, m, self.eK, self.Nr, nonce))
e = min(s + per, nb) k += m
ranges.append((2 + s, e - s, self.eK, self.Nr, nonce))
ks = b"".join(pool.imap(_gcm_ctr_chunk_worker, ranges))[:len(plaintext)] ks = b"".join(pool.imap(_gcm_ctr_chunk_worker, ranges))[:len(plaintext)]
ct = _xor_bytes(plaintext, ks) ct = _xor_bytes(plaintext, ks)
else: if ct is None:
ct = self._gcm_ctr_serial(nonce, plaintext)
else:
ct = self._gcm_ctr_serial(nonce, plaintext) ct = self._gcm_ctr_serial(nonce, plaintext)
aad_pad = aad + b"\x00" * ((16 - len(aad) % 16) % 16) aad_pad = aad + b"\x00" * ((16 - len(aad) % 16) % 16)
@@ -764,18 +916,21 @@ class AES:
else: else:
S = _ghash_serial(ghash_data, H) S = _ghash_serial(ghash_data, H)
ek_j0 = aes_encrypt_block(J0, self.eK, self.Nr) ek_j0 = self._enc(int.from_bytes(J0, "big"), self.eK).to_bytes(16, "big")
tag = _xor_bytes(ek_j0, S.to_bytes(16, "big")) tag = _xor_bytes(ek_j0, S.to_bytes(16, "big"))
return ct, tag return ct, tag
def _gcm_ctr_serial(self, nonce: bytes, plaintext: bytes) -> bytes: def _gcm_ctr_serial(self, nonce: bytes, plaintext: bytes) -> bytes:
ks = bytearray() n = len(plaintext)
ctr = 2 nb = (n + 15) // 16
nb = (len(plaintext) + 15) // 16 if nb == 0:
for _ in range(nb): return b""
ks += aes_encrypt_block(nonce + ctr.to_bytes(4, "big"), self.eK, self.Nr) enc = self._enc
ctr += 1 ek = self.eK
return _xor_bytes(plaintext, ks[:len(plaintext)]) base = int.from_bytes(nonce, "big") << 32
ks = b"".join([enc(base | ((2 + j) & MASK32), ek).to_bytes(16, "big")
for j in range(nb)])
return (int.from_bytes(plaintext, "big") ^ int.from_bytes(ks[:n], "big")).to_bytes(n, "big")
def gcm_decrypt(self, nonce: bytes, ct: bytes, tag: bytes, aad: bytes = b"") -> bytes: def gcm_decrypt(self, nonce: bytes, ct: bytes, tag: bytes, aad: bytes = b"") -> bytes:
"""AES-GCM authenticated decryption. """AES-GCM authenticated decryption.
@@ -796,14 +951,14 @@ class AES:
f"GCM nonce must be 12 bytes, got {len(nonce)}", f"GCM nonce must be 12 bytes, got {len(nonce)}",
"pass a 12 byte nonce") "pass a 12 byte nonce")
# The authentication tag must be computed over the CIPHERTEXT directly; do not re-encrypt ct as plaintext. # The authentication tag must be computed over the CIPHERTEXT directly; do not re-encrypt ct as plaintext.
H = int.from_bytes(aes_encrypt_block(b"\x00" * 16, self.eK, self.Nr), "big") H = self._gcm_h()
J0 = nonce + b"\x00\x00\x00\x01" J0 = nonce + b"\x00\x00\x00\x01"
aad_pad = aad + b"\x00" * ((16 - len(aad) % 16) % 16) aad_pad = aad + b"\x00" * ((16 - len(aad) % 16) % 16)
ct_pad = ct + b"\x00" * ((16 - len(ct) % 16) % 16) ct_pad = ct + b"\x00" * ((16 - len(ct) % 16) % 16)
lens = (len(aad) * 8).to_bytes(8, "big") + (len(ct) * 8).to_bytes(8, "big") lens = (len(aad) * 8).to_bytes(8, "big") + (len(ct) * 8).to_bytes(8, "big")
ghash_data = aad_pad + ct_pad + lens ghash_data = aad_pad + ct_pad + lens
S = _ghash_serial(ghash_data, H) S = _ghash_serial(ghash_data, H)
ek_j0 = aes_encrypt_block(J0, self.eK, self.Nr) ek_j0 = self._enc(int.from_bytes(J0, "big"), self.eK).to_bytes(16, "big")
tag2 = _xor_bytes(ek_j0, S.to_bytes(16, "big")) tag2 = _xor_bytes(ek_j0, S.to_bytes(16, "big"))
if len(tag) != 16: if len(tag) != 16:
return err(PPYC_ERR_INVALID_TAG, return err(PPYC_ERR_INVALID_TAG,
@@ -837,33 +992,37 @@ class AES:
def _aes_enc_chunk_worker(args): def _aes_enc_chunk_worker(args):
chunk, eK, Nr = args chunk, eK, Nr = args
out = bytearray() f = _ENC_CORE[Nr]
for i in range(0, len(chunk), 16): ib = int.from_bytes
out += aes_encrypt_block(chunk[i:i + 16], eK, Nr) return b"".join([f(ib(chunk[i:i + 16], "big"), eK).to_bytes(16, "big")
return bytes(out) for i in range(0, len(chunk), 16)])
def _aes_dec_chunk_worker(args): def _aes_dec_chunk_worker(args):
chunk, dK, Nr = args chunk, dK, Nr = args
out = bytearray() f = _DEC_CORE[Nr]
for i in range(0, len(chunk), 16): ib = int.from_bytes
out += aes_decrypt_block(chunk[i:i + 16], dK, Nr) return b"".join([f(ib(chunk[i:i + 16], "big"), dK).to_bytes(16, "big")
return bytes(out) for i in range(0, len(chunk), 16)])
def _aes_ctr_chunk_worker(args): def _aes_ctr_chunk_worker(args):
start_i, n_blocks, eK, Nr, nonce = args start_i, n_blocks, eK, Nr, nonce = args
out = bytearray() f = _ENC_CORE[Nr]
base = int.from_bytes(nonce, "big") << 64
out = []
ap = out.append
for j in range(n_blocks): for j in range(n_blocks):
i = start_i + j ap(f(base + start_i + j, eK).to_bytes(16, "big"))
out += aes_encrypt_block(nonce + i.to_bytes(8, "big"), eK, Nr) return b"".join(out)
return bytes(out)
def _gcm_ctr_chunk_worker(args): def _gcm_ctr_chunk_worker(args):
ctr, n_blocks, eK, Nr, nonce = args ctr, n_blocks, eK, Nr, nonce = args
out = bytearray() f = _ENC_CORE[Nr]
base = int.from_bytes(nonce, "big") << 32
out = []
ap = out.append
for j in range(n_blocks): for j in range(n_blocks):
ctr_block = nonce + ((ctr + j) & MASK32).to_bytes(4, "big") ap(f(base | ((ctr + j) & MASK32), eK).to_bytes(16, "big"))
out += aes_encrypt_block(ctr_block, eK, Nr) return b"".join(out)
return bytes(out)
+212 -54
View File
@@ -120,6 +120,8 @@ _AUTO_MP_MIN_BLOCKS = 8192
MAX_INPUT_BYTES = 1 << 36 MAX_INPUT_BYTES = 1 << 36
_SIV_MASK128 = (1 << 128) - 1 _SIV_MASK128 = (1 << 128) - 1
# Clear the most significant bit (bit 7 of byte 15, i.e. x^127) of a block.
_SIV_CLEAR_TOP = (1 << 127) - 1
# GF(2^128), irreducible polynomial x^128 + x^127 + x^126 + x^121 + 1. # GF(2^128), irreducible polynomial x^128 + x^127 + x^126 + x^121 + 1.
# Bit convention of RFC 8452 section 3: bit i of the integer is the coefficient of x^i # Bit convention of RFC 8452 section 3: bit i of the integer is the coefficient of x^i
@@ -128,6 +130,10 @@ _SIV_MASK128 = (1 << 128) - 1
_POLY = (1 << 128) | (1 << 127) | (1 << 126) | (1 << 121) | 1 _POLY = (1 << 128) | (1 << 127) | (1 << 126) | (1 << 121) | 1
# x^-128 = x^127 + x^124 + x^121 + x^114 + 1 (RFC 8452 section 3) # x^-128 = x^127 + x^124 + x^121 + x^114 + 1 (RFC 8452 section 3)
_INV128 = (1 << 127) | (1 << 124) | (1 << 121) | (1 << 114) | 1 _INV128 = (1 << 127) | (1 << 124) | (1 << 121) | (1 << 114) | 1
# x^-1 = x^127 + x^126 + x^125 + x^120 (reciprocal of x: x * _XINV1 == 1 mod P).
# Used to walk the table ladder backwards from H, replacing a full 128x128 field
# multiply plus 127 conditional left shifts with 128 cheap shift/xor steps.
_XINV1 = 0xE1000000000000000000000000000000
# ============================================================ # ============================================================
@@ -141,23 +147,51 @@ _INV128 = (1 << 127) | (1 << 124) | (1 << 121) | (1 << 114) | 1
# so it can be accelerated with a 4-bit lookup table (32 tables of 16 entries), like the GHASH table method in aes.py. # so it can be accelerated with a 4-bit lookup table (32 tables of 16 entries), like the GHASH table method in aes.py.
def _poly_mul(a: int, b: int) -> int: def _poly_mul(a: int, b: int) -> int:
"""Polynomial multiplication in GF(2^128) modulo _POLY (little-endian bit convention).""" """Polynomial multiplication in GF(2^128) modulo _POLY (little-endian bit convention).
``b`` is consumed 4 bits at a time through a 16-entry window table of the
multiples of ``a``, so the accumulate loop runs at most 32 times instead of
shifting/testing ``b`` bit by bit up to 128 times. The product is then
reduced modulo ``_POLY`` with the usual high-to-low bit cancellation.
"""
if not b:
return 0
t0 = a
t1 = a << 1
t2 = t1 << 1
t3 = t2 << 1
a1 = t1 ^ t0
a2 = t2 ^ t0
a3 = t3 ^ t0
t = [0, t0, t1, a1, t2, a2, t1 ^ t2, a1 ^ t2,
t3, a3, t1 ^ t3, a1 ^ t3, t2 ^ t3, a2 ^ t3, (t1 ^ t2) ^ t3, (a1 ^ t2) ^ t3]
p = 0 p = 0
sh = 0
while b: while b:
if b & 1: p ^= t[b & 15] << sh
p ^= a b >>= 4
b >>= 1 sh += 4
a <<= 1
# Reduction: cancel bits from the high end down to 128 bits, one bit at a time # Reduction: cancel bits from the high end down to 128 bits, one bit at a time
for i in range(p.bit_length() - 1, 127, -1): for i in range(p.bit_length() - 1, 127, -1):
if (p >> i) & 1: if (p >> i) & 1:
p ^= _POLY << (i - 128) p ^= _POLY << (i - 128)
return p & _SIV_MASK128 return p & _SIV_MASK128
_POLYVAL_TABLE_CACHE = {} # h -> tables; avoids rebuilding the table for the same authentication key _POLYVAL_TABLE_CACHE = {} # h -> tables; avoids rebuilding the table for the same authentication key
_POLYVAL_TABLE_CACHE_MAX = 8 _POLYVAL_TABLE_CACHE_MAX = 8
# Byte-window POLYVAL tables: tables[j][b] = dot(b * x^(8j), H), j = 0..15.
# A multiply-by-H needs 16 reads instead of 32, but the (one-off, cached) build is
# larger, so it is only used from _POLYVAL8_MIN_BLOCKS blocks upwards.
_POLYVAL_TABLE8_CACHE = {}
_POLYVAL_TABLE8_CACHE_MAX = 4
_POLYVAL8_MIN_BLOCKS = 64
# Per-message encryption-key AES objects (expanded key schedules). Reusing them
# removes one AES key expansion (roughly 45us) from every seal/open call.
_ENC_AES_CACHE = {}
_ENC_AES_CACHE_MAX = 8
# Master cache switch (performance vs. key material residing in memory). # Master cache switch (performance vs. key material residing in memory).
# Default True: performance first. If your threat model does not allow derived keys / lookup tables to reside in # Default True: performance first. If your threat model does not allow derived keys / lookup tables to reside in
# process memory, call set_cache_enabled(False) to disable it (this significantly reduces small-message performance). # process memory, call set_cache_enabled(False) to disable it (this significantly reduces small-message performance).
@@ -181,7 +215,9 @@ def set_cache_enabled(enabled: bool) -> None:
_CACHE_ENABLED = bool(enabled) _CACHE_ENABLED = bool(enabled)
if not _CACHE_ENABLED: if not _CACHE_ENABLED:
_POLYVAL_TABLE_CACHE.clear() _POLYVAL_TABLE_CACHE.clear()
_POLYVAL_TABLE8_CACHE.clear()
_DERIVE_CACHE.clear() _DERIVE_CACHE.clear()
_ENC_AES_CACHE.clear()
def cache_enabled() -> bool: def cache_enabled() -> bool:
@@ -192,37 +228,55 @@ def cache_enabled() -> bool:
def clear_caches() -> None: def clear_caches() -> None:
"""Manually clear the internal caches (does not change the switch state).""" """Manually clear the internal caches (does not change the switch state)."""
_POLYVAL_TABLE_CACHE.clear() _POLYVAL_TABLE_CACHE.clear()
_POLYVAL_TABLE8_CACHE.clear()
_DERIVE_CACHE.clear() _DERIVE_CACHE.clear()
_ENC_AES_CACHE.clear()
def _polyval_vs(h: int):
"""Return the 128-entry ladder ``vs[i] = dot(x^i, H) = H * x^(i-128)``.
Instead of multiplying H by x^-128 and then shifting left 127 times, the
ladder is walked *downwards* from H by repeatedly dividing by x
(``x^-1 = _XINV1``), which is 128 cheap shift/xor steps with no big multiply.
"""
vs = [0] * 128
v = h
for i in range(127, -1, -1):
if v & 1:
v = (v >> 1) ^ _XINV1
else:
v >>= 1
vs[i] = v
return vs
def _polyval_tables(h: int): def _polyval_tables(h: int):
"""Precompute the POLYVAL lookup table for key H: T[i] = dot(x^i, H), then fold by nibble. """Precompute the POLYVAL nibble lookup tables for the authentication key H.
Performance: building the table takes 128 shifts + 512 table-entry combinations, which for **small messages** tables[j][n] = dot(n * x^(4j), H), hence dot(y, H) = XOR_j tables[j][(y >> 4j) & 0xF].
costs far more than the actual POLYVAL computation, so it is cached per H (LRU-style, capacity _POLYVAL_TABLE_CACHE_MAX).
Performance: the 16 entries of every table are written out directly as the 16
linear combinations of its four basis values (one list literal per table)
instead of running a 4-step bit test per entry -- about 5x faster than the
previous builder. The result depends only on H, so it is cached per H
(LRU-style, capacity _POLYVAL_TABLE_CACHE_MAX).
""" """
if _CACHE_ENABLED: if _CACHE_ENABLED:
cached = _POLYVAL_TABLE_CACHE.get(h) cached = _POLYVAL_TABLE_CACHE.get(h)
if cached is not None: if cached is not None:
return cached return cached
# base = dot(x^0, H) = H * x^-128 vs = _polyval_vs(h)
base = _poly_mul(h, _INV128)
vs = [base]
for _ in range(127):
v = vs[-1] << 1
if v & (1 << 128):
v ^= _POLY
vs.append(v & _SIV_MASK128)
tables = [] tables = []
ap = tables.append
for j in range(32): for j in range(32):
tbl = [0] * 16 v0 = vs[4 * j]
for n in range(16): v1 = vs[4 * j + 1]
r = 0 v2 = vs[4 * j + 2]
for k in range(4): v3 = vs[4 * j + 3]
if (n >> k) & 1: ap([0, v0, v1, v0 ^ v1, v2, v0 ^ v2, v1 ^ v2, v0 ^ v1 ^ v2,
r ^= vs[4 * j + k] v3, v0 ^ v3, v1 ^ v3, v0 ^ v1 ^ v3, v2 ^ v3, v0 ^ v2 ^ v3,
tbl[n] = r v1 ^ v2 ^ v3, v0 ^ v1 ^ v2 ^ v3])
tables.append(tbl)
if _CACHE_ENABLED: if _CACHE_ENABLED:
if len(_POLYVAL_TABLE_CACHE) >= _POLYVAL_TABLE_CACHE_MAX: if len(_POLYVAL_TABLE_CACHE) >= _POLYVAL_TABLE_CACHE_MAX:
_POLYVAL_TABLE_CACHE.pop(next(iter(_POLYVAL_TABLE_CACHE))) _POLYVAL_TABLE_CACHE.pop(next(iter(_POLYVAL_TABLE_CACHE)))
@@ -230,6 +284,36 @@ def _polyval_tables(h: int):
return tables return tables
def _polyval_tables8(h: int):
"""Precompute the POLYVAL byte-window tables: tables[j][b] = dot(b * x^(8j), H).
A multiply-by-H then needs 16 table reads (one per byte of the operand)
instead of 32 nibble reads. The build is ~5x more expensive than the nibble
tables (and ~6x larger), so it is used only from _POLYVAL8_MIN_BLOCKS blocks
upwards and, like the nibble tables, cached per H.
"""
if _CACHE_ENABLED:
cached = _POLYVAL_TABLE8_CACHE.get(h)
if cached is not None:
return cached
vs = _polyval_vs(h)
tables = []
ap = tables.append
for j in range(16):
tbl = [0] * 256
base = 8 * j
for k in range(8):
n = 1 << k
v = vs[base + k]
tbl[n:2 * n] = [x ^ v for x in tbl[:n]]
ap(tbl)
if _CACHE_ENABLED:
if len(_POLYVAL_TABLE8_CACHE) >= _POLYVAL_TABLE8_CACHE_MAX:
_POLYVAL_TABLE8_CACHE.pop(next(iter(_POLYVAL_TABLE8_CACHE)))
_POLYVAL_TABLE8_CACHE[h] = tables
return tables
def _polyval_lookup(y: int, tables) -> int: def _polyval_lookup(y: int, tables) -> int:
"""dot(y, H) = XOR_j tables[j][ (y >> 4j) & 0xF ].""" """dot(y, H) = XOR_j tables[j][ (y >> 4j) & 0xF ]."""
z = 0 z = 0
@@ -238,6 +322,64 @@ def _polyval_lookup(y: int, tables) -> int:
return z return z
def _polyval_run(buf, tables) -> int:
"""POLYVAL over ``buf`` (length a multiple of 16) using nibble tables.
The multiply-by-H is inlined into the block loop (no per-block call) and
``buf`` is consumed 16 bytes at a time as one little-endian integer.
"""
fb = int.from_bytes
y = 0
for i in range(0, len(buf), 16):
v = y ^ fb(buf[i:i + 16], "little")
z = 0
for j in range(32):
z ^= tables[j][(v >> (4 * j)) & 0xF]
y = z
return y
def _polyval_run8(buf, tables) -> int:
"""POLYVAL over ``buf`` (length a multiple of 16) using byte-window tables."""
fb = int.from_bytes
T0 = tables[0]
T1 = tables[1]
T2 = tables[2]
T3 = tables[3]
T4 = tables[4]
T5 = tables[5]
T6 = tables[6]
T7 = tables[7]
T8 = tables[8]
T9 = tables[9]
T10 = tables[10]
T11 = tables[11]
T12 = tables[12]
T13 = tables[13]
T14 = tables[14]
T15 = tables[15]
y = 0
for i in range(0, len(buf), 16):
bs = (y ^ fb(buf[i:i + 16], "little")).to_bytes(16, "little")
y = (T0[bs[0]] ^ T1[bs[1]] ^ T2[bs[2]] ^ T3[bs[3]] ^
T4[bs[4]] ^ T5[bs[5]] ^ T6[bs[6]] ^ T7[bs[7]] ^
T8[bs[8]] ^ T9[bs[9]] ^ T10[bs[10]] ^ T11[bs[11]] ^
T12[bs[12]] ^ T13[bs[13]] ^ T14[bs[14]] ^ T15[bs[15]])
return y
def _polyval_run_buf(h: int, buf) -> int:
"""POLYVAL over ``buf`` (length a multiple of 16), picking the cheaper tables.
For messages of at least _POLYVAL8_MIN_BLOCKS blocks the byte-window tables
halve the number of table reads per block; they are only used when the table
cache is on (otherwise their larger build cost is paid on every call).
"""
if _CACHE_ENABLED and len(buf) >= _POLYVAL8_MIN_BLOCKS * 16:
return _polyval_run8(buf, _polyval_tables8(h))
return _polyval_run(buf, _polyval_tables(h))
def polyval(h: bytes, data: bytes) -> bytes: def polyval(h: bytes, data: bytes) -> bytes:
"""POLYVAL(H, data): the data length must be a multiple of 16; returns a 16-byte digest. """POLYVAL(H, data): the data length must be a multiple of 16; returns a 16-byte digest.
@@ -258,14 +400,10 @@ def polyval(h: bytes, data: bytes) -> bytes:
return err(PPYC_ERR_INVALID_LENGTH, return err(PPYC_ERR_INVALID_LENGTH,
f"POLYVAL input length must be a multiple of 16, got {len(data)}", f"POLYVAL input length must be a multiple of 16, got {len(data)}",
"pad the input to a multiple of 16 bytes") "pad the input to a multiple of 16 bytes")
tables = _polyval_tables(int.from_bytes(h, "little")) y = _polyval_run_buf(int.from_bytes(h, "little"), data)
y = 0
for i in range(0, len(data), 16):
y = _polyval_lookup(y ^ int.from_bytes(data[i:i + 16], "little"), tables)
return y.to_bytes(16, "little") return y.to_bytes(16, "little")
# ============================================================
# 12. AES-GCM-SIV (RFC 8452 sections 4/5) # 12. AES-GCM-SIV (RFC 8452 sections 4/5)
# ============================================================ # ============================================================
@@ -306,6 +444,26 @@ def _derive_keys(key: bytes, nonce: bytes) -> Tuple[bytes, bytes]:
return auth_key, enc_key return auth_key, enc_key
def _enc_aes_for(enc_key: bytes) -> AES:
"""Return an AES object for a per-message encryption key.
When the cache is enabled the expanded key schedule is reused across calls
with the same (key, nonce) pair, which removes one AES key expansion (about
45us for AES-256) from every seal/open. ``clear_caches()`` /
``set_cache_enabled(False)`` drop it together with the other caches.
"""
if _CACHE_ENABLED:
hit = _ENC_AES_CACHE.get(enc_key)
if hit is not None:
return hit
obj = AES(enc_key)
if _CACHE_ENABLED:
if len(_ENC_AES_CACHE) >= _ENC_AES_CACHE_MAX:
_ENC_AES_CACHE.pop(next(iter(_ENC_AES_CACHE)))
_ENC_AES_CACHE[enc_key] = obj
return obj
def _auth_tag(auth_key: bytes, enc_aes: AES, nonce: bytes, def _auth_tag(auth_key: bytes, enc_aes: AES, nonce: bytes,
aad: bytes, plaintext: bytes) -> bytes: aad: bytes, plaintext: bytes) -> bytes:
"""Compute the 16-byte tag per RFC 8452 section 4. """Compute the 16-byte tag per RFC 8452 section 4.
@@ -324,22 +482,18 @@ def _auth_tag(auth_key: bytes, enc_aes: AES, nonce: bytes,
* The total POLYVAL input length is a multiple of 16, because aad and pt are each zero-padded to whole blocks, * The total POLYVAL input length is a multiple of 16, because aad and pt are each zero-padded to whole blocks,
plus the 16-byte length_block. plus the 16-byte length_block.
""" """
tables = _polyval_tables(int.from_bytes(auth_key, "little"))
pad_aad = aad + b"\x00" * ((16 - (len(aad) & 15)) & 15) pad_aad = aad + b"\x00" * ((16 - (len(aad) & 15)) & 15)
pad_pt = plaintext + b"\x00" * ((16 - (len(plaintext) & 15)) & 15) pad_pt = plaintext + b"\x00" * ((16 - (len(plaintext) & 15)) & 15)
length_block = ((len(aad) * 8).to_bytes(8, "little") + length_block = ((len(aad) * 8).to_bytes(8, "little") +
(len(plaintext) * 8).to_bytes(8, "little")) (len(plaintext) * 8).to_bytes(8, "little"))
y = 0
buf = pad_aad + pad_pt + length_block buf = pad_aad + pad_pt + length_block
for i in range(0, len(buf), 16): y = _polyval_run_buf(int.from_bytes(auth_key, "little"), buf)
y = _polyval_lookup(y ^ int.from_bytes(buf[i:i + 16], "little"), tables)
block = bytearray(y.to_bytes(16, "little")) # S_s[0:12] ^= nonce, S_s[15] &= 0x7f, tag = AES(enc_key, S_s); done as one
for i in range(_SIV_NONCE_LEN): # integer operation (the nonce occupies the low 12 little-endian bytes).
block[i] ^= nonce[i] s = (y ^ int.from_bytes(nonce, "little")) & _SIV_CLEAR_TOP
block[15] &= 0x7F return enc_aes.encrypt_block(s.to_bytes(16, "little"))
return enc_aes.encrypt_block(bytes(block))
# ---- Multiprocessing CTR worker (top-level function so the pool can pickle it) ---- # ---- Multiprocessing CTR worker (top-level function so the pool can pickle it) ----
@@ -404,29 +558,33 @@ def _ctr_xor(enc_aes: AES, tag: bytes, data: bytes, n_workers: int = None) -> by
return (int.from_bytes(data, "little") ^ return (int.from_bytes(data, "little") ^
int.from_bytes(ks, "little")).to_bytes(n, "little") int.from_bytes(ks, "little")).to_bytes(n, "little")
encrypt_block = enc_aes.encrypt_block # bind to a local name to reduce attribute lookups # ---- Serial path ------------------------------------------------
# Drive the unrolled AES core directly on integers (big-endian 128-bit
# packing) and build the complete keystream first. The final xor is then a
# single big-integer operation over the whole message, which removes the
# per-block keystream/data conversions and the per-block slice copy.
core = enc_aes._enc # bound unrolled core: int128 (big-endian) -> int128
eK = enc_aes.eK
to_bytes = int.to_bytes to_bytes = int.to_bytes
from_bytes = int.from_bytes from_bytes = int.from_bytes
M32 = 0xFFFFFFFF M32 = 0xFFFFFFFF
n = len(data) n = len(data)
out = bytearray(n) ks = bytearray(n)
pos = 0 pos = 0
full = n - (n & 15) # length of the whole-block part full = n - (n & 15) # length of the whole-block part
while pos < full: while pos < full:
ks = encrypt_block(to_bytes(ctr & M32, 4, "little") + tail) ks[pos:pos + 16] = core(
from_bytes(to_bytes(ctr & M32, 4, "little") + tail, "big"),
eK).to_bytes(16, "big")
ctr += 1 ctr += 1
# Integer XOR: 16 bytes at once, avoiding a per-byte Python loop
out[pos:pos + 16] = to_bytes(
from_bytes(data[pos:pos + 16], "little") ^ from_bytes(ks, "little"),
16, "little")
pos += 16 pos += 16
if pos < n: # trailing partial block of fewer than 16 bytes if pos < n: # trailing partial block of fewer than 16 bytes
ks = encrypt_block(to_bytes(ctr & M32, 4, "little") + tail) ks[pos:] = core(
rem = n - pos from_bytes(to_bytes(ctr & M32, 4, "little") + tail, "big"),
chunk = data[pos:] eK).to_bytes(16, "big")[:n - pos]
out[pos:] = bytes(x ^ y for x, y in zip(chunk, ks[:rem])) # data and ks are both n-byte big-endian integers, so a single xor covers
ctr = (ctr + 1) & MASK32 # every byte, including the trailing partial block.
return bytes(out) return (from_bytes(data, "big") ^ from_bytes(ks, "big")).to_bytes(n, "big")
def _check_key_nonce(key: bytes, nonce: bytes): def _check_key_nonce(key: bytes, nonce: bytes):
@@ -471,7 +629,7 @@ def _seal(key: bytes, nonce: bytes, plaintext: bytes, aad: bytes,
if _len_err is not None: if _len_err is not None:
return _len_err return _len_err
auth_key, enc_key = _derive_keys(key, nonce) auth_key, enc_key = _derive_keys(key, nonce)
enc_aes = AES(enc_key) enc_aes = _enc_aes_for(enc_key)
tag = _auth_tag(auth_key, enc_aes, nonce, aad, plaintext) tag = _auth_tag(auth_key, enc_aes, nonce, aad, plaintext)
ct = _ctr_xor(enc_aes, tag, plaintext, n_workers) ct = _ctr_xor(enc_aes, tag, plaintext, n_workers)
return ct, tag return ct, tag
@@ -487,7 +645,7 @@ def _open(key: bytes, nonce: bytes, ct: bytes, tag: bytes, aad: bytes,
if _len_err is not None: if _len_err is not None:
return _len_err return _len_err
auth_key, enc_key = _derive_keys(key, nonce) auth_key, enc_key = _derive_keys(key, nonce)
enc_aes = AES(enc_key) enc_aes = _enc_aes_for(enc_key)
# Decrypt first (untrusted), then verify; plaintext is never returned when verification fails # Decrypt first (untrusted), then verify; plaintext is never returned when verification fails
plaintext = _ctr_xor(enc_aes, tag, ct, n_workers) plaintext = _ctr_xor(enc_aes, tag, ct, n_workers)
expected = _auth_tag(auth_key, enc_aes, nonce, aad, plaintext) expected = _auth_tag(auth_key, enc_aes, nonce, aad, plaintext)
+236 -130
View File
@@ -21,114 +21,192 @@ from ._ppyc_error import (
# ============================================================ # ============================================================
# 10. ChaCha20 / Poly1305 / XChaCha20-Poly1305 # 10. ChaCha20 / Poly1305 / XChaCha20-Poly1305
# ============================================================ # ============================================================
#
# Performance note
# ----------------
# The ChaCha20 core is implemented with "SWAR" (SIMD Within A Register)
# big-integer arithmetic: four consecutive 64-byte keystream blocks are
# computed simultaneously by packing the four 32-bit lanes of every one of
# the sixteen state words into a single Python ``int`` (one lane per 64-bit
# slot). ``+`` / ``^`` then act on all four blocks at once, and the 32-bit
# lane-local rotations are expressed as
# ``((t << n) | (t >> (32 - n))) & _SW_MASK``. The 64-bit slots leave 32
# guard bits per lane so that shifted-out bits are simply masked away, which
# keeps every lane independent (no cross-lane carry/contamination).
#
# This is *pure Python / zero dependency*: it only uses built-in ``int``
# operations and ``struct``. A single block still costs the same as a group
# of four, yet this is still ~4-5x faster than the scalar quarter-round loop.
def _chacha20_block(key: bytes, counter: int, nonce: bytes) -> bytes: _M32 = 0xFFFFFFFF
_SW_MASK = _M32 | (_M32 << 64) | (_M32 << 128) | (_M32 << 192)
_SW_BCAST = 1 | (1 << 64) | (1 << 128) | (1 << 192)
def _chacha20_blocks(key: bytes, nonce: bytes, counter_start: int, n_blocks: int) -> bytes:
"""Generate ``n_blocks`` consecutive 64-byte ChaCha20 keystream blocks.
Internal helper (not part of the public API). Blocks ``counter_start``,
``counter_start + 1``, ... are produced; the 32-bit block counter wraps
around modulo 2**32 exactly like the scalar routine. Four blocks are
computed simultaneously with SWAR big-integer arithmetic; when
``n_blocks`` is not a multiple of four the surplus blocks are computed and
then trimmed away.
Returns
----
bytes : ``n_blocks * 64`` bytes of keystream.
"""
k0, k1, k2, k3, k4, k5, k6, k7 = struct.unpack("<8I", key) k0, k1, k2, k3, k4, k5, k6, k7 = struct.unpack("<8I", key)
n0, n1, n2 = struct.unpack("<3I", nonce) n0, n1, n2 = struct.unpack("<3I", nonce)
M = MASK32 M = _M32
x0 = 0x61707865; x1 = 0x3320646e; x2 = 0x79622d32; x3 = 0x6b206574 MASK = _SW_MASK
x4, x5, x6, x7 = k0, k1, k2, k3 BK = _SW_BCAST
x8, x9, x10, x11 = k4, k5, k6, k7 pack = struct.pack
x12 = counter & M; x13, x14, x15 = n0, n1, n2 out = bytearray()
o0, o1, o2, o3 = x0, x1, x2, x3 cnt = counter_start & M
o4, o5, o6, o7 = x4, x5, x6, x7 for _ in range((n_blocks + 3) >> 2):
o8, o9, o10, o11 = x8, x9, x10, x11 x0 = 0x61707865 * BK; x1 = 0x3320646e * BK; x2 = 0x79622d32 * BK; x3 = 0x6b206574 * BK
o12, o13, o14, o15 = x12, x13, x14, x15 x4 = k0 * BK; x5 = k1 * BK; x6 = k2 * BK; x7 = k3 * BK
for _ in range(10): x8 = k4 * BK; x9 = k5 * BK; x10 = k6 * BK; x11 = k7 * BK
x0 = (x0 + x4) & M; x12 = ((x12 ^ x0) << 16 | (x12 ^ x0) >> 16) & M x12 = cnt | (((cnt + 1) & M) << 64) | (((cnt + 2) & M) << 128) | (((cnt + 3) & M) << 192)
x8 = (x8 + x12) & M; x4 = ((x4 ^ x8) << 12 | (x4 ^ x8) >> 20) & M x13 = n0 * BK; x14 = n1 * BK; x15 = n2 * BK
x0 = (x0 + x4) & M; x12 = ((x12 ^ x0) << 8 | (x12 ^ x0) >> 24) & M o0 = x0; o1 = x1; o2 = x2; o3 = x3; o4 = x4; o5 = x5; o6 = x6; o7 = x7
x8 = (x8 + x12) & M; x4 = ((x4 ^ x8) << 7 | (x4 ^ x8) >> 25) & M o8 = x8; o9 = x9; o10 = x10; o11 = x11; o12 = x12; o13 = x13; o14 = x14; o15 = x15
x1 = (x1 + x5) & M; x13 = ((x13 ^ x1) << 16 | (x13 ^ x1) >> 16) & M for _r in range(10):
x9 = (x9 + x13) & M; x5 = ((x5 ^ x9) << 12 | (x5 ^ x9) >> 20) & M x0 = (x0 + x4) & MASK; t = x12 ^ x0; x12 = ((t << 16) | (t >> 16)) & MASK
x1 = (x1 + x5) & M; x13 = ((x13 ^ x1) << 8 | (x13 ^ x1) >> 24) & M x8 = (x8 + x12) & MASK; t = x4 ^ x8; x4 = ((t << 12) | (t >> 20)) & MASK
x9 = (x9 + x13) & M; x5 = ((x5 ^ x9) << 7 | (x5 ^ x9) >> 25) & M x0 = (x0 + x4) & MASK; t = x12 ^ x0; x12 = ((t << 8) | (t >> 24)) & MASK
x2 = (x2 + x6) & M; x14 = ((x14 ^ x2) << 16 | (x14 ^ x2) >> 16) & M x8 = (x8 + x12) & MASK; t = x4 ^ x8; x4 = ((t << 7) | (t >> 25)) & MASK
x10 = (x10 + x14) & M; x6 = ((x6 ^ x10) << 12 | (x6 ^ x10) >> 20) & M x1 = (x1 + x5) & MASK; t = x13 ^ x1; x13 = ((t << 16) | (t >> 16)) & MASK
x2 = (x2 + x6) & M; x14 = ((x14 ^ x2) << 8 | (x14 ^ x2) >> 24) & M x9 = (x9 + x13) & MASK; t = x5 ^ x9; x5 = ((t << 12) | (t >> 20)) & MASK
x10 = (x10 + x14) & M; x6 = ((x6 ^ x10) << 7 | (x6 ^ x10) >> 25) & M x1 = (x1 + x5) & MASK; t = x13 ^ x1; x13 = ((t << 8) | (t >> 24)) & MASK
x3 = (x3 + x7) & M; x15 = ((x15 ^ x3) << 16 | (x15 ^ x3) >> 16) & M x9 = (x9 + x13) & MASK; t = x5 ^ x9; x5 = ((t << 7) | (t >> 25)) & MASK
x11 = (x11 + x15) & M; x7 = ((x7 ^ x11) << 12 | (x7 ^ x11) >> 20) & M x2 = (x2 + x6) & MASK; t = x14 ^ x2; x14 = ((t << 16) | (t >> 16)) & MASK
x3 = (x3 + x7) & M; x15 = ((x15 ^ x3) << 8 | (x15 ^ x3) >> 24) & M x10 = (x10 + x14) & MASK; t = x6 ^ x10; x6 = ((t << 12) | (t >> 20)) & MASK
x11 = (x11 + x15) & M; x7 = ((x7 ^ x11) << 7 | (x7 ^ x11) >> 25) & M x2 = (x2 + x6) & MASK; t = x14 ^ x2; x14 = ((t << 8) | (t >> 24)) & MASK
x0 = (x0 + x5) & M; x15 = ((x15 ^ x0) << 16 | (x15 ^ x0) >> 16) & M x10 = (x10 + x14) & MASK; t = x6 ^ x10; x6 = ((t << 7) | (t >> 25)) & MASK
x10 = (x10 + x15) & M; x5 = ((x5 ^ x10) << 12 | (x5 ^ x10) >> 20) & M x3 = (x3 + x7) & MASK; t = x15 ^ x3; x15 = ((t << 16) | (t >> 16)) & MASK
x0 = (x0 + x5) & M; x15 = ((x15 ^ x0) << 8 | (x15 ^ x0) >> 24) & M x11 = (x11 + x15) & MASK; t = x7 ^ x11; x7 = ((t << 12) | (t >> 20)) & MASK
x10 = (x10 + x15) & M; x5 = ((x5 ^ x10) << 7 | (x5 ^ x10) >> 25) & M x3 = (x3 + x7) & MASK; t = x15 ^ x3; x15 = ((t << 8) | (t >> 24)) & MASK
x1 = (x1 + x6) & M; x12 = ((x12 ^ x1) << 16 | (x12 ^ x1) >> 16) & M x11 = (x11 + x15) & MASK; t = x7 ^ x11; x7 = ((t << 7) | (t >> 25)) & MASK
x11 = (x11 + x12) & M; x6 = ((x6 ^ x11) << 12 | (x6 ^ x11) >> 20) & M x0 = (x0 + x5) & MASK; t = x15 ^ x0; x15 = ((t << 16) | (t >> 16)) & MASK
x1 = (x1 + x6) & M; x12 = ((x12 ^ x1) << 8 | (x12 ^ x1) >> 24) & M x10 = (x10 + x15) & MASK; t = x5 ^ x10; x5 = ((t << 12) | (t >> 20)) & MASK
x11 = (x11 + x12) & M; x6 = ((x6 ^ x11) << 7 | (x6 ^ x11) >> 25) & M x0 = (x0 + x5) & MASK; t = x15 ^ x0; x15 = ((t << 8) | (t >> 24)) & MASK
x2 = (x2 + x7) & M; x13 = ((x13 ^ x2) << 16 | (x13 ^ x2) >> 16) & M x10 = (x10 + x15) & MASK; t = x5 ^ x10; x5 = ((t << 7) | (t >> 25)) & MASK
x8 = (x8 + x13) & M; x7 = ((x7 ^ x8) << 12 | (x7 ^ x8) >> 20) & M x1 = (x1 + x6) & MASK; t = x12 ^ x1; x12 = ((t << 16) | (t >> 16)) & MASK
x2 = (x2 + x7) & M; x13 = ((x13 ^ x2) << 8 | (x13 ^ x2) >> 24) & M x11 = (x11 + x12) & MASK; t = x6 ^ x11; x6 = ((t << 12) | (t >> 20)) & MASK
x8 = (x8 + x13) & M; x7 = ((x7 ^ x8) << 7 | (x7 ^ x8) >> 25) & M x1 = (x1 + x6) & MASK; t = x12 ^ x1; x12 = ((t << 8) | (t >> 24)) & MASK
x3 = (x3 + x4) & M; x14 = ((x14 ^ x3) << 16 | (x14 ^ x3) >> 16) & M x11 = (x11 + x12) & MASK; t = x6 ^ x11; x6 = ((t << 7) | (t >> 25)) & MASK
x9 = (x9 + x14) & M; x4 = ((x4 ^ x9) << 12 | (x4 ^ x9) >> 20) & M x2 = (x2 + x7) & MASK; t = x13 ^ x2; x13 = ((t << 16) | (t >> 16)) & MASK
x3 = (x3 + x4) & M; x14 = ((x14 ^ x3) << 8 | (x14 ^ x3) >> 24) & M x8 = (x8 + x13) & MASK; t = x7 ^ x8; x7 = ((t << 12) | (t >> 20)) & MASK
x9 = (x9 + x14) & M; x4 = ((x4 ^ x9) << 7 | (x4 ^ x9) >> 25) & M x2 = (x2 + x7) & MASK; t = x13 ^ x2; x13 = ((t << 8) | (t >> 24)) & MASK
return struct.pack("<16I", x8 = (x8 + x13) & MASK; t = x7 ^ x8; x7 = ((t << 7) | (t >> 25)) & MASK
(x0 + o0) & M, (x1 + o1) & M, (x2 + o2) & M, (x3 + o3) & M, x3 = (x3 + x4) & MASK; t = x14 ^ x3; x14 = ((t << 16) | (t >> 16)) & MASK
(x4 + o4) & M, (x5 + o5) & M, (x6 + o6) & M, (x7 + o7) & M, x9 = (x9 + x14) & MASK; t = x4 ^ x9; x4 = ((t << 12) | (t >> 20)) & MASK
(x8 + o8) & M, (x9 + o9) & M, (x10 + o10) & M, (x11 + o11) & M, x3 = (x3 + x4) & MASK; t = x14 ^ x3; x14 = ((t << 8) | (t >> 24)) & MASK
(x12 + o12) & M, (x13 + o13) & M, (x14 + o14) & M, (x15 + o15) & M) x9 = (x9 + x14) & MASK; t = x4 ^ x9; x4 = ((t << 7) | (t >> 25)) & MASK
cnt = (cnt + 4) & M
r = [0] * 64
v = (x0 + o0) & MASK
r[0] = v & M; r[16] = (v >> 64) & M; r[32] = (v >> 128) & M; r[48] = (v >> 192) & M
v = (x1 + o1) & MASK
r[1] = v & M; r[17] = (v >> 64) & M; r[33] = (v >> 128) & M; r[49] = (v >> 192) & M
v = (x2 + o2) & MASK
r[2] = v & M; r[18] = (v >> 64) & M; r[34] = (v >> 128) & M; r[50] = (v >> 192) & M
v = (x3 + o3) & MASK
r[3] = v & M; r[19] = (v >> 64) & M; r[35] = (v >> 128) & M; r[51] = (v >> 192) & M
v = (x4 + o4) & MASK
r[4] = v & M; r[20] = (v >> 64) & M; r[36] = (v >> 128) & M; r[52] = (v >> 192) & M
v = (x5 + o5) & MASK
r[5] = v & M; r[21] = (v >> 64) & M; r[37] = (v >> 128) & M; r[53] = (v >> 192) & M
v = (x6 + o6) & MASK
r[6] = v & M; r[22] = (v >> 64) & M; r[38] = (v >> 128) & M; r[54] = (v >> 192) & M
v = (x7 + o7) & MASK
r[7] = v & M; r[23] = (v >> 64) & M; r[39] = (v >> 128) & M; r[55] = (v >> 192) & M
v = (x8 + o8) & MASK
r[8] = v & M; r[24] = (v >> 64) & M; r[40] = (v >> 128) & M; r[56] = (v >> 192) & M
v = (x9 + o9) & MASK
r[9] = v & M; r[25] = (v >> 64) & M; r[41] = (v >> 128) & M; r[57] = (v >> 192) & M
v = (x10 + o10) & MASK
r[10] = v & M; r[26] = (v >> 64) & M; r[42] = (v >> 128) & M; r[58] = (v >> 192) & M
v = (x11 + o11) & MASK
r[11] = v & M; r[27] = (v >> 64) & M; r[43] = (v >> 128) & M; r[59] = (v >> 192) & M
v = (x12 + o12) & MASK
r[12] = v & M; r[28] = (v >> 64) & M; r[44] = (v >> 128) & M; r[60] = (v >> 192) & M
v = (x13 + o13) & MASK
r[13] = v & M; r[29] = (v >> 64) & M; r[45] = (v >> 128) & M; r[61] = (v >> 192) & M
v = (x14 + o14) & MASK
r[14] = v & M; r[30] = (v >> 64) & M; r[46] = (v >> 128) & M; r[62] = (v >> 192) & M
v = (x15 + o15) & MASK
r[15] = v & M; r[31] = (v >> 64) & M; r[47] = (v >> 128) & M; r[63] = (v >> 192) & M
out += pack("<64I", *r)
return bytes(out)[:n_blocks << 6]
def _chacha20_block(key: bytes, counter: int, nonce: bytes) -> bytes:
"""Return a single 64-byte ChaCha20 keystream block (internal helper)."""
return _chacha20_blocks(key, nonce, counter, 1)
def _chacha20_keystream(key: bytes, nonce: bytes, counter_start: int, n_bytes: int) -> bytes: def _chacha20_keystream(key: bytes, nonce: bytes, counter_start: int, n_bytes: int) -> bytes:
out = bytearray() """Return ``n_bytes`` of ChaCha20 keystream starting at ``counter_start`` (internal helper)."""
counter = counter_start if n_bytes <= 0:
remaining = n_bytes return b""
while remaining > 0: return _chacha20_blocks(key, nonce, counter_start, (n_bytes + 63) >> 6)[:n_bytes]
block = _chacha20_block(key, counter, nonce)
take = min(remaining, 64)
out += block[:take]
counter = (counter + 1) & MASK32
remaining -= take
return bytes(out)
def _hchacha20(key: bytes, nonce16: bytes) -> bytes: def _hchacha20(key: bytes, nonce16: bytes) -> bytes:
"""HChaCha20 (RFC draft-irtf-cfrg-xchacha) - derive a 32-byte subkey (internal helper).
Uses the same SWAR engine as :func:`_chacha20_blocks`; the four packed
lanes carry the identical 16-word state (HChaCha20 has no block counter),
so every lane yields the same result and lane 0 is read back.
"""
k0, k1, k2, k3, k4, k5, k6, k7 = struct.unpack("<8I", key) k0, k1, k2, k3, k4, k5, k6, k7 = struct.unpack("<8I", key)
n0, n1, n2, n3 = struct.unpack("<4I", nonce16) n0, n1, n2, n3 = struct.unpack("<4I", nonce16)
M = MASK32 M = _M32
x0 = 0x61707865; x1 = 0x3320646e; x2 = 0x79622d32; x3 = 0x6b206574 MASK = _SW_MASK
x4, x5, x6, x7 = k0, k1, k2, k3 BK = _SW_BCAST
x8, x9, x10, x11 = k4, k5, k6, k7 x0 = 0x61707865 * BK; x1 = 0x3320646e * BK; x2 = 0x79622d32 * BK; x3 = 0x6b206574 * BK
x12, x13, x14, x15 = n0, n1, n2, n3 x4 = k0 * BK; x5 = k1 * BK; x6 = k2 * BK; x7 = k3 * BK
for _ in range(10): x8 = k4 * BK; x9 = k5 * BK; x10 = k6 * BK; x11 = k7 * BK
x0 = (x0 + x4) & M; x12 = ((x12 ^ x0) << 16 | (x12 ^ x0) >> 16) & M x12 = n0 * BK; x13 = n1 * BK; x14 = n2 * BK; x15 = n3 * BK
x8 = (x8 + x12) & M; x4 = ((x4 ^ x8) << 12 | (x4 ^ x8) >> 20) & M for _r in range(10):
x0 = (x0 + x4) & M; x12 = ((x12 ^ x0) << 8 | (x12 ^ x0) >> 24) & M x0 = (x0 + x4) & MASK; t = x12 ^ x0; x12 = ((t << 16) | (t >> 16)) & MASK
x8 = (x8 + x12) & M; x4 = ((x4 ^ x8) << 7 | (x4 ^ x8) >> 25) & M x8 = (x8 + x12) & MASK; t = x4 ^ x8; x4 = ((t << 12) | (t >> 20)) & MASK
x1 = (x1 + x5) & M; x13 = ((x13 ^ x1) << 16 | (x13 ^ x1) >> 16) & M x0 = (x0 + x4) & MASK; t = x12 ^ x0; x12 = ((t << 8) | (t >> 24)) & MASK
x9 = (x9 + x13) & M; x5 = ((x5 ^ x9) << 12 | (x5 ^ x9) >> 20) & M x8 = (x8 + x12) & MASK; t = x4 ^ x8; x4 = ((t << 7) | (t >> 25)) & MASK
x1 = (x1 + x5) & M; x13 = ((x13 ^ x1) << 8 | (x13 ^ x1) >> 24) & M x1 = (x1 + x5) & MASK; t = x13 ^ x1; x13 = ((t << 16) | (t >> 16)) & MASK
x9 = (x9 + x13) & M; x5 = ((x5 ^ x9) << 7 | (x5 ^ x9) >> 25) & M x9 = (x9 + x13) & MASK; t = x5 ^ x9; x5 = ((t << 12) | (t >> 20)) & MASK
x2 = (x2 + x6) & M; x14 = ((x14 ^ x2) << 16 | (x14 ^ x2) >> 16) & M x1 = (x1 + x5) & MASK; t = x13 ^ x1; x13 = ((t << 8) | (t >> 24)) & MASK
x10 = (x10 + x14) & M; x6 = ((x6 ^ x10) << 12 | (x6 ^ x10) >> 20) & M x9 = (x9 + x13) & MASK; t = x5 ^ x9; x5 = ((t << 7) | (t >> 25)) & MASK
x2 = (x2 + x6) & M; x14 = ((x14 ^ x2) << 8 | (x14 ^ x2) >> 24) & M x2 = (x2 + x6) & MASK; t = x14 ^ x2; x14 = ((t << 16) | (t >> 16)) & MASK
x10 = (x10 + x14) & M; x6 = ((x6 ^ x10) << 7 | (x6 ^ x10) >> 25) & M x10 = (x10 + x14) & MASK; t = x6 ^ x10; x6 = ((t << 12) | (t >> 20)) & MASK
x3 = (x3 + x7) & M; x15 = ((x15 ^ x3) << 16 | (x15 ^ x3) >> 16) & M x2 = (x2 + x6) & MASK; t = x14 ^ x2; x14 = ((t << 8) | (t >> 24)) & MASK
x11 = (x11 + x15) & M; x7 = ((x7 ^ x11) << 12 | (x7 ^ x11) >> 20) & M x10 = (x10 + x14) & MASK; t = x6 ^ x10; x6 = ((t << 7) | (t >> 25)) & MASK
x3 = (x3 + x7) & M; x15 = ((x15 ^ x3) << 8 | (x15 ^ x3) >> 24) & M x3 = (x3 + x7) & MASK; t = x15 ^ x3; x15 = ((t << 16) | (t >> 16)) & MASK
x11 = (x11 + x15) & M; x7 = ((x7 ^ x11) << 7 | (x7 ^ x11) >> 25) & M x11 = (x11 + x15) & MASK; t = x7 ^ x11; x7 = ((t << 12) | (t >> 20)) & MASK
x0 = (x0 + x5) & M; x15 = ((x15 ^ x0) << 16 | (x15 ^ x0) >> 16) & M x3 = (x3 + x7) & MASK; t = x15 ^ x3; x15 = ((t << 8) | (t >> 24)) & MASK
x10 = (x10 + x15) & M; x5 = ((x5 ^ x10) << 12 | (x5 ^ x10) >> 20) & M x11 = (x11 + x15) & MASK; t = x7 ^ x11; x7 = ((t << 7) | (t >> 25)) & MASK
x0 = (x0 + x5) & M; x15 = ((x15 ^ x0) << 8 | (x15 ^ x0) >> 24) & M x0 = (x0 + x5) & MASK; t = x15 ^ x0; x15 = ((t << 16) | (t >> 16)) & MASK
x10 = (x10 + x15) & M; x5 = ((x5 ^ x10) << 7 | (x5 ^ x10) >> 25) & M x10 = (x10 + x15) & MASK; t = x5 ^ x10; x5 = ((t << 12) | (t >> 20)) & MASK
x1 = (x1 + x6) & M; x12 = ((x12 ^ x1) << 16 | (x12 ^ x1) >> 16) & M x0 = (x0 + x5) & MASK; t = x15 ^ x0; x15 = ((t << 8) | (t >> 24)) & MASK
x11 = (x11 + x12) & M; x6 = ((x6 ^ x11) << 12 | (x6 ^ x11) >> 20) & M x10 = (x10 + x15) & MASK; t = x5 ^ x10; x5 = ((t << 7) | (t >> 25)) & MASK
x1 = (x1 + x6) & M; x12 = ((x12 ^ x1) << 8 | (x12 ^ x1) >> 24) & M x1 = (x1 + x6) & MASK; t = x12 ^ x1; x12 = ((t << 16) | (t >> 16)) & MASK
x11 = (x11 + x12) & M; x6 = ((x6 ^ x11) << 7 | (x6 ^ x11) >> 25) & M x11 = (x11 + x12) & MASK; t = x6 ^ x11; x6 = ((t << 12) | (t >> 20)) & MASK
x2 = (x2 + x7) & M; x13 = ((x13 ^ x2) << 16 | (x13 ^ x2) >> 16) & M x1 = (x1 + x6) & MASK; t = x12 ^ x1; x12 = ((t << 8) | (t >> 24)) & MASK
x8 = (x8 + x13) & M; x7 = ((x7 ^ x8) << 12 | (x7 ^ x8) >> 20) & M x11 = (x11 + x12) & MASK; t = x6 ^ x11; x6 = ((t << 7) | (t >> 25)) & MASK
x2 = (x2 + x7) & M; x13 = ((x13 ^ x2) << 8 | (x13 ^ x2) >> 24) & M x2 = (x2 + x7) & MASK; t = x13 ^ x2; x13 = ((t << 16) | (t >> 16)) & MASK
x8 = (x8 + x13) & M; x7 = ((x7 ^ x8) << 7 | (x7 ^ x8) >> 25) & M x8 = (x8 + x13) & MASK; t = x7 ^ x8; x7 = ((t << 12) | (t >> 20)) & MASK
x3 = (x3 + x4) & M; x14 = ((x14 ^ x3) << 16 | (x14 ^ x3) >> 16) & M x2 = (x2 + x7) & MASK; t = x13 ^ x2; x13 = ((t << 8) | (t >> 24)) & MASK
x9 = (x9 + x14) & M; x4 = ((x4 ^ x9) << 12 | (x4 ^ x9) >> 20) & M x8 = (x8 + x13) & MASK; t = x7 ^ x8; x7 = ((t << 7) | (t >> 25)) & MASK
x3 = (x3 + x4) & M; x14 = ((x14 ^ x3) << 8 | (x14 ^ x3) >> 24) & M x3 = (x3 + x4) & MASK; t = x14 ^ x3; x14 = ((t << 16) | (t >> 16)) & MASK
x9 = (x9 + x14) & M; x4 = ((x4 ^ x9) << 7 | (x4 ^ x9) >> 25) & M x9 = (x9 + x14) & MASK; t = x4 ^ x9; x4 = ((t << 12) | (t >> 20)) & MASK
return struct.pack("<8I", x0, x1, x2, x3, x12, x13, x14, x15) x3 = (x3 + x4) & MASK; t = x14 ^ x3; x14 = ((t << 8) | (t >> 24)) & MASK
x9 = (x9 + x14) & MASK; t = x4 ^ x9; x4 = ((t << 7) | (t >> 25)) & MASK
return struct.pack("<8I", x0 & M, x1 & M, x2 & M, x3 & M,
x12 & M, x13 & M, x14 & M, x15 & M)
# ---- Poly1305 ---- # ---- Poly1305 ----
@@ -155,23 +233,46 @@ def poly1305_mac(key32: bytes, msg: bytes) -> bytes:
return err(PPYC_ERR_INVALID_KEY_LEN, return err(PPYC_ERR_INVALID_KEY_LEN,
f"Poly1305 key must be 32 bytes, got {len(key32)}", f"Poly1305 key must be 32 bytes, got {len(key32)}",
"pass a 32 byte one-time key (r || s)") "pass a 32 byte one-time key (r || s)")
r = int.from_bytes(key32[:16], "little") r = _poly1305_clamp(int.from_bytes(key32[:16], "little"))
s = int.from_bytes(key32[16:32], "little") s = int.from_bytes(key32[16:32], "little")
r = _poly1305_clamp(r)
acc = 0
p = POLY1305_P p = POLY1305_P
fb = int.from_bytes
n_full = len(msg) // 16 acc = 0
for i in range(n_full): n_full = len(msg) >> 4
n = int.from_bytes(msg[i * 16:(i + 1) * 16], "little") | (1 << 128) if n_full >= 16:
acc = ((acc + n) * r) % p # Batch 8 blocks per modular reduction (precomputed powers of r).
# Horner over one group: acc' = (acc+n0)*r^8 + n1*r^7 + ... + n7*r
rem = len(msg) - n_full * 16 K = 8
rp = [1] * (K + 1)
rp[1] = r
for _i in range(2, K + 1):
rp[_i] = (rp[_i - 1] * r) % p
rK = rp[K]
i = 0
while i + K <= n_full:
o = i << 4
t = (acc + (fb(msg[o:o + 16], "little") | (1 << 128))) * rK
t += (fb(msg[o + 16:o + 32], "little") | (1 << 128)) * rp[7]
t += (fb(msg[o + 32:o + 48], "little") | (1 << 128)) * rp[6]
t += (fb(msg[o + 48:o + 64], "little") | (1 << 128)) * rp[5]
t += (fb(msg[o + 64:o + 80], "little") | (1 << 128)) * rp[4]
t += (fb(msg[o + 80:o + 96], "little") | (1 << 128)) * rp[3]
t += (fb(msg[o + 96:o + 112], "little") | (1 << 128)) * rp[2]
t += (fb(msg[o + 112:o + 128], "little") | (1 << 128)) * rp[1]
acc = t % p
i += K
while i < n_full:
o = i << 4
acc = ((acc + (fb(msg[o:o + 16], "little") | (1 << 128))) * r) % p
i += 1
else:
for i in range(n_full):
o = i << 4
acc = ((acc + (fb(msg[o:o + 16], "little") | (1 << 128))) * r) % p
rem = len(msg) - (n_full << 4)
if rem: if rem:
block = msg[n_full * 16:] + b"\x01" + b"\x00" * (15 - rem) blk = msg[n_full << 4:] + b"\x01" + b"\x00" * (15 - rem)
n = int.from_bytes(block, "little") acc = ((acc + fb(blk, "little")) * r) % p
acc = ((acc + n) * r) % p
acc = (acc + s) & MASK128 acc = (acc + s) & MASK128
return acc.to_bytes(16, "little") return acc.to_bytes(16, "little")
@@ -184,9 +285,8 @@ _CC_NONCE_LEN = 24
def _poly1305_aead_data(aad: bytes, ct: bytes) -> bytes: def _poly1305_aead_data(aad: bytes, ct: bytes) -> bytes:
return _pad16(aad) + _pad16(ct) + ( return b"".join((_pad16(aad), _pad16(ct),
len(aad).to_bytes(8, "little") + len(ct).to_bytes(8, "little") len(aad).to_bytes(8, "little"), len(ct).to_bytes(8, "little")))
)
def xchacha20poly1305_encrypt(key: bytes, nonce: bytes, plaintext: bytes, def xchacha20poly1305_encrypt(key: bytes, nonce: bytes, plaintext: bytes,
@@ -217,12 +317,12 @@ def xchacha20poly1305_encrypt(key: bytes, nonce: bytes, plaintext: bytes,
"pass a 24 byte nonce") "pass a 24 byte nonce")
subkey = _hchacha20(key, nonce[:16]) subkey = _hchacha20(key, nonce[:16])
chacha_nonce = b"\x00" * 4 + nonce[16:24] chacha_nonce = b"\x00" * 4 + nonce[16:24]
block0 = _chacha20_block(subkey, 0, chacha_nonce)
poly_key = block0[:32]
if plaintext: if plaintext:
ks = _chacha20_keystream(subkey, chacha_nonce, 1, len(plaintext)) ks = _chacha20_keystream(subkey, chacha_nonce, 0, 64 + len(plaintext))
ct = _xor_bytes_fast(plaintext, ks) poly_key = ks[:32]
ct = _xor_bytes_fast(plaintext, ks[64:])
else: else:
poly_key = _chacha20_blocks(subkey, chacha_nonce, 0, 1)[:32]
ct = b"" ct = b""
tag = poly1305_mac(poly_key, _poly1305_aead_data(aad, ct)) tag = poly1305_mac(poly_key, _poly1305_aead_data(aad, ct))
return ct + tag return ct + tag
@@ -257,8 +357,12 @@ def xchacha20poly1305_decrypt(key: bytes, nonce: bytes, ct_with_tag: bytes,
tag = ct_with_tag[-_CC_TAG_LEN:] tag = ct_with_tag[-_CC_TAG_LEN:]
subkey = _hchacha20(key, nonce[:16]) subkey = _hchacha20(key, nonce[:16])
chacha_nonce = b"\x00" * 4 + nonce[16:24] chacha_nonce = b"\x00" * 4 + nonce[16:24]
block0 = _chacha20_block(subkey, 0, chacha_nonce) if ct:
poly_key = block0[:32] ks = _chacha20_keystream(subkey, chacha_nonce, 0, 64 + len(ct))
poly_key = ks[:32]
else:
ks = None
poly_key = _chacha20_blocks(subkey, chacha_nonce, 0, 1)[:32]
expected = poly1305_mac(poly_key, _poly1305_aead_data(aad, ct)) expected = poly1305_mac(poly_key, _poly1305_aead_data(aad, ct))
if not _consttime_eq(tag, expected): if not _consttime_eq(tag, expected):
return err(PPYC_ERR_AUTH_FAILED, return err(PPYC_ERR_AUTH_FAILED,
@@ -266,8 +370,7 @@ def xchacha20poly1305_decrypt(key: bytes, nonce: bytes, ct_with_tag: bytes,
"check that the key, nonce and AAD match, or whether the data was tampered with") "check that the key, nonce and AAD match, or whether the data was tampered with")
if not ct: if not ct:
return b"" return b""
ks = _chacha20_keystream(subkey, chacha_nonce, 1, len(ct)) return _xor_bytes_fast(ct, ks[64:])
return _xor_bytes_fast(ct, ks)
# ---- ChaCha20-Poly1305 AEAD (IETF, 96-bit nonce, RFC 8439) ---- # ---- ChaCha20-Poly1305 AEAD (IETF, 96-bit nonce, RFC 8439) ----
@@ -298,12 +401,12 @@ def chacha20poly1305_encrypt(key: bytes, nonce: bytes, plaintext: bytes,
return err(PPYC_ERR_INVALID_NONCE_LEN, return err(PPYC_ERR_INVALID_NONCE_LEN,
f"ChaCha20-Poly1305 nonce must be 12 bytes, got {len(nonce)}", f"ChaCha20-Poly1305 nonce must be 12 bytes, got {len(nonce)}",
"pass a 12 byte nonce") "pass a 12 byte nonce")
block0 = _chacha20_block(key, 0, nonce)
poly_key = block0[:32]
if plaintext: if plaintext:
ks = _chacha20_keystream(key, nonce, 1, len(plaintext)) ks = _chacha20_keystream(key, nonce, 0, 64 + len(plaintext))
ct = _xor_bytes_fast(plaintext, ks) poly_key = ks[:32]
ct = _xor_bytes_fast(plaintext, ks[64:])
else: else:
poly_key = _chacha20_blocks(key, nonce, 0, 1)[:32]
ct = b"" ct = b""
tag = poly1305_mac(poly_key, _poly1305_aead_data(aad, ct)) tag = poly1305_mac(poly_key, _poly1305_aead_data(aad, ct))
return ct + tag return ct + tag
@@ -336,8 +439,12 @@ def chacha20poly1305_decrypt(key: bytes, nonce: bytes, ct_with_tag: bytes,
"pass ct||tag (at least 16 bytes long)") "pass ct||tag (at least 16 bytes long)")
ct = ct_with_tag[:-_CC_TAG_LEN] ct = ct_with_tag[:-_CC_TAG_LEN]
tag = ct_with_tag[-_CC_TAG_LEN:] tag = ct_with_tag[-_CC_TAG_LEN:]
block0 = _chacha20_block(key, 0, nonce) if ct:
poly_key = block0[:32] ks = _chacha20_keystream(key, nonce, 0, 64 + len(ct))
poly_key = ks[:32]
else:
ks = None
poly_key = _chacha20_blocks(key, nonce, 0, 1)[:32]
expected = poly1305_mac(poly_key, _poly1305_aead_data(aad, ct)) expected = poly1305_mac(poly_key, _poly1305_aead_data(aad, ct))
if not _consttime_eq(tag, expected): if not _consttime_eq(tag, expected):
return err(PPYC_ERR_AUTH_FAILED, return err(PPYC_ERR_AUTH_FAILED,
@@ -345,5 +452,4 @@ def chacha20poly1305_decrypt(key: bytes, nonce: bytes, ct_with_tag: bytes,
"check that the key, nonce and AAD match, or whether the data was tampered with") "check that the key, nonce and AAD match, or whether the data was tampered with")
if not ct: if not ct:
return b"" return b""
ks = _chacha20_keystream(key, nonce, 1, len(ct)) return _xor_bytes_fast(ct, ks[64:])
return _xor_bytes_fast(ct, ks)
+43 -22
View File
@@ -61,18 +61,24 @@ def _consttime_eq(a: bytes, b: bytes) -> bool:
True if the contents are identical, otherwise False. True if the contents are identical, otherwise False.
This is an internal hot path that cannot fail, so no error tuple is returned. This is an internal hot path that cannot fail, so no error tuple is returned.
""" """
if len(a) != len(b): la = len(a)
la, lb = len(a), len(b) lb = len(b)
diff = la ^ lb if la == lb:
for i in range(max(la, lb)): if la == 0:
x = a[i] if i < la else 0 return True
y = b[i] if i < lb else 0 # Fixed-width big-int compare: (x | hi) ^ (y | hi) == x ^ y, and both operands
diff |= x ^ y # always occupy the same, data-independent number of machine digits, so the
return diff == 0 # running time does not depend on *where* the first difference is (no shortcut).
r = 0 hi = 1 << (la << 3)
for x, y in zip(a, b): return ((int.from_bytes(a, "big") | hi) ^ (int.from_bytes(b, "big") | hi)) == 0
r |= x ^ y # Different lengths can never be equal; still perform a fixed-width masked XOR
return r == 0 # (result discarded) so the runtime depends only on the (public) lengths.
n = la if la > lb else lb
aa = a if la == n else a + bytes(n - la)
bb = b if lb == n else b + bytes(n - lb)
hi = 1 << (n << 3)
_ = (int.from_bytes(aa, "big") | hi) ^ (int.from_bytes(bb, "big") | hi)
return False
def _consttime_int_eq(a: int, b: int, bits: int) -> bool: def _consttime_int_eq(a: int, b: int, bits: int) -> bool:
@@ -83,11 +89,11 @@ def _consttime_int_eq(a: int, b: int, bits: int) -> bool:
bool bool
True if equal, otherwise False. Internal hot path, no error tuple returned. True if equal, otherwise False. Internal hot path, no error tuple returned.
""" """
diff = a ^ b # Keep exactly the same observable semantics as the previous fixed-count
result = 0 # reduction (bits rounded up to a whole number of 64-bit words), but do the
for i in range(0, bits, 64): # reduction with a single masked XOR instead of a per-word loop.
result |= (diff >> i) & MASK64 full = ((bits + 63) >> 6) << 6
return result == 0 return ((a ^ b) & ((1 << full) - 1)) == 0
def _consttime_select(cond: int, a: int, b: int, bits: int) -> int: def _consttime_select(cond: int, a: int, b: int, bits: int) -> int:
@@ -98,8 +104,10 @@ def _consttime_select(cond: int, a: int, b: int, bits: int) -> int:
int int
The selected bits-bit integer. Internal hot path, no error tuple returned. The selected bits-bit integer. Internal hot path, no error tuple returned.
""" """
mask = (-cond) & ((1 << bits) - 1) m = (1 << bits) - 1
return (a & mask) | (b & ~mask & ((1 << bits) - 1)) mask = (-cond) & m
# mask is a subset of m, hence ~mask & m == m ^ mask (avoids the negative-int AND).
return (a & mask) | (b & (m ^ mask))
def rand_int(a: int, b: int): def rand_int(a: int, b: int):
@@ -148,7 +156,19 @@ def rand_bytes(n: int):
def _xor_bytes(a: bytes, b: bytes) -> bytes: def _xor_bytes(a: bytes, b: bytes) -> bytes:
"""Byte-wise XOR (uses the shorter of the two lengths). Internal hot path, no error return.""" """Byte-wise XOR (uses the shorter of the two lengths). Internal hot path, no error return."""
return bytes(x ^ y for x, y in zip(a, b)) la = len(a)
lb = len(b)
if la == lb:
if la == 0:
return b""
return (int.from_bytes(a, "little") ^ int.from_bytes(b, "little")).to_bytes(la, "little")
if la < lb:
if la == 0:
return b""
return (int.from_bytes(a, "little") ^ int.from_bytes(b[:la], "little")).to_bytes(la, "little")
if lb == 0:
return b""
return (int.from_bytes(a[:lb], "little") ^ int.from_bytes(b, "little")).to_bytes(lb, "little")
def _xor_bytes_fast(a: bytes, b: bytes) -> bytes: def _xor_bytes_fast(a: bytes, b: bytes) -> bytes:
@@ -158,9 +178,10 @@ def _xor_bytes_fast(a: bytes, b: bytes) -> bytes:
def _pad16(data: bytes) -> bytes: def _pad16(data: bytes) -> bytes:
"""Zero-pad to a 16-byte boundary (returned unchanged if already aligned). Internal hot path, no error return.""" """Zero-pad to a 16-byte boundary (returned unchanged if already aligned). Internal hot path, no error return."""
if len(data) % 16 == 0: r = len(data) & 15
if r == 0:
return data return data
return data + b"\x00" * (16 - len(data) % 16) return data + b"\x00" * (16 - r)
def _pad_pkcs7(data: bytes, bs: int = 16): def _pad_pkcs7(data: bytes, bs: int = 16):
+93 -27
View File
@@ -19,41 +19,93 @@ from ._ppyc_error import (
OID_RSA = "1.2.840.113549.1.1.1" OID_RSA = "1.2.840.113549.1.1.1"
# ---- precomputed constant tables (built once at import time) ----
# single-byte DER length (0x00..0x7f) as ready-made bytes objects
_SHORT_LEN = tuple(bytes((i,)) for i in range(0x80))
# long-form "number of length octets" byte: 0x80 | n (n <= 8)
_LONG_LEN = tuple(bytes((0x80 | i,)) for i in range(9))
# TAG+LENGTH header tables: _HDR_<tag>[L] is the DER header for a content of L bytes
_HDR_MAX = 1024
def _hdr_table(tag: int) -> tuple:
t = bytes((tag,))
out = [None] * (_HDR_MAX + 1)
for L in range(_HDR_MAX + 1):
if L < 0x80:
out[L] = t + bytes((L,))
else:
r = L.to_bytes((L.bit_length() + 7) >> 3, "big")
out[L] = t + bytes((0x80 | len(r),)) + r
return tuple(out)
_HDR_INT = _hdr_table(0x02) # INTEGER
_HDR_SEQ = _hdr_table(0x30) # SEQUENCE
_HDR_OCT = _hdr_table(0x04) # OCTET STRING
_HDR_OID = _hdr_table(0x06) # OBJECT IDENTIFIER
# BIT STRING: content = unused-bits byte (0x00) + payload -> fold the 0x00 into the header
_HDR_BIT = tuple(h + b"\x00" for h in _hdr_table(0x03))
_DER_NULL = b"\x05\x00"
def _der_len(n: int) -> bytes: def _der_len(n: int) -> bytes:
if n < 0x80: if n < 0x80:
return bytes([n]) return _SHORT_LEN[n]
raw = n.to_bytes((n.bit_length() + 7) // 8, "big") raw = n.to_bytes((n.bit_length() + 7) >> 3, "big")
return bytes([0x80 | len(raw)]) + raw ln = len(raw)
if ln <= 8:
return _LONG_LEN[ln] + raw
return bytes((0x80 | ln,)) + raw
def _der_int(n: int) -> bytes: def _der_int(n: int) -> bytes:
if n == 0: if n == 0:
return b"\x02\x01\x00" return b"\x02\x01\x00"
raw = n.to_bytes((n.bit_length() + 7) // 8, "big") raw = n.to_bytes((n.bit_length() + 7) >> 3, "big")
if raw[0] & 0x80: if raw[0] >= 0x80:
raw = b"\x00" + raw raw = b"\x00" + raw
return b"\x02" + _der_len(len(raw)) + raw L = len(raw)
if L <= _HDR_MAX:
return _HDR_INT[L] + raw
return b"\x02" + _der_len(L) + raw
def _der_seq(*items: bytes) -> bytes: def _der_seq(*items: bytes) -> bytes:
body = b"".join(items) body = b"".join(items)
return b"\x30" + _der_len(len(body)) + body L = len(body)
if L <= _HDR_MAX:
return _HDR_SEQ[L] + body
return b"\x30" + _der_len(L) + body
def _der_octet(data: bytes) -> bytes: def _der_octet(data: bytes) -> bytes:
return b"\x04" + _der_len(len(data)) + data L = len(data)
if L <= _HDR_MAX:
return _HDR_OCT[L] + data
return b"\x04" + _der_len(L) + data
def _der_bit(data: bytes) -> bytes: def _der_bit(data: bytes) -> bytes:
return b"\x03" + _der_len(len(data) + 1) + b"\x00" + data L = len(data) + 1
if L <= _HDR_MAX:
return _HDR_BIT[L] + data
return b"\x03" + _der_len(L) + b"\x00" + data
def _der_null() -> bytes: def _der_null() -> bytes:
return b"\x05\x00" return _DER_NULL
_OID_CACHE = {}
def _der_oid(oid: str) -> bytes: def _der_oid(oid: str) -> bytes:
cached = _OID_CACHE.get(oid)
if cached is not None:
return cached
parts = [int(x) for x in oid.split(".")] parts = [int(x) for x in oid.split(".")]
encoded = [40 * parts[0] + parts[1]] encoded = [40 * parts[0] + parts[1]]
for p in parts[2:]: for p in parts[2:]:
@@ -63,7 +115,15 @@ def _der_oid(oid: str) -> bytes:
stack.append((p & 0x7F) | 0x80) stack.append((p & 0x7F) | 0x80)
p >>= 7 p >>= 7
encoded.extend(reversed(stack)) encoded.extend(reversed(stack))
return b"\x06" + _der_len(len(encoded)) + bytes(encoded) body = bytes(encoded)
L = len(body)
result = (_HDR_OID[L] + body) if L <= _HDR_MAX else (b"\x06" + _der_len(L) + body)
_OID_CACHE[oid] = result
return result
# RSA AlgorithmIdentifier (OID + NULL): constant across every call
_DER_ALG_RSA = _der_seq(_der_oid(OID_RSA), _DER_NULL)
def private_key_to_pkcs1_der(priv: RSAPrivateKey) -> bytes: def private_key_to_pkcs1_der(priv: RSAPrivateKey) -> bytes:
@@ -77,13 +137,12 @@ def public_key_to_pkcs1_der(pub: RSAPublicKey) -> bytes:
def private_key_to_pkcs8_der(priv: RSAPrivateKey) -> bytes: def private_key_to_pkcs8_der(priv: RSAPrivateKey) -> bytes:
alg = _der_seq(_der_oid(OID_RSA), _der_null()) return _der_seq(_der_int(0), _DER_ALG_RSA,
return _der_seq(_der_int(0), alg, _der_octet(private_key_to_pkcs1_der(priv))) _der_octet(private_key_to_pkcs1_der(priv)))
def public_key_to_spki_der(pub: RSAPublicKey) -> bytes: def public_key_to_spki_der(pub: RSAPublicKey) -> bytes:
alg = _der_seq(_der_oid(OID_RSA), _der_null()) return _der_seq(_DER_ALG_RSA, _der_bit(public_key_to_pkcs1_der(pub)))
return _der_seq(alg, _der_bit(public_key_to_pkcs1_der(pub)))
def _pem(der: bytes, label: str) -> str: def _pem(der: bytes, label: str) -> str:
@@ -106,30 +165,37 @@ def _b64_pem_to_der(pem: str) -> bytes:
return base64.b64decode("".join(b64_lines)) return base64.b64decode("".join(b64_lines))
def _der_read(data: bytes, pos: int): def _der_read(data, pos: int):
tag = data[pos]; pos += 1 lb = data[pos + 1]
length_byte = data[pos]; pos += 1 if lb < 0x80:
if length_byte < 0x80: length = lb
length = length_byte pos += 2
else: else:
nb = length_byte & 0x7F nb = lb & 0x7F
length = int.from_bytes(data[pos:pos + nb], "big") length = int.from_bytes(data[pos + 2:pos + 2 + nb], "big")
pos += nb pos += 2 + nb
return data[pos:pos + length], pos + length return data[pos:pos + length], pos + length
def _der_read_int(data: bytes, pos: int): def _der_read_int(data, pos: int):
tag = data[pos] tag = data[pos]
if tag != 0x02: if tag != 0x02:
raise PPYC_ERR(PPYC_ERR_INVALID_ENCODING, raise PPYC_ERR(PPYC_ERR_INVALID_ENCODING,
f"expected ASN.1 INTEGER (0x02), got 0x{tag:02x}", f"expected ASN.1 INTEGER (0x02), got 0x{tag:02x}",
"make sure the input is valid DER encoding") "make sure the input is valid DER encoding")
content, pos = _der_read(data, pos) lb = data[pos + 1]
val = int.from_bytes(content, "big", signed=True) if lb < 0x80:
length = lb
pos += 2
else:
nb = lb & 0x7F
length = int.from_bytes(data[pos + 2:pos + 2 + nb], "big")
pos += 2 + nb
val = int.from_bytes(data[pos:pos + length], "big", signed=True)
if val < 0: if val < 0:
raise PPYC_ERR(PPYC_ERR_INVALID_ENCODING, "ASN.1 INTEGER is negative", raise PPYC_ERR(PPYC_ERR_INVALID_ENCODING, "ASN.1 INTEGER is negative",
"RSA key material must not be negative, please check the input") "RSA key material must not be negative, please check the input")
return val, pos return val, pos + length
def parse_private_pem(pem: str) -> RSAPrivateKey: def parse_private_pem(pem: str) -> RSAPrivateKey:
+278 -33
View File
@@ -93,6 +93,34 @@ Point = Tuple[int, int, int, int]
_BASE: Point = (BX, BY, 1, (BX * BY) % P) _BASE: Point = (BX, BY, 1, (BX * BY) % P)
IDENTITY: Point = (0, 1, 1, 0) # identity element (Z = 1, usable as an affine table entry) IDENTITY: Point = (0, 1, 1, 0) # identity element (Z = 1, usable as an affine table entry)
# ------------------------------------------------------------
# Lazy field reduction (no big-int division)
# ------------------------------------------------------------
# p = 2^255 - 19, so 2^255 == 19 (mod p). Splitting an integer t into
# t = (t >> 255) * 2^255 + (t & (2^255 - 1))
# (which is an exact identity for negative t as well: Python's >> is an
# arithmetic/floor shift and & is a two's-complement mask) gives
# fold(t) := (t & M255) + 19 * (t >> 255) == t (mod p).
# fold() keeps the *value* congruent but only shrinks |t| by a factor ~2^255,
# so it is applied twice; for every |t| < 2^514 the two-round fold returns a
# value r with |r| <= 2^255 + 5756 (verified exhaustively for the magnitudes
# that occur here). A single round replaces a 510-bit `% p` (0.50 us) with a
# shift/mask/small-multiply (0.41 us) and, more importantly, it lets the
# intermediate values stay *signed*, which removes the extra normalising
# `% p` calls that add/subtract steps used to need.
#
# Invariant maintained by every routine below: every stored coordinate v
# satisfies |v| <= 2^255 + 8192 (call it V); sums/differences of two such
# values are bounded by 3V and are only ever used as multiplicands, so every
# product that reaches a fold is < (3V)^2 < 2^514, i.e. inside the fold's
# proven domain. Values are therefore *lazy* (not necessarily in [0, p)), but
# congruent to the true coordinates mod p; the only places that need a
# canonical representative (`_pt_encode`, `_pt_encode_pair`, the tables, the
# identity test in verification) already apply an explicit `% p`.
_M255 = (1 << 255) - 1
# one packed affine comb entry = x | y<<256 | t2d<<512 (3 * 256 bits)
_SLOT3_MASK = (1 << 768) - 1
# Ed25519Error is defined uniformly in purepycrypto._ppyc_error (a PPYC_ERR subclass) and reused here directly. # Ed25519Error is defined uniformly in purepycrypto._ppyc_error (a PPYC_ERR subclass) and reused here directly.
@@ -101,15 +129,30 @@ def _pt_add(p1: Point, p2: Point) -> Point:
"""Unified addition (add-2008-hwcd-3 with a = -1, no exceptional branch, handles any point pair).""" """Unified addition (add-2008-hwcd-3 with a = -1, no exceptional branch, handles any point pair)."""
x1, y1, z1, t1 = p1 x1, y1, z1, t1 = p1
x2, y2, z2, t2 = p2 x2, y2, z2, t2 = p2
a = (y1 - x1) * (y2 - x2) % P a = (y1 - x1) * (y2 - x2)
b = (y1 + x1) * (y2 + x2) % P a = (a & _M255) + 19 * (a >> 255); a = (a & _M255) + 19 * (a >> 255)
c = t1 * D2 % P * t2 % P b = (y1 + x1) * (y2 + x2)
dd = z1 * 2 * z2 % P b = (b & _M255) + 19 * (b >> 255); b = (b & _M255) + 19 * (b >> 255)
c = t1 * D2
c = (c & _M255) + 19 * (c >> 255); c = (c & _M255) + 19 * (c >> 255)
c = c * t2
c = (c & _M255) + 19 * (c >> 255); c = (c & _M255) + 19 * (c >> 255)
dd = z1 * z2
dd = (dd & _M255) + 19 * (dd >> 255); dd = (dd & _M255) + 19 * (dd >> 255)
dd += dd
e = b - a e = b - a
f = dd - c f = dd - c
g = dd + c g = dd + c
h = b + a h = b + a
return (e * f % P, g * h % P, f * g % P, e * h % P) rx = e * f
rx = (rx & _M255) + 19 * (rx >> 255); rx = (rx & _M255) + 19 * (rx >> 255)
ry = g * h
ry = (ry & _M255) + 19 * (ry >> 255); ry = (ry & _M255) + 19 * (ry >> 255)
rz = f * g
rz = (rz & _M255) + 19 * (rz >> 255); rz = (rz & _M255) + 19 * (rz >> 255)
rt = e * h
rt = (rt & _M255) + 19 * (rt >> 255); rt = (rt & _M255) + 19 * (rt >> 255)
return (rx, ry, rz, rt)
def _pt_add_mixed(p1: Point, x2: int, y2: int, t2d: int) -> Point: def _pt_add_mixed(p1: Point, x2: int, y2: int, t2d: int) -> Point:
@@ -118,35 +161,60 @@ def _pt_add_mixed(p1: Point, x2: int, y2: int, t2d: int) -> Point:
9 multiplications are reduced to 7 (the affine specialization of add-2008-hwcd-3); it also holds when p1 is the identity element. 9 multiplications are reduced to 7 (the affine specialization of add-2008-hwcd-3); it also holds when p1 is the identity element.
""" """
x1, y1, z1, t1 = p1 x1, y1, z1, t1 = p1
a = (y1 - x1) * (y2 - x2) % P a = (y1 - x1) * (y2 - x2)
b = (y1 + x1) * (y2 + x2) % P a = (a & _M255) + 19 * (a >> 255); a = (a & _M255) + 19 * (a >> 255)
c = t1 * t2d % P b = (y1 + x1) * (y2 + x2)
b = (b & _M255) + 19 * (b >> 255); b = (b & _M255) + 19 * (b >> 255)
c = t1 * t2d
c = (c & _M255) + 19 * (c >> 255); c = (c & _M255) + 19 * (c >> 255)
dd = z1 + z1 dd = z1 + z1
e = b - a e = b - a
f = dd - c f = dd - c
g = dd + c g = dd + c
h = b + a h = b + a
return (e * f % P, g * h % P, f * g % P, e * h % P) rx = e * f
rx = (rx & _M255) + 19 * (rx >> 255); rx = (rx & _M255) + 19 * (rx >> 255)
ry = g * h
ry = (ry & _M255) + 19 * (ry >> 255); ry = (ry & _M255) + 19 * (ry >> 255)
rz = f * g
rz = (rz & _M255) + 19 * (rz >> 255); rz = (rz & _M255) + 19 * (rz >> 255)
rt = e * h
rt = (rt & _M255) + 19 * (rt >> 255); rt = (rt & _M255) + 19 * (rt >> 255)
return (rx, ry, rz, rt)
def _pt_dbl(p1: Point) -> Point: def _pt_dbl(p1: Point) -> Point:
"""Point doubling (dbl-2008-hwcd from RFC 8032 section 5.1.4, a = -1).""" """Point doubling (dbl-2008-hwcd from RFC 8032 section 5.1.4, a = -1)."""
x1, y1, z1, _t1 = p1 x1, y1, z1, _t1 = p1
a = x1 * x1 % P a = x1 * x1
b = y1 * y1 % P a = (a & _M255) + 19 * (a >> 255); a = (a & _M255) + 19 * (a >> 255)
c = 2 * z1 * z1 % P b = y1 * y1
dd = (-a) % P b = (b & _M255) + 19 * (b >> 255); b = (b & _M255) + 19 * (b >> 255)
e = ((x1 + y1) * (x1 + y1) - a - b) % P ss = (x1 + y1) * (x1 + y1)
g = (dd + b) % P ss = (ss & _M255) + 19 * (ss >> 255); ss = (ss & _M255) + 19 * (ss >> 255)
f = (g - c) % P c = z1 * z1
h = (dd - b) % P c = (c & _M255) + 19 * (c >> 255); c = (c & _M255) + 19 * (c >> 255)
return (e * f % P, g * h % P, f * g % P, e * h % P) c += c
dd = -a
e = ss - a - b
g = dd + b
f = g - c
h = dd - b
rx = e * f
rx = (rx & _M255) + 19 * (rx >> 255); rx = (rx & _M255) + 19 * (rx >> 255)
ry = g * h
ry = (ry & _M255) + 19 * (ry >> 255); ry = (ry & _M255) + 19 * (ry >> 255)
rz = f * g
rz = (rz & _M255) + 19 * (rz >> 255); rz = (rz & _M255) + 19 * (rz >> 255)
rt = e * h
rt = (rt & _M255) + 19 * (rt >> 255); rt = (rt & _M255) + 19 * (rt >> 255)
return (rx, ry, rz, rt)
def _pt_neg(p1: Point) -> Point: def _pt_neg(p1: Point) -> Point:
"""Negation of a point: -(X:Y:Z:T) = (-X:Y:Z:-T).""" """Negation of a point: -(X:Y:Z:T) = (-X:Y:Z:-T)."""
x, y, z, t = p1 x, y, z, t = p1
return ((-x) % P, y, z, (-t) % P) return (-x, y, z, -t)
def _ct_eq_mask(a: int, b: int) -> int: def _ct_eq_mask(a: int, b: int) -> int:
@@ -239,6 +307,23 @@ def _build_comb(w: int, multiprocess: bool = False):
return [tuple(packed[i * step:(i + 1) * step]) for i in range(n)] return [tuple(packed[i * step:(i + 1) * step]) for i in range(n)]
def _pack_rows(rows):
"""Pack every affine row into a single Python int (entry j at bits 768j..768j+767).
A whole Comb row therefore lives in one contiguous object; selecting entry `idx`
is a single shift+mask over that object (see `_scalarmult_base_ct`).
"""
packed_rows = []
for row in rows:
v = 0
sh = 0
for e in row:
v |= e << sh
sh += 768
packed_rows.append(v)
return tuple(packed_rows)
def _comb_table(window, multiprocess: bool = False): def _comb_table(window, multiprocess: bool = False):
"""Return (and cache) the affine Comb table for window `window`; built once on the first call.""" """Return (and cache) the affine Comb table for window `window`; built once on the first call."""
w = _W_CT if window is None else int(window) w = _W_CT if window is None else int(window)
@@ -253,6 +338,7 @@ def _comb_table(window, multiprocess: bool = False):
if tab is None: if tab is None:
tab = _build_comb(w, multiprocess) tab = _build_comb(w, multiprocess)
_COMB_CACHE[w] = tab _COMB_CACHE[w] = tab
_BIGROW_CACHE[w] = _pack_rows(tab)
return tab return tab
@@ -293,21 +379,95 @@ def _split(p):
return (p & _SLOT_MASK, (p >> 256) & _SLOT_MASK, (p >> 512) & _SLOT_MASK) return (p & _SLOT_MASK, (p >> 256) & _SLOT_MASK, (p >> 512) & _SLOT_MASK)
# ------------------------------------------------------------
# Constant-time comb lookup: precomputed masks + fully unrolled scan.
# Semantics are identical to _ct_select_packed (a fixed 2^w round masked
# scan with no secret-dependent branch), but the inner loop is unrolled and
# the per-entry mask ((j ^ idx) - 1) >> 63 is precomputed, which is markedly
# faster than recomputing it for every entry on every row.
# ------------------------------------------------------------
_MASK_TABLE = {} # n -> [masks idx 0..n-1] (each a tuple of n masks)
_SCAN_FUNCS = {} # n -> unrolled scan(row, mask_tuple) -> packed
_BIGROW_CACHE = {} # w -> tuple of rows packed into one big int each
def _get_masks(n):
t = _MASK_TABLE.get(n)
if t is None:
t = [tuple(((j ^ idx) - 1) >> 63 for j in range(n)) for idx in range(n)]
_MASK_TABLE[n] = t
return t
def _get_scan(n):
f = _SCAN_FUNCS.get(n)
if f is None:
lines = ["def _scan_n(row, m):",
" " + ",".join("m%d" % i for i in range(n)) + " = m",
" return " + " | ".join("(row[%d] & m%d)" % (i, i) for i in range(n))]
ns = {}
exec("\n".join(lines), ns)
f = ns["_scan_n"]
_SCAN_FUNCS[n] = f
return f
def _scalarmult_base_ct(scalar: int, window=None, multiprocess: bool = False) -> Point: def _scalarmult_base_ct(scalar: int, window=None, multiprocess: bool = False) -> Point:
"""Secret-scalar fixed-base multiplication scalar*B: affine Comb table + constant-time masked lookup + mixed addition. """Secret-scalar fixed-base multiplication scalar*B: affine Comb table + constant-time masked lookup + mixed addition.
The control flow is independent of the scalar: the main loop always runs ceil(256/w) rounds, each with a fixed 2^w masked comparisons + 1 point addition. The control flow is independent of the scalar: the main loop always runs ceil(256/w) rounds, each with a fixed 2^w masked comparisons + 1 point addition.
""" """
w = _W_CT if window is None else int(window) w = _W_CT if window is None else int(window)
rows = _comb_table(w, multiprocess) _comb_table(w, multiprocess) # (re)builds both caches if needed
bigrows = _BIGROW_CACHE[w]
s = scalar & ((1 << 256) - 1) s = scalar & ((1 << 256) - 1)
mask = (1 << w) - 1 mask = (1 << w) - 1
acc = IDENTITY # Constant-time table lookup, fused with the affine mixed addition (inlined
# _pt_add_mixed) to avoid per-round function-call / tuple-unpacking overhead.
#
# The lookup itself is `(row_big >> (768 * idx)) & (2^768 - 1)`: the whole row
# is ONE big-integer object, and a right shift + mask reads entry `idx` out of
# it. This is a straight-line sequence of big-integer primitives with
# * no branch and no early exit,
# * no secret-dependent *memory* index (the shift walks the entire operand,
# so every element of the row is touched for every idx -- the access
# pattern is identical for all idx, unlike a `masks[idx]` list lookup),
# so the control flow and the memory footprint are independent of the secret
# scalar. `_ct_select_packed` (the fixed 2^w-round masked scan) is kept
# unchanged as the reference primitive.
_P = P
SLOT = _SLOT_MASK
SLOT3 = _SLOT3_MASK
x1 = 0; y1 = 1; z1 = 1; t1 = 0 # identity accumulator
_M = _M255
i = 0 i = 0
for row in rows: for rb in bigrows:
acc = _pt_add_mixed(acc, *_ct_select_packed(row, (s >> (w * i)) & mask)) idx = (s >> (w * i)) & mask
r = (rb >> (768 * idx)) & SLOT3
x2 = r & SLOT
y2 = (r >> 256) & SLOT
t2d = (r >> 512) & SLOT
a = (y1 - x1) * (y2 - x2)
a = (a & _M) + 19 * (a >> 255); a = (a & _M) + 19 * (a >> 255)
b = (y1 + x1) * (y2 + x2)
b = (b & _M) + 19 * (b >> 255); b = (b & _M) + 19 * (b >> 255)
c = t1 * t2d
c = (c & _M) + 19 * (c >> 255); c = (c & _M) + 19 * (c >> 255)
dd = z1 + z1
e_ = b - a
f = dd - c
g = dd + c
h = b + a
x1 = e_ * f
x1 = (x1 & _M) + 19 * (x1 >> 255); x1 = (x1 & _M) + 19 * (x1 >> 255)
y1 = g * h
y1 = (y1 & _M) + 19 * (y1 >> 255); y1 = (y1 & _M) + 19 * (y1 >> 255)
z1 = f * g
z1 = (z1 & _M) + 19 * (z1 >> 255); z1 = (z1 & _M) + 19 * (z1 >> 255)
t1 = e_ * h
t1 = (t1 & _M) + 19 * (t1 >> 255); t1 = (t1 & _M) + 19 * (t1 >> 255)
i += 1 i += 1
return acc return (x1, y1, z1, t1)
def _scalarmult_base_pub(scalar: int, window=None, multiprocess: bool = False) -> Point: def _scalarmult_base_pub(scalar: int, window=None, multiprocess: bool = False) -> Point:
@@ -316,12 +476,36 @@ def _scalarmult_base_pub(scalar: int, window=None, multiprocess: bool = False) -
rows = _comb_table(w, multiprocess) rows = _comb_table(w, multiprocess)
s = scalar & ((1 << 256) - 1) s = scalar & ((1 << 256) - 1)
mask = (1 << w) - 1 mask = (1 << w) - 1
acc = IDENTITY _M = _M255
SLOT = _SLOT_MASK
x1 = 0; y1 = 1; z1 = 1; t1 = 0 # identity accumulator
i = 0 i = 0
for row in rows: for row in rows:
acc = _pt_add_mixed(acc, *_split(row[(s >> (w * i)) & mask])) r = row[(s >> (w * i)) & mask]
x2 = r & SLOT
y2 = (r >> 256) & SLOT
t2d = (r >> 512) & SLOT
a = (y1 - x1) * (y2 - x2)
a = (a & _M) + 19 * (a >> 255); a = (a & _M) + 19 * (a >> 255)
b = (y1 + x1) * (y2 + x2)
b = (b & _M) + 19 * (b >> 255); b = (b & _M) + 19 * (b >> 255)
c = t1 * t2d
c = (c & _M) + 19 * (c >> 255); c = (c & _M) + 19 * (c >> 255)
dd = z1 + z1
e_ = b - a
f = dd - c
g = dd + c
h = b + a
x1 = e_ * f
x1 = (x1 & _M) + 19 * (x1 >> 255); x1 = (x1 & _M) + 19 * (x1 >> 255)
y1 = g * h
y1 = (y1 & _M) + 19 * (y1 >> 255); y1 = (y1 & _M) + 19 * (y1 >> 255)
z1 = f * g
z1 = (z1 & _M) + 19 * (z1 >> 255); z1 = (z1 & _M) + 19 * (z1 >> 255)
t1 = e_ * h
t1 = (t1 & _M) + 19 * (t1 >> 255); t1 = (t1 & _M) + 19 * (t1 >> 255)
i += 1 i += 1
return acc return (x1, y1, z1, t1)
def _wnaf(k: int, w: int): def _wnaf(k: int, w: int):
@@ -358,13 +542,74 @@ def _scalarmult_pub(pt: Point, scalar: int, w: int = 5) -> Point:
algorithm; it must **not** be used for secret-dependent operations such as private keys / randomness. algorithm; it must **not** be used for secret-dependent operations such as private keys / randomness.
""" """
tab = _odd_multiples(pt, w) tab = _odd_multiples(pt, w)
acc = IDENTITY _M = _M255
for d in reversed(_wnaf(int(scalar), w)): D2_ = D2
acc = _pt_dbl(acc) neg = _pt_neg
x1 = 0; y1 = 1; z1 = 1; t1 = 0 # identity accumulator
digits = list(reversed(_wnaf(int(scalar), w)))
last = len(digits) - 1
di = -1
for d in digits:
di += 1
# ---- inlined _pt_dbl (dbl-2008-hwcd, a = -1) ----
ss = (x1 + y1) * (x1 + y1)
ss = (ss & _M) + 19 * (ss >> 255); ss = (ss & _M) + 19 * (ss >> 255)
a = x1 * x1
a = (a & _M) + 19 * (a >> 255); a = (a & _M) + 19 * (a >> 255)
b = y1 * y1
b = (b & _M) + 19 * (b >> 255); b = (b & _M) + 19 * (b >> 255)
c = z1 * z1
c = (c & _M) + 19 * (c >> 255); c = (c & _M) + 19 * (c >> 255)
c += c
dd = -a
e_ = ss - a - b
g = dd + b
f = g - c
h = dd - b
x1 = e_ * f
x1 = (x1 & _M) + 19 * (x1 >> 255); x1 = (x1 & _M) + 19 * (x1 >> 255)
y1 = g * h
y1 = (y1 & _M) + 19 * (y1 >> 255); y1 = (y1 & _M) + 19 * (y1 >> 255)
z1 = f * g
z1 = (z1 & _M) + 19 * (z1 >> 255); z1 = (z1 & _M) + 19 * (z1 >> 255)
# T1 is only consumed by the *addition* below (and by the caller for the
# final point), so it is produced lazily: for a zero wNAF digit -- 5 out
# of 6 rounds on average -- neither the multiplication nor its reduction
# is executed at all. The digit sequence comes from the *public* scalar,
# so this branch carries no secret-dependent information.
if d or di == last:
t1 = e_ * h
t1 = (t1 & _M) + 19 * (t1 >> 255); t1 = (t1 & _M) + 19 * (t1 >> 255)
if d: if d:
q = tab[(d - 1) >> 1] if d > 0 else _pt_neg(tab[(-1 - d) >> 1]) # ---- inlined _pt_add (add-2008-hwcd-3, a = -1) ----
acc = _pt_add(acc, q) if d > 0:
return acc qx, qy, qz, qt = tab[(d - 1) >> 1]
else:
qx, qy, qz, qt = neg(tab[(-1 - d) >> 1])
a = (y1 - x1) * (qy - qx)
a = (a & _M) + 19 * (a >> 255); a = (a & _M) + 19 * (a >> 255)
b = (y1 + x1) * (qy + qx)
b = (b & _M) + 19 * (b >> 255); b = (b & _M) + 19 * (b >> 255)
c = t1 * D2_
c = (c & _M) + 19 * (c >> 255); c = (c & _M) + 19 * (c >> 255)
c = c * qt
c = (c & _M) + 19 * (c >> 255); c = (c & _M) + 19 * (c >> 255)
dd = z1 * qz
dd = (dd & _M) + 19 * (dd >> 255); dd = (dd & _M) + 19 * (dd >> 255)
dd += dd
e_ = b - a
f = dd - c
g = dd + c
h = b + a
x1 = e_ * f
x1 = (x1 & _M) + 19 * (x1 >> 255); x1 = (x1 & _M) + 19 * (x1 >> 255)
y1 = g * h
y1 = (y1 & _M) + 19 * (y1 >> 255); y1 = (y1 & _M) + 19 * (y1 >> 255)
z1 = f * g
z1 = (z1 & _M) + 19 * (z1 >> 255); z1 = (z1 & _M) + 19 * (z1 >> 255)
t1 = e_ * h
t1 = (t1 & _M) + 19 * (t1 >> 255); t1 = (t1 & _M) + 19 * (t1 >> 255)
return (x1, y1, z1, t1)
def _scalarmult_joint(k1: int, tab1, k2: int, tab2, w: int = 5) -> Point: def _scalarmult_joint(k1: int, tab1, k2: int, tab2, w: int = 5) -> Point:
+305 -44
View File
@@ -159,31 +159,36 @@ _B64_ALPHABET = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789
_PAD = 0x3D # '=' _PAD = 0x3D # '='
#: 12-bit -> 2 Base64 characters (4096 entries, built once at import)
_B64_T12 = tuple(bytes((_B64_ALPHABET[i >> 6], _B64_ALPHABET[i & 63])) for i in range(4096))
def _b64_encode_core(data): def _b64_encode_core(data):
"""Pure implementation: ``bytes`` -> standard-alphabet Base64 ``bytes`` with padding.""" """Pure implementation: ``bytes`` -> standard-alphabet Base64 ``bytes`` with padding.
alpha = _B64_ALPHABET
The three input byte streams are walked with ``zip`` and each 3-byte group is
turned into two 12-bit table lookups, so the character mapping costs two
C-level bytes concatenations per group instead of eight Python-level shifts.
"""
n = len(data) n = len(data)
pad = (-n) % 3
if pad:
data = data + b"\x00" * pad
t12 = _B64_T12
out = bytearray() out = bytearray()
for i in range(0, n, 3): for d0, d1, d2 in zip(data[0::3], data[1::3], data[2::3]):
chunk = data[i:i + 3] out += t12[(d0 << 4) | (d1 >> 4)]
b = len(chunk) out += t12[((d1 & 15) << 8) | d2]
v = 0 if pad:
for j in range(b): out[-pad:] = b"=" * pad
v |= chunk[j] << (16 - 8 * j)
out.append(alpha[(v >> 18) & 0x3F])
out.append(alpha[(v >> 12) & 0x3F])
if b == 1:
out.append(_PAD)
out.append(_PAD)
else:
out.append(alpha[(v >> 6) & 0x3F])
if b == 2:
out.append(_PAD)
else:
out.append(alpha[v & 0x3F])
return bytes(out) return bytes(out)
#: ``bytes.translate`` tables derived from the lookup tables above
#: (value 0..63 valid / 64 = padding / 255 = invalid).
_B64_TRANS = {}
def _b64_table(altchars=None): def _b64_table(altchars=None):
"""Build the Base64 decoding lookup table: values 0..63 / -1 invalid / -2 padding.""" """Build the Base64 decoding lookup table: values 0..63 / -1 invalid / -2 padding."""
table = [-1] * 256 table = [-1] * 256
@@ -193,12 +198,68 @@ def _b64_table(altchars=None):
if altchars is not None: if altchars is not None:
table[altchars[0]] = 62 table[altchars[0]] = 62
table[altchars[1]] = 63 table[altchars[1]] = 63
# Keep a strong reference to ``table`` so its id() cannot be recycled.
_B64_TRANS[id(table)] = (table, bytes(255 if v == -1 else (64 if v == -2 else v)
for v in table))
return table return table
def _b64_trans(table):
"""Return (building and caching if needed) the ``bytes.translate`` table for ``table``."""
entry = _B64_TRANS.get(id(table))
if entry is None:
entry = (table, bytes(255 if v == -1 else (64 if v == -2 else v) for v in table))
_B64_TRANS[id(table)] = entry
return entry[1]
_B64_TABLE_STD = _b64_table() _B64_TABLE_STD = _b64_table()
#: cache of the four column masks used by :func:`_b64_pack`, keyed by group count
_B64_COL_MASKS = {}
def _b64_pack(tv, n):
"""Pack ``n`` six-bit values (stored one per byte in ``tv``) into bytes.
The old per-group Python loop is replaced by a vectorised scheme: the four
interleaved 6-bit value streams are turned into the three output byte
columns using a handful of C-level big-integer operations (``int.from_bytes``
/ shifts / ``to_bytes``), and the columns are then woven together with
stepped ``bytearray`` slice assignment - everything runs in C.
"""
m = n & ~3
k = m >> 2
out = bytearray(3 * k)
if k:
masks = _B64_COL_MASKS.get(k)
if masks is None:
masks = (
int.from_bytes(b"\xf0" * k, "big"), # keep the high nibble of each byte
int.from_bytes(b"\x0f" * k, "big"), # keep the low nibble of each byte
int.from_bytes(b"\x3c" * k, "big"), # keep bits 2..5 of each byte
int.from_bytes(b"\x03" * k, "big"), # keep bits 0..1 of each byte
)
_B64_COL_MASKS[k] = masks
mh, ml, mh2, ml2 = masks
a = int.from_bytes(tv[0:m:4], "big")
b = int.from_bytes(tv[1:m:4], "big")
c = int.from_bytes(tv[2:m:4], "big")
d = int.from_bytes(tv[3:m:4], "big")
# column 0 = a3 a2 a1 a0 b5 b4 ; column 1 = b3 b2 b1 b0 c5 c4 ;
# column 2 = c3 c2 c1 c0 d5 d4 (a,b,c,d are the 6-bit groups)
out[0::3] = ((a << 2) + ((b & mh) >> 4)).to_bytes(k, "big")
out[1::3] = (((b & ml) << 4) + ((c & mh2) >> 2)).to_bytes(k, "big")
out[2::3] = (((c & ml2) << 6) + d).to_bytes(k, "big")
r = n - m
if r == 2:
out += (((tv[m] << 6) | tv[m + 1]) << 12).to_bytes(3, "big")[:1]
elif r == 3:
out += ((((tv[m] << 6) | tv[m + 1]) << 12) | (tv[m + 2] << 6)).to_bytes(3, "big")[:2]
return bytes(out)
def _b64_decode_core(data, table, validate): def _b64_decode_core(data, table, validate):
"""Pure-implementation Base64 decoding core. """Pure-implementation Base64 decoding core.
@@ -208,6 +269,44 @@ def _b64_decode_core(data, table, validate):
(None, (code, msg, hint)) invalid encoding / length (PPYC_ERR_INVALID_ENCODING / (None, (code, msg, hint)) invalid encoding / length (PPYC_ERR_INVALID_ENCODING /
PPYC_ERR_INVALID_LENGTH) PPYC_ERR_INVALID_LENGTH)
""" """
# Fast path: one C-level ``translate`` classifies every character at once.
# It is taken only for "clean" input (alphabet characters, padding solely at
# the end); anything else falls back to the character-by-character scanner
# below so all legacy error semantics are preserved.
tv = data.translate(_b64_trans(table))
n = len(tv)
k = n
while k > 0 and tv[k - 1] == 64:
k -= 1
npad = n - k
if tv.find(255) < 0 and tv.find(64, 0, k) < 0:
if k == 0 and npad > 0:
if validate:
return None, err(
PPYC_ERR_INVALID_ENCODING,
"Base64 text starts with the padding '='",
"the padding '=' may only appear at the end",
)
return None, err(
PPYC_ERR_INVALID_LENGTH,
f"incorrect Base64 padding count (expected 0 '=' but got {npad})",
"add the missing '=' or remove the extra '='",
)
rem = k % 4
if rem == 1:
return None, err(
PPYC_ERR_INVALID_LENGTH,
"the Base64 data character count is invalid (=1 mod 4)",
"check for missing or extra characters",
)
expected = (4 - rem) % 4
if npad != expected:
return None, err(
PPYC_ERR_INVALID_LENGTH,
f"incorrect Base64 padding count (expected {expected} '=' but got {npad})",
"add the missing '=' or remove the extra '='",
)
return _b64_pack(tv, k), None
vals = [] vals = []
pad = 0 pad = 0
seen_pad = False seen_pad = False
@@ -454,12 +553,37 @@ _B32_ALPHABET = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"
_B32HEX_ALPHABET = b"0123456789ABCDEFGHIJKLMNOPQRSTUV" _B32HEX_ALPHABET = b"0123456789ABCDEFGHIJKLMNOPQRSTUV"
#: alphabet -> (10-bit -> 2 Base32 characters) table, built once per alphabet
_B32_T10 = {}
def _b32_t10(alphabet):
t = _B32_T10.get(alphabet)
if t is None:
t = tuple(bytes((alphabet[i >> 5], alphabet[i & 31])) for i in range(1024))
_B32_T10[alphabet] = t
return t
def _b32_encode_core(data, alphabet): def _b32_encode_core(data, alphabet):
"""Pure implementation: ``bytes`` -> padded Base32 ``bytes`` (5 bytes -> 8 characters).""" """Pure implementation: ``bytes`` -> padded Base32 ``bytes`` (5 bytes -> 8 characters).
Complete 5-byte groups are emitted as four 10-bit table lookups; only the
(at most one) trailing partial group uses the bit-by-bit path.
"""
n = len(data) n = len(data)
full = n - n % 5
out = bytearray() out = bytearray()
for i in range(0, n, 5): if full:
chunk = data[i:i + 5] t10 = _b32_t10(alphabet)
for a, b, c, d, e in zip(data[0:full:5], data[1:full:5], data[2:full:5],
data[3:full:5], data[4:full:5]):
out += t10[(a << 2) | (b >> 6)]
out += t10[((b & 63) << 4) | (c >> 4)]
out += t10[((c & 15) << 6) | (d >> 2)]
out += t10[((d & 3) << 8) | e]
if n % 5:
chunk = data[full:]
b = len(chunk) b = len(chunk)
buf = chunk + b"\x00" * (5 - b) buf = chunk + b"\x00" * (5 - b)
v = int.from_bytes(buf, "big") # 40 bit v = int.from_bytes(buf, "big") # 40 bit
@@ -472,6 +596,11 @@ def _b32_encode_core(data, alphabet):
return bytes(out) return bytes(out)
#: ``bytes.translate`` tables derived from the Base32 lookup tables
#: (value 0..31 valid / 32 = padding / 255 = invalid).
_B32_TRANS = {}
def _b32_table(alphabet, casefold=False): def _b32_table(alphabet, casefold=False):
"""Build the Base32 decoding lookup table (values 0..31 / -1 invalid / -2 padding).""" """Build the Base32 decoding lookup table (values 0..31 / -1 invalid / -2 padding)."""
table = [-1] * 256 table = [-1] * 256
@@ -483,15 +612,48 @@ def _b32_table(alphabet, casefold=False):
up = c - 32 up = c - 32
if table[up] != -1: if table[up] != -1:
table[c] = table[up] table[c] = table[up]
# Keep a strong reference to ``table`` so its id() cannot be recycled.
_B32_TRANS[id(table)] = (table, bytes(255 if v == -1 else (32 if v == -2 else v)
for v in table))
return table return table
def _b32_trans(table):
entry = _B32_TRANS.get(id(table))
if entry is None:
entry = (table, bytes(255 if v == -1 else (32 if v == -2 else v) for v in table))
_B32_TRANS[id(table)] = entry
return entry[1]
_B32_TABLE_STD = _b32_table(_B32_ALPHABET, False) _B32_TABLE_STD = _b32_table(_B32_ALPHABET, False)
_B32_TABLE_STD_CF = _b32_table(_B32_ALPHABET, True) _B32_TABLE_STD_CF = _b32_table(_B32_ALPHABET, True)
_B32_TABLE_HEX = _b32_table(_B32HEX_ALPHABET, False) _B32_TABLE_HEX = _b32_table(_B32HEX_ALPHABET, False)
_B32_TABLE_HEX_CF = _b32_table(_B32HEX_ALPHABET, True) _B32_TABLE_HEX_CF = _b32_table(_B32HEX_ALPHABET, True)
def _b32_pack(tv, n):
"""Pack ``n`` five-bit values (stored one per byte in ``tv``) into bytes."""
out = bytearray()
m = n - n % 8
for a, b, c, d, e, f, g, h in zip(tv[0:m:8], tv[1:m:8], tv[2:m:8], tv[3:m:8],
tv[4:m:8], tv[5:m:8], tv[6:m:8], tv[7:m:8]):
p0 = (a << 5) | b
p1 = (c << 5) | d
p2 = (e << 5) | f
p3 = (g << 5) | h
out += (((p0 << 10) | p1) << 20 | (p2 << 10) | p3).to_bytes(5, "big")
rem = n - m
if rem:
acc = 0
for x in tv[m:n]:
acc = (acc << 5) | x
nbytes = {2: 1, 4: 2, 5: 3, 7: 4}[rem]
shift = rem * 5 - nbytes * 8
out += (acc >> shift).to_bytes(nbytes, "big")
return bytes(out)
def _b32_decode_core(data, table): def _b32_decode_core(data, table):
"""Pure-implementation Base32 decoding core. """Pure-implementation Base32 decoding core.
@@ -501,6 +663,36 @@ def _b32_decode_core(data, table):
(None, (code, msg, hint)) invalid character (PPYC_ERR_INVALID_ENCODING) (None, (code, msg, hint)) invalid character (PPYC_ERR_INVALID_ENCODING)
or length / padding error (PPYC_ERR_INVALID_LENGTH) or length / padding error (PPYC_ERR_INVALID_LENGTH)
""" """
# Fast path (see _b64_decode_core): classify with one C-level translate and
# only take it for clean input, otherwise use the legacy scanner.
tv = data.translate(_b32_trans(table))
n = len(tv)
k = n
while k > 0 and tv[k - 1] == 32:
k -= 1
npad = n - k
if tv.find(255) < 0 and tv.find(32, 0, k) < 0:
if n % 8 != 0:
return None, err(
PPYC_ERR_INVALID_LENGTH,
f"the Base32 text length must be a multiple of 8, got {n}",
"add the missing characters or '=' padding, or remove extra characters",
)
rem = k % 8
expected = (8 - rem) % 8
if rem not in (0, 2, 4, 5, 7):
return None, err(
PPYC_ERR_INVALID_LENGTH,
f"invalid number of trailing Base32 data characters ({rem} left)",
"the valid counts of trailing data characters are 0 / 2 / 4 / 5 / 7",
)
if npad != expected:
return None, err(
PPYC_ERR_INVALID_LENGTH,
f"incorrect Base32 padding count (expected {expected} '=' but got {npad})",
"add the missing '=' or remove the extra '='",
)
return _b32_pack(tv, k), None
vals = [] vals = []
pad = 0 pad = 0
seen_pad = False seen_pad = False
@@ -852,18 +1044,49 @@ def b64_decode_bigint(s):
# 5. Base58 (Bitcoin alphabet) # 5. Base58 (Bitcoin alphabet)
# ====================================================================== # ======================================================================
# ======================================================================
# 6. Base58 (Bitcoin alphabet)
# ======================================================================
_B58_ALPHABET = b"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz" _B58_ALPHABET = b"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
_B58_TABLE = [-1] * 256 _B58_TABLE = [-1] * 256
for _i, _ch in enumerate(_B58_ALPHABET): for _i, _ch in enumerate(_B58_ALPHABET):
_B58_TABLE[_ch] = _i _B58_TABLE[_ch] = _i
del _i, _ch del _i, _ch
#: byte -> base58 value (255 == invalid) for one-shot validation with ``bytes.translate``.
_B58_DEC = bytes(255 if v < 0 else v for v in _B58_TABLE)
# ---- encoding tables / chunk constants -------------------------------------
_B58_C2 = 58 * 58
#: 58**2 -> the two glyphs of that value, **least-significant glyph first**
#: (the final buffer is byte-reversed once, so lookups are stored pre-reversed).
_B58_T2 = tuple(
bytes((_B58_ALPHABET[i % 58], _B58_ALPHABET[(i // 58) % 58]))
for i in range(_B58_C2)
)
_B58_C4 = _B58_C2 * _B58_C2
#: base58 digits produced by a single big-integer ``divmod`` below
_B58_CHUNK = 64
#: 58**64 -- dividing the running big integer by this yields 64 base58 digits at once,
#: cutting the number of *big-integer* divisions by ~64x versus the old one-per-glyph loop.
_B58_CHUNK_POW = 58 ** _B58_CHUNK
#: number of ``58**4`` sub-splits inside one chunk (64 // 4)
_B58_CHUNK_ITERS = _B58_CHUNK >> 2
def b58encode(data): def b58encode(data):
"""Base58 encoding (Bitcoin alphabet, excluding the easily confused ``0 O I l``). """Base58 encoding (Bitcoin alphabet, excluding the easily confused ``0 O I l``).
A leading zero byte is encoded as a leading ``'1'``. A leading zero byte is encoded as a leading ``'1'``.
Implementation: the whole input is read as one big integer and consumed
``58**64`` at a time with ``divmod``; each resulting 64-digit chunk is then
unpacked through two tiny lookup tables (``58**2``), so a 1 KiB payload needs
only ~20 big-integer divisions instead of ~1400.
Returns Returns
---- ----
str OK: Base58 text str OK: Base58 text
@@ -874,24 +1097,47 @@ def b58encode(data):
return e return e
n = int.from_bytes(b, "big") n = int.from_bytes(b, "big")
out = bytearray() out = bytearray()
while n > 0: T2 = _B58_T2
n, r = divmod(n, 58) C2 = _B58_C2
out.append(_B58_ALPHABET[r]) C4 = _B58_C4
P = _B58_CHUNK_POW
iters = _B58_CHUNK_ITERS
while n:
n, r = divmod(n, P)
for _ in range(iters):
r, q = divmod(r, C4)
q1, q2 = divmod(q, C2)
out += T2[q2]
out += T2[q1]
pad = 0 pad = 0
for byte in b: for byte in b:
if byte == 0: if byte:
pad += 1
else:
break break
pad += 1
if out:
out.reverse()
core = bytes(out).lstrip(b"1") # drop high-order zero glyphs
else:
core = b""
if pad: if pad:
out.extend(_B58_ALPHABET[0:1] * pad) core = b"1" * pad + core
out.reverse() return core.decode("ascii")
return out.decode("ascii")
#: characters consumed by one big-integer multiply in :func:`b58decode`
_B58_DCHUNK = 40
#: 58**40
_B58_DCHUNK_POW = 58 ** _B58_DCHUNK
def b58decode(s): def b58decode(s):
"""Base58 decoding (Bitcoin alphabet), the inverse of :func:`b58encode`. """Base58 decoding (Bitcoin alphabet), the inverse of :func:`b58encode`.
Implementation: validation + value lookup is one C-level ``bytes.translate``;
the digits are then folded into one big integer ``58**40`` at a time
(``n = n * 58**40 + block``), so a 1 KiB payload needs only ~35 big-integer
multiplications instead of ~1400.
Returns Returns
---- ----
bytes OK: the decoded original data bytes OK: the decoded original data
@@ -902,21 +1148,36 @@ def b58decode(s):
data, e = _coerce_ascii(s) data, e = _coerce_ascii(s)
if e is not None: if e is not None:
return e return e
tr = data.translate(_B58_DEC)
bad = tr.find(255)
if bad >= 0:
c = data[bad]
return err(
PPYC_ERR_INVALID_ENCODING,
f"Base58 input contains an invalid character 0x{c:02x} ({chr(c)!r})",
"the Base58 (Bitcoin) alphabet excludes 0 / O / I / l and symbols",
)
pad = 0 pad = 0
for c in data: for c in tr:
if c == _B58_ALPHABET[0]: if c:
pad += 1
else:
break break
pad += 1
n = 0 n = 0
for c in data: L = len(tr)
v = _B58_TABLE[c] res = _B58_DCHUNK
if v == -1: P = _B58_DCHUNK_POW
return err( rem = L % res
PPYC_ERR_INVALID_ENCODING, i = 0
f"Base58 input contains an invalid character 0x{c:02x} ({chr(c)!r})", if rem:
"the Base58 (Bitcoin) alphabet excludes 0 / O / I / l and symbols", v = 0
) for c in tr[:rem]:
n = n * 58 + v v = v * 58 + c
n = v
i = rem
for j in range(i, L, res):
v = 0
for c in tr[j:j + res]:
v = v * 58 + c
n = n * P + v
nbytes = (n.bit_length() + 7) // 8 nbytes = (n.bit_length() + 7) // 8
return b"\x00" * pad + n.to_bytes(nbytes, "big") return b"\x00" * pad + n.to_bytes(nbytes, "big")
+199 -109
View File
@@ -3,6 +3,14 @@
======================================== ========================================
purepycrypto - Pure-Python cryptography library (zero dependencies) purepycrypto - Pure-Python cryptography library (zero dependencies)
Pure-Python hash implementations: SHA-256, SHA-512, BLAKE2b. Pure-Python hash implementations: SHA-256, SHA-512, BLAKE2b.
Performance notes
-----------------
The three compression functions are generated once, lazily, as fully unrolled
straight-line code (``_build_sha256`` / ``_build_sha512`` / ``_build_blake2b``).
Unrolling removes the per-round tuple shuffling, list indexing and closure calls
of a naive loop implementation - those dominate the cost in CPython. Every
algorithm, constant and output is byte-for-byte identical to the reference.
""" """
import struct import struct
@@ -29,47 +37,76 @@ SHA256_K = (
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
) )
_SHA256_UNPACK = struct.Struct(">16I").unpack_from
_SHA256_PACK = struct.Struct(">8I").pack
_SHA256_Q = struct.Struct(">Q")
def _build_sha256():
"""Generate the unrolled SHA-256 block compressor (straight-line code).
The eight working registers ``r0..r7`` form a sliding window: at round ``t``
register ``r[(-t) % 8]`` holds working variable ``a``, ``r[(1-t) % 8]`` holds
``b`` and so on, so the classical ``h,g,f,e,d,c,b,a = ...`` shuffle of every
round collapses into exactly two stores. The sixteen message-schedule words
``w0..w15`` are rolled in place like a circular buffer, making the whole
64-round block branch-free.
"""
out = []
add = out.append
add("def _sha256_blocks(data):")
add(" h0, h1, h2, h3, h4, h5, h6, h7 = _SHA256_H0")
add(" M = MASK32")
add(" unpack = _SHA256_UNPACK")
add(" for off in range(0, len(data), 64):")
add(" r0, r1, r2, r3, r4, r5, r6, r7 = h0, h1, h2, h3, h4, h5, h6, h7")
add(" w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15 = unpack(data, off)")
for t in range(64):
if t < 16:
wt = "w%d" % t
else:
i = t % 16
j1 = (t + 1) % 16
j9 = (t + 9) % 16
j14 = (t + 14) % 16
add(" w%d = (w%d + (((w%d >> 7) | (w%d << 25)) ^ ((w%d >> 18) | (w%d << 14)) ^ (w%d >> 3))"
" + w%d + (((w%d >> 17) | (w%d << 15)) ^ ((w%d >> 19) | (w%d << 13)) ^ (w%d >> 10))) & M"
% (i, i, j1, j1, j1, j1, j1, j9, j14, j14, j14, j14, j14))
wt = "w%d" % i
k = ["r%d" % ((-t) % 8), "r%d" % ((1 - t) % 8), "r%d" % ((2 - t) % 8), "r%d" % ((3 - t) % 8),
"r%d" % ((4 - t) % 8), "r%d" % ((5 - t) % 8), "r%d" % ((6 - t) % 8), "r%d" % ((7 - t) % 8)]
a, b, c, d, e, f, g, h = k
add(" t1 = (%s + (((%s >> 6) | (%s << 26)) ^ ((%s >> 11) | (%s << 21)) ^ ((%s >> 25) | (%s << 7)))"
" + ((%s & %s) ^ ((~%s) & %s)) + 0x%08x + %s) & M" % (h, e, e, e, e, e, e, e, f, e, g, SHA256_K[t], wt))
add(" %s = (%s + t1) & M" % (d, d))
add(" t2 = ((((%s >> 2) | (%s << 30)) ^ ((%s >> 13) | (%s << 19)) ^ ((%s >> 22) | (%s << 10)))"
" + ((%s & %s) ^ (%s & %s) ^ (%s & %s))) & M" % (a, a, a, a, a, a, a, b, a, c, b, c))
add(" %s = (t1 + t2) & M" % h)
for i in range(8):
add(" h%d = (h%d + r%d) & M" % (i, i, i))
add(" return _SHA256_PACK(h0, h1, h2, h3, h4, h5, h6, h7)")
return chr(10).join(out)
_SHA256_BLOCKS = None
def _sha256_blocks(padded):
global _SHA256_BLOCKS
fn = _SHA256_BLOCKS
if fn is None:
ns = {"_SHA256_H0": SHA256_H0, "MASK32": MASK32, "_SHA256_UNPACK": _SHA256_UNPACK,
"_SHA256_PACK": _SHA256_PACK}
exec(compile(_build_sha256(), "<sha256-codegen>", "exec"), ns)
fn = _SHA256_BLOCKS = ns["_sha256_blocks"]
return fn(padded)
def sha256(message: bytes) -> bytes: def sha256(message: bytes) -> bytes:
L = len(message) * 8 """SHA-256 (FIPS 180-4), 32-byte digest."""
padded = message + b"\x80" n = len(message)
while len(padded) % 64 != 56: return _sha256_blocks(
padded += b"\x00" message + b"\x80" + b"\x00" * ((56 - n - 1) % 64) + _SHA256_Q.pack(len(message) * 8))
padded += struct.pack(">Q", L & MASK64)
state = list(SHA256_H0)
K = SHA256_K
M = MASK32
for i in range(0, len(padded), 64):
W = list(struct.unpack(">16I", padded[i:i + 64]))
for t in range(16, 64):
x = W[t - 15]
y = W[t - 2]
s0 = ((x >> 7) | (x << 25)) ^ ((x >> 18) | (x << 14)) ^ (x >> 3)
s1 = ((y >> 17) | (y << 15)) ^ ((y >> 19) | (y << 13)) ^ (y >> 10)
W.append((W[t - 16] + s0 + W[t - 7] + s1) & M)
a, b, c, d, e, f, g, h = state
for t in range(64):
S1 = ((e >> 6) | (e << 26)) ^ ((e >> 11) | (e << 21)) ^ ((e >> 25) | (e << 7))
ch = (e & f) ^ ((~e) & g)
T1 = (h + S1 + ch + K[t] + W[t]) & M
S0 = ((a >> 2) | (a << 30)) ^ ((a >> 13) | (a << 19)) ^ ((a >> 22) | (a << 10))
maj = (a & b) ^ (a & c) ^ (b & c)
T2 = (S0 + maj) & M
h, g, f, e, d, c, b, a = (
g, f, e, (d + T1) & M, c, b, a, (T1 + T2) & M
)
state[0] = (state[0] + a) & M
state[1] = (state[1] + b) & M
state[2] = (state[2] + c) & M
state[3] = (state[3] + d) & M
state[4] = (state[4] + e) & M
state[5] = (state[5] + f) & M
state[6] = (state[6] + g) & M
state[7] = (state[7] + h) & M
return struct.pack(">8I", *state)
# ============================================================ # ============================================================
@@ -104,47 +141,75 @@ SHA512_K = (
0x4cc5d4becb3e42b6, 0x597f299cfc657e2a, 0x5fcb6fab3ad6faec, 0x6c44198c4a475817, 0x4cc5d4becb3e42b6, 0x597f299cfc657e2a, 0x5fcb6fab3ad6faec, 0x6c44198c4a475817,
) )
_SHA512_UNPACK = struct.Struct(">16Q").unpack_from
_SHA512_PACK = struct.Struct(">8Q").pack
_SHA512_QQ = struct.Struct(">QQ")
def _build_sha512():
"""Generate the unrolled SHA-512 block compressor (80 rounds)."""
out = []
add = out.append
add("def _sha512_blocks(data):")
add(" h0, h1, h2, h3, h4, h5, h6, h7 = _SHA512_H0")
add(" M = MASK64")
add(" unpack = _SHA512_UNPACK")
add(" for off in range(0, len(data), 128):")
add(" r0, r1, r2, r3, r4, r5, r6, r7 = h0, h1, h2, h3, h4, h5, h6, h7")
add(" w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15 = unpack(data, off)")
for t in range(80):
if t < 16:
wt = "w%d" % t
else:
i = t % 16
j1 = (t + 1) % 16
j9 = (t + 9) % 16
j14 = (t + 14) % 16
add(" w%d = (w%d + (((w%d >> 1) | (w%d << 63)) ^ ((w%d >> 8) | (w%d << 56)) ^ (w%d >> 7))"
" + w%d + (((w%d >> 19) | (w%d << 45)) ^ ((w%d >> 61) | (w%d << 3)) ^ (w%d >> 6))) & M"
% (i, i, j1, j1, j1, j1, j1, j9, j14, j14, j14, j14, j14))
wt = "w%d" % i
a = "r%d" % ((-t) % 8)
b = "r%d" % ((1 - t) % 8)
c = "r%d" % ((2 - t) % 8)
d = "r%d" % ((3 - t) % 8)
e = "r%d" % ((4 - t) % 8)
f = "r%d" % ((5 - t) % 8)
g = "r%d" % ((6 - t) % 8)
h = "r%d" % ((7 - t) % 8)
add(" t1 = (%s + (((%s >> 14) | (%s << 50)) ^ ((%s >> 18) | (%s << 46)) ^ ((%s >> 41) | (%s << 23)))"
" + ((%s & %s) ^ ((~%s) & %s)) + 0x%016x + %s) & M" % (h, e, e, e, e, e, e, e, f, e, g, SHA512_K[t], wt))
add(" %s = (%s + t1) & M" % (d, d))
add(" t2 = ((((%s >> 28) | (%s << 36)) ^ ((%s >> 34) | (%s << 30)) ^ ((%s >> 39) | (%s << 25)))"
" + ((%s & %s) ^ (%s & %s) ^ (%s & %s))) & M" % (a, a, a, a, a, a, a, b, a, c, b, c))
add(" %s = (t1 + t2) & M" % h)
for i in range(8):
add(" h%d = (h%d + r%d) & M" % (i, i, i))
add(" return _SHA512_PACK(h0, h1, h2, h3, h4, h5, h6, h7)")
return chr(10).join(out)
_SHA512_BLOCKS = None
def _sha512_blocks(padded):
global _SHA512_BLOCKS
fn = _SHA512_BLOCKS
if fn is None:
ns = {"_SHA512_H0": SHA512_H0, "MASK64": MASK64, "_SHA512_UNPACK": _SHA512_UNPACK,
"_SHA512_PACK": _SHA512_PACK}
exec(compile(_build_sha512(), "<sha512-codegen>", "exec"), ns)
fn = _SHA512_BLOCKS = ns["_sha512_blocks"]
return fn(padded)
def sha512(message: bytes) -> bytes: def sha512(message: bytes) -> bytes:
L = len(message) * 8 """SHA-512 (FIPS 180-4), 64-byte digest."""
padded = message + b"\x80" n = len(message)
while len(padded) % 128 != 112: L = n * 8
padded += b"\x00" return _sha512_blocks(
padded += struct.pack(">QQ", (L >> 64) & MASK64, L & MASK64) message + b"\x80" + b"\x00" * ((112 - n - 1) % 128)
+ _SHA512_QQ.pack((L >> 64) & MASK64, L & MASK64))
state = list(SHA512_H0)
K = SHA512_K
M = MASK64
for i in range(0, len(padded), 128):
W = list(struct.unpack(">16Q", padded[i:i + 128]))
for t in range(16, 80):
x = W[t - 15]
y = W[t - 2]
s0 = ((x >> 1) | (x << 63)) ^ ((x >> 8) | (x << 56)) ^ (x >> 7)
s1 = ((y >> 19) | (y << 45)) ^ ((y >> 61) | (y << 3)) ^ (y >> 6)
W.append((W[t - 16] + s0 + W[t - 7] + s1) & M)
a, b, c, d, e, f, g, h = state
for t in range(80):
S1 = ((e >> 14) | (e << 50)) ^ ((e >> 18) | (e << 46)) ^ ((e >> 41) | (e << 23))
ch = (e & f) ^ ((~e) & g)
T1 = (h + S1 + ch + K[t] + W[t]) & M
S0 = ((a >> 28) | (a << 36)) ^ ((a >> 34) | (a << 30)) ^ ((a >> 39) | (a << 25))
maj = (a & b) ^ (a & c) ^ (b & c)
T2 = (S0 + maj) & M
h, g, f, e, d, c, b, a = (
g, f, e, (d + T1) & M, c, b, a, (T1 + T2) & M
)
state[0] = (state[0] + a) & M
state[1] = (state[1] + b) & M
state[2] = (state[2] + c) & M
state[3] = (state[3] + d) & M
state[4] = (state[4] + e) & M
state[5] = (state[5] + f) & M
state[6] = (state[6] + g) & M
state[7] = (state[7] + h) & M
return struct.pack(">8Q", *state)
# ============================================================ # ============================================================
@@ -171,39 +236,64 @@ SIGMA = (
(10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0), (10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0),
) )
_B2B_UNPACK = struct.Struct("<16Q").unpack
_B2B_PACK = struct.Struct("<8Q").pack
def _blake2b_compress(h, block, t0, t1, f): # the eight G-mixing columns of BLAKE2b, as (a, b, c, d) index tuples
M = MASK64 _B2B_COLS = ((0, 4, 8, 12), (1, 5, 9, 13), (2, 6, 10, 14), (3, 7, 11, 15),
v = list(h) + list(BLAKE2B_IV) (0, 5, 10, 15), (1, 6, 11, 12), (2, 7, 8, 13), (3, 4, 9, 14))
v[12] ^= t0
v[13] ^= t1
v[14] ^= f
m = list(struct.unpack("<16Q", block))
def G(a, b, c, d, x, y):
v[a] = (v[a] + v[b] + x) & M
v[d] = ((v[d] ^ v[a]) >> 32) | (((v[d] ^ v[a]) << 32) & M)
v[c] = (v[c] + v[d]) & M
v[b] = ((v[b] ^ v[c]) >> 24) | (((v[b] ^ v[c]) << 40) & M)
v[a] = (v[a] + v[b] + y) & M
v[d] = ((v[d] ^ v[a]) >> 16) | (((v[d] ^ v[a]) << 48) & M)
v[c] = (v[c] + v[d]) & M
v[b] = ((v[b] ^ v[c]) >> 63) | (((v[b] ^ v[c]) << 1) & M)
def _build_blake2b():
"""Generate the unrolled BLAKE2b compression function.
The whole 12-round / 8-G-permutation schedule is expanded inline, with the
16 working words (``v0..v15``) and the 16 message words (``m0..m15``) held in
local variables instead of lists, and without the per-G closure call.
"""
out = []
add = out.append
add("def _blake2b_compress(h, block, t0, t1, f):")
add(" M = MASK64")
add(" h0, h1, h2, h3, h4, h5, h6, h7 = h")
add(" m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15 = _B2B_UNPACK(block)")
add(" v0, v1, v2, v3, v4, v5, v6, v7 = h0, h1, h2, h3, h4, h5, h6, h7")
for i, iv in enumerate(BLAKE2B_IV):
add(" v%d = 0x%016x" % (8 + i, iv))
add(" v12 = v12 ^ t0")
add(" v13 = v13 ^ t1")
add(" v14 = v14 ^ f")
for r in range(12): for r in range(12):
s = SIGMA[r % 10] s = SIGMA[r % 10]
G(0, 4, 8, 12, m[s[0]], m[s[1]]) for gi, (a, b, c, d) in enumerate(_B2B_COLS):
G(1, 5, 9, 13, m[s[2]], m[s[3]]) x = "m%d" % s[2 * gi]
G(2, 6, 10, 14, m[s[4]], m[s[5]]) y = "m%d" % s[2 * gi + 1]
G(3, 7, 11, 15, m[s[6]], m[s[7]]) va, vb, vc, vd = "v%d" % a, "v%d" % b, "v%d" % c, "v%d" % d
G(0, 5, 10, 15, m[s[8]], m[s[9]]) add(" %s = (%s + %s + %s) & M" % (va, va, vb, x))
G(1, 6, 11, 12, m[s[10]], m[s[11]]) add(" %s = ((%s ^ %s) >> 32) | (((%s ^ %s) << 32) & M)" % (vd, vd, va, vd, va))
G(2, 7, 8, 13, m[s[12]], m[s[13]]) add(" %s = (%s + %s) & M" % (vc, vc, vd))
G(3, 4, 9, 14, m[s[14]], m[s[15]]) add(" %s = ((%s ^ %s) >> 24) | (((%s ^ %s) << 40) & M)" % (vb, vb, vc, vb, vc))
add(" %s = (%s + %s + %s) & M" % (va, va, vb, y))
add(" %s = ((%s ^ %s) >> 16) | (((%s ^ %s) << 48) & M)" % (vd, vd, va, vd, va))
add(" %s = (%s + %s) & M" % (vc, vc, vd))
add(" %s = ((%s ^ %s) >> 63) | (((%s ^ %s) << 1) & M)" % (vb, vb, vc, vb, vc))
add(" return [(h0 ^ v0 ^ v8), (h1 ^ v1 ^ v9), (h2 ^ v2 ^ v10), (h3 ^ v3 ^ v11),"
" (h4 ^ v4 ^ v12), (h5 ^ v5 ^ v13), (h6 ^ v6 ^ v14), (h7 ^ v7 ^ v15)]")
return chr(10).join(out)
for i in range(8):
h[i] = (h[i] ^ v[i] ^ v[i + 8]) & M _B2B_COMPRESS = None
return h
def _blake2b_compress(h, block, t0, t1, f):
"""BLAKE2b compression function F (RFC 7693 section 3.2)."""
global _B2B_COMPRESS
fn = _B2B_COMPRESS
if fn is None:
ns = {"MASK64": MASK64, "_B2B_UNPACK": _B2B_UNPACK}
exec(compile(_build_blake2b(), "<blake2b-codegen>", "exec"), ns)
fn = _B2B_COMPRESS = ns["_blake2b_compress"]
return fn(h, block, t0, t1, f)
def blake2b(data: bytes, digest_size: int = 64): def blake2b(data: bytes, digest_size: int = 64):
@@ -232,11 +322,12 @@ def blake2b(data: bytes, digest_size: int = 64):
h = list(BLAKE2B_IV) h = list(BLAKE2B_IV)
h[0] ^= digest_size | (1 << 16) | (1 << 24) h[0] ^= digest_size | (1 << 16) | (1 << 24)
t0, t1 = 0, 0 t0, t1 = 0, 0
n = len(data)
pos = 0 pos = 0
# Key point: only compress as an intermediate block (f=0) when the remaining data EXCEEDS one block, # Key point: only compress as an intermediate block (f=0) when the remaining data EXCEEDS one block,
# otherwise the final block (including the case of exactly 128 bytes) must be finalized with f=MASK64. # otherwise the final block (including the case of exactly 128 bytes) must be finalized with f=MASK64.
# Empty input also requires compressing one all-zero block (RFC 7693). # Empty input also requires compressing one all-zero block (RFC 7693).
while len(data) - pos > 128: while n - pos > 128:
t0 += 128 t0 += 128
if t0 > MASK64: if t0 > MASK64:
t1 += 1 t1 += 1
@@ -248,6 +339,5 @@ def blake2b(data: bytes, digest_size: int = 64):
if t0 > MASK64: if t0 > MASK64:
t1 += 1 t1 += 1
t0 &= MASK64 t0 &= MASK64
last_padded = last + b"\x00" * (128 - len(last)) h = _blake2b_compress(h, last.ljust(128, b"\x00"), t0, t1, MASK64)
h = _blake2b_compress(h, last_padded, t0, t1, MASK64) return _B2B_PACK(h[0], h[1], h[2], h[3], h[4], h[5], h[6], h[7])[:digest_size]
return struct.pack("<8Q", *h)[:digest_size]
+352 -132
View File
@@ -6,9 +6,10 @@ Key derivation: HMAC-SHA256/512, PBKDF2, HKDF, scrypt (RFC 7914), Argon2id (RFC
""" """
import struct import struct
from operator import xor as _xor
from .common import MASK32, MASK64 from .common import MASK32, MASK64
from .hash import sha256, sha512, blake2b from .hash import sha256, sha512, blake2b, SHA256_K, SHA256_H0, SHA512_K, SHA512_H0
from ._ppyc_error import ( from ._ppyc_error import (
PPYC_ERR, err, is_err, PPYC_ERR, err, is_err,
PPYC_ERR_INVALID_ARG, PPYC_ERR_INVALID_ARG,
@@ -18,6 +19,192 @@ from ._ppyc_error import (
) )
# ============================================================
# 4b. Fast SHA-256 / SHA-512 kernels (HMAC / PBKDF2 / HKDF)
# ============================================================
# Minimal compression + finalisation kernels that allow the HMAC ipad/opad
# chaining state to be precomputed once and reused across many iterations.
# This is what turns PBKDF2's 4 compressions per round into 2.
_SHA256_K = SHA256_K
_SHA256_H0 = SHA256_H0
_SHA512_K = SHA512_K
_SHA512_H0 = SHA512_H0
_XOR_IPAD = bytes(i ^ 0x36 for i in range(256))
_XOR_OPAD = bytes(i ^ 0x5C for i in range(256))
_SHA256_PAD8 = [0x80000000, 0, 0, 0, 0, 0, 0, 768]
_SHA512_PAD8 = [0x8000000000000000, 0, 0, 0, 0, 0, 0, 1536]
def _pack_256(st):
return struct.pack(">8I", *st)
def _pack_512(st):
return struct.pack(">8Q", *st)
def _sha256_compress(st, w):
"""One SHA-256 compression. ``st`` (8 words) is updated in place."""
M = MASK32
w = list(w)
for i in range(16, 64):
x = w[i - 15]
y = w[i - 2]
s0 = ((x >> 7) | (x << 25)) ^ ((x >> 18) | (x << 14)) ^ (x >> 3)
s1 = ((y >> 17) | (y << 15)) ^ ((y >> 19) | (y << 13)) ^ (y >> 10)
w.append((w[i - 16] + s0 + w[i - 7] + s1) & M)
a = st[0]; b = st[1]; c = st[2]; d = st[3]
e = st[4]; f = st[5]; g = st[6]; h = st[7]
for kt, wt in zip(_SHA256_K, w):
S1 = ((e >> 6) | (e << 26)) ^ ((e >> 11) | (e << 21)) ^ ((e >> 25) | (e << 7))
ch = (e & f) ^ ((~e) & g)
T1 = (h + S1 + ch + kt + wt) & M
S0 = ((a >> 2) | (a << 30)) ^ ((a >> 13) | (a << 19)) ^ ((a >> 22) | (a << 10))
maj = (a & b) ^ (a & c) ^ (b & c)
T2 = (S0 + maj) & M
h = g; g = f; f = e; e = (d + T1) & M
d = c; c = b; b = a; a = (T1 + T2) & M
st[0] = (st[0] + a) & M; st[1] = (st[1] + b) & M
st[2] = (st[2] + c) & M; st[3] = (st[3] + d) & M
st[4] = (st[4] + e) & M; st[5] = (st[5] + f) & M
st[6] = (st[6] + g) & M; st[7] = (st[7] + h) & M
def _sha256_final_words(st, remaining, prefix_len):
"""Absorb ``remaining`` (prefixed by ``prefix_len`` already-compressed bytes); return the 8-word state."""
msglen = prefix_len + len(remaining)
buf = remaining + b"\x80" + b"\x00" * ((55 - msglen) % 64) + struct.pack(">Q", (msglen * 8) & MASK64)
for i in range(0, len(buf), 64):
_sha256_compress(st, struct.unpack(">16I", buf[i:i + 64]))
return st
def _sha512_compress(st, w):
"""One SHA-512 compression. ``st`` (8 words) is updated in place."""
M = MASK64
w = list(w)
for i in range(16, 80):
x = w[i - 15]
y = w[i - 2]
s0 = ((x >> 1) | (x << 63)) ^ ((x >> 8) | (x << 56)) ^ (x >> 7)
s1 = ((y >> 19) | (y << 45)) ^ ((y >> 61) | (y << 3)) ^ (y >> 6)
w.append((w[i - 16] + s0 + w[i - 7] + s1) & M)
a = st[0]; b = st[1]; c = st[2]; d = st[3]
e = st[4]; f = st[5]; g = st[6]; h = st[7]
for kt, wt in zip(_SHA512_K, w):
S1 = ((e >> 14) | (e << 50)) ^ ((e >> 18) | (e << 46)) ^ ((e >> 41) | (e << 23))
ch = (e & f) ^ ((~e) & g)
T1 = (h + S1 + ch + kt + wt) & M
S0 = ((a >> 28) | (a << 36)) ^ ((a >> 34) | (a << 30)) ^ ((a >> 39) | (a << 25))
maj = (a & b) ^ (a & c) ^ (b & c)
T2 = (S0 + maj) & M
h = g; g = f; f = e; e = (d + T1) & M
d = c; c = b; b = a; a = (T1 + T2) & M
st[0] = (st[0] + a) & M; st[1] = (st[1] + b) & M
st[2] = (st[2] + c) & M; st[3] = (st[3] + d) & M
st[4] = (st[4] + e) & M; st[5] = (st[5] + f) & M
st[6] = (st[6] + g) & M; st[7] = (st[7] + h) & M
def _sha512_final_words(st, remaining, prefix_len):
"""Absorb ``remaining`` (prefixed by ``prefix_len`` already-compressed bytes); return the 8-word state."""
msglen = prefix_len + len(remaining)
nbits = msglen * 8
buf = (remaining + b"\x80" + b"\x00" * ((111 - msglen) % 128)
+ struct.pack(">QQ", (nbits >> 64) & MASK64, nbits & MASK64))
for i in range(0, len(buf), 128):
_sha512_compress(st, struct.unpack(">16Q", buf[i:i + 128]))
return st
def _sha256_midstates(key):
"""Return the precomputed HMAC-SHA256 ipad/opad chaining states for ``key``."""
bs = 64
if len(key) > bs:
key = sha256(key)
if len(key) < bs:
key = key + b"\x00" * (bs - len(key))
key = bytes(key)
mi = list(_SHA256_H0)
_sha256_compress(mi, struct.unpack(">16I", key.translate(_XOR_IPAD)))
mo = list(_SHA256_H0)
_sha256_compress(mo, struct.unpack(">16I", key.translate(_XOR_OPAD)))
return mi, mo
def _sha512_midstates(key, h0=None, hfn=None):
"""Return the precomputed HMAC-SHA512 (or SHA-384 with ``h0``/``hfn``) ipad/opad chaining states."""
if h0 is None:
h0 = _SHA512_H0
if hfn is None:
hfn = sha512
bs = 128
if len(key) > bs:
key = hfn(key)
if len(key) < bs:
key = key + b"\x00" * (bs - len(key))
key = bytes(key)
mi = list(h0)
_sha512_compress(mi, struct.unpack(">16Q", key.translate(_XOR_IPAD)))
mo = list(h0)
_sha512_compress(mo, struct.unpack(">16Q", key.translate(_XOR_OPAD)))
return mi, mo
def _hmac_pre_sha256(mi, mo, message):
"""HMAC-SHA256 given precomputed ipad/opad midstates."""
st = list(mi)
_sha256_final_words(st, message, 64)
st2 = list(mo)
_sha256_final_words(st2, _pack_256(st), 64)
return _pack_256(st2)
def _hmac_pre_sha512(mi, mo, message):
"""HMAC-SHA512 given precomputed ipad/opad midstates."""
st = list(mi)
_sha512_final_words(st, message, 128)
st2 = list(mo)
_sha512_final_words(st2, _pack_512(st), 128)
return _pack_512(st2)
def _pbkdf2_fast(password, salt, iterations, dklen, h_len, midstates, compress,
final_words, pack, pad, prefix_len, trim=None):
"""PBKDF2 inner loop with a reused HMAC ipad/opad state.
Steps ``U_{j} = PRF(P, U_{j-1})`` directly on the 8 chaining words, so the
per-iteration cost is exactly two block compressions and no byte-level XOR.
"""
mi, mo = midstates(password)
l = (dklen + h_len - 1) // h_len
dk = bytearray()
for i in range(1, l + 1):
st = list(mi)
final_words(st, salt + struct.pack(">I", i), prefix_len)
st2 = list(mo)
if trim is not None:
st = trim(st)
final_words(st2, pack(st), prefix_len)
if trim is not None:
st2 = trim(st2)
u = st2
acc = list(st2)
for _ in range(iterations - 1):
si = list(mi)
compress(si, u + pad)
if trim is not None:
si = trim(si)
so = list(mo)
compress(so, si + pad)
u = so if trim is None else trim(so)
acc = [x ^ y for x, y in zip(acc, u)]
dk += pack(acc)
return bytes(dk[:dklen])
# ============================================================ # ============================================================
# 5. Argon2id (RFC 9106) # 5. Argon2id (RFC 9106)
# ============================================================ # ============================================================
@@ -52,58 +239,62 @@ def _h_prime(data: bytes, outlen: int):
return out[:outlen] return out[:outlen]
def _gb(v, a, b, c, d): def _gb(v, a, b, c, d, M=MASK64, M32=MASK32):
M = MASK64 t = (v[a] + v[b] + 2 * (v[a] & M32) * (v[b] & M32)) & M
v[a] = (v[a] + v[b] + 2 * (v[a] & MASK32) * (v[b] & MASK32)) & M v[a] = t
v[d] = ((v[d] ^ v[a]) >> 32) | (((v[d] ^ v[a]) << 32) & M) x = v[d] ^ t
v[c] = (v[c] + v[d] + 2 * (v[c] & MASK32) * (v[d] & MASK32)) & M v[d] = (x >> 32) | ((x << 32) & M)
v[b] = ((v[b] ^ v[c]) >> 24) | (((v[b] ^ v[c]) << 40) & M) t = (v[c] + v[d] + 2 * (v[c] & M32) * (v[d] & M32)) & M
v[a] = (v[a] + v[b] + 2 * (v[a] & MASK32) * (v[b] & MASK32)) & M v[c] = t
v[d] = ((v[d] ^ v[a]) >> 16) | (((v[d] ^ v[a]) << 48) & M) x = v[b] ^ t
v[c] = (v[c] + v[d] + 2 * (v[c] & MASK32) * (v[d] & MASK32)) & M v[b] = (x >> 24) | ((x << 40) & M)
v[b] = ((v[b] ^ v[c]) >> 63) | (((v[b] ^ v[c]) << 1) & M) t = (v[a] + v[b] + 2 * (v[a] & M32) * (v[b] & M32)) & M
v[a] = t
x = v[d] ^ t
v[d] = (x >> 16) | ((x << 48) & M)
t = (v[c] + v[d] + 2 * (v[c] & M32) * (v[d] & M32)) & M
v[c] = t
x = v[b] ^ t
v[b] = (x >> 63) | ((x << 1) & M)
def _permute_words(w):
"""In-place Argon2 P-permutation on a flat list of 128 64-bit words."""
gb = _gb
for i in range(8):
b = i << 4
r = w[b:b + 16]
gb(r, 0, 4, 8, 12); gb(r, 1, 5, 9, 13)
gb(r, 2, 6, 10, 14); gb(r, 3, 7, 11, 15)
gb(r, 0, 5, 10, 15); gb(r, 1, 6, 11, 12)
gb(r, 2, 7, 8, 13); gb(r, 3, 4, 9, 14)
w[b:b + 16] = r
for j in range(8):
c = []
ap = c.append
for i in range(8):
o = (i << 4) + (j << 1)
ap(w[o]); ap(w[o + 1])
gb(c, 0, 4, 8, 12); gb(c, 1, 5, 9, 13)
gb(c, 2, 6, 10, 14); gb(c, 3, 7, 11, 15)
gb(c, 0, 5, 10, 15); gb(c, 1, 6, 11, 12)
gb(c, 2, 7, 8, 13); gb(c, 3, 4, 9, 14)
for i in range(8):
o = (i << 4) + (j << 1)
w[o] = c[i << 1]; w[o + 1] = c[(i << 1) + 1]
def _permute_p(S: bytes) -> bytes: def _permute_p(S: bytes) -> bytes:
regs = [] w = list(struct.unpack("<128Q", S))
for i in range(8): _permute_words(w)
row = [] return struct.pack("<128Q", *w)
for j in range(8):
off = (i * 8 + j) * 16
lo, hi = struct.unpack("<2Q", S[off:off + 16])
row.append([lo, hi])
regs.append(row)
def perm(rl):
v = []
for lo, hi in rl:
v.append(lo); v.append(hi)
_gb(v, 0, 4, 8, 12); _gb(v, 1, 5, 9, 13)
_gb(v, 2, 6, 10, 14); _gb(v, 3, 7, 11, 15)
_gb(v, 0, 5, 10, 15); _gb(v, 1, 6, 11, 12)
_gb(v, 2, 7, 8, 13); _gb(v, 3, 4, 9, 14)
return [[v[2 * i], v[2 * i + 1]] for i in range(8)]
for i in range(8):
regs[i] = perm(regs[i])
for j in range(8):
col = [regs[i][j] for i in range(8)]
col_p = perm(col)
for i in range(8):
regs[i][j] = col_p[i]
out = bytearray(1024)
for i in range(8):
for j in range(8):
off = (i * 8 + j) * 16
out[off:off + 16] = struct.pack("<2Q", regs[i][j][0], regs[i][j][1])
return bytes(out)
def _compress_g(X: bytes, Y: bytes) -> bytes: def _compress_g(X: bytes, Y: bytes) -> bytes:
R = bytes(a ^ b for a, b in zip(X, Y)) R = list(map(_xor, struct.unpack("<128Q", X), struct.unpack("<128Q", Y)))
Z = _permute_p(R) Z = R[:]
return bytes(a ^ b for a, b in zip(Z, R)) _permute_words(Z)
return struct.pack("<128Q", *map(_xor, Z, R))
def argon2id(password: bytes, salt: bytes, t: int = 1, m: int = 256, p: int = 1, def argon2id(password: bytes, salt: bytes, t: int = 1, m: int = 256, p: int = 1,
@@ -233,7 +424,8 @@ def argon2id(password: bytes, salt: bytes, t: int = 1, m: int = 256, p: int = 1,
new_block = _compress_g(prev, ref_block) new_block = _compress_g(prev, ref_block)
if r > 0 or curr >= 2: if r > 0 or curr >= 2:
new_block = bytes(a ^ b for a, b in zip(new_block, B[i][curr])) new_block = (int.from_bytes(new_block, "little")
^ int.from_bytes(B[i][curr], "little")).to_bytes(1024, "little")
B[i][curr][:] = new_block B[i][curr][:] = new_block
final = bytearray(B[0][q - 1]) final = bytearray(B[0][q - 1])
@@ -252,23 +444,27 @@ def argon2id(password: bytes, salt: bytes, t: int = 1, m: int = 256, p: int = 1,
# ============================================================ # ============================================================
def hmac_sha256(key: bytes, message: bytes) -> bytes: def hmac_sha256(key: bytes, message: bytes) -> bytes:
bs = 64 """HMAC-SHA256 (RFC 2104).
if len(key) > bs:
key = sha256(key) Returns
key = key + b"\x00" * (bs - len(key)) ----
ipad = bytes(b ^ 0x36 for b in key) bytes
opad = bytes(b ^ 0x5c for b in key) A 32-byte MAC.
return sha256(opad + sha256(ipad + message)) """
mi, mo = _sha256_midstates(key)
return _hmac_pre_sha256(mi, mo, message)
def hmac_sha512(key: bytes, message: bytes) -> bytes: def hmac_sha512(key: bytes, message: bytes) -> bytes:
bs = 128 """HMAC-SHA512 (RFC 2104).
if len(key) > bs:
key = sha512(key) Returns
key = key + b"\x00" * (bs - len(key)) ----
ipad = bytes(b ^ 0x36 for b in key) bytes
opad = bytes(b ^ 0x5c for b in key) A 64-byte MAC.
return sha512(opad + sha512(ipad + message)) """
mi, mo = _sha512_midstates(key)
return _hmac_pre_sha512(mi, mo, message)
def pbkdf2_hmac(password: bytes, salt: bytes, iterations: int, def pbkdf2_hmac(password: bytes, salt: bytes, iterations: int,
@@ -305,17 +501,13 @@ def pbkdf2_hmac(password: bytes, salt: bytes, iterations: int,
f"PBKDF2 output length dklen must be >= 1, got {dklen}", f"PBKDF2 output length dklen must be >= 1, got {dklen}",
"pass a desired key length >= 1") "pass a desired key length >= 1")
l = (dklen + h_len - 1) // h_len if hash_name == "sha256":
dk = bytearray() return _pbkdf2_fast(password, salt, iterations, dklen, 32,
for i in range(1, l + 1): _sha256_midstates, _sha256_compress,
u = hmac_func(password, salt + struct.pack(">I", i)) _sha256_final_words, _pack_256, _SHA256_PAD8, 64)
t = bytearray(u) return _pbkdf2_fast(password, salt, iterations, dklen, 64,
for _ in range(iterations - 1): _sha512_midstates, _sha512_compress,
u = hmac_func(password, u) _sha512_final_words, _pack_512, _SHA512_PAD8, 128)
for j in range(h_len):
t[j] ^= u[j]
dk.extend(t)
return bytes(dk[:dklen])
# ---- scrypt is defined later in this file (single implementation, the correct RFC 7914 version) ---- # ---- scrypt is defined later in this file (single implementation, the correct RFC 7914 version) ----
@@ -384,10 +576,16 @@ def hkdf_expand(prk: bytes, info: bytes, length: int, hash_name: str = "sha256")
f"the HKDF single-call output limit is {255 * h_len} bytes") f"the HKDF single-call output limit is {255 * h_len} bytes")
n = (length + h_len - 1) // h_len n = (length + h_len - 1) // h_len
if hash_name == "sha256":
mi, mo = _sha256_midstates(prk)
hmac_func = lambda m: _hmac_pre_sha256(mi, mo, m)
else:
mi, mo = _sha512_midstates(prk)
hmac_func = lambda m: _hmac_pre_sha512(mi, mo, m)
okm = b"" okm = b""
t = b"" t = b""
for i in range(1, n + 1): for i in range(1, n + 1):
t = hmac_func(prk, t + info + bytes([i])) t = hmac_func(t + info + bytes([i]))
okm += t okm += t
return okm[:length] return okm[:length]
@@ -416,6 +614,59 @@ def hkdf(ikm: bytes, salt: bytes = b"", info: bytes = b"",
# ============ Fixed scrypt + GHASH ============ # ============ Fixed scrypt + GHASH ============
def _salsa20_8_words(x):
"""Salsa20/8 core permutation on a 16-word list (internal hot path)."""
M = MASK32
x0, x1, x2, x3 = x[0], x[1], x[2], x[3]
x4, x5, x6, x7 = x[4], x[5], x[6], x[7]
x8, x9, x10, x11 = x[8], x[9], x[10], x[11]
x12, x13, x14, x15 = x[12], x[13], x[14], x[15]
o0, o1, o2, o3 = x0, x1, x2, x3
o4, o5, o6, o7 = x4, x5, x6, x7
o8, o9, o10, o11 = x8, x9, x10, x11
o12, o13, o14, o15 = x12, x13, x14, x15
for _ in range(4):
t = (x0 + x12) & M; x4 ^= (t << 7) | (t >> 25)
t = (x4 + x0) & M; x8 ^= (t << 9) | (t >> 23)
t = (x8 + x4) & M; x12 ^= (t << 13) | (t >> 19)
t = (x12 + x8) & M; x0 ^= (t << 18) | (t >> 14)
t = (x5 + x1) & M; x9 ^= (t << 7) | (t >> 25)
t = (x9 + x5) & M; x13 ^= (t << 9) | (t >> 23)
t = (x13 + x9) & M; x1 ^= (t << 13) | (t >> 19)
t = (x1 + x13) & M; x5 ^= (t << 18) | (t >> 14)
t = (x10 + x6) & M; x14 ^= (t << 7) | (t >> 25)
t = (x14 + x10) & M; x2 ^= (t << 9) | (t >> 23)
t = (x2 + x14) & M; x6 ^= (t << 13) | (t >> 19)
t = (x6 + x2) & M; x10 ^= (t << 18) | (t >> 14)
t = (x15 + x11) & M; x3 ^= (t << 7) | (t >> 25)
t = (x3 + x15) & M; x7 ^= (t << 9) | (t >> 23)
t = (x7 + x3) & M; x11 ^= (t << 13) | (t >> 19)
t = (x11 + x7) & M; x15 ^= (t << 18) | (t >> 14)
t = (x0 + x3) & M; x1 ^= (t << 7) | (t >> 25)
t = (x1 + x0) & M; x2 ^= (t << 9) | (t >> 23)
t = (x2 + x1) & M; x3 ^= (t << 13) | (t >> 19)
t = (x3 + x2) & M; x0 ^= (t << 18) | (t >> 14)
t = (x5 + x4) & M; x6 ^= (t << 7) | (t >> 25)
t = (x6 + x5) & M; x7 ^= (t << 9) | (t >> 23)
t = (x7 + x6) & M; x4 ^= (t << 13) | (t >> 19)
t = (x4 + x7) & M; x5 ^= (t << 18) | (t >> 14)
t = (x10 + x9) & M; x11 ^= (t << 7) | (t >> 25)
t = (x11 + x10) & M; x8 ^= (t << 9) | (t >> 23)
t = (x8 + x11) & M; x9 ^= (t << 13) | (t >> 19)
t = (x9 + x8) & M; x10 ^= (t << 18) | (t >> 14)
t = (x15 + x14) & M; x12 ^= (t << 7) | (t >> 25)
t = (x12 + x15) & M; x13 ^= (t << 9) | (t >> 23)
t = (x13 + x12) & M; x14 ^= (t << 13) | (t >> 19)
t = (x14 + x13) & M; x15 ^= (t << 18) | (t >> 14)
return [(x0 + o0) & M, (x1 + o1) & M, (x2 + o2) & M, (x3 + o3) & M,
(x4 + o4) & M, (x5 + o5) & M, (x6 + o6) & M, (x7 + o7) & M,
(x8 + o8) & M, (x9 + o9) & M, (x10 + o10) & M, (x11 + o11) & M,
(x12 + o12) & M, (x13 + o13) & M, (x14 + o14) & M, (x15 + o15) & M]
def _salsa20_8_core(block_in): def _salsa20_8_core(block_in):
"""Salsa20/8 core permutation (internal hot path). """Salsa20/8 core permutation (internal hot path).
@@ -431,57 +682,8 @@ def _salsa20_8_core(block_in):
raise PPYC_ERR(PPYC_ERR_INTERNAL, raise PPYC_ERR(PPYC_ERR_INTERNAL,
f"_salsa20_8_core requires a 64-byte input, got {len(block_in)}", f"_salsa20_8_core requires a 64-byte input, got {len(block_in)}",
"this is an internal library error, please file an issue") "this is an internal library error, please file an issue")
M = MASK32 return struct.pack("<16I", *_salsa20_8_words(list(struct.unpack("<16I", block_in))))
x = list(struct.unpack("<16I", block_in))
x0, x1, x2, x3 = x[0], x[1], x[2], x[3]
x4, x5, x6, x7 = x[4], x[5], x[6], x[7]
x8, x9, x10, x11 = x[8], x[9], x[10], x[11]
x12, x13, x14, x15 = x[12], x[13], x[14], x[15]
o0, o1, o2, o3 = x0, x1, x2, x3
o4, o5, o6, o7 = x4, x5, x6, x7
o8, o9, o10, o11 = x8, x9, x10, x11
o12, o13, o14, o15 = x12, x13, x14, x15
for _ in range(4):
t = (x0 + x12) & M; x4 = (x4 ^ (((t << 7) | (t >> 25)) & M)) & M
t = (x4 + x0) & M; x8 = (x8 ^ (((t << 9) | (t >> 23)) & M)) & M
t = (x8 + x4) & M; x12 = (x12 ^ (((t << 13) | (t >> 19)) & M)) & M
t = (x12 + x8) & M; x0 = (x0 ^ (((t << 18) | (t >> 14)) & M)) & M
t = (x5 + x1) & M; x9 = (x9 ^ (((t << 7) | (t >> 25)) & M)) & M
t = (x9 + x5) & M; x13 = (x13 ^ (((t << 9) | (t >> 23)) & M)) & M
t = (x13 + x9) & M; x1 = (x1 ^ (((t << 13) | (t >> 19)) & M)) & M
t = (x1 + x13) & M; x5 = (x5 ^ (((t << 18) | (t >> 14)) & M)) & M
t = (x10 + x6) & M; x14 = (x14 ^ (((t << 7) | (t >> 25)) & M)) & M
t = (x14 + x10) & M; x2 = (x2 ^ (((t << 9) | (t >> 23)) & M)) & M
t = (x2 + x14) & M; x6 = (x6 ^ (((t << 13) | (t >> 19)) & M)) & M
t = (x6 + x2) & M; x10 = (x10 ^ (((t << 18) | (t >> 14)) & M)) & M
t = (x15 + x11) & M; x3 = (x3 ^ (((t << 7) | (t >> 25)) & M)) & M
t = (x3 + x15) & M; x7 = (x7 ^ (((t << 9) | (t >> 23)) & M)) & M
t = (x7 + x3) & M; x11 = (x11 ^ (((t << 13) | (t >> 19)) & M)) & M
t = (x11 + x7) & M; x15 = (x15 ^ (((t << 18) | (t >> 14)) & M)) & M
t = (x0 + x3) & M; x1 = (x1 ^ (((t << 7) | (t >> 25)) & M)) & M
t = (x1 + x0) & M; x2 = (x2 ^ (((t << 9) | (t >> 23)) & M)) & M
t = (x2 + x1) & M; x3 = (x3 ^ (((t << 13) | (t >> 19)) & M)) & M
t = (x3 + x2) & M; x0 = (x0 ^ (((t << 18) | (t >> 14)) & M)) & M
t = (x5 + x4) & M; x6 = (x6 ^ (((t << 7) | (t >> 25)) & M)) & M
t = (x6 + x5) & M; x7 = (x7 ^ (((t << 9) | (t >> 23)) & M)) & M
t = (x7 + x6) & M; x4 = (x4 ^ (((t << 13) | (t >> 19)) & M)) & M
t = (x4 + x7) & M; x5 = (x5 ^ (((t << 18) | (t >> 14)) & M)) & M
t = (x10 + x9) & M; x11 = (x11 ^ (((t << 7) | (t >> 25)) & M)) & M
t = (x11 + x10) & M; x8 = (x8 ^ (((t << 9) | (t >> 23)) & M)) & M
t = (x8 + x11) & M; x9 = (x9 ^ (((t << 13) | (t >> 19)) & M)) & M
t = (x9 + x8) & M; x10 = (x10 ^ (((t << 18) | (t >> 14)) & M)) & M
t = (x15 + x14) & M; x12 = (x12 ^ (((t << 7) | (t >> 25)) & M)) & M
t = (x12 + x15) & M; x13 = (x13 ^ (((t << 9) | (t >> 23)) & M)) & M
t = (x13 + x12) & M; x14 = (x14 ^ (((t << 13) | (t >> 19)) & M)) & M
t = (x14 + x13) & M; x15 = (x15 ^ (((t << 18) | (t >> 14)) & M)) & M
return struct.pack("<16I",
(x0 + o0) & M, (x1 + o1) & M, (x2 + o2) & M, (x3 + o3) & M,
(x4 + o4) & M, (x5 + o5) & M, (x6 + o6) & M, (x7 + o7) & M,
(x8 + o8) & M, (x9 + o9) & M, (x10 + o10) & M, (x11 + o11) & M,
(x12 + o12) & M, (x13 + o13) & M, (x14 + o14) & M, (x15 + o15) & M)
def _blockmix_salsa8(B, r): def _blockmix_salsa8(B, r):
@@ -490,12 +692,24 @@ def _blockmix_salsa8(B, r):
# for i = 0 .. 2r-1: X = Salsa20/8(X xor B[i]); Y[i] = X # for i = 0 .. 2r-1: X = Salsa20/8(X xor B[i]); Y[i] = X
# BlockMix = (Y[0], Y[2], ..., Y[2r-2], Y[1], Y[3], ..., Y[2r-1]) # BlockMix = (Y[0], Y[2], ..., Y[2r-2], Y[1], Y[3], ..., Y[2r-1])
# Key point: the chained XOR must advance in the order i=0,1,...,2r-1, and only then is the even/odd permutation applied to the output. # Key point: the chained XOR must advance in the order i=0,1,...,2r-1, and only then is the even/odd permutation applied to the output.
X = bytes(B[(2 * r - 1) * 64: 2 * r * 64]) # Words are carried as 32-bit ints so the 64-byte XOR is a 16-element C-level map.
Y = [None] * (2 * r) two_r = 2 * r
for i in range(2 * r): unpack = struct.unpack_from
X = _salsa20_8_core(bytes(a ^ b for a, b in zip(X, B[i*64:(i+1)*64]))) salsa = _salsa20_8_words
xor = _xor
X = list(unpack("<16I", B, (two_r - 1) * 64))
Y = [None] * two_r
for i in range(two_r):
X = salsa(list(map(xor, X, unpack("<16I", B, i * 64))))
Y[i] = X Y[i] = X
return b"".join(Y[0::2] + Y[1::2]) out = bytearray(128 * r)
pack_into = struct.pack_into
off = 0
for i in range(0, two_r, 2):
pack_into("<16I", out, off, *Y[i]); off += 64
for i in range(1, two_r, 2):
pack_into("<16I", out, off, *Y[i]); off += 64
return bytes(out)
def _integerify(B, r): def _integerify(B, r):
@@ -508,12 +722,18 @@ def _romix(B, N, r):
bs = 128 * r bs = 128 * r
V = bytearray(N * bs) V = bytearray(N * bs)
X = bytes(B) X = bytes(B)
blk = _blockmix_salsa8
for i in range(N): for i in range(N):
V[i*bs:(i+1)*bs] = X V[i*bs:(i+1)*bs] = X
X = _blockmix_salsa8(X, r) X = blk(X, r)
from_bytes = int.from_bytes
unpack = struct.unpack_from
off = (2 * r - 1) * 64
for i in range(N): for i in range(N):
j = _integerify(X, r) % N j = unpack("<Q", X, off)[0] % N
X = _blockmix_salsa8(bytes(a ^ b for a, b in zip(X, V[j*bs:(j+1)*bs])), r) # XOR two whole blocks with one big-int operation instead of a per-byte generator.
X = blk((from_bytes(X, "little")
^ from_bytes(V[j*bs:(j+1)*bs], "little")).to_bytes(bs, "little"), r)
return X return X
+133 -11
View File
@@ -49,6 +49,21 @@ from .kdf import (
_h_prime, _h_prime,
_permute_p, _permute_p,
_compress_g, _compress_g,
_pbkdf2_fast,
_sha256_midstates,
_sha512_midstates,
_sha256_compress,
_sha512_compress,
_sha256_final_words,
_sha512_final_words,
_hmac_pre_sha256,
_hmac_pre_sha512,
_pack_256,
_pack_512,
_SHA256_PAD8,
_SHA512_PAD8,
_XOR_IPAD,
_XOR_OPAD,
) )
from ._ppyc_error import ( from ._ppyc_error import (
PPYC_ERR, PPYC_ERR,
@@ -214,6 +229,99 @@ def sha384(message: bytes) -> bytes:
return _sha512_core(message, _SHA384_H0)[:48] return _sha512_core(message, _SHA384_H0)[:48]
# ======================================================================
# 0b. Fast compression kernels for the supplementary hashes
# ======================================================================
# Same "precompute the ipad/opad chaining state" trick as ``kdf`` so that a
# PBKDF2 round costs two block compressions instead of four.
_SHA1_H0 = (0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0)
#: single-block SHA-1 padding for a 20-byte HMAC payload (64+20 bytes -> 672 bits)
_SHA1_PAD = [0x80000000] + [0] * 9 + [672]
#: single-block SHA-384 padding for a 48-byte HMAC payload (128+48 bytes -> 1408 bits)
_SHA384_PAD = [0x8000000000000000] + [0] * 8 + [1408]
def _pack_160(st):
return struct.pack(">5I", *st)
def _pack_384(st):
return struct.pack(">6Q", *st[:6])
def _sha1_compress(st, w):
"""One SHA-1 compression. ``st`` (5 words) is updated in place."""
M = MASK32
w = list(w)
for i in range(16, 80):
v = w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16]
w.append(((v << 1) | (v >> 31)) & M)
a = st[0]; b = st[1]; c = st[2]; d = st[3]; e = st[4]
for i in range(0, 20):
T = (((a << 5) | (a >> 27)) + ((b & c) | ((~b) & d)) + e + 0x5A827999 + w[i]) & M
e = d; d = c; c = ((b << 30) | (b >> 2)) & M; b = a; a = T
for i in range(20, 40):
T = (((a << 5) | (a >> 27)) + (b ^ c ^ d) + e + 0x6ED9EBA1 + w[i]) & M
e = d; d = c; c = ((b << 30) | (b >> 2)) & M; b = a; a = T
for i in range(40, 60):
T = (((a << 5) | (a >> 27)) + ((b & c) | (b & d) | (c & d)) + e + 0x8F1BBCDC + w[i]) & M
e = d; d = c; c = ((b << 30) | (b >> 2)) & M; b = a; a = T
for i in range(60, 80):
T = (((a << 5) | (a >> 27)) + (b ^ c ^ d) + e + 0xCA62C1D6 + w[i]) & M
e = d; d = c; c = ((b << 30) | (b >> 2)) & M; b = a; a = T
st[0] = (st[0] + a) & M; st[1] = (st[1] + b) & M; st[2] = (st[2] + c) & M
st[3] = (st[3] + d) & M; st[4] = (st[4] + e) & M
def _sha1_final_words(st, remaining, prefix_len):
msglen = prefix_len + len(remaining)
buf = remaining + b"\x80" + b"\x00" * ((55 - msglen) % 64) + struct.pack(">Q", (msglen * 8) & MASK64)
for i in range(0, len(buf), 64):
_sha1_compress(st, struct.unpack(">16I", buf[i:i + 64]))
return st
def _sha1_midstates(key):
bs = 64
if len(key) > bs:
key = sha1(key)
if len(key) < bs:
key = key + b"\x00" * (bs - len(key))
key = bytes(key)
mi = list(_SHA1_H0)
_sha1_compress(mi, struct.unpack(">16I", key.translate(_XOR_IPAD)))
mo = list(_SHA1_H0)
_sha1_compress(mo, struct.unpack(">16I", key.translate(_XOR_OPAD)))
return mi, mo
def _sha384_midstates(key):
# A key longer than the block size must be hashed with SHA-384 itself.
return _sha512_midstates(key, _SHA384_H0, sha384)
def _trim_mod6(st):
"""SHA-384 keeps only the first 6 words (48 bytes) of the SHA-512 state."""
return st[:6]
def _hmac_pre_sha1(mi, mo, message):
st = list(mi)
_sha1_final_words(st, message, 64)
st2 = list(mo)
_sha1_final_words(st2, _pack_160(st), 64)
return _pack_160(st2)
def _hmac_pre_sha384(mi, mo, message):
st = list(mi)
_sha512_final_words(st, message, 128)
st2 = list(mo)
_sha512_final_words(st2, _pack_384(st), 128)
return _pack_384(st2)
# ====================================================================== # ======================================================================
# 1. HMAC (generic construction, supporting sha1/sha256/sha384/sha512) # 1. HMAC (generic construction, supporting sha1/sha256/sha384/sha512)
# ====================================================================== # ======================================================================
@@ -221,11 +329,22 @@ def sha384(message: bytes) -> bytes:
def _hmac(hashfunc, block_size: int, key: bytes, message: bytes) -> bytes: def _hmac(hashfunc, block_size: int, key: bytes, message: bytes) -> bytes:
"""RFC 2104 generic HMAC construction (internal hot path). """RFC 2104 generic HMAC construction (internal hot path).
The ipad/opad chaining state is precomputed and the message is absorbed
directly by a block compressor, avoiding the padded-buffer round trip.
Returns Returns
---- ----
bytes bytes
The HMAC digest. The HMAC digest.
""" """
if hashfunc is sha256:
return _hmac_pre_sha256(*_sha256_midstates(key), message)
if hashfunc is sha512:
return _hmac_pre_sha512(*_sha512_midstates(key), message)
if hashfunc is sha384:
return _hmac_pre_sha384(*_sha384_midstates(key), message)
if hashfunc is sha1:
return _hmac_pre_sha1(*_sha1_midstates(key), message)
if isinstance(key, bytearray): if isinstance(key, bytearray):
key = bytes(key) key = bytes(key)
if isinstance(message, bytearray): if isinstance(message, bytearray):
@@ -370,16 +489,18 @@ def pbkdf2(password: bytes, salt: bytes, iterations: int, dklen: int,
f"PBKDF2 output length too large: dklen={dklen}, needs {l} blocks (limit 2^32-1)", f"PBKDF2 output length too large: dklen={dklen}, needs {l} blocks (limit 2^32-1)",
"reduce dklen, or switch to an extendable KDF such as HKDF") "reduce dklen, or switch to an extendable KDF such as HKDF")
dk = bytearray() if hash_name == "sha256":
for i in range(1, l + 1): return _pbkdf2_fast(pw, sl, iterations, dklen, 32, _sha256_midstates,
u = _hmac(hashfunc, block_size, pw, sl + struct.pack(">I", i)) _sha256_compress, _sha256_final_words, _pack_256, _SHA256_PAD8, 64)
t = bytearray(u) if hash_name == "sha512":
for _ in range(iterations - 1): return _pbkdf2_fast(pw, sl, iterations, dklen, 64, _sha512_midstates,
u = _hmac(hashfunc, block_size, pw, u) _sha512_compress, _sha512_final_words, _pack_512, _SHA512_PAD8, 128)
for j in range(h_len): if hash_name == "sha384":
t[j] ^= u[j] return _pbkdf2_fast(pw, sl, iterations, dklen, 48, _sha384_midstates,
dk.extend(t) _sha512_compress, _sha512_final_words, _pack_384, _SHA384_PAD, 128,
return bytes(dk[:dklen]) _trim_mod6)
return _pbkdf2_fast(pw, sl, iterations, dklen, 20, _sha1_midstates,
_sha1_compress, _sha1_final_words, _pack_160, _SHA1_PAD, 64)
#: Fully equivalent compatibility alias for :func:`pbkdf2` #: Fully equivalent compatibility alias for :func:`pbkdf2`
@@ -581,7 +702,8 @@ def _argon2_derive(password, salt, t, m, p, tag_length, variant,
new_block = _compress_g(prev, ref_block) new_block = _compress_g(prev, ref_block)
if r > 0 or curr >= 2: if r > 0 or curr >= 2:
new_block = bytes(a ^ b for a, b in zip(new_block, B[i][curr])) new_block = (int.from_bytes(new_block, "little")
^ int.from_bytes(B[i][curr], "little")).to_bytes(1024, "little")
B[i][curr][:] = new_block B[i][curr][:] = new_block
final = bytearray(B[0][q - 1]) final = bytearray(B[0][q - 1])
+61 -18
View File
@@ -22,6 +22,7 @@ from typing import Tuple, List, Optional
from .common import ( from .common import (
MASK32, MASK32,
_consttime_eq, rand_int, _consttime_eq, rand_int,
_xor_bytes_fast,
) )
from .hash import sha256, sha512 from .hash import sha256, sha512
from .parallel import _HAS_MP from .parallel import _HAS_MP
@@ -95,12 +96,17 @@ def mod_inverse(a: int, m: int):
(str, str, str) (str, str, str)
A non-fatal error tuple; ``PPYC_ERR_INVALID_ARG`` (a and m are not coprime, so no inverse exists). A non-fatal error tuple; ``PPYC_ERR_INVALID_ARG`` (a and m are not coprime, so no inverse exists).
""" """
g, x, _ = extended_gcd(a % m, m) # Python >= 3.8 exposes the extended-Euclid inverse as a C-implemented built-in
if g != 1: # (`pow(x, -1, m)`), which is markedly faster than the pure-Python extended_gcd()
# above for the multi-thousand-bit moduli used by RSA. Values and error
# semantics are unchanged (same canonical representative in [0, m)).
try:
return pow(a % m, -1, m) % m
except ValueError:
g, _x, _ = extended_gcd(a % m, m)
raise PPYC_ERR(PPYC_ERR_INVALID_ARG, raise PPYC_ERR(PPYC_ERR_INVALID_ARG,
f"{a} has no multiplicative inverse modulo {m} (gcd={g})", f"{a} has no multiplicative inverse modulo {m} (gcd={g})",
"make sure a and m are coprime") "make sure a and m are coprime")
return x % m
def _mr_round(n: int, d: int, s: int, a: int) -> bool: def _mr_round(n: int, d: int, s: int, a: int) -> bool:
@@ -235,11 +241,23 @@ def _bpsw(n: int) -> bool:
def generate_prime_fast(bits: int) -> int: def generate_prime_fast(bits: int) -> int:
"""Draw a random `bits`-bit prime (BPSW + 4 random Miller-Rabin rounds).
The two top bits of the candidate are forced to 1, i.e. the prime is drawn
from ``[0.75 * 2^(bits-1), 2^bits)`` -- this is exactly the range FIPS 186-4
(B.3.1) prescribes for the RSA factors (`sqrt(2)*2^(n/2-1) <= p < 2^(n/2)`),
and it is what OpenSSL does as well. The practical consequence is that the
product of two such primes is *guaranteed* to have exactly ``2*bits`` bits, so
rsa_keygen() no longer has to throw away ~38% of the generated pairs
(P((1+u)(1+v) < 2) = 2*ln2 - 1 = 0.386 for uniform u, v in [0,1)) and never
re-runs the search. Security-wise this merely restricts the sample space to
the standard FIPS range; the prime still carries ~bits-1 bits of entropy.
"""
urandom = os.urandom urandom = os.urandom
isqrt = math.isqrt isqrt = math.isqrt
while True: while True:
base = int.from_bytes(urandom(bits // 8), "big") base = int.from_bytes(urandom(bits // 8), "big")
base |= (1 << (bits - 1)) | 1 base |= (1 << (bits - 1)) | (1 << (bits - 2)) | 1
for offset in range(0, 1 << 17, 2): for offset in range(0, 1 << 17, 2):
cand = base + offset cand = base + offset
if cand.bit_length() != bits: if cand.bit_length() != bits:
@@ -282,9 +300,10 @@ def _gen_worker(bits: int) -> int:
def generate_two_primes(bits_half: int) -> Tuple[int, int]: def generate_two_primes(bits_half: int) -> Tuple[int, int]:
if _HAS_MP: if _HAS_MP:
try: try:
import multiprocessing as mp # lazy: keeps the module import cheap
with mp.Pool(2) as pool: with mp.Pool(2) as pool:
p, q = pool.map(_gen_worker, [bits_half, bits_half]) p, q = pool.map(_gen_worker, [bits_half, bits_half])
except (OSError, RuntimeError, ImportError, AttributeError): except (OSError, RuntimeError, ImportError, AttributeError, ValueError):
p = generate_prime_fast(bits_half) p = generate_prime_fast(bits_half)
q = generate_prime_fast(bits_half) q = generate_prime_fast(bits_half)
else: else:
@@ -431,9 +450,9 @@ def oaep_encode(message: bytes, k: int, label: bytes, hash_func, h_len: int):
DB = lHash + PS + b"\x01" + message DB = lHash + PS + b"\x01" + message
seed = os.urandom(h_len) seed = os.urandom(h_len)
dbMask = mgf1(seed, k - h_len - 1, hash_func, h_len) dbMask = mgf1(seed, k - h_len - 1, hash_func, h_len)
maskedDB = bytes(a ^ b for a, b in zip(DB, dbMask)) maskedDB = _xor_bytes_fast(DB, dbMask)
seedMask = mgf1(maskedDB, h_len, hash_func, h_len) seedMask = mgf1(maskedDB, h_len, hash_func, h_len)
maskedSeed = bytes(a ^ b for a, b in zip(seed, seedMask)) maskedSeed = _xor_bytes_fast(seed, seedMask)
return b"\x00" + maskedSeed + maskedDB return b"\x00" + maskedSeed + maskedDB
@@ -457,9 +476,9 @@ def oaep_decode(em: bytes, k: int, label: bytes, hash_func, h_len: int):
maskedSeed = em[1:1 + h_len] maskedSeed = em[1:1 + h_len]
maskedDB = em[1 + h_len:] maskedDB = em[1 + h_len:]
seedMask = mgf1(maskedDB, h_len, hash_func, h_len) seedMask = mgf1(maskedDB, h_len, hash_func, h_len)
seed = bytes(a ^ b for a, b in zip(maskedSeed, seedMask)) seed = _xor_bytes_fast(maskedSeed, seedMask)
dbMask = mgf1(seed, k - h_len - 1, hash_func, h_len) dbMask = mgf1(seed, k - h_len - 1, hash_func, h_len)
DB = bytes(a ^ b for a, b in zip(maskedDB, dbMask)) DB = _xor_bytes_fast(maskedDB, dbMask)
if not _consttime_eq(DB[:h_len], hash_func(label)): if not _consttime_eq(DB[:h_len], hash_func(label)):
fail = True fail = True
rest = DB[h_len:] rest = DB[h_len:]
@@ -501,7 +520,7 @@ def pss_encode(message: bytes, em_bits: int, salt_len: int,
ps = b"\x00" * (em_len - salt_len - h_len - 2) ps = b"\x00" * (em_len - salt_len - h_len - 2)
db = ps + b"\x01" + salt db = ps + b"\x01" + salt
db_mask = mgf1(h, em_len - h_len - 1, hash_func, h_len) db_mask = mgf1(h, em_len - h_len - 1, hash_func, h_len)
masked_db = bytearray(a ^ b for a, b in zip(db, db_mask)) masked_db = bytearray(_xor_bytes_fast(db, db_mask))
bits_to_clear = 8 * em_len - em_bits bits_to_clear = 8 * em_len - em_bits
if bits_to_clear > 0: if bits_to_clear > 0:
masked_db[0] &= (0xFF >> bits_to_clear) masked_db[0] &= (0xFF >> bits_to_clear)
@@ -528,7 +547,7 @@ def pss_verify(message: bytes, em: bytes, em_bits: int, salt_len: int,
bits_to_clear = 8 * em_len - em_bits bits_to_clear = 8 * em_len - em_bits
if bits_to_clear > 0 and (masked_db[0] & (0xFF << (8 - bits_to_clear))): if bits_to_clear > 0 and (masked_db[0] & (0xFF << (8 - bits_to_clear))):
fail = True fail = True
db = bytes(a ^ b for a, b in zip(masked_db, mgf1(h, em_len - h_len - 1, hash_func, h_len))) db = _xor_bytes_fast(bytes(masked_db), mgf1(h, em_len - h_len - 1, hash_func, h_len))
if bits_to_clear > 0: if bits_to_clear > 0:
db = bytes([db[0] & (0xFF >> bits_to_clear)]) + db[1:] db = bytes([db[0] & (0xFF >> bits_to_clear)]) + db[1:]
idx = -1 idx = -1
@@ -571,6 +590,7 @@ class RSAPrivateKey:
self.salt_len = self.h_len self.salt_len = self.h_len
self._blind_r = None self._blind_r = None
self._blind_r_inv = None self._blind_r_inv = None
self._blind_re = None # (r^e mod n), kept in sync with _blind_r
self._blind_count = 0 self._blind_count = 0
self._mont_p = Montgomery(p) self._mont_p = Montgomery(p)
self._mont_q = Montgomery(q) self._mont_q = Montgomery(q)
@@ -590,6 +610,11 @@ class RSAPrivateKey:
if math.gcd(r, self.n) == 1: if math.gcd(r, self.n) == 1:
self._blind_r = r self._blind_r = r
self._blind_r_inv = mod_inverse(r, self.n) self._blind_r_inv = mod_inverse(r, self.n)
# r^e mod n is carried along instead of being recomputed on every
# blind(): unblind() squares r, and (r^2)^e = (r^e)^2, so the
# cached value can be updated with a single squaring -- the blinding
# factors themselves (and therefore the blinding) are unchanged.
self._blind_re = pow(r, self.e, self.n)
self._blind_count = 0 self._blind_count = 0
return return
@@ -598,24 +623,38 @@ class RSAPrivateKey:
if self._blind_count >= BLIND_RESET_INTERVAL: if self._blind_count >= BLIND_RESET_INTERVAL:
self._blind_r = None self._blind_r = None
self._blind_r_inv = None self._blind_r_inv = None
self._blind_re = None
def blind(self, c: int) -> int: def blind(self, c: int) -> int:
if self._blind_r is None: r = self._blind_r
if r is None:
self._init_blinding() self._init_blinding()
return (c * pow(self._blind_r, self.e, self.n)) % self.n r = self._blind_r
re = self._blind_re
if re is None: # defensive: keep the cache consistent
re = pow(r, self.e, self.n)
self._blind_re = re
return (c * re) % self.n
def unblind(self, m_blinded: int) -> int: def unblind(self, m_blinded: int) -> int:
m = (m_blinded * self._blind_r_inv) % self.n m = (m_blinded * self._blind_r_inv) % self.n
self._blind_r = (self._blind_r * self._blind_r) % self.n self._blind_r = (self._blind_r * self._blind_r) % self.n
self._blind_r_inv = (self._blind_r_inv * self._blind_r_inv) % self.n self._blind_r_inv = (self._blind_r_inv * self._blind_r_inv) % self.n
self._blind_re = (self._blind_re * self._blind_re) % self.n
self._maybe_reset_blinding() self._maybe_reset_blinding()
return m return m
def _crt_decrypt_raw(self, c: int) -> int: def _crt_decrypt_raw(self, c: int) -> int:
m1 = self._mont_p.pow(c % self.p, self.dp) # CRT private-key exponentiation: two half-size modular exponentiations with Python's
m2 = self._mont_q.pow(c % self.q, self.dq) # built-in pow() (C implementation). Mathematically identical to the previous pure-Python
h = (self.q_inv * (m1 - m2)) % self.p # Montgomery pow() (m_i = c^d_i mod n_i), but several times faster.
return m2 + h * self.q _pow = pow
p = self.p
q = self.q
m1 = _pow(c, self.dp, p)
m2 = _pow(c, self.dq, q)
h = (self.q_inv * (m1 - m2)) % p
return m2 + h * q
def decrypt_blinded(self, c: int) -> int: def decrypt_blinded(self, c: int) -> int:
c_blinded = self.blind(c) c_blinded = self.blind(c)
@@ -748,9 +787,13 @@ def rsa_pss_sign(message: bytes, priv: RSAPrivateKey, salt_len: int = None):
if m >= priv.n: if m >= priv.n:
raise PPYC_ERR(PPYC_ERR_MESSAGE_TOO_LONG, "encoded message exceeds the modulus", raise PPYC_ERR(PPYC_ERR_MESSAGE_TOO_LONG, "encoded message exceeds the modulus",
"message too long, shorten it or use a larger key") "message too long, shorten it or use a larger key")
# s = m^d mod n. Use CRT (two half-size exponentiations) together with RSA blinding
# (decrypt_blinded), which is several times faster than a single full-size pow(m, d, n)
# and additionally hardens against timing attacks. Result value is identical.
sig = priv.decrypt_blinded(m)
except PPYC_ERR as e: except PPYC_ERR as e:
return e.as_tuple() return e.as_tuple()
return pow(m, priv.d, priv.n).to_bytes(k, "big") return sig.to_bytes(k, "big")
def rsa_pss_verify(message: bytes, signature: bytes, pub: RSAPublicKey, def rsa_pss_verify(message: bytes, signature: bytes, pub: RSAPublicKey,
+102 -22
View File
@@ -133,40 +133,119 @@ def _rotl64(v: int, n: int) -> int:
return ((v << n) | (v >> (64 - n))) & MASK64 if n else v return ((v << n) | (v >> (64 - n))) & MASK64 if n else v
def _perm_packed(S: int, rounds: int = 24) -> int: # ------------------------------------------------------------
"""Keccak-f[1600] permutation (SWAR-packed integer version). # Keccak-f[1600]: code-generated, fully unrolled permutation
# ------------------------------------------------------------
# Design notes (kept for auditing):
#
# * theta and chi touch all 25 lanes "SWAR-style" (SIMD-Within-A-Register): one big-integer
# shift/xor/and operates on all 25 lanes at once, so those two steps cost ~13-32 Python
# operations *per round* instead of ~200 per-lane operations.
# * rho+pi needs 24 rotations by 24 *different* amounts, which cannot be expressed as a bulk
# big-integer operation. struct.Struct (one C call in, one C call out) is the cheapest way
# to move the 25 lanes between the packed int and Python-level integers.
# * The complete 24-round schedule is emitted as straight-line code at import time:
# no Python-level loop, no list indexing, no per-round re-packing, and every rotation
# amount / round constant / mask becomes a LOAD_CONST constant.
# * rotl64(v, n) is evaluated as ((v * (2**64 + 1)) >> (64 - n)) & MASK64: the 128-bit
# product v + (v << 64) already contains both the wrapped-out high bits and the shifted
# low bits, so one multiply + one shift + one mask replaces the classic
# two shifts + or + mask (3 integer operations instead of 4).
#
# The generic (looping) implementation is kept as `_perm_packed_generic` for arbitrary
# round counts; `_perm_packed` dispatches to the generated 24-round version.
S is a 1600-bit integer; state layout: lane i = x + 5y sits at bit 64*i (little-endian). _MASK_HEX = "0xFFFFFFFFFFFFFFFF"
theta/chi process all lanes at once with big-integer bit operations, while rho/pi use struct-based batch rotation, _K65_HEX = "0x10000000000000001"
roughly 4x faster than a per-lane Python loop.
This is an internal function; the list interface `keccak_f1600(state)` is still exposed publicly.
""" def _keccak_f_source(rounds: int = 24) -> str:
"""Emit the straight-line source of a fully unrolled Keccak-f[1600] `rounds`-round permutation."""
out = []
ap = out.append
ap("def _keccak_f_packed(S, _unpack=_UNPACK, _pack=_PACK, _fb=int.from_bytes):")
for rnd in range(rounds):
# ---- theta: column parities C, then the diffusion D = C[x-1] ^ rotl(C[x+1], 1) ----
# (tree form: 3 shifts instead of 4 for the 5-way column XOR)
ap(" A=S^(S>>640)")
ap(" B=A^(A>>320)")
ap(" C=(B^(B>>1280))&0x%X" % _M320)
ap(" R1=((C<<1)&0x%X)|((C>>63)&0x%X)" % (_LOMASK, _HIMASK))
ap(" D=(((C<<64)|(C>>256))&0x%X)^(((R1>>64)|(R1<<256))&0x%X)" % (_M320, _M320))
# broadcast D onto all five columns of every row in one shot, then fold into S
ap(" S=S^(D|(D<<320)|(D<<640)|(D<<960)|(D<<1280))")
# ---- rho + pi: unpack all 25 lanes, rotate each, repack (values are compile-time) ----
ap(" l0,l1,l2,l3,l4,l5,l6,l7,l8,l9,l10,l11,l12,l13,l14,l15,l16,l17,l18,l19,l20,l21,l22,l23,l24=_unpack(S.to_bytes(200,'little'))")
rot = []
for _dst, (_src, _n) in enumerate(_RHOPI_ORDER):
if _n:
rot.append("((l%d*%s)>>%d)&%s" % (_src, _K65_HEX, 64 - _n, _MASK_HEX))
else:
rot.append("l%d" % _src)
ap(" S=_fb(_pack(%s),'little')" % ",".join(rot))
# ---- chi: intra-row nonlinear mixing, again SWAR (all 25 lanes per operation) ----
ap(" B1=((S>>64)&0x%X)|((S<<256)&0x%X)" % (_KEEPNONEND, _ENDMASK))
ap(" B2=((B1>>64)&0x%X)|((B1<<256)&0x%X)" % (_KEEPNONEND, _ENDMASK))
ap(" S^=B2&~B1")
# ---- iota: round constant ----
ap(" S^=0x%X" % _KECCAK_RC[rnd])
ap(" return S")
return "\n".join(out)
def _compile_keccak_f(rounds: int = 24):
"""Compile the generated straight-line permutation and return the function object."""
src = _keccak_f_source(rounds)
ns = {"_UNPACK": _UNPACK, "_PACK": _PACK, "int": int, "__name__": __name__}
exec(compile(src, "<purepycrypto.sha3.keccak_f%d>" % rounds, "exec"), ns)
return ns["_keccak_f_packed"]
_keccak_f_packed24 = _compile_keccak_f(24)
def _perm_packed_generic(S: int, rounds: int = 24) -> int:
"""Generic (looping) SWAR-packed Keccak-f[1600]; kept for non-standard round counts."""
M64 = _M64 M64 = _M64
_unpack = _UNPACK _unpack = _UNPACK
_pack = _PACK _pack = _PACK
_frm = int.from_bytes
for r in range(rounds): for r in range(rounds):
# ---- theta: column parity C, diffusion D ---- # ---- theta ----
C = (S ^ (S >> 320) ^ (S >> 640) ^ (S >> 960) ^ (S >> 1280)) & _M320 C = (S ^ (S >> 320) ^ (S >> 640) ^ (S >> 960) ^ (S >> 1280)) & _M320
Cm1 = ((C << 64) | (C >> 256)) & _M320 Cm1 = ((C << 64) | (C >> 256)) & _M320
Cp1 = ((C >> 64) | (C << 256)) & _M320 Cp1 = ((C >> 64) | (C << 256)) & _M320
R = ((Cp1 << 1) & _LOMASK) | ((Cp1 >> 63) & _HIMASK) R = ((Cp1 << 1) & _LOMASK) | ((Cp1 >> 63) & _HIMASK)
D = Cm1 ^ R D = Cm1 ^ R
S ^= D | (D << 320) | (D << 640) | (D << 960) | (D << 1280) S ^= D | (D << 320) | (D << 640) | (D << 960) | (D << 1280)
# ---- rho + pi: batch rotate + rearrange ---- # ---- rho + pi ----
lanes = _unpack(S.to_bytes(200, "little")) lanes = _unpack(S.to_bytes(200, "little"))
S = int.from_bytes( S = _frm(_pack(*[((lanes[src] << n) | (lanes[src] >> (64 - n))) & M64
_pack(*[((lanes[src] << n) | (lanes[src] >> (64 - n))) & M64 for src, n in _RHOPI_ORDER]), "little")
for src, n in _RHOPI_ORDER]), "little") # ---- chi ----
# ---- chi: intra-row nonlinear mixing (big-integer mask implementation) ----
B1 = ((S >> 64) & _KEEPNONEND) | ((S << 256) & _ENDMASK) B1 = ((S >> 64) & _KEEPNONEND) | ((S << 256) & _ENDMASK)
B2 = ((B1 >> 64) & _KEEPNONEND) | ((B1 << 256) & _ENDMASK) B2 = ((B1 >> 64) & _KEEPNONEND) | ((B1 << 256) & _ENDMASK)
S ^= B2 & ~B1 S ^= B2 & ~B1
# ---- iota: round constant ---- # ---- iota ----
S ^= _KECCAK_RC[r] S ^= _KECCAK_RC[r]
return S return S
def _perm_packed(S: int, rounds: int = 24) -> int:
"""Keccak-f[1600] permutation (SWAR-packed integer version).
S is a 1600-bit integer; state layout: lane i = x + 5y sits at bit 64*i (little-endian).
theta/chi process all 25 lanes at once with big-integer bit operations, while rho/pi use
struct-based batch rotation; the 24 standard rounds are straight-line generated code
(see `_keccak_f_source`), roughly 5x faster than a naive per-lane Python loop.
This is an internal function; the list interface `keccak_f1600(state)` is still exposed publicly.
"""
if rounds == 24:
return _keccak_f_packed24(S)
return _perm_packed_generic(S, rounds)
def keccak_f1600(state): def keccak_f1600(state):
"""Keccak-f[1600] permutation (modifies the state list in place and returns it). """Keccak-f[1600] permutation (modifies the state list in place and returns it).
@@ -175,12 +254,12 @@ def keccak_f1600(state):
state : list[int], a list of 25 64-bit lanes (little-endian mapping). state : list[int], a list of 25 64-bit lanes (little-endian mapping).
Index convention A[x + 5*y], x, y in [0, 5). Index convention A[x + 5*y], x, y in [0, 5).
This function is now driven by the SWAR-packed implementation: internally the 25 lanes are packed into a 1600-bit integer, This function is driven by the SWAR-packed implementation: internally the 25 lanes are
`_perm_packed` is called and the result is written back to the list. The interface and semantics are unchanged. packed into a 1600-bit integer, `_perm_packed` is called and the result is written back
to the list. The interface and semantics are unchanged.
""" """
S = int.from_bytes(struct.pack("<25Q", *state), "little") S = _perm_packed(int.from_bytes(struct.pack("<25Q", *state), "little"))
S = _perm_packed(S) vals = _UNPACK(S.to_bytes(200, "little"))
vals = struct.unpack("<25Q", S.to_bytes(200, "little"))
for i in range(25): for i in range(25):
state[i] = vals[i] state[i] = vals[i]
return state return state
@@ -221,18 +300,19 @@ def _sponge(data: bytes, rate: int, suffix: int, outlen: int) -> bytes:
padded = data + bytes([suffix]) + b"\x00" * (padlen - 2) + bytes([0x80]) padded = data + bytes([suffix]) + b"\x00" * (padlen - 2) + bytes([0x80])
# ---- absorb: XOR whole blocks into the state, then permute (the state is carried as a 1600-bit integer) ---- # ---- absorb: XOR whole blocks into the state, then permute (the state is carried as a 1600-bit integer) ----
_perm = _keccak_f_packed24 # local binding: hot loop, one permutation per block
_frm = int.from_bytes
lo_mask = (1 << (64 * (rate // 8))) - 1 lo_mask = (1 << (64 * (rate // 8))) - 1
S = 0 S = 0
for off in range(0, len(padded), rate): for off in range(0, len(padded), rate):
S ^= int.from_bytes(padded[off:off + rate], "little") S = _perm(S ^ _frm(padded[off:off + rate], "little"))
S = _perm_packed(S)
# ---- squeeze: emit rate bytes each time, permuting again when more are needed ---- # ---- squeeze: emit rate bytes each time, permuting again when more are needed ----
out = bytearray() out = bytearray()
while len(out) < outlen: while len(out) < outlen:
out += (S & lo_mask).to_bytes(rate, "little") out += (S & lo_mask).to_bytes(rate, "little")
if len(out) < outlen: if len(out) < outlen:
S = _perm_packed(S) S = _perm(S)
return bytes(out[:outlen]) return bytes(out[:outlen])
File diff suppressed because it is too large Load Diff
+53 -35
View File
@@ -61,48 +61,66 @@ def x25519(k_bytes: bytes, u_bytes: bytes) -> Union[bytes, PPYCResult]:
f"X25519 k and u must each be 32 bytes (got k={len(k_bytes)}, u={len(u_bytes)})", f"X25519 k and u must each be 32 bytes (got k={len(k_bytes)}, u={len(u_bytes)})",
"pass a 32-byte scalar and u coordinate") "pass a 32-byte scalar and u coordinate")
k_list = bytearray(k_bytes) # ---- Scalar / u clamping (unchanged bit semantics: RFC 7748 section 5) ----
k_list[0] &= 248 # k[0] &= 248; k[31] &= 127; k[31] |= 64 (little-endian byte clamping)
k_list[31] &= 127 k = int.from_bytes(k_bytes, "little")
k_list[31] |= 64 k = ((k & ~7) & ~(1 << 255)) | (1 << 254)
k = int.from_bytes(k_list, "little") # u[31] &= 0x7F; u mod p
u = (int.from_bytes(u_bytes, "little") & ((1 << 255) - 1)) % P25519
u_list = bytearray(u_bytes)
u_list[31] &= 0x7F
u = int.from_bytes(u_list, "little")
u %= P25519
# ---- Montgomery ladder (fully inlined, constant-time) ----
# Reductions use the Mersenne-style folding t = (t&(2^255-1)) + 19*(t>>255)
# (2^255 == 19 mod p), applied twice; this is faster than a big-integer "% p"
# on the 510-bit products. For any integer t (negative included)
# t = (t >> 255) * 2^255 + (t & (2^255 - 1))
# holds exactly, so the fold is an exact congruence and needs no sign fixup.
# Field elements are kept as *signed lazy* values with |v| <= 2^255 + 2^31:
# a fold of a product of two values bounded by 2^257 gives at most
# 2^255 + 38 + 361*|t|/2^510, and the only larger intermediate is
# E*(AA + A24*E) < 2^532, which the two folding rounds still map below
# 2^255 + 2^31. Everything downstream (`% p` of the final x2 * z2^-1) is exact.
# All scalar-dependent selection (the conditional swap) uses arithmetic masks
# (no branch, no secret index).
_P = P25519
_M = (1 << 255) - 1
_A24 = A24_25519
x1 = u x1 = u
x2, z2 = 1, 0 x2 = 1; z2 = 0
x3, z3 = u, 1 x3 = u; z3 = 1
swap = 0 prev = 0 # previous key bit (initial swap = 0)
for t in range(254, -1, -1): for t in range(254, -1, -1):
kt = (k >> t) & 1 kt = (k >> t) & 1
swap ^= kt m = -(prev ^ kt) # 0 or -1: cswap iff the bit changed
x2, x3 = _cswap(swap, x2, x3) d = m & (x2 ^ x3); x2 ^= d; x3 ^= d
z2, z3 = _cswap(swap, z2, z3) d = m & (z2 ^ z3); z2 ^= d; z3 ^= d
swap = kt prev = kt
A = (x2 + z2) % P25519 # No sign normalisation is needed on B / D / E: the folding reduction is an exact
AA = A * A % P25519 # congruence for negative arguments as well (see the module note above), and the
B = (x2 - z2) % P25519 # magnitude analysis below shows the lazy values stay inside the fold's safe domain.
BB = B * B % P25519 A = x2 + z2
E = (AA - BB) % P25519 AA = A * A; AA = (AA & _M) + 19 * (AA >> 255); AA = (AA & _M) + 19 * (AA >> 255)
C = (x3 + z3) % P25519 B = x2 - z2
D = (x3 - z3) % P25519 BB = B * B; BB = (BB & _M) + 19 * (BB >> 255); BB = (BB & _M) + 19 * (BB >> 255)
DA = D * A % P25519 E = AA - BB
CB = C * B % P25519 C = x3 + z3
D = x3 - z3
DA = D * A; DA = (DA & _M) + 19 * (DA >> 255); DA = (DA & _M) + 19 * (DA >> 255)
CB = C * B; CB = (CB & _M) + 19 * (CB >> 255); CB = (CB & _M) + 19 * (CB >> 255)
t1 = DA + CB
t1 = t1 * t1; t1 = (t1 & _M) + 19 * (t1 >> 255); t1 = (t1 & _M) + 19 * (t1 >> 255); x3 = t1
t2 = DA - CB
t2 = t2 * t2; t2 = (t2 & _M) + 19 * (t2 >> 255); t2 = (t2 & _M) + 19 * (t2 >> 255)
z3 = x1 * t2; z3 = (z3 & _M) + 19 * (z3 >> 255); z3 = (z3 & _M) + 19 * (z3 >> 255)
x2 = AA * BB; x2 = (x2 & _M) + 19 * (x2 >> 255); x2 = (x2 & _M) + 19 * (x2 >> 255)
t1 = E * (AA + _A24 * E)
t1 = (t1 & _M) + 19 * (t1 >> 255); z2 = (t1 & _M) + 19 * (t1 >> 255)
x3 = (DA + CB) ** 2 % P25519 m = -prev
z3 = x1 * (DA - CB) ** 2 % P25519 d = m & (x2 ^ x3); x2 ^= d; x3 ^= d
x2 = AA * BB % P25519 d = m & (z2 ^ z3); z2 ^= d; z3 ^= d
z2 = E * (AA + A24_25519 * E) % P25519
x2, x3 = _cswap(swap, x2, x3) result = x2 * pow(z2, _P - 2, _P) % _P
z2, z3 = _cswap(swap, z2, z3)
result = x2 * pow(z2, P25519 - 2, P25519) % P25519
return result.to_bytes(32, "little") return result.to_bytes(32, "little")
+1 -1
View File
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
[project] [project]
name = "purepycrypto" name = "purepycrypto"
version = "3.2.0" version = "3.2.1"
description = "Pure-Python cryptography library (zero dependencies): SHA-2/SHA-3/BLAKE2b, AES-GCM(-SIV), ChaCha20-Poly1305, X25519/Ed25519, RSA-OAEP/PSS, with built-in TUI and command-line tool" description = "Pure-Python cryptography library (zero dependencies): SHA-2/SHA-3/BLAKE2b, AES-GCM(-SIV), ChaCha20-Poly1305, X25519/Ed25519, RSA-OAEP/PSS, with built-in TUI and command-line tool"
readme = "README.md" readme = "README.md"
requires-python = ">=3.7" requires-python = ">=3.7"
+1 -1
View File
@@ -57,7 +57,7 @@ import sys
from setuptools import setup, find_packages from setuptools import setup, find_packages
VERSION = "3.2.0" VERSION = "3.2.1"
HERE = os.path.abspath(os.path.dirname(__file__)) HERE = os.path.abspath(os.path.dirname(__file__))