osv-scanner-mcp 0.3.4 → 0.4.1

package/dist/utils/projectDetector.js

@@ -11,22 +11,22 @@
  * `project_path`はLLM・ユーザー由来の信頼できない入力として扱う:
  * - `realpath`で正規化し、シンボリックリンクを解決した実体パスで判定する
  * - `allowedRoot`指定時は、解決後のパスがその配下にあることを検証する(パストラバーサル対策)
- * - マニフェスト探索はエントリ数・件数・深さに上限を設け、シンボリックリンクのディレクトリは辿らない
+ * - 走査は上限付きで、シンボリックリンクのディレクトリは辿らない(projectWalk.ts)
  *
  * 検出したマニフェストが、そのままOSV-Scannerのスキャン範囲になる(ディレクトリは渡さない)。
- * そのため探索を深さで打ち切らず(Javaのソースツリーは深い)、上限に達した場合は
- * 結果を黙って欠落させずにエラーにする。
  */
-import { readdir, realpath, stat } from "node:fs/promises";
+import { stat } from "node:fs/promises";
 import path from "node:path";
 import { ScanToolError } from "../errors.js";
-const DEFAULT_MAX_DEPTH = 64;
-const DEFAULT_MAX_ENTRIES = 200_000;
-const DEFAULT_MAX_MANIFESTS = 1_000;
+import { assertInsideAllowedRoot, resolveExistingPath, walkProjectFiles, } from "./projectWalk.js";
 /** ビルド成果物・VCS等、マニフェスト探索でスキップするディレクトリ */
 const SKIPPED_DIRS = new Set([".git", "node_modules", "target", "build", ".idea", ".vscode"]);
