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:

1. Navigate to any Docusaurus website using the vulnerable plugin
2. Open browser developer tools or view page source
3. Inspect the JavaScript bundles or search for configuration objects
4. Extract the exposed GitHub Personal Access Token
5. 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:

/**
 * 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:

+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

# 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