osv-scanner-mcp 0.4.0 → 0.4.1

package/README.md

@@ -119,7 +119,7 @@ npm run build
 | 変数 | 説明 |
 |---|---|
 | `OSV_SCANNER_PATH` | 使用するosv-scannerバイナリの明示指定。省略時はPATH→自動ダウンロードの順で解決。**指定が無効な場合はフォールバックせずエラーになります**(意図しないバイナリの実行防止) |
-| `OSV_MCP_ALLOWED_ROOT` | 指定時、このディレクトリ配下以外のスキャンを拒否します(パストラバーサル対策の境界)。**設定を推奨** |
+| `OSV_MCP_ALLOWED_ROOT` | 指定時、このディレクトリ配下以外のスキャンを拒否します(パストラバーサル対策の境界)。**設定を推奨**。空文字・空白のみは未設定として扱います |
 | `OSV_MCP_REQUIRE_ALLOWED_ROOT` | `1` または `true` 指定時、`OSV_MCP_ALLOWED_ROOT` が未設定ならサーバーの起動自体を拒否します(運用環境向けのfail-closedモード) |
 | `OSV_MCP_MAX_CONCURRENT_SCANS` | 同時実行できるスキャン数の上限(デフォルト `2`、最大 `16`)。超過したリクエストは待たずに即時エラーになります |
 | `OSV_MCP_AUTO_DOWNLOAD` | `0` または `false` でバイナリの自動ダウンロードを無効化(デフォルト有効) |
@@ -405,6 +405,7 @@ OSV-Scanner 2.4.0の `java/archive` プラグインを使用し、ネストJAR
 | `binary_not_found` | OSV-Scannerが見つからない(インストール案内をmessageに含む) |
 | `project_not_found` | 指定パスが存在しない・ディレクトリ/pom.xmlでない |
 | `no_manifest_found` | 対応マニフェスト(pom.xml / gradle.lockfile)が見つからない |
+| `scan_input_too_large` | スキャン対象ファイル(一時ディレクトリへのコピー)の合計サイズが上限(2GiB)を超えた。対象を絞って再実行する |
 | `manifest_search_limit_exceeded` | マニフェスト探索が上限(20万エントリ・1,000マニフェスト)に達した。より狭いディレクトリかマニフェストを直接指定する |
 | `binary_download_failed` | バイナリのダウンロード失敗(未対応プラットフォーム含む) |
 | `binary_checksum_mismatch` | ダウンロードしたバイナリのチェックサム不一致(改ざん/破損の可能性) |
@@ -427,8 +428,9 @@ OSV-Scanner 2.4.0の `java/archive` プラグインを使用し、ネストJAR
 
 - **サプライチェーン対策**: バイナリの自動ダウンロードは公式GitHub Releasesに限定し、バージョンをピン留め。**パッケージに埋め込まれたSHA256チェックサム**で検証します(配布元のSHA256SUMSファイルは信用しないため、リリース側が改ざんされても検出可能)。検証合格まで実行権限を与えず、キャッシュ済みバイナリも使用のたびに再検証します。`OSV_MCP_PREFER_DOWNLOAD=1` でPATH上の未検証バイナリを使わない運用も選べます
 - **コマンドインジェクション対策**: シェルを経由しない `spawn` + 引数配列で実行。OSV-Scannerへの引数は固定リストのみで、可変部は検証済み絶対パス1つだけ
