javascript-solid-server 0.0.209 → 0.0.212

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.
@@ -1,58 +1,14 @@
1
1
  {
2
2
  "permissions": {
3
3
  "allow": [
4
+ "Bash(node bin/jss.js start:*)",
5
+ "Bash(node:*)",
6
+ "Bash(source ~/.nvm/nvm.sh)",
7
+ "Bash(nvm use:*)",
4
8
  "Bash(gh issue *)",
5
- "Bash(sort -t: -k3 -n)",
6
- "Bash(sed -n '1,30p' docs/features/overview.md)",
7
- "Bash(npm run *)",
8
- "Bash(git add *)",
9
- "Bash(git commit -q -m 'docs: add Account Management page with API endpoints \\(#23\\) *)",
10
- "Bash(git push *)",
11
- "Bash(gh pr create --title 'docs: Account Management page \\(change password, backup/export, delete\\) — closes #23' --body ' *)",
12
- "Bash(gh pr *)",
13
- "Bash(git checkout *)",
14
- "Bash(git pull *)",
15
- "Bash(gh api *)",
16
- "Bash(git fetch *)",
17
- "Bash(grep *)",
18
- "Bash(node --check src/cli/install.js)",
19
- "Bash(git commit -q -m 'fix\\(install\\): drop spawnSync\\('\\\\''rm'\\\\''\\) shell-out for fs.rmSync — works on Windows *)",
20
- "Bash(node --test --test-concurrency=1 test/turtle.test.js)",
21
- "Bash(npm test *)",
22
- "Bash(git commit -q -m 'fix\\(rdf\\): preserve blank-node SUBJECTS through Turtle ↔ JSON-LD \\(#536\\) *)",
23
- "Bash(npm view *)",
24
- "Bash(git branch *)",
25
- "Bash(git commit -q -m 'bump version to 0.0.205 *)",
26
- "Bash(gh repo *)",
27
- "Bash(curl -sL https://raw.githubusercontent.com/JavaScriptSolidServer/solid-oidc/gh-pages/example.html)",
28
- "Bash(curl -sL https://raw.githubusercontent.com/JavaScriptSolidServer/solid-oidc/gh-pages/solid-oidc.js)",
29
- "Bash(mkdir -p /tmp/jss-sanity-23)",
30
- "Read(//tmp/**)",
31
- "Bash(DATA_ROOT=. node /home/melvin/remote/github.com/JavaScriptSolidServer/JavaScriptSolidServer/bin/jss.js start --idp --conneg --port 4901 --quiet)",
32
- "Bash(curl -si -c /tmp/jss-sanity-cookies.txt -b /tmp/jss-sanity-cookies.txt \"http://localhost:4901/idp/interaction/Qp-9Nn6O9Rv79dlCsI9YWGlXNZZswTi4UUJ2PjXt4x3\")",
33
- "Bash(curl -s -c /tmp/jss-sanity-cookies.txt -b /tmp/jss-sanity-cookies.txt \"http://localhost:4901/idp/interaction/Qp-9Nn6O9Rv79dlCsI9YWGlXNZZswTi4UUJ2PjXt4x3\")",
34
- "Bash(kill bx5n5fpi1 *)",
35
- "Bash(pkill -f \"jss.js start --idp --port 4901\")",
36
- "Bash(rm -f /tmp/jss-sanity-cookies.txt)",
37
- "Bash(rm -rf /tmp/jss-sanity-23)",
38
- "Bash(gh label *)",
39
- "Bash(git commit -q -m 'fix\\(idp\\): handleSchnorrComplete recovers from interactionFinished throw — no more 504 hang \\(#412\\) *)",
40
- "Bash(sed -n '163,170p' src/idp/interactions.js)",
41
- "Bash(sed -n '283,295p' src/idp/interactions.js)",
42
- "Bash(sed -n '600,610p' src/idp/interactions.js)",
43
- "Bash(sed -n '638,650p' src/idp/interactions.js)",
44
- "Bash(wait)",
45
- "Bash(node --test --test-concurrency=1 test/schnorr-complete-defensive.test.js)",
46
- "Bash(git commit -q -m 'review fixes \\(#539\\): stop leaking err.message + add regression tests *)",
47
- "Bash(git commit -q -m 'review pass-3 \\(#539\\): log payload preserves stack + mock matches Node behaviour *)",
48
- "Bash(git commit -q -m 'refactor\\(idp\\): sweep hijack-then-throw defensive pattern across all 5 interaction handlers \\(#526\\) *)",
49
- "Bash(npm audit *)",
50
- "Bash(node --check src/index.js)",
51
- "Bash(node --check src/server.js)",
52
- "Bash(node --test --test-concurrency=1 test/body-limit.test.js)",
53
- "Bash(git commit -q -m 'feat: configurable bodyLimit via createServer / --body-limit / JSS_BODY_LIMIT \\(#474\\) *)",
54
- "Bash(git commit -q -m 'review fixes \\(#543\\): unused imports + DATA_ROOT pollution + clearer comment *)",
55
- "Bash(node --test --test-concurrency=1 test/ssrf.test.js)"
9
+ "Bash(GIT_CONFIG_NOSYSTEM=1 gh issue *)",
10
+ "Bash(GIT_CONFIG_NOSYSTEM=1 gh auth status)",
11
+ "Bash(git -C /home/melvin/remote/github.com/JavaScriptSolidServer/JavaScriptSolidServer remote -v)"
56
12
  ]
57
13
  }
58
14
  }
@@ -160,7 +160,7 @@ Server: pub http://localhost:4443/alice/public/data.json (on change)
160
160
  | `--ap-display-name <name>` | ActivityPub display name | (username) |
161
161
  | `--ap-summary <text>` | ActivityPub bio/summary | - |
162
162
  | `--ap-nostr-pubkey <hex>` | Nostr pubkey for identity linking | - |
163
- | `--public` | Allow unauthenticated access (skip WAC) | false |
163
+ | `--public` | Allow unauthenticated access (skip WAC); never writes into the served directory (no landing-page seed) | false |
164
164
  | `--read-only` | Disable PUT/DELETE/PATCH methods | false |