-/** OSV-Scannerがスキャンできるマニフェスト(実機確認済み) */
-const MANIFEST_FILENAMES = new Set(["pom.xml", "gradle.lockfile", "buildscript-gradle.lockfile"]);
+/** OSV-Scannerがスキャンできるマニフェスト(実機確認済み)。ファイル名がそのまま解析形式になる */
+const MANIFEST_FILENAMES = new Set([
+    "pom.xml",
+    "gradle.lockfile",
+    "buildscript-gradle.lockfile",
+]);
 /** Gradleプロジェクトの存在を示すが、それ自体はスキャンできないビルドファイル */
 const GRADLE_BUILD_FILENAMES = new Set([
     "build.gradle",
@@ -38,62 +38,12 @@ const GRADLE_LOCKFILE_GUIDANCE = "Gradleプロジェクトを検出しました
     "本ツールはlockfile方式のみ対応しています(ビルド実行方式はbuild.gradleの任意コード実行を伴うため非対応)。" +
     "`./gradlew dependencies --write-locks` でlockfileを生成してから再実行してください" +
     "(依存ロックが未設定の場合は build.gradle に dependencyLocking { lockAllConfigurations() } の追加が必要です)";
-async function resolveExistingPath(inputPath) {
-    try {
-        return await realpath(path.resolve(inputPath));
-    }
-    catch {
-        throw new ScanToolError("project_not_found", `指定されたパスが存在しません: ${inputPath}`);
-    }
-}
-function assertInsideAllowedRoot(resolvedDir, allowedRootReal) {
-    const relative = path.relative(allowedRootReal, resolvedDir);
-    if (relative.startsWith("..") || path.isAbsolute(relative)) {
-        throw new ScanToolError("path_outside_allowed_root", `指定されたパスは許可されたディレクトリ(${allowedRootReal})の外にあります`);
-    }
-}
-function searchLimitError(reason) {
-    return new ScanToolError("manifest_search_limit_exceeded", `マニフェスト探索が上限(${reason})に達したため、スキャンを中止しました。` +
-        "結果の欠落を避けるため途中までの結果は返しません。より狭いディレクトリ、またはpom.xml / gradle.lockfileを直接指定してください");
-}
-/** 上限付きでマニフェストを探索する。シンボリックリンクは辿らない。上限到達はエラー。 */
-async function findManifests(rootDir, limits) {
-    const manifests = [];
-    let gradleBuildFileFound = false;
-    let visited = 0;
-    let currentLevel = [rootDir];
-    for (let depth = 1; currentLevel.length > 0; depth++) {
-        if (depth > limits.maxDepth)
-            throw searchLimitError(`深さ${limits.maxDepth}`);
-        const nextLevel = [];
-        for (const dir of currentLevel) {
-            let entries;
-            try {
-                entries = await readdir(dir, { withFileTypes: true });
-            }
-            catch {
-                continue; // 読めないディレクトリはスキップ(権限不足等)
-            }
-            for (const entry of entries) {
-                if (++visited > limits.maxEntries)
-                    throw searchLimitError(`${limits.maxEntries}エントリ`);
-                if (entry.isFile() && MANIFEST_FILENAMES.has(entry.name)) {
-                    if (manifests.length >= limits.maxManifests)
-                        throw searchLimitError(`マニフェスト${limits.maxManifests}件`);
-                    manifests.push(path.relative(rootDir, path.join(dir, entry.name)));
-                }
-                else if (entry.isFile() && GRADLE_BUILD_FILENAMES.has(entry.name)) {
-                    gradleBuildFileFound = true;
-                }
-                else if (entry.isDirectory() && !SKIPPED_DIRS.has(entry.name)) {
-                    // isDirectory()はシンボリックリンクに対してfalseを返すため、リンクは自然に除外される
-                    nextLevel.push(path.join(dir, entry.name));
-                }
-            }
-        }
-        currentLevel = nextLevel;
-    }
-    return { manifests, gradleBuildFileFound };
+function buildResult(projectDir, manifests, allowedRootReal) {
+    const targets = manifests.map((manifest) => ({
+        path: path.join(projectDir, manifest),
+        format: path.basename(manifest),
+    }));
+    return { projectDir, manifests, targets, allowedRootReal };
 }
 /**
  * 入力パスを検証し、スキャン対象のJavaプロジェクトとして解決する。
@@ -110,10 +60,10 @@ export async function detectJavaProject(inputPath, options = {}) {
     // 親ディレクトリを探索しないため、探索上限エラーの回避手段として使える
     if (stats.isFile() && MANIFEST_FILENAMES.has(path.basename(resolved))) {
         const projectDir = path.dirname(resolved);
-        if (options.allowedRoot !== undefined) {
-            assertInsideAllowedRoot(projectDir, await resolveExistingPath(options.allowedRoot));
-        }
-        return { projectDir, manifests: [path.basename(resolved)], manifestPaths: [resolved] };
+        const allowedRootReal = options.allowedRoot !== undefined ? await resolveExistingPath(options.allowedRoot) : undefined;
+        if (allowedRootReal !== undefined)
+            assertInsideAllowedRoot(projectDir, allowedRootReal);
+        return buildResult(projectDir, [path.basename(resolved)], allowedRootReal);
     }
     let projectDir;
     if (stats.isDirectory()) {
@@ -127,13 +77,19 @@ export async function detectJavaProject(inputPath, options = {}) {
     else {
         throw new ScanToolError("project_not_found", `指定されたパスはディレクトリでも対応マニフェスト(pom.xml / gradle.lockfile)でもありません: ${inputPath}`);
     }
-    if (options.allowedRoot !== undefined) {
-        assertInsideAllowedRoot(projectDir, await resolveExistingPath(options.allowedRoot));
-    }
-    const { manifests, gradleBuildFileFound } = await findManifests(projectDir, {
-        maxDepth: options.maxDepth ?? DEFAULT_MAX_DEPTH,
-        maxEntries: options.maxEntries ?? DEFAULT_MAX_ENTRIES,
-        maxManifests: options.maxManifests ?? DEFAULT_MAX_MANIFESTS,
+    const allowedRootReal = options.allowedRoot !== undefined ? await resolveExistingPath(options.allowedRoot) : undefined;
+    if (allowedRootReal !== undefined)
+        assertInsideAllowedRoot(projectDir, allowedRootReal);
+    const manifests = [];
+    let gradleBuildFileFound = false;
+    await walkProjectFiles(projectDir, options, SKIPPED_DIRS, (relativePath, name) => {
+        if (MANIFEST_FILENAMES.has(name)) {
+            manifests.push(relativePath);
+            return true;
+        }
+        if (GRADLE_BUILD_FILENAMES.has(name))
+            gradleBuildFileFound = true;
+        return false;
     });
     if (manifests.length === 0) {
         if (gradleBuildFileFound) {
@@ -141,9 +97,5 @@ export async function detectJavaProject(inputPath, options = {}) {
         }
         throw new ScanToolError("no_manifest_found", `対応マニフェスト(pom.xml / gradle.lockfile)が見つかりません: ${projectDir}`);
     }
-    return {
-        projectDir,
-        manifests,
-        manifestPaths: manifests.map((manifest) => path.join(projectDir, manifest)),
-    };
+    return buildResult(projectDir, manifests, allowedRootReal);
 }

package/dist/utils/projectWalk.js

@@ -0,0 +1,77 @@
+/**
+ * スキャン対象パスの検証と、上限付きのディレクトリ走査(Java用・汎用の検出で共有)。
+ *
+ * 検出したファイルがそのままOSV-Scannerのスキャン範囲になるため、走査は深さで打ち切らず
+ * (Javaのソースツリーは深い)、上限に達した場合は結果を黙って欠落させずにエラーにする。
+ */
+import { readdir, realpath } from "node:fs/promises";
+import path from "node:path";
+import { ScanToolError } from "../errors.js";
+const DEFAULT_MAX_DEPTH = 64;
+const DEFAULT_MAX_ENTRIES = 200_000;
+const DEFAULT_MAX_MANIFESTS = 1_000;
+export async function resolveExistingPath(inputPath) {
+    try {
+        return await realpath(path.resolve(inputPath));
+    }
+    catch {
+        throw new ScanToolError("project_not_found", `指定されたパスが存在しません: ${inputPath}`);
+    }
+}
+/** targetがbaseDir自身またはその配下か(どちらも解決済みの絶対パス) */
+export function isInsideDir(baseDir, target) {
+    const relative = path.relative(baseDir, target);
+    return relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+export function assertInsideAllowedRoot(resolvedDir, allowedRootReal) {
+    if (!isInsideDir(allowedRootReal, resolvedDir)) {
+        throw new ScanToolError("path_outside_allowed_root", `指定されたパスは許可されたディレクトリ(${allowedRootReal})の外にあります`);
+    }
+}
+function searchLimitError(reason) {
+    return new ScanToolError("manifest_search_limit_exceeded", `マニフェスト探索が上限(${reason})に達したため、スキャンを中止しました。` +
+        "結果の欠落を避けるため途中までの結果は返しません。より狭いディレクトリ、またはマニフェストを直接指定してください");
+}
+/**
+ * 上限付きで幅優先に走査し、ファイルごとにonFileを呼ぶ。シンボリックリンクは辿らない。
+ * onFileがtrueを返したファイルをマニフェストとして数え、上限到達はエラーにする。
+ */
+export async function walkProjectFiles(rootDir, options, skippedDirs, onFile) {
+    const limits = {
+        maxDepth: options.maxDepth ?? DEFAULT_MAX_DEPTH,
+        maxEntries: options.maxEntries ?? DEFAULT_MAX_ENTRIES,
+        maxManifests: options.maxManifests ?? DEFAULT_MAX_MANIFESTS,
+    };
+    let visited = 0;
+    let manifests = 0;
+    let currentLevel = [rootDir];
+    for (let depth = 1; currentLevel.length > 0; depth++) {
+        if (depth > limits.maxDepth)
+            throw searchLimitError(`深さ${limits.maxDepth}`);
+        const nextLevel = [];
+        for (const dir of currentLevel) {
+            let entries;
+            try {
+                entries = await readdir(dir, { withFileTypes: true });
+            }
+            catch {
+                continue; // 読めないディレクトリはスキップ(権限不足等)
+            }
+            for (const entry of entries) {
+                if (++visited > limits.maxEntries)
+                    throw searchLimitError(`${limits.maxEntries}エントリ`);
+                if (entry.isFile()) {
+                    if (onFile(path.relative(rootDir, path.join(dir, entry.name)), entry.name)) {
+                        if (++manifests > limits.maxManifests)
+                            throw searchLimitError(`マニフェスト${limits.maxManifests}件`);
+                    }
+                }
+                else if (entry.isDirectory() && !skippedDirs.has(entry.name)) {
+                    // isDirectory()はシンボリックリンクに対してfalseを返すため、リンクは自然に除外される
+                    nextLevel.push(path.join(dir, entry.name));
+                }
+            }
+        }
+        currentLevel = nextLevel;
+    }
+}

package/dist/utils/requirementsFile.js

@@ -0,0 +1,223 @@
+/**
+ * requirements.txtの解析と、osv-scannerに渡す検証済みコピーの内容の生成(pipは使わない)。
+ *
+ * 元のファイルはosv-scannerに渡さない。osv-scannerは取り込み指定を独自に正規化してたどる
+ * (`- r ../x.txt` のような空白入りも取り込みとして扱い、スキャン対象の外のファイルを読む)ため、
+ * 事前解析との解釈のずれがそのまま境界の迂回になる。そこで、ここで解釈できた依存の行だけを
+ * `名前==版` 等の単純な形に正規化して返し、呼び出し側がそれを専用コピーに書いてスキャンする。
+ * コピーには取り込み・オプションを一切含めないため、osv-scannerがたどれる参照は存在しない。
+ *
+ * osv-scanner v2.4.0の実機確認(2026-10-07):
+ * - `==` / `===` はその版をスキャンする。`>=X` / `~=X` は下限Xを使用中の版とみなす
+ * - `>` `<` `!=` `==1.*` 範囲の組み合わせ・版なしは空の版になり、結果から消える
+ * - `-r` はたどるが、`--requirement` / `-c` はたどらない
+ *
+ * 取り込み(`-r` / `--requirement`)は、プロジェクトディレクトリ内の取り込み先だけをここで展開する。
+ * 外・存在しない・URL・上限超過の取り込み、制約ファイル(`-c`)、解釈できない行は、
+ * スキャンされない参照として報告する(黙って無視しない)。
+ */
+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;
+/** PEP 503の名前正規化(小文字化し、`-_.`の連続を`-`にする) */
+export function normalizePypiName(name) {
+    return name.toLowerCase().replace(/[-_.]+/g, "-");
+}
+// osv-scannerは`-`の後の空白も許して取り込みとみなすため、こちらも空白を許して認識する
+const INCLUDE_REQUIREMENT = /^(?:-\s*r|--\s*requirement)(?:\s*=\s*|\s*)(\S.*)$/;
+const INCLUDE_CONSTRAINT = /^(?:-\s*c|--\s*constraint)(?:\s*=\s*|\s*)(\S.*)$/;
+const EDITABLE = /^(?:-\s*e|--\s*editable)(?:\s|=|$)/;
+/** 依存の解決先や取得方法に関するオプション。スキャン対象には影響しない(deps.devモードでは接続しない) */
+const HARMLESS_OPTION = /^(?:-i|--index-url|--extra-index-url|-f|--find-links|--trusted-host|--pre|--no-binary|--only-binary|--prefer-binary|--require-hashes|--no-index|--use-feature)(?:\s|=|$)/;
+const URL_SCHEME = /^[a-z][a-z0-9+.-]*:\/\//i;
+const NAME_AND_SPEC = /^([A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?)\s*(?:\[[^\]]*\])?\s*(.*)$/;
+const SPEC = /^(===|==|~=|!=|>=|<=|>|<)\s*([^\s,]+)$/;
+/** コピーに書く版。想定外の文字を含む版は書かない(解釈のずれを持ち込まない) */
+const SAFE_VERSION = /^[A-Za-z0-9][A-Za-z0-9._+!-]*$/;
+/** 行継続を結合し、コメントを除いた論理行を返す(行番号は論理行の先頭) */
+function logicalLines(text) {
+    const result = [];
+    const physical = text.split(/\r?\n/);
+    let buffer = "";
+    let start = 0;
+    for (let i = 0; i < physical.length; i++) {
+        const raw = physical[i];
+        if (buffer === "")
+            start = i + 1;
+        if (raw.endsWith("\\")) {
+            buffer += raw.slice(0, -1) + " ";
+            continue;
+        }
+        buffer += raw;
+        flush();
+    }
+    flush(); // 行継続で終わるファイル
+    return result;
+    function flush() {
+        // 行頭または空白の後の#以降はコメント(URL内の#egg=等は残る)
+        const content = buffer.replace(/(^|\s)#.*$/, "").trim();
+        if (content !== "")
+            result.push({ line: start, content });
+        buffer = "";
+    }
+}
+function classifyRequirement(file, line, content, out) {
+    const reference = (reason) => {
+        out.references.push({ file, line, text: content, reason });
+    };
+    // 環境マーカーと行末のオプション(--hash等)を除く
+    const withoutMarker = content.split(";")[0];
+    const requirement = withoutMarker.replace(/\s--?[A-Za-z].*$/, "").trim();
+    if (/\s@\s/.test(requirement) || URL_SCHEME.test(requirement) || /^[./~]/.test(requirement) || requirement.includes("/")) {
+        reference("URL・パス指定の依存はスキャンされません");
+        return;
+    }
+    const match = NAME_AND_SPEC.exec(requirement);
+    if (!match) {
+        reference("解釈できない行です");
+        return;
+    }
+    const name = match[1];
+    const specifier = match[2].replace(/[()]/g, "").trim();
+    const specs = specifier === "" ? [] : specifier.split(",").map((s) => s.trim()).filter((s) => s !== "");
+    if (specs.length === 0) {
+        out.issues.push({ file, line, name, specifier, kind: "unpinned" });
+        return;
+    }
+    const parsed = specs.length === 1 ? SPEC.exec(specs[0]) : null;
+    if (parsed) {
+        const op = parsed[1];
+        const version = parsed[2];
+        if ((op === "==" || op === "===") && !version.includes("*")) {
+            if (!SAFE_VERSION.test(version))
+                return reference("解釈できない版の指定です");
+            out.entries.push(`${name}==${version}`);
+            return;
+        }
+        if (op === ">=" || op === "~=") {
+            if (!SAFE_VERSION.test(version))
+                return reference("解釈できない版の指定です");
+            // osv-scannerは下限を使用中の版とみなしてスキャンする(実機確認)。その挙動を保ち、印を付けて報告する
+            out.entries.push(`${name}${op}${version}`);
+            out.issues.push({ file, line, name, specifier, kind: "lower_bound" });
+            out.lowerBounds.push({ name: normalizePypiName(name), version });
+            return;
+        }
+    }
+    out.issues.push({ file, line, name, specifier, kind: "range" });
+}
+async function include(file, line, content, target, projectDir, depth, out, context) {
+    const reference = (reason) => {
+        out.references.push({ file, line, text: content, reason });
+    };
+    const cleaned = target.trim().replace(/^["']|["']$/g, "");
+    if (URL_SCHEME.test(cleaned))
+        return reference("URLの取り込みは展開しません");
+    if (depth >= MAX_INCLUDE_DEPTH)
+        return reference(`取り込みの深さが上限(${MAX_INCLUDE_DEPTH})を超えています`);
+    let resolved;
+    try {
+        resolved = await realpath(path.resolve(path.dirname(file), cleaned));
+    }
+    catch {
+        return reference("取り込み先が存在しません");
+    }
+    if (!isInsideDir(projectDir, resolved))
+        return reference("取り込み先がプロジェクトディレクトリの外のため展開しません");
+    if (out.visited.has(resolved))
+        return; // 循環
+    if (out.visited.size >= MAX_FILES)
+        return reference(`取り込みファイルが上限(${MAX_FILES}件)を超えています`);
+    let failure;
+    try {
+        failure = await analyze(resolved, projectDir, depth + 1, out, context);
+    }
+    catch {
+        failure = "取り込み先を読み込めません";
+    }
+    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, context) {
+    out.visited.add(file);
+    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, context);
+            continue;
+        }
+        if (INCLUDE_CONSTRAINT.test(content)) {
+            out.references.push({ file, line, text: content, reason: "制約ファイルは適用していません" });
+            continue;
+        }
+        if (EDITABLE.test(content)) {
+            out.references.push({ file, line, text: content, reason: "編集可能インストール(-e)はスキャンされません" });
+            continue;
+        }
+        if (content.startsWith("-")) {
+            if (!HARMLESS_OPTION.test(content)) {
+                out.references.push({ file, line, text: content, reason: "解釈できないオプションです" });
+            }
+            continue;
+        }
+        classifyRequirement(file, line, content, out);
+    }
+    return null;
+}
+/**
+ * requirements.txtを解析する。元ファイル自体が読めない・大きすぎる場合だけ`ok: false`。
+ * @param file 検出済みの絶対パス
+ * @param 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, context);
+    }
+    catch {
+        reason = "読み込めません";
+    }
+    if (reason !== null)
+        return { ok: false, reason };
+    return { ok: true, entries: out.entries, issues: out.issues, references: out.references, lowerBounds: out.lowerBounds };
+}

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)