التحقق من حركة وكلاء الذكاء الاصطناعي في Next.js باستخدام Web Bot Auth ومعيار RFC 9421

GET /ar/services HTTP/1.1
Host: noqta.tn
Signature-Agent: "https://signer.example.com"
Signature-Input: sig1=("@authority" "signature-agent");created=1785667520;
                 keyid="poqkLGiymh_W0uP6PZFw-dvez3QJT5SolqXBCW38r0U";
                 alg="ed25519";expires=1785667820;nonce="Rifzo0j0...";tag="web-bot-auth"
Signature: sig1=:mMElbdKxLiXjcOJ7161NxIUscYhA/HMyThrbs7KQLvhm...:

{
  "keys": [
    {
      "crv": "Ed25519",
      "kty": "OKP",
      "x": "7F_3jDlxaquwh291MiACkcS3Opq88NksyHiakzS-Y1g",
      "kid": "otMqcjr17mGyruktGvJU8oojQTSMHlVm7uO-lrcqbdg",
      "use": "sig",
      "nbf": 1735689600,
      "exp": 1786272375
    }
  ],
  "signature_agent": "https://chatgpt.com",
  "purpose": "ai"
}

npm install web-bot-auth jose

// منطق البروتوكول والثوابت والتحقق
import { verify, signatureHeaders, REQUEST_COMPONENTS } from "web-bot-auth";
 
// محوّلات تشفيرية فوق WebCrypto
import { signerFromJWK, verifierFromJWK } from "web-bot-auth/crypto";

import { generateKeyPair, exportJWK } from "jose";
import { jwkToKeyID, helpers } from "web-bot-auth";
import { writeFileSync } from "node:fs";
 
async function main() {
  const { publicKey, privateKey } = await generateKeyPair("Ed25519", {
    extractable: true,
  });
 
  const privateJWK = { ...(await exportJWK(privateKey)), kty: "OKP", crv: "Ed25519" };
  const publicJWK = { ...(await exportJWK(publicKey)), kty: "OKP", crv: "Ed25519" };
 
  // بصمة RFC 7638 — تصبح هي `keyid` في كل توقيع تُصدره
  const kid = await jwkToKeyID(
    publicJWK,
    helpers.WEBCRYPTO_SHA256,
    helpers.BASE64URL_DECODE
  );
 
  publicJWK.kid = kid;
  privateJWK.kid = kid;
 
  writeFileSync("keys/public.jwk.json", JSON.stringify({ ...publicJWK, use: "sig" }, null, 2));
  writeFileSync("keys/private.jwk.json", JSON.stringify(privateJWK, null, 2));
 
  console.log("معرّف المفتاح (البصمة):", kid);
}
 
main();

mkdir -p keys && npx tsx scripts/generate-key.ts

const privateJWK = JSON.parse(process.env.WEB_BOT_AUTH_PRIVATE_JWK!);

import { MediaType } from "web-bot-auth";
import publicJWK from "@/keys/public.jwk.json";
 
export const runtime = "nodejs";
export const dynamic = "force-static";
 
export function GET() {
  const directory = {
    keys: [publicJWK],
    signature_agent: process.env.SIGNATURE_AGENT_ORIGIN ?? "https://agent.example.com",
    purpose: "ai",
  };
 
  return new Response(JSON.stringify(directory), {
    headers: {
      "Content-Type": MediaType.HTTP_MESSAGE_SIGNATURES_DIRECTORY,
      "Cache-Control": "public, max-age=86400",
    },
  });
}

curl -s http://localhost:3000/.well-known/http-message-signatures-directory | jq

import { signatureHeaders, REQUEST_COMPONENTS, generateNonce } from "web-bot-auth";
import { signerFromJWK } from "web-bot-auth/crypto";
 
const SIGNATURE_AGENT = process.env.SIGNATURE_AGENT_ORIGIN!;
const VALIDITY_SECONDS = 300;
 
// خزّن المُوقِّع مؤقتًا — استيراد CryptoKey مع كل طلب هدر للموارد
let signerPromise: ReturnType<typeof signerFromJWK> | null = null;
 
