Skip to content

A local-first personal finance app

7.8 KB
Raw Blame
import createDebug from 'debug';
import express from 'express';
import rateLimit from 'express-rate-limit';
import { fetch } from 'undici';

import { config } from './load-config';
import { requestLoggerMiddleware } from './util/middlewares';
import { isBlockedIp } from './util/ssrf';
import { validateSession } from './util/validate-user';

const debugSensitive = createDebug('actual-sensitive:cors-proxy');

const app = express();

app.use(express.json());
app.use(requestLoggerMiddleware);
app.use(
  rateLimit({
    windowMs: 60 * 1000,
    max: 25,
    legacyHeaders: false,
    standardHeaders: true,
  }),
);

// Cache for the allowlist to avoid fetching it on every request
let allowlistedRepos = [];
let lastAllowlistFetch = 0;
const ALLOWLIST_CACHE_TTL = 5 * 60 * 1000; // 5 minutes

// Export cache clearing function for testing
export const clearAllowlistCache = () => {
  allowlistedRepos = [];
  lastAllowlistFetch = 0;
};

async function fetchAllowlist() {
  const now = Date.now();
  if (
    now - lastAllowlistFetch < ALLOWLIST_CACHE_TTL &&
    allowlistedRepos.length > 0
  ) {
    return allowlistedRepos;
  }

  try {
    const response = await fetch(
      'https://raw.githubusercontent.com/actualbudget/plugin-store/refs/heads/main/plugins.json',
    );
    if (!response.ok) {
      throw new Error(`Failed to fetch allowlist: ${response.status}`);
    }
    const plugins = await response.json();
    allowlistedRepos = plugins.map(plugin => plugin.url);
    lastAllowlistFetch = now;
    console.log('Updated plugin allowlist:', allowlistedRepos);
    return allowlistedRepos;
  } catch (error) {
    console.error('Failed to fetch plugin allowlist:', error);
    // Return empty array if fetch fails to be safe
    allowlistedRepos = [];
    return allowlistedRepos;
  }
}

/**
 * Return true only if the URL is on an allowlist and not a local/private address.
 */
function isUrlAllowed(targetUrl) {
  try {
    const url = new URL(targetUrl);
    const hostname = url.hostname;

    // Block private/local IP addresses
    if (isBlockedIp(hostname)) {
      console.warn(`Blocked request to private/localhost IP: ${hostname}`);
      return false;
    }

    // Always allow the specific plugin-store URL
    if (
      targetUrl ===
      'https://raw.githubusercontent.com/actualbudget/plugin-store/refs/heads/main/plugins.json'
    ) {
      return true;
    }

    // Check against allowlisted repositories
    for (const repoUrl of allowlistedRepos) {
      try {
        const { pathname } = new URL(repoUrl);
        const [, repoOwner, repoName] = pathname.split('/');

        if (
          targetUrl === repoUrl ||
          targetUrl.startsWith(repoUrl + '/') ||
          (hostname === 'api.github.com' &&
            (url.pathname === `/repos/${repoOwner}/${repoName}` ||
              url.pathname.startsWith(`/repos/${repoOwner}/${repoName}/`))) ||
          (hostname === 'raw.githubusercontent.com' &&
            url.pathname.startsWith(`/${repoOwner}/${repoName}/`)) ||
          (hostname === 'github.com' &&
            url.pathname.startsWith(`/${repoOwner}/${repoName}/releases/`))
        ) {
          return true;
        }
      } catch (e) {
        console.warn(
          'Invalid repository URL in allowlist:',
          repoUrl,
          e.message,
        );
      }
    }

    return false;
  } catch (e) {
    console.warn('Invalid target URL');
    debugSensitive('Invalid target URL %s: %O', targetUrl, e);
    return false;
  }
}

