@jgardner04/ghost-mcp-server 1.13.1 → 1.13.3

package/src/services/memberService.js

@@ -204,18 +204,6 @@ export function validateMemberUpdateData(updateData) {
   }
 }
 
-/**
- * Sanitizes a value for use in NQL filters to prevent injection
- * Escapes backslashes, single quotes, and double quotes
- * @param {string} value - The value to sanitize
- * @returns {string} The sanitized value
- */
-export function sanitizeNqlValue(value) {
-  if (!value) return value;
-  // Escape backslashes first, then quotes
-  return value.replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/"/g, '\\"');
-}
-
 /**
  * Validates query options for member browsing
  * @param {Object} options - The query options to validate
@@ -388,5 +376,4 @@ export default {
   validateMemberLookup,
   validateSearchQuery,
   validateSearchOptions,
-  sanitizeNqlValue,
 };

package/src/services/tierService.js

@@ -284,21 +284,8 @@ export function validateTierQueryOptions(options) {
   }
 }
 
-/**
- * Sanitizes a value for use in NQL filters to prevent injection
- * Escapes backslashes, single quotes, and double quotes
- * @param {string} value - The value to sanitize
- * @returns {string} The sanitized value
- */
-export function sanitizeNqlValue(value) {
-  if (!value) return value;
-  // Escape backslashes first, then quotes
-  return value.replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/"/g, '\\"');
-}
-
 export default {
   validateTierData,
   validateTierUpdateData,
   validateTierQueryOptions,
-  sanitizeNqlValue,
 };

package/src/utils/__tests__/nqlSanitizer.test.js

@@ -0,0 +1,38 @@
+import { describe, it, expect } from 'vitest';
+import { sanitizeNqlValue } from '../nqlSanitizer.js';
+
+describe('sanitizeNqlValue', () => {
+  it('should escape backslashes', () => {
+    expect(sanitizeNqlValue('hello\\world')).toBe('hello\\\\world');
+  });
+
+  it('should escape single quotes', () => {
+    expect(sanitizeNqlValue("it's")).toBe("it\\'s");
+  });
+
+  it('should escape double quotes', () => {
+    expect(sanitizeNqlValue('say "hello"')).toBe('say \\"hello\\"');
+  });
+
+  it('should escape all three special characters combined', () => {
+    expect(sanitizeNqlValue('a\\b\'c"d')).toBe('a\\\\b\\\'c\\"d');
+  });
+
+  it('should return null as-is', () => {
+    expect(sanitizeNqlValue(null)).toBe(null);
+  });
+
+  it('should return undefined as-is', () => {
+    expect(sanitizeNqlValue(undefined)).toBe(undefined);
+  });
+
+  it('should return empty string as-is', () => {
+    expect(sanitizeNqlValue('')).toBe('');
+  });
+
+  it('should pass through normal strings without special characters', () => {
+    expect(sanitizeNqlValue('simple-value')).toBe('simple-value');
+    expect(sanitizeNqlValue('test@example.com')).toBe('test@example.com');
+    expect(sanitizeNqlValue('hello world 123')).toBe('hello world 123');
+  });
+});

package/src/utils/__tests__/urlValidator.test.js

@@ -1,5 +1,11 @@
 import { describe, it, expect } from 'vitest';