function getSigner() {
  if (!signerPromise) {
    signerPromise = signerFromJWK(JSON.parse(process.env.WEB_BOT_AUTH_PRIVATE_JWK!));
  }
  return signerPromise;
}
 
export async function signedFetch(url: string, init: RequestInit = {}) {
  // قيمة Signature-Agent سلسلة نصية بين علامتَي اقتباس
  const signatureAgent = `"${SIGNATURE_AGENT}"`;
 
  const request = new Request(url, {
    ...init,
    headers: { ...init.headers, "Signature-Agent": signatureAgent },
  });
 
  const created = new Date();
  const headers = await signatureHeaders(request, await getSigner(), {
    created,
    expires: new Date(created.getTime() + VALIDITY_SECONDS * 1000),
    nonce: generateNonce(),
    components: REQUEST_COMPONENTS, // ["@authority", "signature-agent"]
    key: "sig1",
  });
 
  return fetch(url, {
    ...init,
    headers: {
      ...init.headers,
      "Signature-Agent": signatureAgent,
      Signature: headers["Signature"],
      "Signature-Input": headers["Signature-Input"],
    },
  });
}

const res = await signedFetch(
  "https://http-message-signatures-example.research.cloudflare.com/debug"
);
console.log(await res.json());

import { HTTP_MESSAGE_SIGNATURES_DIRECTORY } from "web-bot-auth";
 
interface Directory {
  keys: JsonWebKey[];
  signature_agent?: string;
  purpose?: string;
}
 
interface CacheEntry {
  keys: JsonWebKey[];
  expiresAt: number;
}
 
const cache = new Map<string, CacheEntry>();
const TTL_MS = 60 * 60 * 1000; // ساعة واحدة
const FETCH_TIMEOUT_MS = 2000;
 
// هؤلاء المُشغِّلون وحدهم موثوقون. جلب أي أصل يسمّيه الطلب دون قيد
// يفتح ثغرة تزوير طلبات من جهة الخادم.
const ALLOWED_AGENTS = new Set([
  "https://chatgpt.com",
  "https://anthropic.com",
  "https://http-message-signatures-example.research.cloudflare.com",
]);
 
export function parseSignatureAgent(header: string | null): string | null {
  if (!header) return null;
  // القيمة سلسلة بين علامتَي اقتباس، وقد تتبعها معاملات حقول مهيكلة
  const match = header.match(/"([^"]+)"/);
  if (!match) return null;
  try {
    const url = new URL(match[1]);
    if (url.protocol !== "https:") return null;
    return url.origin;
  } catch {
    return null;
  }
}
 
export async function resolveKeys(agentOrigin: string): Promise<JsonWebKey[]> {
  if (!ALLOWED_AGENTS.has(agentOrigin)) {
    throw new Error(`وكيل توقيع غير موثوق: ${agentOrigin}`);
  }
 
  const cached = cache.get(agentOrigin);
  if (cached && cached.expiresAt > Date.now()) return cached.keys;
 
  const res = await fetch(agentOrigin + HTTP_MESSAGE_SIGNATURES_DIRECTORY, {
    signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
    headers: { Accept: "application/http-message-signatures-directory+json" },
  });
 
  if (!res.ok) {
    // قدّم النسخة القديمة بدل الإخفاق بسبب عطل عابر
    if (cached) return cached.keys;
    throw new Error(`فشل جلب الدليل: ${res.status}`);
  }
 
  const directory = (await res.json()) as Directory;
  const keys = (directory.keys ?? []).filter(isUsableKey);
 
  cache.set(agentOrigin, { keys, expiresAt: Date.now() + TTL_MS });
  return keys;
}
 
function isUsableKey(key: JsonWebKey & { nbf?: number; exp?: number }): boolean {
  if (key.kty !== "OKP" || key.crv !== "Ed25519" || !key.kid) return false;
 
  // ينشر المُشغِّلون nbf و exp بصيغ متضاربة — بعضهم بالثواني وبعضهم
  // بالمللي ثانية. وحّد الوحدات قبل أي مقارنة.
  const now = Date.now();
  const toMs = (t: number) => (t > 1e11 ? t : t * 1000);
 
  if (key.nbf !== undefined && toMs(key.nbf) > now) return false;
  if (key.exp !== undefined && toMs(key.exp) < now) return false;
  return true;
}

