/

CVE-2021-47746

Severity:

HIGH RISK

(7.5)

Arbitrary File Write / Path Traversal in File Operations

CVE-2021-47746

Awaiting Analysis

Vulnerability type

Category:

Arbitrary File Write / Path Traversal in File Operations

CWE:

CWE-73

Impact:

Arbitrary File Write and Potential Application Compromise

Severity:

HIGH RISK

(7.5)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

NodeBB Plugin Emoji 3.2.1 contains an arbitrary file write vulnerability where the emoji upload API accepts attacker-controlled file paths with directory traversal sequences.

An authenticated administrative user can abuse this to write or overwrite files in arbitrary locations on the server filesystem, potentially impacting application integrity and server behavior.

Affected context

This vulnerability affects NodeBB installations that use the Emoji plugin version 3.2.1 and expose the emoji upload API to administrative users.

The issue occurs in environments where server-side file write operations trust a file path parameter from the request without adequate canonicalization and restriction to a safe directory.

It is most impactful when the NodeBB process has write permissions to sensitive directories or application configuration paths.

Exploit preconditions

  • Attack surface: HTTP(S) interface of the NodeBB Emoji upload API
  • Required access: Valid administrative-level access to the NodeBB instance
  • Trigger point: Submission of an emoji upload request with a crafted file path containing directory traversal sequences (for example, relative paths targeting directories outside the intended upload folder)
  • Why exploitation is possible: The server-side handler concatenates or otherwise uses the user-supplied file path directly in filesystem operations without enforcing a fixed base directory, canonicalizing the path, or validating it against an allowlist, enabling writes outside the intended upload location

Why this happens

The root cause aligns with CWE-73: External Control of File Name or Path, where user-controllable input is used to construct filesystem paths for write operations.

In this case, the emoji upload API accepts a path parameter that is not sanitized or constrained to a specific directory, allowing path traversal patterns (such as ../) to escape the intended upload directory.

The application logic prioritizes flexibility of uploads over strict path validation, resulting in an insecure pattern where the server trusts client-supplied paths for file creation or overwrite.

Potential impact

  • Overwriting critical application files that the NodeBB process can write to, which could disrupt service or alter behavior
  • Modifying configuration or plugin files, potentially enabling further misconfiguration-based attacks
  • Planting new files within web-accessible directories (where permitted), which may enable webshell-like behavior or facilitate follow-on attacks
  • Corrupting or deleting (via overwrite) logs or other operational files, impacting observability and incident response
  • Degrading availability by overwriting resources required for normal application operation

General mitigation guidance

Robust mitigation focuses on restricting and validating file paths used in server-side file operations:

  • Constrain all uploads to a fixed, application-controlled base directory and avoid using client input as part of the directory path.
  • Canonicalize and normalize paths before use, and verify that the resolved path remains within an allowed directory boundary.
  • Apply strict allowlisting for filenames (e.g., based on generated IDs or sanitized basenames) rather than trusting user-submitted paths or directory structures.
  • Use filesystem permissions and runtime user accounts that limit write access to only the directories required for emoji storage, avoiding broader system write privileges for the application process.
  • Centralize file handling utilities in the codebase to enforce consistent path validation and avoid ad-hoc file write logic scattered across components.

How teams detect issues like this

Organizations can detect and monitor for this type of vulnerability using a combination of code-level and operational techniques:

  • Static analysis: Configure rules to flag any filesystem write APIs that accept user-controllable path components without canonicalization or boundary checks.
  • Code review: During review of upload or file management features, look for direct concatenation of request parameters into filesystem paths and absence of checks ensuring paths remain within a defined upload directory.
  • Runtime monitoring: Instrument logging around upload endpoints to record normalized target paths and alert on attempts containing traversal patterns or paths outside expected directories.
  • Policy enforcement: Use secure coding standards and automated checks in CI that require file I/O operations to pass through vetted helper functions with built-in path validation.
  • Automated SAST and security-focused linters can help highlight dangerous path usage patterns early in the development lifecycle.

Sources

SourceLink
github.comgithub.com/NodeBB/nodebb-plugin-emoji
nodebb.orgnodebb.org/
exploit-db.comexploit-db.com/exploits/49813
vulncheck.comvulncheck.com/advisories/nodebb-plugin-emoji-arbitrary-file-write

Frequently asked

questions

Yes, but only through authenticated administrative interfaces. An attacker must be able to send requests to the NodeBB emoji upload API and possess admin-level credentials to exploit it.

Exploitation requires administrative access within NodeBB. A lower-privileged or unauthenticated user would not typically be able to reach or invoke the vulnerable upload behavior with sufficient control.

The safest approach is to eliminate user control over filesystem paths used for writes. Constrain all uploads to a dedicated directory, generate or sanitize filenames on the server, and verify via canonicalization that the resulting path is within the intended directory before writing.

Adopt a standard file handling layer that encapsulates safe path operations, enforce secure coding guidelines for file I/O, and integrate automated checks that flag external control of file names or paths. Regular security reviews of file upload and management features further reduce the risk of reintroducing this bug class.

Find out what's already
exploitable in your codebase.