أفضل ممارسات أمان API: قائمة التحقق التي أطبقها في كل مشروع

import jwt from "jsonwebtoken";
import { timingSafeEqual } from "crypto";
 
interface TokenPayload {
  sub: string;
  role: "user" | "admin";
  iss: string;
  aud: string;
  exp: number;
  iat: number;
  jti: string;
}
 
function verifyToken(token: string): TokenPayload {
  try {
    const payload = jwt.verify(token, process.env.JWT_SECRET!, {
      algorithms: ["HS256"], // لا تسمح أبداً بـ "none"
      issuer: "api.yourapp.com",
      audience: "yourapp.com",
      clockTolerance: 30, // 30 ثانية سماح لفرق الساعات
    }) as TokenPayload;
 
    return payload;
  } catch (error) {
    if (error instanceof jwt.TokenExpiredError) {
      throw new ApiError(401, "Token expired");
    }
    if (error instanceof jwt.JsonWebTokenError) {
      throw new ApiError(401, "Invalid token");
    }
    throw new ApiError(401, "Authentication failed");
  }
}

import { randomBytes } from "crypto";
import { redis } from "./redis";
 
interface RefreshTokenData {
  userId: string;
  family: string; // عائلة الرمز لكشف التدوير
  createdAt: number;
}
 
async function rotateRefreshToken(
  oldRefreshToken: string
): Promise<{ accessToken: string; refreshToken: string }> {
  const tokenData = await redis.get(`refresh:${oldRefreshToken}`);
 
  if (!tokenData) {
    // الرمز غير موجود — إما منتهي الصلاحية أو مستخدم مسبقاً.
    // إذا كان مستخدماً مسبقاً، فهذا هجوم إعادة تشغيل محتمل.
    // إبطال عائلة الرموز بالكامل.
    const parsed = decodeRefreshToken(oldRefreshToken);
    if (parsed?.family) {
      await invalidateTokenFamily(parsed.family);
    }
    throw new ApiError(401, "Invalid refresh token");
  }
 
  const data: RefreshTokenData = JSON.parse(tokenData);
 
  // حذف الرمز القديم فوراً — استخدام واحد فقط
  await redis.del(`refresh:${oldRefreshToken}`);
 
  // توليد رموز جديدة
  const newRefreshToken = randomBytes(64).toString("hex");
  const newAccessToken = generateAccessToken(data.userId);
 
  // تخزين رمز التحديث الجديد بنفس العائلة
  await redis.setex(
    `refresh:${newRefreshToken}`,
    60 * 60 * 24 * 30, // 30 يوماً
    JSON.stringify({
      userId: data.userId,
      family: data.family,
      createdAt: Date.now(),
    })
  );
 
  return { accessToken: newAccessToken, refreshToken: newRefreshToken };
}
 
async function invalidateTokenFamily(family: string): Promise<void> {
  // البحث عن جميع الرموز في هذه العائلة وحذفها.
  // هذا هو الخيار النووي — إذا أعاد شخص ما تشغيل رمز تحديث،
  // نقتل كل رمز في العائلة، مما يفرض إعادة المصادقة.
  const keys = await redis.keys(`refresh:*`);
  for (const key of keys) {
    const data = await redis.get(key);
    if (data) {
      const parsed = JSON.parse(data) as RefreshTokenData;
      if (parsed.family === family) {
        await redis.del(key);
      }
    }
  }
}

// تعيين كوكي رمز تحديث آمن
function setRefreshTokenCookie(res: Response, token: string): void {
  res.cookie("refresh_token", token, {
    httpOnly: true,     // غير متاح عبر JavaScript
    secure: true,       // HTTPS فقط
    sameSite: "strict", // لا طلبات عبر المواقع
    maxAge: 30 * 24 * 60 * 60 * 1000, // 30 يوماً
    path: "/api/auth",  // يُرسل فقط لنقاط نهاية المصادقة
  });
}

import { z } from "zod";
 
