verdaccio-security-filter 1.3.7 → 1.3.9

package/README.md

@@ -430,10 +430,12 @@ middlewares:
 | `cveCheck.enabled` | `boolean` | `false` | Enable CVE scanning |
 | `cveCheck.databases` | `string[]` | `['osv']` | Databases: `osv`, `snyk`, `github` |
 | `cveCheck.severity` | `string[]` | `['high', 'critical']` | Severity levels to check |
-| `cveCheck.autoBlock` | `boolean` | `false` | Auto-block vulnerable packages |
+| `cveCheck.autoBlock` | `boolean` | `false` | Remove vulnerable versions from metadata (whole package blocked if every version is vulnerable) |
 | `cveCheck.updateInterval` | `number` | `24` | Cache update interval (hours) |
 | `cveCheck.cacheDir` | `string` | `./.security-cache` | Cache directory path |
 
+> **Note on `autoBlock` and dist-tags:** only the vulnerable versions are removed; unaffected versions stay installable. Any dist-tag (including `latest`) that points to a removed version is dropped and **not** re-pointed to another version. If `latest` is vulnerable, `npm install <pkg>` without a version or range will fail - install an explicit safe version or range instead (e.g. `npm install <pkg>@^1.2.0`).
+
 ### License Options
 
 | Option | Type | Default | Description |

package/build/index.js

@@ -277,7 +277,7 @@ class SecurityFilterPlugin {
     }
     filter_metadata(packageInfo) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e, _f, _g, _h;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
             let pkg = packageInfo;
             const packageName = pkg.name;
             this.logger.info(`[filter_metadata] --> Processing: ${packageName}`);
