الـ MFA والـ recovery: التاني factor اللي بجد

import { agent, login } from "./agent.js";
import { hotp, step } from "./totp.js";
import { SECRET, PASSWORD, RECOVERY } from "./user.js";
const log = (s, ...x) => console.log(s.padEnd(44), ...x);

// المهاجم معاه الـ password من leak، ومعاه أحيانًا code أو recovery code من phishing
// 1) login بالـ password وبعدين على /account على طول
const a = await login(PASSWORD);
log("1) /account من غير MFA:", await a("GET", "/account"));

// 2) تخمين الـ code
const b = await login(PASSWORD);
const valid = new Set([-1, 0, 1].map((w) => hotp(SECRET, step() + w)));
const t0 = Date.now();
const seen = {};
let tries = 0;
for (let i = 0; i < 300; i++) {
  const code = String(100000 + i);
  if (valid.has(code)) continue;
  const s = await b("POST", "/mfa", { code });
  tries++;
  seen[s] = (seen[s] ?? 0) + 1;
  if (s === 429) break;
}
log(`2) ${tries} محاولة غلط، الردود:`, JSON.stringify(seen));
if (!seen[429]) {
  const perTry = (Date.now() - t0) / tries;
  log("   مفيش حد. متوسط وقت كسر الـ MFA:", Math.round(((1e6 / 3 / 2) * perTry) / 60000), "دقيقة");
}

// 3) replay: الـ code اللي مُنى كتبته اتسرق في نفس التلاتين ثانية
const code = hotp(SECRET, step());
const mona = await login(PASSWORD);
log("3) مُنى بالـ code:", await mona("POST", "/mfa", { code }));
const thief = await login(PASSWORD);
log("   المهاجم بنفس الـ code:", await thief("POST", "/mfa", { code }));

// 4) recovery code اتسرق بعد ما مُنى استخدمته
const c = await login(PASSWORD);
log("4) recovery code أول مرة:", await c("POST", "/recovery", { code: RECOVERY[0] }));
const d = await login(PASSWORD);
log("   نفس الـ recovery code تاني:", await d("POST", "/recovery", { code: RECOVERY[0] }));

// 5) يقفل الـ MFA بـ session لسه ما عدّتش الـ MFA
const e = await login(PASSWORD);
log("5) /mfa/disable من غير MFA:", await e("POST", "/mfa/disable"));

$ node server.js & sleep 0.8; node attack.js; kill $!
API: http://localhost:3000
1) /account من غير MFA:                      200
2) 300 محاولة غلط، الردود:                   {"401":300}
   مفيش حد. متوسط وقت كسر الـ MFA:           3 دقيقة
3) مُنى بالـ code:                           200
   المهاجم بنفس الـ code:                    200
4) recovery code أول مرة:                    200
   نفس الـ recovery code تاني:               200
5) /mfa/disable من غير MFA:                  200

import express from "express";
import crypto from "node:crypto";
import { verifyTotp } from "./totp.js";
import { SECRET, PASSWORD, RECOVERY } from "./user.js";

const app = express();
app.use(express.json());
const sessions = new Map();
const newSid = () => crypto.randomBytes(32).toString("base64url");
const sidOf = (req) => req.get("cookie")?.match(/(?:^|; )sid=([^;]+)/)?.[1];
const setSid = (res, sid) => res.set("Set-Cookie", `sid=${sid}; HttpOnly; Secure; SameSite=Lax; Path=/`);
const safeEq = (a, b) => {
  const x = crypto.createHash("sha256").update(String(a)).digest();
  return crypto.timingSafeEqual(x, crypto.createHash("sha256").update(String(b)).digest());
};
// في الحقيقة الـ password بيتخزن argon2 زي درس الـ passwords. هنا مختصرين.
const mona = { id: "mona", password: PASSWORD, totpSecret: SECRET };
const sha = (s) => crypto.createHash("sha256").update(s).digest("hex");
// ✅ hashes بس. الـ codes عشوائية وطويلة، فـ SHA-256 كفاية (مش زي الـ passwords)
mona.recovery = new Set(RECOVERY.map(sha));
mona.lastStep = 0; // آخر step اتقبل، علشان الـ replay
mona.fails = 0;
mona.lockedUntil = 0;
const MAX_FAILS = 5;

