Upload via GUI (7543 Dateien)

2026-10-22 06:53:45 +00:00
parent 5571f225d5
commit 047196c4d0
16 changed files with 7030 additions and 7467 deletions
@@ -0,0 +1,201 @@
+const test = require('node:test');
+const assert = require('node:assert');
+const http = require('node:http');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+const archiver = require('archiver');
+
+require('../src/git/gitBinary.js').useBundledGit();
+const { registerFeatureIpc } = require('../src/features/featuresIpc.js');
+
+const git = (cwd, ...a) => spawnSync('git', ['-c', 'user.name=t', '-c', 'user.email=t@t', ...a], { cwd, encoding: 'utf8' });
+const tmp = (p) => fs.mkdtempSync(path.join(os.tmpdir(), p));
+
+function makeZip(file, entries) {
+  return new Promise((resolve, reject) => {
+    const out = fs.createWriteStream(file);
+    const zip = archiver('zip');
+    out.on('close', resolve);
+    zip.on('error', reject);
+    zip.pipe(out);
+    for (const [name, content] of entries) zip.append(content, { name });
+    zip.finalize();
+  });
+}
+
+// Backup-Ordner wie von GiteaRepoBackup angelegt: Spiegel + ZIP-Stände
+async function makeBackupDir() {
+  const work = tmp('gm-src-');
+  git(work, 'init', '-q', '-b', 'main');
+  fs.writeFileSync(path.join(work, 'a.txt'), 'hallo');
+  git(work, 'add', '.'); git(work, 'commit', '-qm', 'eins');
+  git(work, 'branch', 'feature'); git(work, 'tag', 'v1.0');
+  const dir = tmp('gm-bk-');
+  fs.mkdirSync(path.join(dir, 'M_Viper'));
+  git(dir, 'clone', '-q', '--mirror', work, path.join(dir, 'M_Viper', 'deskhub.git'));
+  const zipDir = path.join(dir, 'M_Viper', 'deskhub-archiv');
+  fs.mkdirSync(zipDir);
+  await makeZip(path.join(zipDir, 'deskhub-2026-10-01_10-00.zip'), [['deskhub/a.txt', 'alt'], ['deskhub/src/b.kt', 'fun b() {}']]);
+  await makeZip(path.join(zipDir, 'deskhub-2026-10-20_10-00.zip'), [['deskhub/a.txt', 'neu'], ['deskhub/src/b.kt', 'fun b() {}']]);
+  fs.utimesSync(path.join(zipDir, 'deskhub-2026-10-01_10-00.zip'), new Date('2026-10-01'), new Date('2026-10-01'));
+  fs.writeFileSync(path.join(dir, 'backup-protokoll.json'), '{}');
+  return { dir, work };
+}
+
+// Gitea-Nachbau: neue Repos zeigen auf echte lokale Bare-Repos, damit der Push wirklich läuft
+function fakeGitea() {
+  const created = [];
+  const patches = [];
+  const repoRoot = tmp('gm-remote-');
+  const server = http.createServer((req, res) => {
+    const u = new URL(req.url, 'http://x');
+    const send = (code, obj) => { res.statusCode = code; res.setHeader('Content-Type', 'application/json'); res.end(JSON.stringify(obj)); };
+    let body = '';
+    req.on('data', c => body += c);
+    req.on('end', () => {
+      if (u.pathname === '/api/v1/user') return send(200, { login: 'M_Viper' });
+      if (u.pathname === '/api/v1/user/repos' && req.method === 'POST') {
+        const b = JSON.parse(body);
+        if (b.name === 'deskhub') return send(409, { message: 'repository already exists' });
+        const bare = path.join(repoRoot, `${b.name}.git`);
+        spawnSync('git', ['init', '-q', '--bare', '-b', 'main', bare]);
+        created.push(b);
+        return send(201, { name: b.name, full_name: `M_Viper/${b.name}`, owner: { login: 'M_Viper' }, clone_url: bare, html_url: `http://gitea/M_Viper/${b.name}`, default_branch: 'main' });
+      }
+      if (u.pathname.startsWith('/api/v1/repos/M_Viper/') && req.method === 'PATCH') { patches.push(JSON.parse(body)); return send(200, {}); }
+      send(404, { message: 'not found' });
+    });
+  });
+  return new Promise(r => server.listen(0, '127.0.0.1', () => r({ server, created, patches, repoRoot, url: `http://127.0.0.1:${server.address().port}` })));
+}
+
+function setup(url) {
+  const handlers = {};
+  const userData = tmp('gm-ud-');
+  registerFeatureIpc({
+    ipcMain: { handle: (name, fn) => { handlers[name] = fn; } },
+    app: { getPath: () => userData },
+    readCredentials: () => ({ giteaURL: url, giteaToken: 'geheim123' }),
+    buildItemsFromPaths: async () => ({ items: [], skipped: [], ignored: [] }),
+    clearGitTransportBlock: () => false
+  });
+  return (name, data) => handlers[name]({ sender: { send() {} } }, data);
+}
+
+test('Sicherungen werden gefunden: Spiegel und ZIP-Stände, neuester zuerst', async () => {
+  const { dir } = await makeBackupDir();
+  const call = setup('http://127.0.0.1:1');
+  const r = await call('repo-backup-list', { dir });
+  assert.strictEqual(r.ok, true, r.error);
+  assert.strictEqual(r.backups.length, 1);
+  const b = r.backups[0];
+  assert.deepStrictEqual([b.owner, b.repo], ['M_Viper', 'deskhub']);
+  assert.ok(b.mirror);
+  assert.deepStrictEqual(b.zips.map(z => z.file), ['deskhub-2026-10-20_10-00.zip', 'deskhub-2026-10-01_10-00.zip']);
+});
+
+test('Lokal: Spiegel wird zur Arbeitskopie mit allen Branches, ZIP ohne Oberordner entpackt', async () => {
+  const { dir } = await makeBackupDir();
+  const call = setup('http://127.0.0.1:1');
+  const { backups: [b] } = await call('repo-backup-list', { dir });
+
+  const dest1 = tmp('gm-dst-');
+  const m = await call('repo-restore-local', { kind: 'mirror', source: b.mirror.path, destParent: dest1, repo: 'deskhub' });
+  assert.strictEqual(m.ok, true, m.error);
+  assert.strictEqual(fs.readFileSync(path.join(dest1, 'deskhub', 'a.txt'), 'utf8'), 'hallo');
+  assert.match(git(path.join(dest1, 'deskhub'), 'branch', '-r').stdout, /feature/);
+
+  // Zweiter Versuch in denselben Ordner darf nichts überschreiben
+  const again = await call('repo-restore-local', { kind: 'mirror', source: b.mirror.path, destParent: dest1, repo: 'deskhub' });
+  assert.strictEqual(again.ok, false);
+  assert.match(again.error, /existiert bereits/);
+
+  const dest2 = tmp('gm-dst-');
+  const z = await call('repo-restore-local', { kind: 'zip', source: b.zips[0].path, destParent: dest2, repo: 'deskhub' });
+  assert.strictEqual(z.ok, true, z.error);
+  assert.strictEqual(z.files, 2);
+  assert.strictEqual(fs.readFileSync(path.join(dest2, 'deskhub', 'a.txt'), 'utf8'), 'neu');
+  assert.ok(fs.existsSync(path.join(dest2, 'deskhub', 'src', 'b.kt')));
+});
+
+// ZIP von Hand bauen: archiver entschärft "../" schon beim Erzeugen, ein echter Angreifer nicht.
+function rawZip(file, entries) {
+  const zlib = require('node:zlib');
+  const locals = [];
+  const centrals = [];
+  let offset = 0;
+  for (const [name, content] of entries) {
+    const n = Buffer.from(name);
+    const data = Buffer.from(content);
+    const crc = zlib.crc32(data);
+    const lh = Buffer.alloc(30);
+    lh.writeUInt32LE(0x04034b50, 0); lh.writeUInt16LE(20, 4); lh.writeUInt32LE(crc, 14);
+    lh.writeUInt32LE(data.length, 18); lh.writeUInt32LE(data.length, 22); lh.writeUInt16LE(n.length, 26);
+    const ch = Buffer.alloc(46);
+    ch.writeUInt32LE(0x02014b50, 0); ch.writeUInt16LE(20, 4); ch.writeUInt16LE(20, 6); ch.writeUInt32LE(crc, 16);
+    ch.writeUInt32LE(data.length, 20); ch.writeUInt32LE(data.length, 24); ch.writeUInt16LE(n.length, 28); ch.writeUInt32LE(offset, 42);
+    locals.push(lh, n, data);
+    centrals.push(ch, n);
+    offset += lh.length + n.length + data.length;
+  }
+  const cd = Buffer.concat(centrals);
+  const end = Buffer.alloc(22);
+  end.writeUInt32LE(0x06054b50, 0); end.writeUInt16LE(entries.length, 8); end.writeUInt16LE(entries.length, 10);
+  end.writeUInt32LE(cd.length, 12); end.writeUInt32LE(offset, 16);
+  fs.writeFileSync(file, Buffer.concat([...locals, cd, end]));
+}
+
+test('Archive mit Pfaden außerhalb des Ziels werden abgewiesen', async () => {
+  const d = tmp('gm-evil-');
+  const zip = path.join(d, 'evil.zip');
+  rawZip(zip, [['deskhub/ok.txt', 'ok'], ['deskhub/../../boese.txt', 'x']]);
+  const unzipper = require('unzipper');
+  const names = (await unzipper.Open.file(zip)).files.map(f => f.path);
+  assert.ok(names.includes('deskhub/../../boese.txt'), 'Testarchiv muss den gefährlichen Pfad wirklich enthalten');
+  const call = setup('http://127.0.0.1:1');
+  const destParent = tmp('gm-dst-');
+  const r = await call('repo-restore-local', { kind: 'zip', source: zip, destParent, repo: 'x' });
+  assert.strictEqual(r.ok, false);
+  assert.match(r.error, /Unsicherer Pfad/);
+  assert.ok(!fs.existsSync(path.join(destParent, 'x', 'ok.txt')), 'auch harmlose Dateien dürfen dann nicht entpackt werden');
+  assert.ok(!fs.existsSync(path.join(destParent, 'boese.txt')));
+});
+
+test('Gitea: Spiegel und ZIP als neues Repo, Namenskonflikt und ZIP-Überschreiben werden abgefangen', async () => {
+  const { dir } = await makeBackupDir();
+  const g = await fakeGitea();
+  try {
+    const call = setup(g.url);
+    const { backups: [b] } = await call('repo-backup-list', { dir });
+
+    const m = await call('repo-restore-gitea', { kind: 'mirror', source: b.mirror.path, owner: 'M_Viper', repo: 'deskhub', mode: 'new', newName: 'deskhub-wieder', isPrivate: true });
+    assert.strictEqual(m.ok, true, m.error);
+    const bare = path.join(g.repoRoot, 'deskhub-wieder.git');
+    const refs = git(bare, 'for-each-ref', '--format=%(refname)').stdout;
+    assert.match(refs, /refs\/heads\/main/);
+    assert.match(refs, /refs\/heads\/feature/);
+    assert.match(refs, /refs\/tags\/v1\.0/);
+    assert.strictEqual(g.created[0].private, true);
+
+    const z = await call('repo-restore-gitea', { kind: 'zip', source: b.zips[0].path, owner: 'M_Viper', repo: 'deskhub', mode: 'new', newName: 'deskhub-zip' });
+    assert.strictEqual(z.ok, true, z.error);
+    assert.strictEqual(z.method, 'Git');
+    const files = git(path.join(g.repoRoot, 'deskhub-zip.git'), 'ls-tree', '-r', '--name-only', 'main').stdout.trim().split('\n');
+    assert.deepStrictEqual(files.sort(), ['a.txt', 'src/b.kt']);
+
+    const conflict = await call('repo-restore-gitea', { kind: 'mirror', source: b.mirror.path, owner: 'M_Viper', repo: 'deskhub', mode: 'new', newName: 'deskhub' });
+    assert.strictEqual(conflict.ok, false);
+    assert.match(conflict.error, /existiert bereits/);
+
+    const zipOverwrite = await call('repo-restore-gitea', { kind: 'zip', source: b.zips[0].path, owner: 'M_Viper', repo: 'deskhub', mode: 'overwrite' });
+    assert.strictEqual(zipOverwrite.ok, false);
+    assert.match(zipOverwrite.error, /nur mit einem Git-Spiegel/);
+
+    const badName = await call('repo-restore-gitea', { kind: 'zip', source: b.zips[0].path, owner: 'M_Viper', repo: 'deskhub', mode: 'new', newName: 'mit leerzeichen' });
+    assert.strictEqual(badName.ok, false);
+  } finally {
+    g.server.close();
+  }
+});