15 Sicherheit in NestJS

// Ein praktisches Beispiel für das CIA-Triad in Code
@Injectable()
export class SecureDataService {
  constructor(
    private readonly encryptionService: EncryptionService, // Für Vertraulichkeit
    private readonly auditService: AuditService, // Für Integrität
    private readonly healthService: HealthService, // Für Verfügbarkeit
  ) {}

  async processUserData(userId: string, data: any) {
    // Vertraulichkeit: Daten verschlüsseln bevor sie gespeichert werden
    const encryptedData = await this.encryptionService.encrypt(data);
    
    // Integrität: Jeden Zugriff protokollieren
    await this.auditService.logDataAccess(userId, 'READ', data.type);
    
    // Verfügbarkeit: System-Gesundheit überprüfen
    if (!await this.healthService.isSystemHealthy()) {
      throw new ServiceUnavailableException('System temporarily unavailable');
    }
    
    return encryptedData;
  }
}

// Beispiel für Defense in Depth in einer NestJS-Anwendung
@Controller('users')
@UseGuards(AuthGuard) // Erste Verteidigungslinie: Authentifizierung
@UseInterceptors(RateLimitInterceptor) // Zweite Linie: Rate Limiting
export class UsersController {
  
  @Post()
  @UseGuards(RolesGuard) // Dritte Linie: Autorisierung
  @UsePipes(ValidationPipe) // Vierte Linie: Input-Validierung
  async createUser(
    @Body() createUserDto: CreateUserDto, // DTO mit eingebauter Validierung
  ) {
    // Fünfte Linie: Business Logic Validierung
    if (await this.userService.emailExists(createUserDto.email)) {
      throw new ConflictException('Email bereits registriert');
    }
    
    // Sechste Linie: Sichere Datenverarbeitung
    const sanitizedData = this.sanitizationService.sanitize(createUserDto);
    
    return this.userService.create(sanitizedData);
  }
}

// So sieht die JWT-Implementierung in NestJS aus
@Injectable()
export class JwtAuthService {
  constructor(
    private readonly jwtService: JwtService,
    private readonly userService: UserService,
  ) {}

  async generateTokens(user: User): Promise<TokenPair> {
    // Der Payload - die Informationen, die wir im Token speichern wollen
    // Denken Sie daran: Alles hier kann von jedem gelesen werden!
    const payload = {
      sub: user.id, // 'sub' steht für 'subject' - das ist ein Standard-Feld
      email: user.email,
      roles: user.roles,
      // Niemals Passwörter oder andere sensible Daten hier speichern!
    };

    // Der Access Token - wie ein Tagespass, der schnell abläuft
    const accessToken = await this.jwtService.signAsync(payload, {
      expiresIn: '15m', // Kurze Lebensdauer für Sicherheit
      secret: process.env.JWT_ACCESS_SECRET,
    });

    // Der Refresh Token - wie eine Jahreskarte, die länger gültig ist
    const refreshToken = await this.jwtService.signAsync(
      { sub: user.id, tokenType: 'refresh' },
      {
        expiresIn: '7d', // Längere Lebensdauer
        secret: process.env.JWT_REFRESH_SECRET, // Anderer Schlüssel!
      }
    );

    return { accessToken, refreshToken };
  }

  async validateToken(token: string): Promise<User> {
    try {
      // Hier überprüfen wir die "Unterschrift" auf dem digitalen Ausweis
      const payload = await this.jwtService.verifyAsync(token, {
        secret: process.env.JWT_ACCESS_SECRET,
      });

      // Zusätzliche Sicherheit: Prüfen wir, ob der Benutzer noch existiert
      const user = await this.userService.findById(payload.sub);
      if (!user || !user.isActive) {
        throw new UnauthorizedException('Benutzer nicht gefunden oder deaktiviert');
      }

      return user;
    } catch (error) {
      // Wenn die Überprüfung fehlschlägt, ist der Token ungültig
      throw new UnauthorizedException('Ungültiger Token');
    }
  }
}

@Injectable()
export class TokenRefreshService {
  constructor(
    private readonly jwtService: JwtService,
    private readonly userService: UserService,
  ) {}

