k
202 lines
7.5 KiB
Python
202 lines
7.5 KiB
Python
"""
|
|
Signed-request verification: EIP-191 signature that binds {action, wallet, timestamp, body}.
|
|
|
|
Message format (human-readable — what the user sees in MetaMask):
|
|
|
|
TrumpSignal · {ACTION}
|
|
wallet: 0x...
|
|
timestamp: 1713724800000
|
|
body: <sha256_hex_of_canonical_json, or "-" for empty>
|
|
|
|
Server verifies:
|
|
1. recovered signer == wallet
|
|
2. |now - timestamp| <= MAX_SKEW_SECONDS (5 min)
|
|
3. sha256(canonical_json(body)) matches the hash in the message
|
|
4. signature not seen before (replay cache, TTL = MAX_SKEW)
|
|
|
|
Same scheme is used for writes (with body) and reads (body=None → "-").
|
|
"""
|
|
import hashlib
|
|
import json
|
|
import logging
|
|
import time
|
|
from typing import Any, Optional
|
|
|
|
from eth_account import Account
|
|
from eth_account.messages import encode_defunct
|
|
from fastapi import HTTPException
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
MAX_SKEW_SECONDS = 300 # 5 minutes
|
|
|
|
|
|
def canonical_body_hash(body: Optional[Any]) -> str:
|
|
"""Stable sha256 of a Python dict/primitive. `None` → '-'."""
|
|
if body is None:
|
|
return "-"
|
|
payload = json.dumps(body, sort_keys=True, separators=(",", ":"), default=str)
|
|
return hashlib.sha256(payload.encode("utf-8")).hexdigest()
|
|
|
|
|
|
def build_message(action: str, wallet: str, timestamp_ms: int, body_hash: str) -> str:
|
|
return (
|
|
f"TrumpSignal · {action}\n"
|
|
f"wallet: {wallet.lower()}\n"
|
|
f"timestamp: {timestamp_ms}\n"
|
|
f"body: {body_hash}"
|
|
)
|
|
|
|
|
|
# ── Replay cache ──────────────────────────────────────────────────────────
|
|
# In-memory; fine for a single-process deploy. For multi-worker, move to Redis.
|
|
_seen: dict[str, float] = {} # sha256(signature) → expiry epoch seconds
|
|
|
|
# Purge when the dict exceeds this size. At 5 minutes TTL and ~10 req/s peak
|
|
# that's ~3000 entries at saturation; 1000 gives comfortable headroom while
|
|
# keeping purge cost tiny (<1 ms for 1000-entry linear scan).
|
|
_SEEN_PURGE_THRESHOLD = 1000
|
|
|
|
|
|
def _cache_put(sig: str, ttl: float) -> bool:
|
|
"""Return True if sig was new, False if replay."""
|
|
now = time.time()
|
|
# Lazy purge: only scan when we've crossed the threshold, not every call.
|
|
# Scanning 1000 vs 5000 entries keeps individual request latency negligible
|
|
# even under burst traffic.
|
|
if len(_seen) >= _SEEN_PURGE_THRESHOLD:
|
|
expired = [k for k, v in _seen.items() if v < now]
|
|
for k in expired:
|
|
del _seen[k]
|
|
key = hashlib.sha256(sig.encode("utf-8")).hexdigest()
|
|
if key in _seen and _seen[key] > now:
|
|
return False
|
|
_seen[key] = now + ttl
|
|
return True
|
|
|
|
|
|
# ── Public API ────────────────────────────────────────────────────────────
|
|
def verify_signed_request(
|
|
*,
|
|
action: str,
|
|
wallet: str,
|
|
timestamp_ms: int,
|
|
signature: str,
|
|
body: Optional[Any],
|
|
allow_replay: bool = False,
|
|
) -> None:
|
|
"""Raise HTTPException(401/422) if invalid. Silent on success.
|
|
|
|
allow_replay=True skips the nonce cache — use only for idempotent reads
|
|
(e.g. GET /user). Timestamp expiry still bounds the window to MAX_SKEW.
|
|
"""
|
|
wallet = wallet.lower().strip()
|
|
|
|
# 1. Freshness
|
|
now_ms = int(time.time() * 1000)
|
|
if timestamp_ms > now_ms + 30_000 or now_ms - timestamp_ms > MAX_SKEW_SECONDS * 1000: # allow 30s future drift for clock skew
|
|
raise HTTPException(401, "Signed request expired or clock skew too large")
|
|
|
|
# 2. Recover signer
|
|
body_hash = canonical_body_hash(body)
|
|
message = build_message(action, wallet, timestamp_ms, body_hash)
|
|
try:
|
|
recovered = Account.recover_message(encode_defunct(text=message), signature=signature).lower()
|
|
except Exception as exc:
|
|
logger.warning("Signature recovery failed (%s): %s", action, exc)
|
|
raise HTTPException(401, "Signature verification failed")
|
|
if recovered != wallet:
|
|
raise HTTPException(401, "Signature does not match wallet")
|
|
|
|
# 3. Replay guard (writes only)
|
|
if not allow_replay:
|
|
if not _cache_put(signature, ttl=MAX_SKEW_SECONDS):
|
|
raise HTTPException(401, "Signature already used (replay blocked)")
|
|
|
|
|
|
def verify_signed_request_any(
|
|
*,
|
|
actions: list[str],
|
|
wallet: str,
|
|
timestamp_ms: int,
|
|
signature: str,
|
|
body: Optional[Any],
|
|
allow_replay: bool = False,
|
|
) -> None:
|
|
"""Accept any one of several signed read-actions.
|
|
|
|
Useful for wallet-owned read endpoints where the frontend may already hold
|
|
a fresh cached envelope for a sibling read action such as `view_user`.
|
|
"""
|
|
last_exc: Optional[HTTPException] = None
|
|
for action in actions:
|
|
try:
|
|
verify_signed_request(
|
|
action=action,
|
|
wallet=wallet,
|
|
timestamp_ms=timestamp_ms,
|
|
signature=signature,
|
|
body=body,
|
|
allow_replay=allow_replay,
|
|
)
|
|
return
|
|
except HTTPException as exc:
|
|
last_exc = exc
|
|
if last_exc is not None:
|
|
raise last_exc
|
|
|
|
|
|
# ── Signed-read credential extraction (C3) ────────────────────────────────
|
|
# Read endpoints historically took the signature as `?ts=&sig=` query params,
|
|
# which leaks signatures into access logs / proxies / browser history. The
|
|
# canonical transport is now the X-Sig-Ts / X-Sig-Sig HEADERS; the query
|
|
# params are kept as a deprecated fallback so older clients keep working.
|
|
from dataclasses import dataclass
|
|
|
|
from fastapi import Header, Query
|
|
|
|
|
|
@dataclass
|
|
class SignedReadCreds:
|
|
ts: int
|
|
sig: str
|
|
|
|
|
|
def signed_read_creds(
|
|
ts: Optional[int] = Query(default=None, deprecated=True,
|
|
description="DEPRECATED — use X-Sig-Ts header"),
|
|
sig: Optional[str] = Query(default=None, deprecated=True,
|
|
description="DEPRECATED — use X-Sig-Sig header"),
|
|
x_sig_ts: Optional[int] = Header(default=None, alias="X-Sig-Ts",
|
|
description="Signed timestamp (ms)"),
|
|
x_sig_sig: Optional[str] = Header(default=None, alias="X-Sig-Sig",
|
|
description="EIP-191 signature"),
|
|
) -> SignedReadCreds:
|
|
"""FastAPI dependency: required signed-read credentials.
|
|
|
|
Headers win over query params when both are present."""
|
|
t = x_sig_ts if x_sig_ts is not None else ts
|
|
s = x_sig_sig if x_sig_sig else sig
|
|
if t is None or not s:
|
|
raise HTTPException(
|
|
422, "Missing signed-read credentials (X-Sig-Ts / X-Sig-Sig headers)")
|
|
return SignedReadCreds(ts=t, sig=s)
|
|
|
|
|
|
def optional_signed_read_creds(
|
|
# Legacy query names used by /telegram/{wallet}/status.
|
|
timestamp: Optional[int] = Query(default=None, deprecated=True,
|
|
description="DEPRECATED — use X-Sig-Ts header"),
|
|
signature: Optional[str] = Query(default=None, deprecated=True,
|
|
description="DEPRECATED — use X-Sig-Sig header"),
|
|
x_sig_ts: Optional[int] = Header(default=None, alias="X-Sig-Ts"),
|
|
x_sig_sig: Optional[str] = Header(default=None, alias="X-Sig-Sig"),
|
|
) -> Optional[SignedReadCreds]:
|
|
"""Like signed_read_creds but returns None when absent — for endpoints
|
|
that serve a redacted response to unauthenticated callers."""
|
|
t = x_sig_ts if x_sig_ts is not None else timestamp
|
|
s = x_sig_sig if x_sig_sig else signature
|
|
if t is None or not s:
|
|
return None
|
|
return SignedReadCreds(ts=t, sig=s)
|