@yuneta/gobj-js 7.26.19 → 7.26.21

package/dist/gobj-js.umd.js

@@ -3439,6 +3439,11 @@
 		"sessionkey",
 		"authdata"
 	];
+	var SECRET_NAME_SEGMENTS = /* @__PURE__ */ new Set([
+		"pass",
+		"pin",
+		"otp"
+	]);
 	var NOT_SECRET_SEGMENTS = /* @__PURE__ */ new Set([
 		"endpoint",
 		"url",
@@ -3471,10 +3476,16 @@
 		if (typeof name !== "string" || name.length < 3) return false;
 		let lower = name.toLowerCase();
 		let hit = false;
-		for (const part of SECRET_NAME_PARTS) if (lower.indexOf(part) >= 0) {
+		for (const segment of lower.split(/[^a-z0-9]+/)) if (SECRET_NAME_SEGMENTS.has(segment)) {
 			hit = true;
 			break;
 		}
+		if (!hit) {
+			for (const part of SECRET_NAME_PARTS) if (lower.indexOf(part) >= 0) {
+				hit = true;
+				break;
+			}
+		}
 		if (!hit) {
 			let joined = lower.replace(/[_\-. \t]/g, "");
 			for (const part of SECRET_NAME_JOINED) if (joined.indexOf(part) >= 0) {
@@ -3512,32 +3523,250 @@
 		}
 	}
 	/************************************************************
-	*  A text (a command line) with the value of every "name=value"
-	*  whose name is a secret's written as "********", quoted or not
-	*  (and the "value" of a write-attr whose attribute names a
-	*  secret). The rest as it is. Return null when there was nothing
-	*  to mask. As the C kernel's mask_secrets_inline().
+	*  A credential by its SHAPE, whatever names it -- the C kernel's
+	*  jwt_len() / scheme_credential(), the shapes the agent's audit
+	*  record redacts, and the schemes of an HTTP Authorization:
+	*    - a JWT or a JWE: "eyJ" (the base64url of '{"') at the start
+	*      of a word, base64url, and a '.' after it -- three parts
+	*      joined by '.' (a JWS), five (a JWE), or fewer when a cap cut
+	*      it; the dots at the end of the run are not its own (a JWT
+	*      ends a sentence: "... eyJ.eyJ.sig.");
+	*    - the credential after the scheme word "Bearer" or "Basic"
+	*      (any case, a word of its own): scheme_credential().
 	************************************************************/
+	var MASK_TOKEN_MIN = 8;
+	var MASK_PROSE_MAX = 24;
+	function is_ascii_alnum_code(code) {
+		return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122;
+	}
+	function is_ascii_letter_code(code) {
+		return code >= 65 && code <= 90 || code >= 97 && code <= 122;
+	}
+	function is_ascii_upper_code(code) {
+		return code >= 65 && code <= 90;
+	}
+	function is_base64url_code(code) {
+		return is_ascii_alnum_code(code) || code === 45 || code === 95;
+	}
+	function ascii_case_equal(str, p, word) {
+		if (str.length - p < word.length) return false;
+		for (let i = 0; i < word.length; i++) {
+			let code = str.charCodeAt(p + i);
+			if (code >= 65 && code <= 90) code += 32;
+			if (code !== word.charCodeAt(i)) return false;
+		}
+		return true;
+	}
+	function jwt_len(str, p) {
+		if (str.length - p < 3 || str[p] !== "e" || str[p + 1] !== "y" || str[p + 2] !== "J") return 0;
+		if (p > 0 && (is_base64url_code(str.charCodeAt(p - 1)) || str[p - 1] === ".")) return 0;
+		let e = p;
+		let dotted = false;
+		while (e < str.length && (is_base64url_code(str.charCodeAt(e)) || str[e] === ".")) {
+			if (str[e] === ".") dotted = true;
+			e++;
+		}
+		if (!dotted) return 0;
+		while (str[e - 1] === ".") e--;
+		return e - p;
+	}
+	function scheme_word_len(str, p) {
+		if (p > 0 && is_ascii_alnum_code(str.charCodeAt(p - 1))) return 0;
+		for (const scheme of ["bearer", "basic"]) {
+			const n = scheme.length;
+			if (str.length - p > n && ascii_case_equal(str, p, scheme) && (str[p + n] === " " || str[p + n] === "	")) return n;
+		}
+		return 0;
+	}
+	function code_points(str, w, n) {
+		let count = 0;
+		for (let i = w; i < w + n; i++) {
+			const code = str.charCodeAt(i);
+			if (code < 56320 || code > 57343) count++;
+		}
+		return count;
+	}
+	function is_prose_word(str, w, n) {
+		if (n === 0 || n >= MASK_PROSE_MAX) return false;
+		let i = w;
+		const end = w + n;
+		while (true) {
+			let r = i;
+			let upper_rest = true;
+			let lower_rest = true;
+			while (r < end && is_ascii_letter_code(str.charCodeAt(r))) {
+				if (r > i) {
+					if (is_ascii_upper_code(str.charCodeAt(r))) lower_rest = false;
+					else upper_rest = false;
+				}
+				r++;
+			}
+			if (r === i) return false;
+			if (!lower_rest && !(upper_rest && is_ascii_upper_code(str.charCodeAt(i)))) return false;
+			if (r === end) return true;
+			if (str[r] !== "-" && str[r] !== "." && str[r] !== "/" || r + 1 === end) return false;
+			i = r + 1;
+		}
+	}
+	function base64_digit(code) {
+		if (code >= 65 && code <= 90) return code - 65;
+		if (code >= 97 && code <= 122) return code - 97 + 26;
+		if (code >= 48 && code <= 57) return code - 48 + 52;
+		if (code === 43) return 62;
+		if (code === 47) return 63;
+		return -1;
+	}
+	function is_basic_credential(str, w, n) {
+		let bits = 0;
+		let n_bits = 0;
+		for (let i = 0; i < n; i++) {
+			const v = base64_digit(str.charCodeAt(w + i));
+			if (v < 0) return false;
+			bits = (bits << 6 | v) & 16383;
+			n_bits += 6;
+			if (n_bits >= 8) {
+				n_bits -= 8;
+				if ((bits >> n_bits & 255) === 58) return true;
+			}
+		}
+		return false;
+	}
+	var SCHEME_WORD_STOPS = " 	\r\n\"',;}]\0";
+	function scheme_credential(str, p) {
+		const n = scheme_word_len(str, p);
+		if (!n) return [0, 0];
+		const scheme = n === 5 ? "basic" : "bearer";
+		let context = false;
+		let t = p + n;
+		while (t < str.length && (str[t] === " " || str[t] === "	")) t++;
+		if (t < str.length && scheme_word_len(str, t) === n && ascii_case_equal(str, t, scheme)) {
+			t += n;
+			context = true;
+			while (t < str.length && (str[t] === " " || str[t] === "	")) t++;
+		}
+		if (t >= str.length) return [0, 0];
+		if (str[t] === "\"" || str[t] === "'") {
+			let q = t + 1;
+			while (q < str.length && str[q] !== str[t] && str[q] !== " " && str[q] !== "	" && str[q] !== "\r" && str[q] !== "\n" && str[q] !== "\0") q++;
+			if (q < str.length && str[q] === str[t] && q > t + 1) return [t - p, q + 1 - t];
+			return [0, 0];
+		}
+		let e = t;
+		while (e < str.length && SCHEME_WORD_STOPS.indexOf(str[e]) < 0) e++;
+		if (e === t) return [0, 0];
+		if (!context) {
+			let w_end = e;
+			while (w_end > t && str[w_end - 1] === ".") w_end--;
+			const len = w_end - t;
+			if (len === 0 || is_prose_word(str, t, len)) return [0, 0];
+			if (n === 5) {
+				if (!is_basic_credential(str, t, len)) return [0, 0];
+			} else if (code_points(str, t, len) < MASK_TOKEN_MIN) return [0, 0];
+		}
+		return [t - p, e - t];
+	}
+	function shape_len(str, p) {
+		const c = str[p];
+		if (c === "e") return [0, jwt_len(str, p)];
+		if (c === "b" || c === "B") return scheme_credential(str, p);
+		return [0, 0];
+	}
+	function shape_len_7_26_9(str, p) {
+		const c = str[p];
+		if (c === "e") {
+			if (str.length - p < 3 || str[p + 1] !== "y" || str[p + 2] !== "J") return [0, 0];
+			if (p > 0 && (is_base64url_code(str.charCodeAt(p - 1)) || str[p - 1] === ".")) return [0, 0];
+			let e = p;
+			let dots = 0;
+			while (e < str.length && (is_base64url_code(str.charCodeAt(e)) || str[e] === ".")) {
+				if (str[e] === ".") dots++;
+				e++;
+			}
+			while (str[e - 1] === ".") {
+				e--;
+				dots--;
+			}
+			return dots === 2 ? [0, e - p] : [0, 0];
+		}
+		if (c === "b" || c === "B") {
+			if (str.length - p <= 6 || !ascii_case_equal(str, p, "bearer")) return [0, 0];
+			if (p > 0 && is_ascii_alnum_code(str.charCodeAt(p - 1))) return [0, 0];
+			let t = p + 6;
+			if (str[t] !== " " && str[t] !== "	") return [0, 0];
+			while (t < str.length && (str[t] === " " || str[t] === "	")) t++;
+			let e = t;
+			while (e < str.length && " 	\r\n'\",;}]\0".indexOf(str[e]) < 0) e++;
+			return [t - p, e - t];
+		}
+		return [0, 0];
+	}
+	var COLON_VALUE_STOPS = " 	\r\n,;&)]}<>\"'\0";
+	function colon_value_end(str, v) {
+		if (v >= str.length) return v;
+		const c = str[v];
+		if (c === "\"" || c === "'") {
+			let e = v + 1;
+			while (e < str.length && str[e] !== c) {
+				if (str[e] === "\\" && e + 1 < str.length) e++;
+				e++;
+			}
+			return e < str.length ? e + 1 : str.length;
+		}
+		if (c === "{" || c === "[") {
+			let depth = 0;
+			let in_string = false;
+			for (let e = v; e < str.length; e++) if (in_string) {
+				if (str[e] === "\\" && e + 1 < str.length) e++;
+				else if (str[e] === "\"") in_string = false;
+			} else if (str[e] === "\"") in_string = true;
+			else if (str[e] === "{" || str[e] === "[") depth++;
+			else if (str[e] === "}" || str[e] === "]") {
+				depth--;
+				if (depth === 0) return e + 1;
+			}
+			return str.length;
+		}
+		if (c === "\\") {
+			let q = v;
+			while (q < str.length && str[q] === "\\") q++;
+			if (q < str.length && (str[q] === "\"" || str[q] === "'")) {
+				const level = q - v;
+				let run = 0;
+				for (let e = q + 1; e < str.length; e++) {
+					if (str[e] === "\\") {
+						run++;
+						continue;
+					}
+					if (str[e] === str[q] && run === level) return e + 1;
+					run = 0;
+				}
+				return str.length;
+			}
+		}
+		let e = v;
+		const n = scheme_word_len(str, v);
+		if (n) {
+			e = v + n;
+			while (e < str.length && (str[e] === " " || str[e] === "	")) e++;
+			if (e < str.length && (str[e] === "\"" || str[e] === "'")) return colon_value_end(str, e);
+		}
+		while (e < str.length && COLON_VALUE_STOPS.indexOf(str[e]) < 0) e++;
+		return e;
+	}
 	var MASK_MAX_NAME = 128;
 	var MASK_MAX_BYTES = 4194304;
 	var MASK_TOO_LARGE = "<not shown: too large to mask>";
-	function mask_secrets_inline(str) {
-		if (typeof str !== "string" || str.indexOf("=") < 0) return null;
-		if (str.length > MASK_MAX_BYTES) return MASK_TOO_LARGE;
-		let value_is_secret = false;
-		let re_attr = /(^|[ \t])attribute=["']?([^ \t"']*)/g;
-		let m;
-		while ((m = re_attr.exec(str)) !== null) if (is_secret_name(m[2].slice(-128))) value_is_secret = true;
-		let parts = [];
-		let copied = 0;
-		let changed = false;
+	function mark_range(marks, from, to) {
+		for (let i = from; i < to; i++) marks[i] = 1;
+	}
+	function mark_params(str, value_is_secret, as_7_26_9, marks) {
+		const is_blank_or_end = (i) => i >= str.length || str[i] === " " || str[i] === "	" || str[i] === "\0";
 		let outer = "";
 		let word = 0;
 		let p = 0;
-		const is_blank_or_end = (i) => i >= str.length || str[i] === " " || str[i] === "	";
 		while (p < str.length) {
-			let c = str[p];
-			if (c === " " || c === "	") {
+			const c = str[p];
+			if (c === " " || c === "	" || c === "\0") {
 				p++;
 				word = p;
 				continue;
@@ -3546,43 +3775,124 @@
 				if (!outer && (p === 0 || str[p - 1] === " " || str[p - 1] === "	" || str[p - 1] === "=")) outer = c;
 				else if (c === outer && is_blank_or_end(p + 1)) outer = "";
 			}
+			if (as_7_26_9) {
+				const [offset, n] = shape_len_7_26_9(str, p);
+				if (n) {
+					p += offset + n;
+					word = p;
+					continue;
+				}
+			}
 			if (c !== "=") {
 				p++;
 				continue;
 			}
-			let name = str.substring(Math.max(word, p - MASK_MAX_NAME), p);
+			const name_from = Math.max(word, p - MASK_MAX_NAME);
+			const name = str.substring(name_from, p);
 			word = p + 1;
-			if (!(is_secret_name(name) || value_is_secret && name.toLowerCase() === "value")) {
+			if (!(is_secret_name(name) || value_is_secret && name.length === 5 && ascii_case_equal(str, name_from, "value"))) {
 				p++;
 				continue;
 			}
 			p++;
-			let quote = str[p] === "\"" || str[p] === "'" ? str[p] : "";
 			let end;
+			const quote = p < str.length && (str[p] === "\"" || str[p] === "'") ? str[p] : "";
 			if (quote) {
 				end = p + 1;
-				while (end < str.length && str[end] !== quote) end++;
-				if (str[end] === quote) end++;
+				while (end < str.length && str[end] !== quote && str[end] !== "\0") end++;
+				if (end < str.length && str[end] === quote) end++;
 			} else end = inline_secret_value_end(str, p, outer);
-			if (end > p) {
-				parts.push(str.substring(copied, p));
+			mark_range(marks, p, end);
+			p = end;
+			word = p;
+		}
+	}
+	function mark_shapes(str, marks) {
+		for (let p = 0; p < str.length; p++) {
+			const c = str[p];
+			if (c !== "e" && c !== "b" && c !== "B") continue;
+			const [offset, n] = shape_len(str, p);
+			if (n) mark_range(marks, p + offset, p + offset + n);
+		}
+	}
+	function mark_labels(str, marks) {
+		let word = 0;
+		let p = 0;
+		while (p < str.length) {
+			const c = str[p];
+			if (c === " " || c === "	" || c === "\0" || c === "=") {
+				p++;
+				word = p;
+				continue;
+			}
+			if (c !== ":") {
+				p++;
+				continue;
+			}
+			if (!is_secret_name(str.substring(Math.max(word, p - MASK_MAX_NAME), p))) {
+				p++;
+				word = p;
+				continue;
+			}
+			let v = p + 1;
+			while (v < str.length && (str[v] === " " || str[v] === "	")) v++;
+			const e = colon_value_end(str, v);
+			mark_range(marks, v, e);
+			const n_scheme = scheme_word_len(str, v);
+			if (n_scheme) p = v + n_scheme;
+			else p = e > v ? e : p + 1;
+			word = p;
+		}
+	}
+	/************************************************************
+	*  A text (a command line) with the secrets that can be told
+	*  written as "********" (each run of them as one), the rest as it
+	*  is: the value of every "name=value" whose name is a secret's,
+	*  quoted or not (and the "value" of a write-attr whose attribute
+	*  names a secret); the same for a "name: value", its name in quotes
+	*  or not (a json, a header, a label: "password": x, Authorization:
+	*  Basic x, bearer: tok); and a JWT or the credential after "Bearer "
+	*  or "Basic ", wherever they are, whatever names them. Each rule
+	*  judges the text as it came. Return null when there was nothing to
+	*  mask. As the C kernel's mask_secrets_inline().
+	************************************************************/
+	function mask_secrets_inline(str) {
+		if (typeof str !== "string") return null;
+		if (str.indexOf("=") < 0 && str.indexOf(":") < 0 && str.indexOf("eyJ") < 0 && !/bearer|basic/i.test(str)) return null;
+		if (str.length > MASK_MAX_BYTES) return MASK_TOO_LARGE;
+		let value_is_secret = false;
+		let re_attr = /(^|[ \t])attribute=["']?([^ \t"'\u0000]*)/g;
+		let m;
+		while ((m = re_attr.exec(str)) !== null) if (is_secret_name(m[2].slice(-128))) value_is_secret = true;
+		const marks = new Uint8Array(str.length);
+		mark_params(str, value_is_secret, true, marks);
+		mark_params(str, value_is_secret, false, marks);
+		mark_shapes(str, marks);
+		mark_labels(str, marks);
+		let parts = [];
+		let changed = false;
+		let i = 0;
+		while (i < str.length) {
+			let j = i;
+			if (marks[i]) {
+				while (j < str.length && marks[j]) j++;
 				parts.push("********");
-				copied = end;
 				changed = true;
+			} else {
+				while (j < str.length && !marks[j]) j++;
+				parts.push(str.substring(i, j));
 			}
-			p = end;
-			word = p;
+			i = j;
 		}
-		if (!changed) return null;
-		parts.push(str.substring(copied));
-		return parts.join("");
+		return changed ? parts.join("") : null;
 	}
 	/************************************************************
 	*  A json as a log or a trace may show it: at any depth, the
 	*  value of a key with a secret's name is "********", whatever
 	*  its type (not an absent one, a null or an empty string); so is
 	*  the "value" of a dict whose "attribute" names a secret; and a
-	*  string is masked as mask_secrets_inline(). Return a masked
+	*  string, under any key, is masked as mask_secrets_inline() (a
+	*  JWT, a "Bearer" token, a secret name=value). Return a masked
 	*  copy, or `jn` itself when there was nothing to mask. As the C
 	*  kernel's json_mask_secrets().
 	*
@@ -3611,7 +3921,7 @@
 				return MASK_TOO_LARGE;
 			}
 			budget.left -= jn.length;
-			let masked = mask_secrets_inline(jn);
+			let masked = mask_secrets_inline(jn.indexOf("\0") >= 0 ? jn.replace(/\u0000/g, " ") : jn);
 			return masked !== null ? masked : jn;
 		}
 		let is_array = Array.isArray(jn);
@@ -7113,15 +7423,34 @@
 		return gobj_save_persistent_attrs(gobj, attr);
 	}
 	/***************************************************************
-	*  "set" as the C command reads it: TRUE / set / 1, FALSE / reset / 0
+	*  "set" as the C command reads it (trace_set_value() of c_yuno.c):
+	*  a boolean; an integer in the range of an int (true unless 0); or
+	*  text -- set / reset, a JSON integer -?(0|[1-9][0-9]*), or true /
+	*  false, yes / no, on / off, any case. null for anything else: a
+	*  real (2.5), " 1", "0x1", "1e3", "+5", "007" and "2.5" are refused,
+	*  as in C. Up to gobj-js 7.26.19 the text went through Number(),
+	*  which took all of them, and "yes" / "on" were refused.
 	***************************************************************/
+	var INT_MIN = -2147483648;
+	var INT_MAX = 2147483647;
 	function parse_set(value) {
 		if (value === true || value === false) return value;
-		let v = String(value === void 0 || value === null ? "" : value).toLowerCase();
-		if (v === "true" || v === "set") return true;
-		if (v === "false" || v === "reset") return false;
-		if (v === "" || isNaN(Number(v))) return null;
-		return Number(v) ? true : false;
+		if (typeof value === "number") {
+			if (!Number.isInteger(value) || value < INT_MIN || value > INT_MAX) return null;
+			return value !== 0;
+		}
+		if (typeof value !== "string" || value === "") return null;
+		let v = value.toLowerCase();
+		if (v === "set") return true;
+		if (v === "reset") return false;
+		if (/^-?(0|[1-9][0-9]*)$/.test(value)) {
+			let n = Number(value);
+			if (n < INT_MIN || n > INT_MAX) return null;
+			return n !== 0;
+		}
+		if (v === "true" || v === "yes" || v === "on") return true;
+		if (v === "false" || v === "no" || v === "off") return false;
+		return null;
 	}
 	function yuno_prefix() {
 		return `${gobj_yuno_role()}^${gobj_yuno_name()}`;