الـ Passkeys و WebAuthn: login من غير password وضد الـ phishing

import { browser } from "./browser.js";
import { createAuthenticator } from "./authenticator.js";
const log = (s, ...x) => console.log(s.padEnd(40), ...x);
const tryIt = async (fn) => { try { return await fn(); } catch (e) { return e.message; } };

const phone = createAuthenticator("موبايل مُنى");
const mona = browser();
await mona.register(phone, "mona");
const first = await mona.login(phone, "mona");
log("مُنى login عادي:", first.status, first.body);

// 1) replay: المهاجم شاف الـ response بتاع مُنى (log أو proxy) وبعته تاني
const thief = browser();
const replay = await thief.send("/login/verify", { username: "mona", response: first.response });
log("1) replay لنفس الـ response:", replay.status, replay.body);

// 2) عمر عنده passkey على حسابه هو، وبيقول إنه mona
const laptop = createAuthenticator("لابتوب عمر");
const omar = browser();
await omar.register(laptop, "omar");
const opts = (await omar.send("/login/options", { username: "mona" })).body;
const omarSig = await laptop.get({ ...opts, allowCredentials: [] }, "http://localhost:3000");
const swap = await omar.send("/login/verify", { username: "mona", response: omarSig });
log("2) credential عمر + username mona:", swap.status, swap.body, (await omar.me()).body);

// 3) نسخة من موبايل مُنى (malware نسخ الـ keys)، ومُنى لسه بتستخدم الأصلي
const copy = phone.clone();
for (let i = 0; i < 3; i++) await mona.login(phone, "mona");
const cl = await tryIt(() => browser().login(copy, "mona"));
log("3) النسخة القديمة من الجهاز:", cl.status, cl.body);

// 4) phishing: صفحة مزيّفة على baassma-login.com بتمرّر الـ challenge من الموقع الحقيقي
const evil = browser("https://baassma-login.com");
const real = (await evil.send("/login/options", { username: "mona" })).body;
log("4) الصفحة المزيّفة بـ rpId الحقيقي:", await tryIt(() => phone.get(real, "https://baassma-login.com")));
log("   الصفحة المزيّفة بـ rpId بتاعها:", await tryIt(() => phone.get({ ...real, rpId: "baassma-login.com" }, "https://baassma-login.com")));

$ node --no-warnings server.js & sleep 1; node attack.js; kill $!
API: http://localhost:3000
مُنى login عادي:                         200 { verified: true, user: 'mona' }
1) replay لنفس الـ response:             200 { verified: true, user: 'mona' }
2) credential عمر + username mona:       200 { verified: true, user: 'mona' } { user: 'mona' }
3) النسخة القديمة من الجهاز:             200 { verified: true, user: 'mona' }
4) الصفحة المزيّفة بـ rpId الحقيقي:      SecurityError: baassma-login.com مش مسموحله يطلب rpId=localhost
   الصفحة المزيّفة بـ rpId بتاعها:       NotAllowedError: مفيش passkey لـ baassma-login.com على موبايل مُنى

import express from "express";
import crypto from "node:crypto";
import {
  generateRegistrationOptions,
  verifyRegistrationResponse,
  generateAuthenticationOptions,
  verifyAuthenticationResponse,
} from "@simplewebauthn/server";

const RP_ID = "localhost"; // الـ domain بتاعك. الـ passkey بيتربط بيه للأبد
const ORIGIN = "http://localhost:3000";
const app = express();
app.use(express.json());

const users = new Map(); // username → { webauthnId, credentials: [] }
const credentials = new Map(); // credential id → { id, publicKey, counter, transports, owner }
const sessions = new Map();
const cookie = (req, name) => req.get("cookie")?.match(new RegExp(`(?:^|; )${name}=([^;]+)`))?.[1];
const startSession = (res, username) => {
  const sid = crypto.randomBytes(32).toString("base64url");
  sessions.set(sid, username);
  res.append("Set-Cookie", `sid=${sid}; HttpOnly; Secure; SameSite=Lax; Path=/`);
};
const getUser = (username) => {
  if (!users.has(username)) users.set(username, { webauthnId: crypto.randomBytes(16), credentials: [] });
  return users.get(username);
};
app.get("/me", (req, res) => res.json({ user: sessions.get(cookie(req, "sid")) ?? null }));