  async refreshTokens(refreshToken: string): Promise<TokenPair> {
    try {
      // Schritt 1: Den Refresh Token überprüfen
      const payload = await this.jwtService.verifyAsync(refreshToken, {
        secret: process.env.JWT_REFRESH_SECRET,
      });

      // Schritt 2: Sicherstellen, dass es wirklich ein Refresh Token ist
      if (payload.tokenType !== 'refresh') {
        throw new UnauthorizedException('Das ist kein gültiger Refresh Token');
      }

      // Schritt 3: Den Benutzer aus der Datenbank laden
      const user = await this.userService.findById(payload.sub);
      if (!user || !user.isActive) {
        throw new UnauthorizedException('Benutzer nicht gefunden');
      }

      // Schritt 4: Neue Tokens generieren
      // Das ist wie das Ausstellen neuer Ausweise mit aktualisierten Informationen
      return this.generateTokens(user);
    } catch (error) {
      throw new UnauthorizedException('Refresh Token ist ungültig oder abgelaufen');
    }
  }
}

// Ein grundlegender Authentication Guard
@Injectable()
export class JwtAuthGuard implements CanActivate {
  constructor(
    private readonly jwtService: JwtService,
    private readonly userService: UserService,
  ) {}

  async canActivate(context: ExecutionContext): Promise<boolean> {
    // Schritt 1: Den HTTP-Request aus dem Kontext extrahieren
    const request = context.switchToHttp().getRequest();
    
    // Schritt 2: Nach dem Authorization Header suchen
    const authHeader = request.headers.authorization;
    
    // Schritt 3: Prüfen, ob überhaupt ein Header vorhanden ist
    if (!authHeader) {
      throw new UnauthorizedException('Kein Authorization Header gefunden');
    }

    // Schritt 4: Den Token aus dem Header extrahieren
    // Format: "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
    const token = this.extractTokenFromHeader(authHeader);
    
    if (!token) {
      throw new UnauthorizedException('Kein gültiger Token im Authorization Header');
    }

    try {
      // Schritt 5: Den Token validieren
      const payload = await this.jwtService.verifyAsync(token, {
        secret: process.env.JWT_ACCESS_SECRET,
      });

      // Schritt 6: Den Benutzer aus der Datenbank laden
      const user = await this.userService.findById(payload.sub);
      
      if (!user || !user.isActive) {
        throw new UnauthorizedException('Benutzer nicht gefunden oder deaktiviert');
      }

      // Schritt 7: Den Benutzer für nachfolgende Handler verfügbar machen
      request.user = user;
      
      // Wenn wir hier ankommen, ist alles in Ordnung
      return true;
    } catch (error) {
      // Wenn irgendwas schief geht, verweigern wir den Zugang
      throw new UnauthorizedException('Token-Validierung fehlgeschlagen');
    }
  }

  private extractTokenFromHeader(authHeader: string): string | null {
    // "Bearer token123" -> ["Bearer", "token123"]
    const [type, token] = authHeader.split(' ');
    
    // Wir erwarten das Format "Bearer <token>"
    return type === 'Bearer' ? token : null;
  }
}

// Ein Roles Guard, der überprüft, ob der Benutzer die richtige Rolle hat
@Injectable()
export class RolesGuard implements CanActivate {
  constructor(private readonly reflector: Reflector) {}

  canActivate(context: ExecutionContext): boolean {
    // Schritt 1: Schauen, welche Rollen für diese Route erforderlich sind
    // Das wird durch den @Roles() Decorator definiert
    const requiredRoles = this.reflector.getAllAndOverride<string[]>('roles', [
      context.getHandler(), // Die spezifische Methode
      context.getClass(),   // Die ganze Controller-Klasse
    ]);

    // Schritt 2: Wenn keine Rollen erforderlich sind, lassen wir jeden durch
    if (!requiredRoles || requiredRoles.length === 0) {
      return true;
    }

    // Schritt 3: Den Benutzer aus dem Request holen
    // Dieser wurde vom AuthGuard dort platziert
    const request = context.switchToHttp().getRequest();
    const user = request.user;

    // Schritt 4: Prüfen, ob der Benutzer überhaupt eingeloggt ist
    if (!user) {
      throw new UnauthorizedException('Benutzer nicht authentifiziert');
    }

    // Schritt 5: Prüfen, ob der Benutzer mindestens eine der erforderlichen Rollen hat
    const hasRequiredRole = requiredRoles.some(role => user.roles?.includes(role));
    
    if (!hasRequiredRole) {
      throw new ForbiddenException(
        `Zugriff verweigert. Erforderliche Rollen: ${requiredRoles.join(', ')}`
      );
    }

    return true;
  }
}

// Der Decorator, der definiert, welche Rollen erforderlich sind
export const Roles = (...roles: string[]) => SetMetadata('roles', roles);

// So wird es in einem Controller verwendet
@Controller('admin')
@UseGuards(JwtAuthGuard, RolesGuard) // Wichtig: Reihenfolge beachten!
export class AdminController {
  
