تغيير الأسرار والـ HMAC: إزاي تغيّر مفتاح من غير ما كل حاجة تقع

// problem.js: ليه مفتاح واحد ثابت مشكلة
import { makeToken, readToken } from "./sign.js";

const token = makeToken({ user: "mahmoud", action: "unsubscribe" });
console.log("توكن:", token.slice(0, 40) + "...");
console.log("اتقرا:", readToken(token));

// السيناريو: المفتاح اتسرّب (في git history، أو log، أو laptop اتسرق).
// عايز تغيّره. بس عندك مليون توكن متوقّع بالقديم في إيدين الناس:
// - لو غيّرت SECRET، كل التوكنات القديمة تبقى invalid فجأة ← كل الـ sessions تقع، وكل unsubscribe link يموت.
// - ولو سبته، المهاجم اللي معاه المفتاح يقدر يزوّر أي توكن.
// محتاج تقبل الاتنين وقت التغيير، وتعرف أنهي توكن اتعمل بأنهي مفتاح.
console.log("\nمحتاج rotation: توقّع بالجديد، واقبل القديم، لحد ما القديم يخلص.");

$ node problem.js
توكن: eyJ1c2VyIjoibWFobW91ZCIsImFjdGlvbiI6InVu...
اتقرا: { user: 'mahmoud', action: 'unsubscribe' }

محتاج rotation: توقّع بالجديد، واقبل القديم، لحد ما القديم يخلص.

// tokens.js: توكنات موقّعة بـ HMAC، بـ kid للـ rotation، ومفتاح مشتق لكل غرض
import { createHmac, hkdfSync, timingSafeEqual } from "node:crypto";

const b64 = (v) => Buffer.from(v).toString("base64url");

// مفتاح لكل غرض من نفس الـ secret: توكن unsubscribe ما ينفعش يتقري كـ session
const derive = (secret, purpose) => Buffer.from(hkdfSync("sha256", secret, "", `tokens:${purpose}`, 32));

export function createSigner({ keyring, purpose, now = () => Date.now() }) {
  if (!keyring.length) throw new Error("keyring فاضي");
  // نشتق مرة واحدة: kid ← key
  const keys = new Map(keyring.map(({ kid, secret }) => [kid, derive(secret, purpose)]));
  const current = keyring[0].kid;
  const mac = (key, data) => createHmac("sha256", key).update(data).digest();

  return {
    sign(payload, ttlSec) {
      const body = b64(JSON.stringify({ ...payload, exp: Math.floor(now() / 1000) + ttlSec }));
      const data = `v1.${current}.${body}`; // الـ kid جُوّه الـ data الموقّعة
      return `${data}.${mac(keys.get(current), data).toString("base64url")}`;
    },

    verify(token) {
      if (typeof token !== "string" || token.length > 4096) return null;
      const parts = token.split(".");
      if (parts.length !== 4 || parts[0] !== "v1") return null;
      const [, kid, body, sig] = parts;
      const key = keys.get(kid); // بنختار المفتاح بالـ kid، ما بنجرّبش الكل
      if (!key) return null; // kid اتشال أو مزوّر
      const expected = mac(key, `v1.${kid}.${body}`);
      const given = Buffer.from(sig, "base64url");
      if (given.length !== expected.length || !timingSafeEqual(given, expected)) return null;
      let payload;
      try {
        payload = JSON.parse(Buffer.from(body, "base64url").toString("utf8"));
      } catch {
        return null;
      }
      if (typeof payload?.exp !== "number" || payload.exp <= Math.floor(now() / 1000)) return null;
      return { ...payload, kid };
    },
  };
}

$ node main.js
١) توكن يناير                              ✔ mahmoud (kid 2026-01)
٢) توكن يناير القديم (لسه شغّال)           ✔ mahmoud (kid 2026-01)
٢) توكن فبراير الجديد                      ✔ sara (kid 2026-02)
٣) توكن يناير بعد ما شلناه                 ✘ مرفوض
٣) توكن فبراير                             ✔ sara (kid 2026-02)
توكن unsubscribe اتبعت مكان session        ✘ مرفوض

// rotate.js: rotation على تلات مراحل، بالترتيب ده بالضبط
import { createSigner } from "./tokens.js";

const JAN = { kid: "2026-01", secret: "s_lab_jan_4e7b20" };
const FEB = { kid: "2026-02", secret: "s_lab_feb_9a3f1c" };
const show = (label, v) => console.log(label.padEnd(42), v ? `✔ ${v.user} (kid ${v.kid})` : "✘ مرفوض");

// المرحلة ١: يناير بس
let s = createSigner({ keyring: [JAN], purpose: "session" });
const old = s.sign({ user: "mahmoud" }, 3600);
show("١) توكن يناير", s.verify(old));

// المرحلة ٢: فبراير بقى الحالي، ويناير لسه للتحقق
s = createSigner({ keyring: [FEB, JAN], purpose: "session" });
const fresh = s.sign({ user: "sara" }, 3600);
show("٢) توكن يناير القديم (لسه شغّال)", s.verify(old));
show("٢) توكن فبراير الجديد", s.verify(fresh));