import { verify, HTTP_MESSAGE_SIGNATURE_TAG } from "web-bot-auth";
import { verifierFromJWK } from "web-bot-auth/crypto";
 
export interface VerifiedAgent {
  agentOrigin: string;
  keyid: string;
  nonce?: string;
  expires: Date;
}
 
const MAX_CLOCK_SKEW_MS = 60_000;
 
export async function verifySignedRequest(
  request: Request,
  agentOrigin: string,
  keys: JsonWebKey[]
): Promise<VerifiedAgent> {
  const index = new Map(keys.map((k) => [(k as { kid: string }).kid, k]));
  let result: VerifiedAgent | null = null;
 
  // نُركّب فحوصنا الخاصة حول عملية التحقق التي تجريها المكتبة
  const verifier = async (
    data: string,
    signature: Uint8Array,
    params: { keyid: string; created: Date; expires: Date; tag: string; nonce?: string }
  ) => {
    if (params.tag !== HTTP_MESSAGE_SIGNATURE_TAG) {
      throw new Error(`وسم غير متوقع: ${params.tag}`);
    }
 
    const jwk = index.get(params.keyid);
    if (!jwk) throw new Error(`معرّف مفتاح مجهول: ${params.keyid}`);
 
    if (params.created.getTime() - Date.now() > MAX_CLOCK_SKEW_MS) {
      throw new Error("التوقيع مُنشأ في المستقبل");
    }
 
    result = {
      agentOrigin,
      keyid: params.keyid,
      nonce: params.nonce,
      expires: params.expires,
    };
 
    const inner = await verifierFromJWK(jwk);
    return inner(data, signature, params);
  };
 
  await verify(request, verifier);
 
  if (!result) throw new Error("لم تُنتج عملية التحقق أي نتيجة");
  return result;
}

import { Redis } from "@upstash/redis";
 
const redis = Redis.fromEnv();
 
/**
 * يسجّل قيمة nonce ويُبلغ إن كانت قد شوهدت من قبل.
 * تنتهي صلاحية المفتاح مع انتهاء التوقيع، فيبقى التخزين محدودًا.
 */
export async function isReplay(keyid: string, nonce: string, expires: Date): Promise<boolean> {
  const ttlSeconds = Math.ceil((expires.getTime() - Date.now()) / 1000);
  if (ttlSeconds <= 0) return true; // منتهٍ أصلًا، يُعامَل كإعادة تشغيل
 
  const key = `wba:nonce:${keyid}:${nonce}`;
  // تُعيد SET NX القيمة null عندما يكون المفتاح موجودًا سلفًا
  const stored = await redis.set(key, "1", { nx: true, ex: ttlSeconds });
  return stored === null;
}

import { NextRequest, NextResponse } from "next/server";
import { parseSignatureAgent, resolveKeys } from "@/lib/web-bot-auth/directory";
import { verifySignedRequest } from "@/lib/web-bot-auth/verify";
import { isReplay } from "@/lib/web-bot-auth/replay";
 
// Ed25519 عبر WebCrypto إضافة إلى طلب شبكي — بيئة تشغيل Node مطلوبة
export const config = {
  runtime: "nodejs",
  matcher: ["/((?!_next/static|_next/image|favicon.ico).*)"],
};
 
export async function middleware(request: NextRequest) {
  const headers = new Headers(request.headers);
 
  // احذف أي قيمة يرسلها العميل حتى لا يُخدع الكود اللاحق
  headers.delete("x-verified-agent");
  headers.delete("x-agent-keyid");
 
  const agentOrigin = parseSignatureAgent(request.headers.get("signature-agent"));
 
  if (agentOrigin && request.headers.get("signature")) {
    try {
      const keys = await resolveKeys(agentOrigin);
      const verified = await verifySignedRequest(request, agentOrigin, keys);
 
      if (verified.nonce && (await isReplay(verified.keyid, verified.nonce, verified.expires))) {
        return new NextResponse("توقيع مُعاد", { status: 401 });
      }
 
      headers.set("x-verified-agent", verified.agentOrigin);
      headers.set("x-agent-keyid", verified.keyid);
    } catch (error) {
      // التوقيع الفاشل إشارة أقوى من غياب التوقيع تمامًا:
      // ثمة من حاول وأخطأ. سجّل الحدث ولا تتجاهله بصمت.
      console.warn("فشل التحقق من web-bot-auth", {
        agentOrigin,
        reason: error instanceof Error ? error.message : "غير معروف",
      });
      return new NextResponse("توقيع غير صالح", { status: 401 });
    }
  }
 
  return NextResponse.next({ request: { headers } });
}