// كل ceremony ليها challenge واحد، مربوط بالمتصفح ده بـ cookie، وبيتمسح أول ما يتستخدم
const ceremonies = new Map(); // cid → { type, challenge, username, exp }
const begin = (res, data) => {
  const cid = crypto.randomBytes(16).toString("base64url");
  ceremonies.set(cid, { ...data, exp: Date.now() + 5 * 60_000 });
  res.append("Set-Cookie", `wa=${cid}; HttpOnly; Secure; SameSite=Strict; Path=/`);
};
const take = (req, type) => {
  const cid = cookie(req, "wa");
  const c = ceremonies.get(cid);
  ceremonies.delete(cid);
  return c && c.type === type && Date.now() < c.exp ? c : null;
};

app.post("/register/options", async (req, res) => {
  // في الحقيقة: مستخدم جديد، أو مستخدم عامل login وبيضيف passkey
  const username = String(req.body.username ?? "");
  const user = getUser(username);
  const options = await generateRegistrationOptions({
    rpName: "Baassma",
    rpID: RP_ID,
    userName: username,
    userID: user.webauthnId,
    attestationType: "none",
    excludeCredentials: user.credentials.map((id) => ({ id, transports: credentials.get(id).transports })),
    authenticatorSelection: { residentKey: "required", userVerification: "required" },
  });
  begin(res, { type: "register", challenge: options.challenge, username });
  res.json(options);
});

