git-tag-guardian 1.0.0

package/src/checks/postinstall-hooks.js

@@ -0,0 +1,170 @@
+/**
+ * Проверка 2: Postinstall / lifecycle hooks
+ *
+ * Обнаруживает пакеты в node_modules, которые содержат
+ * потенциально опасные lifecycle-скрипты:
+ *   - preinstall, install, postinstall
+ *   - preuninstall, uninstall, postuninstall
+ *   - prepare, prepublish
+ *
+ * Вектор атаки: через tag rewrite вредоносный package.json
+ * получает postinstall hook, который автоматически выполняется
+ * при npm install, собирая env vars, SSH-ключи, токены.
+ */
+
+import { readFile, readdir } from 'node:fs/promises';
+import { join, basename } from 'node:path';
+import { logger } from '../utils/logger.js';
+
+const DANGEROUS_HOOKS = [
+  'preinstall',
+  'install',
+  'postinstall',
+  'preuninstall',
+  'uninstall',
+  'postuninstall',
+  'prepare',
+];
+
+// Паттерны подозрительного кода в lifecycle-скриптах
+const SUSPICIOUS_PATTERNS = [
+  { pattern: /curl\s+.*https?:\/\//, label: 'HTTP exfiltration (curl)' },
+  { pattern: /wget\s+.*https?:\/\//, label: 'HTTP exfiltration (wget)' },
+  { pattern: /https?\.request|https?\.get|fetch\(/, label: 'Network request in script' },
+  { pattern: /process\.env/, label: 'Доступ к переменным окружения' },
+  { pattern: /\.ssh\//, label: 'Доступ к SSH-ключам' },
+  { pattern: /\.bashrc|\.zshrc|\.profile/, label: 'Модификация shell profile' },
+  { pattern: /\.npmrc/, label: 'Модификация npm config' },
+  { pattern: /\.gitconfig/, label: 'Доступ к git config' },
+  { pattern: /child_process|exec\(|execSync|spawn/, label: 'Порождение процессов' },
+  { pattern: /eval\(|Function\(/, label: 'Динамическое выполнение кода' },
+  { pattern: /Buffer\.from\(.*,\s*['"]base64['"]/, label: 'Base64 decode (обфускация)' },
+  { pattern: /\\x[0-9a-f]{2}/i, label: 'Hex-encoded strings' },
+  { pattern: /require\(['"]https?['"]\)/, label: 'Импорт http(s) модуля' },
+  { pattern: /os\.userInfo|os\.hostname/, label: 'Сбор информации о системе' },
+  { pattern: /fs\.appendFileSync|fs\.writeFileSync/, label: 'Запись в файловую систему' },
+  { pattern: /dns\.resolve|dns\.lookup/, label: 'DNS exfiltration' },
+];
+
+/**
+ * @param {string} cwd
+ * @param {object} config
+ * @returns {Promise<import('../index.js').Finding[]>}
+ */
+export async function checkPostinstallHooks(cwd, config) {
+  /** @type {import('../index.js').Finding[]} */
+  const findings = [];
+
+  const nmDir = join(cwd, 'node_modules');
+  let modules;
+  try {
+    modules = await readdir(nmDir, { withFileTypes: true });
+  } catch {
+    logger.info('  node_modules не найден — пропускаем');
+    return findings;
+  }
+
+  const allowList = new Set(config.allowedLifecyclePackages || []);
+  let checkedCount = 0;
+  let hookCount = 0;
+
+  // Обходим top-level и scoped пакеты
+  const packageDirs = [];
+  for (const entry of modules) {
+    if (!entry.isDirectory() || entry.name.startsWith('.')) continue;
+
+    if (entry.name.startsWith('@')) {
+      // Scoped packages
+      try {
+        const scoped = await readdir(join(nmDir, entry.name), { withFileTypes: true });
+        for (const sub of scoped) {
+          if (sub.isDirectory()) {
+            packageDirs.push(join(entry.name, sub.name));
+          }
+        }
+      } catch { /* skip */ }
+    } else {
+      packageDirs.push(entry.name);
+    }
+  }
+
+  for (const relPath of packageDirs) {
+    const pkgJsonPath = join(nmDir, relPath, 'package.json');
+    let pkgJson;
+    try {
+      pkgJson = JSON.parse(await readFile(pkgJsonPath, 'utf8'));
+    } catch { continue; }
+
+    checkedCount++;
+    const scripts = pkgJson.scripts || {};
+
+    for (const hook of DANGEROUS_HOOKS) {
+      if (!scripts[hook]) continue;
+
+      hookCount++;
+      const pkgName = pkgJson.name || relPath;
+      const scriptContent = scripts[hook];
+
+      if (allowList.has(pkgName)) {
+        logger.debug(`  ${pkgName}: ${hook} — в allow-list, пропускаем`);
+        continue;
+      }
+
+      // Определяем severity на основе подозрительных паттернов
+      const suspiciousMatches = [];
+      for (const { pattern, label } of SUSPICIOUS_PATTERNS) {
+        if (pattern.test(scriptContent)) {
+          suspiciousMatches.push(label);
+        }
+      }
+
+      // Дополнительно проверяем файл, на который ссылается hook
+      const hookFile = extractHookFile(scriptContent, join(nmDir, relPath));
+      if (hookFile) {
+        try {
+          const hookCode = await readFile(hookFile, 'utf8');
+          for (const { pattern, label } of SUSPICIOUS_PATTERNS) {
+            if (pattern.test(hookCode) && !suspiciousMatches.includes(label)) {
+              suspiciousMatches.push(label);
+            }
+          }
+        } catch { /* файл не найден */ }
+      }
+
+      const severity = suspiciousMatches.length >= 3 ? 'critical' :
+                       suspiciousMatches.length >= 1 ? 'high' : 'medium';
+
+      findings.push({
+        check: 'postinstall-hooks',
+        severity,
+        message: `Пакет "${pkgName}" содержит lifecycle hook: ${hook}`,
+        pkg: pkgName,
+        file: pkgJsonPath,
+        detail: suspiciousMatches.length
+          ? `Подозрительные паттерны: ${suspiciousMatches.join(', ')}\nСкрипт: ${scriptContent.slice(0, 200)}`
+          : `Скрипт: ${scriptContent.slice(0, 200)}`,
+        fix: `Проверьте содержимое скрипта вручную. Если доверяете — добавьте "${pkgName}" в allowedLifecyclePackages`,
+      });
+    }
+  }
+
+  logger.info(`  Проверено пакетов: ${checkedCount}`);
+  logger.info(`  Lifecycle hooks найдено: ${hookCount}`);
+
+  return findings;
+}
+
+/**
+ * Пытается определить файл, на который ссылается lifecycle-скрипт.
+ */
+function extractHookFile(script, pkgDir) {
+  // "node install.js" → install.js
+  const nodeMatch = script.match(/node\s+([^\s;|&]+)/);
+  if (nodeMatch) return join(pkgDir, nodeMatch[1]);
+
+  // "./scripts/postinstall.sh"
+  const shMatch = script.match(/(?:sh|bash)\s+([^\s;|&]+)/);
+  if (shMatch) return join(pkgDir, shMatch[1]);
+
+  return null;
+}

package/src/checks/sha-pinning.js

@@ -0,0 +1,172 @@
+/**
+ * Проверка 1: SHA Pinning
+ *
+ * Обнаруживает git-зависимости в package.json/package-lock.json,
+ * которые ссылаются на теги вместо полных SHA.
+ *
+ * Вектор атаки: Tag Rewrite — злоумышленник переписывает тег
+ * на вредоносный коммит из форка. При следующем npm install
+ * SHA в package-lock.json молча меняется.
+ *
+ * Также отслеживает drift: если baseline зафиксировал SHA,
+ * а package-lock.json теперь содержит другой — предупреждение.
+ */
+
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { logger } from '../utils/logger.js';
+import { BaselineManager } from '../utils/baseline.js';
+
+const GIT_DEP_RE = /^(?:git(?:\+(?:ssh|https?))?:\/\/|github:)/;
+const GITHUB_SHORT_RE = /^([^/]+\/[^/#]+)(?:#(.+))?$/;
+const SHA_FULL_RE = /^[0-9a-f]{40}$/;
+const SHA_SHORT_RE = /^[0-9a-f]{7,40}$/;
+
+/**
+ * @param {string} cwd
+ * @param {object} config
+ * @returns {Promise<import('../index.js').Finding[]>}
+ */
+export async function checkSHAPinning(cwd, config) {
+  /** @type {import('../index.js').Finding[]} */
+  const findings = [];
+
+  // ── Анализ package.json ──────────────────────────────────────
+  let pkgJson;
+  try {
+    pkgJson = JSON.parse(await readFile(join(cwd, 'package.json'), 'utf8'));
+  } catch {
+    logger.warn('  package.json не найден — пропускаем');
+    return findings;
+  }
+
+  const allDeps = {
+    ...pkgJson.dependencies,
+    ...pkgJson.devDependencies,
+    ...pkgJson.optionalDependencies,
+  };
+
+  // Находим git-зависимости с тегами (а не SHA)
+  for (const [name, spec] of Object.entries(allDeps)) {
+    if (typeof spec !== 'string') continue;
+
+    const gitInfo = parseGitDep(spec);
+    if (!gitInfo) continue; // не git-зависимость
+
+    if (gitInfo.ref && !SHA_FULL_RE.test(gitInfo.ref)) {
+      findings.push({
+        check: 'sha-pinning',
+        severity: 'high',
+        message: `Зависимость "${name}" ссылается на тег/ветку "${gitInfo.ref}" вместо SHA`,
+        pkg: name,
+        file: 'package.json',
+        detail: `spec: ${spec}`,
+        fix: `Замените на полный SHA коммита: "${name}": "${gitInfo.base}#<full-40-char-sha>"`,
+      });
+    }
+  }
+
+  // ── Анализ package-lock.json ─────────────────────────────────
+  let lockfile;
+  try {
+    lockfile = JSON.parse(await readFile(join(cwd, 'package-lock.json'), 'utf8'));
+  } catch {
+    logger.debug('  package-lock.json не найден');
+    return findings;
+  }
+
+  // Baseline для drift detection
+  const baseline = new BaselineManager(cwd, config.baselineFile);
+  await baseline.load();
+
+  const packages = lockfile.packages || {};
+  for (const [pkgPath, meta] of Object.entries(packages)) {
+    if (!meta.resolved || !meta.resolved.includes('git')) continue;
+
+    const resolvedSHA = extractSHAFromResolved(meta.resolved);
+    if (!resolvedSHA) continue;
+
+    const pkgName = pkgPath.replace('node_modules/', '');
+    if (!pkgName) continue;
+
+    // Drift detection: сравниваем с baseline
+    const baselineSHA = baseline.getDependencySHA(pkgName);
+    if (baselineSHA && baselineSHA !== resolvedSHA) {
+      findings.push({
+        check: 'sha-pinning',
+        severity: 'critical',
+        message: `SHA DRIFT: "${pkgName}" SHA изменился с момента baseline!`,
+        pkg: pkgName,
+        file: 'package-lock.json',
+        detail: `baseline: ${baselineSHA}\ncurrent:  ${resolvedSHA}`,
+        fix: 'Проверьте git-зависимость вручную. Если изменение легитимно, обновите baseline: npx git-tag-guardian baseline',
+      });
+    }
+
+    // Проверяем что resolved содержит full SHA (не short)
+    if (resolvedSHA && !SHA_FULL_RE.test(resolvedSHA)) {
+      findings.push({
+        check: 'sha-pinning',
+        severity: 'medium',
+        message: `"${pkgName}" resolved содержит короткий SHA`,
+        pkg: pkgName,
+        file: 'package-lock.json',
+        detail: `resolved SHA: ${resolvedSHA}`,
+      });
+    }
+
+    logger.debug(`  ${pkgName}: ${resolvedSHA?.slice(0, 12)}...`);
+  }
+
+  const gitDepCount = Object.entries(allDeps).filter(([, v]) => parseGitDep(v)).length;
+  if (gitDepCount === 0) {
+    logger.info('  Git-зависимости не обнаружены — OK');
+  } else {
+    logger.info(`  Обнаружено git-зависимостей: ${gitDepCount}`);
+  }
+
+  return findings;
+}
+
+/**
+ * Парсит git-зависимость, возвращает { base, ref } или null.
+ */
+function parseGitDep(spec) {
+  if (!spec || typeof spec !== 'string') return null;
+
+  // github:owner/repo#ref
+  if (spec.startsWith('github:')) {
+    const rest = spec.slice(7);
+    const match = rest.match(GITHUB_SHORT_RE);
+    if (match) return { base: `github:${match[1]}`, ref: match[2] || null };
+  }
+
+  // owner/repo#ref (GitHub shorthand)
+  if (/^[^@/][^/]*\/[^/#]+/.test(spec) && !spec.startsWith('@')) {
+    const match = spec.match(GITHUB_SHORT_RE);
+    if (match) return { base: match[1], ref: match[2] || null };
+  }
+
+  // git+https://... или git+ssh://...
+  if (GIT_DEP_RE.test(spec)) {
+    const hashIdx = spec.indexOf('#');
+    if (hashIdx !== -1) {
+      return { base: spec.slice(0, hashIdx), ref: spec.slice(hashIdx + 1) };
+    }
+    return { base: spec, ref: null };
+  }
+
+  return null;
+}
+
+/**
+ * Извлекает SHA из resolved поля package-lock.json.
+ * Например: "git+ssh://git@github.com/owner/repo.git#abc123..." → "abc123..."
+ */
+function extractSHAFromResolved(resolved) {
+  if (!resolved) return null;
+  const hashIdx = resolved.lastIndexOf('#');
+  if (hashIdx === -1) return null;
+  const sha = resolved.slice(hashIdx + 1);
+  return SHA_SHORT_RE.test(sha) ? sha : null;
+}

package/src/checks/tag-integrity.js

@@ -0,0 +1,229 @@
+/**
+ * Проверка 3: Tag Integrity через GitHub API
+ *
+ * Для каждой git-зависимости, ссылающейся на GitHub,
+ * запрашивает текущий SHA тега через API и сравнивает
+ * с baseline.
+ *
+ * Вектор атаки: Tag Rewrite — злоумышленник с push-доступом
+ * переписывает lightweight тег на SHA вредоносного коммита
+ * из fork network. GitHub API: PATCH /git/refs/tags/<tag>
+ * с { sha: "malicious_sha", force: true }.
+ */
+
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { logger } from '../utils/logger.js';
+import { BaselineManager } from '../utils/baseline.js';
+
+const GITHUB_REPO_RE = /github\.com[/:]([^/]+)\/([^/.#]+)/;
+
+/**
+ * @param {string} cwd
+ * @param {object} config
+ * @param {string} githubToken
+ * @returns {Promise<import('../index.js').Finding[]>}
+ */
+export async function checkTagIntegrity(cwd, config, githubToken) {
+  /** @type {import('../index.js').Finding[]} */
+  const findings = [];
+
+  let pkgJson;
+  try {
+    pkgJson = JSON.parse(await readFile(join(cwd, 'package.json'), 'utf8'));
+  } catch {
+    return findings;
+  }
+
+  const allDeps = {
+    ...pkgJson.dependencies,
+    ...pkgJson.devDependencies,
+    ...pkgJson.optionalDependencies,
+  };
+
+  const baseline = new BaselineManager(cwd, config.baselineFile);
+  await baseline.load();
+
+  for (const [name, spec] of Object.entries(allDeps)) {
+    if (typeof spec !== 'string') continue;
+
+    const info = parseGitHubRef(spec);
+    if (!info || !info.tag) continue; // нет тега — ок (SHA pinned)
+
+    logger.debug(`  Проверяем тег: ${info.owner}/${info.repo}#${info.tag}`);
+
+    try {
+      const remoteSHA = await fetchTagSHA(info.owner, info.repo, info.tag, githubToken);
+      if (!remoteSHA) {
+        findings.push({
+          check: 'tag-integrity',
+          severity: 'medium',
+          message: `Тег "${info.tag}" не найден для ${info.owner}/${info.repo}`,
+          pkg: name,
+          detail: `Возможно тег удалён или переименован`,
+        });
+        continue;
+      }
+
+      const repoTag = `${info.owner}/${info.repo}#${info.tag}`;
+      const baselineSHA = baseline.getTagSHA(repoTag);
+
+      if (baselineSHA && baselineSHA !== remoteSHA) {
+        findings.push({
+          check: 'tag-integrity',
+          severity: 'critical',
+          message: `TAG REWRITE DETECTED: ${repoTag} SHA изменился!`,
+          pkg: name,
+          detail: `baseline SHA: ${baselineSHA}\nremote SHA:   ${remoteSHA}\nЭто может означать, что тег был переписан на вредоносный коммит.`,
+          fix: `1. НЕ запускайте npm install!\n2. Проверьте коммит ${remoteSHA} вручную через GitHub UI\n3. Свяжитесь с maintainer-ом репозитория\n4. Переключитесь на SHA-pinning: "${name}": "github:${info.owner}/${info.repo}#${baselineSHA}"`,
+        });
+      } else if (!baselineSHA) {
+        logger.info(`  ${repoTag} → ${remoteSHA.slice(0, 12)}... (первое сканирование)`);
+      } else {
+        logger.info(`  ${repoTag} → ${remoteSHA.slice(0, 12)}... (соответствует baseline)`);
+      }
+
+      // Дополнительно: проверяем, принадлежит ли коммит ветке main/master
+      try {
+        const commitInfo = await fetchCommitInfo(info.owner, info.repo, remoteSHA, githubToken);
+        if (commitInfo && commitInfo.isForkCommit) {
+          findings.push({
+            check: 'tag-integrity',
+            severity: 'critical',
+            message: `Тег "${info.tag}" указывает на коммит из ФОРКА!`,
+            pkg: name,
+            detail: `Коммит ${remoteSHA} не найден в default branch.\nЭто типичный признак tag rewrite attack.`,
+            fix: `Немедленно проверьте коммит вручную. Если подтвердится — это supply chain атака.`,
+          });
+        }
+      } catch {
+        // API limit или ошибка — не критично
+      }
+
+    } catch (err) {
+      logger.warn(`  Ошибка проверки ${name}: ${err.message}`);
+    }
+  }
+
+  return findings;
+}
+
+/**
+ * Парсит GitHub-ссылку из dependency spec.
+ * @returns {{ owner: string, repo: string, tag: string|null } | null}
+ */
+function parseGitHubRef(spec) {
+  if (!spec || typeof spec !== 'string') return null;
+
+  // "github:owner/repo#tag"
+  let rest = spec;
+  if (rest.startsWith('github:')) rest = rest.slice(7);
+  if (rest.startsWith('git+https://')) rest = rest.slice(12);
+  if (rest.startsWith('git+ssh://git@')) rest = rest.slice(14);
+
+  const match = rest.match(GITHUB_REPO_RE) || rest.match(/^([^/]+)\/([^/#]+)(?:#(.+))?$/);
+  if (!match) return null;
+
+  const owner = match[1];
+  const repo = match[2].replace(/\.git$/, '');
+  const hashIdx = spec.indexOf('#');
+  const ref = hashIdx !== -1 ? spec.slice(hashIdx + 1) : null;
+
+  // Если ref — полный SHA (40 hex), то это не тег
+  if (ref && /^[0-9a-f]{40}$/.test(ref)) return { owner, repo, tag: null };
+
+  return { owner, repo, tag: ref };
+}
+
+/**
+ * Запрашивает SHA тега через GitHub API.
+ */
+async function fetchTagSHA(owner, repo, tag, token) {
+  const url = `https://api.github.com/repos/${owner}/${repo}/git/refs/tags/${tag}`;
+  const res = await fetch(url, {
+    headers: {
+      'Authorization': `token ${token}`,
+      'Accept': 'application/vnd.github+json',
+      'User-Agent': 'git-tag-guardian/1.0',
+    },
+  });
+
+  if (res.status === 404) return null;
+  if (!res.ok) throw new Error(`GitHub API: ${res.status} ${res.statusText}`);
+
+  const data = await res.json();
+
+  // Annotated tag — нужно дереференсить
+  if (data.object?.type === 'tag') {
+    const tagUrl = data.object.url;
+    const tagRes = await fetch(tagUrl, {
+      headers: {
+        'Authorization': `token ${token}`,
+        'Accept': 'application/vnd.github+json',
+        'User-Agent': 'git-tag-guardian/1.0',
+      },
+    });
+    if (tagRes.ok) {
+      const tagData = await tagRes.json();
+      return tagData.object?.sha || data.object.sha;
+    }
+  }
+
+  return data.object?.sha || null;
+}
+
+/**
+ * Проверяет, принадлежит ли коммит default branch.
+ * Если нет — возможно это коммит из форка (tag rewrite attack).
+ */
+async function fetchCommitInfo(owner, repo, sha, token) {
+  // Проверяем, содержит ли default branch этот коммит
+  const url = `https://api.github.com/repos/${owner}/${repo}/commits/${sha}/branches-where-head`;
+  const res = await fetch(url, {
+    headers: {
+      'Authorization': `token ${token}`,
+      'Accept': 'application/vnd.github+json',
+      'User-Agent': 'git-tag-guardian/1.0',
+    },
+  });
+
+  if (!res.ok) return null;
+
+  const branches = await res.json();
+  // Проверяем, есть ли main/master среди веток
+  const onDefaultBranch = branches.some(
+    b => b.name === 'main' || b.name === 'master'
+  );
+
+  // Дополнительная проверка: сравниваем author коммита с maintainer-ами
+  const commitUrl = `https://api.github.com/repos/${owner}/${repo}/commits/${sha}`;
+  const commitRes = await fetch(commitUrl, {
+    headers: {
+      'Authorization': `token ${token}`,
+      'Accept': 'application/vnd.github+json',
+      'User-Agent': 'git-tag-guardian/1.0',
+    },
+  });
+
+  let isForkCommit = !onDefaultBranch;
+
+  if (commitRes.ok) {
+    const commitData = await commitRes.json();
+    // Если коммит не на default branch И автор не collaborator — высокий риск
+    if (!onDefaultBranch && commitData.author?.login) {
+      const collabUrl = `https://api.github.com/repos/${owner}/${repo}/collaborators/${commitData.author.login}`;
+      const collabRes = await fetch(collabUrl, {
+        headers: {
+          'Authorization': `token ${token}`,
+          'Accept': 'application/vnd.github+json',
+          'User-Agent': 'git-tag-guardian/1.0',
+        },
+      });
+      if (collabRes.status === 404) {
+        isForkCommit = true; // автор не collaborator
+      }
+    }
+  }
+
+  return { isForkCommit, onDefaultBranch };
+}

package/src/checks/tarball-integrity.js

@@ -0,0 +1,117 @@
+/**
+ * Проверка 4: Tarball (.tar.gz) Integrity
+ *
+ * Для git-зависимостей, ссылающихся на GitHub через теги,
+ * скачивает .tar.gz и сверяет SHA256 с baseline.
+ *
+ * Вектор атаки: GitHub автоматически регенерирует .tar.gz
+ * после tag rewrite. URL остаётся прежним, но содержимое
+ * меняется (размер, хеш, новые файлы типа install.js).
+ */
+
+import { createHash } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { logger } from '../utils/logger.js';
+import { BaselineManager } from '../utils/baseline.js';
+
+/**
+ * @param {string} cwd
+ * @param {object} config
+ * @returns {Promise<import('../index.js').Finding[]>}
+ */
+export async function checkTarballIntegrity(cwd, config) {
+  /** @type {import('../index.js').Finding[]} */
+  const findings = [];
+
+  let pkgJson;
+  try {
+    pkgJson = JSON.parse(await readFile(join(cwd, 'package.json'), 'utf8'));
+  } catch {
+    return findings;
+  }
+
+  const allDeps = {
+    ...pkgJson.dependencies,
+    ...pkgJson.devDependencies,
+  };
+
+  const baseline = new BaselineManager(cwd, config.baselineFile);
+  await baseline.load();
+
+  for (const [name, spec] of Object.entries(allDeps)) {
+    if (typeof spec !== 'string') continue;
+
+    const tarballUrl = buildTarballUrl(spec);
+    if (!tarballUrl) continue;
+
+    logger.debug(`  Проверяем tarball: ${name} → ${tarballUrl}`);
+
+    try {
+      const res = await fetch(tarballUrl, {
+        headers: { 'User-Agent': 'git-tag-guardian/1.0' },
+        redirect: 'follow',
+      });
+
+      if (!res.ok) {
+        logger.warn(`  ${name}: tarball недоступен (${res.status})`);
+        continue;
+      }
+
+      const buffer = Buffer.from(await res.arrayBuffer());
+      const sha256 = createHash('sha256').update(buffer).digest('hex');
+      const size = buffer.length;
+
+      const baselineHash = baseline.getTarballHash(tarballUrl);
+      if (baselineHash && baselineHash !== sha256) {
+        findings.push({
+          check: 'tarball-integrity',
+          severity: 'critical',
+          message: `TARBALL CHANGED: "${name}" .tar.gz хеш изменился!`,
+          pkg: name,
+          detail: `URL:      ${tarballUrl}\nbaseline: ${baselineHash}\ncurrent:  ${sha256}\nsize:     ${size} bytes\n\nТег мог быть переписан (tag rewrite attack).`,
+          fix: `1. Сравните содержимое tarball вручную\n2. Проверьте тег через GitHub API\n3. Обновите baseline если изменение легитимно`,
+        });
+      } else if (!baselineHash) {
+        logger.info(`  ${name}: ${sha256.slice(0, 16)}... (${size} bytes) — записано в baseline`);
+      } else {
+        logger.info(`  ${name}: OK (соответствует baseline)`);
+      }
+
+    } catch (err) {
+      logger.warn(`  ${name}: ошибка скачивания tarball: ${err.message}`);
+    }
+  }
+
+  return findings;
+}
+
+/**
+ * Строит URL .tar.gz для GitHub-зависимости.
+ * github:owner/repo#tag → https://github.com/owner/repo/archive/refs/tags/tag.tar.gz
+ */
+function buildTarballUrl(spec) {
+  if (!spec || typeof spec !== 'string') return null;
+
+  let rest = spec;
+  if (rest.startsWith('github:')) rest = rest.slice(7);
+  else if (rest.includes('github.com')) {
+    const m = rest.match(/github\.com[/:]([^/]+\/[^/.#]+)/);
+    if (m) rest = m[1];
+    else return null;
+  } else {
+    return null;
+  }
+
+  // owner/repo#ref
+  const hashIdx = rest.indexOf('#');
+  if (hashIdx === -1) return null;
+
+  const ownerRepo = rest.slice(0, hashIdx);
+  const ref = rest.slice(hashIdx + 1);
+
+  // Только для тегов (не для полных SHA)
+  if (/^[0-9a-f]{40}$/.test(ref)) return null;
+
+  return `https://github.com/${ownerRepo}/archive/refs/tags/${ref}.tar.gz`;
+}