// المرحلة ٣: بعد ما الـ TTL بتاع يناير يعدّي، نشيله
s = createSigner({ keyring: [FEB], purpose: "session" });
show("٣) توكن يناير بعد ما شلناه", s.verify(old));
show("٣) توكن فبراير", s.verify(fresh));

// ومفتاح لكل غرض: نفس الـ secret، بس توكن unsubscribe ما يتقريش كـ session
const unsub = createSigner({ keyring: [FEB], purpose: "unsubscribe" }).sign({ user: "sara" }, 3600);
show("توكن unsubscribe اتبعت مكان session", s.verify(unsub));

// sign.js: توكن موقّع بـ HMAC. فيه secret واحد hard-coded، ومفيش طريقة تغيّره
import { createHmac } from "node:crypto";

const SECRET = "supersecret123"; // نفس المفتاح من يوم ما الموقع نزل

const b64 = (s) => Buffer.from(s).toString("base64url");
const mac = (data) => createHmac("sha256", SECRET).update(data).digest("base64url");

// توكن = payload.signature (unsubscribe link، أو session، أو أي حاجة موقّعة)
export function makeToken(payload) {
  const data = b64(JSON.stringify(payload));
  return `${data}.${mac(data)}`;
}

export function readToken(token) {
  const [data, sig] = token.split(".");
  if (mac(data) !== sig) return null; // string compare: بيسرّب الوقت كمان
  return JSON.parse(Buffer.from(data, "base64url").toString());
}

import { createSigner } from "./tokens.js";
import { createHmac } from "node:crypto";
import { readFileSync } from "node:fs";

let ok = 0, all = 0;
const check = (name, cond, extra = "") => { all++; if (cond) ok++; console.log(cond ? "✅" : "❌", name, extra); };
const JAN = { kid: "2026-01", secret: "s_lab_jan_4e7b20" };
const FEB = { kid: "2026-02", secret: "s_lab_feb_9a3f1c" };
let clock = 1_800_000_000_000;
const now = () => clock;
const mk = (keyring, purpose = "session") => createSigner({ keyring, purpose, now });

const t = mk([JAN]).sign({ user: "mahmoud", role: "user" }, 600);
const parts = t.split(".");
check("الشكل v1.kid.body.sig", parts.length === 4 && parts[0] === "v1" && parts[1] === "2026-01", t.slice(0, 30));
const v = mk([JAN]).verify(t);
check("verify بيرجّع الـ payload والـ kid", v?.user === "mahmoud" && v?.role === "user" && v?.kid === "2026-01");
check("الـ exp اتحط صح", v?.exp === 1_800_000_000 + 600);
check("sign بيستخدم أول مفتاح", mk([FEB, JAN]).sign({ user: "x" }, 60).split(".")[1] === "2026-02");
check("rotation: توكن يناير شغّال لما الـ keyring فيه فبراير ويناير", mk([FEB, JAN]).verify(t)?.user === "mahmoud");
check("بعد ما يناير يتشال ← null", mk([FEB]).verify(t) === null);
check("نفس الـ kid بـ secret تاني (مفتاح اتسرّب واتغيّر) ← null", mk([{ kid: "2026-01", secret: "other" }]).verify(t) === null);
check("kid مزوّر ← null", mk([JAN]).verify(["v1", "2099-01", parts[2], parts[3]].join(".")) === null);
check("تغيير الـ kid لمفتاح تاني موجود ← null (الـ kid جُوّه التوقيع)", mk([FEB, JAN]).verify(["v1", "2026-02", parts[2], parts[3]].join(".")) === null);

const evil = Buffer.from(JSON.stringify({ user: "mahmoud", role: "admin", exp: 1_800_000_600 })).toString("base64url");
check("body متغيّر (role admin) ← null", mk([JAN]).verify(["v1", "2026-01", evil, parts[3]].join(".")) === null);
const rawMac = createHmac("sha256", JAN.secret).update(`v1.2026-01.${evil}`).digest("base64url");
check("توقيع بالـ secret الخام من غير HKDF ← null", mk([JAN]).verify(`v1.2026-01.${evil}.${rawMac}`) === null);
check("توقيع ناقص حرف ← null", mk([JAN]).verify(t.slice(0, -1)) === null);
check("توقيع فاضي ← null", mk([JAN]).verify(parts.slice(0, 3).join(".") + ".") === null);
check("v2 ← null", mk([JAN]).verify(t.replace(/^v1/, "v2")) === null);
for (const bad of ["", "a.b", "v1.2026-01.x.y.z", null, 42, "v1." + "a".repeat(5000)])
  check(`مدخل زبالة ${JSON.stringify(bad)?.slice(0, 20)} ← null من غير throw`, (() => { try { return mk([JAN]).verify(bad) === null; } catch { return false; } })());

const unsub = mk([JAN], "unsubscribe").sign({ user: "mahmoud" }, 600);
check("توكن unsubscribe اتقرا كـ session ← null", mk([JAN], "session").verify(unsub) === null);
check("توكن unsubscribe اتقرا كـ unsubscribe ← شغّال", mk([JAN], "unsubscribe").verify(unsub)?.user === "mahmoud");

clock += 599_000;
check("قبل الـ exp بتانية ← شغّال", mk([JAN]).verify(t) !== null);
clock += 1_000;
check("عند الـ exp ← null", mk([JAN]).verify(t) === null);
check("keyring
…