165
165
  | `--live-reload` | Auto-refresh browser on file changes | false |
166
166
  | `--pay` | Enable HTTP 402 paid access for /pay/* | false |
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "javascript-solid-server",
3
- "version": "0.0.209",
3
+ "version": "0.0.212",
4
4
  "description": "A minimal, fast Solid server",
5
5
  "main": "src/index.js",
6
6
  "type": "module",
@@ -12,21 +12,52 @@ import { secp256k1 } from '@noble/curves/secp256k1';
12
12
  /** Multicodec varint for secp256k1-pub: 0xe7 0x01 → "e701" hex. */
13
13
  const MULTICODEC_SECP256K1_PUB_HEX = 'e701';
14
14
 
15
+ /**
16
+ * The two valid y-coordinates (64-char hex) for a secp256k1 x: the
17
+ * even-parity point and its odd-parity reflection. Returns `null` if
18
+ * `xHex` isn't a valid curve x.
19
+ *
20
+ * Both parities are in-spec for did:nostr: the spec
21
+ * (https://nostrcg.github.io/did-nostr/) states "Nostr applications
22
+ * may generate keys with either 0x02 or 0x03 prefixes" — 0x02 for an
23
+ * even y, 0x03 for an odd y. So a verification method that encodes the
24
+ * same x-only Nostr identity can legitimately carry either parity, and
25
+ * key matching accepts either while still requiring `(x, y)` to be a
26
+ * real on-curve point. See issue #571.
27
+ */
28
+ export function nostrJwkYParities(xHex) {
29
+ if (typeof xHex !== 'string') return null;
30
+ const x = xHex.toLowerCase();
31
+ if (!/^[0-9a-f]{64}$/.test(x)) return null;
32
+ try {
33
+ const even = secp256k1.ProjectivePoint.fromHex('02' + x).toAffine().y;
34
+ const odd = secp256k1.ProjectivePoint.fromHex('03' + x).toAffine().y;
35
+ return [
36
+ even.toString(16).padStart(64, '0'),
37
+ odd.toString(16).padStart(64, '0'),
38
+ ];
39
+ } catch {
40
+ return null;
41
+ }
42
+ }
43
+
15
44
  /**
16
45
  * Validate a secp256k1 JWK as a Nostr key and return its x-only
17
46
  * pubkey hex. Returns `null` if the JWK isn't a Nostr-shaped key
18
- * or its `y` doesn't match the BIP-340 canonical (even-y) point
19
- * for the declared `x`.
47
+ * or its `y` isn't an on-curve point (either parity) for the
48
+ * declared `x`.
20
49
  *
21
- * Why y matters: every secp256k1 x has TWO valid points (positive
22
- * and negative y). Nostr uses x-only pubkeys, which by BIP-340
23
- * convention always pick the even-y point. A profile that declares
24
- * a JWK with the right x but the wrong y is NOT the user's Nostr
25
- * key — accepting it would let an attacker plant a JWK at someone
26
- * else's WebID and have the indexer publish it as theirs.
50
+ * Why y matters: every secp256k1 x has TWO valid points (even and
51
+ * odd y). Nostr identities are x-only, so the x coordinate IS the
52
+ * identity — but a profile that declares a JWK with the right x and a
53
+ * *fabricated* (off-curve) y is malformed and must be rejected, else
54
+ * an attacker could plant arbitrary key material at someone else's
55
+ * WebID and have the indexer publish it. We therefore require y to be
56
+ * one of the two genuine on-curve y's, accepting either parity per the
57
+ * did:nostr spec (see `nostrJwkYParities` / issue #571).
27
58
  *
28
- * The verifier in src/auth/nostr.js (jwkMatchesNostrPubkey) does
29
- * the same check. Keeping the indexer in sync prevents the
59
+ * The verifier in src/auth/nostr.js (jwkMatchesNostrPubkey) applies
60
+ * the same rule. Keeping the indexer in sync prevents the
30
61
  * "indexed but verifier rejects" inconsistency that would surface
31
62
  * as a 401 on a key the well-known endpoint had advertised.
32
63
  */
@@ -41,18 +72,14 @@ export function pubkeyFromValidatedJwk(jwk) {
41
72
  .toString('hex').toLowerCase();
42
73
  } catch { return null; }
43
74
  if (!/^[0-9a-f]{64}$/.test(xHex)) return null;
44
- let canonicalY;
45
- try {
46
- // Compressed SEC1 encoding for the EVEN-y point at this x.
47
- const point = secp256k1.ProjectivePoint.fromHex('02' + xHex);
48
- canonicalY = point.toAffine().y.toString(16).padStart(64, '0');
49
- } catch { return null; }
75
+ const validY = nostrJwkYParities(xHex);
76
+ if (!validY) return null;
50
77
  let jwkYHex;
51
78
  try {
52
79
  jwkYHex = Buffer.from(jwk.y.replace(/-/g, '+').replace(/_/g, '/'), 'base64')
53
80
  .toString('hex').toLowerCase();
54
81
  } catch { return null; }
55
- if (jwkYHex !== canonicalY) return null;
82
+ if (!validY.includes(jwkYHex)) return null;
56
83
  return xHex;
57
84
  }
58
85
 
@@ -99,11 +126,11 @@ export function extractNostrPubkeysFromProfile(profile) {
99
126
  const xonly = decodeFFormSecp256k1(vm.publicKeyMultibase);
100
127
  if (xonly) out.push({ pubkey: xonly, vm });
101
128
  } else if (vm.publicKeyJwk && typeof vm.publicKeyJwk === 'object') {
102
- // Require y to match the BIP-340 canonical point — the same
103
- // check the NIP-98 verifier applies. Without this, the indexer
104
- // could publish a JWK that the verifier will then reject,
105
- // surfacing as a 401 on a key the well-known endpoint had
106
- // advertised as authentic.
129
+ // Require y to be a genuine on-curve point for x (either
130
+ // parity, per the did:nostr spec) — the same check the NIP-98
131
+ // verifier applies. Without this, the indexer could publish a
132
+ // JWK that the verifier will then reject, surfacing as a 401 on
133
+ // a key the well-known endpoint had advertised as authentic.
107
134
  const xonly = pubkeyFromValidatedJwk(vm.publicKeyJwk);
108
135
  if (xonly) out.push({ pubkey: xonly, vm });
109
136
  }