app.post("/login", (req, res) => {
  if (req.body.user !== "mona" || !safeEq(req.body.password, mona.password))
    return res.status(401).json({ error: "بيانات غلط" });
  const sid = newSid();
  sessions.set(sid, { user: "mona", stage: "mfa", exp: Date.now() + 5 * 60_000 });
  setSid(res, sid);
  res.json({ next: "mfa" });
});

// الـ session اللي عدّت الـ password بس، ولسه في وقتها
const pendingSid = (req, res) => {
  const sid = sidOf(req);
  const s = sessions.get(sid);
  if (!s || s.stage !== "mfa" || Date.now() > s.exp) {
    res.status(401).json({ error: "ابدأ login من الأول" });
    return null;
  }
  if (Date.now() < mona.lockedUntil) {
    res.status(429).json({ error: "محاولات كتير، استنى ربع ساعة" });
    return null;
  }
  return sid;
};
// العدّاد على المستخدم، مش على الـ session: المهاجم معاه الـ password ويقدر يعمل login تاني
const fail = (res, why) => {
  console.log("رفضنا:", why);
  if (++mona.fails >= MAX_FAILS) {
    mona.lockedUntil = Date.now() + 15 * 60_000;
    console.log("📧 email لمُنى: محاولات MFA غلط كتير، الحساب اتقفل مؤقتًا");
  }
  res.status(401).json({ error: "code غلط" });
};
// نجاح: session جديدة خالص (ضد الـ fixation) بـ stage full
const complete = (res, oldSid) => {
  sessions.delete(oldSid);
  const sid = newSid();
  sessions.set(sid, { user: "mona", stage: "full", authAt: Date.now() });
  mona.fails = 0;
  setSid(res, sid);
  res.json({ ok: true });
};

app.post("/mfa", (req, res) => {
  const sid = pendingSid(req, res);
  if (!sid) return;
  const st = verifyTotp(mona.totpSecret, String(req.body.code ?? ""));
  if (st === null) return fail(res, "totp غلط");
  if (st <= mona.lastStep) return fail(res, "totp اتستخدم قبل كده (replay)");
  mona.lastStep = st;
  complete(res, sid);
});

app.post("/recovery", (req, res) => {
  const sid = pendingSid(req, res);
  if (!sid) return;
  const h = sha(S
…

$ node server.js & sleep 0.8; node attack.js; kill $!
API: http://localhost:3000
1) /account من غير MFA:                      401
رفضنا: totp غلط
رفضنا: totp غلط
رفضنا: totp غلط
رفضنا: totp غلط
رفضنا: totp غلط
📧 email لمُنى: محاولات MFA غلط كتير، الحساب اتقفل مؤقتًا
2) 6 محاولة غلط، الردود:                     {"401":5,"429":1}
3) مُنى بالـ code:                           429
   المهاجم بنفس الـ code:                    429
4) recovery code أول مرة:                    429
   نفس الـ recovery code تاني:               429
5) /mfa/disable من غير MFA:                  401

// totp.js: نفس اللي جُوّه Google Authenticator، بالـ RFC 6238
import crypto from "node:crypto";

const B32 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
const unbase32 = (s) => {
  let bits = "";
  for (const c of s.replace(/=+$/, "")) bits += B32.indexOf(c).toString(2).padStart(5, "0");
  const out = [];
  for (let i = 0; i + 8 <= bits.length; i += 8) out.push(parseInt(bits.slice(i, i + 8), 2));
  return Buffer.from(out);
};
export const newSecret = () => {
  let bits = "";
  for (const b of crypto.randomBytes(20)) bits += b.toString(2).padStart(8, "0");
  return bits.match(/.{5}/g).map((x) => B32[parseInt(x, 2)]).join("");
};
export const otpauthUrl = (secret, account) =>
  `otpauth://totp/Baassma:${account}?secret=${secret}&issuer=Baassma&digits=6&period=30`;

// HOTP: HMAC-SHA1 على رقم الـ counter، وبعدين "dynamic truncation" لستة أرقام
export function hotp(secret, counter) {
  const msg = Buffer.alloc(8);
  msg.writeBigUInt64BE(BigInt(counter));
  const h = crypto.createHmac("sha1", unbase32(secret)).update(msg).digest();
  const off = h[h.length - 1] & 0xf;
  return String((h.readUInt32BE(off) & 0x7fffffff) % 1_000_000).padStart(6, "0");
}
// TOTP = HOTP والـ counter هو الوقت مقسوم على تلاتين ثانية
export const step = (t = Date.now()) => Math.floor(t / 1000 / 30);

