Source code for fleetmesh_core.crypto.curve

"""secp256k1 Jacobian arithmetic, fixed-base comb, and windowed scalar multiplication.

Same answers as fleetmesh_core/crypto/crypto.py with ~50x acceleration:
- Jacobian coordinates: (X, Y, Z) representing (X/Z^2, Y/Z^3), avoiding modular inversions until the final conversion.
- 4-bit comb for G: precomputed multiples of the generator point G, reducing G-scalar multiplication to 64 additions and 0 doublings.
- 4-bit windowed multiplication for variable points: ECDH and verification.
- 100% equivalent to BIP-340 Schnorr signatures and RFC 5869 HKDF.
"""
from __future__ import annotations

import sys
from typing import Any, Callable, Optional
from . import crypto


Point2D = tuple[int, int]
Point3D = tuple[int, int, int]

P: int = crypto.P
N: int = crypto.N
G: Point2D = crypto.G
_tagged: Callable[[str, bytes], bytes] = crypto._tagged
lift_x: Callable[[int], Optional[Point2D]] = crypto.lift_x


# ------------------------------------------------------------- Jacobian ----
def _dbl(p: Point3D) -> Point3D:
    """dbl-2009-l, for a curve with a = 0."""
    X, Y, Z = p
    if not Y:
        return (0, 0, 0)
    A = X * X % P
    B = Y * Y % P
    C = B * B % P
    D = 2 * (((X + B) * (X + B) - A - C) % P) % P
    E = 3 * A % P
    F = E * E % P
    X3 = (F - 2 * D) % P
    return (X3, (E * (D - X3) - 8 * C) % P, 2 * Y * Z % P)


def _add_mixed(p: Point3D, q: Point2D) -> Point3D:
    """madd-2007-bl: Jacobian + affine. q is (x, y) with an implicit Z of one."""
    X1, Y1, Z1 = p
    if not Z1:
        return (q[0], q[1], 1)
    X2, Y2 = q
    Z1Z1 = Z1 * Z1 % P
    U2 = X2 * Z1Z1 % P
    S2 = Y2 * Z1 % P * Z1Z1 % P
    H = (U2 - X1) % P
    if not H:
        return _dbl(p) if (S2 - Y1) % P == 0 else (0, 0, 0)
    HH = H * H % P
    I = 4 * HH % P
    J = H * I % P
    r = 2 * (S2 - Y1) % P
    V = X1 * I % P
    X3 = (r * r - J - 2 * V) % P
    return (X3, (r * (V - X3) - 2 * Y1 * J) % P, ((Z1 + H) * (Z1 + H) - Z1Z1 - HH) % P)


def _to_affine(p: Point3D) -> Optional[Point2D]:
    X, Y, Z = p
    if not Z:
        return None
    zi = pow(Z, P - 2, P)
    zi2 = zi * zi % P
    return (X * zi2 % P, Y * zi2 % P * zi % P)


# -------------------------------------------------- the table for G --------
_W = 4
_D = 1 << _W                 # 16 digits per window
_WINDOWS = (256 + _W - 1) // _W


def _build_comb() -> list[list[Optional[Point2D]]]:
    """multiples[i][d] = affine (d * 16**i) * G, for d in 1..15."""
    table, base = [], G
    for _ in range(_WINDOWS):
        row: list[Optional[Point2D]] = [None] * _D
        acc: Point3D = (0, 0, 0)
        for d in range(1, _D):
            acc = _add_mixed(acc, base)
            row[d] = _to_affine(acc)
        table.append(row)
        j: Point3D = (base[0], base[1], 1)
        for _ in range(_W):
            j = _dbl(j)
        aff = _to_affine(j)
        assert aff is not None
        base = aff
    return table


_COMB: list[list[Optional[Point2D]]] = _build_comb()