app.use('/', async (req, res) => {
  // CORS preflight
  if (req.method === 'OPTIONS') {
    res.set('Access-Control-Allow-Origin', '*');
    res.set('Access-Control-Allow-Methods', 'GET,HEAD,OPTIONS');
    res.set('Access-Control-Allow-Headers', 'Content-Type, X-Actual-Token');
    res.set('Access-Control-Max-Age', '600');
    return res.status(204).end();
  }

  const targetUrlString = req.query.url;

  if (!targetUrlString) {
    return res.status(400).json({ error: 'Missing url parameter' });
  }

  // Validate session/token
  const session = await validateSession(req, res);
  if (!session) {
    return; // validateSession already sent the response
  }

  let url;
  try {
    url = new URL(targetUrlString);
  } catch {
    return res.status(400).json({ error: 'Invalid url parameter' });
  }

  // Fetch the latest allowlist
  try {
    await fetchAllowlist();
  } catch (error) {
    console.error('Failed to fetch allowlist:', error);
    return res.status(403).json({
      error: 'URL not allowed',
      message: 'Unable to verify allowlist',
    });
  }

  // Check if the URL is allowed
  if (!isUrlAllowed(url.href)) {
    console.warn('Blocked request to unauthorized URL');
    debugSensitive('Blocked request to unauthorized URL: %s', url.href);
    return res.status(403).json({
      error: 'URL not allowed',
      message:
        'Only allowlisted plugin repositories are allowed (localhost only in development)',
    });
  }

  try {
    const { method = 'GET', headers: customHeaders = {} } = req.body || {};

    if (typeof method !== 'string') {
      return res.status(400).json({ error: 'Invalid method parameter' });
    }
    const methodNormalized = method.toUpperCase();
    if (!['GET', 'HEAD'].includes(methodNormalized)) {
      return res.status(405).json({ error: 'Method not allowed' });
    }

    const requestHeaders = {
      ...req.headers,
      ...customHeaders,
      host: url.host,
    };

    // Remove headers that shouldn't be forwarded
    delete requestHeaders['x-actual-token'];
    delete requestHeaders['content-length'];
    delete requestHeaders['cookie'];
    delete requestHeaders['cookie2'];

    // Add GitHub authentication if token is configured and request is to GitHub
    const githubToken = config.get('github.token');
    if (
      githubToken &&
      (url.hostname === 'api.github.com' ||
        url.hostname === 'raw.githubusercontent.com' ||
        (url.hostname === 'github.com' && url.pathname.includes('/releases/')))
    ) {
      requestHeaders['Authorization'] = `Bearer ${githubToken}`;
      requestHeaders['User-Agent'] = 'Actual-Budget-Plugin-System';
      console.log(
        `Using GitHub authentication for request to: ${url.hostname}`,
      );
    }

    const response = await fetch(url.href, {
      method: methodNormalized,
      headers: requestHeaders,
    });

    const contentType =
      response.headers.get('content-type') || 'application/octet-stream';

    res.set('Access-Control-Allow-Origin', '*');
    res.status(response.status);

    // Try to detect if this might be JSON content based on URL or content
    const urlString = url.toString().toLowerCase();
    const isLikelyJson =
      contentType?.includes('application/json') ||
      urlString.includes('.json') ||
      urlString.includes('/manifest') ||
      urlString.includes('manifest.json') ||
      urlString.includes('package.json');

    if (isLikelyJson) {
      // For JSON responses, return the actual content
      res.set('Content-Type', 'application/json');
      const text = await response.text();
      try {
        res.json(JSON.parse(text));
      } catch {
        // If it's not valid JSON, treat as text
        res.set('Content-Type', contentType || 'text/plain');
        res.send(text);
      }
    } else if (contentType?.includes('text/')) {
      // For text responses, return as plain text
      res.set('Content-Type', contentType);
      const text = await response.text();
      res.send(text);
    } else {
      // For actual binary responses, return as JSON format
      res.set('Content-Type', 'application/json');
      const buffer = await response.arrayBuffer();
      const binaryData = {
        data: Array.from(new Uint8Array(buffer)),
        contentType,
        isBinary: true,
      };
      res.json(binaryData);
    }
  } catch (err) {
    res
      .status(500)
      .json({ error: 'Error proxying request', details: err.message });
  }
});

export { app as handlers };