CVE-2025-53624: Docusaurus Gists Plugin Token Exposure

CVE-2025-53624 Overview

CVE-2025-53624 is a critical information disclosure vulnerability affecting the Docusaurus gists plugin (docusaurus-plugin-content-gists). The plugin, designed to display all public gists of a GitHub user on a Docusaurus instance, inadvertently exposes GitHub Personal Access Tokens (PATs) in production build artifacts when tokens are passed through plugin configuration options. This sensitive credential, intended solely for build-time API access, becomes embedded in client-side JavaScript bundles and is accessible to anyone who can view the website's source code.

Critical Impact
GitHub Personal Access Tokens leaked in client-side JavaScript bundles can be harvested by attackers to gain unauthorized access to GitHub repositories, potentially leading to source code theft, malicious code injection, or complete account compromise depending on the token's permissions scope.

Affected Products

docusaurus-plugin-content-gists versions prior to 4.0.0
Docusaurus instances using the vulnerable plugin with PAT configuration
Any website built with the affected plugin versions where PAT was passed via plugin options

Discovery Timeline

2025-07-09 - CVE CVE-2025-53624 published to NVD
2025-07-10 - Last updated in NVD database

Technical Details for CVE-2025-53624

Vulnerability Analysis

This vulnerability stems from improper handling of sensitive configuration data during the Docusaurus build process. The plugin architecture failed to properly separate build-time credentials from runtime client-side code, resulting in the GitHub Personal Access Token being bundled directly into the JavaScript assets served to browsers.

When Docusaurus builds a site, plugin configurations are processed and can inadvertently be serialized into the client-side bundle if not properly filtered. In vulnerable versions, the entire configuration object—including the PAT—was accessible in the browser's JavaScript context, making token extraction trivial for any visitor inspecting the page source or network requests.

The vulnerability is classified under CWE-200 (Exposure of Sensitive Information to an Unauthorized Actor), reflecting the core issue of credential leakage to untrusted parties.

Root Cause

The root cause lies in the plugin's failure to implement proper separation between server-side/build-time configuration and client-side runtime configuration. The GitHub PAT, which should only be used during the static site generation phase to fetch gist data from the GitHub API, was being passed through to the client-side JavaScript bundle without sanitization.

The fix introduces a clear architectural boundary between build-time and runtime configurations. The patched version implements a RuntimeConfig interface that explicitly excludes sensitive credentials, ensuring only safe configuration values like enabled, verbose, and component paths are accessible client-side.

Attack Vector

The attack vector is network-based and requires no authentication or user interaction. An attacker can exploit this vulnerability through the following steps:

Navigate to any Docusaurus website using the vulnerable plugin
Open browser developer tools or view page source
Inspect the JavaScript bundles or search for configuration objects
Extract the exposed GitHub Personal Access Token
Use the stolen token to access the victim's GitHub account with whatever permissions the token grants

The patched code introduces proper client-server separation:

typescript

/**
 * Client-side plugin component
 * This runs in the browser and has access to runtime configuration only
 */

interface RuntimeConfig {
  enabled: boolean
  verbose: boolean
  gistListPageComponent: string
  gistPageComponent: string
}

class GistsClient {
  private config: RuntimeConfig

  constructor(config: RuntimeConfig) {
    this.config = config
  }

  // Client-side utility methods
  isEnabled(): boolean {
    return this.config.enabled
  }

  isVerbose(): boolean {
    return this.config.verbose
  }

  getGistListComponent(): string {
    return this.config.gistListPageComponent

Source: GitHub Commit Update

The fix also introduces a proper context provider pattern to manage configuration:

text

+import React, { createContext, useContext, ReactNode } from 'react'
+import { GistsClient, RuntimeConfig } from './index'
+
+interface GistsContextType {
+  client: GistsClient
+  config: RuntimeConfig
+}
+
+const GistsContext = createContext<GistsContextType | undefined>(undefined)
+
+interface GistsProviderProps {
+  children: ReactNode
+  config: RuntimeConfig
+}
+
+export function GistsProvider({ children, config }: GistsProviderProps) {
+  const client = new GistsClient(config)
+
+  return <GistsContext.Provider value={{ client, config }}>{children}</GistsContext.Provider>
+}
+
+export function useGists() {
+  const context = useContext(GistsContext)
+  if (context === undefined) {
+    throw new Error('useGists must be used within a GistsProvider')
+  }
+  return context
+}
+
+export function useGistsClient() {

Source: GitHub Commit Update

Detection Methods for CVE-2025-53624

Indicators of Compromise

Presence of GitHub Personal Access Tokens in client-side JavaScript bundle files
Configuration objects containing token, pat, or personalAccessToken fields in browser-accessible code
Unexpected GitHub API activity from unfamiliar IP addresses using your token
GitHub security alerts indicating token exposure or unusual authentication patterns

Detection Strategies

Audit JavaScript bundles in production builds by searching for strings matching PAT patterns (e.g., ghp_, github_pat_)
Review package.json and package-lock.json for docusaurus-plugin-content-gists versions below 4.0.0
Implement pre-deployment scans using secret detection tools like git-secrets, trufflehog, or gitleaks
Monitor GitHub's security tab for token exposure notifications

Monitoring Recommendations

Enable GitHub's token scanning and push protection features to detect exposed credentials
Set up alerts for GitHub API usage anomalies associated with your Personal Access Tokens
Implement Content Security Policy (CSP) reporting to detect unexpected script behaviors
Regularly audit production builds for sensitive data exposure using automated security scanning

How to Mitigate CVE-2025-53624

Immediate Actions Required

Upgrade docusaurus-plugin-content-gists to version 4.0.0 or later immediately
Rotate any GitHub Personal Access Tokens that may have been exposed in previous builds
Audit your production website's JavaScript bundles for exposed credentials
Review GitHub account activity for any unauthorized access during the exposure window
Invalidate and regenerate all PATs used with the vulnerable plugin version

Patch Information

The vulnerability is fixed in docusaurus-plugin-content-gists version 4.0.0. The patch introduces a proper separation between build-time and runtime configurations through a new RuntimeConfig interface and GistsClient class architecture. The fix ensures that sensitive credentials like GitHub PATs are only used during the build phase and are never serialized into client-side bundles.

For detailed information about the security fix, refer to the GitHub Security Advisory GHSA-qf34-qpr4-5pph and the security patch commit.

Workarounds

Remove the PAT from plugin configuration entirely and use unauthenticated GitHub API access (note: this has stricter rate limits)
Implement environment variable separation ensuring PATs are only available during build and not bundled
Use GitHub Actions or CI/CD pipelines to fetch gists at build time without passing tokens to the plugin
Temporarily disable the gists plugin until upgrade to version 4.0.0 is complete

bash

# Upgrade to patched version
npm update docusaurus-plugin-content-gists@^4.0.0

# Or with yarn
yarn upgrade docusaurus-plugin-content-gists@^4.0.0

# Verify installed version
npm list docusaurus-plugin-content-gists

# Rotate compromised GitHub PAT via GitHub CLI
gh auth refresh