NestJS Security — Guards بتتكسر إزاي

Request
  ↓
[Middleware]              ← Express/Fastify level (helmet, body-parser)
  ↓
[Guards]                  ← AuthGuard, RolesGuard — hasOwnProperty: استثناء = bypass
  ↓
[Interceptors (before)]   ← logging, transformation
  ↓
[Pipes]                   ← ValidationPipe, ParseIntPipe — هنا تُفحص الأنواع
  ↓
[Controller method]       ← business logic
  ↓
[Interceptors (after)]    ← serialization, response shaping
  ↓
Response

// خطر — DTO فيه isAdmin محذوف من الواجهة لكن موجود في DB
class CreateUserDto {
  @IsString() name: string;
  @IsEmail() email: string;
  // isAdmin غير معرّف هنا...
}

@Controller('users')
export class UsersController {
  @Post()
  create(@Body() dto: CreateUserDto) {
    return this.users.save(dto);    // ينسخ كل البيانات، بما فيها isAdmin: true
  }
}

// PoC
POST /users
{ "name": "x", "email": "x@x", "isAdmin": true }   // ⇒ admin

// الإصلاح في main.ts
app.useGlobalPipes(new ValidationPipe({
  whitelist: true,                  // أزل الخصائص غير المعرّفة
  forbidNonWhitelisted: true,       // ارفض الطلب لو فيه خصائص إضافية
  transform: true,                  // type-coerce
  transformOptions: { enableImplicitConversion: false },   // لا coerce ضمنية
  forbidUnknownValues: true
}));

// طلب الـ entity كاملة في response؟ خطأ.
@Get(':id')
async findOne(@Param('id') id: string) {
  return await this.users.findOne(id);   // يتضمن passwordHash, mfaSecret...
}

// الإصلاح — class-transformer + ClassSerializerInterceptor
class User {
  id: number;
  email: string;

  @Exclude()
  passwordHash: string;

  @Exclude()
  mfaSecret: string;
}

// في app.module
@UseInterceptors(ClassSerializerInterceptor)
@Controller('users')
export class UsersController { ... }

// أو DTOs منفصلة للـ response (الأفضل)
class UserResponseDto {
  @Expose() id: number;
  @Expose() email: string;
}
return plainToInstance(UserResponseDto, user, { excludeExtraneousValues: true });

// Guard معتمد على property بسيطة
@Injectable()
export class AdminGuard implements CanActivate {
  canActivate(ctx: ExecutionContext): boolean {
    const req = ctx.switchToHttp().getRequest();
    return req.user?.isAdmin === true;
  }
}

// مع prototype pollution سابق، req.user يرث isAdmin: true من Object.prototype
// → كل user يصبح admin

// أيضاً — Guard يقرأ من req.headers بثقة
return req.headers['x-user-id'] === req.params.id;
// المهاجم يضيف header (مع trust proxy)

// كثير من tutorials يكتب
JwtModule.register({ secret: 'secret' });

// خطأ — نفس الـ secret في dev و prod
// خطأ — لا تحدد algorithms (يقبل HS256 و none و RS256 → key confusion)

// الصحيح
JwtModule.registerAsync({
  useFactory: () => ({
    secret: process.env.JWT_SECRET,           // قوي + per-env
    signOptions: { algorithm: 'HS256', expiresIn: '15m' },
    verifyOptions: { algorithms: ['HS256'] }   // قائمة صارمة
  }),
});

// أو RS256 مع public key
JwtModule.register({
  publicKey: fs.readFileSync('public.pem'),
  privateKey: fs.readFileSync('private.pem'),
  signOptions: { algorithm: 'RS256', expiresIn: '15m' },
  verifyOptions: { algorithms: ['RS256'] }
});

// @nestjs/throttler v5+
import { ThrottlerModule, ThrottlerGuard } from '@nestjs/throttler';

@Module({
  imports: [ThrottlerModule.forRoot([{ ttl: 60_000, limit: 100 }])],
  providers: [{ provide: APP_GUARD, useClass: ThrottlerGuard }],
})

// per-route override
@Throttle({ default: { ttl: 60_000, limit: 5 } })
@Post('login')
login(@Body() dto: LoginDto) { ... }

// IP source — احذر trust proxy
// throttler يستخدم req.ip؛ مع trust proxy خاطئ يستطيع المهاجم تزوير IP

import { ApolloDriver, ApolloDriverConfig } from '@nestjs/apollo';
import depthLimit from 'graphql-depth-limit';
import { createComplexityRule, simpleEstimator } from 'graphql-query-complexity';

