import os, hmac, hashlib, time
from fastapi import FastAPI, Request, HTTPException

PARTNER_SECRET = os.environ["SHADOWFEED_PARTNER_SECRET"].encode()
_seen_nonces: dict[str, float] = {}    # swap for Redis in production

app = FastAPI()

async def verify_shadowfeed_hmac(request: Request) -> bool:
    ts    = request.headers.get("X-Sf-Timestamp", "")
    nonce = request.headers.get("X-Sf-Nonce", "")
    sig   = request.headers.get("X-Sf-Signature", "")
    if not (ts and nonce and sig):
        return False
    if abs(time.time() - int(ts)) > 300:
        return False

    # Replay protection — sweep + check
    now = time.time()
    expired = [n for n, t in _seen_nonces.items() if now - t > 300]
    for n in expired:
        _seen_nonces.pop(n, None)
    if nonce in _seen_nonces:
        return False
    _seen_nonces[nonce] = now

    body = await request.body() if request.method != "GET" else b""
    body_hash = hashlib.sha256(body).hexdigest() if body else ""
    canonical = "\n".join([
        request.method.upper(),
        request.url.path,
        ts, nonce, body_hash,
    ]).encode()

    expected = hmac.new(PARTNER_SECRET, canonical, hashlib.sha256).hexdigest()
    return hmac.compare_digest(sig.lower(), expected.lower())

@app.middleware("http")
async def shadowfeed_partner_middleware(request: Request, call_next):
    if request.headers.get("X-Sf-Partner") == "shadowfeed":
        if not await verify_shadowfeed_hmac(request):
            raise HTTPException(401, "invalid HMAC signature")
        request.state.skip_x402 = True
    return await call_next(request)

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "io"
    "net/http"
    "os"
    "strconv"
    "strings"
    "sync"
    "time"
)

var (
    partnerSecret = []byte(os.Getenv("SHADOWFEED_PARTNER_SECRET"))
    nonceCache    = sync.Map{} // map[string]int64 — nonce → expiresUnix
)

func abs(n int64) int64 { if n < 0 { return -n }; return n }

func verifyShadowfeedHMAC(r *http.Request) bool {
    tsStr := r.Header.Get("X-Sf-Timestamp")
    nonce := r.Header.Get("X-Sf-Nonce")
    sig   := r.Header.Get("X-Sf-Signature")
    if tsStr == "" || nonce == "" || sig == "" { return false }

    ts, err := strconv.ParseInt(tsStr, 10, 64)
    if err != nil { return false }
    if abs(time.Now().Unix() - ts) > 300 { return false }

    // Replay protection
    if _, seen := nonceCache.Load(nonce); seen { return false }
    nonceCache.Store(nonce, time.Now().Unix() + 300)

    var bodyBytes []byte
    if r.Method != "GET" {
        bodyBytes, _ = io.ReadAll(r.Body)
        r.Body = io.NopCloser(strings.NewReader(string(bodyBytes)))
    }
    bodyHash := ""
    if len(bodyBytes) > 0 {
        h := sha256.Sum256(bodyBytes)
        bodyHash = hex.EncodeToString(h[:])
    }

    canonical := strings.Join([]string{
        strings.ToUpper(r.Method), r.URL.Path,
        tsStr, nonce, bodyHash,
    }, "\n")

    mac := hmac.New(sha256.New, partnerSecret)
    mac.Write([]byte(canonical))
    expected := hex.EncodeToString(mac.Sum(nil))
    return hmac.Equal([]byte(strings.ToLower(sig)), []byte(expected))
}

func shadowfeedMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if r.Header.Get("X-Sf-Partner") == "shadowfeed" {
            if !verifyShadowfeedHMAC(r) {
                http.Error(w, "invalid HMAC signature", 401)
                return
            }
            // Mark context so downstream skips x402 payment requirement.
        }
        next.ServeHTTP(w, r)
    })
}