Pompelmi-Befehle

Umfassende Pompelmi-Datei-Upload-Sicherheitsscan-Befehle für Node.js-Anwendungsschutz.

Installation

Befehl	Beschreibung
`npm install pompelmi`	Pompelmi via npm installieren
`yarn add pompelmi`	Pompelmi via Yarn installieren
`pnpm add pompelmi`	Pompelmi via pnpm installieren
`bun add pompelmi`	Pompelmi via Bun installieren

Grundlegende Konfiguration (Express)

const express = require('express');
const { createScanner } = require('pompelmi');

const app = express();
const scanner = createScanner({
  maxFileSize: '10mb',
  allowedExtensions: ['.pdf', '.png', '.jpg', '.docx'],
});

app.post('/upload', scanner.middleware(), (req, res) => {
  res.json({ files: req.files });
});

Framework-Adapter

Framework	Beschreibung
`pompelmi/express`	Express.js-Middleware-Adapter
`pompelmi/koa`	Koa-Middleware-Adapter
`pompelmi/next`	Next.js-API-Route-Adapter
`pompelmi/nitro`	Nuxt/Nitro-Adapter
`pompelmi/fastify`	Fastify-Plugin-Adapter

Scanner-Konfiguration

Option	Beschreibung
`maxFileSize: '10mb'`	Maximal zulässige Dateigröße
`allowedExtensions: ['.pdf', '.png']`	Whitelist der zulässigen Dateierweiterungen
`blockedExtensions: ['.exe', '.bat']`	Blacklist der blockierten Erweiterungen
`allowedMimeTypes: ['image/png']`	Whitelist der zulässigen MIME-Typen
`scanTimeout: 30000`	Scan-Timeout in Millisekunden
`tempDir: '/tmp/pompelmi'`	Temporäres Verzeichnis zum Scannen
`preserveOriginalName: true`	Ursprünglichen Dateinamen behalten

YARA-Integration

Option	Beschreibung
`yara: { enabled: true }`	YARA-Regelscanning aktivieren
`yara: { rules: './rules/' }`	Pfad zum benutzerdefinierten YARA-Regelverzeichnis
`yara: { builtinRules: true }`	Integrierte Malware-Erkennungsregeln verwenden
`yara: { timeout: 10000 }`	YARA-Scan-Timeout
Benutzerdefinierte YARA-Regeldatei	`.yar` Dateien für benutzerdefinierte Erkennungen schreiben

Archive-Schutz

Option	Beschreibung
`archive: { enabled: true }`	Archive-Inspektion aktivieren
`archive: { maxDepth: 3 }`	Maximale Rekursionstiefe für verschachtelte Archive
`archive: { maxFiles: 100 }`	Maximale Dateien im Archive
`archive: { maxRatio: 100 }`	Max Kompressionsrate (Zip-Bomb-Schutz)
`archive: { maxSize: '100mb' }`	Max extrahierte Gesamtgröße
`archive: { formats: ['zip', 'tar', 'gz'] }`	Unterstützte Archive-Formate

Sicherheitsrichtlinien

Richtlinie	Beschreibung
`policy: 'strict'`	Alles verdächtig blockieren (empfohlen)
`policy: 'moderate'`	Bekannte Malware blockieren, vor verdächtig warnen
`policy: 'permissive'`	Nur bestätigte Malware blockieren
Benutzerdefinierte Richtlinienfunktion	Eigene Accept/Reject-Logik definieren

MIME-Typ-Validierung

Check	Beschreibung
Extension-Validierung	Dateierweiterung gegen Allowlist überprüfen
Magic-Byte-Erkennung	Dateityp nach Content-Bytes überprüfen
MIME-Typ-Überprüfung	Serverseitige MIME-Typ-Überprüfung
Doppel-Erweiterungs-Erkennung	`file.pdf.exe` Tricks erkennen
Null-Byte-Erkennung	Null-Byte-Injektionen in Dateinamen blockieren
Content-Type-Mismatch	Erweiterungs-/Content-Abweichungen erkennen

