@antseed/node 0.1.0 → 0.1.1

package/src/p2p/connection-auth.ts

@@ -1,152 +0,0 @@
-import { randomBytes } from 'node:crypto';
-import type { PeerId } from '../types/peer.js';
-import { toPeerId } from '../types/peer.js';
-import { signUtf8Ed25519, verifyUtf8Ed25519 } from './identity.js';
-
-export type InitialWireType = 'intro' | 'hello';
-
-export interface ConnectionAuthEnvelope {
-  peerId: string;
-  ts: number;
-  nonce: string;
-  sig: string;
-}
-
-export interface VerifyConnectionAuthOptions {
-  type: InitialWireType;
-  auth: ConnectionAuthEnvelope | null | undefined;
-  nowMs?: number;
-  maxSkewMs?: number;
-  replayGuard?: NonceReplayGuard;
-}
-
-export interface VerifyConnectionAuthResult {
-  ok: boolean;
-  peerId?: PeerId;
-  reason?: string;
-}
-
-export const INTRO_AUTH_MAX_SKEW_MS = 30_000;
-
-const NONCE_SIZE_BYTES = 16;
-const SIG_HEX_LEN = 128;
-const NONCE_HEX_REGEX = /^[0-9a-f]{32}$/;
-const SIG_HEX_REGEX = /^[0-9a-f]{128}$/;
-
-function buildSigningPayload(
-  type: InitialWireType,
-  peerId: string,
-  ts: number,
-  nonce: string,
-): string {
-  return `${type}|${peerId}|${ts}|${nonce}`;
-}
-
-function buildReplayKey(peerId: PeerId, nonce: string): string {
-  return `${peerId}:${nonce}`;
-}
-
-/**
- * Tracks recently seen nonces to reject replayed intro messages.
- */
-export class NonceReplayGuard {
-  private readonly seen = new Map<string, number>();
-
-  constructor(
-    private readonly ttlMs = INTRO_AUTH_MAX_SKEW_MS * 2,
-    private readonly maxEntries = 20_000,
-  ) {}
-
-  checkAndRemember(peerId: PeerId, nonce: string, nowMs = Date.now()): boolean {
-    this.evictExpired(nowMs);
-    const key = buildReplayKey(peerId, nonce);
-    const existingExpiry = this.seen.get(key);
-    if (existingExpiry && existingExpiry > nowMs) {
-      return false;
-    }
-
-    this.seen.set(key, nowMs + this.ttlMs);
-    if (this.seen.size > this.maxEntries) {
-      const overflow = this.seen.size - this.maxEntries;
-      let removed = 0;
-      for (const oldestKey of this.seen.keys()) {
-        this.seen.delete(oldestKey);
-        removed++;
-        if (removed >= overflow) {
-          break;
-        }
-      }
-    }
-    return true;
-  }
-
-  private evictExpired(nowMs: number): void {
-    for (const [key, expiresAt] of this.seen) {
-      if (expiresAt <= nowMs) {
-        this.seen.delete(key);
-      }
-    }
-  }
-}
-
-export function buildConnectionAuthEnvelope(
-  type: InitialWireType,
-  peerId: PeerId,
-  privateKeySeed: Uint8Array,
-  nowMs = Date.now(),
-): ConnectionAuthEnvelope {
-  const nonce = randomBytes(NONCE_SIZE_BYTES).toString('hex');
-  const payload = buildSigningPayload(type, peerId, nowMs, nonce);
-  const sig = signUtf8Ed25519(privateKeySeed, payload);
-
-  return {
-    peerId,
-    ts: nowMs,
-    nonce,
-    sig,
-  };
-}
-
-export function verifyConnectionAuthEnvelope(
-  options: VerifyConnectionAuthOptions,
-): VerifyConnectionAuthResult {
-  const nowMs = options.nowMs ?? Date.now();
-  const maxSkewMs = options.maxSkewMs ?? INTRO_AUTH_MAX_SKEW_MS;
-  const auth = options.auth;
-  if (!auth || typeof auth !== 'object') {
-    return { ok: false, reason: 'missing auth envelope' };
-  }
-
-  let peerId: PeerId;
-  try {
-    peerId = toPeerId(auth.peerId);
-  } catch {
-    return { ok: false, reason: 'invalid peerId' };
-  }
-
-  if (!Number.isInteger(auth.ts)) {
-    return { ok: false, reason: 'invalid timestamp' };
-  }
-  if (Math.abs(nowMs - auth.ts) > maxSkewMs) {
-    return { ok: false, reason: 'timestamp outside allowed skew' };
-  }
-
-  if (!NONCE_HEX_REGEX.test(auth.nonce)) {
-    return { ok: false, reason: 'invalid nonce format' };
-  }
-  if (!SIG_HEX_REGEX.test(auth.sig) || auth.sig.length !== SIG_HEX_LEN) {
-    return { ok: false, reason: 'invalid signature format' };
-  }
-
-  if (options.replayGuard && !options.replayGuard.checkAndRemember(peerId, auth.nonce, nowMs)) {
-    return { ok: false, reason: 'replayed intro auth nonce' };
-  }
-
-  const payload = buildSigningPayload(options.type, peerId, auth.ts, auth.nonce);
-  const valid = verifyUtf8Ed25519(peerId, payload, auth.sig);
-  if (!valid) {
-    return { ok: false, reason: 'signature verification failed' };
-  }
-
-  return { ok: true, peerId };
-}