-import { validateImageUrl, createSecureAxiosConfig, ALLOWED_DOMAINS } from '../urlValidator.js';
+import {
+  validateImageUrl,
+  createSecureAxiosConfig,
+  createBeforeRedirect,
+  isSafeHost,
+  ALLOWED_DOMAINS,
+} from '../urlValidator.js';
 
 describe('urlValidator', () => {
   describe('ALLOWED_DOMAINS', () => {
@@ -446,5 +452,135 @@ describe('urlValidator', () => {
       expect(config2.url).toBe(url2);
       expect(config1.url).not.toBe(config2.url);
     });
+
+    it('should include beforeRedirect callback', () => {
+      const config = createSecureAxiosConfig('https://imgur.com/image.jpg');
+      expect(config).toHaveProperty('beforeRedirect');
+      expect(typeof config.beforeRedirect).toBe('function');
+    });
+  });
+
+  describe('isSafeHost', () => {
+    it('should allow domains on the allowlist', () => {
+      expect(isSafeHost('imgur.com')).toBe(true);
+      expect(isSafeHost('i.imgur.com')).toBe(true);
+      expect(isSafeHost('github.com')).toBe(true);
+    });
+
+    it('should allow subdomains of allowed domains', () => {
+      expect(isSafeHost('cdn.images.unsplash.com')).toBe(true);
+      expect(isSafeHost('my-bucket.s3.amazonaws.com')).toBe(true);
+    });
+
+    it('should reject domains not on the allowlist', () => {
+      expect(isSafeHost('evil.com')).toBe(false);
+      expect(isSafeHost('fakeimgur.com')).toBe(false);
+    });
+
+    it('should block localhost IPs', () => {
+      expect(isSafeHost('127.0.0.1')).toBe(false);
+      expect(isSafeHost('127.0.0.2')).toBe(false);
+    });
+
+    it('should block private network IPs', () => {
+      expect(isSafeHost('10.0.0.1')).toBe(false);
+      expect(isSafeHost('192.168.1.1')).toBe(false);
+      expect(isSafeHost('172.16.0.1')).toBe(false);
+    });
+
+    it('should block link-local and cloud metadata IPs', () => {
+      expect(isSafeHost('169.254.169.254')).toBe(false);
+      expect(isSafeHost('169.254.0.1')).toBe(false);
+    });
+
+    it('should block IPv6 private addresses', () => {
+      expect(isSafeHost('::1')).toBe(false);
+      expect(isSafeHost('fc00::1')).toBe(false);
+      expect(isSafeHost('fe80::1')).toBe(false);
+    });
+
+    it('should allow public IPs not on blocklist', () => {
+      expect(isSafeHost('8.8.8.8')).toBe(true);
+      expect(isSafeHost('1.1.1.1')).toBe(true);
+    });
+  });
+
+  describe('createBeforeRedirect', () => {
+    it('should not throw for redirects to allowed domains', () => {
+      const beforeRedirect = createBeforeRedirect();
+      expect(() =>
+        beforeRedirect({
+          protocol: 'https:',
+          hostname: 'imgur.com',
+          path: '/image.jpg',
+        })
+      ).not.toThrow();
+    });
+
+    it('should throw for redirect to 127.0.0.1 (localhost)', () => {
+      const beforeRedirect = createBeforeRedirect();
+      expect(() =>
+        beforeRedirect({
+          protocol: 'https:',
+          hostname: '127.0.0.1',
+          path: '/secret',
+        })
+      ).toThrow('Redirect blocked');
+    });
+
+    it('should throw for redirect to 169.254.169.254 (AWS metadata)', () => {
+      const beforeRedirect = createBeforeRedirect();
+      expect(() =>
+        beforeRedirect({
+          protocol: 'http:',
+          hostname: '169.254.169.254',
+          path: '/latest/meta-data/',
+        })
+      ).toThrow('Redirect blocked');
+    });
+
+    it('should throw for redirect to 192.168.x.x (private network)', () => {
+      const beforeRedirect = createBeforeRedirect();
+      expect(() =>
+        beforeRedirect({
+          protocol: 'https:',
+          hostname: '192.168.1.1',
+          path: '/admin',
+        })
+      ).toThrow('Redirect blocked');
+    });
+
+    it('should throw for redirect to 10.x.x.x (private network)', () => {
+      const beforeRedirect = createBeforeRedirect();
+      expect(() =>
+        beforeRedirect({
+          protocol: 'https:',
+          hostname: '10.0.0.1',
+          path: '/internal',
+        })
+      ).toThrow('Redirect blocked');
+    });
+
+    it('should throw for redirect to disallowed domain', () => {
+      const beforeRedirect = createBeforeRedirect();
+      expect(() =>
+        beforeRedirect({
+          protocol: 'https:',
+          hostname: 'evil.com',
+          path: '/payload',
+        })
+      ).toThrow('Redirect blocked');
+    });
+
+    it('should allow redirect between allowed domains', () => {
+      const beforeRedirect = createBeforeRedirect();
+      expect(() =>
+        beforeRedirect({
+          protocol: 'https:',
+          hostname: 'images.unsplash.com',
+          path: '/photo-123',
+        })
+      ).not.toThrow();
+    });
   });
 });

package/src/utils/nqlSanitizer.js

@@ -0,0 +1,11 @@
+/**
+ * Sanitizes a value for use in NQL (Ghost's filter query language) to prevent injection.
+ * Escapes backslashes, single quotes, and double quotes.
+ * @param {string} value - The value to sanitize
+ * @returns {string} The sanitized value
+ */
+export function sanitizeNqlValue(value) {
+  if (!value) return value;
+  // Escape backslashes first, then quotes
+  return value.replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/"/g, '\\"');
+}

package/src/utils/urlValidator.js

@@ -147,7 +147,23 @@ const validateImageUrl = (url) => {
 };
 
 /**
- * Configures axios with security settings for external requests
+ * Creates a beforeRedirect callback that validates each redirect target against
+ * the same SSRF rules applied to the initial URL.
+ * @returns {function} Axios beforeRedirect callback
+ */
+const createBeforeRedirect = () => {
+  return (options) => {
+    const redirectUrl = `${options.protocol}//${options.hostname}${options.path}`;
+    const validation = validateImageUrl(redirectUrl);
+    if (!validation.isValid) {
+      throw new Error(`Redirect blocked: ${validation.error}`);
+    }
+  };
+};
+
+// Note: DNS rebinding (TOCTOU) attacks are not mitigated by hostname-based validation
+/**
+ * Configures axios with security settings for external requests.
  * @param {string} url - The validated URL to request
  * @returns {object} Axios configuration with security settings
  */
@@ -159,10 +175,17 @@ const createSecureAxiosConfig = (url) => {
     maxRedirects: 3, // Limit redirects
     maxContentLength: 50 * 1024 * 1024, // 50MB max response
     validateStatus: (status) => status >= 200 && status < 300, // Only accept 2xx
+    beforeRedirect: createBeforeRedirect(),
     headers: {
       'User-Agent': 'Ghost-MCP-Server/1.0',
     },
   };
 };
 
-export { validateImageUrl, createSecureAxiosConfig, ALLOWED_DOMAINS };
+export {
+  validateImageUrl,
+  createSecureAxiosConfig,
+  createBeforeRedirect,
+  isSafeHost,
+  ALLOWED_DOMAINS,
+};