+- **スナップショット方式(検査と読み込みの不一致の防止)**: OSV-Scannerには元のファイルを一切渡しません。lockfile・`pom.xml`(親POMの連鎖を含む)・JAR/WARは、本サーバーが安全に1回だけ読んだ内容を専用の一時ディレクトリ(所有者のみアクセス可、終了時に削除)へコピーしてスキャンし、検査もそのコピーに対して行います。検査の後で元のファイルやディレクトリを差し替えても結果には影響しません。親POMは元の配置を一時ディレクトリ内に再現してコピーするため、OSV-Scannerが相対パスで親をたどっても、見つかるのは検証してコピーしたファイルだけです(`..` を重ねて一時ディレクトリの外に届く参照は除外)。読み込みは末尾のシンボリックリンクをたどらず、名前付きパイプ等の通常のファイル以外は読まず(処理が止まらない)、読み終えた後にパスを解決し直して境界の内側かつ開いた実体と同じファイルかを確認します。コピーの合計サイズは2GiBまでです(超えると `scan_input_too_large`)
 - **パストラバーサル対策**: 入力パスは `realpath` でシンボリックリンク解決後に境界チェック。pom.xml探索ではシンボリックリンクを辿りません。OSV-Scannerにはディレクトリを渡さず、検出したマニフェストだけを形式を明示して個別に渡します(ディレクトリを渡すと、OSV-Scannerが同じディレクトリの `requirements.txt` も読み、その取り込み指定 `-r ../x.txt` でスキャン範囲の外のファイルを読むため)。`scan_project` でrequirements.txtをスキャンする場合は元ファイルを渡さず、解釈できた依存の行だけを正規化して書いた専用コピーをスキャンします。コピーには取り込み指定を含めないため、OSV-Scannerの取り込みの解釈と本サーバーの解析がずれても、範囲外のファイルは読まれません。`pom.xml` の親POMの連鎖が `OSV_MCP_ALLOWED_ROOT` の外を参照する場合は、その `pom.xml` をスキャン対象から外します([親POMの扱い](#親pomの扱い))
-- **DoS対策**: タイムアウト・stdout上限・stderr抜粋上限を設定。スキャン結果は防御的にパースし、形式不正でも例外を投げません。同時実行スキャン数も上限(デフォルト2)を設け、並列リクエストによるプロセスの無制限起動を防ぎます
+- **DoS対策**: タイムアウト・stdout上限・stderr抜粋上限を設定。スキャン結果は防御的にパースし、形式不正でも例外を投げません。同時実行スキャン数も上限(デフォルト2)を設け、並列リクエストによるプロセスの無制限起動を防ぎます。本サーバー自身の解析も、同じファイルは1回だけ読んで結果を使い回し(workspaceの収録確認でのlockfile、requirements.txtの共通の取り込み先、親POM)、読む量の合計に上限を設けます
 - **fail-closedな運用モード**: `OSV_MCP_REQUIRE_ALLOWED_ROOT=1` で、スキャン許可ルート未設定時にサーバーの起動自体を拒否できます
 - **通信先の固定と明示**: osv-scannerの依存解決先は `deps.dev` を明示指定し、スキャン対象のpom.xmlが指定する任意のリポジトリへ接続するモード(`--data-source native`)は使いません(テストで保証)。通信先の一覧と、deps.devへの送信を止める `OSV_MCP_NO_REMOTE_RESOLUTION=1` は[通信先とプライバシー](#通信先とプライバシー)を参照
 - **情報漏えい対策**: 想定外の例外はスタックトレース等を含めず `internal_error` に丸めます。外部由来のテキスト(脆弱性summary等)は長さ上限付きの「データ」として構造化して返します

package/dist/index.js

@@ -20,7 +20,7 @@ import { handleScanProject } from "./tools/scanProject.js";
 import { handleScanJavaArtifact } from "./tools/scanJavaArtifact.js";
 import { handleScanSbom } from "./tools/scanSbom.js";
 import { handleSuggestFix } from "./tools/suggestFix.js";
-import { ALLOWED_ROOT_ENV, allowedRootStartupError, allowedRootStartupWarning, } from "./utils/startupConfig.js";
+import { ALLOWED_ROOT_ENV, allowedRootFromEnv, allowedRootStartupError, allowedRootStartupWarning, } from "./utils/startupConfig.js";
 export { ALLOWED_ROOT_ENV };
 // fail-closed: 運用モードで許可ルートが未設定なら、ツールを一切公開せず終了する
 const startupError = allowedRootStartupError();
@@ -36,7 +36,7 @@ if (startupWarning !== null) {
 // NOTE: リリース時はpackage.jsonのversionと同じ値に更新すること
 const server = new McpServer({
     name: "osv-scanner-mcp",
-    version: "0.4.0",
+    version: "0.4.1",
 });
 server.registerTool("scan_project", {
     title: "プロジェクトの依存の脆弱性スキャン(Java / JavaScript / Python / Go)",
@@ -52,7 +52,7 @@ server.registerTool("scan_project", {
             .min(1)
             .describe("スキャン対象のプロジェクトディレクトリ、または対応するlockfile・マニフェストの絶対パス"),
     },
-}, async ({ project_path }) => handleScanProject({ project_path }, { allowedRoot: process.env[ALLOWED_ROOT_ENV] }));
+}, async ({ project_path }) => handleScanProject({ project_path }, { allowedRoot: allowedRootFromEnv() }));
 server.registerTool("scan_java_project", {
     title: "Javaプロジェクトの脆弱性スキャン",
     description: "Java(Maven)プロジェクトをGoogle OSV-Scannerでスキャンし、依存ライブラリの既知の脆弱性(CVE/GHSA)を深刻度順のJSONレポートで返す。" +
@@ -65,7 +65,7 @@ server.registerTool("scan_java_project", {
             .min(1)
             .describe("スキャン対象のプロジェクトディレクトリ、またはpom.xml/gradle.lockfileの絶対パス"),
     },
-}, async ({ project_path }) => handleScanJavaProject({ project_path }, { allowedRoot: process.env[ALLOWED_ROOT_ENV] }));
+}, async ({ project_path }) => handleScanJavaProject({ project_path }, { allowedRoot: allowedRootFromEnv() }));
 server.registerTool("suggest_fix", {
     title: "脆弱性を解消する推奨アップグレードの提案",
     description: "Java(Maven)プロジェクトをスキャンし、脆弱な依存パッケージごとに推奨アップグレードバージョンを提案する。" +
@@ -81,7 +81,7 @@ server.registerTool("suggest_fix", {
             .min(1)
             .describe("スキャン対象のプロジェクトディレクトリ、またはpom.xml/gradle.lockfileの絶対パス"),
     },
-}, async ({ project_path }) => handleSuggestFix({ project_path }, { allowedRoot: process.env[ALLOWED_ROOT_ENV] }));
+}, async ({ project_path }) => handleSuggestFix({ project_path }, { allowedRoot: allowedRootFromEnv() }));
 server.registerTool("explain_vulnerability", {
     title: "脆弱性の詳細説明の取得",
     description: "指定したGHSA-IDまたはCVE-IDの脆弱性の詳細をOSVデータベース(api.osv.dev)から取得して返す。" +
@@ -103,7 +103,7 @@ server.registerTool("scan_java_artifact", {
     inputSchema: {
         artifact_path: z.string().min(1).describe("JAR/WARファイル、または探索するディレクトリの絶対パス"),
     },
-}, async ({ artifact_path }) => handleScanJavaArtifact({ artifact_path }, { allowedRoot: process.env[ALLOWED_ROOT_ENV] }));
+}, async ({ artifact_path }) => handleScanJavaArtifact({ artifact_path }, { allowedRoot: allowedRootFromEnv() }));
 server.registerTool("scan_sbom", {
     title: "SBOMの脆弱性スキャン",
     description: "CycloneDX 1.4/1.5/1.6またはSPDX 2.2/2.3のJSON SBOMから識別できる依存をスキャンする。" +
@@ -112,7 +112,7 @@ server.registerTool("scan_sbom", {
     inputSchema: {
         sbom_path: z.string().min(1).describe("CycloneDX/SPDX JSON SBOMファイルの絶対パス"),
     },
-}, async ({ sbom_path }) => handleScanSbom({ sbom_path }, { allowedRoot: process.env[ALLOWED_ROOT_ENV] }));
+}, async ({ sbom_path }) => handleScanSbom({ sbom_path }, { allowedRoot: allowedRootFromEnv() }));
 const transport = new StdioServerTransport();
 await server.connect(transport);
 // stdoutはMCPプロトコル専用のため、起動ログはstderrへ

package/dist/tools/scanJavaArtifact.js

@@ -1,12 +1,43 @@
+import { stat } from "node:fs/promises";
+import path from "node:path";
 import { buildArtifactReport } from "../osv/artifactReport.js";
 import { runOsvArtifactScan } from "../osv/runner.js";
 import { detectJavaArtifacts } from "../utils/artifactDetector.js";
+import { ScanSnapshot } from "../utils/scanSnapshot.js";
+import { asArray, asRecord } from "../utils/unknownJson.js";
 import { errorResult, jsonResult } from "./toolResult.js";
+/** スキャナーが返したパス(スナップショットのコピー)を元のファイルに戻す */
+function restoreSourcePaths(raw, originals) {
+    for (const result of asArray(asRecord(raw)?.results)) {
+        const source = asRecord(asRecord(result)?.source);
+        if (source && typeof source.path === "string") {
+            const original = originals.get(source.path);
+            if (original !== undefined)
+                source.path = original;
+        }
+    }
+    return raw;
+}
 export async function handleScanJavaArtifact(args, options = {}) {
     try {
-        const { artifactPaths } = await detectJavaArtifacts(args.artifact_path, options);
-        const raw = await runOsvArtifactScan(artifactPaths, options);
-        return jsonResult(buildArtifactReport(raw, artifactPaths));
+        const { targetPath, artifactPaths } = await detectJavaArtifacts(args.artifact_path, options);
+        const boundary = (await stat(targetPath)).isDirectory() ? targetPath : path.dirname(targetPath);
+        // 元のJAR/WARは渡さず、安全に読んだ内容のコピーをスキャンする(検査後の差し替え対策)。
+        // コピーできなかったものはスキャンされず、同定不能として報告される
+        const snapshot = await ScanSnapshot.create();
+        try {
+            const originals = new Map();
+            for (const artifact of artifactPaths) {
+                const copy = await snapshot.copy(artifact, boundary);
+                if (copy.ok)
+                    originals.set(copy.path, artifact);
+            }
+            const raw = originals.size > 0 ? await runOsvArtifactScan([...originals.keys()], options) : { results: [] };
+            return jsonResult(buildArtifactReport(restoreSourcePaths(raw, originals), artifactPaths));
+        }
+        finally {
+            await snapshot.cleanup();
+        }
     }
     catch (error) {
         return errorResult(error);

package/dist/tools/scanJavaProject.js

@@ -2,9 +2,12 @@
  * `scan_java_project`ツールのハンドラ。
  * レスポンス形式(成功/エラー)は`toolResult.ts`参照。
  */
+import path from "node:path";
+import { ScanToolError } from "../errors.js";
 import { isRemoteResolutionDisabled, runOsvScan } from "../osv/runner.js";
 import { sanitizeExternalText } from "../utils/externalText.js";
 import { detectJavaProject } from "../utils/projectDetector.js";
+import { ScanSnapshot, snapshotManifests } from "../utils/scanSnapshot.js";
 import { errorResult, jsonResult } from "./toolResult.js";
 const TRANSITIVE_OMITTED_WARNING = "OSV_MCP_NO_REMOTE_RESOLUTIONの設定により、マニフェスト(pom.xml)からの推移的依存の解決を省略しています。" +
     "lockfile(gradle.lockfile)に記録された依存は対象ですが、pom.xmlに直接記載された依存の先にある推移的依存の脆弱性は含まれません。" +
@@ -32,17 +35,49 @@ export function skippedManifestsFields(skipped) {
         scope_warning: SKIPPED_MANIFESTS_WARNING,
     };
 }
+/**
+ * 検出したマニフェストをスナップショットへコピーし、コピーをスキャンする(元のファイルは渡さない)。
+ * 応答に一時ディレクトリのパスを出さないよう、スキャナーのパスは元のファイルに戻す。
+ * スナップショットは成功・失敗とも削除する。全件除外ならエラー。
+ */
+export async function scanJavaManifests(project, options) {
+    const snapshot = await ScanSnapshot.create();
+    try {
+        const { targets, skipped } = await snapshotManifests(snapshot, project.targets, {
+            projectDir: project.projectDir,
+            allowedRootReal: project.allowedRootReal,
+        });
+        const skippedPaths = new Set(skipped.map((s) => s.path));
+        const scanned = project.targets.filter((t) => !skippedPaths.has(t.path));
+        const relative = (file) => path.relative(project.projectDir, file);
+        const skippedRelative = skipped.map((s) => ({ path: relative(s.path), reason: s.reason }));
+        if (targets.length === 0) {
+            const details = skippedRelative.map((s) => `${s.path}: ${s.reason}`).join(" / ");
+            throw new ScanToolError(skipped.every((s) => s.kind === "outside_allowed_root") ? "path_outside_allowed_root" : "no_manifest_found", `スキャンできるマニフェストがありません(${details})`);
+        }
+        const originals = new Map(targets.map((copy, i) => [copy.path, scanned[i].path]));
+        const report = await runOsvScan(targets, options);
+        return {
+            manifests: scanned.map((t) => relative(t.path)),
+            skipped: skippedRelative,
+            report: { ...report, source_files: report.source_files.map((file) => originals.get(file) ?? file) },
+        };
+    }
+    finally {
+        await snapshot.cleanup();
+    }
+}
 export async function handleScanJavaProject(args, options = {}) {
     try {
         const project = await detectJavaProject(args.project_path, {
             allowedRoot: options.allowedRoot,
         });
         const noRemoteResolution = isRemoteResolutionDisabled(options);
-        const report = await runOsvScan(project.targets, { ...options, noRemoteResolution });
+        const { manifests, skipped, report } = await scanJavaManifests(project, { ...options, noRemoteResolution });
         return jsonResult({
             project_dir: project.projectDir,
-            manifests: project.manifests,
-            ...skippedManifestsFields(project.skipped),
+            manifests,
+            ...skippedManifestsFields(skipped),
             dependency_resolution: dependencyResolution(noRemoteResolution),
             ...report,
         });

package/dist/tools/scanProject.js

@@ -4,14 +4,14 @@
  * 誤要約対策(JAR実体スキャンと同じ原則): スキャンできなかった依存を示すcoverageを件数より前に置き、
  * complete=falseの場合は「検出0件でも安全とは言えない」旨の警告を付ける。
  */
-import { mkdtemp, realpath, rm, writeFile } from "node:fs/promises";
-import os from "node:os";
 import path from "node:path";
+import { ScanToolError } from "../errors.js";
 import { isRemoteResolutionDisabled, runOsvScan } from "../osv/runner.js";
 import { parseOsvScanOutput } from "../osv/scanReport.js";
 import { sanitizeExternalText } from "../utils/externalText.js";
 import { detectProject } from "../utils/manifestDetector.js";
 import { normalizePypiName } from "../utils/requirementsFile.js";
+import { ScanSnapshot, snapshotManifests } from "../utils/scanSnapshot.js";
 import { dependencyResolution } from "./scanJavaProject.js";
 import { errorResult, jsonResult } from "./toolResult.js";
 const TRANSITIVE_OMITTED_WARNING = "OSV_MCP_NO_REMOTE_RESOLUTIONの設定により、マニフェスト(pom.xml / requirements.txt)からの推移的依存の解決を省略しています。" +
@@ -88,30 +88,44 @@ function markLowerBounds(project, packages) {
  * requirements.txtは検証済みの正規化行だけを専用の一時ディレクトリに書いてスキャンする
  * (元ファイルの取り込み指定をosv-scannerにたどらせない)。成功・失敗とも削除する。
  */
-async function scanWithRequirementsCopies(project, options) {
-    const copies = project.requirementsCopies.filter((copy) => copy.entries.length > 0);
-    if (project.targets.length === 0 && copies.length === 0)
-        return parseOsvScanOutput({ results: [] });
-    const dir = copies.length > 0 ? await mkdtemp(path.join(await realpath(os.tmpdir()), "osv-mcp-req-")) : null;
+/**
+ * 元のファイルはosv-scannerに渡さず、スナップショット(scanSnapshot.ts)のコピーをスキャンする。
+ * lockfile・pom.xml(親POMの連鎖を含む)は安全に読んだ内容のコピー、requirements.txtは
+ * 検証済みの正規化行だけを書いたコピー。コピーできず外したファイルはskippedFilesに記録する。
+ */
+async function scanFromSnapshot(project, options) {
+    const snapshot = await ScanSnapshot.create();
     try {
-        const targets = [...project.targets];
-        for (const [index, copy] of copies.entries()) {
-            const copyPath = path.join(dir, `${index}.txt`);
-            await writeFile(copyPath, `${copy.entries.join("\n")}\n`, { mode: 0o600, flag: "wx" });
-            targets.push({ path: copyPath, format: "requirements.txt" });
+        const { targets, skipped } = await snapshotManifests(snapshot, project.targets, {
+            projectDir: project.projectDir,
+            allowedRootReal: project.allowedRootReal,
+        });
+        if (skipped.length > 0) {
+            const skippedPaths = new Set(skipped.map((s) => s.path));
+            project.manifests = project.manifests.filter((m) => !skippedPaths.has(path.join(project.projectDir, m.path)));
+            project.skippedFiles.push(...skipped.map((s) => ({ path: path.relative(project.projectDir, s.path), reason: s.reason })));
+            if (project.manifests.length === 0) {
+                throw new ScanToolError(skipped.every((s) => s.kind === "outside_allowed_root") ? "path_outside_allowed_root" : "no_manifest_found", `スキャンできるlockfile・マニフェストがありません(${project.skippedFiles.map((s) => `${s.path}: ${s.reason}`).join(" / ")})`);
+            }
+        }
+        for (const copy of project.requirementsCopies) {
+            if (copy.entries.length === 0)
+                continue;
+            targets.push({ path: await snapshot.writeGenerated(`${copy.entries.join("\n")}\n`), format: "requirements.txt" });
         }
+        if (targets.length === 0)
+            return parseOsvScanOutput({ results: [] });
         return await runOsvScan(targets, options);
     }
     finally {
-        if (dir !== null)
-            await rm(dir, { recursive: true, force: true });
+        await snapshot.cleanup();
     }
 }
 export async function handleScanProject(args, options = {}) {
     try {
         const project = await detectProject(args.project_path, { allowedRoot: options.allowedRoot });
         const noRemoteResolution = isRemoteResolutionDisabled(options);
-        const report = await scanWithRequirementsCopies(project, { ...options, noRemoteResolution });
+        const report = await scanFromSnapshot(project, { ...options, noRemoteResolution });
         return jsonResult({
             project_dir: project.projectDir,
             dependency_resolution: dependencyResolution(noRemoteResolution, TRANSITIVE_OMITTED_WARNING),

package/dist/tools/suggestFix.js

@@ -3,10 +3,10 @@
  * scan_java_projectと同じスキャンを実行し、脆弱なパッケージごとの
  * 推奨アップグレードバージョン(3段階Tier)を返す。
  */
-import { isRemoteResolutionDisabled, runOsvScan } from "../osv/runner.js";
+import { isRemoteResolutionDisabled } from "../osv/runner.js";
 import { suggestUpgrades } from "../osv/suggestFix.js";
 import { detectJavaProject } from "../utils/projectDetector.js";
-import { dependencyResolution, skippedManifestsFields, } from "./scanJavaProject.js";
+import { dependencyResolution, scanJavaManifests, skippedManifestsFields, } from "./scanJavaProject.js";
 import { errorResult, jsonResult } from "./toolResult.js";
 export async function handleSuggestFix(args, options = {}) {
     try {
@@ -14,13 +14,13 @@ export async function handleSuggestFix(args, options = {}) {
             allowedRoot: options.allowedRoot,
         });
         const noRemoteResolution = isRemoteResolutionDisabled(options);
-        const report = await runOsvScan(project.targets, { ...options, noRemoteResolution });
+        const { manifests, skipped, report } = await scanJavaManifests(project, { ...options, noRemoteResolution });
         const suggestions = suggestUpgrades(report.packages);
         const unfixedVulnerabilities = suggestions.reduce((sum, s) => sum + s.per_cve_detail.filter((d) => d.tier === "unfixed").length, 0);
         return jsonResult({
             project_dir: project.projectDir,
-            manifests: project.manifests,
-            ...skippedManifestsFields(project.skipped),
+            manifests,
+            ...skippedManifestsFields(skipped),
             dependency_resolution: dependencyResolution(noRemoteResolution),
             vulnerable_package_count: suggestions.length,
             unfixed_vulnerability_count: unfixedVulnerabilities,

package/dist/utils/manifestDetector.js

@@ -7,12 +7,12 @@
  *
  * 検出・除外の根拠はdocs/DESIGN_TODO.md「対象エコシステム拡大 詳細設計メモ」を参照。
  */
-import { readFile, stat } from "node:fs/promises";
+import { stat } from "node:fs/promises";
 import path from "node:path";
 import { ScanToolError } from "../errors.js";
-import { pomParentOutsideRoot } from "./pomParent.js";
 import { assertInsideAllowedRoot, resolveExistingPath, walkProjectFiles, } from "./projectWalk.js";
-import { analyzeRequirementsFile, } from "./requirementsFile.js";
+import { readRegularFile } from "./safeRead.js";
+import { analyzeRequirementsFile, createRequirementsReadContext, } from "./requirementsFile.js";
 /** ファイル名→(エコシステム, 解析形式)。npm-shrinkwrap.jsonはpackage-lock.json形式で解析する */
 const LOCKFILES = new Map([
     ["pom.xml", { ecosystem: "Maven", format: "pom.xml" }],
@@ -73,26 +73,54 @@ function satisfiesGroup(manifest, group) {
 function isSameOrDescendant(dir, ancestor) {
     return ancestor === "." || dir === ancestor || dir.startsWith(`${ancestor}${path.sep}`);
 }
-/** workspaceの収録確認で読むlockfileの上限 */
+/** workspaceの収録確認で読むlockfile1件の上限と、1回の検出での合計の上限 */
 const MAX_LOCKFILE_BYTES = 64 * 1024 * 1024;
+const MAX_LOCKFILE_TOTAL_BYTES = 256 * 1024 * 1024;
+/**
+ * workspaceの収録確認用に、package-lock.jsonの`packages`のキー一覧を1回だけ読む。
+ * package.jsonの数だけ同じlockfileを解析し直すと、巨大なlockfileで負荷が増大するため、
+ * lockfileごとに結果を使い回し、読む量の合計にも上限を設ける。
+ */
+export class LockfileKeyCache {
+    keys = new Map();
+    remaining;
+    constructor(maxTotalBytes = MAX_LOCKFILE_TOTAL_BYTES) {
+        this.remaining = maxTotalBytes;
+    }
+    /** 収録済みのキー。null=確認できない(v1形式・読めない・大きすぎる・上限超過) */
+    async get(lockAbs, projectDir) {
+        if (this.keys.has(lockAbs))
+            return this.keys.get(lockAbs);
+        let keys = null;
+        if (this.remaining > 0) {
+            const read = await readRegularFile(lockAbs, { maxBytes: Math.min(MAX_LOCKFILE_BYTES, this.remaining), boundary: projectDir });
+            if (read.ok) {
+                this.remaining -= read.bytes.length;
+                try {
+                    const packages = JSON.parse(read.bytes.toString("utf8")).packages;
+                    if (typeof packages === "object" && packages !== null)
+                        keys = new Set(Object.keys(packages));
+                }
+                catch {
+                    keys = null;
+                }
+            }
+        }
+        this.keys.set(lockAbs, keys);
+        return keys;
+    }
+}
 /**
  * package-lock.json(v2以降)の`packages`に、memberDirのエントリがあるか。
- * true=収録 / false=未収録 / null=確認できない(v1形式・読めない・大きすぎる)
+ * true=収録 / false=未収録 / null=確認できない
  */
-async function npmLockfileRecords(projectDir, lockfile, memberDir) {
+async function npmLockfileRecords(cache, projectDir, lockfile, memberDir) {
     const lockAbs = path.join(projectDir, lockfile.path);
-    try {
-        if ((await stat(lockAbs)).size > MAX_LOCKFILE_BYTES)
-            return null;
-        const packages = JSON.parse(await readFile(lockAbs, "utf8")).packages;
-        if (typeof packages !== "object" || packages === null)
-            return null;
-        const key = path.relative(path.dirname(lockAbs), path.join(projectDir, memberDir)).split(path.sep).join("/");
-        return Object.hasOwn(packages, key);
-    }
-    catch {
+    const keys = await cache.get(lockAbs, projectDir);
+    if (keys === null)
         return null;
-    }
+    const key = path.relative(path.dirname(lockAbs), path.join(projectDir, memberDir)).split(path.sep).join("/");
+    return keys.has(key);
 }
 /**
  * lockfileの無いマーカー(package.json等)を判定する。
@@ -101,6 +129,7 @@ async function npmLockfileRecords(projectDir, lockfile, memberDir) {
  *   workspace設定の無いルートのlockfileで、独立した子プロジェクトの欠落を隠さないため
  */
 async function findLockfileMissing(projectDir, markers, manifests) {
+    const cache = new LockfileKeyCache();
     const missing = [];
     for (const marker of markers) {
         const markerDir = path.dirname(marker.path);
@@ -116,7 +145,7 @@ async function findLockfileMissing(projectDir, markers, manifests) {
         let recorded = false;
         for (const candidate of candidates) {
             const result = candidate.format === "package-lock.json"
-                ? await npmLockfileRecords(projectDir, candidate, markerDir)
+                ? await npmLockfileRecords(cache, projectDir, candidate, markerDir)
                 : null;
             if (result === true)
                 recorded = true;
@@ -139,6 +168,7 @@ async function findLockfileMissing(projectDir, markers, manifests) {
 async function finalize(projectDir, manifests, markers, allowedRootReal) {
     const result = {
         projectDir,
+        allowedRootReal,
         manifests: [],
         targets: [],
         requirementsCopies: [],
@@ -148,10 +178,11 @@ async function finalize(projectDir, manifests, markers, allowedRootReal) {
         lowerBounds: [],
         skippedFiles: [],
     };
+    const readContext = createRequirementsReadContext();
     for (const manifest of manifests) {
         const absolute = path.join(projectDir, manifest.path);
         if (manifest.format === "requirements.txt") {
-            const analysis = await analyzeRequirementsFile(absolute, projectDir);
+            const analysis = await analyzeRequirementsFile(absolute, projectDir, readContext);
             if (!analysis.ok) {
                 result.skippedFiles.push({ path: manifest.path, reason: analysis.reason });
                 continue;
@@ -162,11 +193,6 @@ async function finalize(projectDir, manifests, markers, allowedRootReal) {
             result.requirementsCopies.push({ path: manifest.path, entries: analysis.entries });
         }
         else {
-            const outside = manifest.format === "pom.xml" ? await pomParentOutsideRoot(absolute, allowedRootReal) : null;
-            if (outside !== null) {
-                result.skippedFiles.push({ path: manifest.path, reason: outside });
-                continue;
-            }
             result.targets.push({ path: absolute, format: manifest.format });
         }
         result.manifests.push(manifest);

package/dist/utils/pomParent.js

@@ -1,21 +1,15 @@
 /**
- * pom.xmlの親POM(`<parent><relativePath>`)が、スキャン許可ルート(OSV_MCP_ALLOWED_ROOT)の外を
- * 参照していないかを検証する。
+ * pom.xmlの親POM(`<parent><relativePath>`)の参照の解釈。連鎖のコピーと検証はscanSnapshot.tsが行う。
  *
  * osv-scanner v2.4.0の実機確認(2026-10-07):
  * - `<relativePath>`の指す親POMを読み、その依存を結果に含める(`--no-resolve`でも同じ)。親の親もたどる
  * - `<relativePath>`省略時はMavenの既定値`../pom.xml`を参照する。ディレクトリを指す場合はその中のpom.xml
  * - `<relativePath/>`(空)はローカルを参照しない。親のGAVが一致しない場合も読まない
  *
- * サブモジュールのスキャンで親POMを読むのは正当な動作のため、境界はプロジェクトディレクトリではなく
- * 許可ルートとする(未設定時は任意のパスをスキャンできる状態のため検証しない)。GAVの一致は判定が
- * 複雑(親から引き継がれる)なため確認せず、許可ルートの外に参照先のファイルがあれば安全側に除外する。
+ * スナップショット方式では、osv-scannerが読めるのはコピーしたファイルだけのため、ここでの解釈が
+ * osv-scannerとずれても範囲外は読まれない(最悪でも親が見つからない)。解釈できない場合の除外は、
+ * 親から引き継ぐ依存を黙って欠落させないためのもの。
  */
-import { readFile, realpath, stat } from "node:fs/promises";
-import path from "node:path";
-import { isInsideDir } from "./projectWalk.js";
-const MAX_POM_BYTES = 10 * 1024 * 1024;
-const MAX_PARENT_DEPTH = 10;
 const DEFAULT_RELATIVE_PATH = "../pom.xml";
 const NAMED_ENTITIES = { lt: "<", gt: ">", amp: "&", apos: "'", quot: '"' };
 /** XMLの文字参照・定義済み実体参照を展開する。未知の実体はundefined */
@@ -144,7 +138,7 @@ export function parentRelativePath(source) {
     return trimmed;
 }
 /** UTF-8として厳密に読む。不正なバイト列・NULを含む場合はnull(Goと同じ解釈を保証できない) */
-function decodePomBytes(bytes) {
+export function decodePomBytes(bytes) {
     let text;
     try {
         text = new TextDecoder("utf-8", { fatal: true, ignoreBOM: false }).decode(bytes);
@@ -154,53 +148,3 @@ function decodePomBytes(bytes) {
     }
     return text.includes("\u0000") ? null : text;
 }
-/** 参照先を実ファイルに解決する。存在しなければnull(osv-scannerもローカルからは読まない) */
-async function resolveParentFile(fromPom, relativePath) {
-    let candidate = path.resolve(path.dirname(fromPom), relativePath);
-    try {
-        if ((await stat(candidate)).isDirectory())
-            candidate = path.join(candidate, "pom.xml");
-        return await realpath(candidate);
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * 親POMの連鎖が許可ルートの外を参照していれば、除外理由を返す。問題なければnull。
- * @param pomPath 検出済みのpom.xmlの絶対パス
- * @param allowedRootReal 解決済みの許可ルート。未設定なら検証しない
- */
-export async function pomParentOutsideRoot(pomPath, allowedRootReal) {
-    if (allowedRootReal === undefined)
-        return null;
-    let current = pomPath;
-    for (let depth = 0; depth < MAX_PARENT_DEPTH; depth++) {
-        let bytes;
-        try {
-            if ((await stat(current)).size > MAX_POM_BYTES)
-                return `親POMの確認でサイズ上限を超えるpom.xmlがあります(${path.basename(current)})`;
-            bytes = await readFile(current);
-        }
-        catch {
-            return null; // 読めないファイルはosv-scannerも読めない
-        }
-        const xml = decodePomBytes(bytes);
-        const relativePath = xml === null ? undefined : parentRelativePath(xml);
-        if (relativePath === null || relativePath === "")
-            return null;
-        if (relativePath === undefined) {
-            return ("親POMの指定を確実に解釈できないため(親要素の重複、CDATA・DOCTYPE、プロパティ参照、UTF-8以外の文字コード等)、" +
-                "許可ルート内か確認できずスキャン対象から外しました");
-        }
-        const parentFile = await resolveParentFile(current, relativePath);
-        if (parentFile === null)
-            return null;
-        if (!isInsideDir(allowedRootReal, parentFile)) {
-            return (`親POM(relativePath: ${relativePath})が許可ルート(OSV_MCP_ALLOWED_ROOT)の外を参照しているため、スキャン対象から外しました` +
-                "(親のGAVが一致しなければosv-scannerは読みませんが、境界の外のため確認せず除外します)");
-        }
-        current = parentFile;
-    }
-    return `親POMの連鎖が上限(${MAX_PARENT_DEPTH}段)を超えています`;
-}

package/dist/utils/projectDetector.js

@@ -18,7 +18,6 @@
 import { stat } from "node:fs/promises";
 import path from "node:path";
 import { ScanToolError } from "../errors.js";
-import { pomParentOutsideRoot } from "./pomParent.js";
 import { assertInsideAllowedRoot, resolveExistingPath, walkProjectFiles, } from "./projectWalk.js";
 /** ビルド成果物・VCS等、マニフェスト探索でスキップするディレクトリ */
 const SKIPPED_DIRS = new Set([".git", "node_modules", "target", "build", ".idea", ".vscode"]);
@@ -39,27 +38,12 @@ const GRADLE_LOCKFILE_GUIDANCE = "Gradleプロジェクトを検出しました
     "本ツールはlockfile方式のみ対応しています(ビルド実行方式はbuild.gradleの任意コード実行を伴うため非対応)。" +
     "`./gradlew dependencies --write-locks` でlockfileを生成してから再実行してください" +
     "(依存ロックが未設定の場合は build.gradle に dependencyLocking { lockAllConfigurations() } の追加が必要です)";
-/** 親POMが許可ルートの外を参照するpom.xmlを除外して結果を組み立てる。全件除外ならエラー */
-async function buildResult(projectDir, detected, allowedRootReal) {
-    const manifests = [];
-    const skipped = [];
-    for (const manifest of detected) {
-        const reason = path.basename(manifest) === "pom.xml"
-            ? await pomParentOutsideRoot(path.join(projectDir, manifest), allowedRootReal)
-            : null;
-        if (reason !== null)
-            skipped.push({ path: manifest, reason });
-        else
-            manifests.push(manifest);
-    }
-    if (manifests.length === 0) {
-        throw new ScanToolError("path_outside_allowed_root", `スキャンできるマニフェストがありません(${skipped.map((s) => `${s.path}: ${s.reason}`).join(" / ")})`);
-    }
+function buildResult(projectDir, manifests, allowedRootReal) {
     const targets = manifests.map((manifest) => ({
         path: path.join(projectDir, manifest),
         format: path.basename(manifest),
     }));
-    return { projectDir, manifests, targets, skipped };
+    return { projectDir, manifests, targets, allowedRootReal };
 }
 /**
  * 入力パスを検証し、スキャン対象のJavaプロジェクトとして解決する。

package/dist/utils/requirementsFile.js

@@ -16,9 +16,10 @@
  * 外・存在しない・URL・上限超過の取り込み、制約ファイル(`-c`)、解釈できない行は、
  * スキャンされない参照として報告する(黙って無視しない)。
  */
-import { readFile, realpath, stat } from "node:fs/promises";
+import { realpath } from "node:fs/promises";
 import path from "node:path";
 import { isInsideDir } from "./projectWalk.js";
+import { readRegularFile } from "./safeRead.js";
 const MAX_FILE_BYTES = 1024 * 1024;
 const MAX_INCLUDE_DEPTH = 5;
 const MAX_FILES = 50;
@@ -109,7 +110,7 @@ function classifyRequirement(file, line, content, out) {
     }
     out.issues.push({ file, line, name, specifier, kind: "range" });
 }
-async function include(file, line, content, target, projectDir, depth, out) {
+async function include(file, line, content, target, projectDir, depth, out, context) {
     const reference = (reason) => {
         out.references.push({ file, line, text: content, reason });
     };
@@ -133,7 +134,7 @@ async function include(file, line, content, target, projectDir, depth, out) {
         return reference(`取り込みファイルが上限(${MAX_FILES}件)を超えています`);
     let failure;
     try {
-        failure = await analyze(resolved, projectDir, depth + 1, out);
+        failure = await analyze(resolved, projectDir, depth + 1, out, context);
     }
     catch {
         failure = "取り込み先を読み込めません";
@@ -141,19 +142,47 @@ async function include(file, line, content, target, projectDir, depth, out) {
     if (failure !== null)
         reference(failure);
 }
+/** 1回のスキャンで読むrequirements.txt(取り込み先を含む)の合計の上限 */
+const DEFAULT_TOTAL_BYTES = 64 * 1024 * 1024;
+export function createRequirementsReadContext(maxTotalBytes = DEFAULT_TOTAL_BYTES) {
+    return { remainingBytes: maxTotalBytes, texts: new Map() };
+}
+/** 安全に読む(FIFOで止まらず、差し替え・範囲外を検出する)。同じファイルは1回だけ読む */
+async function readText(file, projectDir, context) {
+    const cached = context.texts.get(file);
+    if (cached !== undefined)
+        return { ok: true, text: cached };
+    const budgetLimited = context.remainingBytes < MAX_FILE_BYTES;
+    const result = await readRegularFile(file, {
+        maxBytes: Math.min(MAX_FILE_BYTES, context.remainingBytes),
+        boundary: projectDir,
+    });
+    if (!result.ok) {
+        if (result.failure === "too_large") {
+            return {
+                ok: false,
+                reason: budgetLimited
+                    ? "requirements.txtの解析量の合計が上限を超えたため読みませんでした"
+                    : `サイズが上限(${MAX_FILE_BYTES}バイト)を超えています`,
+            };
+        }
+        return { ok: false, reason: result.message };
+    }
+    context.remainingBytes -= result.bytes.length;
+    const text = result.bytes.toString("utf8");
+    context.texts.set(file, text);
+    return { ok: true, text };
+}
 /** ファイルを解析してoutに追加する。読めない・大きすぎる場合は理由を返す */
-async function analyze(file, projectDir, depth, out) {
+async function analyze(file, projectDir, depth, out, context) {
     out.visited.add(file);
-    const info = await stat(file);
-    if (!info.isFile())
-        return "通常ファイルではありません";
-    if (info.size > MAX_FILE_BYTES)
-        return `サイズが上限(${MAX_FILE_BYTES}バイト)を超えています`;
-    const text = await readFile(file, "utf8");
-    for (const { line, content } of logicalLines(text)) {
+    const read = await readText(file, projectDir, context);
+    if (!read.ok)
+        return read.reason;
+    for (const { line, content } of logicalLines(read.text)) {
         const requirementInclude = INCLUDE_REQUIREMENT.exec(content);
         if (requirementInclude) {
-            await include(file, line, content, requirementInclude[1], projectDir, depth, out);
+            await include(file, line, content, requirementInclude[1], projectDir, depth, out, context);
             continue;
         }
         if (INCLUDE_CONSTRAINT.test(content)) {
@@ -179,11 +208,11 @@ async function analyze(file, projectDir, depth, out) {
  * @param file 検出済みの絶対パス
  * @param projectDir 取り込みを展開する範囲(解決済みの絶対パス)
  */
-export async function analyzeRequirementsFile(file, projectDir) {
+export async function analyzeRequirementsFile(file, projectDir, context = createRequirementsReadContext()) {
     const out = { entries: [], issues: [], references: [], lowerBounds: [], visited: new Set() };
     let reason;
     try {
-        reason = await analyze(await realpath(file), projectDir, 0, out);
+        reason = await analyze(await realpath(file), projectDir, 0, out, context);
     }
     catch {
         reason = "読み込めません";

package/dist/utils/safeRead.js

@@ -0,0 +1,144 @@
+/**
+ * スキャン対象ファイルの安全な読み込み(検査と読み込みの不一致を起こさないための共通部品)。
+ *
+ * - `O_NOFOLLOW`で開き、末尾がシンボリックリンクに差し替えられたファイルを読まない
+ * - `O_NONBLOCK`で開き、名前付きパイプ(FIFO)等で処理が止まらないようにする。開いた実体を
+ *   `fstat`し、通常のファイル以外は読まない
+ * - サイズの上限付きで読む
+ * - 読み終えた後、パスを解決し直して境界の内側にあることと、開いた実体と同じファイル
+ *   (デバイス番号・inodeが一致)であることを確認する。途中のディレクトリをシンボリックリンクに
+ *   差し替えて範囲外を読ませ、確認前に戻す、といった差し替えを検出する
+ *
+ * 呼び出し側は読んだ内容(またはそのコピー)だけを使い、元のパスを他のプロセスに渡さない。
+ * (ハードリンクはパスとしては境界の内側にあるため区別しない)
+ */
+import { constants } from "node:fs";
+import { open, realpath, rm, stat } from "node:fs/promises";
+import { isInsideDir } from "./projectWalk.js";
+const OPEN_FLAGS = constants.O_RDONLY | (constants.O_NONBLOCK ?? 0) | (constants.O_NOFOLLOW ?? 0);
+const MESSAGES = {
+    not_found: "ファイルを開けません",
+    not_regular: "通常のファイルではありません(名前付きパイプ・デバイス等)",
+    too_large: "サイズが上限を超えています",
+    outside: "スキャン範囲の外のファイルです",
+    changed: "検査中にファイルが差し替えられました",
+};
+function failure(kind) {
+    return { ok: false, failure: kind, message: MESSAGES[kind] };
+}
+/**
+ * 読み終えた後の確認: パスを解決し直し、境界の内側で、開いた実体と同じファイルか。
+ * 問題が無ければnull、あれば失敗の種類を返す。
+ */
+export async function verifyOpenedFile(filePath, opened, boundary) {
+    let resolved;
+    let current;
+    try {
+        resolved = await realpath(filePath);
+        current = await stat(resolved);
+    }
+    catch {
+        return "changed";
+    }
+    if (current.dev !== opened.dev || current.ino !== opened.ino)
+        return "changed";
+    if (boundary !== undefined && !isInsideDir(boundary, resolved))
+        return "outside";
+    return null;
+}
+/**
+ * 通常のファイルを上限付きで安全にdestへコピーする(大きなJAR/WAR向けに全体をメモリに載せない)。
+ * destは新規作成(既存なら失敗)・所有者のみ読み書き可。失敗時はdestを削除する。
+ * 成功時はコピーしたバイト数を返す。
+ */
+export async function copyRegularFile(filePath, dest, options) {
+    let source;
+    try {
+        source = await open(filePath, OPEN_FLAGS);
+    }
+    catch {
+        return failure("not_found");
+    }
+    let total = 0;
+    let result = null;
+    try {
+        const info = await source.stat();
+        if (!info.isFile())
+            result = "not_regular";
+        else if (info.size > options.maxBytes)
+            result = "too_large";
+        else {
+            const target = await open(dest, "wx", 0o600);
+            try {
+                const chunk = Buffer.alloc(1024 * 1024);
+                while (true) {
+                    const { bytesRead } = await source.read(chunk, 0, chunk.length, null);
+                    if (bytesRead === 0)
+                        break;
+                    total += bytesRead;
+                    if (total > options.maxBytes) {
+                        result = "too_large";
+                        break;
+                    }
+                    await target.write(chunk, 0, bytesRead);
+                }
+            }
+            finally {
+                await target.close();
+            }
+            if (result === null)
+                result = await verifyOpenedFile(filePath, info, options.boundary);
+        }
+    }
+    catch {
+        result = "not_found";
+    }
+    finally {
+        await source.close();
+    }
+    if (result !== null) {
+        await rm(dest, { force: true });
+        return failure(result);
+    }
+    return { ok: true, bytes: total };
+}
+/** 通常のファイルを上限付きで安全に読む */
+export async function readRegularFile(filePath, options) {
+    let handle;
+    try {
+        handle = await open(filePath, OPEN_FLAGS);
+    }
+    catch {
+        return failure("not_found");
+    }
+    let info;
+    const chunks = [];
+    let total = 0;
+    try {
+        info = await handle.stat();
+        if (!info.isFile())
+            return failure("not_regular");
+        if (info.size > options.maxBytes)
+            return failure("too_large");
+        const chunk = Buffer.alloc(Math.min(1024 * 1024, options.maxBytes + 1));
+        while (true) {
+            const { bytesRead } = await handle.read(chunk, 0, Math.min(chunk.length, options.maxBytes - total + 1), null);
+            if (bytesRead === 0)
+                break;
+            total += bytesRead;
+            if (total > options.maxBytes)
+                return failure("too_large");
+            chunks.push(Buffer.from(chunk.subarray(0, bytesRead)));
+        }
+    }
+    catch {
+        return failure("not_found");
+    }
+    finally {
+        await handle.close();
+    }
+    const problem = await verifyOpenedFile(filePath, info, options.boundary);
+    if (problem !== null)
+        return failure(problem);
+    return { ok: true, bytes: Buffer.concat(chunks, total) };
+}

package/dist/utils/sbomInput.js

@@ -3,6 +3,7 @@ import { constants } from "node:fs";
 import { open, realpath } from "node:fs/promises";
 import path from "node:path";
 import { ScanToolError } from "../errors.js";
+import { verifyOpenedFile } from "./safeRead.js";
 import { asRecord } from "./unknownJson.js";
 const DEFAULT_MAX_INPUT_BYTES = 16 * 1024 * 1024;
 const CYCLONEDX_VERSIONS = new Set(["1.4", "1.5", "1.6"]);
@@ -33,8 +34,9 @@ export async function loadSbom(inputPath, options = {}) {
     try {
         // Nonblocking open avoids hanging on FIFOs. Refuse a leaf replaced by a symlink.
         const file = await open(sourcePath, constants.O_RDONLY | constants.O_NONBLOCK | (constants.O_NOFOLLOW ?? 0));
+        let info;
         try {
-            const info = await file.stat();
+            info = await file.stat();
             if (!info.isFile())
                 throw new ScanToolError("sbom_not_found", "SBOM input must be a regular file");
             if (info.size > maxBytes)
@@ -56,6 +58,13 @@ export async function loadSbom(inputPath, options = {}) {
         finally {
             await file.close();
         }
+        // 読んだ後に、差し替え(途中のディレクトリのシンボリックリンク化等)と境界を確認する
+        const allowedRootReal = options.allowedRoot !== undefined ? await realpath(options.allowedRoot) : undefined;
+        const problem = await verifyOpenedFile(sourcePath, info, allowedRootReal);
+        if (problem === "outside")
+            throw new ScanToolError("path_outside_allowed_root", "SBOM path is outside the allowed root");
+        if (problem !== null)
+            throw new ScanToolError("sbom_not_found", "The SBOM file was replaced while it was being read");
     }
     catch (error) {
         if (error instanceof ScanToolError)

package/dist/utils/scanSnapshot.js

@@ -0,0 +1,164 @@
+/**
+ * スキャン対象のスナップショット: osv-scannerには元のファイルを渡さず、安全に1回だけ読んだ内容を
+ * 専用の一時ディレクトリ(所有者のみアクセス可、終了時に削除)へコピーしてスキャンする。
+ *
+ * - 検査(境界・親POMの検証)はコピーの内容に対して行うため、検査とosv-scannerの読み込みの間に
+ *   元のファイルを差し替えても結果に影響しない
+ * - 親POMは元の配置をスナップショット内に再現してコピーする。osv-scannerが相対パスで親をたどっても、
+ *   見つかるのは検証してコピーしたファイルだけになる(解析が多少ずれても範囲外は読まれず、
+ *   最悪でも親が見つからないだけ)
+ * - `..`を重ねた参照でスナップショットの外(本物のファイルシステム)に出る親POMは除外する
+ * - コピーの合計サイズに上限を設ける
+ */
+import { mkdir, mkdtemp, readFile, realpath, rm, stat, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { ScanToolError } from "../errors.js";
+import { decodePomBytes, parentRelativePath } from "./pomParent.js";
+import { isInsideDir } from "./projectWalk.js";
+import { copyRegularFile } from "./safeRead.js";
+const DEFAULT_MAX_TOTAL_BYTES = 2 * 1024 * 1024 * 1024;
+const MAX_POM_BYTES = 10 * 1024 * 1024;
+const MAX_PARENT_DEPTH = 10;
+export class ScanSnapshot {
+    dir;
+    maxTotalBytes;
+    copied = new Map();
+    parentCache = new Map();
+    used = 0;
+    generated = 0;
+    constructor(dir, maxTotalBytes) {
+        this.dir = dir;
+        this.maxTotalBytes = maxTotalBytes;
+    }
+    static async create(maxTotalBytes = DEFAULT_MAX_TOTAL_BYTES) {
+        const dir = await mkdtemp(path.join(await realpath(os.tmpdir()), "osv-mcp-snap-"));
+        return new ScanSnapshot(dir, maxTotalBytes);
+    }
+    /** 再現した配置のルート(実際のファイルシステムの"/"に相当) */
+    get treeRoot() {
+        return path.join(this.dir, "tree");
+    }
+    /** 元の絶対パスに対応する、スナップショット内のパス */
+    mirror(absolute) {
+        const { root } = path.parse(absolute);
+        return path.join(this.treeRoot, root.replace(/[^A-Za-z0-9]/g, "_"), path.relative(root, absolute));
+    }
+    /** 元のファイルを安全にコピーする。同じファイルは1回だけコピーする */
+    async copy(absolute, boundary, maxBytes = Infinity) {
+        const existing = this.copied.get(absolute);
+        if (existing !== undefined)
+            return { ok: true, path: existing };
+        const remaining = this.maxTotalBytes - this.used;
+        const dest = this.mirror(absolute);
+        await mkdir(path.dirname(dest), { recursive: true, mode: 0o700 });
+        const result = await copyRegularFile(absolute, dest, { maxBytes: Math.min(maxBytes, remaining), boundary });
+        if (!result.ok) {
+            if (result.failure === "too_large" && remaining < maxBytes) {
+                throw new ScanToolError("scan_input_too_large", `スキャン対象ファイルの合計サイズが上限(${this.maxTotalBytes}バイト)を超えるため、スキャンを中止しました。対象を絞って再実行してください`);
+            }
+            return result;
+        }
+        this.used += result.bytes;
+        this.copied.set(absolute, dest);
+        return { ok: true, path: dest };
+    }
+    /** 本サーバーが生成した内容(requirements.txtの正規化コピー等)を書く */
+    async writeGenerated(content) {
+        const dir = path.join(this.dir, "generated");
+        await mkdir(dir, { recursive: true, mode: 0o700 });
+        const file = path.join(dir, `${this.generated++}.txt`);
+        await writeFile(file, content, { mode: 0o600, flag: "wx" });
+        return file;
+    }
+    /** コピー済みのpom.xmlの親参照(同じファイルは1回だけ解析する) */
+    async parentOf(copyPath) {
+        if (this.parentCache.has(copyPath))
+            return this.parentCache.get(copyPath);
+        const xml = decodePomBytes(await readFile(copyPath));
+        const relativePath = xml === null ? undefined : parentRelativePath(xml);
+        this.parentCache.set(copyPath, relativePath);
+        return relativePath;
+    }
+    async cleanup() {
+        await rm(this.dir, { recursive: true, force: true });
+    }
+}
+const UNPARSEABLE = "親POMの指定を確実に解釈できないため(親要素の重複、CDATA・DOCTYPE、プロパティ参照、UTF-8以外の文字コード等)、" +
+    "許可ルート内か確認できずスキャン対象から外しました";
+/**
+ * pom.xmlと親POMの連鎖をスナップショットへコピーする。
+ * 許可ルート設定時、連鎖が許可ルートの外・スナップショットの外を参照するか、解釈できない場合は除外理由を返す。
+ */
+async function snapshotPom(snapshot, pomPath, context) {
+    const first = await snapshot.copy(pomPath, context.projectDir, MAX_POM_BYTES);
+    if (!first.ok)
+        return { ok: false, reason: first.message, kind: "unreadable" };
+    const restricted = context.allowedRootReal !== undefined;
+    let current = pomPath;
+    let currentCopy = first.path;
+    for (let depth = 0; depth < MAX_PARENT_DEPTH; depth++) {
+        const relativePath = await snapshot.parentOf(currentCopy);
+        if (relativePath === null || relativePath === "")
+            return first;
+        if (relativePath === undefined)
+            return restricted ? { ok: false, reason: UNPARSEABLE, kind: "unreadable" } : first;
+        // Goのfilepath.Joinと同じ規則で結合する(絶対パスも連結し、..はルートで止まる)
+        const inCopy = path.join(path.dirname(currentCopy), relativePath);
+        if (!isInsideDir(snapshot.treeRoot, inCopy)) {
+            // ..を重ねるとスナップショットの外(本物のファイルシステム)に届くため、コピーではなく元のファイルが読まれる
+            return restricted
+                ? { ok: false, reason: `親POM(relativePath: ${relativePath})の参照がスキャン範囲の外に出るため、スキャン対象から外しました`, kind: "outside_allowed_root" }
+                : first;
+        }
+        let candidate = path.join(path.dirname(current), relativePath);
+        try {
+            if ((await stat(candidate)).isDirectory())
+                candidate = path.join(candidate, "pom.xml");
+        }
+        catch {
+            return first; // 参照先が無い: スナップショット内にも無いため、osv-scannerは親を読まない
+        }
+        const parent = await snapshot.copy(candidate, context.allowedRootReal, MAX_POM_BYTES);
+        if (!parent.ok) {
+            if (parent.failure === "outside") {
+                return {
+                    ok: false,
+                    reason: `親POM(relativePath: ${relativePath})が許可ルート(OSV_MCP_ALLOWED_ROOT)の外を参照しているため、スキャン対象から外しました` +
+                        "(親のGAVが一致しなければosv-scannerは読みませんが、境界の外のため確認せず除外します)",
+                    kind: "outside_allowed_root",
+                };
+            }
+            if (parent.failure === "changed")
+                return { ok: false, reason: `親POMの${parent.message}`, kind: "unreadable" };
+            return first; // 読めない・通常のファイルでない等: コピーしないため、osv-scannerも読まない
+        }
+        current = candidate;
+        currentCopy = parent.path;
+    }
+    return restricted ? { ok: false, reason: `親POMの連鎖が上限(${MAX_PARENT_DEPTH}段)を超えています`, kind: "unreadable" } : first;
+}
+/**
+ * 検出済みのマニフェストをスナップショットへコピーし、osv-scannerに渡す対象(コピー)を返す。
+ * コピーできない・除外すべきものはskippedに理由付きで返す。
+ */
+export async function snapshotManifests(snapshot, targets, context) {
+    const copies = [];
+    const skipped = [];
+    for (const target of targets) {
+        if (target.format === "pom.xml") {
+            const result = await snapshotPom(snapshot, target.path, context);
+            if (result.ok)
+                copies.push({ path: result.path, format: target.format });
+            else
+                skipped.push({ path: target.path, reason: result.reason, kind: result.kind });
+            continue;
+        }
+        const result = await snapshot.copy(target.path, context.projectDir);
+        if (result.ok)
+            copies.push({ path: result.path, format: target.format });
+        else
+            skipped.push({ path: target.path, reason: result.message, kind: "unreadable" });
+    }
+    return { targets: copies, skipped };
+}

package/dist/utils/startupConfig.js

@@ -14,14 +14,22 @@ function isTruthy(value) {
     const normalized = value.trim().toLowerCase();
     return normalized === "1" || normalized === "true" || normalized === "yes";
 }
+/**
+ * 許可ルートの設定値。空文字・空白のみは未設定(undefined)として扱う。
+ * 起動時の検証とツールへの受け渡しで判定がずれないよう、必ずこの関数で読む
+ * (空文字をそのまま渡すと`path.resolve("")`=起動ディレクトリが許可ルートになっていた)。
+ */
+export function allowedRootFromEnv(env = process.env) {
+    const allowedRoot = env[ALLOWED_ROOT_ENV];
+    return allowedRoot !== undefined && allowedRoot.trim() !== "" ? allowedRoot : undefined;
+}
 /**
  * 起動を拒否すべき設定不備があればエラーメッセージを返す。問題なければnull。
  */
 export function allowedRootStartupError(env = process.env) {
     if (!isTruthy(env[REQUIRE_ALLOWED_ROOT_ENV]))
         return null;
-    const allowedRoot = env[ALLOWED_ROOT_ENV];
-    if (allowedRoot !== undefined && allowedRoot.trim() !== "")
+    if (allowedRootFromEnv(env) !== undefined)
         return null;
     return (`${REQUIRE_ALLOWED_ROOT_ENV}が有効ですが、${ALLOWED_ROOT_ENV}が未設定のため起動を中止します。` +
         `スキャンを許可するルートディレクトリを${ALLOWED_ROOT_ENV}に設定してください`);
@@ -31,8 +39,7 @@ export function allowedRootStartupError(env = process.env) {
  * (許可ルート未設定=任意の絶対パスをスキャン可能な状態の可視化)
  */
 export function allowedRootStartupWarning(env = process.env) {
-    const allowedRoot = env[ALLOWED_ROOT_ENV];
-    if (allowedRoot !== undefined && allowedRoot.trim() !== "")
+    if (allowedRootFromEnv(env) !== undefined)
         return null;
     return (`${ALLOWED_ROOT_ENV}が未設定のため、任意の絶対パスをスキャンできる状態です。` +
         `プロジェクト置き場のルートを${ALLOWED_ROOT_ENV}に設定することを推奨します` +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "osv-scanner-mcp",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "MCP server that wraps Google's OSV-Scanner to scan Java projects for known vulnerabilities",
   "type": "module",
   "license": "Apache-2.0",