From a2bda821c930dcbde35d228a484c13d44246a503 Mon Sep 17 00:00:00 2001 From: qybaihe Date: Sun, 8 Nov 2026 21:14:07 +0800 Subject: [PATCH] fix(sqlite,engine): resolve .db false-positive detection and harden AST/config/manifest/lint gates - Fix #130: require 'SQLite format 3\0' magic bytes for generic .db files while keeping .sqlite/.sqlite3 in the extension fallback so corrupt SQLite files still fail closed - Skip non-SQLite .db files in weave-decoy candidate discovery so WeavePlan.overallStatus is not downgraded by opaque runtime state files - Support WITHOUT ROWID tables and BigInt columns in SQLite snapshotBusinessTables - Clean up newly created partial output directories when directory-mode protectTarget fails on a child artifact, skip symlinks, and forward all ProtectionOptions - Fix #129: replace naive string splitting in encryptStrings with Babel AST span replacement, support 0-substitution backtick templates, and skip already-encrypted files - Validate sidecarEntangle and requireAgentWeave in .blarc and validate existing config in resolveProjectSeed/initBlaConfig - Exclude custom outputDirectory from discoverHardenTargets and reject project-root or .git/node_modules output directories - Add plaintextSecrets, integrityCoverage, and bindScope to bla lint --json detailCounts and --allow-* flags to bla lint / bla_lint - Verify adjacent regular-file or --artifact SHA-256 digests in bla verify-manifest - Add scripts/verify-website.mjs covering all 7 HTML pages, CSP headers, and internal links/anchors Fixes #129 Fixes #130 Co-Authored-By: Claude Code --- .github/workflows/website-pages.yml | 24 +--- scripts/verify-website.d.mts | 8 ++ scripts/verify-website.mjs | 186 +++++++++++++++++++++++++ src/cli.ts | 30 +++- src/core/config.ts | 8 +- src/core/detector.ts | 5 +- src/core/manifest-verify.ts | 147 +++++++++++++++++--- src/core/output-path.ts | 2 +- src/engine/encrypt-strings.ts | 188 +++++++++++++++++++++----- src/engine/harden.ts | 56 ++++++-- src/engine/protector.ts | 45 +++++- src/mcp/server.ts | 14 ++ src/shields/formats/sqlite.ts | 19 ++- src/shields/weave/weave-decoy.ts | 5 + tests/blarc-config-validation.test.ts | 19 ++- tests/core-domain.test.ts | 6 + tests/directory-fail-open.test.ts | 56 +++++++- tests/encrypt-strings.test.ts | 39 ++++++ tests/output-path-safety.test.ts | 23 ++++ tests/verify-manifest-command.test.ts | 37 +++++ tests/website-integrity.test.ts | 42 ++++++ 21 files changed, 856 insertions(+), 103 deletions(-) create mode 100644 scripts/verify-website.d.mts create mode 100644 scripts/verify-website.mjs create mode 100644 tests/website-integrity.test.ts diff --git a/.github/workflows/website-pages.yml b/.github/workflows/website-pages.yml index bd50d57..0cf53cb 100644 --- a/.github/workflows/website-pages.yml +++ b/.github/workflows/website-pages.yml @@ -24,25 +24,5 @@ jobs: steps: - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 - - name: Verify required pages and assets exist - run: | - for f in \ - website/index.html \ - website/get-started/index.html \ - website/showcase/index.html \ - website/guides/index.html \ - website/faq/index.html \ - website/enterprise/index.html \ - website/assets/styles.css \ - website/assets/main.js \ - website/assets/i18n.js \ - website/assets/home.js \ - website/assets/logo.png \ - website/assets/favicon.png \ - website/assets/favicon.svg \ - website/assets/social-card.svg \ - website/schemas/defense-manifest-v1.json \ - website/schemas/bla.config.v1.json; do - test -f "$f" || (echo "Missing required website file: $f" && exit 1) - done - echo "All website pages and assets verified." + - name: Verify website pages, CSP headers, assets, and internal links + run: node scripts/verify-website.mjs diff --git a/scripts/verify-website.d.mts b/scripts/verify-website.d.mts new file mode 100644 index 0000000..3959634 --- /dev/null +++ b/scripts/verify-website.d.mts @@ -0,0 +1,8 @@ +export interface WebsiteVerifyResult { + readonly ok: boolean; + readonly pagesChecked: number; + readonly linksChecked: number; + readonly errors: readonly string[]; +} + +export function verifyWebsiteDirectory(websiteRoot?: string): WebsiteVerifyResult; diff --git a/scripts/verify-website.mjs b/scripts/verify-website.mjs new file mode 100644 index 0000000..bd66bac --- /dev/null +++ b/scripts/verify-website.mjs @@ -0,0 +1,186 @@ +#!/usr/bin/env node +import { existsSync, readFileSync, statSync } from "node:fs"; +import { dirname, resolve } from "node:path"; +import { fileURLToPath } from "node:url"; + +const REPO_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), ".."); + +const REQUIRED_HTML_PAGES = [ + "index.html", + "get-started/index.html", + "showcase/index.html", + "crackme/index.html", + "guides/index.html", + "faq/index.html", + "enterprise/index.html", +]; + +const REQUIRED_ASSETS = [ + "assets/styles.css", + "assets/main.js", + "assets/i18n.js", + "assets/home.js", + "assets/logo.png", + "assets/favicon.png", + "assets/favicon.svg", + "assets/social-card.svg", + "schemas/defense-manifest-v1.json", + "schemas/bla.config.v1.json", +]; + +function extractIds(html) { + const ids = new Set(); + const re = /\bid\s*=\s*(?:"([^"]+)"|'([^']+)')/gi; + let m; + while ((m = re.exec(html)) !== null) { + ids.add(m[1] ?? m[2]); + } + return ids; +} + +function extractCspContent(html) { + const metaRe = /]*http-equiv\s*=\s*(?:"Content-Security-Policy"|'Content-Security-Policy')[^>]*>/i; + const tag = metaRe.exec(html)?.[0]; + if (!tag) return null; + const contentRe = /\bcontent\s*=\s*(?:"([^"]*)"|'([^']*)')/i; + const m = contentRe.exec(tag); + return m ? (m[1] ?? m[2] ?? "") : null; +} + +function extractLocalRefs(html) { + const refs = []; + const re = /\b(?:href|src)\s*=\s*(?:"([^"]*)"|'([^']*)')/gi; + let m; + while ((m = re.exec(html)) !== null) { + const val = (m[1] ?? m[2] ?? "").trim(); + if ( + !val || + val.startsWith("http://") || + val.startsWith("https://") || + val.startsWith("mailto:") || + val.startsWith("data:") || + val.startsWith("javascript:") + ) { + continue; + } + refs.push(val); + } + return refs; +} + +/** + * Verify all static website HTML pages, assets, CSP headers, and internal links/anchors. + * + * @param {string} [websiteRoot] + * @returns {{ ok: boolean, pagesChecked: number, linksChecked: number, errors: string[] }} + */ +export function verifyWebsiteDirectory(websiteRoot = resolve(REPO_ROOT, "website")) { + const absRoot = resolve(websiteRoot); + const errors = []; + let pagesChecked = 0; + let linksChecked = 0; + + for (const rel of REQUIRED_ASSETS) { + const full = resolve(absRoot, rel); + if (!existsSync(full) || !statSync(full).isFile()) { + errors.push(`Missing required asset: ${rel}`); + } + } + + const pageCache = new Map(); + const idCache = new Map(); + + for (const rel of REQUIRED_HTML_PAGES) { + const full = resolve(absRoot, rel); + if (!existsSync(full) || !statSync(full).isFile()) { + errors.push(`Missing required HTML page: ${rel}`); + continue; + } + const html = readFileSync(full, "utf8"); + pageCache.set(full, html); + idCache.set(full, extractIds(html)); + } + + for (const rel of REQUIRED_HTML_PAGES) { + const full = resolve(absRoot, rel); + const html = pageCache.get(full); + if (html === undefined) continue; + pagesChecked++; + + const csp = extractCspContent(html); + if (!csp) { + errors.push(`${rel}: missing Content-Security-Policy tag`); + } else { + if (!/default-src\s+[^;]*'self'/i.test(csp)) { + errors.push(`${rel}: CSP missing default-src 'self'`); + } + if (!/script-src\s+[^;]*'self'/i.test(csp)) { + errors.push(`${rel}: CSP missing script-src 'self'`); + } + if (!/object-src\s+[^;]*'none'/i.test(csp)) { + errors.push(`${rel}: CSP missing object-src 'none'`); + } + if (/'unsafe-eval'/i.test(csp)) { + errors.push(`${rel}: CSP must not allow 'unsafe-eval'`); + } + } + + const pageDir = dirname(full); + for (const ref of extractLocalRefs(html)) { + linksChecked++; + const [rawPath, rawHash] = ref.split("#", 2); + let targetFile = full; + if (rawPath && rawPath.length > 0) { + const candidate = resolve(pageDir, rawPath); + if (!candidate.startsWith(absRoot)) { + errors.push(`${rel}: link escapes website root (${ref})`); + continue; + } + if (existsSync(candidate) && statSync(candidate).isDirectory()) { + targetFile = resolve(candidate, "index.html"); + } else { + targetFile = candidate; + } + if (!existsSync(targetFile) || !statSync(targetFile).isFile()) { + errors.push(`${rel}: broken link target '${ref}'`); + continue; + } + } + if (rawHash && rawHash.length > 0) { + let ids = idCache.get(targetFile); + if (!ids && existsSync(targetFile) && statSync(targetFile).isFile()) { + const targetHtml = readFileSync(targetFile, "utf8"); + ids = extractIds(targetHtml); + idCache.set(targetFile, ids); + } + if (!ids || !ids.has(rawHash)) { + errors.push(`${rel}: broken anchor '#${rawHash}' in '${ref}'`); + } + } + } + } + + return { + ok: errors.length === 0, + pagesChecked, + linksChecked, + errors, + }; +} + +const isDirectRun = + process.argv[1] && + resolve(process.argv[1]) === fileURLToPath(import.meta.url); + +if (isDirectRun) { + const res = verifyWebsiteDirectory(); + if (!res.ok) { + for (const err of res.errors) { + console.error(`Website verification error: ${err}`); + } + process.exit(1); + } + console.log( + `Verified ${res.pagesChecked} website HTML pages and ${res.linksChecked} internal links/assets.`, + ); +} diff --git a/src/cli.ts b/src/cli.ts index 3851d49..f0c83ee 100644 --- a/src/cli.ts +++ b/src/cli.ts @@ -134,6 +134,7 @@ interface ParsedCliArgs { readonly signManifest: boolean; readonly manifestKey?: string; readonly publicKey?: string; + readonly artifactPath?: string; readonly llmDirectives: boolean; readonly weaveDecoys: boolean; readonly selfSeal: boolean; @@ -149,6 +150,9 @@ interface ParsedCliArgs { readonly allowJsWasmHydrateDump: boolean; readonly allowWasmXorMaskSidecar: boolean; readonly allowWasmSealXorKnownPlaintext: boolean; + readonly allowPlaintextString: boolean; + readonly allowSinglePointIntegrity: boolean; + readonly allowMissingBindRuntime: boolean; readonly lang: NativeHeaderLanguage; readonly clients: SupportedAgentClientId[]; readonly allDetected: boolean; @@ -175,6 +179,7 @@ export function parseCliArgs(argv: readonly string[]): ParsedCliArgs { let signManifest = false; let manifestKey: string | undefined; let publicKey: string | undefined; + let artifactPath: string | undefined; let llmDirectives = false; let weaveDecoys = false; let selfSeal = false; @@ -189,6 +194,9 @@ export function parseCliArgs(argv: readonly string[]): ParsedCliArgs { let allowJsWasmHydrateDump = false; let allowWasmXorMaskSidecar = false; let allowWasmSealXorKnownPlaintext = false; + let allowPlaintextString = false; + let allowSinglePointIntegrity = false; + let allowMissingBindRuntime = false; let allowPanelOfflineOracle = false; let lang: NativeHeaderLanguage = "c"; const clients: SupportedAgentClientId[] = []; @@ -231,6 +239,8 @@ export function parseCliArgs(argv: readonly string[]): ParsedCliArgs { manifestKey = argv[++i]!; } else if (arg === "--public-key" && i + 1 < argv.length) { publicKey = argv[++i]!; + } else if (arg === "--artifact" && i + 1 < argv.length) { + artifactPath = argv[++i]!; } else if (arg === "--llm-directives") { llmDirectives = true; } else if (arg === "--weave-decoys") { @@ -259,6 +269,12 @@ export function parseCliArgs(argv: readonly string[]): ParsedCliArgs { allowWasmXorMaskSidecar = true; } else if (arg === "--allow-wasm-seal-xor-known-plaintext") { allowWasmSealXorKnownPlaintext = true; + } else if (arg === "--allow-plaintext-string") { + allowPlaintextString = true; + } else if (arg === "--allow-single-point-integrity") { + allowSinglePointIntegrity = true; + } else if (arg === "--allow-missing-bind-runtime") { + allowMissingBindRuntime = true; } else if (arg.startsWith("--wasm-preserve-exports=")) { wasmPreserveExports = arg .slice("--wasm-preserve-exports=".length) @@ -333,6 +349,7 @@ export function parseCliArgs(argv: readonly string[]): ParsedCliArgs { signManifest, ...(manifestKey !== undefined ? { manifestKey } : {}), ...(publicKey !== undefined ? { publicKey } : {}), + ...(artifactPath !== undefined ? { artifactPath } : {}), llmDirectives, weaveDecoys, selfSeal, @@ -348,6 +365,9 @@ export function parseCliArgs(argv: readonly string[]): ParsedCliArgs { allowJsWasmHydrateDump, allowWasmXorMaskSidecar, allowWasmSealXorKnownPlaintext, + allowPlaintextString, + allowSinglePointIntegrity, + allowMissingBindRuntime, lang, clients, allDetected, @@ -618,6 +638,9 @@ export async function runCli(argv: readonly string[] = process.argv.slice(2)): P allowJsWasmHydrateDump: parsed.allowJsWasmHydrateDump, allowWasmXorMaskSidecar: parsed.allowWasmXorMaskSidecar, allowWasmSealXorKnownPlaintext: parsed.allowWasmSealXorKnownPlaintext, + allowPlaintextString: parsed.allowPlaintextString, + allowSinglePointIntegrity: parsed.allowSinglePointIntegrity, + allowMissingBindRuntime: parsed.allowMissingBindRuntime, allowLaneIndependentGates: parsed.allowLaneIndependentGates, allowPanelOfflineOracle: parsed.allowPanelOfflineOracle, allowStablePanelDeriveAbi: parsed.allowStablePanelDeriveAbi, @@ -635,6 +658,9 @@ export async function runCli(argv: readonly string[] = process.argv.slice(2)): P wasmSealXor: report.details.wasmSealXor.length, lanes: report.details.lanes.length, panelDerive: report.details.panelDerive.length, + plaintextSecrets: report.details.plaintextSecrets.length, + integrityCoverage: report.details.integrityCoverage.length, + bindScope: report.details.bindScope.length, } }, null, 2)); } else { console.log(formatPackagingGatesReport(report)); @@ -966,10 +992,10 @@ export async function runCli(argv: readonly string[] = process.argv.slice(2)): P case "verify-manifest": { const target = parsed.positionals[0]; if (!target) { - console.error("Error: Missing path for `bla verify-manifest [--public-key ]`."); + console.error("Error: Missing path for `bla verify-manifest [--public-key ] [--artifact ]`."); return 1; } - const result = verifyManifestFile(target, parsed.publicKey); + const result = verifyManifestFile(target, parsed.publicKey, parsed.artifactPath); if (parsed.json) { console.log(JSON.stringify(result, null, 2)); } else { diff --git a/src/core/config.ts b/src/core/config.ts index 6d25080..6007843 100644 --- a/src/core/config.ts +++ b/src/core/config.ts @@ -22,6 +22,8 @@ export interface BlaProjectConfig { readonly selfSeal?: boolean; /** Opt-in sidecar/entry entanglement strip⇒fail for JS/Python (issue #40). Parity with CLI `--sidecar-entangle` / MCP `sidecar_entangle`. */ readonly sidecarEntangle?: boolean; + /** Enforce Agent-First Closed-Loop: refuse hardening if source files lack verified Stage 2 surgical weave. */ + readonly requireAgentWeave?: boolean; /** WASM export names that must remain the public ABI when export rename runs (issue #40.3). */ readonly wasmPreserveExports?: readonly string[]; /** When true, allow harden/defend of lane-independent JS gates (issue #40.1). Default false. */ @@ -82,6 +84,8 @@ const BOOLEAN_CONFIG_KEYS = [ "honeySourceMaps", "weaveDecoys", "selfSeal", + "sidecarEntangle", + "requireAgentWeave", "allowLaneIndependentGates", "allowPlaintextSeal", "allowWasmClearParamCarriers", @@ -262,7 +266,7 @@ export function resolveProjectSeed( let targetPath: string; if (loaded.sourcePath && !loaded.sourcePath.endsWith("package.json")) { targetPath = loaded.sourcePath; - const existing = JSON.parse(readFileSync(targetPath, "utf8")) as BlaProjectConfig; + const existing = readConfigFile(targetPath); persistSeed(targetPath, seed, existing); } else { targetPath = join(root, ".blarc"); @@ -280,7 +284,7 @@ export function initBlaConfig( ): { configPath: string; created: boolean; config: BlaProjectConfig } { const configPath = join(resolve(targetDir), "bla.config.json"); if (existsSync(configPath) && !overwrite) { - const existing = JSON.parse(readFileSync(configPath, "utf8")) as BlaProjectConfig; + const existing = readConfigFile(configPath); const merged = { ...DEFAULT_BLA_CONFIG, ...existing }; if (!isUsableSeed(merged.seed)) { const seed = generateProjectSeed(); diff --git a/src/core/detector.ts b/src/core/detector.ts index 732044e..dd99288 100644 --- a/src/core/detector.ts +++ b/src/core/detector.ts @@ -216,7 +216,10 @@ export function detectArtifactFormat(targetPath: string): ArtifactFormat { if ([".html", ".htm"].includes(ext)) return "html-bundle"; if ([".py", ".pyw"].includes(ext)) return "python-source"; if (ext === ".wasm") return "wasm"; - if ([".sqlite", ".sqlite3", ".db"].includes(ext)) return "sqlite"; + // Only unambiguous `.sqlite`/`.sqlite3` extensions fall back without magic so + // corrupt SQLite files still fail closed; generic `.db` files (JSON/hex state, + // LevelDB, etc.) require the `SQLite format 3\0` magic check at step 5 (#130). + if ([".sqlite", ".sqlite3"].includes(ext)) return "sqlite"; if (ext === ".gguf") return "model-gguf"; if (ext === ".dex") return "android-dex"; if ([".plist", ".entitlements", ".mobileprovision"].includes(ext)) return "apple-plist"; diff --git a/src/core/manifest-verify.ts b/src/core/manifest-verify.ts index 5047487..2292343 100644 --- a/src/core/manifest-verify.ts +++ b/src/core/manifest-verify.ts @@ -1,15 +1,17 @@ -import { createPublicKey } from "node:crypto"; -import { readFileSync } from "node:fs"; +import { createHash, createPublicKey } from "node:crypto"; +import { existsSync, readFileSync, statSync } from "node:fs"; import { resolve } from "node:path"; import { verifyManifestSignature } from "./manifest-signing.js"; export interface ManifestVerifyResult { - /** Signature bytes are valid for the payload. */ + /** Signature bytes (and artifact digest, when checked) are valid. */ readonly ok: boolean; /** A signature object is present. */ readonly signed: boolean; /** The caller supplied a trusted public key that matched the embedded key. */ readonly pinned: boolean; + /** True when the protected artifact file's SHA-256 was checked and matched `protectedSha256`. */ + readonly artifactVerified: boolean; readonly reason: string; } @@ -25,21 +27,39 @@ function normalizePublicKeyPem(pem: string): string { * Without `publicKeyPath`, this only proves the manifest was signed by the key * embedded in it (an attacker can re-sign their own edits). Supply * `publicKeyPath` to pin the trusted key. + * + * When `artifactPath` is supplied — or when `.bla-manifest.json` sits + * adjacent to a regular file `` — `protectedSha256` in the manifest is + * also checked against the on-disk artifact bytes. */ export function verifyManifestFile( manifestPath: string, publicKeyPath?: string, + artifactPath?: string, ): ManifestVerifyResult { + const absManifest = resolve(manifestPath); let manifest: Record; try { - const parsed: unknown = JSON.parse(readFileSync(resolve(manifestPath), "utf8")); + const parsed: unknown = JSON.parse(readFileSync(absManifest, "utf8")); if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) { - return { ok: false, signed: false, pinned: false, reason: "manifest must be a JSON object" }; + return { + ok: false, + signed: false, + pinned: false, + artifactVerified: false, + reason: "manifest must be a JSON object", + }; } manifest = parsed as Record; } catch (err) { const message = err instanceof Error ? err.message : String(err); - return { ok: false, signed: false, pinned: false, reason: `cannot read manifest: ${message}` }; + return { + ok: false, + signed: false, + pinned: false, + artifactVerified: false, + reason: `cannot read manifest: ${message}`, + }; } const rawSignature = manifest.signature; @@ -49,14 +69,26 @@ export function verifyManifestFile( typeof rawSignature === "object" && typeof (rawSignature as { value?: unknown }).value === "string"; if (!signed) { - return { ok: false, signed: false, pinned: false, reason: "manifest is unsigned" }; + return { + ok: false, + signed: false, + pinned: false, + artifactVerified: false, + reason: "manifest is unsigned", + }; } let pinned = false; if (publicKeyPath !== undefined) { const embedded = (rawSignature as { publicKey?: unknown }).publicKey; if (typeof embedded !== "string") { - return { ok: false, signed: true, pinned: false, reason: "manifest signature has no public key" }; + return { + ok: false, + signed: true, + pinned: false, + artifactVerified: false, + reason: "manifest signature has no public key", + }; } try { const expected = normalizePublicKeyPem(readFileSync(resolve(publicKeyPath), "utf8")); @@ -67,24 +99,107 @@ export function verifyManifestFile( ok: false, signed: true, pinned: true, + artifactVerified: false, reason: "manifest public key does not match the pinned --public-key", }; } } catch (err) { const message = err instanceof Error ? err.message : String(err); - return { ok: false, signed: true, pinned: false, reason: `cannot read pinned public key: ${message}` }; + return { + ok: false, + signed: true, + pinned: false, + artifactVerified: false, + reason: `cannot read pinned public key: ${message}`, + }; } } - const ok = verifyManifestSignature(manifest); + const sigOk = verifyManifestSignature(manifest); + if (!sigOk) { + return { + ok: false, + signed: true, + pinned, + artifactVerified: false, + reason: "signature invalid", + }; + } + + let resolvedArtifactPath: string | undefined; + if (artifactPath !== undefined) { + resolvedArtifactPath = resolve(artifactPath); + } else if ( + absManifest.endsWith(".bla-manifest.json") && + manifest.detectedFormat !== "directory" + ) { + const adjacent = absManifest.slice(0, -".bla-manifest.json".length); + try { + if (existsSync(adjacent) && statSync(adjacent).isFile()) { + resolvedArtifactPath = adjacent; + } + } catch { + // Ignore inaccessible or non-file adjacent paths when not explicitly requested. + } + } + + let artifactVerified = false; + if (resolvedArtifactPath !== undefined) { + const expectedSha = manifest.protectedSha256; + if (typeof expectedSha !== "string" || !/^[0-9a-f]{64}$/i.test(expectedSha)) { + return { + ok: false, + signed: true, + pinned, + artifactVerified: false, + reason: "manifest is missing a valid 64-hex protectedSha256 field for artifact verification", + }; + } + try { + const st = statSync(resolvedArtifactPath); + if (!st.isFile()) { + return { + ok: false, + signed: true, + pinned, + artifactVerified: false, + reason: `cannot read artifact: ${resolvedArtifactPath} is not a regular file`, + }; + } + const actualSha = createHash("sha256") + .update(readFileSync(resolvedArtifactPath)) + .digest("hex"); + if (actualSha !== expectedSha.toLowerCase()) { + return { + ok: false, + signed: true, + pinned, + artifactVerified: false, + reason: `artifact SHA-256 mismatch (expected ${expectedSha.toLowerCase()}, got ${actualSha})`, + }; + } + artifactVerified = true; + } catch (err) { + const message = err instanceof Error ? err.message : String(err); + return { + ok: false, + signed: true, + pinned, + artifactVerified: false, + reason: `cannot read artifact: ${message}`, + }; + } + } + + const keyNote = pinned + ? "pinned key" + : "embedded key only — pass --public-key to authenticate"; + const artifactNote = artifactVerified ? ", artifact SHA-256 verified" : ""; return { - ok, + ok: true, signed: true, pinned, - reason: ok - ? pinned - ? "signature valid (pinned key)" - : "signature valid (embedded key only — pass --public-key to authenticate)" - : "signature invalid", + artifactVerified, + reason: `signature valid (${keyNote}${artifactNote})`, }; } \ No newline at end of file diff --git a/src/core/output-path.ts b/src/core/output-path.ts index fa0c7b3..bc7c123 100644 --- a/src/core/output-path.ts +++ b/src/core/output-path.ts @@ -11,7 +11,7 @@ function exists(path: string): boolean { } } -function physicalPath(path: string): string { +export function physicalPath(path: string): string { const suffix: string[] = []; let ancestor = path; while (!exists(ancestor)) { diff --git a/src/engine/encrypt-strings.ts b/src/engine/encrypt-strings.ts index 0230ba9..29edd25 100644 --- a/src/engine/encrypt-strings.ts +++ b/src/engine/encrypt-strings.ts @@ -10,6 +10,8 @@ * MCP: bla_encrypt_strings. */ +import { parse } from "@babel/parser"; +import _traverse from "@babel/traverse"; import { createHash } from "node:crypto"; import { existsSync, @@ -27,6 +29,13 @@ import { lintPlaintextSecretsSource, } from "./plaintext-secret-lint.js"; +type UnwrapDefault = T extends { readonly default: infer D } ? D : T; +type TraverseFn = UnwrapDefault; +const traverse: TraverseFn = + typeof _traverse === "function" + ? (_traverse as unknown as TraverseFn) + : (_traverse as unknown as { readonly default: TraverseFn }).default; + export const ENCRYPT_STRINGS_SCHEMA = "bla-encrypt-strings/v1" as const; export interface EncryptStringsOptions { @@ -213,30 +222,127 @@ function shouldEncrypt(lit: string, includeUrls: boolean): boolean { return true; } -function replaceLiteralsInJs( - source: string, - replacements: Map, -): { readonly code: string; readonly count: number } { - let count = 0; - const keys = [...replacements.keys()].sort((a, b) => b.length - a.length); - let code = source; - for (const lit of keys) { - const call = replacements.get(lit)!; - const patterns = [ - JSON.stringify(lit), - `'${lit.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`, - `"${lit.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`, - ]; - for (const p of patterns) { - if (!code.includes(p)) continue; - const parts = code.split(p); - if (parts.length > 1) { - count += parts.length - 1; - code = parts.join(call); - } +interface LiteralSpan { + readonly start: number; + readonly end: number; + readonly value: string; +} + +function isNonReplaceableStringPosition(path: { + readonly node: unknown; + readonly parent: unknown; + readonly parentPath?: { readonly parent: unknown } | null; +}): boolean { + const node = path.node as Record; + const parent = path.parent as Record | null | undefined; + if (!parent) return false; + const pType = parent.type; + + // Module specifiers in import / export declarations + if ( + (pType === "ImportDeclaration" || + pType === "ExportAllDeclaration" || + pType === "ExportNamedDeclaration") && + parent.source === node + ) { + return true; + } + if (pType === "ImportAttribute") { + return true; + } + // TypeScript literal types or module references + if ( + pType === "TSLiteralType" || + pType === "TSExternalModuleReference" || + pType === "TSImportType" + ) { + return true; + } + // Non-computed object / class keys or destructuring pattern keys + if ( + (pType === "ObjectProperty" || + pType === "ObjectMethod" || + pType === "ClassProperty" || + pType === "ClassMethod" || + pType === "TSPropertySignature" || + pType === "TSMethodSignature") && + parent.key === node && + parent.computed !== true + ) { + return true; + } + if (pType === "ObjectProperty" && path.parentPath?.parent) { + const grand = path.parentPath.parent as Record; + if (grand.type === "ObjectPattern") return true; + } + // CommonJS require("...") or dynamic import("...") + if (pType === "CallExpression") { + const callee = parent.callee as Record | undefined; + const args = parent.arguments as unknown[] | undefined; + if ( + args?.[0] === node && + (callee?.type === "Import" || + (callee?.type === "Identifier" && callee.name === "require")) + ) { + return true; } } - return { code, count }; + return false; +} + +function collectJsLiteralSpans(source: string): LiteralSpan[] { + try { + const ast = parse(source, { + sourceType: "unambiguous", + allowReturnOutsideFunction: true, + allowImportExportEverywhere: true, + allowSuperOutsideMethod: true, + plugins: ["typescript", "jsx", "decorators-legacy"], + }); + const spans: LiteralSpan[] = []; + traverse(ast, { + StringLiteral(path) { + if (isNonReplaceableStringPosition(path)) return; + const { start, end, value } = path.node; + if (typeof start === "number" && typeof end === "number") { + spans.push({ start, end, value }); + } + }, + TemplateLiteral(path) { + if ( + path.parent.type === "TaggedTemplateExpression" || + path.node.expressions.length > 0 || + path.node.quasis.length !== 1 || + isNonReplaceableStringPosition(path) + ) { + return; + } + const quasi = path.node.quasis[0]; + const { start, end } = path.node; + const value = quasi?.value.cooked ?? quasi?.value.raw ?? ""; + if (typeof start === "number" && typeof end === "number") { + spans.push({ start, end, value }); + } + }, + }); + spans.sort((a, b) => a.start - b.start); + return spans; + } catch { + // Fallback for non-standard script fragments: match quote/backtick literals while skipping comments + const spans: LiteralSpan[] = []; + const tokenRe = + /\/\/[^\n]*|\/\*[\s\S]*?\*\/|'(?:\\.|[^'\\])*'|"(?:\\.|[^"\\])*"|`(?:\\.|[^`\\$]|\$(?!\{))*`/g; + let m: RegExpExecArray | null; + while ((m = tokenRe.exec(source)) !== null) { + const raw = m[0]!; + if (raw.startsWith("//") || raw.startsWith("/*")) continue; + const [decoded] = extractStringLiterals(raw); + if (decoded !== undefined) { + spans.push({ start: m.index, end: m.index + raw.length, value: decoded }); + } + } + return spans; + } } function transformJsSource( @@ -248,20 +354,28 @@ function transformJsSource( readonly encrypted: string[]; readonly skipped: number; } { - const literals = extractStringLiterals(source); + // Never re-encrypt a file that already carries the _blaS decrypt stub + if (source.includes("var _blaS=") && source.includes("var _blaT=")) { + return { code: source, encrypted: [], skipped: 0 }; + } + + const spans = collectJsLiteralSpans(source); + const replaceable: LiteralSpan[] = []; const unique: string[] = []; const seen = new Set(); let skipped = 0; - for (const lit of literals) { - if (!shouldEncrypt(lit, includeUrls)) { + for (const span of spans) { + if (!shouldEncrypt(span.value, includeUrls)) { skipped += 1; continue; } - if (seen.has(lit)) continue; - seen.add(lit); - unique.push(lit); + replaceable.push(span); + if (!seen.has(span.value)) { + seen.add(span.value); + unique.push(span.value); + } } - if (unique.length === 0) { + if (unique.length === 0 || replaceable.length === 0) { return { code: source, encrypted: [], skipped }; } @@ -276,14 +390,20 @@ function transformJsSource( const ksName = prng.identifier({ style: "camel", hint: "blaK", entropy: 3 }); const stub = buildRuntimeStub(table, keystream, fnName, tableName, ksName); - const replacements = new Map(); + const indexByLiteral = new Map(); unique.forEach((lit, i) => { - replacements.set(lit, `${fnName}(${i})`); + indexByLiteral.set(lit, i); }); - const { code: body, count } = replaceLiteralsInJs(source, replacements); - if (count === 0) { - return { code: source, encrypted: [], skipped }; + + // Splice AST spans in reverse order so earlier offsets stay valid. + let body = source; + const descending = [...replaceable].sort((a, b) => b.start - a.start); + for (const span of descending) { + const idx = indexByLiteral.get(span.value); + if (idx === undefined) continue; + body = `${body.slice(0, span.start)}${fnName}(${idx})${body.slice(span.end)}`; } + // Keep shebang / "use strict" at the very top so Node can still execute the file. const shebangMatch = body.match(/^#![^\n]*\n/); const shebang = shebangMatch ? shebangMatch[0] : ""; diff --git a/src/engine/harden.ts b/src/engine/harden.ts index 12e6451..05d40a5 100644 --- a/src/engine/harden.ts +++ b/src/engine/harden.ts @@ -5,8 +5,9 @@ import { statSync, writeFileSync, } from "node:fs"; -import { basename, dirname, join, relative, resolve, sep } from "node:path"; +import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path"; import { detectArtifactFormat } from "../core/detector.js"; +import { physicalPath } from "../core/output-path.js"; import { walkBounded } from "../core/walk.js"; import type { ArtifactFormat, ProtectionIntensity } from "../core/types.js"; import { BLA_IDENTITY } from "../identity.js"; @@ -336,6 +337,7 @@ function collectRootArtifacts( projectRoot: string, maxArtifacts: number, skipDirs: ReadonlySet, + excludeDir?: string, ): DiscoveredArtifact[] { const formats = new Map(); const files = walkBounded(root, { @@ -346,6 +348,9 @@ function collectRootArtifacts( // Locale-independent name sort so offset paging is stable across platforms. sortEntries: true, accept: (full, name) => { + if (excludeDir && (full === excludeDir || full.startsWith(excludeDir + sep))) { + return false; + } const format = detectArtifactFormat(full); if (!isProtectableFormat(format)) return false; // Skip already-shielded outputs to avoid re-hardening loops. @@ -373,7 +378,7 @@ function collectRootArtifacts( */ export function discoverHardenableArtifacts( directory: string = process.cwd(), - options: { readonly maxArtifacts?: number; readonly offset?: number } = {}, + options: { readonly maxArtifacts?: number; readonly offset?: number; readonly outputDirectory?: string } = {}, ): readonly DiscoveredArtifact[] { return discoverHardenTargets(directory, options).artifacts; } @@ -387,13 +392,14 @@ export function discoverHardenableArtifacts( */ export function discoverHardenTargets( directory: string = process.cwd(), - options: { readonly maxArtifacts?: number; readonly offset?: number } = {}, + options: { readonly maxArtifacts?: number; readonly offset?: number; readonly outputDirectory?: string } = {}, ): HardenDiscoveryResult { const abs = resolve(directory); const maxArtifacts = Math.max(1, Math.floor(options.maxArtifacts ?? MAX_DISCOVERED_ARTIFACTS)); const offset = Math.max(0, Math.floor(options.offset ?? 0)); + const excludeDir = options.outputDirectory ? resolve(options.outputDirectory) : undefined; // Collect one past the page end so truncated/nextOffset stay honest. - const all = collectHardenableArtifacts(abs, offset + maxArtifacts + 1); + const all = collectHardenableArtifacts(abs, offset + maxArtifacts + 1, excludeDir); const page = all.slice(offset, offset + maxArtifacts); const truncated = all.length > offset + maxArtifacts; return { @@ -409,6 +415,7 @@ export function discoverHardenTargets( function collectHardenableArtifacts( abs: string, maxArtifacts: number, + excludeDir?: string, ): readonly DiscoveredArtifact[] { if (!existsSync(abs)) { throw new Error(`Path not found: ${abs}`); @@ -430,11 +437,11 @@ function collectHardenableArtifacts( for (const root of preferred) { const remaining = maxArtifacts - found.length; if (remaining <= 0) break; - found.push(...collectRootArtifacts(root, abs, remaining, SKIP_DIR_NAMES)); + found.push(...collectRootArtifacts(root, abs, remaining, SKIP_DIR_NAMES, excludeDir)); } if (includeProjectRootSupplemental && found.length < maxArtifacts) { found.push( - ...collectRootArtifacts(abs, abs, maxArtifacts - found.length, SUPPLEMENTAL_SKIP_DIR_NAMES), + ...collectRootArtifacts(abs, abs, maxArtifacts - found.length, SUPPLEMENTAL_SKIP_DIR_NAMES, excludeDir), ); } // De-dupe by absolute path (cargo release may overlap target/) @@ -473,8 +480,37 @@ export function hardenProject( } const maxArtifacts = options.maxArtifacts ?? MAX_DISCOVERED_ARTIFACTS; + const outputRoot = resolve( + options.outputDirectory ?? + (existsSync(absDir) && statSync(absDir).isDirectory() + ? join(absDir, ".bla-hardened") + : join(dirname(absDir), ".bla-hardened")), + ); + + if (options.outputDirectory) { + if (existsSync(absDir)) { + const physSrc = physicalPath(absDir); + const physOut = physicalPath(outputRoot); + if (physSrc === physOut) { + throw new Error( + "Output directory must not be the input directory; in-place project hardening is not supported.", + ); + } + } + const relFromProject = relative(absDir, outputRoot); + const checkSegments = + !isAbsolute(relFromProject) && !relFromProject.startsWith("..") + ? relFromProject.split(/[\\/]+/).filter(Boolean) + : [basename(outputRoot)]; + for (const seg of checkSegments) { + if (seg === ".git" || seg === "node_modules" || seg === ".hg" || seg === ".svn") { + throw new Error(`Refusing to use protected directory as output: ${outputRoot}`); + } + } + } + const dryRun = options.dryRun === true; - const discovery = discoverHardenTargets(absDir, { maxArtifacts }); + const discovery = discoverHardenTargets(absDir, { maxArtifacts, outputDirectory: outputRoot }); const discovered = discovery.artifacts; const packagingBlocks = evaluateHardenProjectPackagingBlocks({ @@ -493,12 +529,6 @@ export function hardenProject( const blockingJsHydrateDump = packagingBlocks.blockingJsHydrateDump; const blockingWasmXorMask = packagingBlocks.blockingWasmXorMask; const blockingWasmSealXor = packagingBlocks.blockingWasmSealXor; - const outputRoot = resolve( - options.outputDirectory ?? - (statSync(absDir).isDirectory() - ? join(absDir, ".bla-hardened") - : join(dirname(absDir), ".bla-hardened")), - ); let plannedOutputs = discovered.map((artifact) => { const outputPath = planArtifactOutputPath(artifact, outputRoot); return { artifact, outputPath, outputExisted: existsSync(outputPath) }; diff --git a/src/engine/protector.ts b/src/engine/protector.ts index 64a863c..80385c5 100644 --- a/src/engine/protector.ts +++ b/src/engine/protector.ts @@ -8,6 +8,7 @@ import { readFileSync, readdirSync, renameSync, + rmSync, statSync, unlinkSync, writeFileSync, @@ -963,16 +964,27 @@ function protectTargetInner(options: ProtectionOptions): ProtectionResult { binarySectionsPatched = res.blocksInjected; counteredVectors.add("uf2-firmware-inspection"); } else if (format === "directory") { + const outputExistedBefore = existsSync(absOutput); mkdirSync(absOutput, { recursive: true }); const walkAndProtect = (srcDir: string, dstDir: string): void => { mkdirSync(dstDir, { recursive: true }); for (const entry of readdirSync(srcDir, { withFileTypes: true })) { - if (entry.name === "node_modules" || entry.name === ".git") continue; + if ( + entry.name === "node_modules" || + entry.name === ".git" || + entry.name === ".hg" || + entry.name === ".svn" || + entry.name === ".bla-hardened" || + entry.name === "__pycache__" + ) { + continue; + } + if (entry.isSymbolicLink()) continue; const srcFull = join(srcDir, entry.name); const dstFull = join(dstDir, entry.name); if (entry.isDirectory()) { walkAndProtect(srcFull, dstFull); - } else { + } else if (entry.isFile()) { const ext = extname(entry.name).toLowerCase(); if ([".js", ".ts", ".mjs", ".cjs", ".jsx", ".tsx"].includes(ext)) { const raw = readFileSync(srcFull, "utf8"); @@ -980,6 +992,7 @@ function protectTargetInner(options: ProtectionOptions): ProtectionResult { intensity, seed: `${seed}:${entry.name}`, filename: entry.name, + llmDirectives: options.llmDirectives, ...(selfSealTransformOption(options, absOutput) !== undefined ? { selfSeal: selfSealTransformOption(options, absOutput)! } : {}), }); const honey = generateHoneySourceMap( @@ -1007,6 +1020,21 @@ function protectTargetInner(options: ProtectionOptions): ProtectionResult { intensity, seed: `${seed}:${entry.name}`, honeySourceMaps: options.honeySourceMaps, + llmDirectives: options.llmDirectives, + weaveDecoys: options.weaveDecoys, + selfSeal: options.selfSeal, + sidecarEntangle: options.sidecarEntangle, + wasmPreserveExports: options.wasmPreserveExports, + allowLaneIndependentGates: options.allowLaneIndependentGates, + allowPlaintextSeal: options.allowPlaintextSeal, + allowWasmClearParamCarriers: options.allowWasmClearParamCarriers, + allowStablePanelDeriveAbi: options.allowStablePanelDeriveAbi, + allowJsAesUnwrap: options.allowJsAesUnwrap, + allowPanelOfflineOracle: options.allowPanelOfflineOracle, + allowJsWasmHydrateDump: options.allowJsWasmHydrateDump, + allowWasmXorMaskSidecar: options.allowWasmXorMaskSidecar, + allowWasmSealXorKnownPlaintext: options.allowWasmSealXorKnownPlaintext, + selfSealSiblingPaths: options.selfSealSiblingPaths, }); decoyFunctionsInjected += subRes.metrics.decoyFunctionsInjected; fakeCrossReferencesCreated += subRes.metrics.fakeCrossReferencesCreated; @@ -1030,7 +1058,18 @@ function protectTargetInner(options: ProtectionOptions): ProtectionResult { } } }; - walkAndProtect(absInput, absOutput); + try { + walkAndProtect(absInput, absOutput); + } catch (err) { + if (!outputExistedBefore) { + try { + rmSync(absOutput, { recursive: true, force: true }); + } catch { + // Preserve the original child protection failure if cleanup fails. + } + } + throw err; + } counteredVectors.add("js-static-semantics"); counteredVectors.add("electron-ipc-bridge"); counteredVectors.add("js-route-rpc-inventory"); diff --git a/src/mcp/server.ts b/src/mcp/server.ts index 8c4e5ef..7cabd48 100644 --- a/src/mcp/server.ts +++ b/src/mcp/server.ts @@ -834,6 +834,14 @@ export const BLA_MCP_TOOLS: readonly McpToolDefinition[] = Object.freeze([ type: "boolean", description: "Treat cleartext sensitive literals as non-blocking (lab only)", }, + allow_single_point_integrity: { + type: "boolean", + description: "Treat single-point integrity coverage as non-blocking (lab only)", + }, + allow_missing_bind_runtime: { + type: "boolean", + description: "Treat missing/narrow bind runtime scope as non-blocking (lab only)", + }, }, additionalProperties: false, }, @@ -1526,6 +1534,12 @@ function runPackagingGatesLint(args: Record): PackagingGatesRep ...(args.allow_plaintext_string === true ? { allowPlaintextString: true } : {}), + ...(args.allow_single_point_integrity === true + ? { allowSinglePointIntegrity: true } + : {}), + ...(args.allow_missing_bind_runtime === true + ? { allowMissingBindRuntime: true } + : {}), }); } diff --git a/src/shields/formats/sqlite.ts b/src/shields/formats/sqlite.ts index f33d76e..98395b0 100644 --- a/src/shields/formats/sqlite.ts +++ b/src/shields/formats/sqlite.ts @@ -233,11 +233,22 @@ function snapshotBusinessTables( const digests: BusinessTableDigest[] = []; for (const { name } of tables) { if (isHoneyTableName(name)) continue; - const rows = db - .prepare(`SELECT * FROM ${quoteIdentifier(name)} ORDER BY rowid`) - .all(); + let rows: unknown[]; + try { + rows = db + .prepare(`SELECT * FROM ${quoteIdentifier(name)} ORDER BY rowid`) + .all(); + } catch { + rows = db + .prepare(`SELECT * FROM ${quoteIdentifier(name)}`) + .all(); + } const hash = createHash("sha256") - .update(JSON.stringify(rows)) + .update( + JSON.stringify(rows, (_k, v) => + typeof v === "bigint" ? v.toString() : v, + ), + ) .digest("hex"); digests.push({ name, diff --git a/src/shields/weave/weave-decoy.ts b/src/shields/weave/weave-decoy.ts index 2d6b60f..bb9a775 100644 --- a/src/shields/weave/weave-decoy.ts +++ b/src/shields/weave/weave-decoy.ts @@ -1441,6 +1441,11 @@ function walkWeaveCandidateFiles( if (/\.shielded(\.|$)/i.test(ent.name)) continue; const ext = extname(ent.name).toLowerCase(); if (INTERESTING_EXT.has(ext) || ent.name === "global-metadata.dat") { + // Generic `.db` files may be non-SQLite runtime state (#130); only include + // them as weave candidates when format detection recognizes them. + if (ext === ".db" && detectArtifactFormat(full) === "unknown") { + continue; + } out.push(full); } } diff --git a/tests/blarc-config-validation.test.ts b/tests/blarc-config-validation.test.ts index ad0b657..c9c4819 100644 --- a/tests/blarc-config-validation.test.ts +++ b/tests/blarc-config-validation.test.ts @@ -2,7 +2,7 @@ import { mkdtempSync, rmSync, writeFileSync } from "node:fs"; import { tmpdir } from "node:os"; import { join } from "node:path"; import { afterEach, describe, expect, it } from "vitest"; -import { loadBlaConfig } from "../src/core/config.js"; +import { initBlaConfig, loadBlaConfig, resolveProjectSeed } from "../src/core/config.js"; const tempDirs: string[] = []; function createTempDir(): string { @@ -43,10 +43,25 @@ describe(".blarc/config validation", () => { expect(() => loadBlaConfig(dir)).toThrow(/intensity.*stealth, balanced, maximum, bankrupt/); }); - it("fails loudly on a non-boolean boolean field", () => { + it("fails loudly on a non-boolean boolean field including sidecarEntangle and requireAgentWeave", () => { const dir = createTempDir(); writeFileSync(join(dir, ".blarc"), JSON.stringify({ selfSeal: "yes" }), "utf8"); expect(() => loadBlaConfig(dir)).toThrow(/selfSeal.*boolean/); + + writeFileSync(join(dir, ".blarc"), JSON.stringify({ sidecarEntangle: 1 }), "utf8"); + expect(() => loadBlaConfig(dir)).toThrow(/sidecarEntangle.*boolean/); + + writeFileSync(join(dir, ".blarc"), JSON.stringify({ requireAgentWeave: "true" }), "utf8"); + expect(() => loadBlaConfig(dir)).toThrow(/requireAgentWeave.*boolean/); + }); + + it("validates existing config when resolveProjectSeed or initBlaConfig runs", () => { + const dir = createTempDir(); + writeFileSync(join(dir, ".blarc"), "{ malformed", "utf8"); + expect(() => resolveProjectSeed(dir)).toThrow(/Invalid BLA config at .*\.blarc/); + + writeFileSync(join(dir, "bla.config.json"), "{ malformed", "utf8"); + expect(() => initBlaConfig(dir)).toThrow(/Invalid BLA config at .*bla\.config\.json/); }); it("rejects config files above the size cap", () => { diff --git a/tests/core-domain.test.ts b/tests/core-domain.test.ts index 7ebc5ff..de4a695 100644 --- a/tests/core-domain.test.ts +++ b/tests/core-domain.test.ts @@ -25,15 +25,21 @@ describe("core domain modules previously without dedicated tests", () => { const py = path.join(dir, "app.py"); const wasm = path.join(dir, "core.wasm"); const sqlite = path.join(dir, "db.sqlite"); + const sqliteDb = path.join(dir, "db-with-magic.db"); + const opaqueDb = path.join(dir, "runtime-output.db"); const missing = path.join(dir, "nope.xyz"); fs.writeFileSync(py, "x = 1\n", "utf8"); fs.writeFileSync(wasm, Buffer.from([0x00, 0x61, 0x73, 0x6d]), "utf8"); fs.writeFileSync(sqlite, Buffer.from("SQLite format 3\0"), "utf8"); + fs.writeFileSync(sqliteDb, Buffer.from("SQLite format 3\0"), "utf8"); + fs.writeFileSync(opaqueDb, "not a database\n", "utf8"); fs.mkdirSync(path.join(dir, "sub")); expect(detectArtifactFormat(py)).toBe("python-source"); expect(detectArtifactFormat(wasm)).toBe("wasm"); expect(detectArtifactFormat(sqlite)).toBe("sqlite"); + expect(detectArtifactFormat(sqliteDb)).toBe("sqlite"); + expect(detectArtifactFormat(opaqueDb)).toBe("unknown"); expect(detectArtifactFormat(missing)).toBe("unknown"); expect(detectArtifactFormat(path.join(dir, "sub"))).toBe("directory"); }); diff --git a/tests/directory-fail-open.test.ts b/tests/directory-fail-open.test.ts index da72376..520542c 100644 --- a/tests/directory-fail-open.test.ts +++ b/tests/directory-fail-open.test.ts @@ -1,8 +1,11 @@ -import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"; +import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"; import { tmpdir } from "node:os"; import { join } from "node:path"; import { afterEach, describe, expect, it } from "vitest"; import { protectTarget } from "../src/engine/protector.js"; +import { buildWeavePlan } from "../src/shields/weave/weave-decoy.js"; +import { isNodeSqliteAvailable, getDatabaseSyncClass } from "../src/core/sqlite-runtime.js"; +import { protectSqliteBuffer } from "../src/shields/formats/sqlite.js"; const tempDirs: string[] = []; function createTempDir(): string { @@ -18,9 +21,10 @@ afterEach(() => { }); describe("directory protection reports child failures instead of copying unprotected bytes", () => { - it("fails loudly when a detected child artifact cannot be protected", () => { + it("fails loudly when a detected child artifact cannot be protected and cleans up partial output directory", () => { const dir = createTempDir(); const input = join(dir, "in"); + const output = join(dir, "out"); mkdirSync(input, { recursive: true }); writeFileSync(join(input, "app.js"), "const x = 1;\n", "utf8"); // Invalid WASM magic bytes: format detection routes this to the WASM shield, @@ -31,10 +35,11 @@ describe("directory protection reports child failures instead of copying unprote expect(() => protectTarget({ inputPath: input, - outputPath: join(dir, "out"), + outputPath: output, intensity: "balanced", }), ).toThrow(/Directory protection failed for 'broken\.wasm'/); + expect(existsSync(output)).toBe(false); }); it("still copies non-protectable file types as a documented pass-through", () => { @@ -54,4 +59,49 @@ describe("directory protection reports child failures instead of copying unprote expect(result.detectedFormat).toBe("directory"); expect(readFileSync(join(output, "notes.txt"), "utf8")).toBe("plain text asset"); }); + + it("copies .db files without the SQLite magic instead of aborting the directory", () => { + const dir = createTempDir(); + const input = join(dir, "in"); + const output = join(dir, "out"); + mkdirSync(input, { recursive: true }); + writeFileSync(join(input, "app.js"), "const x = 1;\n", "utf8"); + writeFileSync(join(input, "runtime-output.db"), "hex-encoded json\n", "utf8"); + + const result = protectTarget({ + inputPath: input, + outputPath: output, + intensity: "balanced", + }); + + expect(result.detectedFormat).toBe("directory"); + expect(readFileSync(join(output, "runtime-output.db"), "utf8")).toBe("hex-encoded json\n"); + + // Weave planner also ignores non-SQLite .db files so overallStatus is not downgraded + const plan = buildWeavePlan(input); + expect(plan.targets.map((t) => t.relativePath)).toEqual(["app.js"]); + expect(plan.overallStatus).toBe("ready"); + }); + + it("protects SQLite databases containing WITHOUT ROWID tables", () => { + if (!isNodeSqliteAvailable()) return; + const dir = createTempDir(); + const dbPath = join(dir, "without-rowid.db"); + const DatabaseSync = getDatabaseSyncClass(); + const db = new DatabaseSync(dbPath); + db.exec(` + PRAGMA journal_mode = DELETE; + CREATE TABLE kv_store ( + k TEXT PRIMARY KEY, + v TEXT NOT NULL + ) WITHOUT ROWID; + INSERT INTO kv_store (k, v) VALUES ('tier', 'pro'); + `); + db.close(); + + const raw = readFileSync(dbPath); + const res = protectSqliteBuffer(raw, { intensity: "balanced", seed: "without-rowid-seed" }); + expect(res.honeyTablesInjected).toBeGreaterThanOrEqual(5); + expect(res.businessDataState).toBe("business-data-preserved"); + }); }); diff --git a/tests/encrypt-strings.test.ts b/tests/encrypt-strings.test.ts index 0b3c96e..ebd2ca9 100644 --- a/tests/encrypt-strings.test.ts +++ b/tests/encrypt-strings.test.ts @@ -115,4 +115,43 @@ module.exports = { unlock }; expect(report.status).toBe("noop"); expect(report.totalEncrypted).toBe(0); }); + + it("uses AST spans so comments and object keys are preserved while backtick templates are encrypted", () => { + const dir = mkdtempSync(join(tmpdir(), "bla-enc-ast-")); + const secret = "FLAG{ast_span_safe_secret_value_012345}"; + const tmplSecret = "FLAG{template_literal_secret_67890}"; + const src = [ + `// Comment mentioning "${secret}" must not be rewritten into invalid JS`, + `const map = { "${secret}": "preserve-key-only" };`, + `const val = "${secret}";`, + `const tmpl = \`${tmplSecret}\`;`, + `module.exports = { map, val, tmpl };`, + ].join("\n"); + writeFileSync(join(dir, "license.cjs"), src, "utf8"); + + const report = encryptStrings({ + path: dir, + seed: "ast-seed", + outDir: join(dir, "out"), + }); + expect(report.status).toBe("ok"); + expect(report.totalEncrypted).toBe(2); + + const out = readFileSync(join(dir, "out", "license.cjs"), "utf8"); + expect(out).toContain(`// Comment mentioning "${secret}"`); + expect(out).toContain(`"${secret}": "preserve-key-only"`); + expect(out).not.toContain(`\`${tmplSecret}\``); + + const mod = require(join(dir, "out", "license.cjs")); + expect(mod.val).toBe(secret); + expect(mod.tmpl).toBe(tmplSecret); + + // Re-running on an already encrypted output is idempotent (noop) + const second = encryptStrings({ + path: join(dir, "out"), + seed: "ast-seed", + outDir: join(dir, "out2"), + }); + expect(second.status).toBe("noop"); + }); }); diff --git a/tests/output-path-safety.test.ts b/tests/output-path-safety.test.ts index 95c13e5..43f3d36 100644 --- a/tests/output-path-safety.test.ts +++ b/tests/output-path-safety.test.ts @@ -11,6 +11,7 @@ import { tmpdir } from "node:os"; import { join } from "node:path"; import { afterEach, describe, expect, it } from "vitest"; import { protectTarget } from "../src/engine/protector.js"; +import { hardenProject } from "../src/engine/harden.js"; const tempDirs: string[] = []; @@ -109,4 +110,26 @@ describe("protectTarget output path safety", () => { }); expect(readFileSync(inputFile, "utf8")).not.toBe(original); }); + + it("excludes custom outputDirectory from hardenProject discovery and rejects project root or .git/.node_modules outputDirectory", () => { + const root = makeTempDir(); + mkdirSync(join(root, "dist"), { recursive: true }); + writeFileSync(join(root, "dist", "app.js"), "export const x = 1;\n", "utf8"); + + expect(() => + hardenProject({ directory: root, outputDirectory: root }), + ).toThrow(/Output directory must not be the input directory/); + + expect(() => + hardenProject({ directory: root, outputDirectory: join(root, ".git", "out") }), + ).toThrow(/Refusing to use protected directory as output/); + + const customOut = join(root, "custom-hardened"); + const first = hardenProject({ directory: root, outputDirectory: customOut }); + expect(first.hardenedCount).toBe(1); + + // Re-running with the same custom outputDirectory must not re-discover custom-hardened/* + const second = hardenProject({ directory: root, outputDirectory: customOut }); + expect(second.hardenedCount).toBe(1); + }); }); diff --git a/tests/verify-manifest-command.test.ts b/tests/verify-manifest-command.test.ts index 21261e4..66e085a 100644 --- a/tests/verify-manifest-command.test.ts +++ b/tests/verify-manifest-command.test.ts @@ -84,4 +84,41 @@ describe("bla verify-manifest", () => { writeFileSync(manifestPath, JSON.stringify({ a: 1 }), "utf8"); await expect(runCli(["verify-manifest", manifestPath, "--json"])).resolves.toBe(2); }); + + it("verifies adjacent file artifact SHA-256 and detects post-sign artifact tampering", async () => { + const dir = createTempDir(); + const pair = generateManifestSigningKeyPair(); + const artifactPath = join(dir, "bundle.shielded.js"); + const manifestPath = `${artifactPath}.bla-manifest.json`; + const publicKeyPath = join(dir, "public.pem"); + const content = "const x = 42;\n"; + writeFileSync(artifactPath, content, "utf8"); + const { createHash } = await import("node:crypto"); + const sha = createHash("sha256").update(content).digest("hex"); + const signed = signManifestPayload( + { + schema: "https://bla.tools/schemas/defense-manifest-v1.json", + blaVersion: "3.1.0", + protectedSha256: sha, + }, + pair.privateKeyPem, + ); + writeFileSync(manifestPath, JSON.stringify(signed, null, 2), "utf8"); + writeFileSync(publicKeyPath, pair.publicKeyPem, "utf8"); + + const okRes = verifyManifestFile(manifestPath, publicKeyPath); + expect(okRes).toMatchObject({ + ok: true, + signed: true, + pinned: true, + artifactVerified: true, + }); + + // Tamper with the artifact without changing the signed manifest + writeFileSync(artifactPath, "const x = 999;\n", "utf8"); + const badRes = verifyManifestFile(manifestPath, publicKeyPath); + expect(badRes.ok).toBe(false); + expect(badRes.artifactVerified).toBe(false); + expect(badRes.reason).toMatch(/artifact SHA-256 mismatch/); + }); }); \ No newline at end of file diff --git a/tests/website-integrity.test.ts b/tests/website-integrity.test.ts new file mode 100644 index 0000000..e2ed726 --- /dev/null +++ b/tests/website-integrity.test.ts @@ -0,0 +1,42 @@ +import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from "node:fs"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { afterEach, describe, expect, it } from "vitest"; +import { verifyWebsiteDirectory } from "../scripts/verify-website.mjs"; + +const tempDirs: string[] = []; +function createTempDir(): string { + const dir = mkdtempSync(join(tmpdir(), "bla-website-verify-")); + tempDirs.push(dir); + return dir; +} + +afterEach(() => { + for (const dir of tempDirs.splice(0)) { + rmSync(dir, { recursive: true, force: true }); + } +}); + +describe("website static verification", () => { + it("passes on the repository website directory", () => { + const res = verifyWebsiteDirectory(); + expect(res.ok).toBe(true); + expect(res.errors).toEqual([]); + expect(res.pagesChecked).toBe(7); + expect(res.linksChecked).toBeGreaterThan(50); + }); + + it("flags missing CSP or broken internal links", () => { + const dir = createTempDir(); + mkdirSync(join(dir, "assets"), { recursive: true }); + writeFileSync( + join(dir, "index.html"), + "x", + "utf8", + ); + const res = verifyWebsiteDirectory(dir); + expect(res.ok).toBe(false); + expect(res.errors.some((e) => e.includes("missing Content-Security-Policy"))).toBe(true); + expect(res.errors.some((e) => e.includes("broken link target 'missing.html'"))).toBe(true); + }); +});