  @Get('users')
  @Roles('admin', 'moderator') // Nur Admins und Moderatoren
  async getAllUsers() {
    return this.userService.findAll();
  }

  @Delete('users/:id')
  @Roles('admin') // Nur Admins können Benutzer löschen
  async deleteUser(@Param('id') id: string) {
    return this.userService.remove(id);
  }
}

// Ein komplexer Guard, der verschiedene Bedingungen prüft
@Injectable()
export class ResourceOwnershipGuard implements CanActivate {
  constructor(
    private readonly userService: UserService,
    private readonly postService: PostService,
  ) {}

  async canActivate(context: ExecutionContext): Promise<boolean> {
    const request = context.switchToHttp().getRequest();
    const user = request.user;
    
    // Schritt 1: Basis-Authentifizierung prüfen
    if (!user) {
      throw new UnauthorizedException('Benutzer nicht authentifiziert');
    }

    // Schritt 2: Admins dürfen alles
    if (user.roles?.includes('admin')) {
      return true;
    }

    // Schritt 3: Die ID der Ressource aus der URL extrahieren
    const resourceId = request.params.id;
    if (!resourceId) {
      throw new BadRequestException('Ressourcen-ID nicht gefunden');
    }

    // Schritt 4: Die Ressource aus der Datenbank laden
    const post = await this.postService.findById(resourceId);
    if (!post) {
      throw new NotFoundException('Ressource nicht gefunden');
    }

    // Schritt 5: Prüfen, ob der Benutzer der Besitzer ist
    if (post.authorId === user.id) {
      return true;
    }

    // Schritt 6: Weitere Geschäftslogik...
    // Vielleicht dürfen Moderatoren auch zugreifen?
    if (user.roles?.includes('moderator') && post.status === 'published') {
      return true;
    }

    // Wenn nichts zutrifft, Zugriff verweigern
    throw new ForbiddenException('Sie haben keine Berechtigung für diese Ressource');
  }
}

// Ein umfassender XSS-Schutz-Service
@Injectable()
export class XssProtectionService {
  constructor() {
    // DOMPurify ist eine bewährte Bibliothek zum Säubern von HTML
    // Es ist wie ein Filter, der nur sichere HTML-Elemente durchlässt
  }

  sanitizeHtml(input: string): string {
    if (!input) return '';

    // DOMPurify entfernt alle gefährlichen Elemente und Attribute
    return DOMPurify.sanitize(input, {
      // Wir erlauben nur sehr grundlegende HTML-Tags
      ALLOWED_TAGS: ['b', 'i', 'em', 'strong', 'p', 'br'],
      ALLOWED_ATTR: [], // Keine Attribute erlaubt
      KEEP_CONTENT: true, // Behalte den Textinhalt, auch wenn Tags entfernt werden
    });
  }