package/src/auth/nostr.js CHANGED
@@ -26,7 +26,6 @@
26
26
  */
27
27
 
28
28
  import { verifyEvent, getEventHash } from '../nostr/event.js';
29
- import { secp256k1 } from '@noble/curves/secp256k1';
30
29
  import crypto from 'crypto';
31
30
  import { resolveDidNostrToWebId } from './did-nostr.js';
32
31
  // resolveDidNostrLocally is loaded lazily (inside the idpEnabled
@@ -35,8 +34,8 @@ import { resolveDidNostrToWebId } from './did-nostr.js';
35
34
  // importing the NIP-98 verifier.
36
35
  import { fetchCidDocument } from './cid-doc-fetch.js';
37
36
  import { normalizeControllers } from './lws-cid.js'; // shared JSON-LD controller helper
38
- import { decodeFFormSecp256k1, extractNostrPubkeysFromProfile } from './nostr-keys.js'; // re-exported for back-compat
39
- export { extractNostrPubkeysFromProfile };
37
+ import { decodeFFormSecp256k1, extractNostrPubkeysFromProfile, nostrJwkYParities } from './nostr-keys.js';
38
+ export { extractNostrPubkeysFromProfile }; // re-exported for back-compat
40
39
 
41
40
  // NIP-98 event kind (references RFC 7235)
42
41
  const HTTP_AUTH_KIND = 27235;