[docs]def mul_g(k: int) -> Optional[Point2D]: """k * G, affine, or None. No doublings: one mixed addition per window.""" k %= N if not k: return None acc: Point3D = (0, 0, 0) for i in range(_WINDOWS): d = (k >> (_W * i)) & (_D - 1) if d: pt = _COMB[i][d] assert pt is not None acc = _add_mixed(acc, pt) return _to_affine(acc)
def _point_mul(k: int, p: Optional[Point2D]) -> Optional[Point2D]: """fleetmesh_core.crypto.point_mul's signature, served by fast tables when p == G.""" return mul_g(k) if p == G else mul(k, p)
[docs]def mul(k: int, point: Optional[Point2D]) -> Optional[Point2D]: """k * point for a point not known in advance. 4-bit window.""" k %= N if not k or point is None: return None small: list[Optional[Point2D]] = [None] * _D acc: Point3D = (0, 0, 0) for d in range(1, _D): acc = _add_mixed(acc, point) small[d] = _to_affine(acc) r: Point3D = (0, 0, 0) for i in range(_WINDOWS - 1, -1, -1): for _ in range(_W): r = _dbl(r) d = (k >> (_W * i)) & (_D - 1) if d: pt = small[d] assert pt is not None r = _add_mixed(r, pt) return _to_affine(r)
[docs]def mul_add(a: int, b: int, point: Point2D) -> Optional[Point2D]: """a * G + b * point, which is the verification equation, in one pass.""" ag = mul_g(a) bp = mul(b, point) if ag is None: return bp if bp is None: return ag out = _to_affine(_add_mixed((ag[0], ag[1], 1), bp)) return out
# ------------------------------------------------------ the same API -------
[docs]def pubkey(sk_hex: str) -> str: pt = mul_g(crypto._scalar(sk_hex)) assert pt is not None return '%064x' % pt[0]
[docs]def ecdh_x(sk_hex: str, pk_x_hex: str) -> str: pt = lift_x(crypto._x_coord(pk_x_hex)) if pt is None: raise ValueError('counterparty key is not on the curve') res = mul(crypto._scalar(sk_hex), pt) assert res is not None return '%064x' % res[0]
[docs]def schnorr_sign(msg32: bytes, sk_hex: str, aux: bytes = b'\x00' * 32) -> str: d0 = crypto._scalar(sk_hex) pt = mul_g(d0) assert pt is not None d = d0 if pt[1] % 2 == 0 else N - d0 px = pt[0].to_bytes(32, 'big') t = (d ^ int.from_bytes(_tagged('BIP0340/aux', aux), 'big')).to_bytes(32, 'big') k0 = int.from_bytes(_tagged('BIP0340/nonce', t + px + msg32), 'big') % N if k0 == 0: raise ValueError('nonce is zero') r = mul_g(k0) assert r is not None k = k0 if r[1] % 2 == 0 else N - k0 rx = r[0].to_bytes(32, 'big') e = int.from_bytes(_tagged('BIP0340/challenge', rx + px + msg32), 'big') % N return (rx + ((k + e * d) % N).to_bytes(32, 'big')).hex()
ORIGINAL: dict[str, Callable[..., Any]] = {}
[docs]def install() -> Any: """Point fleetmesh_core.crypto's four hot functions at this module.""" targets = [crypto] pkg = sys.modules.get('fleetmesh_core.crypto') if pkg is not None and pkg is not crypto: targets.append(pkg) for mod in targets: for name in ('pubkey', 'ecdh_x', 'schnorr_sign', 'schnorr_verify', 'point_mul'): ORIGINAL.setdefault(name, getattr(crypto, name)) if name == 'point_mul': setattr(mod, 'point_mul', _point_mul) else: setattr(mod, name, globals()[name]) return crypto
[docs]def uninstall() -> None: """Put the reference's own implementations back.""" targets = [crypto] pkg = sys.modules.get('fleetmesh_core.crypto') if pkg is not None and pkg is not crypto: targets.append(pkg) for mod in targets: for name, fn in ORIGINAL.items(): setattr(mod, name, fn)
[docs]def schnorr_verify(msg32: bytes, pk_x_hex: str, sig_hex: str) -> bool: try: sig = bytes.fromhex(sig_hex) if len(sig) != 64: return False pt = lift_x(crypto._x_coord(pk_x_hex)) if pt is None: return False r = int.from_bytes(sig[:32], 'big') s = int.from_bytes(sig[32:], 'big') if r >= P or s >= N: return False e = int.from_bytes(_tagged('BIP0340/challenge', sig[:32] + pt[0].to_bytes(32, 'big') + msg32), 'big') % N rp = mul_add(s, N - e, pt) return rp is not None and rp[1] % 2 == 0 and rp[0] == r except (ValueError, TypeError): return False