  escapeHtml(input: string): string {
    if (!input) return '';

    // Diese Funktion verwandelt gefährliche Zeichen in harmlose HTML-Entities
    // < wird zu &lt;, > wird zu &gt;, etc.
    return input
      .replace(/&/g, '&amp;')   // & muss zuerst ersetzt werden!
      .replace(/</g, '&lt;')    // < verhindert HTML-Tags
      .replace(/>/g, '&gt;')    // > vervollständigt den Schutz
      .replace(/"/g, '&quot;')  // " verhindert Attribute-Injection
      .replace(/'/g, '&#x27;'); // ' verhindert JavaScript-Injection
  }

  sanitizeForAttribute(input: string): string {
    if (!input) return '';

    // Für HTML-Attribute sind andere Zeichen gefährlich
    // Wir entfernen alles, was JavaScript-Code enthalten könnte
    return input
      .replace(/[<>"']/g, '') // Entferne gefährliche Zeichen komplett
      .replace(/javascript:/gi, '') // Entferne javascript: URLs
      .replace(/on\w+=/gi, ''); // Entferne Event-Handler wie onclick=
  }

  validateUrl(url: string): boolean {
    if (!url) return false;

    try {
      const parsedUrl = new URL(url);
      
      // Nur HTTP und HTTPS URLs erlauben
      // javascript:, data:, file: etc. sind potentiell gefährlich
      const allowedProtocols = ['http:', 'https:', 'mailto:', 'tel:'];
      
      return allowedProtocols.includes(parsedUrl.protocol);
    } catch {
      // Wenn die URL nicht geparst werden kann, ist sie ungültig
      return false;
    }
  }
}

// Ein Pipe, der automatisch alle Eingaben säubert
@Injectable()
export class XssSanitizationPipe implements PipeTransform {
  constructor(private readonly xssProtection: XssProtectionService) {}

  transform(value: any): any {
    if (typeof value === 'string') {
      return this.xssProtection.sanitizeHtml(value);
    }

    if (typeof value === 'object' && value !== null) {
      return this.sanitizeObject(value);
    }

    return value;
  }

  private sanitizeObject(obj: any): any {
    if (Array.isArray(obj)) {
      return obj.map(item => this.transform(item));
    }

    const sanitized = {};
    for (const key in obj) {
      if (obj.hasOwnProperty(key)) {
        sanitized[key] = this.transform(obj[key]);
      }
    }

    return sanitized;
  }
}

// So verwenden wir den XSS-Schutz in einem Controller
@Controller('posts')
export class PostsController {
  constructor(
    private readonly postsService: PostsService,
    private readonly xssProtection: XssProtectionService,
  ) {}

  @Post()
  @UsePipes(XssSanitizationPipe) // Automatische Säuberung aller Eingaben
  async createPost(@Body() createPostDto: CreatePostDto) {
    // Zusätzliche manuelle Säuberung für besonders kritische Felder
    const sanitizedContent = this.xssProtection.sanitizeHtml(createPostDto.content);
    const sanitizedTitle = this.xssProtection.escapeHtml(createPostDto.title);

    return this.postsService.create({
      ...createPostDto,
      title: sanitizedTitle,
      content: sanitizedContent,
    });
  }
}

// CSP-Middleware für NestJS
@Injectable()
export class CspMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction) {
    // Generiere eine einmalige Nummer (Nonce) für jeden Request
    // Das ist wie ein Geheimcode, den nur unser Server kennt
    const nonce = this.generateNonce();
    
    // Mache die Nonce für Templates verfügbar
    res.locals.cspNonce = nonce;

    // Definiere die CSP-Regeln
    const cspDirectives = [
      "default-src 'self'", // Standardmäßig nur Ressourcen von unserer eigenen Domain
      `script-src 'self' 'nonce-${nonce}'`, // JavaScript nur von uns und mit korrekter Nonce
      "style-src 'self' 'unsafe-inline' https://fonts.googleapis.com", // CSS-Regeln
      "img-src 'self' data: https:", // Bilder von uns, Data-URLs und HTTPS-Seiten
      "font-src 'self' https://fonts.gstatic.com", // Schriftarten
      "connect-src 'self'", // AJAX-Requests nur zu unserer Domain
      "frame-src 'none'", // Keine iframes erlaubt
      "object-src 'none'", // Keine Flash/Java-Objekte
      "base-uri 'self'", // Base-Tag kann nur unsere Domain referenzieren
      "form-action 'self'", // Formulare können nur an unsere Domain gesendet werden
    ];

    // Setze den CSP-Header
    res.setHeader('Content-Security-Policy', cspDirectives.join('; '));
    
    next();
  }

  private generateNonce(): string {
    // Erstelle eine kryptographisch sichere Zufallszeichenkette
    return crypto.randomBytes(16).toString('base64');
  }
}

// In einem Template (falls Sie Server-Side Rendering verwenden):
// <script nonce="{{cspNonce}}">
//   // Nur JavaScript mit der korrekten Nonce wird ausgeführt
//   console.log('Dieses Script ist erlaubt');
// </script>

<!-- Diese Form ist auf einer bösartigen Website versteckt -->
<form action="https://meine-bank.de/transfer" method="POST" id="hiddenForm">
  <input type="hidden" name="to" value="angreifer-konto">
  <input type="hidden" name="amount" value="1000">
</form>
<script>
  // Diese Form wird automatisch abgesendet, wenn Sie die Seite besuchen
  document.getElementById('hiddenForm').submit();
</script>

// CSRF-Token-Service
@Injectable()
export class CsrfService {
  private readonly secretKey: string;

  constructor() {
    this.secretKey = process.env.CSRF_SECRET || 'your-secret-key';
  }

  generateToken(sessionId: string): string {
    // Erstelle einen Token, der an die Session gebunden ist
    const timestamp = Date.now().toString();
    const data = `${sessionId}:${timestamp}`;
    
    // Verwende HMAC (Hash-based Message Authentication Code)
    // Das ist wie eine digitale Unterschrift, die nicht gefälscht werden kann
    const hmac = crypto.createHmac('sha256', this.secretKey);
    hmac.update(data);
    const signature = hmac.digest('hex');
    
    // Der Token besteht aus Zeitstempel und Signatur
    return `${timestamp}.${signature}`;
  }

  validateToken(token: string, sessionId: string): boolean {
    if (!token || !sessionId) {
      return false;
    }

    try {
      // Token aufteilen
      const [timestamp, signature] = token.split('.');
      
      if (!timestamp || !signature) {
        return false;
      }

      // Prüfe, ob der Token nicht zu alt ist (z.B. maximal 2 Stunden)
      const tokenAge = Date.now() - parseInt(timestamp);
      const maxAge = 2 * 60 * 60 * 1000; // 2 Stunden in Millisekunden
      
      if (tokenAge > maxAge) {
        return false; // Token ist abgelaufen
      }

      // Erstelle die erwartete Signatur
      const data = `${sessionId}:${timestamp}`;
      const hmac = crypto.createHmac('sha256', this.secretKey);
      hmac.update(data);
      const expectedSignature = hmac.digest('hex');

      // Verwende timingSafeEqual um Timing-Angriffe zu verhindern
      // Das ist wichtig für kryptographische Vergleiche!
      return crypto.timingSafeEqual(
        Buffer.from(signature, 'hex'),
        Buffer.from(expectedSignature, 'hex')
      );
    } catch (error) {
      return false;
    }
  }
}

// CSRF-Guard
@Injectable()
export class CsrfGuard implements CanActivate {
  constructor(
    private readonly csrfService: CsrfService,
    private readonly reflector: Reflector,
  ) {}

  canActivate(context: ExecutionContext): boolean {
    const request = context.switchToHttp().getRequest();
    
    // Prüfe, ob CSRF-Schutz für diese Route deaktiviert ist
    const skipCsrf = this.reflector.get<boolean>('skipCsrf', context.getHandler());
    if (skipCsrf) {
      return true;
    }

    // Sichere HTTP-Methoden (GET, HEAD, OPTIONS) sind normalerweise sicher
    // da sie keine Änderungen verursachen sollten
    const safeMethods = ['GET', 'HEAD', 'OPTIONS'];
    if (safeMethods.includes(request.method)) {
      return true;
    }

    // Für unsichere Methoden (POST, PUT, DELETE) prüfen wir den CSRF-Token
    const csrfToken = request.headers['x-csrf-token'] || 
                     request.body._csrf || 
                     request.query._csrf;
    
    const sessionId = request.session?.id || request.sessionID;

    if (!this.csrfService.validateToken(csrfToken, sessionId)) {
      throw new ForbiddenException('Invalid CSRF token');
    }

    return true;
  }
}

// Decorator um CSRF-Schutz zu überspringen (z.B. für APIs)
export const SkipCsrf = () => SetMetadata('skipCsrf', true);

// Controller-Beispiel
@Controller('posts')
@UseGuards(CsrfGuard)
export class PostsController {
  constructor(
    private readonly postsService: PostsService,
    private readonly csrfService: CsrfService,
  ) {}

  @Get('new')
  showCreateForm(@Req() request, @Res() response) {
    // Generiere einen CSRF-Token für das Formular
    const csrfToken = this.csrfService.generateToken(request.sessionID);
    
    // In einem echten Szenario würden Sie den Token an Ihr Template weitergeben
    response.render('create-post', { csrfToken });
  }

  @Post()
  // CSRF-Guard wird automatisch angewendet
  async createPost(@Body() createPostDto: CreatePostDto) {
    return this.postsService.create(createPostDto);
  }

  @Post('api')
  @SkipCsrf() // API-Endpunkte verwenden oft andere Authentifizierungsmethoden
  async createPostApi(@Body() createPostDto: CreatePostDto) {
    return this.postsService.create(createPostDto);
  }
}

// Double Submit Cookie CSRF-Schutz
@Injectable()
export class DoubleSubmitCsrfMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction) {
    // Für GET-Requests: Setze CSRF-Cookie und Token
    if (req.method === 'GET') {
      let csrfToken = req.cookies['csrf-token'];
      
      // Wenn kein Token existiert, erstelle einen neuen
      if (!csrfToken) {
        csrfToken = crypto.randomBytes(32).toString('hex');
        
        // Setze das Cookie mit sicheren Optionen
        res.cookie('csrf-token', csrfToken, {
          httpOnly: false, // Muss von JavaScript lesbar sein!
          secure: process.env.NODE_ENV === 'production',
          sameSite: 'strict',
          maxAge: 24 * 60 * 60 * 1000, // 24 Stunden
        });
      }
      
      // Mache den Token für Templates verfügbar
      res.locals.csrfToken = csrfToken;
    }