@@ -659,29 +658,22 @@ function hexToBase64url(hex) {
659
658
  *
660
659
  * EC keys are (x, y) pairs — two distinct valid points share the same
661
660
  * x with opposite y parities. Matching on x alone would let an
662
- * attacker craft a JWK with the target x and a wrong y, which we'd
663
- * then accept as the user's Nostr key. So we also derive the
664
- * BIP-340-canonical y (even-parity) for the target x and require the
665
- * JWK's y to match.
661
+ * attacker craft a JWK with the target x and a fabricated, off-curve
662
+ * y, which we'd then accept as the user's Nostr key. So we also
663
+ * require the JWK's y to be a genuine on-curve y for the target x —
664
+ * accepting either parity, since the did:nostr spec allows both 0x02
665
+ * (even) and 0x03 (odd) encodings of the same x-only identity (see
666
+ * `nostrJwkYParities` / issue #571).
666
667
  *
667
668
  * Returns false if the JWK's coordinates aren't on-curve, can't be
668
- * decoded, or don't match the BIP-340 canonical point for `targetHex`.
669
+ * decoded, or don't match an on-curve point for `targetHex`.
669
670
  */
670
671
  function jwkMatchesNostrPubkey(jwk, targetHex, targetB64u) {
671
672
  if (typeof jwk.x !== 'string' || typeof jwk.y !== 'string') return false;
672
673
  if (jwk.x !== targetB64u) return false;
673
- // Decompress the BIP-340 even-y point for the target x. Then compare
674
- // the JWK's declared y against this canonical y.
675
- let canonicalY;
676
- try {
677
- // Compressed SEC1 point, even-y prefix (0x02) || x.
678
- const compressed = '02' + targetHex;
679
- const point = secp256k1.ProjectivePoint.fromHex(compressed);
680
- const affine = point.toAffine();
681
- canonicalY = affine.y.toString(16).padStart(64, '0');
682
- } catch {
683
- return false;
684
- }
674
+ // The two genuine on-curve y's (even + odd parity) for the target x.
675
+ const validY = nostrJwkYParities(targetHex);
676
+ if (!validY) return false;
685
677
  let jwkYHex;
686
678
  try {
687
679
  jwkYHex = Buffer.from(jwk.y.replace(/-/g, '+').replace(/_/g, '/'), 'base64')
@@ -689,7 +681,7 @@ function jwkMatchesNostrPubkey(jwk, targetHex, targetB64u) {
689
681
  } catch {
690
682
  return false;
691
683
  }
692
- return jwkYHex === canonicalY;
684
+ return validY.includes(jwkYHex);
693
685
  }
694
686
 
695
687
  function isInProofPurpose(profile, predicate, vmId, baseUrl) {
@@ -3,7 +3,9 @@ import { initializeQuota, checkQuota, updateQuotaUsage } from '../storage/quota.
3
3
  import { getAllHeaders } from '../ldp/headers.js';
4
4
  import { isContainer, getEffectiveUrlPath, getPodName } from '../utils/url.js';
5
5
  import { generateProfile, generatePreferences, generateTypeIndex, serialize } from '../webid/profile.js';
6
- import { generateOwnerAcl, generatePrivateAcl, generateInboxAcl, generatePublicFolderAcl, serializeAcl, relativizeOwnerWebId } from '../wac/parser.js';
6
+ import { generateOwnerAcl, generatePrivateAcl, generateInboxAcl, generatePublicFolderAcl, serializeAcl, relativizeOwnerWebId, AccessMode } from '../wac/parser.js';
7
+ import { checkAccess } from '../wac/checker.js';
8
+ import { buildResourceUrl } from '../auth/middleware.js';
7
9
  import { provisionOwnerKey, assertProvisionKeysCompatible } from '../keys/provision.js';
8
10
  import { createToken } from '../auth/token.js';
9
11
  import { canAcceptInput, toJsonLd, RDF_TYPES } from '../rdf/conneg.js';
@@ -88,6 +90,43 @@ export async function handlePost(request, reply) {
88
90
  const newStoragePath = storagePath + filename + (isCreatingContainer ? '/' : '');
89
91
  const resourceUrl = `${request.protocol}://${request.hostname}${newUrlPath}`;
90
92
 
93
+ // Security: a Slug that resolves to an `.acl` sidecar governs ANOTHER
94
+ // resource's permissions — the WAC checker searches for `*.acl`, so an
95
+ // `.acl` written here becomes the authorization policy for its sibling.
96
+ // The authorize() preHandler only checked Append/Write on the *container*
97
+ // (the request path), and its dedicated `.acl` Control guard
98
+ // (authorizeAclAccess) never fires here because the request path is the
99
+ // container, not the resolved sidecar. Without this an agent with mere
100
+ // Append rights on a container could POST `Slug: victim.acl` and self-grant
101
+ // Control on a sibling resource — privilege escalation. `.meta` is not
102
+ // consulted for WAC, but it is a protected Solid sidecar dotfile, so we gate
103
+ // it the same way (defense in depth) rather than let it be minted by Append.
104
+ // Mirror authorizeAclAccess: require acl:Control on the protected resource
105
+ // before minting a sidecar via POST. Build the resource URL with the same
106
+ // buildResourceUrl() the auth middleware uses so this Control decision is
107
+ // evaluated against the identical origin (host+port, subdomain-normalized).
108
+ // noDebit: this is a secondary WAC check on a request the authorize() hook
109
+ // already evaluated (and possibly billed) — pass noDebit so a payment-gated
110
+ // Control grant can't be charged here (no double debit, no silent charge).
111
+ if (!isCreatingContainer && /\.(acl|meta)$/.test(filename)) {
112
+ const protectedUrlPath = newUrlPath.replace(/\.(acl|meta)$/, '');
113
+ const protectedStoragePath = newStoragePath.replace(/\.(acl|meta)$/, '');
114
+ const { allowed } = await checkAccess({
115
+ resourceUrl: buildResourceUrl(request, protectedUrlPath),
116
+ resourcePath: protectedStoragePath,
117
+ isContainer: protectedUrlPath.endsWith('/'),
118
+ agentWebId: request.webId,
119
+ requiredMode: AccessMode.CONTROL,
120
+ noDebit: true
121
+ });
122
+ if (!allowed) {
123
+ return reply.code(403).send({
124
+ error: 'Forbidden',
125
+ message: 'Creating an ACL/meta sidecar via POST requires Control on the protected resource'
126
+ });
127
+ }
128
+ }
129
+
91
130
  let success;
92
131
  if (isCreatingContainer) {
93
132
  success = await storage.createContainer(newStoragePath);
package/src/mcp/tools.js CHANGED
@@ -300,12 +300,22 @@ async function read_acl({ path }, ctx) {
300
300
  });
301
301
  }
302
302
 
303
- function buildAclDoc(structured) {
303
+ function buildAclDoc(structured, targetRef, isContainer) {
304
304
  const graph = structured.authorizations.map((auth, i) => {
305
305
  const node = {
306
306
  '@id': `#auth${i}`,
307
307
  '@type': 'acl:Authorization',
308
- 'acl:accessTo': { '@id': './' },
308
+ // accessTo is a *relative* IRI; the parser resolves it against the
309
+ // ACL's base URL (parser.js getBaseUrl()), which is the parent
310
+ // container directory for BOTH container and resource ACLs. So './'
311
+ // resolves to that container — correct for a container ACL, but for a
312
+ // *resource* ACL it points at the parent container, not the resource,
313
+ // leaving checkAuthorizations() (which requires an exact accessTo
314
+ // match) with zero authorizations and locking out even the owner who
315
+ // just granted themselves Control (#575). targetRef is therefore './'
316
+ // for a container and './<basename>' for a resource. Relative IRIs
317
+ // keep stored ACLs host-portable across origins (#428).
318
+ 'acl:accessTo': { '@id': targetRef },
309
319
  'acl:mode': (auth.modes || []).map(m => ({ '@id': `acl:${m}` }))
310
320
  };
311
321
  if (auth.agents && auth.agents.length) {
@@ -316,8 +326,10 @@ function buildAclDoc(structured) {
316
326
  '@id': fullAgentClass(c)
317
327
  }));
318
328
  }
319
- if (auth.isDefault) {
320
- node['acl:default'] = { '@id': './' };
329
+ // acl:default only has meaning on a container ACL (it supplies the
330
+ // defaults inherited by contained resources), where targetRef is './'.
331
+ if (auth.isDefault && isContainer) {
332
+ node['acl:default'] = { '@id': targetRef };
321
333
  }
322
334
  return node;
323
335
  });
@@ -340,26 +352,50 @@ async function write_acl({ path, authorizations }, ctx) {
340
352
  return toolError(`access denied: control ${path}`);
341
353
  }
342
354
  const aclPath = aclUrlFor(path);
343
- const doc = buildAclDoc({ authorizations });
355
+ const isContainer = path.endsWith('/');
356
+ // Relative target IRI for the stored ACL (host-portable, #428): './' for
357
+ // a container, './<basename>' for a resource. The parser resolves it
358
+ // against the ACL base URL (the parent container directory), so the
359
+ // basename lands on the resource.
360
+ const targetRef = isContainer
361
+ ? './'
362
+ : './' + path.replace(/\/+$/, '').split('/').pop();
363
+ const targetUrl = buildUrl(ctx, path); // absolute, for the lockout check below
364
+ const doc = buildAclDoc({ authorizations }, targetRef, isContainer);
344
365
  const serialized = serializeAcl(doc);
345
366
 
346
367
  // Safety: refuse to write an ACL that would lock the caller out of
347
- // future Control. This is the most common write_acl footgun —
348
- // typically caused by relative WebID paths in `agents` resolving
349
- // against the .acl URL to a different absolute URI than the caller's
350
- // actual WebID. Parse the proposed ACL with its real URL so relative
351
- // agents resolve correctly, then check whether any authorization
352
- // grants Control to the caller.
368
+ // future Control. Two footguns are covered:
369
+ // 1. relative WebID paths in `agents` resolving against the .acl URL
370
+ // to a different absolute URI than the caller's actual WebID;
371
+ // 2. an authorization whose `accessTo` does not actually cover this
372
+ // resource (e.g. #575), which the checker would skip entirely.
373
+ // Parse the proposed ACL with its real URL so relative refs resolve
374
+ // correctly, then require an authorization that both grants Control to
375
+ // the caller *and* applies to this target.
353
376
  const aclAbsUrl = buildUrl(ctx, aclPath);
354
377
  const proposed = await parseAcl(serialized, aclAbsUrl);
355
- const callerHasControl = proposed.some(auth => {
378
+ const normUrl = u => String(u).replace(/\/$/, '');
379
+ const grantsCallerControl = auth => {
356
380
  if (!(auth.modes || []).includes(AccessMode.CONTROL)) return false;
357
381
  if (ctx.webId && (auth.agents || []).includes(ctx.webId)) return true;
358
382
  if ((auth.agentClasses || []).includes(FOAF_AGENT)) return true;
359
383
  if (ctx.webId && (auth.agentClasses || []).includes(ACL_AUTH_AGENT)) return true;
360
384
  return false;
361
- });
362
- if (!callerHasControl) {
385
+ };
386
+ const appliesToTarget = auth => {
387
+ const t = normUrl(targetUrl);
388
+ return (auth.accessTo || []).some(a => normUrl(a) === t) ||
389
+ (auth.default || []).some(d => {
390
+ const p = normUrl(d);
391
+ return t === p || t.startsWith(p + '/');
392
+ });
393
+ };
394
+ // Distinguish the two failure modes so the caller can fix the right thing:
395
+ // (a) no authorization grants Control to the caller at all, vs
396
+ // (b) one does, but its accessTo/default does not cover this target.
397
+ const controlAuths = proposed.filter(grantsCallerControl);
398
+ if (controlAuths.length === 0) {
363
399
  return toolError(
364
400
  `write_acl refused: the proposed ACL would not grant Control to the caller (${ctx.webId || 'anonymous'}). ` +
365
401
  'This is typically caused by relative WebID paths in agents resolving against the .acl URL — use absolute WebIDs. ' +
@@ -367,6 +403,14 @@ async function write_acl({ path, authorizations }, ctx) {
367
403
  'first grant Control to the new owner, then have the new owner write_acl without you.'
368
404
  );
369
405
  }
406
+ if (!controlAuths.some(appliesToTarget)) {
407
+ return toolError(
408
+ `write_acl refused: the proposed ACL grants Control to the caller (${ctx.webId || 'anonymous'}) ` +
409
+ `but none of those authorizations apply to ${path} — their accessTo/default targets a different ` +
410
+ 'resource (commonly the parent container), so the resource would be left with no effective Control. ' +
411
+ 'Ensure each authorization\'s accessTo covers this resource.'
412
+ );
413
+ }
370
414
 
371
415
  await storage.write(aclPath, Buffer.from(serialized, 'utf8'), {
372
416
  contentType: 'application/ld+json'
package/src/server.js CHANGED
@@ -887,8 +887,11 @@ export function createServer(options = {}) {
887
887
  // Server-root landing page: seed /index.html and a public-read /.acl
888
888
  // on first start (skip-if-exists, so operator-provided files are
889
889
  // preserved). See #433 / #276. Skipped in read-only deployments so
890
- // startup never mutates DATA_ROOT.
891
- if (!options.readOnly) {
890
+ // startup never mutates DATA_ROOT, and in --public mode: WAC is
891
+ // bypassed there so the seeded .acl files would never be consulted,
892
+ // and public mode's serve-a-directory use case (servejss) must not
893
+ // write into the served tree.
894
+ if (!options.readOnly && !options.public) {
892
895
  fastify.addHook('onReady', async () => {
893
896
  // A missing or unreadable package.json (some production bundles
894
897
  // omit it) shouldn't block seeding; fall back to "unknown".
@@ -16,14 +16,32 @@ import { readLedger, getBalance, debit } from '../webledger.js';
16
16
  * @param {boolean} options.isContainer - Whether resource is a container
17
17
  * @param {string|null} options.agentWebId - WebID of the agent (null for unauthenticated)
18
18
  * @param {string} options.requiredMode - Required access mode (from AccessMode)
19
- * @returns {Promise<{allowed: boolean, wacAllow: string}>}
19
+ * @param {boolean} [options.noDebit=false] - When true, evaluate a
20
+ * PaymentCondition without charging the ledger. A positive-cost paid grant
21
+ * is treated as not-satisfied (returns paymentRequired) rather than debited.
22
+ * Used by secondary/guard checks (e.g. the POST sidecar Control gate in
23
+ * handlePost) so a single request cannot debit twice or charge silently;
24
+ * the authoritative debit stays in the primary authorize() hook.
25
+ * @returns {Promise<{
26
+ * allowed: boolean,
27
+ * wacAllow: string,
28
+ * paymentRequired?: object|null,
29
+ * paid?: number,
30
+ * balance?: number,
31
+ * currency?: string
32
+ * }>}
33
+ * `paymentRequired` carries the unmet PaymentCondition (present when a paid
34
+ * grant is denied, including every `noDebit` denial). `paid`/`balance`/
35
+ * `currency` are set only when a debit actually occurred. The no-ACL deny
36
+ * path returns just `{allowed, wacAllow}`.
20
37
  */
21
38
  export async function checkAccess({
22
39
  resourceUrl,
23
40
  resourcePath,
24
41
  isContainer,
25
42
  agentWebId,
26
- requiredMode
43
+ requiredMode,
44
+ noDebit = false
27
45
  }) {
28
46
  // Find applicable ACL
29
47
  const aclResult = await findApplicableAcl(resourceUrl, resourcePath, isContainer);
@@ -43,7 +61,8 @@ export async function checkAccess({
43
61
  resourceUrl, // Use actual resource URL, not the ACL container URL
44
62
  agentWebId,
45
63
  requiredMode,
46
- isDefault
64
+ isDefault,
65
+ noDebit
47
66
  );
48
67
 
49
68
  // Calculate WAC-Allow header
@@ -129,7 +148,7 @@ function getParentPath(path) {
129
148
  // Supported condition types
130
149
  const SUPPORTED_CONDITIONS = ['PaymentCondition', 'https://webacl.org/ns#PaymentCondition'];
131
150
 
132
- async function checkAuthorizations(authorizations, targetUrl, agentWebId, requiredMode, isDefault) {
151
+ async function checkAuthorizations(authorizations, targetUrl, agentWebId, requiredMode, isDefault, noDebit = false) {
133
152
  for (const auth of authorizations) {
134
153
  // For default ACLs, check if auth has default rules and matches target
135
154
  // For direct ACLs, check if accessTo matches target
@@ -183,6 +202,11 @@ async function checkAuthorizations(authorizations, targetUrl, agentWebId, requir
183
202
  // Paid access: check balance and deduct
184
203
  const balance = getBalance(ledger, agentWebId, currency);
185
204
  if (cost > 0 && balance >= cost) {
205
+ // Guard checks must not charge: a paid grant is left unsatisfied
206
+ // here so billing happens once, in the primary authorize() path.
207
+ if (noDebit) {
208
+ return { allowed: false, paymentRequired: paymentCondition };
209
+ }
186
210
  const result = debit(ledger, agentWebId, cost, currency);
187
211
  const { writeLedger } = await import('../webledger.js');
188
212
  await writeLedger(ledger);
package/test/auth.test.js CHANGED
@@ -212,6 +212,60 @@ describe('Authentication', () => {
212
212
  const res3 = await request('/authuser1/authenticated-only/test.txt', { auth: 'authuser2' });
213
213
  assertStatus(res3, 200);
214
214
  });
215
+
216
+ it('should deny POST-created .acl/.meta sidecars without Control on the protected resource', async () => {
217
+ // Regression for the POST .acl sidecar injection: an agent holding only
218
+ // acl:Append on a container (here, the public-append inbox) must not be
219
+ // able to plant an .acl sidecar, which the WAC checker would then treat
220
+ // as the authorization policy for the sibling resource. .meta is not a
221
+ // WAC input, but is gated the same way as a protected Solid sidecar.
222
+ await createTestPod('sidecarvictim');
223
+
224
+ const aclBody = JSON.stringify({
225
+ '@context': { acl: 'http://www.w3.org/ns/auth/acl#' },
226
+ '@graph': []
227
+ });
228
+
229
+ // Append-only (unauthenticated public append) agent tries to plant victim.acl
230
+ const attackAcl = await request('/sidecarvictim/inbox/', {
231
+ method: 'POST',
232
+ headers: { 'Content-Type': 'application/json', 'Slug': 'victim.acl' },
233
+ body: aclBody
234
+ });
235
+ assertStatus(attackAcl, 403);
236
+
237
+ // The same trick with a .meta sidecar must also be blocked
238
+ const attackMeta = await request('/sidecarvictim/inbox/', {
239
+ method: 'POST',
240
+ headers: { 'Content-Type': 'application/json', 'Slug': 'victim.meta' },
241
+ body: aclBody
242
+ });
243
+ assertStatus(attackMeta, 403);
244
+
245
+ // A normal (non-sidecar) POST to the public inbox still works
246
+ const legit = await request('/sidecarvictim/inbox/', {
247
+ method: 'POST',
248
+ headers: { 'Content-Type': 'application/json', 'Slug': 'note' },
249
+ body: JSON.stringify({ type: 'note' })
250
+ });
251
+ assertStatus(legit, 201);
252
+ });
253
+
254
+ it('should allow the owner (Control) to POST an .acl sidecar', async () => {
255
+ // Owners hold acl:Control, so the sidecar guard must not block them.
256
+ await createTestPod('sidecarowner');
257
+
258
+ const res = await request('/sidecarowner/', {
259
+ method: 'POST',
260
+ headers: { 'Content-Type': 'application/json', 'Slug': 'owned.acl' },
261
+ body: JSON.stringify({
262
+ '@context': { acl: 'http://www.w3.org/ns/auth/acl#' },
263
+ '@graph': []
264
+ }),
265
+ auth: 'sidecarowner'
266
+ });
267
+ assertStatus(res, 201);
268
+ });
215
269
  });
216
270
 
217
271
  describe('WAC-Allow Header', () => {
package/test/mcp.test.js CHANGED
@@ -22,6 +22,7 @@ import {
22
22
  import { emitChange } from '../src/notifications/events.js';
23
23
 
24
24
  let token;
25
+ let ownerWebId;
25
26
 
26
27
  async function rpc(body, opts = {}) {
27
28
  const headers = { 'Content-Type': 'application/json' };
@@ -39,8 +40,9 @@ async function rpc(body, opts = {}) {
39
40
  describe('MCP server (--mcp enabled)', () => {
40
41
  before(async () => {
41
42
  await startTestServer({ mcp: true });
42
- await createTestPod('mcptest');
43
+ const pod = await createTestPod('mcptest');
43
44
  token = getPodToken('mcptest');
45
+ ownerWebId = pod.webId;
44
46
  });
45
47
 
46
48
  after(async () => {
@@ -322,6 +324,41 @@ describe('MCP server (--mcp enabled)', () => {
322
324
  assert.match(body.result.content[0].text, /control/i);
323
325
  });
324
326
 
327
+ it('write_acl on a resource does not lock the owner out (#575)', async () => {
328
+ // Regression: write_acl on a non-container resource used to set
329
+ // accessTo='./', which resolves to the *parent container* rather than
330
+ // the resource, leaving the resource with zero matching authorizations
331
+ // and locking out even the owner who just granted themselves Control.
332
+ const resPath = '/mcptest/public/acl575.txt';
333
+ const cr = await rpc({
334
+ jsonrpc: '2.0', id: 220, method: 'tools/call',
335
+ params: { name: 'write_resource', arguments: { path: resPath, content: 'secret', contentType: 'text/plain' } }
336
+ }, { token });
337
+ assert.strictEqual(cr.body.result.isError, false, cr.body.result.content?.[0]?.text);
338
+
339
+ // Grant the owner Read/Write/Control on the resource itself.
340
+ const wr = await rpc({
341
+ jsonrpc: '2.0', id: 221, method: 'tools/call',
342
+ params: { name: 'write_acl', arguments: {
343
+ path: resPath,
344
+ authorizations: [{ agents: [ownerWebId], modes: ['Read', 'Write', 'Control'] }]
345
+ } }
346
+ }, { token });
347
+ assert.strictEqual(wr.body.result.isError, false, wr.body.result.content?.[0]?.text);
348
+
349
+ // read_acl requires Control on the resource. Before the fix the owner
350
+ // was locked out and this was denied; it must now succeed.
351
+ const rd = await rpc({
352
+ jsonrpc: '2.0', id: 222, method: 'tools/call',
353
+ params: { name: 'read_acl', arguments: { path: resPath } }
354
+ }, { token });
355
+ assert.strictEqual(rd.body.result.isError, false,
356
+ 'owner locked out of resource ACL (#575): ' + rd.body.result.content?.[0]?.text);
357
+ const payload = JSON.parse(rd.body.result.content[0].text);
358
+ assert.ok(payload.authorizations.some(a => a.modes.includes('Control')),
359
+ 'resource ACL should grant the owner Control');
360
+ });
361
+
325
362
  // --- call_remote_pod (#495) ---
326
363
 
327
364
  it('call_remote_pod denied without federation gate access', async () => {
@@ -0,0 +1,96 @@
1
+ /**
2
+ * Parity consistency across the two Nostr verification-method decoders
3
+ * (#571).
4
+ *
5
+ * The did:nostr spec (https://nostrcg.github.io/did-nostr/) allows BOTH
6
+ * parity prefixes for the same x-only identity: "Nostr applications may
7
+ * generate keys with either 0x02 or 0x03 prefixes." So:
8
+ *
9
+ * - the f-form Multikey decoder accepts 02 and 03 (parity discarded,
10
+ * x is the identity), and
11
+ * - the JWK path accepts an even-Y *or* odd-Y on-curve point,
12
+ *
13
+ * but both still reject a fabricated/off-curve y. These tests pin that
14
+ * the two paths agree.
15
+ */
16
+
17
+ import { describe, it } from 'node:test';
18
+ import assert from 'node:assert';
19
+ import { secp256k1 } from '@noble/curves/secp256k1';
20
+ import {
21
+ decodeFFormSecp256k1,
22
+ pubkeyFromValidatedJwk,
23
+ nostrJwkYParities,
24
+ extractNostrPubkeysFromProfile,
25
+ } from '../src/auth/nostr-keys.js';
26
+
27
+ const b64u = (hex) => Buffer.from(hex, 'hex').toString('base64')
28
+ .replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
29
+
30
+ /** A real x-only Nostr pubkey (x with a valid even-Y point). */
31
+ const X = '124c0fa99407182ece5a24fad9b7f6674902fc422843d3128d38a0afbee0fdd2';
32
+
33
+ function jwkFor(xHex, parity) {
34
+ const point = secp256k1.ProjectivePoint.fromHex(parity + xHex).toAffine();
35
+ return {
36
+ kty: 'EC', crv: 'secp256k1', alg: 'ES256K',
37
+ x: b64u(point.x.toString(16).padStart(64, '0')),
38
+ y: b64u(point.y.toString(16).padStart(64, '0')),
39
+ };
40
+ }
41
+
42
+ const fform = (xHex, parity) => 'f' + 'e701' + parity + xHex.toLowerCase();
43
+
44
+ describe('Nostr key parity consistency (#571)', () => {
45
+ it('f-form Multikey decoder accepts both 02 and 03, returning the same x', () => {
46
+ assert.strictEqual(decodeFFormSecp256k1(fform(X, '02')), X);
47
+ assert.strictEqual(decodeFFormSecp256k1(fform(X, '03')), X);
48
+ });
49
+
50
+ it('f-form decoder rejects a non-parity prefix byte', () => {
51
+ assert.strictEqual(decodeFFormSecp256k1(fform(X, '04')), null);
52
+ });
53
+
54
+ it('JWK path accepts an even-Y point and returns x', () => {
55
+ assert.strictEqual(pubkeyFromValidatedJwk(jwkFor(X, '02')), X);
56
+ });
57
+
58
+ it('JWK path now also accepts an odd-Y point and returns the same x', () => {
59
+ assert.strictEqual(pubkeyFromValidatedJwk(jwkFor(X, '03')), X);
60
+ });
61
+
62
+ it('JWK path still rejects a fabricated off-curve y', () => {
63
+ const bad = jwkFor(X, '02');
64
+ // Flip the low bit of y → no longer the genuine even-Y coordinate
65
+ // (and not the odd-Y one either), so it must be rejected.
66
+ const yHex = Buffer.from(bad.y.replace(/-/g, '+').replace(/_/g, '/'), 'base64')
67
+ .toString('hex');
68
+ const flipped = (BigInt('0x' + yHex) ^ 1n).toString(16).padStart(64, '0');
69
+ bad.y = b64u(flipped);
70
+ assert.strictEqual(pubkeyFromValidatedJwk(bad), null);
71
+ });
72
+
73
+ it('nostrJwkYParities returns both genuine y values and null for a bad x', () => {
74
+ const ys = nostrJwkYParities(X);
75
+ assert.ok(Array.isArray(ys) && ys.length === 2);
76
+ assert.notStrictEqual(ys[0], ys[1]);
77
+ assert.strictEqual(nostrJwkYParities('zz'), null);
78
+ assert.strictEqual(nostrJwkYParities(42), null);
79
+ });
80
+
81
+ it('nostrJwkYParities normalizes uppercase hex (matches the lowercase result)', () => {
82
+ assert.deepStrictEqual(nostrJwkYParities(X.toUpperCase()), nostrJwkYParities(X));
83
+ });
84
+
85
+ it('profile extraction maps a 03 Multikey and a 03 JWK to the same identity', () => {
86
+ const profile = {
87
+ verificationMethod: [
88
+ { id: '#mk', type: 'Multikey', publicKeyMultibase: fform(X, '03') },
89
+ { id: '#jwk', type: 'JsonWebKey', publicKeyJwk: jwkFor(X, '03') },
90
+ ],
91
+ };
92
+ const found = extractNostrPubkeysFromProfile(profile);
93
+ assert.strictEqual(found.length, 2);
94
+ assert.ok(found.every((e) => e.pubkey === X));
95
+ });
96
+ });
@@ -103,6 +103,56 @@ describe('Server-root landing — operator override', () => {
103
103
  });
104
104
  });
105
105
 
106
+ describe('Server-root landing — public mode skips seeding', () => {
107
+ let server;
108
+ let baseUrl;
109
+ let savedDataRoot;
110
+ const DATA_DIR = './test-data-server-root-public';
111
+
112
+ before(async () => {
113
+ savedDataRoot = process.env.DATA_ROOT;
114
+
115
+ await fs.remove(DATA_DIR);
116
+ await fs.ensureDir(DATA_DIR);
117
+ await fs.writeFile(`${DATA_DIR}/hello.txt`, 'hello');
118
+
119
+ server = createServer({
120
+ logger: false,
121
+ root: DATA_DIR,
122
+ public: true,
123
+ forceCloseConnections: true,
124
+ });
125
+ await server.listen({ port: 0, host: '127.0.0.1' });
126
+ baseUrl = `http://127.0.0.1:${server.server.address().port}`;
127
+ });
128
+
129
+ after(async () => {
130
+ await server.close();
131
+ await fs.remove(DATA_DIR);
132
+ if (savedDataRoot === undefined) delete process.env.DATA_ROOT;
133
+ else process.env.DATA_ROOT = savedDataRoot;
134
+ });
135
+
136
+ it('does not seed /index.html, /.acl, or /index.html.acl into the served tree', async () => {
137
+ // WAC is bypassed in public mode, so the seeded ACLs would never be
138
+ // consulted — and serve-a-directory consumers (servejss) must not
139
+ // have startup write into the directory they serve.
140
+ assert.strictEqual(await fs.pathExists(`${DATA_DIR}/index.html`), false);
141
+ assert.strictEqual(await fs.pathExists(`${DATA_DIR}/.acl`), false);
142
+ assert.strictEqual(await fs.pathExists(`${DATA_DIR}/index.html.acl`), false);
143
+ });
144
+
145
+ it('GET / serves the container listing, and files remain readable', async () => {
146
+ const res = await fetch(`${baseUrl}/`);
147
+ assert.strictEqual(res.status, 200);
148
+ assert.match(res.headers.get('content-type'), /application\/ld\+json/);
149
+
150
+ const file = await fetch(`${baseUrl}/hello.txt`);
151
+ assert.strictEqual(file.status, 200);
152
+ assert.strictEqual(await file.text(), 'hello');
153
+ });
154
+ });
155
+
106
156
  describe('renderServerRoot', () => {
107
157
  // The seeded HTML is fully static — no template substitution, no
108
158
  // values vary by request. This is deliberate: anything dynamic
package/test/wac.test.js CHANGED
@@ -25,6 +25,8 @@ import {
25
25
  relativizeOwnerWebId
26
26
  } from '../src/wac/parser.js';
27
27
  import { checkAccess, getRequiredMode } from '../src/wac/checker.js';
28
+ import * as storage from '../src/storage/filesystem.js';
29
+ import { createLedger, setBalance, getBalance, LEDGER_PATH } from '../src/webledger.js';
28
30
 
29
31
  describe('WAC Parser', () => {
30
32
  describe('parseAcl', () => {
@@ -713,3 +715,76 @@ describe('WAC Conditions', () => {
713
715
  });
714
716
  });
715
717
  });
718
+
719
+ describe('WAC PaymentCondition noDebit (secondary/guard checks must not charge)', () => {
720
+ let baseUrl;
721
+ const AGENT = 'https://payer.example/profile/card#me';
722
+ const COST = 5;
723
+ const RESOURCE_PATH = '/paygate/resource';
724
+
725
+ before(async () => {
726
+ const result = await startTestServer();
727
+ baseUrl = result.baseUrl;
728
+ });
729
+
730
+ after(async () => {
731
+ await stopTestServer();
732
+ });
733
+
734
+ // Seed a ledger balance for AGENT and an ACL granting AGENT Control on the
735
+ // protected resource, gated behind a positive-cost PaymentCondition.
736
+ async function seed(balance) {
737
+ const ledger = createLedger();
738
+ setBalance(ledger, AGENT, balance, 'sat');
739
+ await storage.write(LEDGER_PATH, Buffer.from(JSON.stringify(ledger)));
740
+
741
+ const resourceUrl = `${baseUrl}${RESOURCE_PATH}`;
742
+ const acl = {
743
+ '@context': { acl: 'http://www.w3.org/ns/auth/acl#' },
744
+ '@graph': [{
745
+ '@id': '#paid',
746
+ '@type': 'acl:Authorization',
747
+ 'acl:agent': { '@id': AGENT },
748
+ 'acl:accessTo': { '@id': resourceUrl },
749
+ 'acl:mode': [{ '@id': 'acl:Control' }],
750
+ 'acl:condition': { '@type': 'PaymentCondition', amount: String(COST), currency: 'sat' }
751
+ }]
752
+ };
753
+ await storage.write(`${RESOURCE_PATH}.acl`, Buffer.from(JSON.stringify(acl)));
754
+ return resourceUrl;
755
+ }
756
+
757
+ async function balanceNow() {
758
+ const raw = await storage.read(LEDGER_PATH);
759
+ return getBalance(JSON.parse(raw.toString()), AGENT, 'sat');
760
+ }
761
+
762
+ it('debits the ledger on a normal (primary) Control check', async () => {
763
+ const resourceUrl = await seed(100);
764
+ const res = await checkAccess({
765
+ resourceUrl,
766
+ resourcePath: RESOURCE_PATH,
767
+ isContainer: false,
768
+ agentWebId: AGENT,
769
+ requiredMode: AccessMode.CONTROL
770
+ });
771
+ assert.strictEqual(res.allowed, true);
772
+ assert.strictEqual(res.paid, COST);
773
+ assert.strictEqual(await balanceNow(), 100 - COST, 'primary check should debit');
774
+ });
775
+
776
+ it('does NOT debit when noDebit is set (guard/secondary check)', async () => {
777
+ const resourceUrl = await seed(100);
778
+ const res = await checkAccess({
779
+ resourceUrl,
780
+ resourcePath: RESOURCE_PATH,
781
+ isContainer: false,
782
+ agentWebId: AGENT,
783
+ requiredMode: AccessMode.CONTROL,
784
+ noDebit: true
785
+ });
786
+ assert.strictEqual(res.allowed, false, 'paid grant is not satisfied without charging');
787
+ assert.ok(res.paymentRequired, 'should surface paymentRequired instead of debiting');
788
+ assert.strictEqual(await balanceNow(), 100, 'balance must be unchanged');
789
+ });
790
+ });