import { headers } from "next/headers";
 
export default async function ServicesPage() {
  const agent = (await headers()).get("x-verified-agent");
 
  if (agent) {
    // مُشغِّل مُتحقَّق منه — قدّم تمثيلًا مهيكلًا وخفيفًا.
    // تجاوز الغلاف التسويقي يقلّص الحمولة ويحسّن دقة التحليل.
    return <ServicesStructuredView operator={agent} />;
  }
 
  return <ServicesMarketingPage />;
}

import { describe, it, expect } from "vitest";
import { signatureHeaders, REQUEST_COMPONENTS, generateNonce } from "web-bot-auth";
import { signerFromJWK } from "web-bot-auth/crypto";
import { verifySignedRequest } from "./verify";
 
// مفتاح اختبار RFC 9421 الملحق B.1.4 — معلوم للجميع، لا يُستخدم في الإنتاج
const PRIVATE_JWK = {
  kty: "OKP",
  crv: "Ed25519",
  d: "n4Ni-HpISpVObnQMW0wOhCKROaIKqKtW_2ZYb2p9KcU",
  x: "JrQLj5P_89iXES9-vFgrIy29clF9CC_oPPsw3c5D0bs",
};
 
const PUBLIC_JWK = {
  kty: "OKP",
  crv: "Ed25519",
  x: PRIVATE_JWK.x,
  kid: "poqkLGiymh_W0uP6PZFw-dvez3QJT5SolqXBCW38r0U", // بصمة المفتاح أعلاه
};
 
const AGENT = "https://signer.example.com";
 
async function makeSignedRequest(url = "https://noqta.tn/ar/services", offsetMs = 0) {
  const signatureAgent = `"${AGENT}"`;
  const base = new Request(url, { headers: { "Signature-Agent": signatureAgent } });
  const created = new Date(Date.now() + offsetMs);
 
  const headers = await signatureHeaders(base, await signerFromJWK(PRIVATE_JWK), {
    created,
    expires: new Date(created.getTime() + 300_000),
    nonce: generateNonce(),
    components: REQUEST_COMPONENTS,
    key: "sig1",
  });
 
  return new Request(url, {
    headers: {
      "Signature-Agent": signatureAgent,
      Signature: headers["Signature"],
      "Signature-Input": headers["Signature-Input"],
    },
  });
}
 
describe("verifySignedRequest", () => {
  it("يقبل توقيعًا صالحًا", async () => {
    const request = await makeSignedRequest();
    const result = await verifySignedRequest(request, AGENT, [PUBLIC_JWK]);
    expect(result.keyid).toBe(PUBLIC_JWK.kid);
  });
 
  it("يرفض توقيعًا مرتبطًا بجهة أخرى", async () => {
    const signed = await makeSignedRequest();
    // الترويسات نفسها بمضيف مختلف — لم تعد @authority مطابقة
    const moved = new Request("https://evil.example/ar/services", {
      headers: signed.headers,
    });
    await expect(verifySignedRequest(moved, AGENT, [PUBLIC_JWK])).rejects.toThrow();
  });
 
  it("يرفض معرّف مفتاح مجهول", async () => {
    const request = await makeSignedRequest();
    const wrongKey = { ...PUBLIC_JWK, kid: "بصمة-غير-صحيحة" };
    await expect(verifySignedRequest(request, AGENT, [wrongKey])).rejects.toThrow(/مجهول/);
  });
 
  it("يرفض توقيعًا منتهي الصلاحية", async () => {
    const request = await makeSignedRequest("https://noqta.tn/ar/services", -7_200_000);
    await expect(verifySignedRequest(request, AGENT, [PUBLIC_JWK])).rejects.toThrow(/expired/i);
  });
});