javascript-solid-server 0.0.210 → 0.0.213

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 |
@@ -350,6 +350,40 @@ When `--invite-only` is enabled:
350
350
 
351
351
  Invite codes are stored in `.server/invites.json` in your data directory.
352
352
 
353
+ ## Application Mount Points (appPaths)
354
+
355
+ Programmatic compositions can mount whole applications beside the pod
356
+ (the plugin-zero pattern from
357
+ [#206](https://github.com/JavaScriptSolidServer/JavaScriptSolidServer/issues/206)):
358
+
359
+ ```js
360
+ import { createServer } from 'javascript-solid-server/src/server.js';
361
+
362
+ const fastify = createServer({ appPaths: ['/myapp'] });
363
+ // Register both forms: fastify wildcards don't match the bare prefix.
364
+ fastify.all('/myapp', myAppHandler);
365
+ fastify.all('/myapp/*', myAppHandler); // the app owns auth below its prefix
366
+ await fastify.listen({ port: 4443 });
367
+ ```
368
+
369
+ Requests at or below an app path skip the WAC authorization hook — the
370
+ application authenticates and authorizes its own traffic, exactly like the
371
+ built-in `/storage/` and `/db/` routes. Everything outside the declared
372
+ prefixes keeps full WAC enforcement. Entries must start with `/` and be
373
+ longer than `/`; anything else is ignored.
374
+
375
+ Because the WAC hook is also what populates `request.webId`, requests under
376
+ an app path never carry it — don't rely on `request.webId` in app handlers.
377
+ Resolve identity yourself, e.g. with `getWebIdFromRequestAsync(request)`
378
+ from `src/auth/token.js` (a stable public accessor is tracked in
379
+ [#584](https://github.com/JavaScriptSolidServer/JavaScriptSolidServer/issues/584)).
380
+
381
+ See [#582](https://github.com/JavaScriptSolidServer/JavaScriptSolidServer/issues/582)
382
+ for the design discussion and
383
+ [melvincarvalho/tideholm](https://github.com/melvincarvalho/tideholm/tree/gh-pages/jss-plugin)
384
+ for a complete example (a multiplayer game where pod WebIDs are the player
385
+ accounts).
386
+
353
387
  ## Storage Quotas
354
388
 
355
389
  Limit storage per pod to prevent abuse and manage resources:
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "javascript-solid-server",
3
- "version": "0.0.210",
3
+ "version": "0.0.213",
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/server.js CHANGED
@@ -107,6 +107,16 @@ export function createServer(options = {}) {
107
107
  // Tunnel proxy is OFF by default
108
108
  const tunnelEnabled = options.tunnel ?? false;
109
109
  const tunnelPath = options.tunnelPath ?? '/.tunnel';
110
+ // Application mount points (plugin seam, #206): URL prefixes owned by
111
+ // registered apps (e.g. a game mounted at /tideholm). Requests below an
112
+ // app path skip the WAC hook — the app owns authentication and
113
+ // authorization under its prefix, like /storage/ and /db/ already do.
114
+ const appPaths = Array.isArray(options.appPaths)
115
+ ? options.appPaths
116
+ .filter((p) => typeof p === 'string')
117
+ .map((p) => p.trim().replace(/\/+$/, '')) // '/myapp/' matches like '/myapp'
118
+ .filter((p) => p.startsWith('/') && p.length > 1)
119
+ : [];
110
120
  // ActivityPub federation is OFF by default
111
121
  const activitypubEnabled = options.activitypub ?? false;
112
122
  const apUsername = options.apUsername ?? 'me';
@@ -719,6 +729,7 @@ export function createServer(options = {}) {
719
729
  (webrtcEnabled && (request.url === webrtcPath || request.url.startsWith(webrtcPath + '?'))) ||
720
730
  (terminalEnabled && (request.url === '/.terminal' || request.url.startsWith('/.terminal?'))) ||
721
731
  (tunnelEnabled && (request.url === tunnelPath || request.url.startsWith(tunnelPath + '?') || request.url.startsWith('/tunnel/'))) ||
732
+ appPaths.some(p => request.url === p || request.url.startsWith(p + '/') || request.url.startsWith(p + '?')) ||
722
733
  mashlibPaths.some(p => request.url === p || request.url.startsWith(p + '.'))) {
723
734
  return;
724
735
  }
@@ -887,8 +898,11 @@ export function createServer(options = {}) {
887
898
  // Server-root landing page: seed /index.html and a public-read /.acl
888
899
  // on first start (skip-if-exists, so operator-provided files are
889
900
  // preserved). See #433 / #276. Skipped in read-only deployments so
890
- // startup never mutates DATA_ROOT.
891
- if (!options.readOnly) {
901
+ // startup never mutates DATA_ROOT, and in --public mode: WAC is
902
+ // bypassed there so the seeded .acl files would never be consulted,
903
+ // and public mode's serve-a-directory use case (servejss) must not
904
+ // write into the served tree.
905
+ if (!options.readOnly && !options.public) {
892
906
  fastify.addHook('onReady', async () => {
893
907
  // A missing or unreadable package.json (some production bundles
894
908
  // 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);
@@ -0,0 +1,151 @@
1
+ /**
2
+ * appPaths — WAC-exempt application mount points (#582).
3
+ *
4
+ * The global WAC preHandler authorizes every URL against pod ACLs and
5
+ * rejects before routes run; the only escapes are its hardcoded prefix
6
+ * list (/storage/, /db, /mcp, …). That means a third-party app plugin
7
+ * registering routes on the returned fastify instance (#206's plugin-zero
8
+ * pattern, e.g. a game mounted at /tideholm) has its POSTs swallowed by
9
+ * WAC with no way to opt out.
10
+ *
11
+ * createServer({ appPaths: ['/myapp'] }) declares URL prefixes owned by
12
+ * registered applications: requests at or below an app path skip the WAC
13
+ * hook, and the app owns authentication and authorization under its
14
+ * prefix — exactly the deal the bundled pseudo-plugins already have.
15
+ *
16
+ * Tests verify the seam end-to-end: an app route mounted on the returned
17
+ * instance receives unauthenticated requests (WAC stays out), sibling LDP
18
+ * paths keep full WAC enforcement, and malformed appPaths entries are
19
+ * dropped rather than becoming accidental holes.
20
+ */
21
+
22
+ import { describe, it, before, after, afterEach } from 'node:test';
23
+ import assert from 'node:assert';
24
+ import { createServer } from '../src/server.js';
25
+ import fs from 'fs-extra';
26
+
27
+ const TEST_DATA_DIR = './test-data-app-paths';
28
+
29
+ let server;
30
+ let baseUrl;
31
+ let originalDataRoot;
32
+
33
+ async function startWith(appPaths) {
34
+ await fs.emptyDir(TEST_DATA_DIR);
35
+ server = createServer({
36
+ logger: false,
37
+ forceCloseConnections: true,
38
+ root: TEST_DATA_DIR,
39
+ appPaths,
40
+ });
41
+ // An app in the #206 plugin-zero shape: routes registered on the returned
42
+ // instance, answering with its own status codes (its own "auth").
43
+ server.all('/myapp', echo);
44
+ server.all('/myapp/*', echo);
45
+ async function echo(request, reply) {
46
+ reply.code(200).send({
47
+ app: true,
48
+ method: request.method,
49
+ url: request.url,
50
+ webId: request.webId ?? null, // hook skipped -> never set
51
+ });
52
+ }
53
+ await server.listen({ port: 0, host: '127.0.0.1' });
54
+ const address = server.server.address();
55
+ baseUrl = `http://127.0.0.1:${address.port}`;
56
+ }
57
+
58
+ describe('appPaths application mount points (#582)', () => {
59
+ before(() => {
60
+ // createServer({ root }) mutates process.env.DATA_ROOT; snapshot so the
61
+ // test dir doesn't leak into later suites.
62
+ originalDataRoot = process.env.DATA_ROOT;
63
+ });
64
+
65
+ afterEach(async () => {
66
+ if (server) {
67
+ await server.close();
68
+ server = null;
69
+ }
70
+ await fs.remove(TEST_DATA_DIR);
71
+ });
72
+
73
+ after(() => {
74
+ if (originalDataRoot === undefined) delete process.env.DATA_ROOT;
75
+ else process.env.DATA_ROOT = originalDataRoot;
76
+ });
77
+
78
+ it('unauthenticated POST below an app path reaches the app handler', async () => {
79
+ await startWith(['/myapp']);
80
+ const res = await fetch(`${baseUrl}/myapp/api/action`, {
81
+ method: 'POST',
82
+ headers: { 'Content-Type': 'application/json' },
83
+ body: JSON.stringify({ hello: 'world' }),
84
+ });
85
+ assert.strictEqual(res.status, 200);
86
+ const body = await res.json();
87
+ assert.strictEqual(body.app, true);
88
+ assert.strictEqual(body.method, 'POST');
89
+ });
90
+
91
+ it('the bare app path and query-string forms are exempt too', async () => {
92
+ await startWith(['/myapp']);
93
+ for (const path of ['/myapp', '/myapp?tab=map']) {
94
+ const res = await fetch(`${baseUrl}${path}`, { method: 'POST' });
95
+ assert.strictEqual(res.status, 200, `${path} should reach the app`);
96
+ }
97
+ });
98
+
99
+ it('the WAC hook never sets request.webId on app-path requests', async () => {
100
+ await startWith(['/myapp']);
101
+ const res = await fetch(`${baseUrl}/myapp/whoami`);
102
+ const body = await res.json();
103
+ assert.strictEqual(body.webId, null);
104
+ });
105
+
106
+ it('sibling LDP paths keep full WAC enforcement', async () => {
107
+ await startWith(['/myapp']);
108
+ // Writing outside the app prefix without auth must still be rejected.
109
+ const res = await fetch(`${baseUrl}/notes.jsonld`, {
110
+ method: 'PUT',
111
+ headers: { 'Content-Type': 'application/ld+json' },
112
+ body: JSON.stringify({ '@id': '', name: 'x' }),
113
+ });
114
+ assert.ok(res.status === 401 || res.status === 403,
115
+ `expected WAC rejection, got ${res.status}`);
116
+ });
117
+
118
+ it('a prefix match is a path-segment match, not a string prefix', async () => {
119
+ await startWith(['/myapp']);
120
+ // /myapplication must NOT be exempt just because it shares characters.
121
+ const res = await fetch(`${baseUrl}/myapplication.jsonld`, {
122
+ method: 'PUT',
123
+ headers: { 'Content-Type': 'application/ld+json' },
124
+ body: JSON.stringify({ '@id': '', name: 'x' }),
125
+ });
126
+ assert.ok(res.status === 401 || res.status === 403,
127
+ `expected WAC rejection, got ${res.status}`);
128
+ });
129
+
130
+ it('trailing-slash entries are normalized, children still exempt', async () => {
131
+ await startWith(['/myapp/']);
132
+ const res = await fetch(`${baseUrl}/myapp/api/action`, { method: 'POST' });
133
+ assert.strictEqual(res.status, 200);
134
+ });
135
+
136
+ it('malformed appPaths entries are dropped, not accidental holes', async () => {
137
+ // No leading slash and bare '/' are both invalid; with them filtered out
138
+ // the route registrations still exist but WAC fires first.
139
+ await startWith(['myapp', '/', '///', ' ']);
140
+ const res = await fetch(`${baseUrl}/myapp/api/action`, { method: 'POST' });
141
+ assert.ok(res.status === 401 || res.status === 403,
142
+ `expected WAC rejection (invalid entries dropped), got ${res.status}`);
143
+ });
144
+
145
+ it('omitting appPaths changes nothing (default off)', async () => {
146
+ await startWith(undefined);
147
+ const res = await fetch(`${baseUrl}/myapp/api/action`, { method: 'POST' });
148
+ assert.ok(res.status === 401 || res.status === 403,
149
+ `expected WAC rejection with no appPaths, got ${res.status}`);
150
+ });
151
+ });
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', () => {
@@ -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
+ });