@@ -300,41 +300,65 @@ class SecurityFilterPlugin {
                 }
                 if ((_a = this.config.cveCheck) === null || _a === void 0 ? void 0 : _a.enabled) {
                     const versions = Object.keys(pkg.versions || {});
-                    const vulnerableVersions = [];
-                    const BATCH_SIZE = 10;
-                    for (let i = 0; i < versions.length; i += BATCH_SIZE) {
-                        const batch = versions.slice(i, i + BATCH_SIZE);
-                        const results = yield Promise.allSettled(batch.map(version => this.cveChecker.checkPackage(packageName, version)));
-                        results.forEach((result, index) => {
-                            if (result.status === 'fulfilled' && result.value.isVulnerable) {
-                                const version = batch[index];
-                                vulnerableVersions.push(version);
-                                this.logger.warn(`[filter_metadata] CVE found in ${packageName}@${version}: ${result.value.vulnerabilities.length} vulnerabilities`);
-                            }
-                            else if (result.status === 'rejected') {
-                                this.logger.error(`[filter_metadata] CVE check failed for ${packageName}@${batch[index]}: ${result.reason}`);
-                            }
-                        });
+                    let vulnerableVersions = [];
+                    try {
+                        const results = yield this.cveChecker.checkVersions(packageName, versions);
+                        vulnerableVersions = results.filter(result => result.isVulnerable).map(result => result.version);
+                    }
+                    catch (error) {
+                        this.logger.error(`[filter_metadata] CVE check failed for ${packageName}: ${error.message}`);
+                        if (((_b = this.config.errorHandling) === null || _b === void 0 ? void 0 : _b.onCveCheckError) === 'fail-closed') {
+                            const reason = `CVE check failed (fail-closed mode): ${error.message}`;
+                            this.metrics.recordBlock(packageName, '*', reason);
+                            return Object.assign(Object.assign({}, pkg), { versions: {}, 'dist-tags': {}, security: {
+                                    blocked: true,
+                                    reason,
+                                    plugin: {
+                                        name: 'verdaccio-security-filter',
+                                        version: '2.0.0',
+                                    },
+                                    blockedAt: new Date().toISOString(),
+                                } });
+                        }
+                    }
+                    if (vulnerableVersions.length > 0 && !this.config.cveCheck.autoBlock) {
+                        this.logger.warn(`[filter_metadata] CVE found in ${packageName}: ${vulnerableVersions.length} vulnerable version(s), autoBlock is off`);
                     }
                     if (this.config.cveCheck.autoBlock && vulnerableVersions.length > 0) {
                         const reason = `Package has ${vulnerableVersions.length} vulnerable version(s)`;
-                        this.logger.warn(`[filter_metadata] CVE BLOCKED: ${packageName} - ${reason}`);
-                        this.metrics.recordBlock(packageName, '*', reason);
-                        return Object.assign(Object.assign({}, pkg), { versions: {}, 'dist-tags': {}, security: {
-                                blocked: true,
-                                reason,
-                                vulnerableVersions,
-                                plugin: {
-                                    name: 'verdaccio-security-filter',
-                                    version: '2.0.0',
-                                },
-                                blockedAt: new Date().toISOString(),
-                            } });
+                        if (vulnerableVersions.length === versions.length) {
+                            this.logger.warn(`[filter_metadata] CVE BLOCKED: ${packageName} - ${reason}`);
+                            this.metrics.recordBlock(packageName, '*', reason);
+                            return Object.assign(Object.assign({}, pkg), { versions: {}, 'dist-tags': {}, security: {
+                                    blocked: true,
+                                    reason,
+                                    vulnerableVersions,
+                                    plugin: {
+                                        name: 'verdaccio-security-filter',
+                                        version: '2.0.0',
+                                    },
+                                    blockedAt: new Date().toISOString(),
+                                } });
+                        }
+                        this.logger.warn(`[filter_metadata] CVE FILTERED: ${packageName} - ${reason}: ${vulnerableVersions.join(', ')}`);
+                        const filteredVersions = Object.assign({}, pkg.versions);
+                        for (const version of vulnerableVersions) {
+                            delete filteredVersions[version];
+                            this.metrics.recordBlock(packageName, version, reason);
+                        }
+                        const filteredDistTags = Object.assign({}, pkg['dist-tags']);
+                        for (const [tag, tagVersion] of Object.entries(filteredDistTags)) {
+                            if (vulnerableVersions.includes(tagVersion)) {
+                                delete filteredDistTags[tag];
+                                this.logger.debug(`[filter_metadata] Removed dist-tag "${tag}" pointing to vulnerable version ${tagVersion}`);
+                            }
+                        }
+                        pkg = Object.assign(Object.assign({}, pkg), { versions: filteredVersions, 'dist-tags': filteredDistTags });
                     }
                 }
                 if (this.config.licenses && this.config.licenses.allowed && this.config.licenses.allowed.length > 0) {
-                    const latestVersion = (_b = pkg['dist-tags']) === null || _b === void 0 ? void 0 : _b.latest;
-                    if (latestVersion && ((_c = pkg.versions) === null || _c === void 0 ? void 0 : _c[latestVersion])) {
+                    const latestVersion = (_c = pkg['dist-tags']) === null || _c === void 0 ? void 0 : _c.latest;
+                    if (latestVersion && ((_d = pkg.versions) === null || _d === void 0 ? void 0 : _d[latestVersion])) {
                         const versionData = pkg.versions[latestVersion];
                         const licenseResult = this.licenseChecker.checkLicense(versionData);
                         if (!licenseResult.allowed) {
@@ -353,7 +377,7 @@ class SecurityFilterPlugin {
                         }
                     }
                 }
-                if ((_d = this.config.packageAge) === null || _d === void 0 ? void 0 : _d.enabled) {
+                if ((_e = this.config.packageAge) === null || _e === void 0 ? void 0 : _e.enabled) {
                     const ageResult = this.packageAgeChecker.checkPackageAge(pkg);
                     if (!ageResult.allowed && !ageResult.warnOnly) {
                         this.logger.warn(`[filter_metadata] AGE BLOCKED: ${packageName} - ${ageResult.reason}`);
@@ -400,9 +424,9 @@ class SecurityFilterPlugin {
                         }
                     }
                 }
-                if ((_e = this.config.authorFilter) === null || _e === void 0 ? void 0 : _e.enabled) {
-                    const latestVersion = (_f = pkg['dist-tags']) === null || _f === void 0 ? void 0 : _f.latest;
-                    if (latestVersion && ((_g = pkg.versions) === null || _g === void 0 ? void 0 : _g[latestVersion])) {
+                if ((_f = this.config.authorFilter) === null || _f === void 0 ? void 0 : _f.enabled) {
+                    const latestVersion = (_g = pkg['dist-tags']) === null || _g === void 0 ? void 0 : _g.latest;
+                    if (latestVersion && ((_h = pkg.versions) === null || _h === void 0 ? void 0 : _h[latestVersion])) {
                         const versionData = pkg.versions[latestVersion];
                         const authorResult = this.authorChecker.checkAuthor(versionData);
                         if (!authorResult.allowed && !this.config.authorFilter.warnOnly) {
@@ -440,7 +464,7 @@ class SecurityFilterPlugin {
             }
             catch (error) {
                 this.logger.error(`[filter_metadata] Error processing ${packageName}: ${error.message}`);
-                const errorStrategy = ((_h = this.config.errorHandling) === null || _h === void 0 ? void 0 : _h.onFilterError) || 'fail-open';
+                const errorStrategy = ((_j = this.config.errorHandling) === null || _j === void 0 ? void 0 : _j.onFilterError) || 'fail-open';
                 if (errorStrategy === 'fail-closed') {
                     this.logger.warn(`[filter_metadata] Error handling: fail-closed - BLOCKING ${packageName}`);
                     this.metrics.recordBlock(packageName, '*', `Error during processing: ${error.message}`);

package/build/lib/cve-checker.d.ts

@@ -2,19 +2,29 @@ import { CVECheckConfig, CVECheckResult } from '../types';
 export declare class CVEChecker {
     private config;
     private cache;
-    private lastUpdate;
+    private failedUntil;
+    private inFlight;
+    private matches;
     private readonly MAX_CACHE_SIZE;
     private saveTimer;
     private readonly SAVE_DEBOUNCE_MS;
+    private dirty;
     constructor(config?: CVECheckConfig);
     checkPackage(packageName: string, version: string): Promise<CVECheckResult>;
-    private fetchVulnerabilities;
+    checkVersions(packageName: string, versions: string[]): Promise<CVECheckResult[]>;
+    private getPackageEntry;
+    private refresh;
     private fetchFromOSV;
-    private sleep;
+    private queryOSV;
+    private toCachedVulnerability;
     private mapOSVSeverity;
-    private isCacheStale;
+    private mapDatabaseSpecificSeverity;
+    private scoreToSeverity;
+    private computeCVSSv3BaseScore;
+    private get cacheFile();
     private loadCache;
     private debouncedSaveCache;
+    private serializeCache;
     private saveCache;
     clearCache(): void;
     destroy(): void;

package/build/lib/cve-checker.js

@@ -45,13 +45,73 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CVEChecker = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const semver = __importStar(require("semver"));
 const lru_cache_1 = require("./lru-cache");
+const CVSS_V3_WEIGHTS = {
+    AV: { N: 0.85, A: 0.62, L: 0.55, P: 0.2 },
+    AC: { L: 0.77, H: 0.44 },
+    UI: { N: 0.85, R: 0.62 },
+    PR_UNCHANGED: { N: 0.85, L: 0.62, H: 0.27 },
+    PR_CHANGED: { N: 0.85, L: 0.68, H: 0.5 },
+    CIA: { H: 0.56, L: 0.22, N: 0 },
+};
+function roundUpCvssScore(value) {
+    const intValue = Math.round(value * 100000);
+    if (intValue % 10000 === 0) {
+        return intValue / 100000;
+    }
+    return (Math.floor(intValue / 10000) + 1) / 10;
+}
+const OSV_QUERY_URL = 'https://api.osv.dev/v1/query';
+const OSV_TIMEOUT_MS = 5000;
+const OSV_ATTEMPTS = 2;
+const OSV_RETRY_DELAY_MS = 500;
+const FAILURE_TTL_MS = 60000;
+function compareVersions(a, b) {
+    try {
+        return semver.compare(a, b);
+    }
+    catch (_a) {
+        return NaN;
+    }
+}
+function isInRange(events, version) {
+    let affected = false;
+    for (const event of events) {
+        if (event.introduced !== undefined) {
+            if (event.introduced === '0' || compareVersions(version, event.introduced) >= 0)
+                affected = true;
+        }
+        else if (event.fixed !== undefined) {
+            if (compareVersions(version, event.fixed) >= 0)
+                affected = false;
+        }
+        else if (event.last_affected !== undefined) {
+            if (compareVersions(version, event.last_affected) > 0)
+                affected = false;
+        }
+    }
+    return affected;
+}
+function isAffected(vuln, version, parsed) {
+    const informative = vuln.affected.filter(a => a.versions || a.ranges.length > 0);
+    if (informative.length === 0) {
+        return true;
+    }
+    return informative.some(a => {
+        var _a;
+        return ((_a = a.versions) === null || _a === void 0 ? void 0 : _a.includes(version)) ||
+            (parsed !== null && a.ranges.some(events => isInRange(events, parsed)));
+    });
+}
 class CVEChecker {
     constructor(config) {
-        this.lastUpdate = 0;
+        this.inFlight = new Map();
+        this.matches = new WeakMap();
         this.MAX_CACHE_SIZE = 1000;
         this.saveTimer = null;
         this.SAVE_DEBOUNCE_MS = 5000;
+        this.dirty = false;
         this.config = {
             enabled: (config === null || config === void 0 ? void 0 : config.enabled) || false,
             databases: (config === null || config === void 0 ? void 0 : config.databases) || ['osv'],
@@ -61,166 +121,249 @@ class CVEChecker {
             cacheDir: (config === null || config === void 0 ? void 0 : config.cacheDir) || './.security-cache',
         };
         this.cache = new lru_cache_1.LRUCache(this.MAX_CACHE_SIZE);
+        this.failedUntil = new lru_cache_1.LRUCache(this.MAX_CACHE_SIZE);
         if (this.config.enabled) {
             this.loadCache();
         }
     }
     checkPackage(packageName, version) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.config.enabled) {
-                return {
+            return (yield this.checkVersions(packageName, [version]))[0];
+        });
+    }
+    checkVersions(packageName, versions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const checkedAt = new Date().toISOString();
+            if (!this.config.enabled || !this.config.databases.includes('osv')) {
+                return versions.map(version => ({
                     package: packageName,
                     version,
                     vulnerabilities: [],
                     isVulnerable: false,
-                    checkedAt: new Date().toISOString(),
-                };
+                    checkedAt,
+                }));
             }
-            const cacheKey = `${packageName}@${version}`;
-            if (this.cache.has(cacheKey) && !this.isCacheStale()) {
-                return this.cache.get(cacheKey);
+            const entry = yield this.getPackageEntry(packageName);
+            let memo = this.matches.get(entry);
+            if (!memo) {
+                memo = new Map();
+                this.matches.set(entry, memo);
             }
-            const vulnerabilities = yield this.fetchVulnerabilities(packageName, version);
-            const filteredVulnerabilities = vulnerabilities.filter(vuln => this.config.severity.includes(vuln.severity));
-            const result = {
-                package: packageName,
-                version,
-                vulnerabilities: filteredVulnerabilities,
-                isVulnerable: filteredVulnerabilities.length > 0,
-                checkedAt: new Date().toISOString(),
-            };
-            this.cache.set(cacheKey, result);
-            this.debouncedSaveCache();
-            return result;
+            const relevant = entry.vulns.filter(vuln => this.config.severity.includes(vuln.severity));
+            return versions.map(version => {
+                let vulnerabilities = memo.get(version);
+                if (!vulnerabilities) {
+                    const parsed = semver.parse(version);
+                    vulnerabilities = relevant.filter(vuln => isAffected(vuln, version, parsed));
+                    memo.set(version, vulnerabilities);
+                }
+                return {
+                    package: packageName,
+                    version,
+                    vulnerabilities,
+                    isVulnerable: vulnerabilities.length > 0,
+                    checkedAt,
+                };
+            });
         });
     }
-    fetchVulnerabilities(packageName, version) {
+    getPackageEntry(packageName) {
+        const cached = this.cache.get(packageName);
+        const ttlMs = this.config.updateInterval * 60 * 60 * 1000;
+        if (cached && Date.now() - cached.checkedAt <= ttlMs) {
+            return Promise.resolve(cached);
+        }
+        let pending = this.inFlight.get(packageName);
+        if (!pending) {
+            pending = this.refresh(packageName, cached).finally(() => this.inFlight.delete(packageName));
+            this.inFlight.set(packageName, pending);
+        }
+        return pending;
+    }
+    refresh(packageName, stale) {
         return __awaiter(this, void 0, void 0, function* () {
-            const vulnerabilities = [];
-            for (const database of this.config.databases) {
+            var _a;
+            let failure;
+            if (((_a = this.failedUntil.get(packageName)) !== null && _a !== void 0 ? _a : 0) > Date.now()) {
+                failure = new Error('OSV lookup failed recently, not retrying yet');
+            }
+            else {
                 try {
-                    switch (database) {
-                        case 'osv':
-                            vulnerabilities.push(...yield this.fetchFromOSV(packageName, version));
-                            break;
-                        case 'snyk':
-                            break;
-                        case 'github':
-                            break;
-                    }
+                    const entry = { checkedAt: Date.now(), vulns: yield this.fetchFromOSV(packageName) };
+                    this.cache.set(packageName, entry);
+                    this.failedUntil.delete(packageName);
+                    this.debouncedSaveCache();
+                    return entry;
                 }
                 catch (error) {
-                    const message = error instanceof Error ? error.message : String(error);
-                    console.error(`[CVE Checker] Error fetching from ${database}:`, message);
+                    failure = error;
+                    this.failedUntil.set(packageName, Date.now() + FAILURE_TTL_MS);
                 }
             }
-            return vulnerabilities;
+            if (stale) {
+                const message = failure instanceof Error ? failure.message : String(failure);
+                console.warn(`[CVE Checker] Using stale data for ${packageName}: ${message}`);
+                return stale;
+            }
+            throw failure;
+        });
+    }
+    fetchFromOSV(packageName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const vulns = [];
+            let pageToken;
+            do {
+                const data = yield this.queryOSV({
+                    package: { name: packageName, ecosystem: 'npm' },
+                    page_token: pageToken,
+                });
+                for (const vuln of data.vulns || []) {
+                    vulns.push(this.toCachedVulnerability(vuln, packageName));
+                }
+                pageToken = data.next_page_token;
+            } while (pageToken);
+            return vulns;
         });
     }
-    fetchFromOSV(packageName, version) {
+    queryOSV(body) {
         return __awaiter(this, void 0, void 0, function* () {
-            const maxRetries = 3;
-            const retryDelay = 1000;
-            for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            for (let attempt = 1;; attempt++) {
                 try {
-                    const controller = new AbortController();
-                    const timeoutId = setTimeout(() => controller.abort(), 10000);
-                    const response = yield fetch('https://api.osv.dev/v1/query', {
+                    const response = yield fetch(OSV_QUERY_URL, {
                         method: 'POST',
-                        headers: {
-                            'Content-Type': 'application/json',
-                        },
-                        body: JSON.stringify({
-                            package: {
-                                name: packageName,
-                                ecosystem: 'npm',
-                            },
-                            version: version,
-                        }),
-                        signal: controller.signal,
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify(body),
+                        signal: AbortSignal.timeout(OSV_TIMEOUT_MS),
                     });
-                    clearTimeout(timeoutId);
                     if (!response.ok) {
-                        if (response.status === 429 && attempt < maxRetries) {
-                            const waitTime = retryDelay * Math.pow(2, attempt - 1);
-                            console.warn(`[CVE Checker] Rate limited, retrying in ${waitTime}ms (attempt ${attempt}/${maxRetries})`);
-                            yield this.sleep(waitTime);
-                            continue;
-                        }
                         throw new Error(`OSV API returned ${response.status}`);
                     }
-                    const data = yield response.json();
-                    if (!data.vulns || data.vulns.length === 0) {
-                        return [];
-                    }
-                    return data.vulns.map((vuln) => {
-                        var _a, _b, _c, _d, _e, _f, _g;
-                        return ({
-                            id: vuln.id,
-                            severity: this.mapOSVSeverity(vuln.severity),
-                            summary: vuln.summary || vuln.details || 'No description available',
-                            affectedVersions: ((_a = vuln.affected) === null || _a === void 0 ? void 0 : _a.map((a) => { var _a; return (_a = a.ranges) === null || _a === void 0 ? void 0 : _a.map((r) => { var _a; return (_a = r.events) === null || _a === void 0 ? void 0 : _a.map((e) => e.introduced || e.fixed).filter(Boolean); }).flat(); }).flat()) || [],
-                            fixedVersion: (_g = (_f = (_e = (_d = (_c = (_b = vuln.affected) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.ranges) === null || _d === void 0 ? void 0 : _d[0]) === null || _e === void 0 ? void 0 : _e.events) === null || _f === void 0 ? void 0 : _f.find((e) => e.fixed)) === null || _g === void 0 ? void 0 : _g.fixed,
-                            publishedDate: vuln.published || new Date().toISOString(),
-                            source: 'osv',
-                        });
-                    });
+                    return yield response.json();
                 }
                 catch (error) {
-                    const message = error instanceof Error ? error.message : String(error);
-                    if (attempt === maxRetries) {
-                        console.error(`[CVE Checker] OSV API error after ${maxRetries} attempts:`, message);
-                        return [];
-                    }
-                    if (error instanceof Error && error.name === 'AbortError') {
-                        console.warn(`[CVE Checker] Request timeout, retrying (attempt ${attempt}/${maxRetries})`);
+                    if (attempt >= OSV_ATTEMPTS) {
+                        throw error;
                     }
-                    else {
-                        console.warn(`[CVE Checker] Request failed, retrying (attempt ${attempt}/${maxRetries}):`, message);
-                    }
-                    yield this.sleep(retryDelay * attempt);
+                    yield new Promise(resolve => setTimeout(resolve, OSV_RETRY_DELAY_MS));
                 }
             }
-            return [];
         });
     }
-    sleep(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
+    toCachedVulnerability(vuln, packageName) {
+        var _a;
+        const affected = (vuln.affected || [])
+            .filter(a => { var _a; return !((_a = a.package) === null || _a === void 0 ? void 0 : _a.name) || a.package.name === packageName; })
+            .map(a => {
+            var _a;
+            return ({
+                versions: ((_a = a.versions) === null || _a === void 0 ? void 0 : _a.length) ? a.versions : undefined,
+                ranges: (a.ranges || []).filter(r => r.type !== 'GIT').map(r => r.events || []),
+            });
+        });
+        const events = affected.flatMap(a => a.ranges.flat());
+        return {
+            id: vuln.id || 'unknown',
+            severity: this.mapOSVSeverity(vuln),
+            summary: vuln.summary || 'No description available',
+            affectedVersions: events.map(e => e.introduced || e.fixed).filter((v) => !!v),
+            fixedVersion: (_a = events.find(e => e.fixed)) === null || _a === void 0 ? void 0 : _a.fixed,
+            publishedDate: vuln.published || new Date().toISOString(),
+            source: 'osv',
+            affected,
+        };
     }
-    mapOSVSeverity(osvSeverity) {
-        if (!osvSeverity || osvSeverity.length === 0) {
-            return 'medium';
+    mapOSVSeverity(vuln) {
+        var _a, _b, _c, _d;
+        const databaseSeverity = this.mapDatabaseSpecificSeverity((_a = vuln === null || vuln === void 0 ? void 0 : vuln.database_specific) === null || _a === void 0 ? void 0 : _a.severity);
+        if (databaseSeverity) {
+            return databaseSeverity;
         }
-        const severity = osvSeverity[0];
-        if (severity.type === 'CVSS_V3') {
-            const score = parseFloat(severity.score);
-            if (score >= 9.0)
-                return 'critical';
-            if (score >= 7.0)
-                return 'high';
-            if (score >= 4.0)
-                return 'medium';
-            return 'low';
+        const cvssV3 = (_b = vuln === null || vuln === void 0 ? void 0 : vuln.severity) === null || _b === void 0 ? void 0 : _b.find(entry => entry.type === 'CVSS_V3');
+        const score = cvssV3 ? this.computeCVSSv3BaseScore(cvssV3.score) : null;
+        if (score !== null) {
+            return this.scoreToSeverity(score);
+        }
+        if ((_c = vuln === null || vuln === void 0 ? void 0 : vuln.severity) === null || _c === void 0 ? void 0 : _c.some(entry => entry.type === 'CVSS_V4')) {
+            console.debug(`[CVE Checker] ${(_d = vuln.id) !== null && _d !== void 0 ? _d : 'unknown vulnerability'} only has a CVSS_V4 vector, which is not scored yet - defaulting severity to medium`);
         }
         return 'medium';
     }
-    isCacheStale() {
-        const now = Date.now();
-        const updateIntervalMs = this.config.updateInterval * 60 * 60 * 1000;
-        return now - this.lastUpdate > updateIntervalMs;
+    mapDatabaseSpecificSeverity(severity) {
+        if (typeof severity !== 'string') {
+            return null;
+        }
+        switch (severity.toUpperCase()) {
+            case 'LOW': return 'low';
+            case 'MODERATE': return 'medium';
+            case 'HIGH': return 'high';
+            case 'CRITICAL': return 'critical';
+            default: return null;
+        }
+    }
+    scoreToSeverity(score) {
+        if (score >= 9.0)
+            return 'critical';
+        if (score >= 7.0)
+            return 'high';
+        if (score >= 4.0)
+            return 'medium';
+        return 'low';
+    }
+    computeCVSSv3BaseScore(vector) {
+        if (typeof vector !== 'string') {
+            return null;
+        }
+        const metrics = {};
+        for (const part of vector.split('/')) {
+            const [key, value] = part.split(':');
+            if (key && value) {
+                metrics[key] = value;
+            }
+        }
+        const scope = metrics.S;
+        const av = CVSS_V3_WEIGHTS.AV[metrics.AV];
+        const ac = CVSS_V3_WEIGHTS.AC[metrics.AC];
+        const ui = CVSS_V3_WEIGHTS.UI[metrics.UI];
+        const pr = scope === 'C'
+            ? CVSS_V3_WEIGHTS.PR_CHANGED[metrics.PR]
+            : CVSS_V3_WEIGHTS.PR_UNCHANGED[metrics.PR];
+        const c = CVSS_V3_WEIGHTS.CIA[metrics.C];
+        const i = CVSS_V3_WEIGHTS.CIA[metrics.I];
+        const a = CVSS_V3_WEIGHTS.CIA[metrics.A];
+        if ((scope !== 'U' && scope !== 'C') || [av, ac, ui, pr, c, i, a].some(value => value === undefined)) {
+            return null;
+        }
+        const impactSubScoreBase = 1 - (1 - c) * (1 - i) * (1 - a);
+        const impactSubScore = scope === 'U'
+            ? 6.42 * impactSubScoreBase
+            : 7.52 * (impactSubScoreBase - 0.029) - 3.25 * Math.pow(impactSubScoreBase - 0.02, 15);
+        if (impactSubScore <= 0) {
+            return 0;
+        }
+        const exploitability = 8.22 * av * ac * pr * ui;
+        const rawScore = scope === 'U'
+            ? impactSubScore + exploitability
+            : 1.08 * (impactSubScore + exploitability);
+        const cappedScore = Math.min(rawScore, 10);
+        return metrics.CVSS === '3.0'
+            ? Math.ceil(cappedScore * 10) / 10
+            : roundUpCvssScore(cappedScore);
+    }
+    get cacheFile() {
+        return path.join(this.config.cacheDir, 'cve-cache.json');
     }
     loadCache() {
         try {
-            const cacheFile = path.join(this.config.cacheDir, 'cve-cache.json');
-            if (fs.existsSync(cacheFile)) {
-                const data = fs.readFileSync(cacheFile, 'utf8');
-                const parsed = JSON.parse(data);
-                const entries = Object.entries(parsed.cache);
-                const sortedEntries = entries.slice(-this.MAX_CACHE_SIZE);
-                sortedEntries.forEach(([key, value]) => {
-                    this.cache.set(key, value);
-                });
-                this.lastUpdate = parsed.lastUpdate || 0;
+            if (!fs.existsSync(this.cacheFile)) {
+                return;
+            }
+            const parsed = JSON.parse(fs.readFileSync(this.cacheFile, 'utf8'));
+            for (const [key, value] of Object.entries((parsed === null || parsed === void 0 ? void 0 : parsed.cache) || {}).slice(-this.MAX_CACHE_SIZE)) {
+                const entry = value;
+                if (typeof (entry === null || entry === void 0 ? void 0 : entry.checkedAt) === 'number' && Array.isArray(entry.vulns)
+                    && entry.vulns.every(vuln => Array.isArray(vuln === null || vuln === void 0 ? void 0 : vuln.affected))) {
+                    this.cache.set(key, entry);
+                }
             }
         }
         catch (error) {
@@ -229,44 +372,54 @@ class CVEChecker {
         }
     }
     debouncedSaveCache() {
+        this.dirty = true;
         if (this.saveTimer) {
             clearTimeout(this.saveTimer);
         }
         this.saveTimer = setTimeout(() => {
-            this.saveCache();
             this.saveTimer = null;
+            void this.saveCache();
         }, this.SAVE_DEBOUNCE_MS);
+        this.saveTimer.unref();
+    }
+    serializeCache() {
+        return JSON.stringify({ cache: Object.fromEntries(this.cache.entries()) });
     }
     saveCache() {
-        try {
-            const cacheFile = path.join(this.config.cacheDir, 'cve-cache.json');
-            const dir = path.dirname(cacheFile);
-            if (!fs.existsSync(dir)) {
-                fs.mkdirSync(dir, { recursive: true });
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.dirty = false;
+                const tmpFile = `${this.cacheFile}.${process.pid}.tmp`;
+                yield fs.promises.mkdir(path.dirname(this.cacheFile), { recursive: true });
+                yield fs.promises.writeFile(tmpFile, this.serializeCache(), 'utf8');
+                yield fs.promises.rename(tmpFile, this.cacheFile);
             }
-            const data = {
-                cache: Object.fromEntries(this.cache.entries()),
-                lastUpdate: Date.now(),
-            };
-            fs.writeFileSync(cacheFile, JSON.stringify(data, null, 2), 'utf8');
-            this.lastUpdate = Date.now();
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            console.error('[CVE Checker] Failed to save cache:', message);
-        }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                console.error('[CVE Checker] Failed to save cache:', message);
+            }
+        });
     }
     clearCache() {
         this.cache.clear();
-        this.lastUpdate = 0;
-        this.saveCache();
+        this.failedUntil.clear();
+        this.debouncedSaveCache();
     }
     destroy() {
         if (this.saveTimer) {
             clearTimeout(this.saveTimer);
             this.saveTimer = null;
         }
-        this.saveCache();
+        if (this.dirty) {
+            try {
+                fs.mkdirSync(path.dirname(this.cacheFile), { recursive: true });
+                fs.writeFileSync(this.cacheFile, this.serializeCache(), 'utf8');
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                console.error('[CVE Checker] Failed to save cache:', message);
+            }
+        }
         this.cache.clear();
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "verdaccio-security-filter",
-  "version": "1.3.7",
+  "version": "1.3.9",
   "description": "Advanced security filter plugin for Verdaccio with version range blocking and fallback strategies",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -54,7 +54,7 @@
     "typescript-eslint": "^8.0.0"
   },
   "overrides": {
-    "qs": "6.14.2",
+    "qs": "6.16.0",
     "@cypress/request": "latest"
   },
   "author": {