GraphQLModule.forRoot<ApolloDriverConfig>({
  driver: ApolloDriver,
  introspection: process.env.NODE_ENV !== 'production',
  playground: false,
  validationRules: [
    depthLimit(7),
    createComplexityRule({
      maximumComplexity: 1000,
      estimators: [simpleEstimator({ defaultComplexity: 1 })],
    }),
  ],
});

// خطر — gateway بدون auth
@WebSocketGateway()
export class ChatGateway {
  @SubscribeMessage('msg')
  handleMessage(client: Socket, payload: any) {
    this.server.emit('msg', payload);   // broadcast لكل user
  }
}

// أي user متصل (حتى دون login) يستطيع broadcast
// PoC: socket.io-client ثم emit('msg', '<script>...</script>')

// الإصلاح
@UseGuards(WsJwtGuard)               // Guard مخصّص للـ WS
@WebSocketGateway({ cors: { origin: ['https://app.target.gov'] } })

// JWT في handshake
io.use((socket, next) => {
  const token = socket.handshake.auth.token;
  try {
    socket.data.user = jwt.verify(token, secret);
    next();
  } catch { next(new Error('unauthorized')); }
});

// خطر — يقبل أي ملف
@Post('avatar')
@UseInterceptors(FileInterceptor('file'))
upload(@UploadedFile() file: Express.Multer.File) {
  fs.writeFileSync(`./uploads/${file.originalname}`, file.buffer);
  // path traversal عبر originalname: "../../etc/cron.d/x"
}

// آمن
@Post('avatar')
@UseInterceptors(FileInterceptor('file', {
  storage: diskStorage({
    destination: './uploads',
    filename: (req, file, cb) => cb(null, `${randomUUID()}.${extname(file.originalname).slice(1)}`),
  }),
  limits: { fileSize: 2 * 1024 * 1024 },
  fileFilter: (req, file, cb) => {
    if (!['image/png','image/jpeg','image/webp'].includes(file.mimetype)) {
      return cb(new BadRequestException('bad mime'), false);
    }
    cb(null, true);
  },
}))
upload(@UploadedFile(new ParseFilePipe({
  validators: [
    new MaxFileSizeValidator({ maxSize: 2 * 1024 * 1024 }),
    new FileTypeValidator({ fileType: /^image\/(png|jpeg|webp)$/ }),
  ],
})) file: Express.Multer.File) { ... }

// + content-type magic byte check (file-type lib)
// + virus scan (clamav)
// + serve من CDN منفصل، ليس من نفس origin (يمنع HTML/JS upload XSS)

// TypeORM raw query — خطر
this.users.query(`SELECT * FROM users WHERE id = ${req.params.id}`);
// SQLi مباشر

// آمن — parameters
this.users.query('SELECT * FROM users WHERE id = $1', [req.params.id]);
// أو QueryBuilder
this.users.createQueryBuilder('u').where('u.id = :id', { id }).getOne();

// Prisma — أساساً آمن، لكن $queryRawUnsafe خطر
prisma.$queryRawUnsafe(`SELECT * FROM ${table}`);   // SQLi
prisma.$queryRaw`SELECT * FROM users WHERE id = ${id}`;   // آمن (template tag)

// Prisma — extended raw filter بـ JSON
prisma.user.findMany({ where: req.body.where });   // مهاجم يضع OR / AND معقّدة
// قيّد الـ where لـ DTO معروف

import { NestFactory } from '@nestjs/core';
import { ValidationPipe, VersioningType } from '@nestjs/common';
import helmet from 'helmet';
import compression from 'compression';
import cookieParser from 'cookie-parser';

async function bootstrap() {
  const app = await NestFactory.create(AppModule, {
    logger: ['error', 'warn', 'log'],
  });

  app.use(helmet());
  app.use(compression());
  app.use(cookieParser());
  app.set('trust proxy', 1);

  app.enableCors({
    origin: ['https://app.target.gov'],
    credentials: true,
    methods: ['GET','POST','PUT','PATCH','DELETE'],
  });

  app.useGlobalPipes(new ValidationPipe({
    whitelist: true,
    forbidNonWhitelisted: true,
    forbidUnknownValues: true,
    transform: true,
    transformOptions: { enableImplicitConversion: false },
  }));

  app.enableVersioning({ type: VersioningType.URI });
  app.setGlobalPrefix('api');

  // graceful shutdown — هام لـ Kubernetes
  app.enableShutdownHooks();

  await app.listen(3000);
}
bootstrap();