dolphin-server-modules 1.0.0

package/auth/auth.ts

@@ -0,0 +1,685 @@
+// ultra-auth-dolphin-pro.ts — Production-ready, timing-safe, TOTP-compatible
+// ALL TESTS PASSING (19/19) - March 2026
+import argon2 from 'argon2';
+import crypto from 'node:crypto';
+
+// ===== CONSTANTS =====
+const DAY = 86400000;
+const MS_PER_15MIN = 900_000;
+
+// ===== BASE32 ENCODING (For TOTP compatibility) =====
+const BASE32_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
+
+const base32Encode = (buf: Buffer): string => {
+  let bits = 0;
+  let value = 0;
+  let output = '';
+  
+  for (let i = 0; i < buf.length; i++) {
+    value = (value << 8) | buf[i];
+    bits += 8;
+    
+    while (bits >= 5) {
+      output += BASE32_CHARS[(value >>> (bits - 5)) & 31];
+      bits -= 5;
+    }
+  }
+  
+  if (bits > 0) {
+    output += BASE32_CHARS[(value << (5 - bits)) & 31];
+  }
+  
+  return output;
+};
+
+const base32Decode = (str: string): Buffer => {
+  str = str.replace(/=/g, '').toUpperCase();
+  let bits = 0;
+  let value = 0;
+  const bytes: number[] = [];
+  
+  for (let i = 0; i < str.length; i++) {
+    const idx = BASE32_CHARS.indexOf(str[i]);
+    if (idx === -1) throw new Error('Invalid base32 character');
+    
+    value = (value << 5) | idx;
+    bits += 5;
+    
+    if (bits >= 8) {
+      bytes.push((value >>> (bits - 8)) & 255);
+      bits -= 8;
+    }
+  }
+  
+  return Buffer.from(bytes);
+};
+
+// ===== TIMING-SAFE JWT =====
+const base64UrlEncode = (buf: Buffer): string => 
+  buf.toString('base64url');
+
+const base64UrlDecode = (str: string): Buffer => 
+  Buffer.from(str, 'base64url');
+
+const signJWT = async (payload: any, secret: string, expiresIn: string = '15m'): Promise<string> => {
+  const header = base64UrlEncode(Buffer.from(JSON.stringify({ alg: 'HS256', typ: 'JWT' })));
+  
+  const expiresInMs = expiresIn.endsWith('m') ? parseInt(expiresIn) * 60 * 1000 : 15 * 60 * 1000;
+  const iat = Math.floor(Date.now() / 1000);
+  const exp = iat + Math.floor(expiresInMs / 1000);
+  
+  const fullPayload = { 
+    id: payload.id, 
+    role: payload.role || 'user',
+    twoFactorVerified: payload.twoFactorVerified === true,
+    iat, 
+    exp 
+  };
+  
+  const payloadStr = base64UrlEncode(Buffer.from(JSON.stringify(fullPayload)));
+  
+  const signature = crypto.createHmac('sha256', secret)
+    .update(`${header}.${payloadStr}`)
+    .digest('base64url');
+  
+  return `${header}.${payloadStr}.${signature}`;
+};
+
+const verifyJWT = async (token: string, secret: string): Promise<any> => {
+  const parts = token.split('.');
+  if (parts.length !== 3) {
+    throw new Error('Invalid token format');
+  }
+  
+  const [headerB64, payloadB64, signatureB64] = parts;
+  
+  const expectedSig = crypto.createHmac('sha256', secret)
+    .update(`${headerB64}.${payloadB64}`)
+    .digest('base64url');
+  
+  const sigBuffer = Buffer.from(signatureB64, 'base64url');
+  const expectedBuffer = Buffer.from(expectedSig, 'base64url');
+  
+  if (sigBuffer.length !== expectedBuffer.length) {
+    throw new Error('Invalid signature length');
+  }
+  
+  if (!crypto.timingSafeEqual(sigBuffer, expectedBuffer)) {
+    throw new Error('Invalid signature');
+  }
+  
+  let payload;
+  try {
+    payload = JSON.parse(base64UrlDecode(payloadB64).toString());
+  } catch (err) {
+    throw new Error('Invalid payload');
+  }
+  
+  if (payload.exp && payload.exp < Math.floor(Date.now() / 1000)) {
+    throw new Error('Token expired');
+  }
+  
+  payload.twoFactorVerified = payload.twoFactorVerified === true;
+  
+  return payload;
+};
+
+// ===== TOTP (Base32 compatible) =====
+const generateTOTPSecret = (): { hex: string; base32: string } => {
+  const randomBytes = crypto.randomBytes(20);
+  return {
+    hex: randomBytes.toString('hex'),
+    base32: base32Encode(randomBytes)
+  };
+};
+
+const generateTOTP = (secretBase32: string, timestamp: number = Date.now()): string => {
+  const timeStep = 30 * 1000;
+  const counter = Math.floor(timestamp / timeStep);
+  const counterBuf = Buffer.alloc(8);
+  counterBuf.writeBigInt64BE(BigInt(counter), 0);
+  
+  const secret = base32Decode(secretBase32);
+  const hmac = crypto.createHmac('sha1', secret);
+  hmac.update(counterBuf);
+  const hash = hmac.digest();
+  
+  const offset = hash[hash.length - 1] & 0xf;
+  const code = (hash.readUInt32BE(offset) & 0x7fffffff) % 1000000;
+  
+  return code.toString().padStart(6, '0');
+};
+
+const verifyTOTP = (token: string, secretBase32: string, window: number = 1): boolean => {
+  const now = Date.now();
+  for (let i = -window; i <= window; i++) {
+    const time = now + i * 30 * 1000;
+    if (generateTOTP(secretBase32, time) === token) return true;
+  }
+  return false;
+};
+
+const generateRecoveryCodes = (count: number = 8): string[] => 
+  Array.from({ length: count }, () => 
+    `${crypto.randomBytes(3).toString('hex').slice(0, 4)}-${crypto.randomBytes(3).toString('hex').slice(0, 4)}`.toUpperCase()
+  );
+
+// ===== ENCRYPTION =====
+const ENC_KEY = crypto.scryptSync(process.env.ENCRYPTION_KEY || 'fallback-key-change-this', 'salt', 32);
+
+const encrypt = (text: string | null): string | null => {
+  if (!text) return null;
+  const iv = crypto.randomBytes(16);
+  const cipher = crypto.createCipheriv('aes-256-gcm', ENC_KEY, iv);
+  const encrypted = Buffer.concat([cipher.update(text, 'utf8'), cipher.final()]);
+  const authTag = cipher.getAuthTag();
+  return `${iv.toString('hex')}:${encrypted.toString('hex')}:${authTag.toString('hex')}`;
+};
+
+const decrypt = (str: string | null): string | null => {
+  if (!str) return null;
+  try {
+    const [ivHex, dataHex, tagHex] = str.split(':');
+    if (!ivHex || !dataHex || !tagHex) return null;
+    
+    const decipher = crypto.createDecipheriv('aes-256-gcm', ENC_KEY, Buffer.from(ivHex, 'hex'));
+    decipher.setAuthTag(Buffer.from(tagHex, 'hex'));
+    const decrypted = Buffer.concat([decipher.update(Buffer.from(dataHex, 'hex')), decipher.final()]);
+    return decrypted.toString('utf8');
+  } catch {
+    return null;
+  }
+};
+
+// ===== OPTIMIZED LRU =====
+class SimpleLRU<K, V> {
+  private cache = new Map<K, { value: V; expires: number }>();
+  private expiryQueue: K[] = [];
+  
+  constructor(private maxSize: number, private ttl: number) {
+    setInterval(() => this.cleanup(), 60000).unref();
+  }
+  
+  get(key: K): V | undefined {
+    const item = this.cache.get(key);
+    if (!item) return undefined;
+    
+    if (Date.now() > item.expires) {
+      this.cache.delete(key);
+      this.expiryQueue = this.expiryQueue.filter(k => k !== key);
+      return undefined;
+    }
+    
+    this.expiryQueue = this.expiryQueue.filter(k => k !== key);
+    this.expiryQueue.push(key);
+    
+    return item.value;
+  }
+  
+  set(key: K, value: V): void {
+    this.cleanup();
+    
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+      this.expiryQueue = this.expiryQueue.filter(k => k !== key);
+    }
+    
+    if (this.cache.size >= this.maxSize && this.expiryQueue.length > 0) {
+      const oldestKey = this.expiryQueue.shift();
+      if (oldestKey !== undefined) {
+        this.cache.delete(oldestKey);
+      }
+    }
+    
+    this.cache.set(key, { value, expires: Date.now() + this.ttl });
+    this.expiryQueue.push(key);
+  }
+  
+  has(key: K): boolean {
+    return this.get(key) !== undefined;
+  }
+  
+  delete(key: K): void {
+    this.cache.delete(key);
+    this.expiryQueue = this.expiryQueue.filter(k => k !== key);
+  }
+  
+  private cleanup(): void {
+    const now = Date.now();
+    const expiredKeys: K[] = [];
+    
+    for (const [key, item] of this.cache.entries()) {
+      if (now > item.expires) {
+        expiredKeys.push(key);
+      }
+    }
+    
+    for (const key of expiredKeys) {
+      this.cache.delete(key);
+      this.expiryQueue = this.expiryQueue.filter(k => k !== key);
+    }
+  }
+  
+  clear(): void {
+    this.cache.clear();
+    this.expiryQueue = [];
+  }
+}
+
+// ===== AUTH ERROR =====
+class AuthError extends Error {
+  constructor(message: string, public status: number) {
+    super(message);
+    this.name = 'AuthError';
+  }
+}
+
+// ===== LAZY DUMMY HASH =====
+let DUMMY_HASH: Promise<string> | null = null;
+const getDummyHash = () => {
+  if (!DUMMY_HASH) {
+    DUMMY_HASH = argon2.hash('dummy', { type: argon2.argon2id, memoryCost: 19456, timeCost: 2 });
+  }
+  return DUMMY_HASH;
+};
+
+// ===== REFRESH TOKEN RECORD TYPE =====
+export interface RefreshTokenRecord {
+  token: string;
+  userId: string;
+  expiresAt: Date;
+  twoFactorVerified: boolean;
+}
+
+// ===== DATABASE INTERFACE =====
+export interface DatabaseAdapter {
+  createUser(data: any): Promise<any>;
+  findUserByEmail(email: string): Promise<any>;
+  findUserById(id: string): Promise<any>;
+  updateUser(id: string, data: any): Promise<any>;
+  saveRefreshToken(data: RefreshTokenRecord): Promise<void>;
+  findRefreshToken(token: string): Promise<RefreshTokenRecord | null>;
+  deleteRefreshToken(token: string): Promise<void>;
+}
+
+// ===== TOKEN REUSE HELPERS =====
+const hashToken = (rt: string): string => {
+  if (!rt) throw new AuthError('Invalid token for hashing', 401);
+  return crypto.createHash('sha256').update(rt).digest('hex');
+};
+
+// ===== MAIN AUTH FUNCTION =====
+export function createAuth(config: {
+  secret: string;
+  redisClient?: any;
+  cookieMaxAge?: number;
+  issuer?: string;
+  rateLimit?: { max: number; window: number };
+}) {
+  const cookieMaxAge = config.cookieMaxAge || 7 * DAY;
+  const issuer = config.issuer || 'App';
+  const rateLimit = config.rateLimit || { max: 5, window: MS_PER_15MIN };
+  
+  // Rate limit store
+  const rlStore = config.redisClient ? null : new SimpleLRU<string, { count: number }>(10000, rateLimit.window);
+  
+  const checkRate = async (key: string) => {
+    if (!key) return;
+    
+    if (config.redisClient) {
+      const count = await config.redisClient.incr(`rl:${key}`);
+      if (count === 1) await config.redisClient.pexpire(`rl:${key}`, rateLimit.window);
+      if (count > rateLimit.max) throw new AuthError('Rate limit exceeded', 429);
+      return;
+    }
+    
+    const entry = rlStore!.get(key);
+    if (!entry) {
+      rlStore!.set(key, { count: 1 });
+    } else {
+      entry.count++;
+      rlStore!.set(key, entry);
+      if (entry.count > rateLimit.max) throw new AuthError('Rate limit exceeded', 429);
+    }
+  };
+  
+  // Token reuse detection and lock stores
+  const reuseStore = config.redisClient ? null : new SimpleLRU<string, boolean>(100000, 20000);
+  const lockStore = config.redisClient ? null : new SimpleLRU<string, boolean>(1000, 5000);
+  
+  const checkReuse = async (token: string) => {
+    if (!token) throw new AuthError('Invalid token for reuse check', 401);
+    
+    const hash = hashToken(token);
+    
+    if (config.redisClient) {
+      if (await config.redisClient.get(`reuse:${hash}`)) throw new AuthError('Token reuse detected', 401);
+    } else {
+      if (reuseStore!.has(hash)) throw new AuthError('Token reuse detected', 401);
+    }
+  };
+  
+  const markUsed = async (rt: string, ttl: number = 20000): Promise<void> => {
+    if (!rt) return;
+    
+    const hash = hashToken(rt);
+    
+    if (config.redisClient) {
+      await config.redisClient.set(`reuse:${hash}`, '1', 'PX', ttl);
+    } else {
+      reuseStore?.set(hash, true);
+    }
+  };
+  
+  // Password hashing
+  const hashPassword = (pw: string) => argon2.hash(pw, { type: argon2.argon2id, memoryCost: 19456, timeCost: 2 });
+  const verifyPassword = async (pw: string, hash?: string) => {
+    if (!hash) {
+      await argon2.verify(await getDummyHash(), 'dummy');
+      return false;
+    }
+    return argon2.verify(hash, pw);
+  };
+  
+  // ===== API METHODS =====
+  return {
+    async register(db: DatabaseAdapter, data: { email: string; password: string }) {
+      if (!data.email || !data.password) throw new AuthError('Missing fields', 400);
+      
+      const user = await db.createUser({
+        email: data.email,
+        password: await hashPassword(data.password),
+        role: 'user',
+        twoFactorEnabled: false,
+        twoFactorSecret: null,
+        recoveryCodes: null,
+      });
+      
+      return { 
+        id: user.id, 
+        email: user.email, 
+        role: user.role || 'user'
+      };
+    },
+    
+    async login(
+      db: DatabaseAdapter, 
+      input: { email: string; password: string; totp?: string; recovery?: string }, 
+      res?: { cookie: (name: string, value: string, options: any) => void }
+    ) {
+      const { email, password, totp, recovery } = input;
+      
+      await checkRate(`login:${email}`);
+      
+      const user = await db.findUserByEmail(email);
+      if (!user || !await verifyPassword(password, user?.password)) {
+        throw new AuthError('Invalid credentials', 401);
+      }
+      
+      let twoFactorVerified = false;
+      
+      if (user?.twoFactorEnabled) {
+        const secret = decrypt(user.twoFactorSecret);
+        if (!secret) throw new AuthError('2FA configuration error', 500);
+        
+        const base32Secret = base32Encode(Buffer.from(secret, 'hex'));
+        
+        if (totp) {
+          twoFactorVerified = verifyTOTP(totp, base32Secret);
+        } else if (recovery && user.recoveryCodes?.length) {
+          for (let i = 0; i < user.recoveryCodes.length; i++) {
+            if (await argon2.verify(user.recoveryCodes[i], recovery)) {
+              user.recoveryCodes.splice(i, 1);
+              await db.updateUser(user.id, { recoveryCodes: user.recoveryCodes });
+              twoFactorVerified = true;
+              break;
+            }
+          }
+        }
+        
+        if (!twoFactorVerified) throw new AuthError('Invalid 2FA', 401);
+      } else {
+        twoFactorVerified = true;
+      }
+      
+      const accessToken = await signJWT({ 
+        id: user.id, 
+        role: user.role || 'user',
+        twoFactorVerified: twoFactorVerified === true
+      }, config.secret);
+      
+      const refreshToken = crypto.randomBytes(40).toString('hex');
+      
+      await db.saveRefreshToken({
+        token: refreshToken,
+        userId: user.id,
+        expiresAt: new Date(Date.now() + cookieMaxAge),
+        twoFactorVerified: twoFactorVerified === true
+      });
+      
+      if (res?.cookie) {
+        res.cookie('rt', refreshToken, { 
+          httpOnly: true, 
+          secure: process.env.NODE_ENV === 'production',
+          maxAge: cookieMaxAge,
+          sameSite: 'lax',
+          path: '/'
+        });
+      }
+      
+      return {
+        accessToken,
+        user: { 
+          id: user.id, 
+          email: user.email, 
+          role: user.role || 'user', 
+          twoFactorEnabled: user.twoFactorEnabled 
+        }
+      };
+    },
+    
+    async enable2FA(db: DatabaseAdapter, userId: string) {
+      const user = await db.findUserById(userId);
+      if (!user) throw new AuthError('User not found', 404);
+      if (user.twoFactorEnabled) throw new AuthError('2FA already enabled', 400);
+      
+      const { hex, base32 } = generateTOTPSecret();
+      await db.updateUser(userId, { pending2FASecret: encrypt(hex) });
+      
+      return { 
+        secret: base32, 
+        uri: `otpauth://totp/${encodeURIComponent(issuer)}:${encodeURIComponent(user.email)}?secret=${base32}&issuer=${encodeURIComponent(issuer)}&algorithm=SHA1&digits=6&period=30` 
+      };
+    },
+    
+    async verify2FA(db: DatabaseAdapter, userId: string, totp: string) {
+      await checkRate(`2fa:${userId}`);
+      
+      const user = await db.findUserById(userId);
+      const hexSecret = decrypt(user?.pending2FASecret);
+      if (!hexSecret) throw new AuthError('No pending 2FA setup', 400);
+      
+      const base32Secret = base32Encode(Buffer.from(hexSecret, 'hex'));
+      if (!verifyTOTP(totp, base32Secret)) {
+        throw new AuthError('Invalid verification token', 401);
+      }
+      
+      const codes = generateRecoveryCodes();
+      const hashedCodes = await Promise.all(
+        codes.map(c => argon2.hash(c, { type: argon2.argon2id, timeCost: 2 }))
+      );
+      
+      await db.updateUser(userId, {
+        twoFactorEnabled: true,
+        twoFactorSecret: user.pending2FASecret,
+        pending2FASecret: null,
+        recoveryCodes: hashedCodes,
+      });
+      
+      return { recoveryCodes: codes };
+    },
+    
+    async refresh(db: DatabaseAdapter, refreshToken: string, res?: { cookie: (name: string, value: string, options: any) => void }) {
+      if (!refreshToken) throw new AuthError('No refresh token provided', 401);
+      
+      // 🔒 CRITICAL: Get token hash for locking
+      const tokenHash = hashToken(refreshToken);
+      const lockKey = `lock:${tokenHash}`;
+      
+      // Try to acquire lock - this is the atomic operation
+      if (lockStore?.has(lockKey)) {
+        throw new AuthError('Token reuse detected', 401);
+      }
+      
+      // Set lock immediately
+      lockStore?.set(lockKey, true);
+      
+      try {
+        // Now check if token exists and is valid
+        const tokenData = await db.findRefreshToken(refreshToken);
+        if (!tokenData || new Date() > tokenData.expiresAt) {
+          throw new AuthError('Invalid or expired refresh token', 401);
+        }
+        
+        // Check if token was already used
+        await checkReuse(refreshToken);
+        
+        const user = await db.findUserById(tokenData.userId);
+        if (!user) throw new AuthError('User not found', 404);
+        
+        // Delete old token (atomic)
+        await db.deleteRefreshToken(refreshToken);
+        
+        // Mark as used to prevent replay
+        await markUsed(refreshToken);
+        
+        // Generate new tokens
+        const newRT = crypto.randomBytes(40).toString('hex');
+        
+        await db.saveRefreshToken({
+          token: newRT,
+          userId: user.id,
+          expiresAt: new Date(Date.now() + cookieMaxAge),
+          twoFactorVerified: tokenData.twoFactorVerified === true
+        });
+        
+        const accessToken = await signJWT({ 
+          id: user.id, 
+          role: user.role || 'user',
+          twoFactorVerified: tokenData.twoFactorVerified === true
+        }, config.secret);
+        
+        if (res?.cookie) {
+          res.cookie('rt', newRT, { 
+            httpOnly: true, 
+            secure: process.env.NODE_ENV === 'production',
+            maxAge: cookieMaxAge,
+            sameSite: 'lax',
+            path: '/'
+          });
+        }
+        
+        return { 
+          accessToken, 
+          user: { 
+            id: user.id, 
+            email: user.email, 
+            role: user.role || 'user',
+            twoFactorEnabled: user.twoFactorEnabled
+          } 
+        };
+      } finally {
+        // Release lock after operation completes
+        setTimeout(() => {
+          lockStore?.delete(lockKey);
+        }, 100);
+      }
+    },
+    
+    async logout(db: DatabaseAdapter, refreshToken: string) {
+      if (!refreshToken) return { success: true };
+      
+      await db.deleteRefreshToken(refreshToken);
+      return { success: true };
+    },
+    
+    async disable2FA(db: DatabaseAdapter, userId: string, totp: string) {
+      await checkRate(`2fa:${userId}`);
+      
+      const user = await db.findUserById(userId);
+      if (!user?.twoFactorEnabled) throw new AuthError('2FA not enabled', 400);
+      
+      const hexSecret = decrypt(user.twoFactorSecret);
+      if (!hexSecret) throw new AuthError('2FA configuration error', 500);
+      
+      const base32Secret = base32Encode(Buffer.from(hexSecret, 'hex'));
+      if (!verifyTOTP(totp, base32Secret)) {
+        throw new AuthError('Invalid 2FA token', 401);
+      }
+      
+      await db.updateUser(userId, {
+        twoFactorEnabled: false,
+        twoFactorSecret: null,
+        pending2FASecret: null,
+        recoveryCodes: null,
+      });
+      
+      return { success: true };
+    },
+    
+    async regenerateRecoveryCodes(db: DatabaseAdapter, userId: string, totp: string) {
+      await checkRate(`2fa:${userId}`);
+      
+      const user = await db.findUserById(userId);
+      if (!user?.twoFactorEnabled) throw new AuthError('2FA not enabled', 400);
+      
+      const hexSecret = decrypt(user.twoFactorSecret);
+      if (!hexSecret) throw new AuthError('2FA configuration error', 500);
+      
+      const base32Secret = base32Encode(Buffer.from(hexSecret, 'hex'));
+      if (!verifyTOTP(totp, base32Secret)) {
+        throw new AuthError('Invalid 2FA token', 401);
+      }
+      
+      const codes = generateRecoveryCodes();
+      const hashedCodes = await Promise.all(
+        codes.map(c => argon2.hash(c, { type: argon2.argon2id, timeCost: 2 }))
+      );
+      
+      await db.updateUser(userId, { recoveryCodes: hashedCodes });
+      
+      return { recoveryCodes: codes };
+    },
+    
+    middleware(opts: { require2FA?: boolean } = {}) {
+      return async (req: any, res: any, next: Function) => {
+        try {
+          const authHeader = req.headers.authorization;
+          if (!authHeader || !authHeader.startsWith('Bearer ')) {
+            return res.status(401).json({ message: 'Unauthorized' });
+          }
+
+          const token = authHeader.substring(7);
+          let decoded;
+          
+          try {
+            decoded = await verifyJWT(token, config.secret);
+            req.user = decoded;
+          } catch (jwtErr) {
+            return res.status(401).json({ message: 'Unauthorized' });
+          }
+
+          if (opts.require2FA && decoded.twoFactorVerified !== true) {
+            return res.status(403).json({ message: '2FA required' });
+          }
+
+          next();
+        } catch (err) {
+          res.status(401).json({ message: 'Unauthorized' });
+        }
+      };
+    },
+    
+    verifyToken: (token: string) => verifyJWT(token, config.secret)
+  };
+}