Event-Hooks

Event	Beschreibung
`scanner.on('scan:start', fn)`	Beim Scan-Start ausgelöst
`scanner.on('scan:complete', fn)`	Beim Scan-Ende ausgelöst
`scanner.on('scan:reject', fn)`	Wenn Datei abgelehnt wird ausgelöst
`scanner.on('scan:accept', fn)`	Wenn Datei alle Checks passiert ausgelöst
`scanner.on('scan:error', fn)`	Bei Scan-Fehler ausgelöst
`scanner.on('yara:match', fn)`	Wenn YARA-Regel matched ausgelöst

Scan-Ergebnisse

Property	Beschreibung
`result.safe`	Boolean: Datei hat alle Checks bestanden
`result.threats`	Array der erkannten Bedrohungen
`result.mimeType`	Erkannter MIME-Typ
`result.extension`	Dateierweiterung
`result.size`	Dateigröße in Bytes
`result.hash`	SHA-256-Hash der Datei
`result.scanTime`	Zeit zum Scannen (ms)
`result.yaraMatches`	YARA-Regel-Matches (falls aktiviert)

Express-Middleware-Beispiel

const { createScanner } = require('pompelmi');

const scanner = createScanner({
  maxFileSize: '5mb',
  allowedExtensions: ['.pdf', '.png', '.jpg'],
  yara: { enabled: true, builtinRules: true },
  archive: { enabled: true, maxDepth: 2 },
  policy: 'strict',
});

// Als Middleware
app.post('/upload', scanner.middleware(), handleUpload);

// Manuelles Scannen
app.post('/upload', async (req, res) => {
  const result = await scanner.scan(req.file.buffer, {
    filename: req.file.originalname,
  });

  if (!result.safe) {
    return res.status(400).json({
      error: 'File rejected',
      threats: result.threats,
    });
  }

  // Sichere Datei verarbeiten...
});

Koa-Adapter-Beispiel

const { createScanner } = require('pompelmi/koa');

const scanner = createScanner({
  maxFileSize: '10mb',
  allowedMimeTypes: ['application/pdf', 'image/*'],
});

router.post('/upload', scanner.middleware(), async (ctx) => {
  ctx.body = { files: ctx.request.files };
});

Next.js-API-Route-Beispiel

import { createScanner } from 'pompelmi/next';

const scanner = createScanner({
  maxFileSize: '5mb',
  allowedExtensions: ['.pdf', '.png'],
});

export default scanner.handler(async (req, res) => {
  const files = req.files;
  res.json({ uploaded: files.length });
});

CLI-Scanning

Befehl	Beschreibung
`npx pompelmi scan <file>`	Einzelne Datei scannen
`npx pompelmi scan ./uploads/`	Verzeichnis von Dateien scannen
`npx pompelmi scan --yara <file>`	Mit YARA-Regeln scannen
`npx pompelmi scan --json <file>`	Ergebnisse als JSON ausgeben
`npx pompelmi rules list`	Verfügbare YARA-Regeln auflisten
`npx pompelmi rules update`	Integrierte YARA-Regeln aktualisieren

Tipps und Best Practices

Tipp	Beschreibung
Strikte Richtlinie in Produktion verwenden	Alles verdächtige blockieren
YARA-Regeln aktivieren	Bekannte Malware-Signaturen erkennen
Archive-Limits setzen	Zip-Bombs und verschachtelte Payloads verhindern
MIME-Typen auf Server-Seite validieren	Nicht auf Client-Content-Type vertrauen
Doppel-Erweiterungen überprüfen	`file.pdf.exe` Muster blockieren
Angemessene Größenlimits setzen	Ressourcenerschöpfung verhindern
Im Speicher scannen	Vertraute Dateien nicht auf Disk schreiben
Scan-Events überwachen	Ablehnungen protokollieren und alarmieren
YARA-Regeln regelmäßig aktualisieren	Mit Threat-Intelligence aktuell bleiben
Allowlists über Blocklists verwenden	Whitelist-Ansatz ist sicherer als Blacklist