@danieltmn/tamnora 0.8.0 → 0.9.0

package/harness/packages/server/test/security.test.js

@@ -0,0 +1,252 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import http from 'node:http';
+import { mkdtemp, writeFile, unlink, mkdir } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { createTamnoraServer } from '../src/index.js';
+import { setHome, ensureApp, writeApp, makeUser, bridgeStatePath } from '../../core/src/index.js';
+import { isLoopback, localOk } from '../src/lib/workspace.js';
+import { loginClear } from '../src/auth.js';
+
+const fakeProvider = {
+  id: 'fake',
+  async streamChat(_config, { onEvent }) {
+    onEvent?.({ type: 'text', delta: 'hola', full: 'hola' });
+    return { content: 'hola', reasoning: '', toolCalls: [] };
+  },
+};
+
+async function startServer(overrides = {}) {
+  const cwd = overrides.cwd ?? (await mkdtemp(path.join(tmpdir(), 'tamnora-sec-')));
+  setHome(cwd);
+  const instance = await createTamnoraServer({
+    cwd,
+    dbPath: path.join(cwd, 'tamnora.db'),
+    loadMcp: false,
+    resolveProvider: () => ({ provider: fakeProvider, config: {} }),
+    ...overrides,
+  });
+  const info = await instance.listen({ port: 0 });
+  return { instance, base: info.url, cwd, home: cwd };
+}
+
+/** Deja un bridge.json apuntando a un supervisor vivo (este proceso). */
+async function fakeTunnel() {
+  await writeFile(bridgeStatePath(), `${JSON.stringify({ pid: process.pid, url: 'https://fake.tunnelmole.net', provider: 'tunnelmole', port: 4517 })}\n`);
+}
+
+async function clearTunnel() {
+  try {
+    await unlink(bridgeStatePath());
+  } catch {
+    /* nada */
+  }
+}
+
+test('isLoopback solo acepta direcciones de loopback', () => {
+  for (const good of ['127.0.0.1', '127.9.9.9', '::1', '0:0:0:0:0:0:0:1', '::ffff:127.0.0.1']) {
+    assert.ok(isLoopback(good), good);
+  }
+  for (const bad of ['192.168.1.5', '::ffff:192.168.1.5', '', null, 'fe80::1']) {
+    assert.ok(!isLoopback(bad), String(bad));
+  }
+});
+
+test('localOk exige loopback en remoteAddress y sin tunel activo', async () => {
+  const fake = (remote) => ({ socket: { remoteAddress: remote } });
+  assert.ok(localOk(fake('127.0.0.1')));
+  assert.ok(!localOk(fake('192.168.1.5')));
+  // localAddress (la direccion de bind) ya no engana.
+  assert.ok(!localOk({ socket: { remoteAddress: '10.0.0.8', localAddress: '127.0.0.1' } }));
+
+  const { instance, home } = await startServer();
+  try {
+    // Con tunel activo, hasta una conexion loopback deja de ser local.
+    await fakeTunnel();
+    // El cache de tunnelState vive 1 s.
+    await new Promise((r) => setTimeout(r, 1100));
+    assert.ok(!localOk({ socket: { remoteAddress: '127.0.0.1' } }));
+    assert.equal(home, path.dirname(bridgeStatePath()));
+  } finally {
+    await clearTunnel();
+    await instance.close();
+  }
+});
+
+test('POST /api/shell responde 403 mientras el tunel esta activo', async () => {
+  const { instance, base } = await startServer();
+  try {
+    const shell = (extraHeaders = {}) =>
+      fetch(`${base}/api/shell`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...extraHeaders },
+        body: JSON.stringify({ command: 'echo tamnora-ok' }),
+      });
+
+    const ok = await shell();
+    assert.equal(ok.status, 200);
+    const body = await ok.json();
+    assert.match(String(body.output), /tamnora-ok/);
+
+    await fakeTunnel();
+    await new Promise((r) => setTimeout(r, 1100));
+    const blocked = await shell();
+    assert.equal(blocked.status, 403);
+
+    // Con header falsificado tampoco pasa: remoteAddress manda.
+    const spoofed = await shell({ 'x-forwarded-for': '203.0.113.9' });
+    assert.equal(spoofed.status, 403);
+  } finally {
+    await clearTunnel();
+    await instance.close();
+  }
+});
+
+test('GET /api/files: sin tunel acepta ?root; con tunel y sin auth responde 403', async () => {
+  const { instance, base } = await startServer();
+  try {
+    // Sin tunel y desde loopback el request es local: cualquier raiz va.
+    const outside = await mkdtemp(path.join(tmpdir(), 'tamnora-fuera-'));
+    mkdir(path.join(outside, 'sub'));
+    const free = await (await fetch(`${base}/api/files?root=${encodeURIComponent(outside)}`)).json();
+    assert.equal(free.root, outside, 'conexion local puede explorar otra raiz');
+
+    const escape = await fetch(`${base}/api/files?path=..%2F..&root=${encodeURIComponent(outside)}`);
+    assert.equal(escape.status, 400);
+
+    await fakeTunnel();
+    await new Promise((r) => setTimeout(r, 1100));
+    const viaTunnel = await fetch(`${base}/api/files`);
+    assert.equal(viaTunnel.status, 403);
+  } finally {
+    await clearTunnel();
+    await instance.close();
+  }
+});
+
+test('con auth, git/files quedan usables por el tunel y confinados al workspace', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-sec-auth-'));
+  setHome(cwd);
+  const app = ensureApp();
+  app.user = makeUser('admin', 'secreto123');
+  writeApp(app);
+
+  const instance = await createTamnoraServer({
+    cwd,
+    dbPath: path.join(cwd, 'tamnora.db'),
+    loadMcp: false,
+    resolveProvider: () => ({ provider: fakeProvider, config: {} }),
+  });
+  const info = await instance.listen({ port: 0 });
+  const base = info.url;
+  try {
+    const login = await fetch(`${base}/api/auth/login`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ username: 'admin', password: 'secreto123' }),
+    });
+    assert.equal(login.status, 200);
+    const cookie = login.headers.get('set-cookie');
+    const { csrf } = await login.json();
+
+    await fakeTunnel();
+    await new Promise((r) => setTimeout(r, 1100));
+
+    const files = await fetch(`${base}/api/files`, { headers: { cookie } });
+    assert.equal(files.status, 200);
+    const listing = await files.json();
+    assert.equal(listing.root, cwd, 'por el tunel la raiz es el workspace');
+
+    const shell = await fetch(`${base}/api/shell`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', cookie, 'x-csrf': csrf },
+      body: JSON.stringify({ command: 'echo nope' }),
+    });
+    assert.equal(shell.status, 403, 'el shell directo sigue cerrado por el tunel');
+  } finally {
+    await clearTunnel();
+    await instance.close();
+  }
+});
+
+test('el lockout de login no se esquiva falsificando X-Forwarded-For', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-sec-lock-'));
+  setHome(cwd);
+  const app = ensureApp();
+  app.user = makeUser('locktest', 'secreto123');
+  writeApp(app);
+
+  const instance = await createTamnoraServer({
+    cwd,
+    dbPath: path.join(cwd, 'tamnora.db'),
+    loadMcp: false,
+    resolveProvider: () => ({ provider: fakeProvider, config: {} }),
+  });
+  const info = await instance.listen({ port: 0 });
+  const base = info.url;
+  try {
+    const attempt = (xff) =>
+      fetch(`${base}/api/auth/login`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...(xff ? { 'x-forwarded-for': xff } : {}) },
+        body: JSON.stringify({ username: 'locktest', password: 'mala' }),
+      });
+
+    for (let i = 0; i < 5; i++) {
+      await attempt(i % 2 ? '203.0.113.1' : '203.0.113.2');
+    }
+    const lockedPlain = await attempt();
+    assert.equal(lockedPlain.status, 429);
+
+    const lockedSpoof = await attempt('198.51.100.7');
+    assert.equal(lockedSpoof.status, 429, 'XFF falsificado no resetea el contador');
+  } finally {
+    loginClear({ socket: { remoteAddress: '127.0.0.1' } }, 'locktest');
+    await instance.close();
+  }
+});
+
+test('la cookie va con Secure cuando hay tunel y el Host es publico', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-sec-cookie-'));
+  setHome(cwd);
+  const app = ensureApp();
+  app.user = makeUser('admin', 'secreto123');
+  writeApp(app);
+
+  const instance = await createTamnoraServer({
+    cwd,
+    dbPath: path.join(cwd, 'tamnora.db'),
+    loadMcp: false,
+    resolveProvider: () => ({ provider: fakeProvider, config: {} }),
+  });
+  const info = await instance.listen({ port: 0 });
+  try {
+    await fakeTunnel();
+    await new Promise((r) => setTimeout(r, 1100));
+
+    const rawLogin = (host) =>
+      new Promise((resolve, reject) => {
+        const body = JSON.stringify({ username: 'admin', password: 'secreto123' });
+        const req = http.request(
+          { host: '127.0.0.1', port: info.port, path: '/api/auth/login', method: 'POST', headers: { Host: host, 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) } },
+          (res) => {
+            let out = '';
+            res.on('data', (c) => (out += c));
+            res.on('end', () => resolve({ status: res.statusCode, setCookie: res.headers['set-cookie']?.[0] ?? '' }));
+          }
+        );
+        req.on('error', reject);
+        req.end(body);
+      });
+
+    const viaTunnel = await rawLogin('algo.tunnelmole.net');
+    assert.match(String(viaTunnel.setCookie), /Secure/, 'por el tunel la cookie es Secure');
+
+    const local = await rawLogin('localhost:4517');
+    assert.ok(!/Secure/i.test(String(local.setCookie)), 'local http no fuerza Secure');
+  } finally {
+    await clearTunnel();
+    await instance.close();
+  }
+});