    // Für POST/PUT/DELETE: Validiere Token
    if (['POST', 'PUT', 'DELETE', 'PATCH'].includes(req.method)) {
      const cookieToken = req.cookies['csrf-token'];
      const headerToken = req.headers['x-csrf-token'];
      
      // Beide Tokens müssen existieren und identisch sein
      if (!cookieToken || !headerToken || cookieToken !== headerToken) {
        res.status(403).json({ error: 'CSRF token mismatch' });
        return;
      }
    }

    next();
  }
}

// Frontend-JavaScript würde dann so aussehen:
/*
// Den Token aus dem Cookie lesen
function getCsrfToken() {
  const match = document.cookie.match(/csrf-token=([^;]+)/);
  return match ? match[1] : null;
}

// Bei AJAX-Requests den Token im Header senden
fetch('/api/posts', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-CSRF-Token': getCsrfToken()
  },
  body: JSON.stringify({ title: 'Mein Post', content: 'Inhalt...' })
});
*/

// Eine umfassende Input-Validation-Strategie
import { IsEmail, IsString, IsOptional, Length, Matches, IsEnum, IsDateString, ValidateNested, IsUrl, IsPhoneNumber } from 'class-validator';
import { Transform, Type } from 'class-transformer';

// Ein DTO (Data Transfer Object) mit umfassender Validierung
export class CreateUserDto {
  @IsEmail({}, { 
    message: 'Bitte geben Sie eine gültige E-Mail-Adresse ein' 
  })
  @Transform(({ value }) => value?.toLowerCase().trim()) // Normalisiere die E-Mail
  email: string;

