fedipod-server 0.11.0 → 0.13.0

package/lib/core/contexts/security-data-integrity-v1.json

@@ -0,0 +1,78 @@
+{
+  "@context": {
+    "id": "@id",
+    "type": "@type",
+    "@protected": true,
+    "digestMultibase": {
+      "@id": "https://w3id.org/security#digestMultibase",
+      "@type": "https://w3id.org/security#multibase"
+    },
+    "proof": {
+      "@id": "https://w3id.org/security#proof",
+      "@type": "@id",
+      "@container": "@graph"
+    },
+    "DataIntegrityProof": {
+      "@id": "https://w3id.org/security#DataIntegrityProof",
+      "@context": {
+        "@protected": true,
+        "id": "@id",
+        "type": "@type",
+        "challenge": "https://w3id.org/security#challenge",
+        "created": {
+          "@id": "http://purl.org/dc/terms/created",
+          "@type": "http://www.w3.org/2001/XMLSchema#dateTime"
+        },
+        "domain": "https://w3id.org/security#domain",
+        "expires": {
+          "@id": "https://w3id.org/security#expiration",
+          "@type": "http://www.w3.org/2001/XMLSchema#dateTime"
+        },
+        "nonce": "https://w3id.org/security#nonce",
+        "proofPurpose": {
+          "@id": "https://w3id.org/security#proofPurpose",
+          "@type": "@vocab",
+          "@context": {
+            "@protected": true,
+            "id": "@id",
+            "type": "@type",
+            "assertionMethod": {
+              "@id": "https://w3id.org/security#assertionMethod",
+              "@type": "@id",
+              "@container": "@set"
+            },
+            "authentication": {
+              "@id": "https://w3id.org/security#authenticationMethod",
+              "@type": "@id",
+              "@container": "@set"
+            },
+            "capabilityInvocation": {
+              "@id": "https://w3id.org/security#capabilityInvocationMethod",
+              "@type": "@id",
+              "@container": "@set"
+            },
+            "capabilityDelegation": {
+              "@id": "https://w3id.org/security#capabilityDelegationMethod",
+              "@type": "@id",
+              "@container": "@set"
+            },
+            "keyAgreement": {
+              "@id": "https://w3id.org/security#keyAgreementMethod",
+              "@type": "@id",
+              "@container": "@set"
+            }
+          }
+        },
+        "cryptosuite": "https://w3id.org/security#cryptosuite",
+        "proofValue": {
+          "@id": "https://w3id.org/security#proofValue",
+          "@type": "https://w3id.org/security#multibase"
+        },
+        "verificationMethod": {
+          "@id": "https://w3id.org/security#verificationMethod",
+          "@type": "@id"
+        }
+      }
+    }
+  }
+}

package/lib/core/contexts/security-data-integrity-v2.json

@@ -0,0 +1,81 @@
+{
+  "@context": {
+    "id": "@id",
+    "type": "@type",
+    "@protected": true,
+    "proof": {
+      "@id": "https://w3id.org/security#proof",
+      "@type": "@id",
+      "@container": "@graph"
+    },
+    "DataIntegrityProof": {
+      "@id": "https://w3id.org/security#DataIntegrityProof",
+      "@context": {
+        "@protected": true,
+        "id": "@id",
+        "type": "@type",
+        "challenge": "https://w3id.org/security#challenge",
+        "created": {
+          "@id": "http://purl.org/dc/terms/created",
+          "@type": "http://www.w3.org/2001/XMLSchema#dateTime"
+        },
+        "domain": "https://w3id.org/security#domain",
+        "expires": {
+          "@id": "https://w3id.org/security#expiration",
+          "@type": "http://www.w3.org/2001/XMLSchema#dateTime"
+        },
+        "nonce": "https://w3id.org/security#nonce",
+        "previousProof": {
+          "@id": "https://w3id.org/security#previousProof",
+          "@type": "@id"
+        },
+        "proofPurpose": {
+          "@id": "https://w3id.org/security#proofPurpose",
+          "@type": "@vocab",
+          "@context": {
+            "@protected": true,
+            "id": "@id",
+            "type": "@type",
+            "assertionMethod": {
+              "@id": "https://w3id.org/security#assertionMethod",
+              "@type": "@id",
+              "@container": "@set"
+            },
+            "authentication": {
+              "@id": "https://w3id.org/security#authenticationMethod",
+              "@type": "@id",
+              "@container": "@set"
+            },
+            "capabilityInvocation": {
+              "@id": "https://w3id.org/security#capabilityInvocationMethod",
+              "@type": "@id",
+              "@container": "@set"
+            },
+            "capabilityDelegation": {
+              "@id": "https://w3id.org/security#capabilityDelegationMethod",
+              "@type": "@id",
+              "@container": "@set"
+            },
+            "keyAgreement": {
+              "@id": "https://w3id.org/security#keyAgreementMethod",
+              "@type": "@id",
+              "@container": "@set"
+            }
+          }
+        },
+        "cryptosuite": {
+          "@id": "https://w3id.org/security#cryptosuite",
+          "@type": "https://w3id.org/security#cryptosuiteString"
+        },
+        "proofValue": {
+          "@id": "https://w3id.org/security#proofValue",
+          "@type": "https://w3id.org/security#multibase"
+        },
+        "verificationMethod": {
+          "@id": "https://w3id.org/security#verificationMethod",
+          "@type": "@id"
+        }
+      }
+    }
+  }
+}