app.post("/register/verify", async (req, res) => {
  const c = take(req, "register");
  if (!c) return res.status(400).json({ error: "ابدأ من الأول" });
  try {
    const { verified, registrationInfo } = await verifyRegistrationResponse({
      response: req.body.response,
      expectedChallenge: c.challenge,
      expectedOrigin: ORIGIN,
      expectedRPID: RP_ID,
      requireUserVerification: true,
    });
    const cred = registrationInfo?.credential;
    if (!verified || credentials.has(cred.id)) return res.status(400).json({ error:
…

$ node --no-warnings server.js & sleep 1; node attack.js; kill $!
API: http://localhost:3000
مُنى login عادي:                         200 { verified: true, user: 'mona' }
رفضنا: مفيش ceremony أو اتستخدمت (replay)
1) replay لنفس الـ response:             401 { error: 'الدخول فشل' }
2) credential عمر + username mona:       200 { verified: true, user: 'omar' } { user: 'omar' }
رفضنا: Response counter value 2 was lower than expected 4
3) النسخة القديمة من الجهاز:             401 { error: 'الدخول فشل' }
4) الصفحة المزيّفة بـ rpId الحقيقي:      SecurityError: baassma-login.com مش مسموحله يطلب rpId=localhost
   الصفحة المزيّفة بـ rpId بتاعها:       NotAllowedError: مفيش passkey لـ baassma-login.com على موبايل مُنى

// authenticator.js: passkey software، بيعمل اللي الموبايل أو الـ security key بيعمله، بالضبط بنفس الـ formats
import crypto from "node:crypto";

const sha = (b) => crypto.createHash("sha256").update(b).digest();
const u32 = (n) => Buffer.from([(n >>> 24) & 255, (n >> 16) & 255, (n >> 8) & 255, n & 255]);
const head = (major, n) =>
  n < 24 ? [(major << 5) | n] : n < 256 ? [(major << 5) | 24, n] : [(major << 5) | 25, n >> 8, n & 255];
// CBOR صغير: الـ format اللي الـ attestationObject والـ public key مكتوبين بيه
const cbor = (v) => {
  if (typeof v === "number") return Buffer.from(v >= 0 ? head(0, v) : head(1, -1 - v));
  if (typeof v === "string") return Buffer.concat([Buffer.from(head(3, Buffer.byteLength(v))), Buffer.from(v)]);
  if (v instanceof Uint8Array) return Buffer.concat([Buffer.from(head(2, v.length)), v]);
  const entries = v instanceof Map ? [...v] : Object.entries(v);
  return Buffer.concat([Buffer.from(head(5, entries.length)), ...entries.flatMap(([k, x]) => [cbor(k), cbor(x)])]);
};

export function createAuthenticator(name) {
  const creds = []; // { id, rpId, userHandle, privateKey, counter }
  // المتصفح هو اللي بيكتب الـ origin الحقيقي بتاع الصفحة، والموقع ما يقدرش يغيّره
  const scope = (origin, rpId) => {
    const host = new URL(origin).hostname;
    if (host !== rpId && !host.endsWith("." + rpId)) throw new Error(`SecurityError: ${host} مش مسموحله يطلب rpId=${rpId}`);
  };
  return {
    name,
    async create(options, origin) {
      const rpId = options.rp.id;
      scope(origin, rpId);
      if (options.excludeCredentials?.some((c) => creds.some((x) => x.id === c.id)))
        throw new Error("InvalidStateError: الجهاز ده متسجّل قبل كده");
      const { privateKey, publicKey } = crypto.generateKeyPairSync("ec", { namedCurve: "P-256" });
      const { x, y } = publicKey.export({ format: "jwk" });
      const raw = crypto.randomBytes(16);
      const id = raw.toString("base64url");
      creds.push({ id, rpId, userHandle: options.user.id, privateKey, counter: 0 });
      // COSE key: kty=EC2، alg=ES256، crv=P-256، x، y
      const cose = new Map([[1, 2], [3, -7], [-1, 1], [-2, Buffer.from(x, "base64url")], [-3, Buffer.from(y, "base64url")]]);
      const flags = 0x01 | 0x04 | 0x40; // UP (المستخدم موجود) + UV (بصمة/PIN) + AT (فيه credential جديد)
      const authData = Buffer.concat([sha(rpId), Buffer.from([flags]), u32(0), Buffer.alloc(16), Buffer.from([0, raw.length]), raw, cbor(cose)]);
      const clientData = { type: "webauthn.create", challenge: options.challenge, origin, crossOrigin: false };
      return {
        id,
        rawId: id,
        type: "public-key",
        response: {
          clientDataJSON: Buffer.from(JSON.stringify(clientData)).toString("base64url"),
          attestationObject: cbor({ fmt: "none", attStmt: {}, authData }).toString("base64url"),
          transports: ["internal", "hybrid"],
        },
        clientExtensionResults: {},
        authenticatorAttachment: "platform",
      };
 
…

// browser.js: متصفح صغير: cookies + بيوصّل الـ server بالـ authenticator
export const browser = (origin = "http://localhost:3000") => {
  let cookies = {};
  const send = async (path, body) => {
    const r = await fetch("http://localhost:3000" + path, {
      method: body === undefined ? "GET" : "POST",
      headers: { "content-type": "application/json", cookie: Object.entries(cookies).map(([k, v]) => `${k}=${v}`).join("; ") },
      body: body === undefined ? undefined : JSON.stringify(body),
    });
    for (const sc of r.headers.getSetCookie()) {
      const [kv] = sc.split(";");
      const i = kv.indexOf("=");
      cookies[kv.slice(0, i)] = kv.slice(i + 1);
    }
    return { status: r.status, body: await r.json().catch(() => null) };
  };
  return {
    send,
    async register(device, username) {
      const opts = (await send("/register/options", { username })).body;
      const response = await device.create(opts, origin);
      return send("/register/verify", { username, response });
    },
    async login(device, username) {
      const opts = (await send("/login/options", { username })).body;
      const response = await device.get(opts, origin);
      return { ...(await send("/login/verify", { username, response })), response };
    },
    me: () => send("/me"),
  };
};