Skip to content

OpenPanel is an open-source web and product analytics platform, an open-source alternative to Mixpanel with optional self-hosting.

5.9 KB
Raw Blame
// Tests @openpanel/shared's safeFetch from here because the root `test` script
// does not run packages/shared.
import { afterAll, beforeAll, describe, expect, it } from 'bun:test';
import http from 'node:http';
import type { AddressInfo } from 'node:net';
import {
  BlockedUrlError,
  isBlockedIp,
  safeFetch,
  safeFetchStream,
} from '@openpanel/shared/server';

describe('isBlockedIp', () => {
  it('blocks the ranges an SSRF payload aims at', () => {
    const blocked = [
      '169.254.169.254', // AWS/GCP/Azure instance metadata
      '127.0.0.1',
      '127.1.2.3',
      '0.0.0.0',
      '10.0.0.1',
      '172.16.0.1',
      '172.31.255.255',
      '192.168.1.1',
      '100.64.0.1', // CGNAT
      '198.18.0.1', // benchmarking
      '224.0.0.1', // multicast
      '255.255.255.255',
      '::1',
      '::',
      'fd00::1', // unique local
      'fe80::1', // link local
      'ff00::1', // multicast
      '::ffff:127.0.0.1', // IPv4-mapped loopback
      '::ffff:169.254.169.254', // IPv4-mapped metadata
      '2002:7f00:1::', // 6to4 wrapping 127.0.0.1
      '64:ff9b::7f00:1', // NAT64 wrapping 127.0.0.1
      'not-an-ip',
    ];

    for (const ip of blocked) {
      expect(isBlockedIp(ip), ip).toBe(true);
    }
  });

  it('allows public addresses', () => {
    for (const ip of ['8.8.8.8', '1.1.1.1', '93.184.216.34', '2606:4700::1']) {
      expect(isBlockedIp(ip), ip).toBe(false);
    }
  });
});

describe('safeFetch', () => {
  let secretServer: http.Server;
  let redirectServer: http.Server;
  let secretPort: number;
  let redirectPort: number;

  beforeAll(async () => {
    secretServer = http.createServer((_req, res) => {
      res.writeHead(200, { 'content-type': 'text/plain' });
      res.end('INTERNAL-SECRET');
    });
    await new Promise<void>((resolve) =>
      secretServer.listen(0, '127.0.0.1', resolve)
    );
    secretPort = (secretServer.address() as AddressInfo).port;

    redirectServer = http.createServer((_req, res) => {
      res.writeHead(302, {
        location: `http://127.0.0.1:${secretPort}/secret.png`,
      });
      res.end();
    });
    await new Promise<void>((resolve) =>
      redirectServer.listen(0, '127.0.0.1', resolve)
    );
    redirectPort = (redirectServer.address() as AddressInfo).port;
  });

  afterAll(async () => {
    await new Promise<void>((resolve) => secretServer.close(() => resolve()));
    await new Promise<void>((resolve) => redirectServer.close(() => resolve()));
  });

  it('refuses to fetch a loopback address directly', async () => {
    await expect(
      safeFetch(`http://127.0.0.1:${secretPort}/secret.png`, {
        timeoutMs: 3000,
      })
    ).rejects.toBeInstanceOf(BlockedUrlError);
  });

  it('refuses to fetch a hostname that resolves to loopback', async () => {
    await expect(
      safeFetch(`http://localhost:${secretPort}/secret.png`, {
        timeoutMs: 3000,
      })
    ).rejects.toBeInstanceOf(BlockedUrlError);
  });

  it('refuses a redirect that points at an internal address', async () => {
    // The reachability gate on the caller side only inspects the first URL,
    // so the redirect hop has to be re-validated or the guard is bypassable.
    await expect(
      safeFetch(`http://127.0.0.1:${redirectPort}/x.png`, { timeoutMs: 3000 })
    ).rejects.toBeInstanceOf(BlockedUrlError);
  });

  it('refuses cloud instance metadata', async () => {
    await expect(
      safeFetch('http://169.254.169.254/latest/meta-data/', {
        timeoutMs: 3000,
      })
    ).rejects.toBeInstanceOf(BlockedUrlError);
  });

  it('refuses non-http schemes', async () => {
    await expect(safeFetch('file:///etc/passwd')).rejects.toBeInstanceOf(
      BlockedUrlError
    );
  });
});

describe('safeFetchStream', () => {
  let secretServer: http.Server;
  let redirectServer: http.Server;
  let secretPort: number;
  let redirectPort: number;

  beforeAll(async () => {
    secretServer = http.createServer((_req, res) => {
      res.writeHead(200, { 'content-type': 'text/csv' });
      res.end('INTERNAL-SECRET');
    });
    await new Promise<void>((resolve) =>
      secretServer.listen(0, '127.0.0.1', resolve)
    );
    secretPort = (secretServer.address() as AddressInfo).port;

    redirectServer = http.createServer((_req, res) => {
      res.writeHead(302, {
        location: `http://127.0.0.1:${secretPort}/export.csv`,
      });
      res.end();
    });
    await new Promise<void>((resolve) =>
      redirectServer.listen(0, '127.0.0.1', resolve)
    );
    redirectPort = (redirectServer.address() as AddressInfo).port;
  });

  afterAll(async () => {
    await new Promise<void>((resolve) => secretServer.close(() => resolve()));
    await new Promise<void>((resolve) => redirectServer.close(() => resolve()));
  });

  // The streaming variant must hold the same line as safeFetch; a second
  // implementation that forgot a check left the importer unguarded once.
  it('refuses to fetch a loopback address directly', async () => {
    await expect(
      safeFetchStream(`http://127.0.0.1:${secretPort}/export.csv`, {
        timeoutMs: 3000,
      })
    ).rejects.toBeInstanceOf(BlockedUrlError);
  });

  it('refuses to fetch a hostname that resolves to loopback', async () => {
    await expect(
      safeFetchStream(`http://localhost:${secretPort}/export.csv`, {
        timeoutMs: 3000,
      })
    ).rejects.toBeInstanceOf(BlockedUrlError);
  });

  it('refuses a redirect that points at an internal address', async () => {
    await expect(
      safeFetchStream(`http://127.0.0.1:${redirectPort}/export.csv`, {
        timeoutMs: 3000,
      })
    ).rejects.toBeInstanceOf(BlockedUrlError);
  });

  it('refuses cloud instance metadata', async () => {
    await expect(
      safeFetchStream('http://169.254.169.254/latest/meta-data/', {
        timeoutMs: 3000,
      })
    ).rejects.toBeInstanceOf(BlockedUrlError);
  });

  it('refuses non-http schemes', async () => {
    await expect(safeFetchStream('file:///etc/passwd')).rejects.toBeInstanceOf(
      BlockedUrlError
    );
  });
});