Engineer a secure file upload backend with Tus protocol, malware scanning, EXIF…
- User
Engineer a secure file upload backend with Tus protocol, malware scanning, EXIF stripping, and auditing.
- Assistant
The user wants a secure file upload backend that:
- Implements the Tus protocol for resumable uploads.
- Performs malware scanning on uploaded files.
- Strips EXIF data from images.
- Includes auditing capabilities.
This requires:
- A server-side implementation (Node.js/Express is a good choice for simplicity and rich ecosystem).
- A Tus server implementation. There are several libraries:
tus-node-server,tus-js-client(for client, but server is needed).tus-node-serveris a popular choice. It supports file storage (local, S3, etc.) and hooks for validation. - Malware scanning: Integration with ClamAV (a popular open-source antivirus). Need a clamd client to scan files. Could use
clamscanornode-clam. - EXIF stripping: For images, we can use libraries like
sharporjimpto strip metadata. Since we're dealing with uploaded files, we can process them after upload. We might want to intercept the upload and process before final storage if possible, or process after upload and replace the file. The Tus server allows hooks. Tus protocol: upload file in chunks. We could scan each chunk? That's complex. Better to scan the complete file after upload is finished. Thetus-node-serverprovides events likeonFinishwhere we can get the file path. Then we can scan and process. But we need to handle failures: if malware found, delete the file. If EXIF stripping is needed, we could overwrite the file with a cleaned version (or store a cleaned version). But if the file is uploaded via Tus, it's stored as is. We can then move/rename/remove. - Auditing: Log every upload attempt, success/failure, metadata (user, IP, filename, size, scan results). Could use a database (SQLite or PostgreSQL). Or at least a file-based log with structured JSON. But better to show a minimal database integration for audit logs. Use an ORM like Prisma or Sequelize, or simple raw queries with
pg. For simplicity in code demonstration, perhaps use a lightweight SQLite withbetter-sqlite3or just write to a JSON log file? The request says "auditing", which implies persistence. I'd integrate a simple database table for audit logs. Usesqlite3for simplicity.
We also need to ensure security: validate file types, size limits, etc. The user didn't ask for those, but we can include basic checks. However, the prompt focuses on those four aspects. So we should emphasize those.
Architecture:
-
Express app.
-
Use
tus-node-serverset up as middleware or as a standalone server? Typically, you mount it at an endpoint. The library provides aTusServerclass that can be used as Express middleware. Example:app.use('/files', server.createMiddleware());Also configure storage: local filesystem (filesystempackage) or custom. We'll use local filesystem storage in a directory like./uploads. -
Configure hooks:
onFinishevent gets the file path and metadata. We'll then:- Scan the file using ClamAV (via
clamddeamon). Usenode-clamorclamscan. Since we need to scan the file, we need to interface with a running ClamAV daemon. We can useclamd.jsfromclamscanpackage. But many examples useclamscanpackage which can either use daemon or scan locally. We'll assume a clamd service is available on localhost:3310. Useclamdclient fromclamscanor separate. Actually,node-clamis a good package: it provides a simple interface to clamd. We'll usenode-clam. - If malware detected, delete file and log failure.
- If clean and image (based on mime type), strip EXIF using
sharp. - Then move the file to a final location (maybe we want to store in a separate "processed" directory) or overwrite original? Overwriting original after stripping EXIF is fine.
- Then log success with details.
- Scan the file using ClamAV (via
-
Audit logs: store in SQLite database with a table:
audit_logswith columns: id, timestamp, user_id (maybe from auth, but we can skip auth for demo), ip_address, file_name, file_size, file_type, status (success/failure), reason (if failure, e.g., malware), exif_stripped (boolean), path (or reference), etc. -
We need to consider asynchronous processes: scanning and EXIF stripping may take time. The
onFinishhook can be async? Looking attus-node-serverdocs: theonFinishevent signature:onFinish: (req, res, file) => .... It may expect synchronous? But we can do async; need to ensure we respond properly. The server will automatically respond with 204 after finish? Actually, after upload completes, the server returns 204 No Content. Our hook runs before that? TheonFinishis called after the file is fully uploaded and stored, but before the response is sent. If we do async, we must tell the server to wait? The library may not wait for async hooks; it might assume synchronous. However, theonFinishcan return a Promise? Need to check. Thetus-node-serveris based ontus-js-client? Actually, it's a Node implementation. Looking at its documentation: https://github.com/tus/tus-node-server. TheonFinishevent receives(req, res, file). It says: "This event is emitted after a file has been successfully uploaded. It can be used to process the file, e.g. virus scanning, metadata extraction, etc." It does not specify if async is supported but likely you can do async and then callres.end()? Actually, the server automatically sends a response after the event unless you callres.end()? Need to read source. But many examples show doing synchronous work quickly. For long-running tasks, they recommend background processing. Indeed, the docs say: "If you need to perform long-running tasks after the upload has completed, it is recommended to queue them and process them in the background, as the Tus protocol expects a quick response." So we should not block the response. So we need to handle scanning and EXIF stripping in a background job. But for demonstration, we could keep it simple and do it synchronously (but scanning can be slow). But a proper design would offload to a background worker (e.g., using a queue like Bull). However, the prompt may not require that complexity. But to be "secure" and "engineer", we should show a decent pattern: after upload, we respond quickly with 202 Accepted maybe? But the Tus protocol expects 204 on successful upload. But we can still do background job: we can respond after we've at least started a background job. As long as we don't block for too long. Scanning might take a second or two, acceptable for small files? Possibly not. Better to show using a queue or at least an async function that doesn't block the event loop extremely. But we can useasync/awaitand let the hook be async, but the server might not wait for the promise to resolve before sending the response. That could lead to race conditions (file being scanned while response already sent). But the file is already stored, so it's okay to continue processing after response. So we can fire-and-forget an async function. UsesetImmediateor just call an async function without awaiting. So implement like:
server.on('finish', async (req, res, file) => { // fire and forget processUploadedFile(file).catch(console.error); });This is acceptable.
Now, the implementation steps:
- Initialize project: npm init, install dependencies: express, tus-node-server, @tus/file-store (or the storage implementation that
tus-node-serveruses). Actually,tus-node-serverhas peer dependencies:@tus/serverand@tus/storage. We need to pick a storage implementation:@tus/file-store(for local filesystem) or@tus/s3-store. We'll use file-store. Also needsharpfor image processing,node-clamfor malware scanning,better-sqlite3orsqlite3for database, andwinstonorpinofor logging? But we can use simple console, but auditing requires storage. Usebetter-sqlite3because it's synchronous and easy. Also needmime-typesto detect mime type? We can usefile-typepackage to detect from buffer? Or rely on extension? Better to detect properly. We'll usefile-typeto check magic bytes. But that requires reading file content. Since file is already saved, we can read its path.
Alternatively, we could also validate file size and type before upload using Tus: the protocol allows creation with metadata, including filename and file size? Actually, when creating an upload, you send a POST to the Tus endpoint with headers:
Upload-Length,Upload-Metadata(base64 encoded). We can validate size and allowed extensions based on that. But that's before upload. For simplicity, we'll do validation after upload as well.We also need to consider authentication: the prompt didn't mention user auth, but we can include a simple API key header or IP tracking for auditing. We'll capture IP from request.
Now, design code structure:
app.jsorserver.js: main entry.audit.js: database and logging functions.scanner.js: malware scanning using node-clam.processor.js: EXIF stripping using sharp.config.js: configuration (upload dir, db path, clamd host/port, allowed mime types, max file size?).
Implementation details:
Tus server setup:
const { Server } = require('@tus/server'); const { FileStore } = require('@tus/file-store'); // Optionally use @tus/s3-store const server = new Server({ path: '/files', datastore: new FileStore({ directory: './uploads', // other options: lock, etc. }), // events onFinish: async (req, res, file) => { // Our handler } }); // Use tus middleware in express app.use(server.middleware());But
tus-node-serveralso provides a more straightforward integration:const TusServer = require('tus-node-server');Actually, the packagetus-node-serveris a wrapper that uses@tus/server. Its documentation shows:const TusServer = require('tus-node-server'); const server = new TusServer(); server.datastore = new TusServer.FileStore({ directory: './uploads' }); app.use(server.createMiddleware());We'll use that since it's simpler. The package
tus-node-serveris well-known.Check the docs: https://github.com/tus/tus-node-server
Example:
const express = require('express'); const TusServer = require('tus-node-server'); const app = express(); const server = new TusServer(); server.datastore = new TusServer.FileStore({ directory: './uploads' }); app.use(server.createMiddleware()); app.listen(1080, () => { console.log('Server listening on port 1080'); });And events:
server.on('error', (err) => { console.error(err); }); server.on('log', (debug) => { console.log(debug); }); server.on('finish', (req, res, file) => { console.log(`File ${file.id} has been uploaded`); });Yes,
finishevent. So we'll attach to that.Now, we need to get the file's info: the
fileobject has properties likeid,size,metadata. The metadata is an object with keys: filename (original name), maybefiletype? Actually, Tus metadata is encoded base64 and transmitted. The library parses them intofile.metadata. Usually, client sendsfilenameandfiletype(mime). So we can accessfile.metadata.filenameandfile.metadata.filetype.The physical file path on disk: In FileStore, the file is stored as a temporary file during upload? After completion, it may be stored in the same directory with the file ID as name (or maybe with original extension?). The FileStore default stores files in the specified directory using the file ID as filename. But the client metadata includes original filename. So after finish, we may want to rename the file to original filename or keep ID and store reference? For security, we might not want to use original filename directly (avoid path traversal). Better to keep the stored filename as a random ID and keep original as metadata in database. The FileStore by default uses the file's ID as filename (a UUID). So the file on disk is something like
./uploads/<id>. But we can also configure a naming function. For simplicity, we'll keep that.So after upload, we have the file at
storePath? Thefileobject may have apathproperty? In FileStore, the file is stored with the ID as name. Thefileobject from tus-node-server likely hasidand maybegetFilePath()method. Let's check the source: In@tus/file-store, a file hasidandpathcomputed aspath.join(this.directory, this.fileId). So we can get path aspath.join(uploadDir, file.id). We'll store that path in audit.Now, processing steps in background:
- Determine mime type: from
file.metadata.filetypeif provided, or detect viafile-typepackage to be sure. - Malware scan: use node-clam. Example:
const nodeClam = require('node-clam'); const clam = new nodeClam.ClamAV(); clam.isInfected(filePath, (err, isInfected, malware) => { if (err) { /* handle error */ } if (isInfected) { /* delete file, log */ } else { /* proceed to EXIF strip if image */ } });But node-clam also supports scanning a buffer or stream? We have file saved already, scanning file is fine.
- EXIF stripping: if mime type is image/jpeg, image/png, etc. Use sharp:
const sharp = require('sharp'); sharp(filePath) .withMetadata({ exif: null }) // Actually, to strip EXIF we can use .withMetadata({ exif: null })? Wait, sharp documentation: .withMetadata(options) can set exif, iptc, xmp. Removing exif: set exif: false? There is also .exif() method. Actually, to preserve image but remove EXIF, you can use .withMetadata({ exif: Buffer.alloc(0) })? Not sure. Better: .rotate(), .flatten()? Simpler: convert to JPEG and set quality? Alternatively, use `jimp` to strip EXIF. But sharp can remove EXIF by not preserving it. Using `.withMetadata({ exif: null })`? Let's check: sharp's withMetadata can take `exif` as Buffer to set. To drop Exif, you can simply not include it. The default is to preserve all metadata. There's a `.exif()` method to extract, but to remove you need to set exif to an empty buffer? Actually, from docs: "When using .withMetadata() you can supply a Buffer to replace the EXIF, IPTC or XMP metadata." So to remove, you can pass an empty buffer: `sharp(input).withMetadata({ exif: Buffer.alloc(0) })`? That would set an empty EXIF block. That might still strip. But better: use `.strip()`? Sharp has a method `.strip()` that removes all text metadata, i.e., EXIF, ICC profiles, etc. Yes, sharp has `sharp(input).strip()` which removes metadata (including EXIF). So we can use: ```javascript sharp(filePath) .strip() .toFile(filePath); // overwriteThat's simple.
- After processing, update audit log with final status.
Now, audit database: we can use
better-sqlite3and create table:CREATE TABLE IF NOT EXISTS audit ( id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp DATETIME DEFAULT CURRENT_TIMESTAMP, ip_address TEXT, user_agent TEXT, method TEXT, file_id TEXT, original_filename TEXT, stored_path TEXT, file_size INTEGER, detected_mime TEXT, status TEXT, -- 'malware', 'clean', 'error' exif_stripped BOOLEAN, error_message TEXT );We'll insert a row when upload finishes (after processing? maybe before processing and then update after). Simpler: insert a row with status 'pending' and then update after scanning? Or insert after processing completes. Since we are doing background processing, we can wait for scanning and EXIF stripping to complete before inserting the final audit record. That may cause delay in logging but okay. Or we insert an entry at start (with status 'uploaded') and later update. But for simplicity, do at end. So the
onFinishtriggers background process. When background finishes, it writes to audit DB. That means audit entry appears after some delay. But that's fine.We also need to capture request IP and user agent. The
reqobject in finish event has these. So we can pass them along to background.So plan:
- In
onFinishhandler: get file info, capture request data (IP, user-agent). Then invoke async functionprocessAndAudit({ file, req })without awaiting.
Now, error handling: if scanning fails (e.g., clamd not available), we should still log error and maybe quarantine file. We'll mark status 'error' and retain file? Possibly we should delete file if we cannot guarantee safety? For security, maybe quarantine and notify admin. But for demo, we'll keep as is but log error.
Also, need to ensure that the file is not accessible directly until processed? In Tus, the file endpoint is separate from serving files. We'll not expose the upload directory directly. We may have a separate endpoint to download files, which should check permissions, but not required by prompt.
Now, we need to write the full code. We'll include:
package.jsondependencies.server.jsmain.- Possibly separate modules.
But we are to output a single code solution? The prompt says "Engineer a secure file upload backend...", likely expecting code files. We'll provide the code in a structured way: maybe as a single file for simplicity, or split. As ChatGPT, we can provide a single block with file structure guidance. We'll produce a complete solution with multiple files.
We'll assume using Node.js v16+.
We'll also need to start ClamAV daemon manually or as part of setup, but that's external. We'll note that.
Implementation details:
- Use environment variables for configuration:
UPLOAD_DIR,CLAMD_HOST,CLAMD_PORT,DB_PATH,MAX_FILE_SIZE. - Allowed mime types: images, PDFs, etc. But we will only strip EXIF for images.
Edge cases:
- Tus allows multiple concurrent uploads. Our background process should handle one file at a time. If multiple uploads, they'll be processed concurrently. That's okay, but scanning is CPU-intensive; we might want to limit concurrency. Not needed for demo.
Now, code.
First,
package.json:{ "name": "secure-tus-upload", "version": "1.0.0", "main": "server.js", "scripts": { "start": "node server.js" }, "dependencies": { "express": "^4.18.2", "tus-node-server": "^2.3.0", "node-clam": "^2.3.0", "sharp": "^0.32.0", "better-sqlite3": "^8.7.0", "mime-types": "^2.1.35" } }Alternatively, use
sqlite3instead of better-sqlite3? better-sqlite3 is synchronous but may require compilation; it's fine if native build tools are present. But for simplicity, usesqlite3(which is async but we can use sync version? no). Actuallysqlite3is asynchronous but we can usebetter-sqlite3for simplicity in code. Many environments have python and build tools for native modules. We'll go withbetter-sqlite3.Now,
server.js:We'll structure:
const express = require('express'); const TusServer = require('tus-node-server'); const path = require('path'); const fs = require('fs'); const { ClamAV } = require('node-clam'); const sharp = require('sharp'); const Database = require('better-sqlite3'); const mime = require('mime-types'); // Configuration from environment or defaults const config = { uploadDir: process.env.UPLOAD_DIR || './uploads', clamHost: process.env.CLAMD_HOST || '127.0.0.1', clamPort: process.env.CLAMD_PORT || 3310, dbPath: process.env.DB_PATH || './audit.db', allowedMimeTypes: [ 'image/jpeg', 'image/png', 'image/gif', 'application/pdf', // add more as needed ], maxFileSize: process.env.MAX_FILE_SIZE ? parseInt(process.env.MAX_FILE_SIZE) : 100 * 1024 * 1024, // 100MB }; // Ensure upload directory exists if (!fs.existsSync(config.uploadDir)) { fs.mkdirSync(config.uploadDir, { recursive: true }); } // Initialize audit DB const db = new Database(config.dbPath); db.exec(` CREATE TABLE IF NOT EXISTS audit ( id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp DATETIME DEFAULT CURRENT_TIMESTAMP, ip_address TEXT, user_agent TEXT, method TEXT, file_id TEXT, original_filename TEXT, stored_path TEXT, file_size INTEGER, detected_mime TEXT, status TEXT, exif_stripped BOOLEAN, error_message TEXT ) `); // Initialize ClamAV client const clam = new ClamAV(); clam.setHost(config.clamHost); clam.setPort(config.clamPort); // Test connection to ClamAV (optional) clam.ping((err, response) => { if (err) { console.error('ClamAV connection error:', err); console.error('Make sure clamd is running and accessible.'); } else { console.log('ClamAV connection established. Response:', response); } }); // Create Express app const app = express(); // Initialize Tus server const tusServer = new TusServer(); // Configure FileStore tusServer.datastore = new TusServer.FileStore({ directory: config.uploadDir, // You can also set a lockstore if needed }); // Event listeners tusServer.on('error', (err) => { console.error('Tus server error:', err); }); tusServer.on('log', (debug) => { if (process.env.DEBUG) { console.log('TUS DEBUG:', debug); } }); // This event is emitted after a file has been fully uploaded // Note: Do NOT perform heavy tasks synchronously here. Use background processing. tusServer.on('finish', async (req, res, file) => { // Capture request metadata before responding const ip = req.headers['x-forwarded-for'] || req.socket.remoteAddress; const userAgent = req.get('User-Agent') || ''; const method = req.method; // File metadata from Tus const originalFilename = file.metadata?.filename ? decodeURIComponent(file.metadata.filename) : 'unknown'; const storedPath = path.join(config.uploadDir, file.id); // FileStore uses file.id as filename const fileSize = file.size; // Try to get mime from metadata let detectedMime = file.metadata?.filetype || mime.lookup(originalFilename) || 'application/octet-stream'; // Fire-and-forget processing to not block Tus response processUploadedFile({ ip, userAgent, method, fileId: file.id, originalFilename, storedPath, fileSize, detectedMime, req // maybe we want to pass something else }).catch((e) => { console.error('Background processing error:', e); // Even if processing fails, we should log error to audit? Possibly already logged inside processUploadedFile? }); // Important: Do not call res.end() here; Tus server will handle response after this event. }); // Mount Tus middleware app.use(tusServer.createMiddleware()); // Health check endpoint app.get('/health', (req, res) => { res.send('OK'); }); // Start server const PORT = process.env.PORT || 1080; app.listen(PORT, () => { console.log(`Tus server listening on port ${PORT}`); }); /** * Background processing function: scans for malware, strips EXIF, and logs audit. */ async function processUploadedFile({ ip, userAgent, method, fileId, originalFilename, storedPath, fileSize, detectedMime }) { let status = 'unknown'; let exifStripped = false; let errorMessage = null; try { // First, verify file exists if (!fs.existsSync(storedPath)) { throw new Error('File not found on disk after upload'); } // Malware scan const isInfected = await scanFile(storedPath); if (isInfected) { // Delete the infected file fs.unlinkSync(storedPath); status = 'malware'; const malwareName = 'detected'; // Typically node-clam returns malware name? Let's get it. // Actually, node-clam isInfected returns (err, isInfected, viruses). We'll adjust. // We'll modify scanFile to return { infected: true, viruses: [] } or false. // We'll handle in scanFile. } else { // Clean, proceed to EXIF stripping if it's an image if (config.allowedMimeTypes.includes(detectedMime) && detectedMime.startsWith('image/')) { try { await stripExif(storedPath); exifStripped = true; } catch (err) { console.error('EXIF stripping failed:', err); // Not critical; we can continue but log error. } } status = 'clean'; } } catch (err) { console.error(`Error processing file ${fileId}:`, err); status = 'error'; errorMessage = err.message; // Maybe keep the file for investigation, or delete if suspicious? We'll keep but mark error. } // Insert audit record insertAuditRecord({ ip_address: ip, user_agent: userAgent, method, file_id: fileId, original_filename: originalFilename, stored_path: status === 'malware' ? null : storedPath, // if malware, file deleted, path null file_size: fileSize, detected_mime: detectedMime, status, exif_stripped: exifStripped, error_message: errorMessage }); } function scanFile(filePath) { return new Promise((resolve, reject) => { clam.isInfected(filePath, (err, isInfected, viruses) => { if (err) { // If clamd is not running, we might want to reject // But for security, if we cannot scan, we should treat as error and possibly quarantine. return reject(new Error(`ClamAV scan failed: ${err.message}`)); } if (isInfected) { console.log(`Malware detected: ${viruses.join(', ')}`); // We also need the virus name for audit. We'll store it in a variable? // But our function returns boolean only. We need name. resolve({ infected: true, viruses }); } else { resolve({ infected: false, viruses: [] }); } }); }); } async function stripExif(filePath) { await sharp(filePath) .strip() .toFile(filePath); } function insertAuditRecord(data) { const stmt = db.prepare(` INSERT INTO audit ( ip_address, user_agent, method, file_id, original_filename, stored_path, file_size, detected_mime, status, exif_stripped, error_message ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) `); stmt.run( data.ip_address, data.user_agent, data.method, data.file_id, data.original_filename, data.stored_path, data.file_size, data.detected_mime, data.status, data.exif_stripped ? 1 : 0, data.error_message ); }But there is a nuance: The
fileobject'ssizemight be used for scanning? The scanFile function uses file path. That's fine.Also, we need to ensure that the storedPath is accessible. Note that the
file.idis used as filename, but there might be also a file extension? FileStore may keep original extension? Actually, by default, FileStore usesidas filename without extension. That means the file has no extension, which could break mime detection if we rely on extension. But we have mime from metadata. We'll still detect viafile-typefrom the content to be safer. Should we add detection usingfile-type? It's good practice. Let's add a step: read the first 4100 bytes of the file to detect mime. We can usefile-typepackage. That will give accurate detection. So replacedetectedMimefrom metadata with detection. But keep original detection from both.We can do:
const FileType = require('file-type'); const stream = fs.createReadStream(storedPath, { start: 0, end: 4100 }); const type = await FileType.fromStream(stream); detectedMime = type ? type.mime : mime.lookup(originalFilename) || 'application/octet-stream';We'll incorporate that after scanning? But we need mime for scanning? No, scanning just cares about file content. But we need to know if it's an image for EXIF stripping. So we need accurate mime. Let's do it before scanning. We'll compute detectedMime after file exists.
We'll modify
processUploadedFile:async function processUploadedFile({ ... }) { try { if (!fs.existsSync(storedPath)) throw new Error('File not found'); // Detect mime using file-type const detectedMime = await detectMime(storedPath, originalFilename); // Then scan, etc. } }Implement
detectMime:const FileType = require('file-type'); function detectMime(filePath, fallbackName) { return new Promise((resolve) => { const stream = fs.createReadStream(filePath, { start: 0, end: 4100 }); FileType.fromStream(stream, (err, type) => { if (type) { resolve(type.mime); } else { // fallback to extension resolve(mime.lookup(fallbackName) || 'application/octet-stream'); } }); }); }But note:
file-typealso supports promise:FileType.fromFile(filePath)? It hasfromFilemethod that reads file. But that reads entire file? ActuallyfromBloborfromFilereads up to 4100 bytes. So we can useFileType.fromFile(storedPath)which returns a promise. That's simpler. We'll useFileType.fromFile.const { fromFile } = require('file-type'); ... const type = await fromFile(storedPath); detectedMime = type ? type.mime : mime.lookup(originalFilename) || 'application/octet-stream';Yes.
Now, update imports.
Now, about ClamAV: The
scanFilefunction currently returns a boolean-ish. But we want to capture virus names for audit. So we'll modify to resolve with an object:{ infected: boolean, viruses: [] }. Then in processing:const scanResult = await scanFile(storedPath); if (scanResult.infected) { // Delete file fs.unlinkSync(storedPath); status = 'malware'; errorMessage = scanResult.viruses.join(', '); }Also, we might want to consider file size limits: The Tus protocol enforces the size declared by client; if a client tries to upload larger than allowed, we can reject creation. We can add a
validateevent or hook.tus-node-serverhasonCreateevent. We can use that to check file size against limit and allowed mime types from metadata before allowing upload to start. That would prevent unnecessary uploads. Good to include for security.We'll add:
tusServer.on('create', async (req, file) => { // file has metadata and size const requestedSize = file.size; if (requestedSize > config.maxFileSize) { req.res.status(400).end('File too large'); return false; // cancel upload } // Check mime type from metadata if available if (file.metadata?.filetype && !config.allowedMimeTypes.includes(file.metadata.filetype)) { req.res.status(400).end('File type not allowed'); return false; } // We could also check extension but not needed. return true; // allow });Note:
onCreateevent can be used to reject creation. The return value of the handler: if it returns false, the creation is aborted. Or we can callreq.res.status(400).end(). That's fine.Also, to enforce that all uploads go through Tus endpoint, we may want to add CORS headers? Not required.
Now, the background processing: we must handle cases where scanning fails (clamd unreachable). In that case, we should probably delete the file to be safe, or at least quarantine. We'll mark status error and file remains? But if we can't scan, we cannot guarantee it's safe. A secure system might reject the file. We'll choose to delete the file and mark status 'scan_error' (maybe treat as malware? Not exactly). Let's define: if scan fails (e.g., clamd down), we log error and delete the file, because we can't trust it. Or we could move to a quarantine folder for manual review. For simplicity, we'll delete and mark error.
Thus, modify:
let scanResult; try { scanResult = await scanFile(storedPath); } catch (err) { // scan error: treat as unsafe, delete file, mark error fs.unlinkSync(storedPath); status = 'error'; errorMessage = `Scan failed: ${err.message}`; // then insert audit and return insertAuditRecord(...); return; }Now, the
scanFilefunction should return{ infected, viruses }. If clamd returns error, it rejects. So catch.Also, we need to ensure we don't attempt EXIF stripping if the file is deleted (malware or scan error). So we need to put EXIF strip in else branch.
Now, database insert should happen even in error, so we capture all.
Now, we need to be careful about file deletion: if we delete the file, we should set
stored_pathto null because it no longer exists.Now, note: The
fileobject might still be in the datastore? After we delete the file on disk, the Tus server's datastore might still think the file exists (its metadata). That could cause issues if later a client tries to access or resume? But after finish, the upload is complete. The file is stored; if we delete it, the next GET on that file ID will fail (404). That's fine; we want to remove malicious files. So it's okay.Now, we should also handle EXIF stripping errors: if sharp fails, we log but still keep file. That's fine.
Now, consider: The file may not be an image but we try to strip EXIF? We'll check mime. If mime is image, we attempt.
Now, the code above sets
detectedMimeafter detection. But we useddetectedMimeto check if it's an image. Also we need to ensure we only attempt EXIF strip on supported formats. Sharp supports JPEG, PNG, WebP, TIFF, etc. We could limit to those.Now, also need to consider: The file could be large and reading it with
file-typemight be okay; it only reads first few bytes. Sharp processing will read entire file, but it's okay.Now, potential race condition: The background function might try to process file while it's still being uploaded? But we are using
finishevent which is after upload, so file is fully written. So safe.Now, we should also handle concurrency: If two uploads finish at same time, they'll each run their own background. That's fine. SQLite supports concurrent writes?
better-sqlite3by default is not safe for concurrent writes unless using WAL mode and proper transaction. But we can handle by serializing writes with a queue, or rely on SQLite's serialization. Since writes are quick, maybe okay. But better to use a mutex? Not necessary for demo.Now, let's refine code:
We'll restructure to be more modular.
We'll produce following file structure:
project/ ├── server.js ├── config.js (or use env) ├── audit.js ├── scanner.js ├── processor.js └── package.jsonBut to keep answer concise, we might put all in one file. The prompt says "Engineer a secure file upload backend...". It's okay to present a single monolith file. I'll produce a single
server.jsthat includes everything. But I'll separate functions logically.Let's craft final code.
But we must be careful about the
node-clamusage. According to its npm page:npm install node-clam. Basic usage:const nodeClam = require('node-clam'); const clam = new nodeClam.ClamAV(); clam.setHost('localhost'); clam.setPort(3310); clam.ping(function (err, isDaemonAlive) { console.log('clamd ping response: ' + isDaemonAlive); }); clam.isInfected('./test.txt', function(err, isInfected, viruses) { console.log(isInfected, viruses); });Yes.
But note:
node-clammight have issues with modern Node versions due to using old dependencies. But it's okay.Alternatively, there is
clamscanpackage. Butnode-clamis more maintained? Let's useclamscan? Actually,clamscanhas aclamscanfunction that usesclamdif available. It's simpler:const clam = require('clamscan');but that spawns a process? Theclamscanmodule:clamscan.isInfect(filePath, cb)? I'd usenode-clamfor better control.However,
node-clamhas an event-based API but not promise. So we wrap in promise.Now, the
sharpEXIF stripping:sharp(filePath).strip().toFile(filePath)works. But we need to ensure we don't lose file extension. Since we overwrite the same file, the extension is whatever it was originally. However, the file stored by FileStore has no extension; it's just a filename with ID. So we are overwriting a file with no extension. That's fine; the file content remains the same format (sharp will preserve format). When we later serve it, we need to set proper Content-Type based on detected mime, which we store in audit. So if we serve based on audit's mime, it's fine. But we may want to keep original filename for downloads. That's a separate endpoint.Now, let's also consider that after EXIF stripping, we could rename the file to include an extension? Not needed.
Now, one more security: After scanning and stripping, we should set proper permissions on the file: e.g., mode 0640. We can do
fs.chmodSync(storedPath, 0o640);after processing. That's good.Now, also consider that the upload directory should not be world-writable. Ensure it's created with appropriate permissions. We'll create with default.
Now, testing: We'll provide instructions on installing ClamAV (e.g.,
sudo apt-get install clamav-daemonand start it). Also, ensure the clamd socket is configured to listen on TCP (usually it listens on a Unix socket by default). We'll need to configureclamd.confto listen on 3310 if needed. Or we can use local socket?node-clamsupports both, but we'll use TCP for simplicity.Now, we need to ensure that the Tus server's
onFinishdoes not block response. Our background function is async, but we don't await it. However, we usedasyncand then.catchat the end? IntusServer.on('finish', async (req, res, file) => { ... processUploadedFile(...).catch(...) }). But because the handler is async, it returns a promise. Will Tus server wait for that promise? It may not, but it's not harmful. To be safe, we can make the handler not async, and call an async function without await. For example:tusServer.on('finish', (req, res, file) => { const ... = capture; (async () => { await processUploadedFile(...); })().catch(console.error); });Thus, we guarantee not to return a promise that Tus might mistakenly await. But I think the event listener just cares about the return? Usually event listeners ignore return value. But it's safe to not return a promise.
We'll use that pattern.
Now, final code:
We'll write full server.js with modular functions.
Also, include some logging (console.log) for clarity.
Now, check for any missing dependencies:
file-typeis needed. We'll include.Add to package.json.
Now, potential improvements: For large files, scanning entire file might be heavy. ClamAV streams; but node-clam sends file path, clamd reads it. That's okay.
Now, ensure that we handle errors from sharp: if sharp fails, we catch and log but continue.
Now, we also need to handle cleanup of uploaded file if any step fails before it's in final state. We'll determine when to keep file. For malware, we delete. For scan error (can't contact clamd), we also delete. For EXIF strip error, we keep the original file (maybe with EXIF). That's acceptable.
Now, we need to store audit records for all outcomes, including deletion. So we insert regardless.
Now, the code.
Let's produce the final answer with file contents.
We'll have:
package.jsonserver.js
Optionally, we could split config, but not needed.
Also, we might want to add .gitignore for node_modules, etc.
Now, let's write the final answer.
We should include comments explaining security considerations.
Also, note: The Tus protocol requires that the client sends metadata, including filename and file type. In this implementation, we trust the client-provided mime type? We also detect ourselves, but we don't enforce that detected mime matches declared mime? That could be a security measure: if they mismatch, reject. We can add a check: if detected mime is not in allowed list, reject. But we do that after upload, not at creation. Could also do at create: we can't know actual mime until file is there. So we can only check after upload. That's fine.
But for creation hook, we might not reject based on mime because we don't have file. But we could reject based on extension? That's weak. So we do post-upload check. That means we allow upload but then delete if mime not allowed. That's acceptable given the flow; but it wastes bandwidth. But we can also limit size at creation.
We'll add a check after detection: if detected mime not in allowed list, delete file and mark error. That should be part of processing.
So modify processing:
const detectedMime = await detectMime(storedPath, originalFilename); if (!config.allowedMimeTypes.includes(detectedMime)) { // Not allowed, delete and mark as invalid type fs.unlinkSync(storedPath); status = 'invalid_type'; errorMessage = `File type ${detectedMime} is not allowed`; // Insert audit and return }Yes.
Now, let's implement
detectMimeusingfile-type.One more thing:
file-typemight fail for empty files? Should handle.Now, incorporate these.
Now, we need to ensure that we are using
awaitcorrectly; we are inside an async IIFE.Now, the code:
server.js:// ... imports, config, etc.We'll use try/catch inside the background IIFE.
Now, careful about the order: after upload, we capture file path etc.
We must also ensure that we close the database connection on process exit? Not needed; it's a long-running service.
Now, test for environment: we must have ClamAV running. We'll log if connection fails at startup, but still start server; we could continue and rely on error handling later.
Now, I'll produce final answer with code blocks.
We'll also provide some usage instructions: how to run, install dependencies, start clamav, etc.
But the user only asked to engineer the backend, so code is primary.
Now, consider potential race: The
fileobject from finish event might not have the file fully flushed to disk? The event is after upload is completed, but the file might still be in the process of being closed? Usually it ensures the file is complete. So safe.Now, let's write the code.
We'll start with
package.json.Then
server.js.I'll include necessary error handling and logging.
Now, check
tus-node-serverversion: The latest version may be 2.x. We'll assume that.Now, code:
================
package.json================{ "name": "secure-tus-upload", "version": "1.0.0", "description": "Secure file upload backend with Tus protocol, malware scanning, EXIF stripping, and auditing", "main": "server.js", "scripts": { "start": "node server.js" }, "author": "Your Name", "license": "MIT", "dependencies": { "better-sqlite3": "^8.7.0", "express": "^4.18.2", "file-type": "^18.2.0", "mime-types": "^2.1.35", "node-clam": "^2.3.0", "sharp": "^0.32.0", "tus-node-server": "^2.3.0" } }Now,
server.js:We'll produce comprehensive code.
Let's write.
Note: We need to handle Windows paths? We'll use path.join.
Also, need to handle URI decoding of filename:
decodeURIComponentmay throw if not encoded. The metadata filename is base64 encoded? In Tus, the metadata is transmitted as base64 of the key and value. The library decodes automatically? I thinkfile.metadata.filenameis already decoded? Let's check the tus-node-server docs: It says "The metadata object contains the parsed metadata." It should be the original value, not base64. The client base64-encodes the value; server decodes. So it should be a UTF-8 string. So we don't need to decodeURIComponent unless it was encoded. But to be safe, we can try decodeURIComponent but catch errors. Actually, the filename might contain special characters. The Tus spec says metadata values are base64 encoded, and the server decodes to UTF-8. So it's plain string. We'll use as is.But sometimes the client may send already decoded? Actually, the client library typically encodes. So we trust that the library did decode. So we can use directly.
Now, one more: The
fileobject also hasidwhich is a string.Now, let's produce the code.
I'll write step by step.
First, require modules, config, etc.
I'll include a health endpoint.
Now, code:
const express = require('express'); const { Server: TusServer } = require('tus-node-server'); const path = require('path'); const fs = require('fs'); const { ClamAV } = require('node-clam'); const sharp = require('sharp'); const Database = require('better-sqlite3'); const { fromFile } = require('file-type'); const mime = require('mime-types'); // Configuration const config = { uploadDir: process.env.UPLOAD_DIR || path.join(__dirname, 'uploads'), clamHost: process.env.CLAMD_HOST || '127.0.0.1', clamPort: process.env.CLAMD_PORT ? parseInt(process.env.CLAMD_PORT) : 3310, dbPath: process.env.DB_PATH || path.join(__dirname, 'audit.db'), maxFileSize: process.env.MAX_FILE_SIZE ? parseInt(process.env.MAX_FILE_SIZE) : 100 * 1024 * 1024, // 100 MB allowedMimeTypes: [ 'image/jpeg', 'image/png', 'image/gif', 'image/webp', 'application/pdf', 'text/plain', // add others as needed ], }; // Ensure upload directory exists if (!fs.existsSync(config.uploadDir)) { fs.mkdirSync(config.uploadDir, { recursive: true }); } // Initialize audit database const db = new Database(config.dbPath); db.exec(` CREATE TABLE IF NOT EXISTS audit ( id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp DATETIME DEFAULT CURRENT_TIMESTAMP, ip_address TEXT, user_agent TEXT, method TEXT, file_id TEXT, original_filename TEXT, stored_path TEXT, file_size INTEGER, detected_mime TEXT, status TEXT, exif_stripped BOOLEAN, error_message TEXT ) `); // Initialize ClamAV client const clam = new ClamAV(); clam.setHost(config.clamHost); clam.setPort(config.clamPort); // Test ClamAV connection on startup (non-blocking) clam.ping((err, isAlive) => { if (err) { console.error('Warning: ClamAV connection failed:', err.message); console.error('Malware scanning will be disabled. Please start clamd daemon.'); // In production, you might want to exit if ClamAV is required. } else { console.log('ClamAV connection successful.'); } }); // Create Express app const app = express(); // Initialize Tus server const tus = new TusServer(); // Configure datastore tus.datastore = new TusServer.FileStore({ directory: config.uploadDir, // optional: lockstore: ... }); // Event: onCreate - validate before allowing upload tus.on('create', async (req, file) => { const requestedSize = file.size; if (requestedSize > config.maxFileSize) { req.res.writeHead(400, { 'Content-Type': 'text/plain' }); req.res.end(`File too large. Maximum allowed size is ${config.maxFileSize} bytes.`); return false; // abort creation } // If client provided file type metadata, check against allowed list if (file.metadata && file.metadata.filetype) { const clientMime = file.metadata.filetype; // We'll accept but still validate after upload because client can lie. // But we can also preemptively reject types that are definitely not allowed. // For simplicity, we allow but log. // Optionally, you can reject here: // if (!config.allowedMimeTypes.includes(clientMime)) { // req.res.writeHead(400, { 'Content-Type': 'text/plain' }); // req.res.end('File type not allowed.'); // return false; // } } return true; // allow }); // Event: onFinish - after upload complete tus.on('finish', (req, res, file) => { // Capture request info const ip = req.headers['x-forwarded-for'] || req.socket.remoteAddress; const userAgent = req.get('User-Agent') || ''; const method = req.method; const originalFilename = file.metadata?.filename || 'unknown'; const storedPath = path.join(config.uploadDir, file.id); const fileSize = file.size; // Fire-and-forget background processing (async () => { try { await processUploadedFile({ ip, userAgent, method, fileId: file.id, originalFilename, storedPath, fileSize }); } catch (err) { console.error('Unhandled error in background processing for file', file.id, err); } })(); }); // Mount Tus middleware app.use(tus.createMiddleware()); // Health endpoint app.get('/health', (req, res) => { res.send('OK'); }); // Start server const PORT = process.env.PORT || 1080; app.listen(PORT, () => { console.log(`Tus upload server listening on port ${PORT}`); }); /** * Background processing function. */ async function processUploadedFile({ ip, userAgent, method, fileId, originalFilename, storedPath, fileSize }) { let status = 'unknown'; let exifStripped = false; let errorMessage = null; let detectedMime = 'application/octet-stream'; try { // Ensure file exists on disk if (!fs.existsSync(storedPath)) { throw new Error('File not found on disk after upload'); } // Detect MIME type using file-type (magic bytes) const type = await fromFile(storedPath); if (type) { detectedMime = type.mime; } else { // Fallback to extension-based guess detectedMime = mime.lookup(originalFilename) || 'application/octet-stream'; } // Check if mime is allowed if (!config.allowedMimeTypes.includes(detectedMime)) { // Disallowed type: delete file and record fs.unlinkSync(storedPath); status = 'disallowed_type'; errorMessage = `File type ${detectedMime} is not allowed.`; insertAuditRecord({ ip_address: ip, user_agent: userAgent, method, file_id: fileId, original_filename: originalFilename, stored_path: null, file_size: fileSize, detected_mime: detectedMime, status, exif_stripped: exifStripped, error_message: errorMessage }); return; } // Perform malware scan const scanResult = await scanFile(storedPath); if (scanResult.infected) { // Delete infected file fs.unlinkSync(storedPath); status = 'malware'; errorMessage = `Malware detected: ${scanResult.viruses.join(', ')}`; insertAuditRecord({ ip_address: ip, user_agent: userAgent, method, file_id: fileId, original_filename: originalFilename, stored_path: null, file_size: fileSize, detected_mime: detectedMime, status, exif_stripped: exifStripped, error_message: errorMessage }); return; } // If it's an image, strip EXIF metadata if (detectedMime.startsWith('image/')) { try { await stripExif(storedPath); exifStripped = true; } catch (err) { console.error(`EXIF stripping failed for file ${fileId}:`, err); // Not critical; file remains but we flag exif_stripped as false and continue. } } // Set secure permissions (read/write for owner, read for group/others) try { fs.chmodSync(storedPath, 0o640); } catch (err) { console.warn('Failed to set file permissions:', err.message); } status = 'clean'; insertAuditRecord({ ip_address: ip, user_agent: userAgent, method, file_id: fileId, original_filename: originalFilename, stored_path: storedPath, file_size: fileSize, detected_mime: detectedMime, status, exif_stripped: exifStripped, error_message: errorMessage }); } catch (err) { console.error(`Error processing uploaded file ${fileId}:`, err); status = 'error'; errorMessage = err.message; // If file still exists and we failed due to something else, we may want to delete it for safety. // But we'll keep for investigation and log. try { if (fs.existsSync(storedPath)) { // Could quarantine by moving to a separate folder, but for simplicity we leave it. // Optionally, we could delete it. // fs.unlinkSync(storedPath); } } catch (e) {} insertAuditRecord({ ip_address: ip, user_agent: userAgent, method, file_id: fileId, original_filename: originalFilename, stored_path: fs.existsSync(storedPath) ? storedPath : null, file_size: fileSize, detected_mime: detectedMime, status, exifStripped, error_message: errorMessage }); } } /** * Scan file using ClamAV. * Returns a Promise that resolves to { infected: boolean, viruses: [] } */ function scanFile(filePath) { return new Promise((resolve, reject) => { clam.isInfected(filePath, (err, isInfected, viruses) => { if (err) { return reject(new Error(err.message || 'ClamAV scan error')); } if (isInfected) { resolve({ infected: true, viruses: Array.isArray(viruses) ? viruses : [String(viruses)] }); } else { resolve({ infected: false, viruses: [] }); } }); }); } /** * Strip EXIF data from image file using Sharp. */ function stripExif(filePath) { return sharp(filePath) .strip() .toFile(filePath); } /** * Insert a record into the audit database. */ function insertAuditRecord({ ip_address, user_agent, method, file_id, original_filename, stored_path, file_size, detected_mime, status, exif_stripped, error_message }) { const stmt = db.prepare(` INSERT INTO audit ( ip_address, user_agent, method, file_id, original_filename, stored_path, file_size, detected_mime, status, exif_stripped, error_message ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) `); stmt.run( ip_address, user_agent, method, file_id, original_filename, stored_path, file_size, detected_mime, status, exif_stripped ? 1 : 0, error_message ); }Now, we need to handle
clam.isInfected- according to node-clam docs, the callback signature:(err, isInfected, viruses). IfisInfectedis true,virusesis a string of virus names? Possibly an array? We'll treat as array. Actually, the source code: It callsclamd.scanand the result is something like? I'd check quickly: node-clam'sisInfectedmethod: It callsclamd.scan(filePath, cb). The callback receives error and result. If no error, the result is either false or an object withisInfected? Hmm, better look up: Node-clam's README:clam.isInfected('/path/to/file', function(err, isInfected, viruses) { if (err) { // Handle error return; } if (isInfected) { console.log('The file is infected with:', viruses); } else { console.log('The file is clean'); } });So viruses is a string or array? The README example uses a string? Actually, they say "viruses" (plural). Might be a string of virus names separated by commas. We'll treat as string and split? But we can just store as string.
We'll store
errorMessageas a string. We'll seterrorMessage = virusesif infected.But we used
scanResult.viruses.join(', '). But if viruses is a string, that will error. So we should normalize. Let's adjust:if (scanResult.infected) { const viruses = Array.isArray(scanResult.viruses) ? scanResult.viruses : [scanResult.viruses]; errorMessage = viruses.join(', '); }Better: In
scanFile, we resolve with{ infected, viruses }where viruses is an array. So we can convert:if (isInfected) { const virusesList = Array.isArray(viruses) ? viruses : (viruses ? [viruses] : []); resolve({ infected: true, viruses: virusesList }); } else { resolve({ infected: false, viruses: [] }); }Now, adjust.
Also, note:
clam.isInfectedmay have a third argument? In some versions, it might be(err, isInfected, viruses)or(err, result)? Let's stick to the documentation: it returnsisInfectedandviruses. We'll handle accordingly.But to be safe, we could also use
clam.scanwhich returns(err, result). However,isInfectedis convenience.Let's check Node-clam version 2.3.0 code: Actually, I'd look at its source quickly: It seems
isInfectedis defined as:ClamAV.prototype.isInfected = function isInfected(filePath, cb) { this.scan(filePath, function(err, result) { if (err) return cb(err); if (result === false) return cb(null, false); cb(null, true, result); }); };So if result is false, it passes false as isInfected? That doesn't match. Actually, scanning returns false if clean, or an object with virus info? In clamd protocol, scan returns either "OK" or "FOUND "? Then the result is a string like "FOUND "? Let's see node-clam's scan method:
ClamAV.prototype.scan = function scan(filePath, cb) { this._send('zINSTREAM\n'); // ... stream file, then recv response // On OK: this.emit('result', 'OK'); // On FOUND: this.emit('result', `FOUND ${virus}`); // ... then callback };The result may be the string. So
isInfectedpassesresultas third argument if infected. Soviruseswould be the string? Probably the virus name or "FOUND "? Might be like "Eicar-Test-Signature FOUND". We could parse. But for audit, we can just record whatever string.Thus, in
isInfectedcallback,virusesmight be a string. So we treat as string.We'll store as string.
So in
scanFile:return new Promise((resolve, reject) => { clam.isInfected(filePath, (err, isInfected, viruses) => { if (err) return reject(new Error(err.message || 'ClamAV scan error')); if (isInfected) { resolve({ infected: true, viruses: viruses || 'Unknown virus' }); } else { resolve({ infected: false, viruses: '' }); } }); });Then later:
if (scanResult.infected) { const virusInfo = scanResult.viruses || ''; errorMessage = `Malware detected: ${virusInfo}`; // ... }Now, we also want to include the virus info in the audit record.
Now, regarding the error handling: if clamd is not running, the
isInfectedcallback likely returns an error (like ECONNREFUSED). So we catch and treat as error.Now, let's think about the
fileobject'smetadata. We usedfile.metadata?.filename. The tus-node-server might store filename in metadata asfilename. The client sendsUpload-Metadataheader, e.g.,filename <base64>. So we read.But what if no metadata? Then originalFilename is unknown.
Now, we also want to store file size from
file.sizebut that is the size declared by client. For accurate size, we could check file's actual size on disk. But we trust Tus validator? The server ensures that the file size matchesUpload-Length? It does. So we can usefile.size. But to be safe, we could also checkfs.statSync(storedPath).sizeand compare, but fine.Now, about the
detectedMime: We set after detection, and used for allowed check and EXIF stripping. Good.Now, consider that after EXIF stripping, we may want to update the
detectedMime? It stays same.Now, we also might want to verify that the file type matches the extension we intend to use for serving, but not needed.
Now, also consider that the uploaded file might be a large image; sharp's strip operation might re-encode? Actually,
strip()removes metadata without re-encoding if possible? For JPEG, stripping EXIF usually requires re-encoding? Sharp's documentation: "strip removes all metadata, including EXIF, ICC, and XMP. It does not re-encode the image data; it simply discards the metadata chunks." So it's fast and lossless. Good.Now, we also need to handle potential errors from sharp if file is not an image (but we already check mime, so safe). Still, we catch.
Now, final audit insert: We pass
stored_pathas null if file deleted.Now, note: The path we store is absolute. That's fine for internal use.
Now, we should also consider that the database might grow; we need a retention policy, but not part of this.
Now, we need to make sure that the
processUploadedFilefunction does not throw uncaught errors because it's inside async IIFE. We catch at the top-level inside and log. We also ensure we return after early decisions (like malware) after audit insert.Now, we also need to ensure that the
detectedMimeis set before we call insertAuditRecord in all branches. In the early branch for disallowed type, we inserted inside the branch and returned. That's fine. For malware we inserted and returned. For clean we inserted at end. For error we inserted in catch.But in the catch at the very outer level, we also call insertAuditRecord. But if we already inserted inside earlier return, we don't want to insert twice. That's okay because we return after inserting. So we need to ensure that for malware and disallowed type we inserted and returned, so catch won't execute. For error in try (like file not found), we will jump to catch and then insert there. That's fine.
But we also have an internal catch for
scanFileerror: we throw after deleting file and then we callinsertAuditRecordand return. That is inside try, not in catch. So we need to make sure that after we handle that error, we don't also go to outer catch. That's fine because we return.Now, what about the
processUploadedFilefunction being called multiple times? Only once per file.Now, let's refine code to ensure all branches set
statusand insert.We'll write a helper
auditthat we call with final status and message. But current design is okay.Now, I'll adjust the code to have a single audit insertion at the end to avoid duplication. But it's fine as is. However, we can restructure to set variables and then at end insert. But we have early returns. That's okay; we inserted and returned early.
But the early returns miss setting
exifStrippedanddetectedMimein the audit call? We pass them accordingly. In disallowed type branch, we passed exifStripped false. In malware branch, same. Good.Now, we need to define
config.allowedMimeTypesto include types we want to accept. We'll include common ones.Now, also we might want to log the event when a file is uploaded and processed. We already have console logs.
Now, consider that the
createevent might be called many times; we currently only log error.Now, we should also add CORS if needed? Not requested.
Now, potential issue: The
tusserver'sfinishevent might be called after the response is sent? Actually, docs: "The finish event is emitted after a file has been successfully uploaded." But it might be before the response is sent? In tus-node-server, theonFinishcallback signature:(req, res, file) => void. The server expects you to do processing and then callres.end()? The server automatically responds after the event? Let's check source. I recall that in tus-node-server, you can do synchronous work and then the server will respond 204. If you do async, you need to manually end the response. The docs say: "If you need to perform long-running tasks after the upload has completed, it is recommended to queue them and process them in the background, as the Tus protocol expects a quick response." So they assume you don't block. Our handler is synchronous but we fire off an async IIFE and return immediately. That should be fine; the server will respond 204 right away. Good.But there is a nuance: The
fileobject might be used by the server after the event? Probably not.Now, we also need to ensure that we capture request data (IP, etc.) correctly. We capture before returning. That's fine.
Now, let's test mentally: Upload completed,
finishevent fires. We capture IP, etc. We start background async process, and then we exit the handler. The server sends 204. Meanwhile, background process runs. If there's an error in scanning, we log and delete file. That occurs after client got success. That's acceptable because the file was uploaded successfully; we later determine it's malicious and delete it. The client will get success, but the file is removed. That's a trade-off: we could have scanned before confirming success, but that would block. To avoid giving success for malicious files, we might want to delay success response until after scanning. But that would violate Tus protocol expectations? Actually, Tus protocol says after the upload completes, the server should respond with 204 No Content. The client expects that. If we delay response for scanning, it's okay as long as we eventually send 204. The client will wait. So we could actually do scanning in thefinishevent and wait for it before sending response? Thefinishevent is called before the response? I'm not entirely sure. Looking at tus-node-server source: In theStoreclass, after upload is complete, it triggersthis.emit('finish', req, res, file). Then later it sends response? Actually, I recall that after emitting 'finish', the server callsres.status(204).end(). So if our handler is asynchronous and returns a promise, the server does not wait. So we cannot block the response by returning a promise unless we override behavior. So to send response only after scanning, we would need to not use the built-in flow, but handle manually: we could use theonFinishto do async and then manually end response? Actually, the server doesres.writeHead(204); res.end();after emitting events. So if we want to control response timing, we could not emit events? Or we could intercept before that. Alternatively, we could usetus-serverdirectly rather than tus-node-server? But we can also use theonFinishevent to perform scanning synchronously (if scanning is fast enough) and then return. But scanning can be slow. For security, we want to avoid confirming success before we know it's safe. There's a trade-off: blocking for scanning may cause client timeouts if scanning takes too long (say > 60 seconds). Also, Tus protocol doesn't specify a timeout for the final response, but client might have network timeouts. However, scanning could be 2-10 seconds for large files. That might be acceptable. But for a robust system, we would want to queue and notify later. But the prompt asks for a secure backend; security-wise, it's better to only confirm success after scanning. However, typical tus implementations do scanning after response because scanning could be long. But we can implement a two-phase: after upload, respond 202 Accepted and then later provide a status endpoint or webhook. But that deviates from Tus spec? Actually, the spec says that after a successful upload, the server should respond with 204. If we respond with 202, it's not a standard Tus response? The spec says after POST to create resource, 201 Created, after PATCH to upload, 204 No Content. For final response after finishing, it's 204. So we must send 204. But we could still send 204 after scanning, as long as we do it within the event handler before returning. That means we need to do scanning synchronously. But scanning is async. We could use a synchronous scanning method? ClamAV doesn't have sync; it's I/O. We could use a synchronous wrapper that blocks? That would block the event loop, not good. But we could do async and not send response until done? Thefinishevent does not allow that by default; it sends response right after. So we would need to override the server'srespondmethod or not use the automatic response. We could instead use thetusserver as middleware that we fully control? Let's check the API oftus-node-server. It providescreateMiddleware()which returns a function that handles requests. In that middleware, after processing, it sends response. We can't easily intercept to delay. However, we could settus.resumable? No.Maybe we can do the scanning in the
createevent? No, that's before upload. Not helpful.Alternatively, we can use a different approach: Instead of using
tus-node-server, implement the Tus protocol ourselves? That's too heavy.Given the complexity, and that the user didn't specify "do not confirm before scanning", we can accept the trade-off: confirm upload to client, then scan and delete if malicious. This is common in many services: they accept upload, then process, and if malicious, they quarantine and maybe notify. But the user might have a false sense of security. However, the requirement says "malware scanning", not necessarily blocking before response. So it's okay.
But we can improve by scanning as the chunks arrive? That's more complex.
We'll keep it as is.
But we could at least do a quick scan on the first few kilobytes as soon as they arrive? The Tus server stores chunks; we could hook into chunk upload to scan incrementally. But that would be heavy. Not needed.
Thus, we proceed.
Now, note: The
fileobject infinishmight havemetadata.filetypebut we're detection anyway. So it's fine.Now, one more security: The upload directory should not be served directly. We'll not create a static serve route for it. If we need to serve files, we should add an endpoint that checks permissions before sending, with appropriate Content-Type. Not required.
Now, code final check:
tus.createMiddleware()is called. But we also have our ownappand we doapp.use(tus.createMiddleware());. That's correct.But we also have
app.get('/health', ...)after that. That's fine.Now, we should also handle errors from the Tus server. Already have event listener.
Now, we need to close database on exit? Not necessary.
Now, about
node-clamconnection: If clamd is not running, errors will occur duringscanFile. In ourprocessUploadedFile, we have try/catch aroundscanFile. IfscanFilerejects (e.g., connection error), we go to catch and set status error, and we may delete file? In catch we currently log error and insert audit. But we did not delete file there. In catch block we did:} catch (err) { console.error(...); status = 'error'; errorMessage = err.message; try { if (fs.existsSync(storedPath)) { // Could quarantine? // fs.unlinkSync(storedPath); } } catch (e) {} insertAuditRecord(...); }So we keep file. That might be insecure. We could choose to delete on scanning error because we cannot guarantee safety. Let's modify: In catch, if the error is from scanning, we delete file. But the catch is for any error in the try block, including file not found, detection, allowed check, scanning, exif stripping, etc. For file not found we already threw and caught, we keep? That's fine, file already missing. For scanning error, we want to delete. We could do:
if (err.message.includes('ClamAV') || err.code === 'ECONNREFUSED') { fs.unlinkSync(storedPath); storedPath = null; // for audit }But simpler: For any error that occurs after we have verified file existence and before we finish, we may delete the file to be safe. But some errors like EXIF stripping shouldn't cause deletion. So we need to differentiate.
We could wrap scanning in try/catch separate, and if scanning fails, delete file and return. That's already covered if we
scanFilerejects? Actually,scanFilerejects if clamd error. In our current try block, we have:const scanResult = await scanFile(storedPath);If scanFile rejects, it goes to catch. But we want to handle specifically scanning error separately. So we could do:
try { const scanResult = await scanFile(storedPath); // ... } catch (err) { if (err instanceof ScanError) { // custom? or check err.message? // delete file } throw err; // rethrow to outer catch }But simpler: In the try block, we could wrap the scan in its own try/catch and if catch, delete and return early with status error. But we already have an early return pattern. So restructure:
try { // existence check // detect mime and allowed check (if disallowed, early return) // scanning let scanResult; try { scanResult = await scanFile(storedPath); } catch (scanErr) { // scanning failed fs.unlinkSync(storedPath); throw new Error(`Malware scan failed: ${scanErr.message}`); } if (scanResult.infected) { // delete and return } // exif // ... } catch (err) { // general errors }That's better.
We'll adjust accordingly.
Now, let's rewrite the
processUploadedFileto be robust.Pseudo:
async function processUploadedFile(params) { let status = 'error'; // default let exifStripped = false; let errorMessage = null; //... try { // check file exists // detect mime // allowed mime check -> if not allowed: delete (if needed), set status, audit, return // scan: let scanResult; try { scanResult = await scanFile(storedPath); } catch (err) { // scanning error: delete file, set status=scan_error, audit, return if (fs.existsSync(storedPath)) fs.unlinkSync(storedPath); status = 'scan_error'; errorMessage = `Scan error: ${err.message}`; insertAuditRecord(...); return; } if (scanResult.infected) { fs.unlinkSync(storedPath); status = 'malware'; errorMessage = `Malware: ${scanResult.viruses}`; insertAuditRecord(...); return; } // exif strip if image if (detectedMime.startsWith('image/')) { try { await stripExif(storedPath); exifStripped = true; } catch (e) { console.warn('EXIF stripping failed:', e.message); } } // set permissions // status = clean } catch (err) { // other errors status = 'error'; errorMessage = err.message; // maybe delete file if unknown error? We'll keep for investigation. } finally { // Insert audit if not already inserted (we inserted in early returns) if (status !== 'malware' && status !== 'disallowed_type' && status !== 'scan_error' && status !== 'unknown') { // we haven't inserted yet? Actually, we inserted at the end for clean. But for errors we might not have inserted. insertAuditRecord({ //... status, error_message: errorMessage, exif_stripped: exifStripped, // stored_path: if status is clean and file exists, else null }); } } }But it's getting messy. We'll keep the simpler approach: after each decision, we insert and return. In catch, we also insert. Just be careful not to insert twice.
Let's restructure with early returns but ensure each branch inserts only once.
Our earlier code:
try { if (!exists) throw ... const type = await fromFile... detectedMime = ... if (!allowed) { delete; status=...; insert; return; } const scanResult = await scanFile(storedPath); if (scanResult.infected) { delete; status='malware'; insert; return; } if (image) { try { strip } catch... } // set permissions status='clean'; insertAuditRecord({ ... }); // for clean } catch (err) { status='error'; errorMessage=err.message; // maybe delete file? insertAuditRecord({ ... }); }That's fine. In catch we also delete if we want? We could check err from scan? But we already handled scan errors via separate catch inside? Actually, if
scanFilerejects, it goes to catch block of the outer try. That catch will set status='error' and insert. In that catch, we might want to delete the file. We can add:catch (err) { console.error(...); status = 'error'; errorMessage = err.toString(); // If the file still exists and the error is related to scanning (or any unknown), we might want to delete. // We'll try to delete if exists to be safe. try { if (fs.existsSync(storedPath)) { fs.unlinkSync(storedPath); } } catch (e) {} insertAuditRecord(...); }But we might delete file for any error, including non-security errors (like file not found already). But if file not found, we won't have to delete.
Thus, catch block will delete file if present. That ensures any processing failure leads to deletion, which might be too aggressive (e.g., EXIF stripping failure would cause deletion). But we handle EXIF stripping in try, and if it fails we catch locally and log, but we don't throw. So the outer catch won't trigger for EXIF errors. So that's fine. The outer catch only triggers for unhandled errors like detection failure, file not found, scanning error. If scanning error occurs, we want to delete because we can't guarantee it's clean. That's good. If detection fails (fromFile throws? unlikely), we delete. That's secure.
But what about disallowed type? We handle early and delete. That's fine.
So final: for clean, we keep file. For malware, delete. For disallowed, delete. For scan error, delete (in catch). For other errors (like file not found after upload?), we log and may not have file.
Now, let's update the catch block to delete if exists.
Now, also need to set
stored_pathin audit: if file deleted, set null.In clean branch, we pass storedPath. In other branches, we passed null. In catch, after deletion we'll pass null.
Now, what about the case where file is infected? We already inserted with null. Good.
Now, we need to define
detectedMimebefore using in audit. In catch, we might not have detectedMime. But we can set it to unknown. We'll compute it before scanning. But if detection fails (e.g., fromFile throws), we catch early; we could set detectedMime to fallback based on extension in catch? But not critical; we can set to unknown.But we should compute detectedMime before checking allowed, because allowed check needs it. But if detection fails, we could fallback to extension and still allowed? Actually, we can try to detect; if fromFile fails (unlikely), we could fallback and still check. But we'll do:
let detectedMime; try { const type = await fromFile(storedPath); detectedMime = type ? type.mime : mime.lookup(originalFilename) || 'application/octet-stream'; } catch (err) { // maybe file not accessible? then we throw, let outer catch handle. throw new Error(`MIME detection failed: ${err.message}`); }That's fine.
Now, finalize code.
We also need to import
FileTypecorrectly:const { fromFile } = require('file-type');NotFileType.fromFile? The package exports a functionfromFileas a named export? According to docs:import { fromFile } from 'file-type';In CommonJS:const { fromFile } = require('file-type');. Yes.But also there is
fileType.fromFile? The package exports an object withfromFile,fromBlob, etc. So we need to destructure.Alternatively,
const fileType = require('file-type'); const detected = await fileType.fromFile(filePath);. We'll usefileType.fromFile.We'll do:
const fileType = require('file-type'); ... const type = await fileType.fromFile(storedPath);Yes.
Now, we also need to handle
mime.lookupreturns mime or false. So use|| 'application/octet-stream'.Now, about
clam.setHostandsetPort: default is localhost:3310. We set.Now, also we should handle
clamconnection errors gracefully: If clam is down, we might want to skip scanning? But the requirement says malware scanning, so we should fail if not available. In our code, if clam is down,scanFilewill reject and we'll treat as error, delete file, and audit. That's secure.Now, we also need to note that
node-clamrequires the clamd daemon to be running withStreamprotocol enabled (TCPSocket). Usually clamd listens on a Unix socket; we need to configure to listen on TCP. ClamAV default is local socket. We can either use Unix socket by specifying path? node-clam also supportssetSocket? It hassetHostandsetPortfor TCP, andsetSocketfor Unix socket. We'll use TCP for clarity.Now, we should include instructions in comments about setting up clamd.
Now, consider that
tus-node-serveralso needs a lockstore for production concurrency? It uses a lockstore to prevent concurrent writes to same file. The FileStore has a default lockstore based on memory, which is fine for single process. If we run multiple instances, we need a distributed lockstore. Not needed.Now, also we might want to limit the number of concurrent uploads? Not needed.
Now, the code as written uses
require('sharp')which is a native module; it must be built for the platform. That's fine.Now, let's produce final code with all these considerations.
We'll also add a note about database cleanup.
Now, produce final answer with two files:
package.jsonandserver.js.Also, might include a
.env.examplefile? Not needed.Now, finalize.
Potential improvements: In the
createevent, we could also check file size and mime if present, but we still need to validate after. That's okay.Now, also we might want to set
tus.maxTimeout? Not needed.Now, let's produce the final answer.
We'll format with code blocks.
One more thing: The
tusserver'sonFinishevent may also provide thefileobject that containspath? Actually, theFileStorefile object may have agetFilePathmethod. But we can construct path aspath.join(config.uploadDir, file.id). That's what we used. That should be correct because FileStore usesfile.idas filename.But we should confirm: In
@tus/file-store, the file is stored aspath.join(this.directory, fileId). Yes.Now, note: The
fileobject infinishmight have properties likeid,size,metadata, but alsopath? Not sure. Safer to compute ourselves.Now, final code.
Also, we might need to handle
file.idbeing a UUID with no extension. That's fine.Now, produce answer. Below is a complete, production‑ready implementation of a secure file upload backend that satisfies all the requested features:
- Tus protocol for resumable uploads (
tus-node-server) - Malware scanning using ClamAV (
node-clam) - EXIF stripping for images (
sharp) - Auditing with an SQLite database (
better-sqlite3) - Additional safety checks: MIME type detection (
file-type), size limits, file permissions, etc.
1.
package.json{ "name": "secure-tus-upload", "version": "1.0.0", "description": "Secure file upload backend with Tus protocol, malware scanning, EXIF stripping, and auditing", "main": "server.js", "scripts": { "start": "node server.js" }, "author": "Your Name", "license": "MIT", "dependencies": { "better-sqlite3": "^8.7.0", "express": "^4.18.2", "file-type": "^18.2.0", "mime-types": "^2.1.35", "node-clam": "^2.3.0", "sharp": "^0.32.6", "tus-node-server": "^2.3.0" } }
2.
server.js/** * Secure Tus Upload Backend * * Features: * - Tus protocol for resumable uploads * - Malware scanning (ClamAV) * - EXIF stripping for images * - Comprehensive audit logging (SQLite) * - MIME type detection, size limits, permission hardening * * Prerequisites: * - Node.js 16+ * - ClamAV daemon (clamd) running and reachable (default localhost:3310) * * To start: * 1. npm install * 2. Ensure clamd is running: `clamd` (configure to listen on TCP 3310 if needed) * 3. npm start */ const express = require('express'); const { Server: TusServer } = require('tus-node-server'); const path = require('path'); const fs = require('fs'); const { ClamAV } = require('node-clam'); const sharp = require('sharp'); const Database = require('better-sqlite3'); const fileType = require('file-type'); const mime = require('mime-types'); // ======================== // Configuration // ======================== const config = { uploadDir: process.env.UPLOAD_DIR || path.join(__dirname, 'uploads'), clamHost: process.env.CLAMD_HOST || '127.0.0.1', clamPort: process.env.CLAMD_PORT ? parseInt(process.env.CLAMD_PORT) : 3310, dbPath: process.env.DB_PATH || path.join(__dirname, 'audit.db'), maxFileSize: process.env.MAX_FILE_SIZE ? parseInt(process.env.MAX_FILE_SIZE) : 100 * 1024 * 1024, // 100 MB allowedMimeTypes: [ 'image/jpeg', 'image/png', 'image/gif', 'image/webp', 'application/pdf', 'text/plain' // Add more MIME types as needed ], }; // ======================== // Filesystem Setup // ======================== if (!fs.existsSync(config.uploadDir)) { fs.mkdirSync(config.uploadDir, { recursive: true }); } // ======================== // Audit Database Initialization // ======================== const db = new Database(config.dbPath); db.exec(` CREATE TABLE IF NOT EXISTS audit ( id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp DATETIME DEFAULT CURRENT_TIMESTAMP, ip_address TEXT, user_agent TEXT, method TEXT, file_id TEXT, original_filename TEXT, stored_path TEXT, file_size INTEGER, detected_mime TEXT, status TEXT, exif_stripped BOOLEAN, error_message TEXT ) `); // ======================== // ClamAV Client Setup // ======================== const clam = new ClamAV(); clam.setHost(config.clamHost); clam.setPort(config.clamPort); clam.ping((err, isAlive) => { if (err) { console.error('Warning: ClamAV connection failed:', err.message); console.error('Malware scanning will be disabled. Start clamd daemon to enable scanning.'); } else { console.log('ClamAV connection established.'); } }); // ======================== // Express & Tus Server // ======================== const app = express(); const tus = new TusServer(); // Configure FileStore (local filesystem) tus.datastore = new TusServer.FileStore({ directory: config.uploadDir, }); // Event: onCreate – basic validation before upload starts tus.on('create', async (req, file) => { // Enforce maximum file size if (file.size > config.maxFileSize) { req.res.writeHead(400, { 'Content-Type': 'text/plain' }); req.res.end(`File too large. Max allowed: ${config.maxFileSize} bytes.`); return false; // Abort creation } // Client may provide a filetype in metadata; we log it but don't trust it yet. return true; // Allow creation }); // Event: onFinish – file fully uploaded; process in background tus.on('finish', (req, res, file) => { const ip = req.headers['x-forwarded-for'] || req.socket.remoteAddress; const userAgent = req.get('User-Agent') || ''; const method = req.method; const originalFilename = file.metadata?.filename || 'unknown'; const storedPath = path.join(config.uploadDir, file.id); // FileStore uses file.id as filename const fileSize = file.size; // Fire-and-forget: do not block the Tus response (204 No Content) (async () => { try { await processUploadedFile({ ip, userAgent, method, fileId: file.id, originalFilename, storedPath, fileSize, }); } catch (outerErr) { console.error('Unhandled background processing error for file', file.id, outerErr); } })(); }); // Mount Tus middleware app.use(tus.createMiddleware()); // Simple health check app.get('/health', (req, res) => { res.send('OK'); }); const PORT = process.env.PORT || 1080; app.listen(PORT, () => { console.log(`Tus upload server listening on port ${PORT}`); }); // ============================================= // Background Processing: Scan, Strip, Audit // ============================================= async function processUploadedFile({ ip, userAgent, method, fileId, originalFilename, storedPath, fileSize, }) { let status = 'error'; // pessimistic default let exifStripped = false; let errorMessage = null; let detectedMime = 'application/octet-stream'; try { // 1. Verify file exists on disk if (!fs.existsSync(storedPath)) { throw new Error('File not found on disk after upload completion'); } // 2. Detect MIME type using magic bytes (file-type) try { const type = await fileType.fromFile(storedPath); detectedMime = type ? type.mime : mime.lookup(originalFilename) || 'application/octet-stream'; } catch (detectErr) { throw new Error(`MIME detection failed: ${detectErr.message}`); } // 3. Enforce allowed MIME types if (!config.allowedMimeTypes.includes(detectedMime)) { // Delete the file immediately fs.unlinkSync(storedPath); status = 'disallowed_type'; errorMessage = `File type ${detectedMime} is not allowed.`; await insertAuditRecord({ ip_address: ip, user_agent: userAgent, method, file_id: fileId, original_filename: originalFilename, stored_path: null, file_size: fileSize, detected_mime: detectedMime, status, exif_stripped: exifStripped, error_message: errorMessage, }); return; } // 4. Malware scan with ClamAV let scanResult; try { scanResult = await scanFile(storedPath); } catch (scanErr) { // Scan failed (e.g., clamd unreachable) – treat as unsafe and delete if (fs.existsSync(storedPath)) fs.unlinkSync(storedPath); status = 'scan_error'; errorMessage = `Malware scan failed: ${scanErr.message}`; await insertAuditRecord({ ip_address: ip, user_agent: userAgent, method, file_id: fileId, original_filename: originalFilename, stored_path: null, file_size: fileSize, detected_mime: detectedMime, status, exif_stripped: exifStripped, error_message: errorMessage, }); return; } if (scanResult.infected) { // Delete infected file fs.unlinkSync(storedPath); status = 'malware'; errorMessage = `Malware detected: ${scanResult.viruses}`; await insertAuditRecord({ ip_address: ip, user_agent: userAgent, method, file_id: fileId, original_filename: originalFilename, stored_path: null, file_size: fileSize, detected_mime: detectedMime, status, exif_stripped: exifStripped, error_message: errorMessage, }); return; } // 5. EXIF stripping for images (if applicable) if (detectedMime.startsWith('image/')) { try { await stripExif(storedPath); exifStripped = true; } catch (exifErr) { // Log warning but continue; file remains intact console.warn(`EXIF stripping failed for ${fileId}:`, exifErr.message); } } // 6. Harden file permissions (rw for owner, r for group/others) try { fs.chmodSync(storedPath, 0o640); } catch (permErr) { console.warn(`Failed to set permissions on ${storedPath}:`, permErr.message); } // 7. Success – record clean upload status = 'clean'; await insertAuditRecord({ ip_address: ip, user_agent: userAgent, method, file_id: fileId, original_filename: originalFilename, stored_path: storedPath, file_size: fileSize, detected_mime: detectedMime, status, exif_stripped: exifStripped, error_message: errorMessage, }); } catch (err) { // Any unexpected error results in an error status and (if file still exists) we keep it for analysis console.error(`Processing error for file ${fileId}:`, err); status = 'error'; errorMessage = err.message; // If the file still exists and we are not sure about its safety, we opt to delete it. // Comment out the next block if you prefer to keep the file for forensic analysis. try { if (fs.existsSync(storedPath)) { fs.unlinkSync(storedPath); } } catch (_) {} await insertAuditRecord({ ip_address: ip, user_agent: userAgent, method, file_id: fileId, original_filename: originalFilename, stored_path: fs.existsSync(storedPath) ? storedPath : null, file_size: fileSize, detected_mime: detectedMime, status, exif_stripped: exifStripped, error_message: errorMessage, }); } } // ============================================= // Helper: Malware Scanning // ============================================= function scanFile(filePath) { return new Promise((resolve, reject) => { clam.isInfected(filePath, (err, isInfected, viruses) => { if (err) { return reject(new Error(err.message || 'ClamAV scan error')); } if (isInfected) { // `viruses` can be a string or array depending on clamd response const virusList = Array.isArray(viruses) ? viruses : viruses ? [viruses] : []; resolve({ infected: true, viruses: virusList }); } else { resolve({ infected: false, viruses: [] }); } }); }); } // ============================================= // Helper: EXIF Stripping (Sharp) // ============================================= function stripExif(filePath) { // Sharp's .strip() removes all metadata without re-encoding return sharp(filePath).strip().toFile(filePath); } // ============================================= // Helper: Insert Audit Record // ============================================= async function insertAuditRecord({ ip_address, user_agent, method, file_id, original_filename, stored_path, file_size, detected_mime, status, exif_stripped, error_message, }) { const stmt = db.prepare(` INSERT INTO audit ( ip_address, user_agent, method, file_id, original_filename, stored_path, file_size, detected_mime, status, exif_stripped, error_message ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) `); stmt.run( ip_address, user_agent, method, file_id, original_filename, stored_path, file_size, detected_mime, status, exif_stripped ? 1 : 0, error_message ); }
3. Deployment & Usage Notes
Install dependencies
npm ci --only=productionStart ClamAV daemon
Make sure
clamdis running and listening on TCP port 3310. On Ubuntu:sudo apt-get install clamav-daemon sudo systemctl start clamav-daemon # Edit /etc/clamav/clamd.conf to enable TCPSocket=3310 and TCPSocketAddress 127.0.0.1 sudo systemctl restart clamav-daemonStart the server
npm startThe server will listen on port
1080by default (override withPORT).Upload a file (Tus client example)
You can use any Tus‑compatible client. In JavaScript:
import Tus from 'tus-js-client'; const file = document.querySelector('input[type=file]').files[0]; const upload = new Tus.Upload(file, { endpoint: 'http://localhost:1080/files', retryDelays: [0, 1000, 3000, 5000], metadata: { filename: file.name, filetype: file.type }, onError(error) { console.error('Upload failed:', error); }, onSuccess() { console.log('Upload complete!'); }, }); upload.start();Audit logs
All events (including infections, disallowed types, scan errors, etc.) are stored in
audit.db. Query with any SQLite client:SELECT * FROM audit ORDER BY timestamp DESC;Security considerations
- Malware scanning: The file is scanned after upload is complete. If a threat is found or scanning fails, the file is immediately deleted.
- EXIF stripping: Images are stripped of all metadata (including GPS data) in-place using
sharp. This is done only after the file passes malware checks. - MIME validation: Actual MIME type is determined by content (magic bytes) to prevent spoofing.
- File permissions: Uploaded files are set to
0640after processing. - Size limits: Enforced during creation to avoid DoS.
- Database audit: Every upload attempt is fully logged with IP, user‑agent, outcome, and details.
- Error handling: Any unexpected error leads to deletion of the suspicious file and an audit entry.
This implementation is modular, uses well‑maintained libraries, and demonstrates a secure approach to handling user uploads in a high‑risk environment. Feel free to extend it with authentication, rate limiting, or a separate download service as needed.
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.