  @IsString({ message: 'Der Vorname muss ein Text sein' })
  @Length(2, 50, { 
    message: 'Der Vorname muss zwischen 2 und 50 Zeichen lang sein' 
  })
  @Transform(({ value }) => this.sanitizeString(value))
  firstName: string;

  @IsString({ message: 'Der Nachname muss ein Text sein' })
  @Length(2, 50, { 
    message: 'Der Nachname muss zwischen 2 und 50 Zeichen lang sein' 
  })
  @Transform(({ value }) => this.sanitizeString(value))
  lastName: string;

  @IsString({ message: 'Das Passwort muss ein Text sein' })
  @Length(8, 128, { 
    message: 'Das Passwort muss zwischen 8 und 128 Zeichen lang sein' 
  })
  @Matches(
    /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]/,
    {
      message: 'Das Passwort muss mindestens einen Kleinbuchstaben, einen Großbuchstaben, eine Zahl und ein Sonderzeichen enthalten'
    }
  )
  password: string;

  @IsOptional()
  @IsPhoneNumber('DE', { 
    message: 'Bitte geben Sie eine gültige deutsche Telefonnummer ein' 
  })
  phone?: string;

  @IsOptional()
  @IsUrl({}, { 
    message: 'Bitte geben Sie eine gültige URL ein' 
  })
  website?: string;

  @IsOptional()
  @IsEnum(['male', 'female', 'other'], { 
    message: 'Das Geschlecht muss male, female oder other sein' 
  })
  gender?: string;

  @IsOptional()
  @IsDateString({}, { 
    message: 'Bitte geben Sie ein gültiges Geburtsdatum ein' 
  })
  dateOfBirth?: string;

  @IsOptional()
  @ValidateNested()
  @Type(() => AddressDto)
  address?: AddressDto;

  // Hilfsmethode zur String-Säuberung
  private sanitizeString(value: string): string {
    if (!value) return value;
    
    // Entferne HTML-Tags und normalisiere Whitespace
    return value
      .replace(/<[^>]*>/g, '') // HTML-Tags entfernen
      .replace(/\s+/g, ' ') // Mehrfache Leerzeichen durch eines ersetzen
      .trim(); // Führende und nachgestellte Leerzeichen entfernen
  }
}

export class AddressDto {
  @IsString({ message: 'Die Straße muss ein Text sein' })
  @Length(1, 100, { message: 'Die Straße muss zwischen 1 und 100 Zeichen lang sein' })
  @Transform(({ value }) => this.sanitizeString(value))
  street: string;

  @IsString({ message: 'Die Stadt muss ein Text sein' })
  @Length(1, 50, { message: 'Die Stadt muss zwischen 1 und 50 Zeichen lang sein' })
  @Transform(({ value }) => this.sanitizeString(value))
  city: string;