// بيرجّع رقم الـ step اللي الـ code ده بتاعه، أو null. window واحد = نسمح بـ step قبل وبعد
export function verifyTotp(secret, code, window = 1, now = Date.now()) {
  if (!secret || typeof code !== "string" || !/^\d{6}$/.test(code)) return null;
  const s = step(now);
  for (let w = -window; w <= window; w++) {
    if (crypto.timingSafeEqual(Buffer.from(code), Buffer.from(hotp(secret, s + w)))) return s + w;
  }
  return null;
}

// user.js: اللي عند مُنى. الـ secret في الـ authenticator app، والـ recovery codes اتطبعولها مرة واحدة يوم التفعيل
export const SECRET = "JBSWY3DPEHPK3PXPJBSWY3DPEHPK3PXP";
export const PASSWORD = "correct horse battery";
export const RECOVERY = ["K7Q2-M9XD-4TRA", "P4TZ-8WRN-V2HE", "C6HV-2JLE-9QSM"];

// agent.js: متصفح صغير بيحفظ الـ cookie
export const agent = () => {
  let cookie = "";
  const send = async (method, path, body) => {
    const r = await fetch("http://localhost:3000" + path, {
      method,
      headers: { cookie, "content-type": "application/json" },
      body: body && JSON.stringify(body),
    });
    const sc = r.headers.get("set-cookie");
    if (sc) cookie = sc.split(";")[0];
    return r.status;
  };
  send.cookie = () => cookie;
  return send;
};
export const login = async (password) => {
  const a = agent();
  await a("POST", "/login", { user: "mona", password });
  return a;
};

import { login } from "./agent.js";
import { hotp, step } from "./totp.js";
import { SECRET, PASSWORD, RECOVERY } from "./user.js";
let ok = 0, all = 0;
const check = (name, cond, extra = "") => { all++; if (cond) ok++; console.log(cond ? "✅" : "❌", name, extra); };

// test vector من الـ RFC 6238: secret "12345678901234567890"، الوقت تسعة وخمسين ثانية
check("totp.js مطابق للـ RFC", hotp("GEZDGNBVGY3TQOJQGEZDGNBVGY3TQOJQ", 1) === "287082");

const a = await login(PASSWORD);
check("/account بعد الـ password بس ← 401", (await a("GET", "/account")) === 401);
const before = a.cookie();
const code = hotp(SECRET, step());
check("/mfa بالـ code الصح ← 200", (await a("POST", "/mfa", { code })) === 200);
check("الـ sid اتغيّر بعد الـ MFA", a.cookie() !== before);
check("/account بعد الـ MFA ← 200", (await a("GET", "/account")) === 200);

const b = await login(PASSWORD);
check("نفس الـ code في session تانية ← 401", (await b("POST", "/mfa", { code })) === 401);

const c = await login(PASSWORD);
check("recovery code ← 200", (await c("POST", "/recovery", { code: RECOVERY[0] })) === 200);
const d = await login(PASSWORD);
check("نفس الـ recovery code تاني ← 401", (await d("POST", "/recovery", { code: RECOVERY[0] })) === 401);

const e = await login(PASSWORD);
check("/mfa/disable من غير MFA ← 401", (await e("POST", "/mfa/disable", {})) === 401);
check("/mfa/disable من غير code ← 403", (await c("POST", "/mfa/disable", {})) === 403);
check("/mfa/disable بـ code جديد ← 200", (await c("POST", "/mfa/disable", { code: hotp(SECRET, step() + 1) })) === 200);

const f = await login(PASSWORD);
let last;
for (let i = 0; i < 6; i++) last = await f("POST", "/mfa", { code: "000000" });
check("بعد محاولات غلط كتير ← 429", last === 429);
check("حتى الـ recovery code الصح ← 429 وهو مقفول", (await f("POST", "/recovery", { code: RECOVERY[1] })) === 429);
console.log(`\n${ok}/${all} نجحوا`);