The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.
fix(block-no-verify): bound the flag scan to the enclosing quote/heredoc line
Greg Royb3a2d3586b39
diff --git a/scripts/hooks/block-no-verify.js b/scripts/hooks/block-no-verify.jsindex 138075484..6416b0944 100644--- a/scripts/hooks/block-no-verify.js+++ b/scripts/hooks/block-no-verify.js@@ -162,11 +162,14 @@ function tokenizeShellWords(input, start = 0, end = input.length) {return tokens;}-function findCommandSegmentEnd(input, start) {+/**+ * Find the end of a shell command segment without scanning beyond `limit`.+ */+function findCommandSegmentEnd(input, start, limit = input.length) {let quote = null;let escaped = false;- for (let i = start; i < input.length; i++) {+ for (let i = start; i < limit; i++) {const char = input.charAt(i);if (escaped) {@@ -200,7 +203,7 @@ function findCommandSegmentEnd(input, start) {}}- return input.length;+ return limit;}function commitOptionConsumesNextValue(value) {@@ -252,24 +255,256 @@ function isCommitNoVerifyShortFlag(value) {}/**- * Check if a position in the input is inside a shell comment.+ * Precompute the positions that follow a comment marker on their current line.+ * This preserves the hook's existing comment heuristic without rescanning a+ * potentially long line for every `git` candidate.*/-function isInComment(input, idx) {- const lineStart = input.lastIndexOf('\n', idx - 1) + 1;- const before = input.slice(lineStart, idx);- for (let i = 0; i < before.length; i++) {- if (before.charAt(i) === '#') {- const prev = i > 0 ? before.charAt(i - 1) : '';- if (prev !== '$' && prev !== '\\') return true;+function buildCommentMask(input) {+ const comments = new Uint8Array(input.length);+ let afterCommentMarker = false;+ let quote = null;+ let escaped = false;++ for (let i = 0; i < input.length; i++) {+ const char = input.charAt(i);+ if (char === '\n') {+ afterCommentMarker = false;+ escaped = false;+ continue;+ }++ comments[i] = afterCommentMarker ? 1 : 0;++ if (afterCommentMarker) continue;++ if (escaped) {+ escaped = false;+ continue;+ }++ if (quote) {+ if (quote === '"' && char === '\\') {+ escaped = true;+ } else if (char === quote) {+ quote = null;+ }+ continue;+ }++ if (char === '\\') {+ escaped = true;+ continue;+ }++ if (char === '"' || char === "'") {+ quote = char;+ continue;+ }++ if (char === '#' && (i === 0 || /[\s;&|()]/.test(input.charAt(i - 1)))) {+ const previous = i > 0 ? input.charAt(i - 1) : '';+ if (previous !== '$' && previous !== '\\') afterCommentMarker = true;}}- return false;++ return comments;}/**- * Find the next 'git' token in the input starting from a position.+ * Compute the maximum scan endpoint for characters inside outer quotes and+ * heredoc body lines. The hook deliberately keeps every `git` candidate: quoted+ * data may later be executed by a shell. Bounds only prevent a candidate's flag+ * scan from leaking into unrelated text after its enclosing quote or body line.*/-function findGit(input, start) {+function buildScanBoundaries(input) {+ const boundaries = new Int32Array(input.length);+ boundaries.fill(-1);++ const pendingHeredocs = [];+ let quote = null;+ let quoteStart = -1;+ let escaped = false;+ let comment = false;++ for (let i = 0; i < input.length; i++) {+ if ((i === 0 || input.charAt(i - 1) === '\n') && pendingHeredocs.length > 0) {+ const lineEnd = input.indexOf('\n', i);+ const physicalEnd = lineEnd === -1 ? input.length : lineEnd;+ const contentEnd = input.charAt(physicalEnd - 1) === '\r' ? physicalEnd - 1 : physicalEnd;+ const heredoc = pendingHeredocs[0];+ const line = input.slice(i, contentEnd);+ const comparableLine = heredoc.stripTabs ? line.replace(/^\t+/, '') : line;++ if (comparableLine === heredoc.delimiter) {+ pendingHeredocs.shift();+ } else {+ boundaries.fill(contentEnd, i, contentEnd);+ }++ i = physicalEnd;+ continue;+ }++ const char = input.charAt(i);++ if (comment) {+ if (char === '\n') comment = false;+ continue;+ }++ if (escaped) {+ escaped = false;+ continue;+ }++ if (quote) {+ if (quote === '"' && char === '\\') {+ escaped = true;+ continue;+ }+ if (char === quote) {+ boundaries.fill(i, quoteStart + 1, i);+ quote = null;+ quoteStart = -1;+ }+ continue;+ }++ if (char === '\\') {+ escaped = true;+ continue;+ }++ if (char === '"' || char === "'") {+ quote = char;+ quoteStart = i;+ continue;+ }++ if (char === '#' && (i === 0 || /[\s;&|()]/.test(input.charAt(i - 1)))) {+ comment = true;+ continue;+ }++ if (char === '<' && input.charAt(i + 1) === '<' && input.charAt(i + 2) !== '<') {+ const heredocMatch = /^<<(-?)[ \t]*(?:'([^']+)'|"([^"]+)"|([^ \t\r\n;|&()<>]+))/.exec(input.slice(i));+ if (heredocMatch) {+ pendingHeredocs.push({+ delimiter: heredocMatch[2] || heredocMatch[3] || heredocMatch[4],+ stripTabs: heredocMatch[1] === '-',+ });+ i += heredocMatch[0].length - 1;+ }+ }+ }++ if (quote) boundaries.fill(input.length, quoteStart + 1);+ return boundaries;+}++/**+ * Return the enclosing quote or heredoc-line endpoint for a candidate.+ */+function getScanBoundary(boundaries, idx, fallback) {+ const boundary = boundaries[idx];+ return boundary >= 0 ? boundary : fallback;+}++/**+ * Parse the first non-global-option word after a `git` executable token.+ * Git chooses that word as its subcommand, so later words cannot change it.+ */+function findGitSubcommand(input, start, end) {+ let value = '';+ let tokenStart = -1;+ let quote = null;+ let escaped = false;+ let expectOptionValue = false;++ /**+ * Classify a completed word, returning a protected Git subcommand if found.+ */+ function classifyWord() {+ if (tokenStart === -1) return null;++ const completed = { value, start: tokenStart };+ value = '';+ tokenStart = -1;++ if (expectOptionValue) {+ expectOptionValue = false;+ return null;+ }++ if (completed.value.startsWith('-')) {+ if (completed.value === '-c' || completed.value === '-C' ||+ completed.value === '--work-tree' || completed.value === '--git-dir' ||+ completed.value === '--namespace' || completed.value === '--super-prefix') {+ expectOptionValue = true;+ }+ return null;+ }++ return {+ terminal: true,+ command: GIT_COMMANDS_WITH_NO_VERIFY.includes(completed.value) ? completed.value : null,+ start: completed.start,+ };+ }++ for (let i = start; i < end; i++) {+ const char = input.charAt(i);++ if (escaped) {+ if (tokenStart === -1) tokenStart = i - 1;+ value += char;+ escaped = false;+ continue;+ }++ if (quote) {+ if (char === quote) {+ quote = null;+ } else if (quote === '"' && char === '\\') {+ escaped = true;+ } else {+ if (tokenStart === -1) tokenStart = i;+ value += char;+ }+ continue;+ }++ if (char === '"' || char === "'") {+ if (tokenStart === -1) tokenStart = i;+ quote = char;+ continue;+ }++ if (char === '\\') {+ if (tokenStart === -1) tokenStart = i;+ escaped = true;+ continue;+ }++ if (/\s/.test(char) || char === ';' || char === '|' || char === '&') {+ const completed = classifyWord();+ if (completed?.terminal) return completed;+ if (char === ';' || char === '|' || char === '&' || char === '\n') return null;+ continue;+ }++ if (tokenStart === -1) tokenStart = i;+ value += char;+ }++ return classifyWord();+}+++/**+ * Find the next contiguous raw `git` token starting from a position.+ */+function findRawGit(input, start) {let pos = start;while (pos < input.length) {const idx = input.indexOf('git', pos);@@ -284,88 +519,196 @@ function findGit(input, start) {}const before = idx > 0 ? input[idx - 1] : ' ';- if (VALID_BEFORE_GIT.includes(before)) return { idx, len };+ if (VALID_BEFORE_GIT.includes(before)) return { idx, len, end: idx + len };pos = idx + 1;}return null;}+/**+ * Find a shell word assembled through quoting or escapes that evaluates to+ * `git` or `git.exe`. Only words before `end` need inspection because a raw+ * candidate at that position is already known to be earlier.+ */+function findAssembledGit(input, start, end) {+ let value = '';+ let tokenStart = -1;+ let quote = null;+ let escaped = false;++ /**+ * Complete the current word and return it when it evaluates to Git.+ */+ function completeWord(wordEnd) {+ if (tokenStart === -1) return null;+ const normalized = value.toLowerCase();+ const candidate = normalized === 'git' || normalized === 'git.exe'+ ? { idx: tokenStart, len: wordEnd - tokenStart, end: wordEnd }+ : null;+ value = '';+ tokenStart = -1;+ return candidate;+ }++ for (let i = start; i < end; i++) {+ const char = input.charAt(i);++ if (escaped) {+ value += char;+ escaped = false;+ continue;+ }++ if (quote) {+ if (char === quote) {+ quote = null;+ } else if (quote === '"' && char === '\\') {+ escaped = true;+ } else {+ value += char;+ }+ continue;+ }++ if (char === '"' || char === "'") {+ if (tokenStart === -1) tokenStart = i;+ quote = char;+ continue;+ }++ if (char === '\\') {+ if (tokenStart === -1) tokenStart = i;+ escaped = true;+ continue;+ }++ if (/\s/.test(char) || char === ';' || char === '|' || char === '&') {+ const candidate = completeWord(i);+ if (candidate) return candidate;+ continue;+ }++ if (tokenStart === -1) tokenStart = i;+ value += char;+ }++ return completeWord(end);+}++/**+ * Find the next raw or shell-assembled Git executable token.+ */+function findGit(input, start) {+ const rawCandidate = findRawGit(input, start);+ const assembledCandidate = findAssembledGit(+ input,+ start,+ rawCandidate ? rawCandidate.idx : input.length+ );+ return assembledCandidate || rawCandidate;+}++/**+ * Normalize the shell word containing `idx`, including adjacent quoted and+ * escaped fragments, and return its raw endpoint.+ */+function assembleShellWordContaining(input, idx) {+ let wordStart = idx;+ while (wordStart > 0 && !/[\s;&|]/.test(input.charAt(wordStart - 1))) {+ wordStart--;+ }++ let value = '';+ let quote = null;+ let escaped = false;+ let wordEnd = input.length;++ for (let i = wordStart; i < input.length; i++) {+ const char = input.charAt(i);++ if (escaped) {+ value += char;+ escaped = false;+ continue;+ }++ if (quote) {+ if (char === quote) {+ quote = null;+ } else if (quote === '"' && char === '\\') {+ escaped = true;+ } else {+ value += char;+ }+ continue;+ }++ if (char === '"' || char === "'") {+ quote = char;+ continue;+ }++ if (char === '\\') {+ escaped = true;+ continue;+ }++ if (/\s/.test(char) || char === ';' || char === '|' || char === '&') {+ wordEnd = i;+ break;+ }++ value += char;+ }++ return { value: value.toLowerCase(), end: wordEnd };+}+/*** Detect which git subcommand (commit, push, etc.) is being invoked.* Returns { command, offset } where offset is the position right after the* subcommand keyword, so callers can scope flag checks to only that portion.*/-function detectGitCommand(input, start = 0) {+function detectGitCommand(input, boundaries, comments, start = 0) {while (start < input.length) {const git = findGit(input, start);if (!git) return null;- if (isInComment(input, git.idx)) {- start = git.idx + git.len;- continue;- }-- // Find the first matching subcommand token after "git".- // We pick the one closest to "git" so that argument values like- // "git push origin commit" don't misclassify "commit" as the subcommand.- let bestCmd = null;- let bestIdx = Infinity;-- for (const cmd of GIT_COMMANDS_WITH_NO_VERIFY) {- let searchPos = git.idx + git.len;- while (searchPos < input.length) {- const cmdIdx = input.indexOf(cmd, searchPos);- if (cmdIdx === -1) break;-- const before = cmdIdx > 0 ? input[cmdIdx - 1] : ' ';- const after = input[cmdIdx + cmd.length] || ' ';- if (!/\s/.test(before)) { searchPos = cmdIdx + 1; continue; }- if (!/[\s;&#|>)\]}"']/.test(after) && after !== '') { searchPos = cmdIdx + 1; continue; }- if (/[;|]/.test(input.slice(git.idx + git.len, cmdIdx))) break;- if (isInComment(input, cmdIdx)) { searchPos = cmdIdx + 1; continue; }-- // Verify this token is the first non-flag word after "git" — i.e. the- // actual subcommand, not an argument value to a different subcommand.- const gap = input.slice(git.idx + git.len, cmdIdx);- const tokens = gap.trim().split(/\s+/).filter(Boolean);- // Every token before the candidate must be a flag or a flag argument.- // Git global flags like -c take a value argument (e.g. -c key=value).- let onlyFlagsAndArgs = true;- let expectFlagArg = false;- for (const t of tokens) {- if (expectFlagArg) { expectFlagArg = false; continue; }- if (t.startsWith('-')) {- // -c is a git global flag that takes the next token as its argument- if (t === '-c' || t === '-C' || t === '--work-tree' || t === '--git-dir' ||- t === '--namespace' || t === '--super-prefix') {- expectFlagArg = true;- }- continue;- }- onlyFlagsAndArgs = false;- break;- }- if (!onlyFlagsAndArgs) { searchPos = cmdIdx + 1; continue; }-- if (cmdIdx < bestIdx) {- bestIdx = cmdIdx;- bestCmd = cmd;- }- break;- }+ if (comments[git.idx]) {+ start = git.end;+ continue;}- if (bestCmd) {+ const rawGitEnd = git.end;+ const enclosingEnd = getScanBoundary(boundaries, git.idx, input.length);+ const quotedExecutable = enclosingEnd === rawGitEnd;+ const assembledWord = quotedExecutable+ ? assembleShellWordContaining(input, git.idx)+ : null;+ const assembledExecutable = assembledWord &&+ (assembledWord.value === 'git' || assembledWord.value === 'git.exe');++ if (quotedExecutable && !assembledExecutable) {+ start = git.end;+ continue;+ }++ const gitEnd = assembledExecutable ? assembledWord.end : rawGitEnd;+ const scanEnd = quotedExecutable ? input.length : enclosingEnd;++ const subcommand = findGitSubcommand(input, gitEnd, scanEnd);+ if (subcommand?.command) {return {- command: bestCmd,- offset: bestIdx + bestCmd.length,+ command: subcommand.command,+ offset: subcommand.start + subcommand.command.length,gitStart: git.idx,- gitEnd: git.idx + git.len,- commandStart: bestIdx,+ gitEnd,+ commandStart: subcommand.start,+ scanEnd,};}- start = git.idx + git.len;+ start = git.end;}return null;}@@ -376,8 +719,8 @@ function detectGitCommand(input, start = 0) {* right after the detected subcommand keyword) so that flags belonging to* earlier commands in a chain are not falsely matched.*/-function hasNoVerifyFlag(input, command, offset) {- const segmentEnd = findCommandSegmentEnd(input, offset);+function hasNoVerifyFlag(input, command, offset, scanEnd) {+ const segmentEnd = findCommandSegmentEnd(input, offset, scanEnd);const tokens = tokenizeShellWords(input, offset, segmentEnd);let skipNext = false;@@ -449,10 +792,12 @@ function hasHooksPathOverride(input, detected) {* Check a command string for git hook bypass attempts.*/function checkCommand(input) {+ const boundaries = buildScanBoundaries(input);+ const comments = buildCommentMask(input);let start = 0;while (start < input.length) {- const detected = detectGitCommand(input, start);+ const detected = detectGitCommand(input, boundaries, comments, start);if (!detected) return { blocked: false };const { command: gitCommand, offset } = detected;@@ -464,14 +809,14 @@ function checkCommand(input) {};}- if (hasNoVerifyFlag(input, gitCommand, offset)) {+ if (hasNoVerifyFlag(input, gitCommand, offset, detected.scanEnd)) {return {blocked: true,reason: `BLOCKED: --no-verify flag is not allowed with git ${gitCommand}. Git hooks must not be bypassed.`,};}- start = findCommandSegmentEnd(input, offset) + 1;+ start = findCommandSegmentEnd(input, offset, detected.scanEnd) + 1;}return { blocked: false };diff --git a/tests/hooks/block-no-verify.test.js b/tests/hooks/block-no-verify.test.jsindex f610030c6..11c1f87a8 100644--- a/tests/hooks/block-no-verify.test.js+++ b/tests/hooks/block-no-verify.test.js@@ -197,6 +197,88 @@ if (test('still allows -tn (n is the -t template path, not a flag)', () => {assert.strictEqual(r.code, 0, `expected exit 0, got ${r.code}: ${r.stderr}`);})) passed++; else failed++;++// --- Quoted/heredoc candidates: preserve blocking, prevent flag leakage ---++const executingPayloads = [+ ['retain broad blocking of a quoted git literal', 'echo "git commit -n"'],+ ['block double-quoted git executable', '"git" commit -n -m x'],+ ['block single-quoted git executable', "'git' commit -n -m x"],+ ['block git executable assembled with empty single quotes', "g''it commit -n -m x"],+ ['block git executable assembled with empty double quotes', 'g""it commit --no-verify -m x'],+ ['block git executable assembled from quoted prefix', "'g'it commit -n -m x"],+ ['block git executable assembled from quoted middle', "g'i't commit -n -m x"],+ ['block git executable assembled with an escape', 'g\\it commit -n -m x'],+ ['block double-quoted git plus exe suffix', '"git".exe commit -n -m x'],+ ['block single-quoted git plus exe suffix', "'git'.exe commit -n -m x"],+ ['block hooksPath after double-quoted git plus exe suffix', '"git".exe -c core.hooksPath=/tmp/no commit -m x'],+ ['block hooksPath after single-quoted git plus exe suffix', "'git'.exe -c core.hooksPath=/tmp/no commit -m x"],+ ['block double-quoted git with quote-assembled exe suffix', '"git".e""xe commit -n -m x'],+ ['block single-quoted git with quote-assembled exe suffix', "'git'.e''xe commit -n -m x"],+ ['block adjacent quoted git and escaped exe suffix', '"git""\\.exe" commit -n -m x'],+ ['block quoted git with escaped exe suffix', '"git".\\exe commit -n -m x'],+ ['block hooksPath after quote-assembled exe suffix', '"git".e""xe -c core.hooksPath=/tmp/no commit -m x'],+ ['quoted hash does not hide a later commit bypass', 'echo "#"; git commit -n -m x'],+ ['hash text in quotes does not hide a later commit bypass', 'echo "not # a comment" && git commit --no-verify -m x'],+ ['word-internal hash does not hide a later commit bypass', 'echo foo#bar; git commit -n -m x'],+ ['word-internal hash does not hide a later push bypass', 'printf %s foo#bar && git push --no-verify'],+ ['pipe echo data to bash', "echo 'git commit -n -m x' | bash"],+ ['pipe printf data to sh', "printf '%s\\n' 'git commit --no-verify -m x' | sh"],+ ['execute data through xargs and bash -c', "printf '%s\\n' 'git commit -n -m x' | xargs -I CMD bash -c CMD"],+ ['execute command substitution text through bash', "echo '$(git commit -n -m x)' | bash"],+ ['execute bash here-string', "bash <<< 'git commit -n -m x'"],+ ['execute sh here-string', "sh -s <<< 'git commit --no-verify -m x'"],+ ['block backtick command substitution', 'echo "`git commit -n -m x`"'],+ ['block substitution after quoted parenthesis', 'echo "$(printf \')\'; git commit -n -m x)"'],+ ['block substitution after case parenthesis', 'echo "$(case x in x) :;; esac; git commit -n -m x)"'],+ ['block bash --noprofile -c', "bash --noprofile -c 'git commit -n -m x'"],+ ['block bash -O extglob -c', "bash -O extglob -c 'git commit -n -m x'"],+ ['block bash -o pipefail -c', "bash -o pipefail -c 'git commit -n -m x'"],+ ['block bash -c after option terminator', "bash -c -- 'git commit -n -m x'"],+ ['block sh -c after option terminator', "sh -c -- 'git commit --no-verify -m x'"],+ ['block heredoc piped to bash', 'cat <<EOF | bash\ngit commit -n -m x\nEOF'],+ ['block heredoc piped to sudo bash', 'cat <<EOF | sudo bash\ngit commit --no-verify -m x\nEOF'],+ ['block heredoc on leading redirection', '<<EOF bash\ngit commit -n -m x\nEOF'],+ ['block executable command after CRLF heredoc', 'python3 - <<\'PY\'\r\nprint("git commit -n")\r\nPY\r\ngit commit -n -m x'],+ ['block bash -c double-quoted payload', 'bash -c "git commit -n -m x"'],+ ['block eval payload', 'eval "git commit --no-verify -m x"'],+ ['block bash heredoc payload', 'bash <<EOF\ngit commit -n -m x\nEOF'],+ ['block bypass in a whitespace-separated command sequence', 'git commit -n -m x git commit --no-verify -m x git commit -am x -n git push --no-verify'],+];++for (const [name, command] of executingPayloads) {+ if (test(name, () => {+ const r = runHook({ tool_input: { command } });+ assert.strictEqual(r.code, 2, `expected exit 2, got ${r.code}: ${r.stderr}`);+ })) passed++; else failed++;+}++const nonLeakingPayloads = [+ ['python heredoc string with later bash -n', 'python3 - <<\'PY\'\nold="git add -A\\nif ! git diff --cached --quiet; then\\n git commit -q -m \\"vault sync"\nPY\nbash -n vault-sync.sh'],+ ['assignment string with later bash -n', 'old="git commit -q -m x"; bash -n x.sh'],+ ['plain commit followed by later-line bash -n', 'git commit -m x\nbash -n s.sh'],+ ['plain commit followed by grep -n', 'git commit -m x; grep -n foo f.txt'],+ ['JSON string followed by sed -n', 'printf \'%s\' \'{"cmd":"git commit -q -m \\"x\\""}\' | node x.js; sed -n 1p f'],+ ['hyphenated Python heredoc delimiter', 'python3 - <<\'PY-SCRIPT\'\nprint("git commit -n")\nPY-SCRIPT\nbash -n x.sh'],+ ['non-shell heredoc after bash argument', "bash -c 'cat' <<EOF\ngit commit -q -m x\nEOF\nbash -n y.sh"],+ ['separate commits do not inherit bash -n', 'git commit -m x ; git commit --no-edit ; bash -n x.sh ; git commit -tn'],+ ['double-quoted literal does not inherit grep -n', 'echo "git commit -q -m x"; grep -n needle file'],+ ['single-quoted push literal does not inherit later flag', "note='git push'; printf '%s\\n' --no-verify"],+ ['Python heredoc line does not inherit sed flag', 'python3 <<EOF\nprint("git commit -q -m x")\nEOF\nsed --no-verify file'],+ ['assignment literal does not inherit grep long flag', "payload='git commit -m x'; grep --no-verify file"],+ ['printf literal does not inherit bash -n', 'printf \'%s\' "git commit -m x"; bash -n script.sh'],+ ['assignment literal does not inherit quoted echo -n data', 'old="git commit -q"; echo " -n"'],+ ['push literal does not inherit quoted printf long flag data', "payload='git push'; printf ' --no-verify'"],+ ['printf literal does not inherit later quoted echo -n data', 'printf "%s" "git commit -q"; echo " -n"'],+];++for (const [name, command] of nonLeakingPayloads) {+ if (test(name, () => {+ const r = runHook({ tool_input: { command } });+ assert.strictEqual(r.code, 0, `expected exit 0, got ${r.code}: ${r.stderr}`);+ })) passed++; else failed++;+}+console.log('─'.repeat(50));console.log(`Passed: ${passed} Failed: ${failed}`);