Genarrative/apps/ai-game-creator-shell/scripts/verify-updater-signature.test.mjs

import assert from 'node:assert/strict';
import {
  createHash,
  generateKeyPairSync,
  randomBytes,
  sign as cryptoSign,
} from 'node:crypto';
import fs from 'node:fs';
import os from 'node:os';
import path from 'node:path';
import test from 'node:test';

import {
  decodeUpdaterPublicKey,
  decodeUpdaterSignature,
  readUpdaterPubkey,
  verifyUpdaterSignature,
} from './verify-updater-signature.mjs';

/**
 * 用进程内生成的 Ed25519 密钥自造 minisign 结构，
 * 覆盖 Tauri 实际使用的 `ED`（BLAKE2b-512 预哈希）与 `Ed`（原文）两种模式。
 */
function createKeyMaterial() {
  const { publicKey, privateKey } = generateKeyPairSync('ed25519');
  const rawKey = Buffer.from(
    publicKey.export({ format: 'jwk' }).x,
    'base64url',
  );
  const keyId = randomBytes(8);
  const pubkey = Buffer.from(
    `untrusted comment: minisign public key: ${keyId.reverse().toString('hex').toUpperCase()}\n` +
      `${Buffer.concat([Buffer.from('Ed'), keyId, rawKey]).toString('base64')}\n`,
  ).toString('base64');
  return { privateKey, keyId, rawKey, pubkey };
}

function signFixture({ privateKey, keyId }, payload, algorithm) {
  const message =
    algorithm === 'ED'
      ? createHash('blake2b512').update(payload).digest()
      : payload;
  const signature = cryptoSign(null, message, privateKey);
  const blob = Buffer.concat([Buffer.from(algorithm), keyId, signature]);
  const globalSignature = cryptoSign(null, blob, privateKey);
  return Buffer.from(
    'untrusted comment: signature from tauri secret key\n' +
      `${blob.toString('base64')}\n` +
      'trusted comment: timestamp:0\tfile:fixture\n' +
      `${globalSignature.toString('base64')}\n`,
  ).toString('base64');
}

function withFixture(run) {
  const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'agc-sig-test-'));
  try {
    const artifactPath = path.join(directory, 'app.app.tar.gz');
    fs.writeFileSync(artifactPath, 'update payload');
    return run({ directory, artifactPath });
  } finally {
    fs.rmSync(directory, { recursive: true, force: true });
  }
}

test('接受 Tauri 实际使用的 ED（BLAKE2b-512 预哈希）签名', () => {
  withFixture(({ directory, artifactPath }) => {
    const material = createKeyMaterial();
    const signaturePath = path.join(directory, 'app.app.tar.gz.sig');
    fs.writeFileSync(
      signaturePath,
      signFixture(material, fs.readFileSync(artifactPath), 'ED'),
    );
    const result = verifyUpdaterSignature({
      artifactPath,
      signaturePath,
      pubkey: material.pubkey,
    });
    assert.equal(result.algorithm, 'ED');
    assert.equal(result.keyId, material.keyId.toString('hex'));
  });
});

test('接受原文 Ed 签名，两种算法互不通用', () => {
  withFixture(({ directory, artifactPath }) => {
    const material = createKeyMaterial();
    const payload = fs.readFileSync(artifactPath);
    const signaturePath = path.join(directory, 'app.app.tar.gz.sig');
    fs.writeFileSync(signaturePath, signFixture(material, payload, 'Ed'));
    assert.equal(
      verifyUpdaterSignature({
        artifactPath,
        signaturePath,
        pubkey: material.pubkey,
      }).algorithm,
      'Ed',
    );
    // 原文模式下签名的是别的载荷时必须失败：证明确实在校验内容而非只看结构。
    fs.writeFileSync(
      signaturePath,
      signFixture(material, Buffer.from('别的载荷'), 'Ed'),
    );
    assert.throws(
      () =>
        verifyUpdaterSignature({
          artifactPath,
          signaturePath,
          pubkey: material.pubkey,
        }),
      /签名校验失败/u,
    );
  });
});

test('产物被篡改时失败关闭', () => {
  withFixture(({ directory, artifactPath }) => {
    const material = createKeyMaterial();
    const signaturePath = path.join(directory, 'app.app.tar.gz.sig');
    fs.writeFileSync(
      signaturePath,
      signFixture(material, fs.readFileSync(artifactPath), 'ED'),
    );
    fs.writeFileSync(artifactPath, 'tampered payload');
    assert.throws(
      () =>
        verifyUpdaterSignature({
          artifactPath,
          signaturePath,
          pubkey: material.pubkey,
        }),
      /签名校验失败/u,
    );
  });
});

test('签名私钥与内置公钥不是同一对时给出明确错误', () => {
  withFixture(({ directory, artifactPath }) => {
    const signing = createKeyMaterial();
    const baked = createKeyMaterial();
    const signaturePath = path.join(directory, 'app.app.tar.gz.sig');
    fs.writeFileSync(
      signaturePath,
      signFixture(signing, fs.readFileSync(artifactPath), 'ED'),
    );
    assert.throws(
      () =>
        verifyUpdaterSignature({
          artifactPath,
          signaturePath,
          pubkey: baked.pubkey,
        }),
      /keyId 不一致/u,
    );
  });
});

test('公钥或签名格式非法时拒绝解析', () => {
  assert.throws(() => decodeUpdaterPublicKey(''), /为空/u);
  assert.throws(
    () => decodeUpdaterPublicKey('bm90IGEgbWluaXNpZ24ga2V5'),
    /不是 minisign 内容/u,
  );
  assert.throws(
    () =>
      decodeUpdaterPublicKey(
        Buffer.from('untrusted comment: x\nAAAA\n').toString('base64'),
      ),
    /长度异常/u,
  );
  assert.throws(
    () =>
      decodeUpdaterSignature(
        Buffer.from('untrusted comment: x\nAAAA\n').toString('base64'),
      ),
    /长度异常/u,
  );
});

test('仓库里配置的 updater 公钥可被解析（两平台共用）', () => {
  const decoded = decodeUpdaterPublicKey(readUpdaterPubkey());
  assert.equal(decoded.algorithm, 'Ed');
  assert.equal(decoded.key.length, 32);
});