package/lib/core/contexts/security-multikey-v1.json

@@ -0,0 +1,35 @@
+{
+  "@context": {
+    "id": "@id",
+    "type": "@type",
+    "@protected": true,
+    "Multikey": {
+      "@id": "https://w3id.org/security#Multikey",
+      "@context": {
+        "@protected": true,
+        "id": "@id",
+        "type": "@type",
+        "controller": {
+          "@id": "https://w3id.org/security#controller",
+          "@type": "@id"
+        },
+        "revoked": {
+          "@id": "https://w3id.org/security#revoked",
+          "@type": "http://www.w3.org/2001/XMLSchema#dateTime"
+        },
+        "expires": {
+          "@id": "https://w3id.org/security#expiration",
+          "@type": "http://www.w3.org/2001/XMLSchema#dateTime"
+        },
+        "publicKeyMultibase": {
+          "@id": "https://w3id.org/security#publicKeyMultibase",
+          "@type": "https://w3id.org/security#multibase"
+        },
+        "secretKeyMultibase": {
+          "@id": "https://w3id.org/security#secretKeyMultibase",
+          "@type": "https://w3id.org/security#multibase"
+        }
+      }
+    }
+  }
+}

package/lib/core/contexts/security-v1.json

@@ -0,0 +1,74 @@
+{
+  "@context": {
+    "id": "@id",
+    "type": "@type",
+    "dc": "http://purl.org/dc/terms/",
+    "sec": "https://w3id.org/security#",
+    "xsd": "http://www.w3.org/2001/XMLSchema#",
+    "EcdsaKoblitzSignature2016": "sec:EcdsaKoblitzSignature2016",
+    "Ed25519Signature2018": "sec:Ed25519Signature2018",
+    "EncryptedMessage": "sec:EncryptedMessage",
+    "GraphSignature2012": "sec:GraphSignature2012",
+    "LinkedDataSignature2015": "sec:LinkedDataSignature2015",
+    "LinkedDataSignature2016": "sec:LinkedDataSignature2016",
+    "CryptographicKey": "sec:Key",
+    "authenticationTag": "sec:authenticationTag",
+    "canonicalizationAlgorithm": "sec:canonicalizationAlgorithm",
+    "cipherAlgorithm": "sec:cipherAlgorithm",
+    "cipherData": "sec:cipherData",
+    "cipherKey": "sec:cipherKey",
+    "created": {
+      "@id": "dc:created",
+      "@type": "xsd:dateTime"
+    },
+    "creator": {
+      "@id": "dc:creator",
+      "@type": "@id"
+    },
+    "digestAlgorithm": "sec:digestAlgorithm",
+    "digestValue": "sec:digestValue",
+    "domain": "sec:domain",
+    "encryptionKey": "sec:encryptionKey",
+    "expiration": {
+      "@id": "sec:expiration",
+      "@type": "xsd:dateTime"
+    },
+    "expires": {
+      "@id": "sec:expiration",
+      "@type": "xsd:dateTime"
+    },
+    "initializationVector": "sec:initializationVector",
+    "iterationCount": "sec:iterationCount",
+    "nonce": "sec:nonce",
+    "normalizationAlgorithm": "sec:normalizationAlgorithm",
+    "owner": {
+      "@id": "sec:owner",
+      "@type": "@id"
+    },
+    "password": "sec:password",
+    "privateKey": {
+      "@id": "sec:privateKey",
+      "@type": "@id"
+    },
+    "privateKeyPem": "sec:privateKeyPem",
+    "publicKey": {
+      "@id": "sec:publicKey",
+      "@type": "@id"
+    },
+    "publicKeyBase58": "sec:publicKeyBase58",
+    "publicKeyPem": "sec:publicKeyPem",
+    "publicKeyWif": "sec:publicKeyWif",
+    "publicKeyService": {
+      "@id": "sec:publicKeyService",
+      "@type": "@id"
+    },
+    "revoked": {
+      "@id": "sec:revoked",
+      "@type": "xsd:dateTime"
+    },
+    "salt": "sec:salt",
+    "signature": "sec:signature",
+    "signatureAlgorithm": "sec:signingAlgorithm",
+    "signatureValue": "sec:signatureValue"
+  }
+}

