Skip to content

Node.js based forum software built for the modern web

fix(activitypub): harden emoji cache against path traversal and SSRF

Julian Lam0832880a5510
diff --git a/src/activitypub/emoji.js b/src/activitypub/emoji.js
index b3924d2b7b..ff9e886a0b 100644
--- a/src/activitypub/emoji.js
+++ b/src/activitypub/emoji.js
@@ -8,10 +8,13 @@ const winston = require('winston');
const db = require('../database');
const validator = require('validator');
-const { check } = require('../ssrf');
+const request = require('../request');
const emojiLookupKey = 'emoji:ap:lookup';
+// The only extensions we are willing to persist for a cached emoji image.
+const ALLOWED_EMOJI_EXTS = new Set(['png', 'jpg', 'jpeg', 'gif', 'webp', 'avif', 'svg']);
+
function getEmojiDir() {
const uploadPath = nconf.get('upload_path') || nconf.get('base_dir') || '.';
return path.join(uploadPath, 'emoji', 'ap');
@@ -100,35 +103,46 @@ async function cacheEmoji(emojiTag) {
return existing;
}
- // Determine file extension from content or URL
- const ext = mime.getExtension(icon.mediaType || '') || path.extname(new URL(icon.url).pathname).slice(1) || 'png';
- const cleanName = shortcode.replace(/^:+|:+$/g, '');
+ let ext = (mime.getExtension(icon.mediaType || '') || path.extname(new URL(icon.url).pathname).slice(1) || 'png').toLowerCase();
+ if (!ALLOWED_EMOJI_EXTS.has(ext)) {
+ ext = 'png';
+ }
+
+ const cleanName = shortcode.replace(/^:+|:+$/g, '').replace(/[/\\]+/g, '_').replace(/\0/g, '');
+ if (!cleanName) {
+ return null;
+ }
const filename = `${cleanName}.${ext}`;
- const dirPath = path.join(getEmojiDir(), hostname);
+ const baseDir = getEmojiDir();
+ const dirPath = path.join(baseDir, hostname);
const localPath = path.join(dirPath, filename);
+ const resolvedBase = path.resolve(baseDir);
+ const resolved = path.resolve(localPath);
+ if (resolved !== resolvedBase && !resolved.startsWith(resolvedBase + path.sep)) {
+ return null;
+ }
+
try {
// Ensure directory exists
await fs.mkdir(dirPath, { recursive: true });
- // SSRF check before fetching remote image
- const { ok } = await check(icon.url);
- if (!ok) {
- winston.warn(`[activitypub:emoji] Blocked SSRF attempt for emoji ${shortcode}: ${icon.url}`);
- return null;
- }
-
- // Fetch the remote image
- const fetchResponse = await fetch(icon.url, {
- signal: AbortSignal.timeout(5000),
- });
-
- if (!fetchResponse.ok) {
- winston.warn(`[activitypub:emoji] Failed to fetch emoji ${shortcode} from ${hostname}: HTTP ${fetchResponse.status}`);
+ // Fetch the remote image through the SSRF-protected request layer. This
+ // pins DNS to the already-validated address (no rebind TOCTOU),
+ // revalidates every redirect hop, and caps the response size.
+ let buffer;
+ let response;
+ try {
+ ({ body: buffer, response } = await request.getBuffer(icon.url, { timeout: 5000 }));
+ if (!response.ok) {
+ winston.warn(`[activitypub:emoji] Failed to fetch emoji ${shortcode} from ${hostname}: HTTP ${response.status}`);
+ return null;
+ }
+ } catch (err) {
+ winston.warn(`[activitypub:emoji] Failed to fetch emoji ${shortcode} from ${hostname}: ${err.message}`);
return null;
}
- const buffer = Buffer.from(await fetchResponse.arrayBuffer());
await fs.writeFile(localPath, buffer);
const mediaType = icon.mediaType || mime.getType(ext) || 'image/png';
diff --git a/src/request.js b/src/request.js
index 4cf7dd1fec..bc252cf320 100644
--- a/src/request.js
+++ b/src/request.js
@@ -81,7 +81,7 @@ function getInsecureDispatcher() {
}
async function call(url, method, {
- body, timeout, jar, sizeLimit = 10 * 1024 * 1024, rejectUnauthorized, ...config
+ body, timeout, jar, sizeLimit = 10 * 1024 * 1024, rejectUnauthorized, binary = false, ...config
} = {}) {
const originalUrl = url;
let currentUrl = url;
@@ -165,6 +165,20 @@ async function call(url, method, {
throw new Error(`Response size (${buffer.byteLength} bytes) exceeds limit (${sizeLimit} bytes)`);
}
+ if (binary) {
+ return {
+ body: Buffer.from(buffer),
+ response: {
+ ok: response.ok,
+ status: response.status,
+ statusCode: response.status,
+ statusText: response.statusText,
+ headers: Object.fromEntries(response.headers.entries()),
+ },
+ url: currentUrl,
+ };
+ }
+
let respBody = new TextDecoder().decode(buffer);
if (isJSON && respBody) {
@@ -210,6 +224,7 @@ const { body, response } = await request.get('someurl?foo=1&baz=2')
exports.check = check;
exports.get = async (url, config) => call(url, 'GET', config);
+exports.getBuffer = async (url, config) => call(url, 'GET', { ...config, binary: true });
exports.head = async (url, config) => call(url, 'HEAD', config);
exports.del = async (url, config) => call(url, 'DELETE', config);
diff --git a/test/activitypub/emoji.js b/test/activitypub/emoji.js
index 19d4f8b3e4..259fe4f904 100644
--- a/test/activitypub/emoji.js
+++ b/test/activitypub/emoji.js
@@ -2,9 +2,12 @@
const assert = require('assert');
const path = require('path');
+const fs = require('fs').promises;
+const nconf = require('nconf');
const db = require('../mocks/databasemock');
const activitypub = require('../../src/activitypub');
+const request = require('../../src/request');
const helpers = require('./helpers');
describe('Emoji', () => {
@@ -98,6 +101,106 @@ describe('Emoji', () => {
});
});
+ describe('cacheEmoji', () => {
+ const uploadPath = nconf.get('upload_path') || nconf.get('base_dir') || '.';
+ const emojiDir = path.join(uploadPath, 'emoji', 'ap');
+
+ it('should cache a valid emoji inside the per-host directory', async () => {
+ const tag = {
+ type: 'Emoji',
+ name: ':poop:',
+ icon: { url: 'https://mastodon.social/emojis/poop.png', mediaType: 'image/png' },
+ };
+ const originalGetBuffer = request.getBuffer;
+ request.getBuffer = async () => ({ body: Buffer.from('png-bytes'), response: { ok: true, status: 200 }, url: '' });
+ try {
+ const result = await emojiModule.cacheEmoji(tag);
+ assert.ok(result, 'expected emoji to be cached');
+ const resolved = path.resolve(uploadPath, result.localPath);
+ assert.ok(resolved.startsWith(path.resolve(emojiDir) + path.sep), `wrote outside emoji dir: ${resolved}`);
+ assert.ok(resolved.endsWith('poop.png'), `unexpected filename: ${resolved}`);
+ } finally {
+ request.getBuffer = originalGetBuffer;
+ await fs.unlink(path.join(emojiDir, 'mastodon.social', 'poop.png')).catch(() => {});
+ }
+ });
+
+ it('should not write outside the emoji dir for a traversal name (CWE-22)', async () => {
+ const evilFile = path.resolve(emojiDir, '..', 'evil.png');
+ await fs.unlink(evilFile).catch(() => {});
+
+ const originalGetBuffer = request.getBuffer;
+ request.getBuffer = async () => ({ body: Buffer.from('x'), response: { ok: true, status: 200 }, url: '' });
+ try {
+ const tag = {
+ type: 'Emoji',
+ name: '../../../evil',
+ icon: { url: 'https://example.com/evil.png', mediaType: 'image/png' },
+ };
+ const result = await emojiModule.cacheEmoji(tag);
+ // Slashes are sanitized to underscores, so it lands safely inside the dir
+ assert.ok(result, 'expected emoji to be cached to a sanitized path');
+ const resolved = path.resolve(uploadPath, result.localPath);
+ assert.ok(resolved.startsWith(path.resolve(emojiDir) + path.sep), `wrote outside emoji dir: ${resolved}`);
+ assert.notStrictEqual(resolved, evilFile);
+ await fs.access(evilFile).then(() => assert.fail('evil file should not exist')).catch(() => {});
+ } finally {
+ request.getBuffer = originalGetBuffer;
+ }
+ });
+
+ it('should not persist a disallowed extension (CWE-22)', async () => {
+ const originalGetBuffer = request.getBuffer;
+ request.getBuffer = async () => ({ body: Buffer.from('x'), response: { ok: true, status: 200 }, url: '' });
+ try {
+ const tag = {
+ type: 'Emoji',
+ name: ':shell:',
+ icon: { url: 'https://example.com/shell.php', mediaType: 'application/x-php' },
+ };
+ const result = await emojiModule.cacheEmoji(tag);
+ assert.ok(result, 'expected emoji to be cached');
+ assert.ok(path.resolve(result.localPath).endsWith('.png'), `expected png fallback, got: ${result.localPath}`);
+ } finally {
+ request.getBuffer = originalGetBuffer;
+ await fs.unlink(path.join(emojiDir, 'example.com', 'shell.png')).catch(() => {});
+ }
+ });
+
+ it('should block fetching an emoji from a reserved/private IP (CWE-918)', async () => {
+ // Use the real request layer (bypass the mock) to exercise the SSRF guard
+ const realGetBuffer = helpers.mocks._originalGetBuffer;
+ await assert.rejects(
+ () => realGetBuffer('http://169.254.169.254/latest/meta-data/'),
+ /reserved|lookup-failed/i,
+ 'reserved IP fetch should be rejected by the request layer'
+ );
+ });
+
+ it('should route the emoji fetch through the SSRF-protected request layer (CWE-918)', async () => {
+ // cacheEmoji must call request.getBuffer (pinned-lookup dispatcher), not
+ // a bare global fetch. Assert it is invoked for a fresh (uncached) emoji.
+ let called = false;
+ const originalGetBuffer = request.getBuffer;
+ request.getBuffer = async () => {
+ called = true;
+ return { body: Buffer.from('x'), response: { ok: true, status: 200 }, url: '' };
+ };
+ try {
+ const tag = {
+ type: 'Emoji',
+ name: ':route:',
+ icon: { url: 'https://example.com/route.png', mediaType: 'image/png' },
+ };
+ await emojiModule.cacheEmoji(tag);
+ assert.ok(called, 'cacheEmoji should fetch via request.getBuffer');
+ } finally {
+ request.getBuffer = originalGetBuffer;
+ await fs.unlink(path.join(emojiDir, 'example.com', 'route.png')).catch(() => {});
+ }
+ });
+ });
+
describe('processEmojiTag', () => {
it('should return null for tag with no icon', async () => {
const tag = { type: 'Emoji', name: ':test:' };
diff --git a/test/activitypub/helpers.js b/test/activitypub/helpers.js
index f4ea94cd98..8e3c64aeaf 100644
--- a/test/activitypub/helpers.js
+++ b/test/activitypub/helpers.js
@@ -50,6 +50,7 @@ Helpers.mocks.mockRequests = function () {
}
const localHost = nconf.get('url_parsed').host;
Helpers.mocks._originalGet = request.get;
+ Helpers.mocks._originalGetBuffer = request.getBuffer;
request.get = async (url, config) => {
let host;
try {
@@ -80,6 +81,38 @@ Helpers.mocks.mockRequests = function () {
url,
};
};
+ // Binary-safe variant (used by the emoji cache). Returns a small buffer for
+ // known URLs and a 404 response otherwise, mirroring request.get.
+ request.getBuffer = async (url, config) => {
+ let host;
+ try {
+ host = new URL(url).host;
+ } catch (e) {
+ host = null;
+ }
+ if (!host || host === localHost) {
+ return Helpers.mocks._originalGetBuffer(url, config);
+ }
+ const cached = activitypub._cache.get(`0;${url}`);
+ if (cached !== undefined) {
+ return {
+ body: Buffer.from('mock-emoji-bytes'),
+ response: {
+ ok: true, status: 200, statusCode: 200, statusText: 'OK',
+ headers: { 'content-type': 'image/png' },
+ },
+ url,
+ };
+ }
+ return {
+ body: Buffer.alloc(0),
+ response: {
+ ok: false, status: 404, statusCode: 404, statusText: 'Not Found',
+ headers: { 'content-type': 'image/png' },
+ },
+ url,
+ };
+ };
Helpers.mocks._mockRequestInstalled = true;
};
@@ -88,6 +121,7 @@ Helpers.mocks.restoreRequests = function () {
return;
}
request.get = Helpers.mocks._originalGet;
+ request.getBuffer = Helpers.mocks._originalGetBuffer;
Helpers.mocks._mockRequestInstalled = false;
};