  @IsString({ message: 'Die Postleitzahl muss ein Text sein' })
  @Matches(/^\d{5}$/, { 
    message: 'Die Postleitzahl muss genau 5 Ziffern haben' 
  })
  postalCode: string;

  @IsString({ message: 'Das Land muss ein Text sein' })
  @Length(2, 3, { message: 'Der Ländercode muss 2 oder 3 Zeichen lang sein' })
  @Transform(({ value }) => value?.toUpperCase())
  country: string;

  private sanitizeString(value: string): string {
    if (!value) return value;
    return value.replace(/<[^>]*>/g, '').replace(/\s+/g, ' ').trim();
  }
}

// Custom Validator: Prüft, ob eine E-Mail bereits existiert
import { registerDecorator, ValidationOptions, ValidatorConstraint, ValidatorConstraintInterface, ValidationArguments } from 'class-validator';
import { Injectable } from '@nestjs/common';
import { UsersService } from '../users/users.service';

@ValidatorConstraint({ name: 'isEmailUnique', async: true })
@Injectable()
export class IsEmailUniqueConstraint implements ValidatorConstraintInterface {
  constructor(private usersService: UsersService) {}

  async validate(email: string, args: ValidationArguments): Promise<boolean> {
    try {
      // Prüfe, ob bereits ein Benutzer mit dieser E-Mail existiert
      const existingUser = await this.usersService.findByEmail(email);
      return !existingUser; // Gib true zurück, wenn die E-Mail noch nicht verwendet wird
    } catch (error) {
      // Bei Datenbankfehlern nehmen wir an, dass die E-Mail verfügbar ist
      // In einem Produktionssystem könnten Sie hier anders entscheiden
      return true;
    }
  }

  defaultMessage(args: ValidationArguments): string {
    return 'Diese E-Mail-Adresse wird bereits verwendet';
  }
}

// Decorator-Funktion für einfache Verwendung
export function IsEmailUnique(validationOptions?: ValidationOptions) {
  return function (object: Object, propertyName: string) {
    registerDecorator({
      target: object.constructor,
      propertyName: propertyName,
      options: validationOptions,
      constraints: [],
      validator: IsEmailUniqueConstraint,
    });
  };
}

// Custom Validator: Prüft Passwort-Stärke nach eigenen Regeln
@ValidatorConstraint({ name: 'isStrongPassword' })
export class IsStrongPasswordConstraint implements ValidatorConstraintInterface {
  validate(password: string, args: ValidationArguments): boolean {
    if (!password) return false;

    // Unsere eigenen Regeln für starke Passwörter
    const hasMinLength = password.length >= 8;
    const hasMaxLength = password.length <= 128;
    const hasUpperCase = /[A-Z]/.test(password);
    const hasLowerCase = /[a-z]/.test(password);
    const hasNumbers = /\d/.test(password);
    const hasSpecialChar = /[!@#$%^&*(),.?":{}|<>]/.test(password);
    
    // Prüfe auf häufige Passwörter (vereinfachte Liste)
    const commonPasswords = [
      'password', '123456', '123456789', 'qwerty', 'abc123',
      'password123', 'admin', 'letmein', 'welcome', 'monkey'
    ];
    const isNotCommon = !commonPasswords.includes(password.toLowerCase());

    // Prüfe, ob das Passwort nicht nur sich wiederholende Zeichen enthält
    const isNotRepeating = !/^(.)\1+$/.test(password);

    return hasMinLength && hasMaxLength && hasUpperCase && hasLowerCase && 
           hasNumbers && hasSpecialChar && isNotCommon && isNotRepeating;
  }

  defaultMessage(args: ValidationArguments): string {
    return 'Das Passwort muss mindestens 8 Zeichen lang sein und Groß- und Kleinbuchstaben, Zahlen und Sonderzeichen enthalten. Verwenden Sie kein häufiges Passwort.';
  }
}

export function IsStrongPassword(validationOptions?: ValidationOptions) {
  return function (object: Object, propertyName: string) {
    registerDecorator({
      target: object.constructor,
      propertyName: propertyName,
      options: validationOptions,
      validator: IsStrongPasswordConstraint,
    });
  };
}

// Verwendung der Custom Validators
export class RegistrationDto {
  @IsEmail()
  @IsEmailUnique() // Unser custom validator
  email: string;

  @IsStrongPassword() // Unser custom validator
  password: string;

  // ... andere Felder
}

// Comprehensive File Upload Validation
@Injectable()
export class FileValidationPipe implements PipeTransform {
  private readonly maxSize = 5 * 1024 * 1024; // 5MB
  private readonly allowedMimeTypes = [
    'image/jpeg',
    'image/png', 
    'image/gif',
    'image/webp',
    'application/pdf',
    'text/plain',
    'application/msword',
    'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
  ];