package/lib/core/contexts/webfinger.json

@@ -0,0 +1,10 @@
+{
+  "@context": {
+    "wf": "https://purl.archive.org/socialweb/webfinger#",
+    "xsd": "http://www.w3.org/2001/XMLSchema#",
+    "webfinger": {
+      "@id": "wf:webfinger",
+      "@type": "xsd:string"
+    }
+  }
+}

package/lib/{deliver.mjs → core/deliver.mjs}

@@ -6,8 +6,8 @@
 import { signRequest } from '@fedify/fedify/sig';
 import { webcrypto } from 'node:crypto';
 import { attachProof } from './proof.mjs';
-import { pinnedFor, retryAfterMs, HTTP_TIMEOUT_MS } from './safefetch.mjs';
-import { USER_AGENT } from './ua.mjs';
+import { pinnedFor, retryAfterMs, HTTP_TIMEOUT_MS } from '../shared/safefetch.mjs';
+import { USER_AGENT } from '../shared/ua.mjs';
 
 const MAX_REDIRECTS = 3;
 

package/lib/core/graphview.mjs

@@ -0,0 +1,269 @@
+// graphview.mjs — what the handlers read.
+//
+// `parseAS2` produces quads. This turns them back into something a handler can
+// read by name, so the thing being read is the GRAPH: every property access
+// here is a lookup over statements, not a key on the JSON a stranger sent.
+//
+// That distinction is the whole point. A document can say the same thing in
+// many ways — `"type": "Create"`, `"@type": "as:Create"`, a term aliased by the
+// sender's own context — and all of them leave the same statement in the
+// graph. Reading the graph means a handler sees one answer without knowing any
+// of that happened.
+//
+// Names are resolved through the contexts we already hold, AS2 first. They are
+// not hardcoded: `movedTo` is not in the AS2 context at all (it lives in
+// miscellany), and `inbox` is `ldp:inbox` rather than an `as:` term, so a map
+// written by hand would get both wrong.
+
+import { CONTEXTS } from './contexts/index.mjs';
+import { AS_CTX } from './wire.mjs';
+
+const RDF_TYPE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
+const RDF_FIRST = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#first';
+const RDF_REST = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#rest';
+const RDF_NIL = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#nil';
+
+// Properties a handler treats as a collection. JSON-LD compaction would hand
+// back a bare value when there is only one, and `Array.isArray` checks in the
+// handlers then read it as empty. These always answer with an array.
+// A stranger's document decides the shape of this graph, so the walk is capped
+// rather than trusted to terminate on its own.
+const MAX_DEPTH = 12;
+
+const ALWAYS_LIST = new Set([
+  'items', 'orderedItems', 'to', 'cc', 'bto', 'bcc', 'tag', 'attachment',
+  'anyOf', 'oneOf', 'audience', 'attributedTo', 'alsoKnownAs',
+]);
+
+/** Expand `as:object` against a context's own prefix declarations. */
+function expandIri(value, prefixes) {
+  if (typeof value !== 'string') return null;
+  if (/^https?:\/\//.test(value)) return value;
+  const colon = value.indexOf(':');
+  if (colon < 1) return null;
+  const base = prefixes[value.slice(0, colon)];
+  return base ? base + value.slice(colon + 1) : null;
+}
+
+/**
+ * term -> { iri, list } over every context we hold, AS2 winning ties.
+ *
+ * Built once. A term already claimed by an earlier context is not overwritten,
+ * and AS2 is walked first, so an extension cannot quietly redefine `object`.
+ */
+function buildTerms() {
+  const terms = new Map();
+  const order = [AS_CTX, ...Object.keys(CONTEXTS).filter(u => u !== AS_CTX)];
+  for (const url of order) {
+    const ctx = CONTEXTS[url]?.['@context'];
+    if (!ctx || typeof ctx !== 'object') continue;
+    const prefixes = {};
+    for (const [k, v] of Object.entries(ctx)) {
+      if (typeof v === 'string' && /^https?:\/\//.test(v)) prefixes[k] = v;
+    }
+    for (const [name, def] of Object.entries(ctx)) {
+      if (name.startsWith('@') || terms.has(name)) continue;
+      const raw = typeof def === 'string' ? def : def?.['@id'];
+      const iri = expandIri(raw, prefixes);
+      if (!iri) continue;
+      terms.set(name, { iri, list: def?.['@container'] === '@list', container: def?.['@container'] ?? null });
+    }
+  }
+  return terms;
+}
+
+const TERMS = buildTerms();
+
+/** iri -> shortest term naming it, so a type comes back as `Create`. */
+const BY_IRI = (() => {
+  const m = new Map();
+  for (const [name, { iri }] of TERMS) {
+    const held = m.get(iri);
+    if (!held || name.length < held.length) m.set(iri, name);
+  }
+  return m;
+})();
+
+/**
+ * iri -> every term naming it.
+ *
+ * More than one term can mean the same predicate: `items` and `orderedItems`
+ * are both `as:items`, and only the list tells them apart. Emitting just the
+ * shorter name would lose `orderedItems` — and with it the ordering, which is
+ * the one thing an OrderedCollection is for.
+ */
+const NAMES_BY_IRI = (() => {
+  const m = new Map();
+  for (const [name, { iri, container }] of TERMS) {
+    // `contentMap` and `content` are the same predicate, but a language map is
+    // not another spelling of the plain term — emitting one as a bare string
+    // would invent a value the document never carried.
+    if (container === '@language' || container === '@index') continue;
+    const held = m.get(iri);
+    if (held) held.push(name); else m.set(iri, [name]);
+  }
+  return m;
+})();
+
+/** Index quads by subject, then by predicate. */
+function indexQuads(quads) {
+  const bySubject = new Map();
+  const objects = new Set();
+  // A BlankNode's `.value` has no `_:` on it, so blankness is recorded here
+  // rather than guessed from the string. A blank node has no id, and handing a
+  // handler `id: "b0"` would be handing it an identifier that means nothing.
+  const blanks = new Set();
+  for (const q of quads) {
+    if (q.subject.termType === 'BlankNode') blanks.add(q.subject.value);
+    if (q.object.termType === 'BlankNode') blanks.add(q.object.value);
+    const s = q.subject.value;
+    let preds = bySubject.get(s);
+    if (!preds) bySubject.set(s, preds = new Map());
+    let vals = preds.get(q.predicate.value);
+    if (!vals) preds.set(q.predicate.value, vals = []);
+    vals.push(q.object);
+    if (q.object.termType === 'NamedNode' || q.object.termType === 'BlankNode') {
+      objects.add(q.object.value);
+    }
+  }
+  return { bySubject, objects, blanks };
+}
+
+/**
+ * The document's own node: a subject nothing else points at. A document that
+ * points back at itself leaves no such subject, so the first typed subject is
+ * the fallback rather than nothing at all.
+ */
+function findRoot({ bySubject, objects }) {
+  for (const s of bySubject.keys()) if (!objects.has(s)) return s;
+  for (const [s, preds] of bySubject) if (preds.has(RDF_TYPE)) return s;
+  return bySubject.keys().next().value ?? null;
+}
+
+/** Walk an rdf:List into an ordered array. `orderedItems` depends on this. */
+function readList(head, ctx, depth, path) {
+  const out = [];
+  const walked = new Set();
+  let node = head;
+  while (node && node !== RDF_NIL && !walked.has(node)) {
+    walked.add(node);
+    const preds = ctx.bySubject.get(node);
+    if (!preds) break;
+    const first = preds.get(RDF_FIRST)?.[0];
+    if (first) {
+      const value = toValue(first, ctx, depth, path);
+      if (value !== null) out.push(value);
+    }
+    node = preds.get(RDF_REST)?.[0]?.value ?? null;
+  }
+  return out;
+}
+
+function isListHead(term, ctx) {
+  if (term.termType !== 'BlankNode' && term.termType !== 'NamedNode') return false;
+  return !!ctx.bySubject.get(term.value)?.has(RDF_FIRST);
+}
+
+/**
+ * A term becomes what a handler expects to find there.
+ *
+ * A node we hold statements about becomes a nested view, which is what an
+ * embedded object was in the JSON. A node we hold nothing about becomes its
+ * IRI, which is what a bare reference was. Handlers already test which they
+ * got (`typeof activity.object === 'object'`), so both stay readable.
+ */
+function toValue(term, ctx, depth, path) {
+  if (term.termType === 'Literal') return term.value;
+  if (isListHead(term, ctx)) return readList(term.value, ctx, depth, path);
+  const preds = ctx.bySubject.get(term.value);
+  if (preds && preds.size) return makeView(term.value, ctx, depth + 1, path);
+  return term.termType === 'BlankNode' ? null : term.value;
+}
+
+function readProperty(subject, name, ctx, depth = 0, path = new Set()) {
+  const preds = ctx.bySubject.get(subject);
+  if (!preds) return undefined;
+
+  if (name === 'id') return ctx.blanks.has(subject) ? undefined : subject;
+  if (name === 'type') {
+    const types = (preds.get(RDF_TYPE) ?? []).map(t => BY_IRI.get(t.value) ?? t.value);
+    if (!types.length) return undefined;
+    return types.length === 1 ? types[0] : types;
+  }
+
+  const term = TERMS.get(name);
+  if (!term) return undefined;
+  const values = preds.get(term.iri);
+  if (!values || !values.length) return undefined;
+
+  // `items` and `orderedItems` are the same predicate; the list is what tells
+  // them apart, so asking for the ordered one only answers when it is ordered.
+  const listed = values.filter(v => isListHead(v, ctx));
+  if (term.list) {
+    if (!listed.length) return undefined;
+    return readList(listed[0].value, ctx, depth, path);
+  }
+  if (listed.length === values.length && listed.length === 1) return readList(listed[0].value, ctx, depth, path);
+
+  const out = values.map(v => toValue(v, ctx, depth, path)).filter(v => v !== null);
+  if (ALWAYS_LIST.has(name)) return out.flat();
+  return out.length === 1 ? out[0] : out;
+}
+
+/**
+ * Build the plain object for one node.
+ *
+ * Materialised rather than proxied on purpose. A lazy reader would still be
+ * reading the graph, but it would be an exotic object, and the handlers pass
+ * what they read on to things that spread it, serialise it and structuredClone
+ * it into the store — all of which a Proxy either breaks or quietly truncates.
+ * What comes out here is an ordinary object whose every value came from a
+ * statement.
+ *
+ * `depth` and `seen` are the guards. The graph is built from a stranger's
+ * document, so it can be cyclic or enormous; a node already on the path
+ * becomes its IRI rather than being walked again.
+ */
+function makeView(subject, ctx, depth = 0, seen = new Set()) {
+  if (depth > MAX_DEPTH || seen.has(subject)) {
+    return ctx.blanks.has(subject) ? null : subject;
+  }
+  const preds = ctx.bySubject.get(subject);
+  if (!preds) return ctx.blanks.has(subject) ? null : subject;
+
+  const path = new Set(seen).add(subject);
+  const out = {};
+  const id = readProperty(subject, 'id', ctx, depth, path);
+  if (id !== undefined) out.id = id;
+  const type = readProperty(subject, 'type', ctx, depth, path);
+  if (type !== undefined) out.type = type;
+
+  for (const predicate of preds.keys()) {
+    if (predicate === RDF_TYPE || predicate === RDF_FIRST || predicate === RDF_REST) continue;
+    // A predicate no context we hold names cannot be asked for by name, so it
+    // is left out rather than carried under an IRI no handler would look up.
+    for (const name of NAMES_BY_IRI.get(predicate) ?? []) {
+      if (name === 'id' || name === 'type') continue;
+      const value = readProperty(subject, name, ctx, depth, path);
+      if (value !== undefined) out[name] = value;
+    }
+  }
+  return out;
+}
+
+/**
+ * A reader over `parseAS2`'s quads.
+ *
+ * Returns null when there is nothing to read, which is the same answer the
+ * document-shaped read gave for bytes that were not a document.
+ */
+export function graphView(quads, { root = null } = {}) {
+  if (!quads || !quads.length) return null;
+  const ctx = indexQuads(quads);
+  const subject = root ?? findRoot(ctx);
+  if (!subject) return null;
+  const view = makeView(subject, ctx);
+  return (view && typeof view === 'object') ? view : null;
+}
+
+export { TERMS, BY_IRI };