const CreateUserSchema = z.object({
  email: z
    .string()
    .email("Invalid email format")
    .max(254, "Email too long")
    .transform((e) => e.toLowerCase().trim()),
 
  password: z
    .string()
    .min(12, "Password must be at least 12 characters")
    .max(128, "Password too long") // منع هجوم DoS عبر bcrypt
    .regex(
      /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)/,
      "Password must contain uppercase, lowercase, and a number"
    ),
 
  name: z
    .string()
    .min(1, "Name is required")
    .max(100, "Name too long")
    .regex(/^[\p{L}\p{M}\s'-]+$/u, "Name contains invalid characters"),
 
  role: z.enum(["user", "editor"]).default("user"),
  // ملاحظة: "admin" متروك عمداً هنا.
  // تعيين دور المدير يتم عبر نقطة نهاية منفصلة ذات صلاحيات.
});
 
type CreateUserInput = z.infer<typeof CreateUserSchema>;
 
// الاستخدام في معالج Express
app.post("/api/users", async (req, res) => {
  const result = CreateUserSchema.safeParse(req.body);
 
  if (!result.success) {
    return res.status(400).json({
      error: "Validation failed",
      details: result.error.issues.map((issue) => ({
        field: issue.path.join("."),
        message: issue.message,
      })),
    });
  }
 
  // result.data مُحدد النوع بالكامل كـ CreateUserInput
  const user = await createUser(result.data);
  return res.status(201).json({ id: user.id, email: user.email });
});

// ثغرة — ربط سلاسل نصية
const query = `SELECT * FROM users WHERE email = '${email}'`;
 
// آمن — استعلام معلمي
const query = `SELECT * FROM users WHERE email = $1`;
const result = await pool.query(query, [email]);

// ثغرة — قالب حرفي في $queryRaw
const users = await prisma.$queryRaw`
  SELECT * FROM users WHERE name LIKE '%${searchTerm}%'
`;
 
// آمن — استخدام Prisma.sql للمعلمات
import { Prisma } from "@prisma/client";
 
const users = await prisma.$queryRaw(
  Prisma.sql`SELECT * FROM users WHERE name LIKE ${`%${searchTerm}%`}`
);

// ثغرة — إذا كان req.body.username هو { "$gt": "" }
// يُرجع أول مستخدم في المجموعة
const user = await db.collection("users").findOne({
  username: req.body.username,
});
 
// آمن — تحويل صريح إلى سلسلة نصية
const user = await db.collection("users").findOne({
  username: String(req.body.username),
});
 
// أفضل — التحقق بـ Zod أولاً
const LoginSchema = z.object({
  username: z.string().min(1).max(50),
  password: z.string().min(1).max(128),
});

import path from "path";
import { access, constants } from "fs/promises";
 
const ALLOWED_DIR = "/app/uploads";
 
async function resolveUserFilePath(userInput: string): Promise<string> {
  // تطبيع وتحويل إلى مسار مطلق
  const resolved = path.resolve(ALLOWED_DIR, userInput);
 
  // حاسم: التحقق من أن المسار المحلول لا يزال داخل المجلد المسموح
  if (!resolved.startsWith(ALLOWED_DIR + path.sep)) {
    throw new ApiError(403, "Access denied");
  }
 
  // التحقق من وجود الملف فعلياً
  await access(resolved, constants.R_OK);
 
  return resolved;
}
 
// بدون هذا الفحص:
// GET /api/files?name=../../../etc/passwd
// يُحل إلى /etc/passwd

import { Redis } from "ioredis";
 
interface RateLimitResult {
  allowed: boolean;
  remaining: number;
  resetAt: number;
}
 
async function slidingWindowRateLimit(
  redis: Redis,
  key: string,
  limit: number,
  windowMs: number
): Promise<RateLimitResult> {
  const now = Date.now();
  const windowStart = now - windowMs;
 
  const multi = redis.multi();
 
  // إزالة المدخلات خارج النافذة
  multi.zremrangebyscore(key, 0, windowStart);
 
  // عد المدخلات في النافذة
  multi.zcard(key);
 
  // إضافة الطلب الحالي (سنزيله إذا تجاوز الحد)
  multi.zadd(key, now.toString(), `${now}:${Math.random()}`);
 
  // تعيين انتهاء الصلاحية على المفتاح
  multi.pexpire(key, windowMs);
 
  const results = await multi.exec();
 
  if (!results) {
    throw new Error("Redis transaction failed");
  }
 
  const count = results[1][1] as number;
 
  if (count >= limit) {
    // تجاوز الحد — إزالة المدخل الذي أضفناه للتو
    await redis.zremrangebyscore(key, now, now);
 
    return {
      allowed: false,
      remaining: 0,
      resetAt: windowStart + windowMs,
    };
  }
 
  return {
    allowed: true,
    remaining: limit - count - 1,
    resetAt: now + windowMs,
  };
}

interface RateLimitConfig {
  window: number;
  max: number;
}
 
const RATE_LIMITS: Record<string, RateLimitConfig> = {
  // نقاط نهاية المصادقة — حدود ضيقة، هدف القوة الغاشمة
  "POST:/api/auth/login": { window: 15 * 60 * 1000, max: 5 },
  "POST:/api/auth/register": { window: 60 * 60 * 1000, max: 3 },
  "POST:/api/auth/reset-password": { window: 60 * 60 * 1000, max: 3 },
 
  // قراءة البيانات — أكثر سخاء
  "GET:/api/users": { window: 60 * 1000, max: 100 },
  "GET:/api/products": { window: 60 * 1000, max: 200 },
 
  // كتابة البيانات — معتدل
  "POST:/api/posts": { window: 60 * 1000, max: 10 },
  "PUT:/api/posts": { window: 60 * 1000, max: 30 },
 
  // الاحتياطي العالمي
  "*": { window: 60 * 1000, max: 60 },
};
 
function getRateLimitKey(req: Request, config: RateLimitConfig): string {
  const identifier = req.user?.id ?? getClientIp(req);
  const endpoint = `${req.method}:${req.path}`;
  return `ratelimit:${identifier}:${endpoint}`;
}

function setRateLimitHeaders(
  res: Response,
  result: RateLimitResult,
  limit: number
): void {
  res.set({
    "X-RateLimit-Limit": limit.toString(),
    "X-RateLimit-Remaining": result.remaining.toString(),
    "X-RateLimit-Reset": Math.ceil(result.resetAt / 1000).toString(),
    "Retry-After": result.allowed
      ? undefined
      : Math.ceil((result.resetAt - Date.now()) / 1000).toString(),
  });
 
  if (!result.allowed) {
    res.status(429).json({
      error: "Too many requests",
      retryAfter: Math.ceil((result.resetAt - Date.now()) / 1000),
    });
  }
}

// خطير — يسمح لأي موقع بقراءة استجابات واجهتك البرمجية
app.use(cors({ origin: "*" }));
 
// خطير أيضاً — هذا نهج "ديناميكي" شائع وهو مجرد * بخطوات إضافية
app.use(
  cors({
    origin: (origin, callback) => {
      callback(null, true); // يسمح بكل شيء
    },
  })
);

import cors from "cors";
 
const ALLOWED_ORIGINS = new Set([
  "https://yourapp.com",
  "https://www.yourapp.com",
  "https://admin.yourapp.com",
]);
 
if (process.env.NODE_ENV === "development") {
  ALLOWED_ORIGINS.add("http://localhost:3000");
  ALLOWED_ORIGINS.add("http://localhost:5173");
}
 
app.use(
  cors({
    origin: (origin, callback) => {
      // السماح بالطلبات بدون أصل (تطبيقات الموبايل، curl، خادم لخادم)
      if (!origin) {
        return callback(null, true);
      }
 
      if (ALLOWED_ORIGINS.has(origin)) {
        return callback(null, origin);
      }
 
      callback(new Error(`Origin ${origin} not allowed by CORS`));
    },
    credentials: true, // السماح بالكوكيز
    methods: ["GET", "POST", "PUT", "DELETE", "PATCH"],
    allowedHeaders: ["Content-Type", "Authorization"],
    exposedHeaders: ["X-RateLimit-Limit", "X-RateLimit-Remaining"],
    maxAge: 86400, // تخزين preflight لمدة 24 ساعة
  })
);

// معالجة preflight يدوياً (معظم الأطر تفعل هذا لك)
app.options("*", (req, res) => {
  res.set({
    "Access-Control-Allow-Origin": getAllowedOrigin(req.headers.origin),
    "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, PATCH",
    "Access-Control-Allow-Headers": "Content-Type, Authorization",
    "Access-Control-Max-Age": "86400",
  });
  res.status(204).end();
});

import helmet from "helmet";
 
// سطر واحد. هذا أسرع مكسب أمني في أي تطبيق Express.
app.use(
  helmet({
    contentSecurityPolicy: {
      directives: {
        defaultSrc: ["'self'"],
        scriptSrc: ["'self'"],
        styleSrc: ["'self'", "'unsafe-inline'"], // مطلوب للعديد من حلول CSS-in-JS
        imgSrc: ["'self'", "data:", "https:"],
        connectSrc: ["'self'", "https://api.yourapp.com"],
        fontSrc: ["'self'"],
        objectSrc: ["'none'"],
        mediaSrc: ["'self'"],
        frameSrc: ["'none'"],
        upgradeInsecureRequests: [],
      },
    },
    hsts: {
      maxAge: 31536000, // سنة واحدة
      includeSubDomains: true,
      preload: true,
    },
    referrerPolicy: { policy: "strict-origin-when-cross-origin" },
  })
);

import { describe, it, expect } from "vitest";
 
describe("Security headers", () => {
  it("should include all required security headers", async () => {
    const response = await fetch("https://api.yourapp.com/health");
 
    expect(response.headers.get("strict-transport-security")).toBeTruthy();
    expect(response.headers.get("x-content-type-options")).toBe("nosniff");
    expect(response.headers.get("x-frame-options")).toBe("SAMEORIGIN");
    expect(response.headers.get("content-security-policy")).toBeTruthy();
    expect(response.headers.get("referrer-policy")).toBeTruthy();
    expect(response.headers.get("x-powered-by")).toBeNull(); // Helmet يزيل هذا
  });
});

# .env.example — التزم بهذا
DATABASE_URL=postgresql://user:password@localhost:5432/dbname
JWT_SECRET=your-secret-here
REDIS_URL=redis://localhost:6379
SMTP_API_KEY=your-smtp-key
 
# .env — لا تُلزم هذا أبداً
# مُدرج في .gitignore

import { z } from "zod";
 
const envSchema = z.object({
  DATABASE_URL: z.string().url(),
  JWT_SECRET: z.string().min(32, "JWT secret must be at least 32 characters"),
  REDIS_URL: z.string().url(),
  NODE_ENV: z.enum(["development", "production", "test"]).default("development"),
  PORT: z.coerce.number().default(3000),
  CORS_ORIGINS: z.string().transform((s) => s.split(",")),
});
 
export type Env = z.infer<typeof envSchema>;
 
function validateEnv(): Env {
  const result = envSchema.safeParse(process.env);
 
  if (!result.success) {
    console.error("Invalid environment variables:");
    console.error(result.error.format());
    process.exit(1); // لا تبدأ بتكوين سيئ
  }
 
  return result.data;
}
 
export const env = validateEnv();

interface SigningKey {
  id: string;
  secret: string;
  createdAt: Date;
  active: boolean; // فقط المفتاح النشط يوقع الرموز الجديدة
}
 
async function verifyWithRotation(token: string): Promise<TokenPayload> {
  const keys = await getSigningKeys(); // يُرجع جميع المفاتيح الصالحة
 
  for (const key of keys) {
    try {
      return jwt.verify(token, key.secret, {
        algorithms: ["HS256"],
      }) as TokenPayload;
    } catch {
      continue; // جرب المفتاح التالي
    }
  }
 
  throw new ApiError(401, "Invalid token");
}
 
function signToken(payload: Omit<TokenPayload, "iat" | "exp">): string {
  const activeKey = getActiveSigningKey();
  return jwt.sign(payload, activeKey.secret, {
    algorithm: "HS256",
    expiresIn: "15m",
    keyid: activeKey.id, // تضمين معرف المفتاح في الرأس
  });
}

// ثغرة — أي مستخدم مُصادَق يمكنه الوصول لبيانات أي مستخدم
app.get("/api/users/:id", authenticate, async (req, res) => {
  const user = await db.users.findById(req.params.id);
  return res.json(user);
});
 
// مُصلح — التحقق من أن المستخدم يصل لبياناته (أو أنه مدير)
app.get("/api/users/:id", authenticate, async (req, res) => {
  if (req.user.id !== req.params.id && req.user.role !== "admin") {
    return res.status(403).json({ error: "Access denied" });
  }
  const user = await db.users.findById(req.params.id);
  return res.json(user);
});

const MAX_LOGIN_ATTEMPTS = 5;
const LOCKOUT_DURATION = 15 * 60 * 1000; // 15 دقيقة
 
async function handleLogin(email: string, password: string): Promise<AuthResult> {
  const lockoutKey = `lockout:${email}`;
  const attempts = await redis.get(lockoutKey);
 
  if (attempts && parseInt(attempts) >= MAX_LOGIN_ATTEMPTS) {
    const ttl = await redis.pttl(lockoutKey);
    throw new ApiError(
      429,
      `Account locked. Try again in ${Math.ceil(ttl / 60000)} minutes.`
    );
  }
 
  const user = await db.users.findByEmail(email);
 
  if (!user || !(await bcrypt.compare(password, user.passwordHash))) {
    // زيادة المحاولات الفاشلة
    await redis.multi()
      .incr(lockoutKey)
      .pexpire(lockoutKey, LOCKOUT_DURATION)
      .exec();
 
    // نفس رسالة الخطأ للحالتين — لا تكشف ما إذا كان البريد موجوداً
    throw new ApiError(401, "Invalid email or password");
  }
 
  // إعادة تعيين المحاولات الفاشلة عند تسجيل الدخول الناجح
  await redis.del(lockoutKey);
 
  return generateTokens(user);
}

// ثغرة — يُرجع كائن المستخدم بالكامل، بما في ذلك الحقول الداخلية
app.get("/api/users/:id", authenticate, authorize, async (req, res) => {
  const user = await db.users.findById(req.params.id);
  return res.json(user);
  // الاستجابة تتضمن: passwordHash, internalNotes, billingId, ...
});
 
// مُصلح — قائمة سماح صريحة للحقول المُرجعة
app.get("/api/users/:id", authenticate, authorize, async (req, res) => {
  const user = await db.users.findById(req.params.id);
  return res.json({
    id: user.id,
    name: user.name,
    email: user.email,
    avatar: user.avatar,
    createdAt: user.createdAt,
  });
});

// ثغرة — التعيين الجماعي
app.put("/api/users/:id", authenticate, async (req, res) => {
  await db.users.update(req.params.id, req.body);
  // المهاجم يرسل: { "role": "admin", "verified": true }
});
 
// مُصلح — اختيار الحقول المسموحة
const UpdateUserSchema = z.object({
  name: z.string().min(1).max(100).optional(),
  avatar: z.string().url().optional(),
});
 
app.put("/api/users/:id", authenticate, async (req, res) => {
  const data = UpdateUserSchema.parse(req.body);
  await db.users.update(req.params.id, data);
});

// تحديد حجم جسم الطلب
app.use(express.json({ limit: "1mb" }));
 
// تحديد تعقيد الاستعلام
const MAX_PAGE_SIZE = 100;
const DEFAULT_PAGE_SIZE = 20;
 
const PaginationSchema = z.object({
  page: z.coerce.number().int().positive().default(1),
  limit: z.coerce
    .number()
    .int()
    .positive()
    .max(MAX_PAGE_SIZE)
    .default(DEFAULT_PAGE_SIZE),
});
 
// تحديد حجم رفع الملفات
const upload = multer({
  limits: {
    fileSize: 5 * 1024 * 1024, // 5 ميغابايت
    files: 1,
  },
  fileFilter: (req, file, cb) => {
    const allowed = ["image/jpeg", "image/png", "image/webp"];
    if (allowed.includes(file.mimetype)) {
      cb(null, true);
    } else {
      cb(new Error("Invalid file type"));
    }
  },
});
 
// مهلة الطلبات طويلة التشغيل
app.use((req, res, next) => {
  res.setTimeout(30000, () => {
    res.status(408).json({ error: "Request timeout" });
  });
  next();
});

// وسيط يتحقق من الوصول المبني على الأدوار
function requireRole(...allowedRoles: string[]) {
  return (req: Request, res: Response, next: NextFunction) => {
    if (!req.user) {
      return res.status(401).json({ error: "Not authenticated" });
    }
 
    if (!allowedRoles.includes(req.user.role)) {
      // سجّل المحاولة — قد يكون هذا هجوماً
      logger.warn("Unauthorized access attempt", {
        userId: req.user.id,
        role: req.user.role,
        requiredRoles: allowedRoles,
        endpoint: `${req.method} ${req.path}`,
        ip: req.ip,
      });
 
      return res.status(403).json({ error: "Insufficient permissions" });
    }
 
    next();
  };
}
 
// التطبيق على المسارات
app.delete("/api/users/:id", authenticate, requireRole("admin"), deleteUser);
app.get("/api/admin/stats", authenticate, requireRole("admin"), getStats);
app.post("/api/posts", authenticate, requireRole("admin", "editor"), createPost);

import { URL } from "url";
import dns from "dns/promises";
import { isPrivateIP } from "./network-utils";
 
async function safeFetch(userProvidedUrl: string): Promise<Response> {
  let parsed: URL;
 
  try {
    parsed = new URL(userProvidedUrl);
  } catch {
    throw new ApiError(400, "Invalid URL");
  }
 
  // السماح فقط بـ HTTP(S)
  if (!["http:", "https:"].includes(parsed.protocol)) {
    throw new ApiError(400, "Only HTTP(S) URLs are allowed");
  }
 
  // حل اسم المضيف والتحقق مما إذا كان IP خاصاً
  const addresses = await dns.resolve4(parsed.hostname);
 
  for (const addr of addresses) {
    if (isPrivateIP(addr)) {
      throw new ApiError(400, "Internal addresses are not allowed");
    }
  }
 
  // الآن اجلب مع مهلة وحد حجم
  const controller = new AbortController();
  const timeout = setTimeout(() => controller.abort(), 5000);
 
  try {
    const response = await fetch(userProvidedUrl, {
      signal: controller.signal,
      redirect: "error", // لا تتبع إعادات التوجيه (قد تُعيد التوجيه إلى عناوين IP داخلية)
    });
 
    return response;
  } finally {
    clearTimeout(timeout);
  }
}

// لا تسرّب تتبع المكدس في الإنتاج
app.use((err: Error, req: Request, res: Response, next: NextFunction) => {
  logger.error("Unhandled error", {
    error: err.message,
    stack: err.stack,
    path: req.path,
    method: req.method,
  });
 
  if (process.env.NODE_ENV === "production") {
    // رسالة خطأ عامة — لا تكشف الداخليات
    res.status(500).json({
      error: "Internal server error",
      requestId: req.id, // تضمين معرف طلب للتصحيح
    });
  } else {
    // في التطوير، اعرض الخطأ الكامل
    res.status(500).json({
      error: err.message,
      stack: err.stack,
    });
  }
});
 
// تعطيل طرق HTTP غير الضرورية
app.use((req, res, next) => {
  const allowed = ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"];
  if (!allowed.includes(req.method)) {
    return res.status(405).json({ error: "Method not allowed" });
  }
  next();
});

import crypto from "crypto";
 
// التحقق من توقيعات webhook الخاصة بـ Stripe
function verifyStripeWebhook(
  payload: string,
  signature: string,
  secret: string
): boolean {
  const timestamp = signature.split(",").find((s) => s.startsWith("t="))?.slice(2);
  const expectedSig = signature.split(",").find((s) => s.startsWith("v1="))?.slice(3);
 
  if (!timestamp || !expectedSig) return false;
 
  // رفض الطوابع الزمنية القديمة (منع هجمات الإعادة)
  const age = Math.abs(Date.now() / 1000 - parseInt(timestamp));
  if (age > 300) return false; // تسامح 5 دقائق
 
  const signedPayload = `${timestamp}.${payload}`;
  const computedSig = crypto
    .createHmac("sha256", secret)
    .update(signedPayload)
    .digest("hex");
 
  return crypto.timingSafeEqual(
    Buffer.from(computedSig),
    Buffer.from(expectedSig)
  );
}

interface AuditLogEntry {
  timestamp: string;
  action: string;           // "user.login", "post.delete", "admin.role_change"
  actor: {
    id: string;
    ip: string;
    userAgent: string;
  };
  target: {
    type: string;           // "user", "post", "setting"
    id: string;
  };
  result: "success" | "failure";
  metadata: Record<string, unknown>; // سياق إضافي
  requestId: string;        // للربط مع سجلات التطبيق
}
 
async function auditLog(entry: AuditLogEntry): Promise<void> {
  // الكتابة إلى مخزن بيانات منفصل، للإلحاق فقط
  // هذا يجب ألا يكون نفس قاعدة بيانات تطبيقك
  await auditDb.collection("audit_logs").insertOne({
    ...entry,
    timestamp: new Date().toISOString(),
  });
 
  // للإجراءات الحرجة، اكتب أيضاً إلى سجل خارجي غير قابل للتغيير
  if (isCriticalAction(entry.action)) {
    await externalLogger.send(entry);
  }
}

function sanitizeForLogging(data: Record<string, unknown>): Record<string, unknown> {
  const sensitiveKeys = new Set([
    "password",
    "passwordHash",
    "token",
    "secret",
    "apiKey",
    "creditCard",
    "ssn",
    "authorization",
  ]);
 
  const sanitized: Record<string, unknown> = {};
 
  for (const [key, value] of Object.entries(data)) {
    if (sensitiveKeys.has(key.toLowerCase())) {
      sanitized[key] = "[REDACTED]";
    } else if (typeof value === "object" && value !== null) {
      sanitized[key] = sanitizeForLogging(value as Record<string, unknown>);
    } else {
      sanitized[key] = value;
    }
  }
 
  return sanitized;
}

import crypto from "crypto";
 
let previousHash = "GENESIS"; // التجزئة الأولية في السلسلة
 
function createTamperEvidentEntry(entry: AuditLogEntry): AuditLogEntry & { hash: string } {
  const content = JSON.stringify(entry) + previousHash;
  const hash = crypto.createHash("sha256").update(content).digest("hex");
 
  previousHash = hash;
 
  return { ...entry, hash };
}
 
// للتحقق من سلامة السلسلة:
function verifyLogChain(entries: Array<AuditLogEntry & { hash: string }>): boolean {
  let expectedPreviousHash = "GENESIS";
 
  for (const entry of entries) {
    const { hash, ...rest } = entry;
    const content = JSON.stringify(rest) + expectedPreviousHash;
    const computedHash = crypto.createHash("sha256").update(content).digest("hex");
 
    if (computedHash !== hash) {
      return false; // السلسلة مكسورة — تم التلاعب بالسجلات
    }
 
    expectedPreviousHash = hash;
  }
 
  return true;
}

# شغّل هذا في CI، أفشل البناء على الثغرات العالية/الحرجة
npm audit --audit-level=high
 
# أصلح ما يمكن إصلاحه تلقائياً
npm audit fix
 
# انظر ما تسحبه فعلاً
npm ls --all

# .github/dependabot.yml
version: 2
updates:
  - package-ecosystem: "npm"
    directory: "/"
    schedule:
      interval: "weekly"
    open-pull-requests-limit: 10
    reviewers:
      - "your-team"
    labels:
      - "dependencies"
    # تجميع التحديثات الثانوية والتصحيحية لتقليل ضوضاء PR
    groups:
      production-dependencies:
        patterns:
          - "*"
        update-types:
          - "minor"
          - "patch"

# في CI، استخدم ci بدلاً من install — يحترم ملف القفل بصرامة
npm ci

// لا تحتاج حزمة لهذا:
const isEven = (n: number): boolean => n % 2 === 0;
 
// أو هذا:
const leftPad = (str: string, len: number, char = " "): string =>
  str.padStart(len, char);
 
// أو هذا:
const isNil = (value: unknown): value is null | undefined =>
  value === null || value === undefined;