  // Magic Numbers (Datei-Signaturen) für zusätzliche Sicherheit
  private readonly fileSignatures = {
    'image/jpeg': [0xFF, 0xD8, 0xFF],
    'image/png': [0x89, 0x50, 0x4E, 0x47],
    'image/gif': [0x47, 0x49, 0x46],
    'application/pdf': [0x25, 0x50, 0x44, 0x46], // %PDF
  };

  transform(file: Express.Multer.File): Express.Multer.File {
    if (!file) {
      throw new BadRequestException('Keine Datei hochgeladen');
    }

    // Schritt 1: Dateigröße prüfen
    if (file.size > this.maxSize) {
      throw new BadRequestException(
        `Datei ist zu groß. Maximum: ${this.maxSize / 1024 / 1024}MB`
      );
    }

    // Schritt 2: MIME-Type prüfen
    if (!this.allowedMimeTypes.includes(file.mimetype)) {
      throw new BadRequestException(
        `Dateityp nicht erlaubt: ${file.mimetype}. ` +
        `Erlaubte Typen: ${this.allowedMimeTypes.join(', ')}`
      );
    }

    // Schritt 3: Datei-Signatur prüfen (Magic Numbers)
    // Das verhindert, dass jemand eine schädliche Datei umbenennt
    if (!this.validateFileSignature(file)) {
      throw new BadRequestException(
        'Dateiinhalt entspricht nicht der Dateiendung'
      );
    }

    // Schritt 4: Dateinamen säubern
    file.originalname = this.sanitizeFilename(file.originalname);

    // Schritt 5: Auf schädliche Inhalte prüfen
    this.scanForMaliciousContent(file);

    return file;
  }

  private validateFileSignature(file: Express.Multer.File): boolean {
    const signature = this.fileSignatures[file.mimetype];
    if (!signature) {
      // Wenn wir keine Signatur haben, überspringen wir die Prüfung
      return true;
    }

    const buffer = file.buffer;
    if (buffer.length < signature.length) {
      return false;
    }

    // Prüfe, ob die ersten Bytes der Datei mit der erwarteten Signatur übereinstimmen
    return signature.every((byte, index) => buffer[index] === byte);
  }

  private sanitizeFilename(filename: string): string {
    // Entferne oder ersetze gefährliche Zeichen im Dateinamen
    return filename
      .replace(/[^a-zA-Z0-9.-]/g, '_') // Ersetze alles außer Buchstaben, Zahlen, Punkt und Bindestrich
      .replace(/\.+/g, '.') // Mehrfache Punkte durch einen ersetzen
      .replace(/^\.+|\.+$/g, '') // Punkte am Anfang und Ende entfernen
      .substring(0, 100); // Dateiname auf 100 Zeichen begrenzen
  }

  private scanForMaliciousContent(file: Express.Multer.File): void {
    const content = file.buffer.toString('utf8', 0, Math.min(file.buffer.length, 1000));
    
    // Suche nach verdächtigen Mustern
    const suspiciousPatterns = [
      /<script[^>]*>/i, // JavaScript
      /javascript:/i,
      /vbscript:/i,
      /on\w+\s*=/i, // Event-Handler wie onclick=
      /<?php/i, // PHP-Code
      /<%/i, // ASP/JSP-Code
    ];

    for (const pattern of suspiciousPatterns) {
      if (pattern.test(content)) {
        throw new BadRequestException(
          'Datei enthält potentiell schädlichen Code'
        );
      }
    }
  }
}

// Verwendung in einem Controller
@Controller('upload')
export class UploadController {
  
  @Post('avatar')
  @UseInterceptors(FileInterceptor('file'))
  async uploadAvatar(
    @UploadedFile(FileValidationPipe) file: Express.Multer.File,
    @Req() request,
  ) {
    // Zusätzliche Sicherheitsmaßnahme: Speichere die Datei außerhalb des Web-Root
    const secureFilename = `${Date.now()}-${crypto.randomBytes(16).toString('hex')}`;
    const securePath = path.join('/secure/uploads', secureFilename);
    
    // In einem echten System würden Sie die Datei hier speichern
    // und eine Referenz in der Datenbank anlegen
    
    return {
      message: 'Datei erfolgreich hochgeladen',
      originalName: file.originalname,
      size: file.size,
      secureId: secureFilename, // Nie den echten Pfad preisgeben!
    };
  }
}