diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 5f1a475..6b65125 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -6,31 +6,47 @@ on:
   pull_request:
     branches: [main]
 
+# Least privilege: this workflow only reads the repo and uploads artifacts.
+permissions:
+  contents: read
+
 jobs:
   wordpress:
     name: WordPress Plugin
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
         with:
           persist-credentials: false
 
-      - uses: shivammathur/setup-php@v2
+      - uses: shivammathur/setup-php@b604ade2a87db23f8871b7182e69ec5e75effb45 # v2
         with:
           php-version: "8.3"
           extensions: intl, mbstring, mysqli
           tools: composer
 
-      - name: Configure private dep access
-        env:
-          TOKEN: ${{ secrets.HTMLTRUST_PKG_TOKEN }}
-        run: |
-          git config --global url."https://x-access-token:${TOKEN}@github.com/".insteadOf "https://github.com/"
-          composer config --global github-oauth.github.com "${TOKEN}"
-
+      # The package token used to be written to ~/.gitconfig and to composer's
+      # global auth.json, where every later step -- including any composer
+      # plugin or lifecycle script -- could read it back. It is now passed
+      # through COMPOSER_AUTH and GIT_CONFIG_*, which are scoped to this
+      # process tree and never persisted to disk. --no-scripts and --no-plugins
+      # stop third-party install hooks (dealerdirect/phpcodesniffer-composer-
+      # installer among them) from running while the token is in the
+      # environment; vendor/ is excluded from the packaged zip below, so
+      # nothing downstream depends on those hooks having run.
+      #
+      # HTMLTRUST_PKG_TOKEN must be a fine-grained PAT scoped to the
+      # HTMLTrust/htmltrust-canonicalization repository with Contents: Read and
+      # nothing else. A classic `repo`-scoped token grants write access to every
+      # repo the owner can reach and must not be used here.
       - name: Install dependencies
         working-directory: wordpress
-        run: composer install --no-interaction --prefer-dist
+        env:
+          COMPOSER_AUTH: '{"github-oauth":{"github.com":"${{ secrets.HTMLTRUST_PKG_TOKEN }}"}}'
+          GIT_CONFIG_COUNT: "1"
+          GIT_CONFIG_KEY_0: url.https://x-access-token:${{ secrets.HTMLTRUST_PKG_TOKEN }}@github.com/.insteadOf
+          GIT_CONFIG_VALUE_0: https://github.com/
+        run: composer install --no-interaction --prefer-dist --no-scripts --no-plugins
 
       - name: Package plugin
         run: |
@@ -39,7 +55,7 @@ jobs:
           zip -r ../dist/htmltrust-wordpress-plugin.zip . \
             -x "vendor/*" "tests/*" "bin/*" "composer.lock" "phpunit.xml"
 
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:
           name: wordpress-plugin
           path: dist/htmltrust-wordpress-plugin.zip
@@ -48,7 +64,9 @@ jobs:
     name: Hugo Integration
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
+        with:
+          persist-credentials: false
 
       - name: Verify Hugo partials syntax
         run: |
@@ -57,7 +75,7 @@ jobs:
           test -s hugo/layouts/partials/htmltrust-meta.html && echo "  ✓ htmltrust-meta.html"
           test -s hugo/scripts/sign-site.mjs && echo "  ✓ sign-site.mjs"
 
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:
           name: hugo-integration
           path: |
diff --git a/README.md b/README.md
index d470ef3..1814003 100644
--- a/README.md
+++ b/README.md
@@ -50,7 +50,7 @@ htmltrust-cms-reference/
 ### Prerequisites
 
 - WordPress 5.0+
-- PHP 7.0+
+- PHP 7.2+
 - A running [HTMLTrust trust directory server](https://github.com/HTMLTrust/htmltrust-server-reference)
 
 ### Installation
@@ -82,12 +82,15 @@ composer test
 
 ## The HTML Protocol
 
-Signed content is embedded using data attributes that the browser extension recognizes:
+Signed content is embedded with a `<signed-section>` wrapper around the actual signed content:
 
 ```html
 <signed-section keyid="did:web:author.example"
     signature="BASE64_SIG" algorithm="ed25519"
-    content-hash="sha256:abc123...">
+    content-hash="sha256:47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU">
+  <meta name="author" content="Alice Example">
+  <meta name="signed-at" content="2026-05-01T10:30:00Z">
+  <meta name="claim:ContentType" content="Article">
   <article>
     <h1>Verifiable Web Content</h1>
     <p>Content should be provable...</p>
diff --git a/docs/developer-guide.md b/docs/developer-guide.md
index 1c89a4f..1210a43 100644
--- a/docs/developer-guide.md
+++ b/docs/developer-guide.md
@@ -139,7 +139,7 @@ Stores details about each signature generated.
 | signing_author_id | VARCHAR | External author ID |
 | wp_user_id | BIGINT | WordPress user ID |
 | content_hash | VARCHAR | Content hash |
-| domain | VARCHAR | Domain |
+| domain | VARCHAR | Serialized Web origin stored in the legacy-named API field |
 | signature | TEXT | Signature data |
 | claims_json | TEXT | Claims as JSON |
 | status | VARCHAR | Signature status |
@@ -364,4 +364,4 @@ wp i18n make-json languages/content-signing-LOCALE.po
 
 - Keep API keys secure
 - Validate and sanitize all user input
-- Follow WordPress security best practices
\ No newline at end of file
+- Follow WordPress security best practices
diff --git a/docs/html-protocol.md b/docs/html-protocol.md
index 3cc4f27..fb25ee9 100644
--- a/docs/html-protocol.md
+++ b/docs/html-protocol.md
@@ -4,7 +4,7 @@ This document specifies how content publishers embed cryptographic signatures in
 
 ## Overview
 
-Signed content uses the `<signed-section>` custom HTML element, as defined in the [HTMLTrust specification](https://github.com/HTMLTrust/htmltrust-spec). This element wraps or accompanies signed content and carries the cryptographic signature as attributes.
+Signed content uses the `<signed-section>` custom HTML element, as defined in the [HTMLTrust specification](https://github.com/HTMLTrust/htmltrust-spec). This element wraps the signed content and carries the cryptographic signature as attributes.
 
 ## The `<signed-section>` Element
 
@@ -16,7 +16,7 @@ Per spec §2.1, the wrapper element carries exactly four required attributes:
 |---|---|---|
 | `keyid` | Identifies the signer; resolved per the rules in **Identity and Key Resolution** below. May be a DID, a direct URL to a public key document, or a trust-directory reference. | `keyid="did:web:author.example"` |
 | `signature` | Base64-encoded (unpadded) cryptographic signature over the canonical binding string defined in **Signature Data Format** | `signature="aBcDeF123..."` |
-| `content-hash` | Hash of the canonicalized text content, prefixed with the hash algorithm | `content-hash="sha256:abc123def456..."` |
+| `content-hash` | Hash of the canonicalized content, prefixed with the hash algorithm and encoded as unpadded standard Base64 | `content-hash="sha256:47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU"` |
 | `algorithm` | Signature algorithm. Required by the spec; implementations MAY default to `ed25519` when the attribute is omitted, but producers SHOULD always emit it explicitly. | `algorithm="ed25519"` |
 
 ### Optional Attributes
@@ -59,14 +59,14 @@ Custom claim types are permitted. The claim vocabulary is extensible.
 
 ## HTML Structure
 
-The `<signed-section>` element can either **wrap** the signed content:
+The `<signed-section>` element wraps the signed content:
 
 ```html
 <signed-section
     signature="BASE64_SIG"
     keyid="https://api.example.com/authors/123/public-key"
     algorithm="ed25519"
-    content-hash="sha256:abc123def456...">
+    content-hash="sha256:47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU">
   <meta name="author" content="Alice Example">
   <meta name="signed-at" content="2025-05-01T10:30:00Z">
   <meta name="claim:ContentType" content="Article">
@@ -79,26 +79,7 @@ The `<signed-section>` element can either **wrap** the signed content:
 </signed-section>
 ```
 
-Or appear as a **standalone marker** alongside content (e.g., when added by a CMS after the content):
-
-```html
-<article>
-  <h1>Verifiable Web Content</h1>
-  <p>This content is signed and verifiable.</p>
-</article>
-<signed-section
-    signature="BASE64_SIG"
-    keyid="https://api.example.com/authors/123/public-key"
-    algorithm="ed25519"
-    content-hash="sha256:abc123def456...">
-  <meta name="author" content="Alice Example">
-  <meta name="signed-at" content="2025-05-01T10:30:00Z">
-  <meta name="claim:ContentType" content="Article">
-  <meta name="claim:License" content="CC-BY-4.0">
-</signed-section>
-```
-
-Both forms are valid. Verifying clients should handle either case.
+CMS integrations should not emit a detached `<signed-section>` containing only metadata. Compatibility UI such as badges and verification buttons should live outside the signed section.
 
 ## Identity and Key Resolution
 
@@ -116,17 +97,18 @@ User agents MAY cache resolved keys (with appropriate freshness and revocation h
 
 ## Canonical Content Extraction
 
-The hash that the signature covers is taken from the **text content** of the signed region, after the extraction and normalization process described below (spec §2.1). This is performed in two stages: HTML extraction, then text normalization.
+The hash that the signature covers is taken from the canonicalized signed region after extraction and normalization. The canonical content includes normalized text plus the signed semantic attributes `href`, `src`, `alt`, and `aria-label` when present on included elements.
 
 ### Stage 1: HTML extraction
 
 Given the inner contents of a `<signed-section>` element:
 
 1. **Strip excluded elements** entirely, including their text content: `<script>`, `<style>`, `<meta>`, `<link>`, `<head>`, `<noscript>`. (`<meta>` is excluded because, inside a signed-section, it carries claim metadata rather than signed content. Claim metadata is hashed separately into the `claims-hash` field.)
-2. **Insert a single space at every block-element boundary** (open and close tags of `<p>`, `<div>`, `<article>`, `<section>`, `<h1>`-`<h6>`, `<li>`, `<ul>`, `<ol>`, `<table>`, `<tr>`, `<td>`, `<th>`, `<header>`, `<footer>`, `<nav>`, `<main>`, `<aside>`, etc.) so that `<p>A</p><p>B</p>` extracts to `A B` and not `AB`. Inline elements (`<em>`, `<strong>`, `<a>`, `<span>`, etc.) do **not** introduce separators.
-3. **Strip all remaining markup** (inline tags and any attributes), preserving only the text content.
-4. **Decode HTML entities** (`&amp;`, `&lt;`, `&gt;`, named entities, numeric `&#nnn;` and `&#xhhhh;` entities).
-5. Pass the resulting string to text normalization.
+2. **Emit a line feed after every boundary-producing element** (`<p>`, `<div>`, `<article>`, `<section>`, `<h1>`-`<h6>`, `<li>`, `<ul>`, `<ol>`, `<table>`, `<tr>`, `<td>`, `<th>`, `<header>`, `<footer>`, `<nav>`, `<main>`, `<aside>`, etc.) so that `<p>A</p><p>B</p>` extracts to `A\nB` and not `AB`. The `br` element emits a line feed at its position. Inline elements (`<em>`, `<strong>`, `<a>`, `<span>`, etc.) do **not** introduce separators.
+3. **Include signed semantic attributes** on included elements in this order: `href`, `src`, `alt`, `aria-label`. `href` and `src` are resolved against the signed document base URL and serialized as URLs; `alt` and `aria-label` use text normalization.
+4. **Strip all remaining markup**, preserving text content and the signed attribute records.
+5. **Decode HTML entities** (`&amp;`, `&lt;`, `&gt;`, named entities, numeric `&#nnn;` and `&#xhhhh;` entities).
+6. Pass text and claim values to text normalization.
 
 ### Stage 2: Text normalization
 
@@ -141,16 +123,15 @@ The HTMLTrust canonicalization library applies, in order:
 
 The output is a UTF-8 string. Hashing produces `sha256:<base64>` where `<base64>` is the unpadded Base64 encoding of the 32-byte SHA-256 digest.
 
-**What is NOT covered by the hash.** Only the text content is hashed. HTML markup, element types, attributes (including `href`, `src`, `class`, `style`), and surrounding media are not part of the canonical content. This is a deliberate scoping choice; see **Text-only scope** below for the rationale and how HTMLTrust addresses the resulting semantic gaps through its layered design.
+**What is NOT covered by the hash.** Full markup, element types, layout attributes, classes, inline styles, and most ARIA attributes are not part of the canonical content. The current signed attribute set is deliberately small and covers `href`, `src`, `alt`, and `aria-label`.
 
 The reference implementation lives in the `@htmltrust/canonicalization` library, with byte-identical bindings for JavaScript, Go, PHP, Python, and Rust.
 
-### Text-only scope
+### Signed-content scope
 
-The canonicalization hashes **text content only**, not the HTML markup or attributes that surround it. This means an adversary with possession of signed text MAY:
+The canonicalization hashes normalized text plus the small signed semantic attribute set, not the full HTML structure. This means an adversary with possession of signed content MAY:
 
 - Rewrap the text in misleading block elements (e.g., change an `<h1>` to a `<del>` strikethrough)
-- Alter link destinations (`href` values) on `<a>` elements surrounding the signed text
 - Introduce, remove, or swap images and other media around the signed text
 
 These are **semantic integrity concerns**, not cryptographic ones. HTMLTrust addresses them through a layered design:
@@ -160,7 +141,7 @@ These are **semantic integrity concerns**, not cryptographic ones. HTMLTrust add
 
 The layered design keeps cryptographic verification simple and portable across language implementations, while delegating semantic-integrity detection to the research ecosystem where it can evolve without breaking existing signatures.
 
-**Open design question**: a future revision MAY extend the hash to cover particularly meaningful attributes, especially `href` on `<a>` elements (since link-swap within the original publication origin is a phishing vector that domain-binding and research cannot address alone). Feedback on which attributes to cover is explicitly welcome.
+Future revisions MAY extend the signed attribute list. Verifiers for this revision use exactly `href`, `src`, `alt`, and `aria-label`.
 
 ## Signature Data Format
 
@@ -172,17 +153,17 @@ The signature binds four values, concatenated with `:` separators:
 
 - `content-hash` — hash of the canonicalized text content (see above)
 - `claims-hash` — SHA-256 hash of the canonical serialization of all inner `<meta>` claim elements, ordered lexically by name (ensures tamper-evident claim metadata)
-- `domain` — the origin where the content is authoritatively published (anti-theft binding)
+- `domain` — the serialized Web origin where the content is authoritatively published, using the legacy field name retained by the protocol
 - `signed-at` — the ISO-8601 timestamp from the `<meta name="signed-at">` element
 
 For example:
 ```
-sha256:RAyBCvKT...:sha256:eFgHiJkL...:example.com:2025-05-01T10:30:00Z
+sha256:RAyBCvKT...:sha256:eFgHiJkL...:https://example.com:2025-05-01T10:30:00Z
 ```
 
 The author's identity is **not** included in the binding because it is implicit in the keyid resolution step: any attempt to claim a signature under a different identity would resolve to a different public key and fail verification. This string is signed with the author's private key using the algorithm declared in the `algorithm` attribute.
 
-**Hash encoding (open feedback)**: hashes are encoded as unpadded Base64, which is shorter than hexadecimal by roughly one-third. Community feedback on alternative encodings (hex, Base32) for ecosystem alignment is welcome.
+Hashes and signatures are encoded as canonical unpadded standard Base64. This is not hex and not base64url.
 
 ## Verification Flow
 
diff --git a/hugo/README.md b/hugo/README.md
index e6a1823..2dc7811 100644
--- a/hugo/README.md
+++ b/hugo/README.md
@@ -4,9 +4,9 @@ This directory contains tools for integrating HTMLTrust content signing with [Hu
 
 ## How It Works
 
-A Hugo partial computes SHA-256 content hashes and outputs `<signed-section>` elements during the normal `hugo build` — no post-processing or external tools required for content hashing.
+A Hugo partial wraps page content in `<signed-section>` and emits direct child claim metadata during the normal `hugo build`.
 
-For full cryptographic signing (binding content to an author's private key via a trust directory), an optional post-build script can fill in `signature` and `keyid` attributes by calling the API.
+For content hashing and full cryptographic signing (binding content to an author's private key via a trust directory), run the post-build script. The script computes the spec wire hash as `sha256:<unpadded standard Base64>`, fills in `signature` and `keyid`, and preserves the signed wrapper.
 
 ## Quick Start
 
@@ -51,15 +51,16 @@ htmltrust:
 hugo --minify
 ```
 
-That's it. Every page with `htmltrust.sign: true` will have its content wrapped in a `<signed-section>` element with:
-- `content-hash` — SHA-256 hash of the canonicalized content
+Every page with `htmltrust.sign: true` will have its content wrapped in a `<signed-section>` element with:
 - Inner `<meta>` tags for author, timestamp, and claims
 - The actual page content
 
+Run the post-build script to add the required `content-hash`, `signature`, `keyid`, and `algorithm` attributes.
+
 ## What Gets Generated
 
 ```html
-<signed-section content-hash="sha256:abc123..." style="display: block;">
+<signed-section>
   <meta name="author" content="Jason Grey">
   <meta name="signed-at" content="2025-05-12T10:30:00Z">
   <meta name="claim:ContentType" content="Article">
@@ -72,7 +73,7 @@ That's it. Every page with `htmltrust.sign: true` will have its content wrapped
 
 ## Optional: API-Based Cryptographic Signing
 
-To add full cryptographic signatures (the `signature`, `keyid`, and `algorithm` attributes), use the post-build script after `hugo build`:
+To add spec-conformant content hashes and full cryptographic signatures, use the post-build script after `hugo build`:
 
 ```sh
 hugo --minify
@@ -85,10 +86,10 @@ This requires a running [HTMLTrust trust directory server](https://github.com/HT
 export HTMLTRUST_API_URL=http://localhost:3000
 export HTMLTRUST_AUTHOR_API_KEY=your_author_api_key
 export HTMLTRUST_AUTHOR_ID=your_author_id
-export HTMLTRUST_DOMAIN=yourdomain.com
+export HTMLTRUST_DOMAIN=https://yourdomain.com
 ```
 
-The script finds existing `<signed-section>` elements (already wrapping the content from the Hugo build) and adds the missing `signature`, `keyid`, and `algorithm` attributes.
+The script finds existing `<signed-section>` elements (already wrapping the content from the Hugo build) and adds or replaces the `content-hash`, `signature`, `keyid`, and `algorithm` attributes. If a page was not built with the partial, the script wraps the selected element instead of appending a detached marker.
 
 ## Files
 
@@ -104,10 +105,8 @@ hugo/
 
 ## Canonicalization
 
-The partial canonicalizes content by:
-1. Stripping all HTML tags (Hugo's `plainify`)
-2. Collapsing all whitespace to single spaces (`replaceRE`)
-3. Trimming leading/trailing whitespace (`strings.TrimSpace`)
-4. Computing SHA-256 hash (Hugo's `sha256`)
-
-This matches the canonicalization used by the WordPress plugin and browser extension.
\ No newline at end of file
+The post-build script canonicalizes content by:
+1. Excluding claim and executable elements such as `meta`, `script`, `style`, and `iframe`
+2. Including signed semantic attributes: `href`, `src`, `alt`, and `aria-label`
+3. Collapsing whitespace and computing a SHA-256 digest
+4. Encoding the digest as canonical unpadded standard Base64
diff --git a/hugo/layouts/partials/htmltrust-signed-section.html b/hugo/layouts/partials/htmltrust-signed-section.html
index 6f05f14..efb28e0 100644
--- a/hugo/layouts/partials/htmltrust-signed-section.html
+++ b/hugo/layouts/partials/htmltrust-signed-section.html
@@ -1,13 +1,10 @@
 {{- if and .Params.htmltrust .Params.htmltrust.sign -}}
-{{- $plain := .Content | plainify -}}
-{{- $canonical := $plain | replaceRE `\s+` " " | strings.TrimSpace -}}
-{{- $hash := printf "sha256:%s" (sha256 $canonical) -}}
-<signed-section content-hash="{{ $hash }}" style="display: block;">
+<signed-section{{ with .Params.htmltrust.signature }} signature="{{ . }}"{{ end }}{{ with .Params.htmltrust.keyid }} keyid="{{ . }}"{{ end }}{{ with .Params.htmltrust.algorithm }} algorithm="{{ . }}"{{ end }}{{ with .Params.htmltrust.contentHash }} content-hash="{{ . }}"{{ end }}>
   {{- with .Params.author | default .Site.Params.author }}
   <meta name="author" content="{{ . }}">
   {{- end }}
   {{- if not .Date.IsZero }}
-  <meta name="signed-at" content="{{ .Date.Format "2006-01-02T15:04:05Z07:00" }}">
+  <meta name="signed-at" content="{{ .Date.UTC.Format "2006-01-02T15:04:05Z" }}">
   {{- end }}
   {{- with .Params.htmltrust.claims }}
   {{- range $key, $value := . }}
diff --git a/hugo/scripts/sign-site.mjs b/hugo/scripts/sign-site.mjs
index cdf138e..b120453 100644
--- a/hugo/scripts/sign-site.mjs
+++ b/hugo/scripts/sign-site.mjs
@@ -14,7 +14,7 @@
  *   HTMLTRUST_API_URL          - Trust directory server URL (default: http://localhost:3000)
  *   HTMLTRUST_AUTHOR_API_KEY   - Author API key for signing
  *   HTMLTRUST_AUTHOR_ID        - Author ID on the trust directory
- *   HTMLTRUST_DOMAIN           - Domain for signatures (default: from baseURL in hugo config)
+ *   HTMLTRUST_DOMAIN           - Serialized publication origin for signatures
  */
 
 import { readFileSync, writeFileSync, readdirSync, statSync } from "fs";
@@ -29,7 +29,7 @@ const AUTHOR_ID = process.env.HTMLTRUST_AUTHOR_ID || "";
 const args = process.argv.slice(2);
 let outputDir = "public";
 let selector = "article";
-let domain = process.env.HTMLTRUST_DOMAIN || "www.htmltrust.org";
+let domain = process.env.HTMLTRUST_DOMAIN || "https://www.htmltrust.org";
 
 for (let i = 0; i < args.length; i++) {
   if (args[i] === "--dir" && args[i + 1]) outputDir = args[++i];
@@ -55,25 +55,186 @@ function findHtmlFiles(dir) {
 }
 
 /**
- * Extract text content from an HTML string by stripping tags.
- * This is a simple implementation — matches the canonicalization
- * used by the WordPress and browser reference implementations.
+ * Convert the configured domain value to the serialized Web origin bound into
+ * the legacy-named domain field.
  */
-function canonicalize(html) {
-  return html
-    .replace(/<[^>]*>/g, "") // Strip HTML tags
-    .replace(/\s+/g, " ") // Collapse whitespace
+function normalizeOrigin(value) {
+  const candidate = /^[a-z][a-z0-9+.-]*:/i.test(value)
+    ? value
+    : `https://${value}`;
+  const url = new URL(candidate);
+  url.hash = "";
+  url.search = "";
+  url.pathname = "";
+  url.username = "";
+  url.password = "";
+  return url.origin;
+}
+
+/**
+ * Extract signed semantic attributes before stripping markup.
+ */
+function canonicalize(html, baseUrl) {
+  const excluded = [
+    "script",
+    "style",
+    "template",
+    "noscript",
+    "iframe",
+    "meta",
+  ];
+  const blockElements = [
+    "address",
+    "article",
+    "aside",
+    "blockquote",
+    "details",
+    "dialog",
+    "div",
+    "dl",
+    "fieldset",
+    "figcaption",
+    "figure",
+    "footer",
+    "form",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "header",
+    "hgroup",
+    "hr",
+    "li",
+    "main",
+    "nav",
+    "ol",
+    "p",
+    "pre",
+    "section",
+    "table",
+    "td",
+    "th",
+    "tr",
+    "ul",
+  ];
+
+  let canonical = html;
+  for (const name of excluded) {
+    canonical = canonical.replace(
+      new RegExp(`<${name}\\b[^>]*>[\\s\\S]*?<\\/${name}>`, "gi"),
+      "",
+    );
+    canonical = canonical.replace(new RegExp(`<${name}\\b[^>]*>`, "gi"), "");
+  }
+
+  canonical = canonical.replace(
+    /<([a-zA-Z][a-zA-Z0-9:-]*)(\s[^>]*)?>/g,
+    (match, rawName, rawAttrs = "") => {
+      const name = rawName.toLowerCase();
+      const attrs = parseAttributes(rawAttrs);
+      const records = ["href", "src", "alt", "aria-label"]
+        .filter((attribute) => Object.prototype.hasOwnProperty.call(attrs, attribute))
+        .map((attribute) => {
+          const value =
+            attribute === "href" || attribute === "src"
+              ? normalizeUrlAttribute(attrs[attribute], baseUrl)
+              : normalizeText(attrs[attribute]);
+          return `@attr:${name}:${attribute}:${value}\n`;
+        })
+        .join("");
+      return `${records}${name === "br" ? "\n" : ""}`;
+    },
+  );
+
+  canonical = canonical.replace(/<\/([a-zA-Z][a-zA-Z0-9:-]*)>/g, (match, rawName) =>
+    blockElements.includes(rawName.toLowerCase()) ? "\n" : "",
+  );
+
+  return normalizeCanonical(canonical);
+}
+
+/**
+ * Parse quoted and unquoted HTML attributes from a start tag.
+ */
+function parseAttributes(rawAttrs) {
+  const attrs = {};
+  const attrPattern =
+    /([^\s"'<>/=]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g;
+  let match;
+  while ((match = attrPattern.exec(rawAttrs))) {
+    attrs[match[1].toLowerCase()] = match[2] ?? match[3] ?? match[4] ?? "";
+  }
+  return attrs;
+}
+
+function normalizeUrlAttribute(value, baseUrl) {
+  return new URL(decodeHtml(value.trim()), baseUrl).href.replace(/\n/g, " ");
+}
+
+function normalizeText(value) {
+  return value.normalize("NFKC").replace(/\s+/g, " ").trim();
+}
+
+function normalizeCanonical(value) {
+  return decodeHtml(value)
+    .split(/(@attr:[^\n]*\n)/g)
+    .map((part) => {
+      if (part.startsWith("@attr:")) return part;
+      return part
+        .split(/\n+/)
+        .map((line) => normalizeText(line))
+        .filter(Boolean)
+        .join("\n");
+    })
+    .join("")
+    .replace(/[ \t]+/g, " ")
+    .replace(/[ \t]*\n[ \t]*/g, "\n")
+    .replace(/\n{2,}/g, "\n")
     .trim();
 }
 
+function decodeHtml(value) {
+  return value
+    .replace(/&nbsp;/gi, " ")
+    .replace(/&amp;/gi, "&")
+    .replace(/&lt;/gi, "<")
+    .replace(/&gt;/gi, ">")
+    .replace(/&quot;/gi, '"')
+    .replace(/&#39;/g, "'");
+}
+
 /**
  * Compute SHA-256 hash of canonical content.
  */
 function hashContent(text) {
-  const hash = createHash("sha256").update(text, "utf8").digest("hex");
+  const hash = createHash("sha256")
+    .update(text, "utf8")
+    .digest("base64")
+    .replace(/=+$/g, "");
   return `sha256:${hash}`;
 }
 
+function compareByCodePoint(left, right) {
+  const a = Array.from(left);
+  const b = Array.from(right);
+  const length = Math.min(a.length, b.length);
+  for (let i = 0; i < length; i++) {
+    const difference = a[i].codePointAt(0) - b[i].codePointAt(0);
+    if (difference !== 0) return difference;
+  }
+  return a.length - b.length;
+}
+
+function canonicalizeClaims(claims) {
+  return Object.entries(claims)
+    .map(([name, value]) => [normalizeText(name), normalizeText(String(value))])
+    .sort(([left], [right]) => compareByCodePoint(left, right))
+    .map(([name, value]) => `${name}:${value}\n`)
+    .join("");
+}
+
 /**
  * Extract content between the first matching open and close tags for
  * the configured selector element.
@@ -92,6 +253,40 @@ function extractArticle(html) {
   return html.substring(start, end + closeTag.length);
 }
 
+/**
+ * Extract an existing signed-section wrapper if the Hugo partial already ran.
+ */
+function extractSignedSection(html) {
+  const match = html.match(/<signed-section\b[^>]*>[\s\S]*?<\/signed-section>/i);
+  if (!match) return null;
+
+  const wrapper = match[0];
+  const openEnd = wrapper.indexOf(">");
+  return {
+    start: match.index,
+    end: match.index + wrapper.length,
+    inner: wrapper.substring(openEnd + 1, wrapper.length - "</signed-section>".length),
+  };
+}
+
+/**
+ * Build a direct meta claim map from a signed-section body.
+ */
+function extractClaims(innerHtml) {
+  const claims = {};
+  const metaPattern = /<meta\b([^>]*)>/gi;
+  let match;
+
+  while ((match = metaPattern.exec(innerHtml))) {
+    const attrs = parseAttributes(match[1]);
+    if (attrs.name && Object.prototype.hasOwnProperty.call(attrs, "content")) {
+      claims[normalizeText(attrs.name)] = normalizeText(attrs.content);
+    }
+  }
+
+  return claims;
+}
+
 /**
  * Call the HTMLTrust trust directory API to sign a content hash.
  */
@@ -112,7 +307,9 @@ async function signWithApi(contentHash, claims = {}) {
       },
       body: JSON.stringify({
         contentHash,
+        claimsHash: hashContent(canonicalizeClaims(claims)),
         domain,
+        signedAt: claims["signed-at"],
         claims,
       }),
     });
@@ -123,7 +320,12 @@ async function signWithApi(contentHash, claims = {}) {
       return null;
     }
 
-    return await response.json();
+    const result = await response.json();
+    if (!result?.signature || !result?.keyid || !result?.algorithm) {
+      console.warn("  ⚠ API response omitted signature, keyid, or algorithm");
+      return null;
+    }
+    return result;
   } catch (err) {
     console.warn(`  ⚠ API request failed: ${err.message}`);
     return null;
@@ -133,31 +335,37 @@ async function signWithApi(contentHash, claims = {}) {
 /**
  * Build the signature HTML block to inject.
  */
-function buildSignatureHtml(result, contentHash) {
-  const pubKeyUrl = `${API_URL}/api/authors/${AUTHOR_ID}/public-key`;
-
-  let innerMeta = "";
+function buildSignedSectionOpen(result, contentHash) {
+  const keyid =
+    result.keyid ||
+    result.keyId ||
+    result.publicKeyUrl ||
+    `${API_URL}/api/authors/${AUTHOR_ID}/public-key`;
+
+  return `<signed-section signature="${escapeAttr(result.signature)}" keyid="${escapeAttr(
+    keyid,
+  )}" algorithm="${escapeAttr(result.algorithm)}" content-hash="${escapeAttr(contentHash)}">`;
+}
 
-  // Timestamp
-  if (result.createdAt) {
-    innerMeta += `\n  <meta name="signed-at" content="${result.createdAt}">`;
-  }
+function buildUnsignedSectionOpen(contentHash) {
+  return `<signed-section content-hash="${escapeAttr(contentHash)}">`;
+}
 
-  // Claims
-  if (result.claims && typeof result.claims === "object") {
-    for (const [key, value] of Object.entries(result.claims)) {
-      innerMeta += `\n  <meta name="claim:${key}" content="${value}">`;
-    }
-  }
+function buildClaimMeta(claims) {
+  return Object.entries(claims)
+    .map(
+      ([name, content]) =>
+        `<meta name="${escapeAttr(name)}" content="${escapeAttr(content)}">`,
+    )
+    .join("");
+}
 
-  return `
-<signed-section
-    signature="${result.signature}"
-    keyid="${pubKeyUrl}"
-    algorithm="ed25519"
-    content-hash="${contentHash}"
-    style="display: block;">${innerMeta}
-</signed-section>`;
+function escapeAttr(value) {
+  return String(value)
+    .replace(/&/g, "&amp;")
+    .replace(/"/g, "&quot;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;");
 }
 
 /**
@@ -165,39 +373,50 @@ function buildSignatureHtml(result, contentHash) {
  */
 async function processFile(filePath) {
   const html = readFileSync(filePath, "utf8");
-  const articleHtml = extractArticle(html);
+  const existingSection = extractSignedSection(html);
+  const articleHtml = existingSection ? existingSection.inner : extractArticle(html);
 
   if (!articleHtml) return false;
 
-  const canonical = canonicalize(articleHtml);
+  const relUrl = filePath
+    .replace(resolve(outputDir), "")
+    .replace(/\\/g, "/")
+    .replace(/\/index\.html$/, "/");
+  const baseUrl = new URL(relUrl || "/", `${domain}/`).href;
+  const canonical = canonicalize(articleHtml, baseUrl);
   if (!canonical || canonical.length < 10) return false; // Skip trivial content
 
   const contentHash = hashContent(canonical);
   console.log(`  Hash: ${contentHash.substring(0, 20)}...`);
 
-  const result = await signWithApi(contentHash);
-  if (!result) {
-    // Even without API, inject the hash for future signing
-    const placeholder = `\n<signed-section content-hash="${contentHash}" style="display: block;"></signed-section>`;
-    const closeTag = `</${selector}>`;
-    const insertPos = html.indexOf(closeTag, html.indexOf(`<${selector}`));
-    if (insertPos !== -1) {
-      const newHtml =
-        html.substring(0, insertPos + closeTag.length) +
-        placeholder +
-        html.substring(insertPos + closeTag.length);
-      writeFileSync(filePath, newHtml, "utf8");
-    }
+  const claims = existingSection ? extractClaims(existingSection.inner) : {};
+  const result = await signWithApi(contentHash, claims);
+  const openTag = result
+    ? buildSignedSectionOpen(result, contentHash)
+    : buildUnsignedSectionOpen(contentHash);
+
+  if (existingSection) {
+    const newHtml =
+      html.substring(0, existingSection.start) +
+      openTag +
+      existingSection.inner +
+      "</signed-section>" +
+      html.substring(existingSection.end);
+    writeFileSync(filePath, newHtml, "utf8");
     return true;
   }
 
-  const signatureHtml = buildSignatureHtml(result, contentHash);
   const closeTag = `</${selector}>`;
-  const insertPos = html.indexOf(closeTag, html.indexOf(`<${selector}`));
-  if (insertPos !== -1) {
+  const start = html.indexOf(`<${selector}`);
+  const insertPos = html.indexOf(closeTag, start);
+  if (start !== -1 && insertPos !== -1) {
+    const article = html.substring(start, insertPos + closeTag.length);
     const newHtml =
-      html.substring(0, insertPos + closeTag.length) +
-      signatureHtml +
+      html.substring(0, start) +
+      openTag +
+      buildClaimMeta(claims) +
+      article +
+      "</signed-section>" +
       html.substring(insertPos + closeTag.length);
     writeFileSync(filePath, newHtml, "utf8");
   }
@@ -207,6 +426,7 @@ async function processFile(filePath) {
 
 // Main
 async function main() {
+  domain = normalizeOrigin(domain);
   const dir = resolve(outputDir);
   console.log(`\nHTMLTrust Hugo Signing`);
   console.log(`  Output dir: ${dir}`);
diff --git a/wordpress/admin/class-content-signing-admin-post-meta-box.php b/wordpress/admin/class-content-signing-admin-post-meta-box.php
index b874fbf..bc8e1d9 100644
--- a/wordpress/admin/class-content-signing-admin-post-meta-box.php
+++ b/wordpress/admin/class-content-signing-admin-post-meta-box.php
@@ -262,13 +262,18 @@ public function enqueue_scripts() {
             false
         );
         
+        // The sign and verify AJAX handlers verify a post-scoped nonce, so the
+        // one handed to the script has to be minted for the post being edited.
+        $post = get_post();
+        $post_id = $post ? $post->ID : 0;
+
         // Localize script
         wp_localize_script(
             'content-signing-post-meta-box',
             'content_signing_post_meta_box',
             array(
                 'ajax_url' => admin_url('admin-ajax.php'),
-                'nonce' => wp_create_nonce('content_signing_nonce'),
+                'nonce' => wp_create_nonce('content_signing_post_' . $post_id),
                 'sign_post_confirm' => __('Are you sure you want to sign this post?', 'content-signing'),
                 'signing_text' => __('Signing...', 'content-signing'),
                 'verifying_text' => __('Verifying...', 'content-signing'),
diff --git a/wordpress/admin/js/content-signing-post-meta-box.js b/wordpress/admin/js/content-signing-post-meta-box.js
index 353e209..5112b71 100644
--- a/wordpress/admin/js/content-signing-post-meta-box.js
+++ b/wordpress/admin/js/content-signing-post-meta-box.js
@@ -114,16 +114,24 @@
                     if (response.success) {
                         // Show success message
                         const resultClass = response.data.valid ? 'valid' : 'invalid';
-                        const resultText = response.data.valid ? 
-                            content_signing_post_meta_box.valid_text : 
+                        const resultText = response.data.valid ?
+                            content_signing_post_meta_box.valid_text :
                             content_signing_post_meta_box.invalid_text;
-                        
-                        const $result = $('<div class="verify-result ' + resultClass + '">' + resultText + '</div>');
+
+                        // Built with .text(): resultText is local, but the
+                        // branch below carries trust-server strings and both
+                        // paths must stay markup-free.
+                        const $result = $('<div>')
+                            .addClass('verify-result ' + resultClass)
+                            .text(resultText);
                         $listItem.append($result);
                     } else {
-                        // Show error message
+                        // Show error message. response.data.message is relayed
+                        // verbatim from the trust server and is untrusted.
                         const errorMessage = response.data && response.data.message ? response.data.message : content_signing_post_meta_box.error_text;
-                        const $result = $('<div class="verify-result invalid">' + content_signing_post_meta_box.error_text + ' ' + errorMessage + '</div>');
+                        const $result = $('<div>')
+                            .addClass('verify-result invalid')
+                            .text(content_signing_post_meta_box.error_text + ' ' + errorMessage);
                         $listItem.append($result);
                     }
                 },
@@ -133,7 +141,9 @@
                     $button.text(content_signing_post_meta_box.verify_text);
 
                     // Show error message
-                    const $result = $('<div class="verify-result invalid">' + content_signing_post_meta_box.error_text + ' ' + content_signing_post_meta_box.ajax_error + '</div>');
+                    const $result = $('<div>')
+                        .addClass('verify-result invalid')
+                        .text(content_signing_post_meta_box.error_text + ' ' + content_signing_post_meta_box.ajax_error);
                     $listItem.append($result);
                 }
             });
diff --git a/wordpress/composer.json b/wordpress/composer.json
index d302328..aff61c3 100644
--- a/wordpress/composer.json
+++ b/wordpress/composer.json
@@ -16,14 +16,14 @@
     }
   ],
   "require": {
-    "php": ">=7.0",
-    "htmltrust/canonicalization": "dev-main"
+    "php": ">=7.2",
+    "htmltrust/canonicalization": "^0.2.2"
   },
   "require-dev": {
     "phpunit/phpunit": "^9.5",
     "yoast/phpunit-polyfills": "^2.0",
     "squizlabs/php_codesniffer": "^3.6",
-    "wp-coding-standards/wpcs": "^2.3",
+    "wp-coding-standards/wpcs": "^3.4.1",
     "dealerdirect/phpcodesniffer-composer-installer": "^0.7.1"
   },
   "scripts": {
diff --git a/wordpress/composer.lock b/wordpress/composer.lock
index 32ea0b0..872fa03 100644
--- a/wordpress/composer.lock
+++ b/wordpress/composer.lock
@@ -4,20 +4,20 @@
         "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies",
         "This file is @generated automatically"
     ],
-    "content-hash": "803423f2956b1ec253eb5ac86665e1d0",
+    "content-hash": "8201c59f2499047b36fae8d8dbae4895",
     "packages": [
         {
             "name": "htmltrust/canonicalization",
-            "version": "dev-main",
+            "version": "v0.2.2",
             "source": {
                 "type": "git",
-                "url": "git@github.com:HTMLTrust/htmltrust-canonicalization.git",
-                "reference": "7babc9610eeb6ca19d9134ea800a7fbe19f80ab9"
+                "url": "https://github.com/HTMLTrust/htmltrust-canonicalization.git",
+                "reference": "79b0d52fecd958f8fc7ade713fe0799ca1e79626"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/HTMLTrust/htmltrust-canonicalization/zipball/7babc9610eeb6ca19d9134ea800a7fbe19f80ab9",
-                "reference": "7babc9610eeb6ca19d9134ea800a7fbe19f80ab9",
+                "url": "https://api.github.com/repos/HTMLTrust/htmltrust-canonicalization/zipball/79b0d52fecd958f8fc7ade713fe0799ca1e79626",
+                "reference": "79b0d52fecd958f8fc7ade713fe0799ca1e79626",
                 "shasum": ""
             },
             "require": {
@@ -28,7 +28,6 @@
             "require-dev": {
                 "phpunit/phpunit": "^8.0 || ^9.0 || ^10.0"
             },
-            "default-branch": true,
             "type": "library",
             "autoload": {
                 "psr-4": {
@@ -41,14 +40,20 @@
                 }
             },
             "license": [
-                "MIT"
+                "LicenseRef-PolyForm-Noncommercial-1.0.0"
             ],
             "description": "HTMLTrust canonical text normalization for PHP",
             "support": {
-                "source": "https://github.com/HTMLTrust/htmltrust-canonicalization/tree/v0.1.0",
+                "source": "https://github.com/HTMLTrust/htmltrust-canonicalization/tree/v0.2.2",
                 "issues": "https://github.com/HTMLTrust/htmltrust-canonicalization/issues"
             },
-            "time": "2026-04-06T00:39:23+00:00"
+            "funding": [
+                {
+                    "type": "github",
+                    "url": "https://github.com/jt55401"
+                }
+            ],
+            "time": "2026-08-27T21:56:42+00:00"
         }
     ],
     "packages-dev": [
@@ -433,6 +438,181 @@
             },
             "time": "2022-02-21T01:04:05+00:00"
         },
+        {
+            "name": "phpcsstandards/phpcsextra",
+            "version": "1.5.1",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/PHPCSStandards/PHPCSExtra.git",
+                "reference": "39467533fdb742446d68c1d10ac33d625ee0311c"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/PHPCSStandards/PHPCSExtra/zipball/39467533fdb742446d68c1d10ac33d625ee0311c",
+                "reference": "39467533fdb742446d68c1d10ac33d625ee0311c",
+                "shasum": ""
+            },
+            "require": {
+                "php": ">=5.4",
+                "phpcsstandards/phpcsutils": "^1.2.3",
+                "squizlabs/php_codesniffer": "^3.13.5 || ^4.0.1"
+            },
+            "require-dev": {
+                "php-parallel-lint/php-console-highlighter": "^1.0",
+                "php-parallel-lint/php-parallel-lint": "^1.4.0",
+                "phpcsstandards/phpcsdevcs": "^1.2.0",
+                "phpcsstandards/phpcsdevtools": "^1.2.1",
+                "phpunit/phpunit": "^4.5 || ^5.0 || ^6.0 || ^7.0 || ^8.0 || ^9.3.4"
+            },
+            "type": "phpcodesniffer-standard",
+            "extra": {
+                "branch-alias": {
+                    "dev-stable": "1.x-dev",
+                    "dev-develop": "1.x-dev"
+                }
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "LGPL-3.0-or-later"
+            ],
+            "authors": [
+                {
+                    "name": "Juliette Reinders Folmer",
+                    "homepage": "https://github.com/jrfnl",
+                    "role": "lead"
+                },
+                {
+                    "name": "Contributors",
+                    "homepage": "https://github.com/PHPCSStandards/PHPCSExtra/graphs/contributors"
+                }
+            ],
+            "description": "A collection of sniffs and standards for use with PHP_CodeSniffer.",
+            "keywords": [
+                "PHP_CodeSniffer",
+                "phpcbf",
+                "phpcodesniffer-standard",
+                "phpcs",
+                "standards",
+                "static analysis"
+            ],
+            "support": {
+                "issues": "https://github.com/PHPCSStandards/PHPCSExtra/issues",
+                "security": "https://github.com/PHPCSStandards/PHPCSExtra/security/policy",
+                "source": "https://github.com/PHPCSStandards/PHPCSExtra"
+            },
+            "funding": [
+                {
+                    "url": "https://github.com/PHPCSStandards",
+                    "type": "github"
+                },
+                {
+                    "url": "https://github.com/jrfnl",
+                    "type": "github"
+                },
+                {
+                    "url": "https://opencollective.com/php_codesniffer",
+                    "type": "open_collective"
+                },
+                {
+                    "url": "https://thanks.dev/u/gh/phpcsstandards",
+                    "type": "thanks_dev"
+                }
+            ],
+            "time": "2026-07-27T11:13:17+00:00"
+        },
+        {
+            "name": "phpcsstandards/phpcsutils",
+            "version": "1.2.3",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/PHPCSStandards/PHPCSUtils.git",
+                "reference": "5f35d9408c54d7b529501f3c688b6eae562aea1f"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/PHPCSStandards/PHPCSUtils/zipball/5f35d9408c54d7b529501f3c688b6eae562aea1f",
+                "reference": "5f35d9408c54d7b529501f3c688b6eae562aea1f",
+                "shasum": ""
+            },
+            "require": {
+                "dealerdirect/phpcodesniffer-composer-installer": "^0.4.1 || ^0.5 || ^0.6.2 || ^0.7 || ^1.0",
+                "php": ">=5.4",
+                "squizlabs/php_codesniffer": "^3.13.5 || ^4.0.1"
+            },
+            "require-dev": {
+                "ext-filter": "*",
+                "php-parallel-lint/php-console-highlighter": "^1.0",
+                "php-parallel-lint/php-parallel-lint": "^1.4.0",
+                "phpcsstandards/phpcsdevcs": "^1.2.0",
+                "yoast/phpunit-polyfills": "^1.1.0 || ^2.0.0 || ^3.0.0"
+            },
+            "type": "phpcodesniffer-standard",
+            "extra": {
+                "branch-alias": {
+                    "dev-stable": "1.x-dev",
+                    "dev-develop": "1.x-dev"
+                }
+            },
+            "autoload": {
+                "classmap": [
+                    "PHPCSUtils/"
+                ]
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "LGPL-3.0-or-later"
+            ],
+            "authors": [
+                {
+                    "name": "Juliette Reinders Folmer",
+                    "homepage": "https://github.com/jrfnl",
+                    "role": "lead"
+                },
+                {
+                    "name": "Contributors",
+                    "homepage": "https://github.com/PHPCSStandards/PHPCSUtils/graphs/contributors"
+                }
+            ],
+            "description": "A suite of utility functions for use with PHP_CodeSniffer",
+            "homepage": "https://phpcsutils.com/",
+            "keywords": [
+                "PHP_CodeSniffer",
+                "phpcbf",
+                "phpcodesniffer-standard",
+                "phpcs",
+                "phpcs3",
+                "phpcs4",
+                "standards",
+                "static analysis",
+                "tokens",
+                "utility"
+            ],
+            "support": {
+                "docs": "https://phpcsutils.com/",
+                "issues": "https://github.com/PHPCSStandards/PHPCSUtils/issues",
+                "security": "https://github.com/PHPCSStandards/PHPCSUtils/security/policy",
+                "source": "https://github.com/PHPCSStandards/PHPCSUtils"
+            },
+            "funding": [
+                {
+                    "url": "https://github.com/PHPCSStandards",
+                    "type": "github"
+                },
+                {
+                    "url": "https://github.com/jrfnl",
+                    "type": "github"
+                },
+                {
+                    "url": "https://opencollective.com/php_codesniffer",
+                    "type": "open_collective"
+                },
+                {
+                    "url": "https://thanks.dev/u/gh/phpcsstandards",
+                    "type": "thanks_dev"
+                }
+            ],
+            "time": "2026-07-27T10:28:41+00:00"
+        },
         {
             "name": "phpunit/php-code-coverage",
             "version": "9.2.32",
@@ -1876,16 +2056,16 @@
         },
         {
             "name": "squizlabs/php_codesniffer",
-            "version": "3.13.5",
+            "version": "3.13.6",
             "source": {
                 "type": "git",
                 "url": "https://github.com/PHPCSStandards/PHP_CodeSniffer.git",
-                "reference": "0ca86845ce43291e8f5692c7356fccf3bcf02bf4"
+                "reference": "4c378e1a528ea066890fc2397cbdd2f94eb2fc91"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/PHPCSStandards/PHP_CodeSniffer/zipball/0ca86845ce43291e8f5692c7356fccf3bcf02bf4",
-                "reference": "0ca86845ce43291e8f5692c7356fccf3bcf02bf4",
+                "url": "https://api.github.com/repos/PHPCSStandards/PHP_CodeSniffer/zipball/4c378e1a528ea066890fc2397cbdd2f94eb2fc91",
+                "reference": "4c378e1a528ea066890fc2397cbdd2f94eb2fc91",
                 "shasum": ""
             },
             "require": {
@@ -1951,7 +2131,7 @@
                     "type": "thanks_dev"
                 }
             ],
-            "time": "2025-11-04T16:30:35+00:00"
+            "time": "2026-08-06T00:17:32+00:00"
         },
         {
             "name": "theseer/tokenizer",
@@ -2005,30 +2185,38 @@
         },
         {
             "name": "wp-coding-standards/wpcs",
-            "version": "2.3.0",
+            "version": "3.4.1",
             "source": {
                 "type": "git",
                 "url": "https://github.com/WordPress/WordPress-Coding-Standards.git",
-                "reference": "7da1894633f168fe244afc6de00d141f27517b62"
+                "reference": "ec2ff942335f33683a5957a85d138753876a05cf"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/WordPress/WordPress-Coding-Standards/zipball/7da1894633f168fe244afc6de00d141f27517b62",
-                "reference": "7da1894633f168fe244afc6de00d141f27517b62",
+                "url": "https://api.github.com/repos/WordPress/WordPress-Coding-Standards/zipball/ec2ff942335f33683a5957a85d138753876a05cf",
+                "reference": "ec2ff942335f33683a5957a85d138753876a05cf",
                 "shasum": ""
             },
             "require": {
-                "php": ">=5.4",
-                "squizlabs/php_codesniffer": "^3.3.1"
+                "ext-filter": "*",
+                "ext-libxml": "*",
+                "ext-tokenizer": "*",
+                "ext-xmlreader": "*",
+                "php": ">=7.2",
+                "phpcsstandards/phpcsextra": "^1.5.1",
+                "phpcsstandards/phpcsutils": "^1.2.3",
+                "squizlabs/php_codesniffer": "^3.13.5"
             },
             "require-dev": {
-                "dealerdirect/phpcodesniffer-composer-installer": "^0.5 || ^0.6",
-                "phpcompatibility/php-compatibility": "^9.0",
-                "phpcsstandards/phpcsdevtools": "^1.0",
-                "phpunit/phpunit": "^4.0 || ^5.0 || ^6.0 || ^7.0"
+                "php-parallel-lint/php-console-highlighter": "^1.0.0",
+                "php-parallel-lint/php-parallel-lint": "^1.4.0",
+                "phpcompatibility/php-compatibility": "^10.0.0@dev",
+                "phpcsstandards/phpcsdevtools": "^1.2.0",
+                "phpunit/phpunit": "^8.0 || ^9.0"
             },
             "suggest": {
-                "dealerdirect/phpcodesniffer-composer-installer": "^0.6 || This Composer plugin will sort out the PHPCS 'installed_paths' automatically."
+                "ext-iconv": "For improved results",
+                "ext-mbstring": "For improved results"
             },
             "type": "phpcodesniffer-standard",
             "notification-url": "https://packagist.org/downloads/",
@@ -2045,6 +2233,7 @@
             "keywords": [
                 "phpcs",
                 "standards",
+                "static analysis",
                 "wordpress"
             ],
             "support": {
@@ -2052,7 +2241,13 @@
                 "source": "https://github.com/WordPress/WordPress-Coding-Standards",
                 "wiki": "https://github.com/WordPress/WordPress-Coding-Standards/wiki"
             },
-            "time": "2020-05-13T23:57:56+00:00"
+            "funding": [
+                {
+                    "url": "https://opencollective.com/php_codesniffer",
+                    "type": "custom"
+                }
+            ],
+            "time": "2026-07-27T11:53:23+00:00"
         },
         {
             "name": "yoast/phpunit-polyfills",
@@ -2120,13 +2315,11 @@
     ],
     "aliases": [],
     "minimum-stability": "stable",
-    "stability-flags": {
-        "htmltrust/canonicalization": 20
-    },
+    "stability-flags": {},
     "prefer-stable": false,
     "prefer-lowest": false,
     "platform": {
-        "php": ">=7.0"
+        "php": ">=7.2"
     },
     "platform-dev": {},
     "plugin-api-version": "2.9.0"
diff --git a/wordpress/content-signing.php b/wordpress/content-signing.php
index 5d8c309..af8808c 100644
--- a/wordpress/content-signing.php
+++ b/wordpress/content-signing.php
@@ -4,6 +4,7 @@
  * Plugin URI: https://example.com/content-signing
  * Description: Integrates WordPress with content signing services to verify content origin and authenticity.
  * Version: 1.0.0
+ * Requires PHP: 7.2
  * Author: Jason Grey
  * Author URI: https://jason-grey.com
  * License: GPL-2.0+
@@ -23,6 +24,18 @@
 define('CONTENT_SIGNING_PLUGIN_URL', plugin_dir_url(__FILE__));
 define('CONTENT_SIGNING_PLUGIN_BASENAME', plugin_basename(__FILE__));
 
+/**
+ * Composer autoloader.
+ *
+ * Supplies HTMLTrust\Canonicalization\Canonicalize, the shared canonicalization
+ * library the signing service uses to derive the bytes it hashes. Without it
+ * the plugin cannot produce a content hash any verifier will reproduce, so the
+ * signing service reports a clear deployment error rather than fatalling.
+ */
+if (file_exists(CONTENT_SIGNING_PLUGIN_DIR . 'vendor/autoload.php')) {
+    require_once CONTENT_SIGNING_PLUGIN_DIR . 'vendor/autoload.php';
+}
+
 /**
  * The code that runs during plugin activation.
  */
@@ -56,4 +69,4 @@ function run_content_signing() {
     $plugin->run();
 }
 
-run_content_signing();
\ No newline at end of file
+run_content_signing();
diff --git a/wordpress/docs/local-signing-audit.md b/wordpress/docs/local-signing-audit.md
index 6d6cfa8..1d9cc34 100644
--- a/wordpress/docs/local-signing-audit.md
+++ b/wordpress/docs/local-signing-audit.md
@@ -30,12 +30,14 @@ Today's flow, per `includes/class-content-signing-signing-service.php` ->
 1. WordPress fires `publish_post` (or `transition_post_status`).
 2. `ContentSigning_Hooks::on_publish_post` -> `Signing_Service::process_post`
    -> `Signing_Service::sign_post`.
-3. `prepare_content_data()` strips HTML, runs the canonicalization PHP
-   binding (`HTMLTrust\Canonicalization\Canonicalize::normalize`), computes
-   `sha256:<hex>`, attaches the post author's claims.
+3. `prepare_content_data()` canonicalizes the signed content, including
+   `href`, `src`, `alt`, and `aria-label` records, computes
+   `sha256:<unpadded standard Base64>`, serializes `domain` as the Web
+   origin, and attaches direct meta claims such as `author`, `signed-at`,
+   and `claim:*`.
 4. `ContentSigning_API_Client::sign_content()` POSTs `{contentHash, domain,
-   claims}` to `<trust-server>/api/content/sign` with the author's API key
-   in `X-AUTHOR-API-KEY`.
+   claims, signedAt, sourceURL}` to `<trust-server>/api/content/sign` with
+   the author's API key in `X-AUTHOR-API-KEY`.
 5. The trust server holds the author's signing key, signs server-side, and
    returns `{signature, ...}`.
 6. We persist the signature row in `wp_content_signing_signatures` and
diff --git a/wordpress/includes/class-content-signing-api-client.php b/wordpress/includes/class-content-signing-api-client.php
index 8bd5e65..426d9fa 100644
--- a/wordpress/includes/class-content-signing-api-client.php
+++ b/wordpress/includes/class-content-signing-api-client.php
@@ -131,6 +131,46 @@ private function request($endpoint, $method = 'GET', $data = array(), $api_key =
         return $result;
     }
 
+    /**
+     * Identifier shape: opaque tokens (object ids, slugs, key ids).
+     */
+    const IDENTIFIER_PATTERN = '/^[A-Za-z0-9._~-]{1,128}$/';
+
+    /**
+     * Hash shape: an algorithm identifier, a colon, then unpadded Base64.
+     */
+    const HASH_PATTERN = '/^[A-Za-z0-9]{1,16}:[A-Za-z0-9+\/_-]{1,128}={0,2}$/';
+
+    /**
+     * Validate and encode a value for use as a single URL path segment.
+     *
+     * Identifiers reaching these methods come from the database and from API
+     * responses, so they are not guaranteed to be path-safe. Interpolated raw,
+     * a value containing "/", "..", "?" or "#" retargets the request at a
+     * different endpoint on the signing server; rawurlencode() confines it to
+     * one segment, and the pattern check rejects shapes that were never valid
+     * identifiers in the first place.
+     *
+     * @since    1.0.0
+     * @access   private
+     * @param    string    $value    The path segment value.
+     * @param    string    $pattern  The pattern the value must match.
+     * @param    string    $label    Human-readable name, used in the error.
+     * @return   string|WP_Error     The encoded segment, or WP_Error if unusable.
+     */
+    private function encode_path_segment($value, $pattern = self::IDENTIFIER_PATTERN, $label = 'identifier') {
+        if (!is_scalar($value)) {
+            return new WP_Error('invalid_identifier', sprintf('Invalid %s.', $label));
+        }
+
+        $value = trim((string) $value);
+        if ($value === '' || !preg_match($pattern, $value)) {
+            return new WP_Error('invalid_identifier', sprintf('Invalid %s.', $label));
+        }
+
+        return rawurlencode($value);
+    }
+
     /**
      * Create a new author.
      *
@@ -150,6 +190,11 @@ public function create_author($author_data) {
      * @return   array|WP_Error          The API response or WP_Error on failure.
      */
     public function get_author($author_id) {
+        $author_id = $this->encode_path_segment($author_id, self::IDENTIFIER_PATTERN, 'author ID');
+        if (is_wp_error($author_id)) {
+            return $author_id;
+        }
+
         return $this->request("authors/{$author_id}", 'GET');
     }
 
@@ -163,6 +208,11 @@ public function get_author($author_id) {
      * @return   array|WP_Error          The API response or WP_Error on failure.
      */
     public function update_author($author_id, $author_data, $author_api_key) {
+        $author_id = $this->encode_path_segment($author_id, self::IDENTIFIER_PATTERN, 'author ID');
+        if (is_wp_error($author_id)) {
+            return $author_id;
+        }
+
         return $this->request("authors/{$author_id}", 'PUT', $author_data, $author_api_key, 'author');
     }
 
@@ -174,6 +224,11 @@ public function update_author($author_id, $author_data, $author_api_key) {
      * @return   array|WP_Error          The API response or WP_Error on failure.
      */
     public function get_author_public_key($author_id) {
+        $author_id = $this->encode_path_segment($author_id, self::IDENTIFIER_PATTERN, 'author ID');
+        if (is_wp_error($author_id)) {
+            return $author_id;
+        }
+
         return $this->request("authors/{$author_id}/public-key", 'GET');
     }
 
@@ -219,6 +274,11 @@ public function get_claim_types($params = array()) {
      * @return   array|WP_Error         The API response or WP_Error on failure.
      */
     public function get_claim_type($claim_id) {
+        $claim_id = $this->encode_path_segment($claim_id, self::IDENTIFIER_PATTERN, 'claim ID');
+        if (is_wp_error($claim_id)) {
+            return $claim_id;
+        }
+
         return $this->request("claims/{$claim_id}", 'GET');
     }
 
@@ -241,6 +301,11 @@ public function search_public_keys($params = array()) {
      * @return   array|WP_Error       The API response or WP_Error on failure.
      */
     public function get_key_reputation($key_id) {
+        $key_id = $this->encode_path_segment($key_id, self::IDENTIFIER_PATTERN, 'key ID');
+        if (is_wp_error($key_id)) {
+            return $key_id;
+        }
+
         return $this->request("directory/keys/{$key_id}/reputation", 'GET');
     }
 
@@ -264,6 +329,13 @@ public function search_signed_content($params = array()) {
      * @return   array|WP_Error             The API response or WP_Error on failure.
      */
     public function find_content_occurrences($content_hash, $params = array()) {
+        // A content hash is "algorithm:base64", and standard-alphabet Base64
+        // contains "/" -- rawurlencode() is what keeps it inside one segment.
+        $content_hash = $this->encode_path_segment($content_hash, self::HASH_PATTERN, 'content hash');
+        if (is_wp_error($content_hash)) {
+            return $content_hash;
+        }
+
         return $this->request("directory/content/{$content_hash}/occurrences", 'GET', $params);
     }
 }
\ No newline at end of file
diff --git a/wordpress/includes/class-content-signing-hooks.php b/wordpress/includes/class-content-signing-hooks.php
index 19b40c0..4927978 100644
--- a/wordpress/includes/class-content-signing-hooks.php
+++ b/wordpress/includes/class-content-signing-hooks.php
@@ -214,22 +214,26 @@ public function on_transition_post_status($new_status, $old_status, $post) {
      * @return   void
      */
     public function ajax_sign_post() {
-        // Check nonce
-        check_ajax_referer('content_signing_nonce', 'nonce');
-        
-        // Check permissions
-        if (!current_user_can('edit_posts')) {
-            wp_send_json_error(array('message' => 'Permission denied.'));
-            return;
-        }
-        
-        // Get post ID
+        // Get post ID first: the nonce and the capability are both scoped to
+        // this specific post.
         $post_id = isset($_POST['post_id']) ? intval($_POST['post_id']) : 0;
         if (!$post_id) {
             wp_send_json_error(array('message' => 'Invalid post ID.'));
             return;
         }
-        
+
+        // Check nonce. Post-scoped, so a nonce minted on one post's edit
+        // screen cannot be replayed against another post.
+        check_ajax_referer('content_signing_post_' . $post_id, 'nonce');
+
+        // Check permissions against this post, not the generic edit_posts
+        // capability: edit_posts is true for any Contributor, which would let
+        // them sign posts they do not own.
+        if (!current_user_can('edit_post', $post_id)) {
+            wp_send_json_error(array('message' => 'Permission denied.'));
+            return;
+        }
+
         // Sign the post
         $result = $this->signing_service->sign_post($post_id);
         
@@ -247,24 +251,24 @@ public function ajax_sign_post() {
      * @return   void
      */
     public function ajax_verify_signature() {
-        // Check nonce
-        check_ajax_referer('content_signing_nonce', 'nonce');
-        
-        // Check permissions
-        if (!current_user_can('edit_posts')) {
-            wp_send_json_error(array('message' => 'Permission denied.'));
-            return;
-        }
-        
         // Get post ID and signature ID
         $post_id = isset($_POST['post_id']) ? intval($_POST['post_id']) : 0;
         $signature_id = isset($_POST['signature_id']) ? intval($_POST['signature_id']) : 0;
-        
+
         if (!$post_id || !$signature_id) {
             wp_send_json_error(array('message' => 'Invalid post ID or signature ID.'));
             return;
         }
-        
+
+        // Check nonce. Post-scoped, as in ajax_sign_post().
+        check_ajax_referer('content_signing_post_' . $post_id, 'nonce');
+
+        // Check permissions against this post rather than edit_posts.
+        if (!current_user_can('edit_post', $post_id)) {
+            wp_send_json_error(array('message' => 'Permission denied.'));
+            return;
+        }
+
         // Verify the signature
         $result = $this->signing_service->verify_post_signature($post_id, $signature_id);
         
@@ -284,13 +288,15 @@ public function ajax_verify_signature() {
     public function ajax_get_claim_types() {
         // Check nonce
         check_ajax_referer('content_signing_nonce', 'nonce');
-        
-        // Check permissions
-        if (!current_user_can('edit_posts')) {
+
+        // Check permissions. This handler reads a server profile and talks to
+        // that server with its stored API key, so it is gated on the same
+        // capability as the plugin's settings screens.
+        if (!current_user_can('manage_options')) {
             wp_send_json_error(array('message' => 'Permission denied.'));
             return;
         }
-        
+
         // Get server ID
         $server_id = isset($_POST['server_id']) ? intval($_POST['server_id']) : 0;
         if (!$server_id) {
diff --git a/wordpress/includes/class-content-signing-scheduler.php b/wordpress/includes/class-content-signing-scheduler.php
index 35875f0..d6c08be 100644
--- a/wordpress/includes/class-content-signing-scheduler.php
+++ b/wordpress/includes/class-content-signing-scheduler.php
@@ -68,7 +68,7 @@ public function schedule_signing($post_id, $timestamp) {
      * @return   bool                  True if canceled successfully, false otherwise.
      */
     public function cancel_scheduled_signing($post_id) {
-        return wp_clear_scheduled_hook('content_signing_scheduled_signing', array($post_id));
+        return wp_clear_scheduled_hook('content_signing_scheduled_signing', array($post_id)) > 0;
     }
 
     /**
@@ -125,4 +125,4 @@ public function get_next_scheduled_signing($post_id) {
     public function has_scheduled_signing($post_id) {
         return (bool) $this->get_next_scheduled_signing($post_id);
     }
-}
\ No newline at end of file
+}
diff --git a/wordpress/includes/class-content-signing-signing-service.php b/wordpress/includes/class-content-signing-signing-service.php
index 44ac2b6..5ac6cd5 100644
--- a/wordpress/includes/class-content-signing-signing-service.php
+++ b/wordpress/includes/class-content-signing-signing-service.php
@@ -13,6 +13,9 @@
 
 class ContentSigning_Signing_Service {
 
+    /** @var array<string, bool> Signing or scheduling work completed in this request. */
+    private $processed_actions = array();
+
     /**
      * The database handler.
      *
@@ -134,12 +137,20 @@ public function process_post($post_id, $post, $update) {
 
         // Sign now if needed
         if ($should_sign_now) {
-            $this->sign_post($post_id);
+            $action_key = 'sign:' . $post_id;
+            if (empty($this->processed_actions[$action_key])) {
+                $this->processed_actions[$action_key] = true;
+                $this->sign_post($post_id);
+            }
         }
 
         // Schedule signing if needed
         if ($should_schedule && $schedule_time > time()) {
-            $this->scheduler->schedule_signing($post_id, $schedule_time);
+            $action_key = 'schedule:' . $post_id;
+            if (empty($this->processed_actions[$action_key])) {
+                $this->processed_actions[$action_key] = true;
+                $this->scheduler->schedule_signing($post_id, $schedule_time);
+            }
         }
     }
 
@@ -177,8 +188,18 @@ public function sign_post($post_id) {
             );
         }
 
-        // Prepare the content for signing
-        $content_data = $this->prepare_content_data($post);
+        // Prepare the content for signing. Canonicalization is allowed to
+        // fail hard (draft §4.3.2 requires MUST-fail on unresolvable signed
+        // attribute values); surface that as a signing error rather than a
+        // PHP fatal inside a save_post hook.
+        try {
+            $content_data = $this->prepare_content_data($post);
+        } catch (Exception $e) {
+            return array(
+                'success' => false,
+                'message' => 'Content canonicalization failed: ' . $e->getMessage(),
+            );
+        }
 
         // Get the author's API key
         $author_api_key = $this->db->decrypt($author_profile->author_api_key_encrypted);
@@ -209,7 +230,7 @@ public function sign_post($post_id) {
         }
 
         // Sign the content
-        $result = $api_client->sign_content($content_data, $author_api_key);
+        $result = $api_client->sign_content($this->prepare_api_content_data($content_data), $author_api_key);
 
         // Update the signature record
         if (is_wp_error($result)) {
@@ -229,9 +250,9 @@ public function sign_post($post_id) {
         } else {
             $this->db->update_signature($signature_id, array(
                 'signature' => $result['signature'],
-                'claims_json' => wp_json_encode($result['claims']),
+                'claims_json' => wp_json_encode($content_data['claims']),
                 'status' => 'signed',
-                'signed_at' => current_time('mysql'),
+                'signed_at' => $content_data['signedAtMysql'],
                 'api_response' => $result,
             ));
 
@@ -311,7 +332,7 @@ private function process_endorsements($post_id, $content_data) {
             }
 
             // Sign the content with the endorser's key
-            $result = $api_client->sign_content($content_data, $endorser_api_key);
+            $result = $api_client->sign_content($this->prepare_api_content_data($content_data), $endorser_api_key);
 
             // Update the signature record
             if (is_wp_error($result)) {
@@ -325,9 +346,9 @@ private function process_endorsements($post_id, $content_data) {
             } else {
                 $this->db->update_signature($signature_id, array(
                     'signature' => $result['signature'],
-                    'claims_json' => wp_json_encode($result['claims']),
+                    'claims_json' => wp_json_encode($content_data['claims']),
                     'status' => 'signed',
-                    'signed_at' => current_time('mysql'),
+                    'signed_at' => $content_data['signedAtMysql'],
                     'api_response' => $result,
                 ));
             }
@@ -342,17 +363,25 @@ private function process_endorsements($post_id, $content_data) {
      * @return   array              The content data.
      */
     private function prepare_content_data($post) {
-        // Get the post content
-        $content = $post->post_content;
+        $base_url = get_permalink($post);
+        $signed_at = gmdate('Y-m-d\TH:i:s\Z');
+        $author_name = $this->get_post_author_name($post);
 
-        // Normalize the content (strip whitespace, etc.)
-        $normalized_content = $this->normalize_content($content);
+        // Hash the rendered content, not the raw post_content. The
+        // <signed-section> element emitted by ContentSigning_Display wraps the
+        // output of the `the_content` filter chain (wpautop, shortcodes, ...),
+        // so hashing the raw editor markup would produce a content hash that
+        // no verifier can reproduce from the published page.
+        $rendered_content = $this->get_rendered_content($post);
+
+        // Normalize the content using the signed content extraction rules.
+        $normalized_content = $this->normalize_content($rendered_content, $base_url);
 
         // Calculate the content hash
         $content_hash = $this->calculate_content_hash($normalized_content);
 
-        // Determine the domain
-        $domain = parse_url(get_site_url(), PHP_URL_HOST);
+        // Determine the serialized Web origin for the legacy-named domain field.
+        $domain = $this->serialize_origin(get_site_url());
 
         // Get default claims from post author's profile
         $author_profile = $this->db->get_author_by_wp_user_id($post->post_author);
@@ -367,38 +396,136 @@ private function prepare_content_data($post) {
             $post_claims = array();
         }
 
-        // Merge claims, with post-specific claims taking precedence
-        $claims = array_merge($default_claims, $post_claims);
+        // Merge claims, with post-specific claims taking precedence.
+        $custom_claims = array_merge($default_claims, $post_claims);
 
         // Add standard claims if not already set
-        if (!isset($claims['ContentType'])) {
-            $claims['ContentType'] = 'Article';
+        if (!isset($custom_claims['ContentType'])) {
+            $custom_claims['ContentType'] = 'Article';
         }
 
-        if (!isset($claims['AuthorType'])) {
-            $claims['AuthorType'] = $author_profile ? $author_profile->default_key_type : 'HUMAN';
+        if (!isset($custom_claims['AuthorType'])) {
+            $custom_claims['AuthorType'] = $author_profile ? $author_profile->default_key_type : 'HUMAN';
         }
 
+        $claims = $this->build_claims($author_name, $signed_at, $custom_claims);
+
         return array(
             'contentHash' => $content_hash,
+            'claimsHash' => $this->calculate_claims_hash($claims),
             'domain' => $domain,
             'claims' => $claims,
+            'signedAt' => $signed_at,
+            'signedAtMysql' => gmdate('Y-m-d H:i:s', strtotime($signed_at)),
+            'sourceURL' => $base_url,
+        );
+    }
+
+    /**
+     * Render post content through the same filters the front end applies.
+     *
+     * ContentSigning_Display wraps the value it receives from the
+     * `the_content` filter, so the signer has to hash that same value. Our own
+     * wrapper callback is detached for the duration of the call: it is
+     * registered on `the_content` itself, so leaving it attached would recurse
+     * and fold a <signed-section> element into the hashed bytes.
+     *
+     * Caveat: filters registered on `the_content` at a priority later than the
+     * display callback (20) run after the wrapper and are therefore outside the
+     * signed bytes on the published page. Themes that mutate content that late
+     * will break reproducibility.
+     *
+     * @since    1.0.0
+     * @param    WP_Post   $post    The post object.
+     * @return   string             The rendered post content.
+     */
+    private function get_rendered_content($post) {
+        $display = $this->get_display();
+        $callback = $display ? array($display, 'display_signature') : null;
+
+        // Read the registered priority back rather than assuming it: detaching
+        // at the wrong priority is a silent no-op, and the recursion it would
+        // leave in place is not obvious from the resulting hash.
+        $priority = $callback ? has_filter('the_content', $callback) : false;
+
+        if (false !== $priority) {
+            remove_filter('the_content', $callback, $priority);
+        }
+
+        $content = apply_filters('the_content', $post->post_content);
+
+        if (false !== $priority) {
+            add_filter('the_content', $callback, $priority);
+        }
+
+        return $content;
+    }
+
+    /**
+     * Get the plugin's display handler, if the plugin is fully booted.
+     *
+     * @since    1.0.0
+     * @return   ContentSigning_Display|null    The display handler.
+     */
+    private function get_display() {
+        if (!class_exists('ContentSigning_Plugin')) {
+            return null;
+        }
+
+        $plugin = ContentSigning_Plugin::get_instance();
+        if (!$plugin) {
+            return null;
+        }
+
+        $public = $plugin->get_public();
+        if (!$public || !method_exists($public, 'get_display')) {
+            return null;
+        }
+
+        return $public->get_display();
+    }
+
+    /**
+     * Prepare the API-facing signing payload.
+     *
+     * @since    1.0.0
+     * @param    array $content_data Internal content data.
+     * @return   array               API content data.
+     */
+    private function prepare_api_content_data($content_data) {
+        // claimsHash is not optional: the signing payload binding is
+        // "content-hash:claims-hash:domain:signed-at" (draft §5), and the
+        // reference server rejects the request outright when it is absent.
+        return array(
+            'contentHash' => $content_data['contentHash'],
+            'claimsHash' => $content_data['claimsHash'],
+            'domain' => $content_data['domain'],
+            'claims' => $content_data['claims'],
+            'signedAt' => $content_data['signedAt'],
+            'sourceURL' => $content_data['sourceURL'],
         );
     }
 
     /**
      * Normalize content for consistent hashing.
      *
+     * Delegates to the shared htmltrust/canonicalization package. This plugin
+     * deliberately keeps no canonicalizer of its own: the bytes hashed here
+     * have to match, byte for byte, what the JavaScript, Go, Python and Rust
+     * verifiers derive from the published page.
+     *
      * @since    1.0.0
-     * @param    string    $content    The content to normalize.
-     * @return   string                The normalized content.
+     * @param    string      $content    The content to normalize.
+     * @param    string|null $base_url   The signed document URL, used to
+     *                                   resolve relative href/src values.
+     * @return   string                  The normalized content.
+     * @throws   RuntimeException         If the canonicalization package is missing.
+     * @throws   InvalidArgumentException If a signed attribute cannot be canonicalized.
      */
-    private function normalize_content($content) {
-        // Strip HTML tags
-        $content = wp_strip_all_tags($content);
+    private function normalize_content($content, $base_url = null) {
+        $this->require_canonicalization_library();
 
-        // Apply canonical text normalization
-        return Canonicalize::normalize($content);
+        return Canonicalize::extractCanonicalText($content, false, $base_url === '' ? null : $base_url);
     }
 
     /**
@@ -410,7 +537,156 @@ private function normalize_content($content) {
      */
     private function calculate_content_hash($content) {
         // Use SHA-256 for hashing
-        return 'sha256:' . hash('sha256', $content);
+        return $this->hash_canonical_bytes($content);
+    }
+
+    /**
+     * Calculate the claims hash for a direct-child claim map.
+     *
+     * The claims hash is the second field of the signing payload binding
+     * (draft §5) and is computed over the canonical claims byte string
+     * defined in draft §4.6.
+     *
+     * @since    1.0.0
+     * @param    array     $claims    Claims keyed by direct meta name.
+     * @return   string               The claims hash.
+     * @throws   RuntimeException         If the canonicalization package is missing.
+     * @throws   InvalidArgumentException If a claim is malformed or duplicated.
+     */
+    private function calculate_claims_hash($claims) {
+        $this->require_canonicalization_library();
+
+        return $this->hash_canonical_bytes(Canonicalize::canonicalizeClaims($claims));
+    }
+
+    /**
+     * Hash a canonical byte string into the spec's prefixed hash format.
+     *
+     * Base64 with the standard alphabet and padding removed, prefixed with the
+     * hash algorithm identifier and a colon (draft §6.2).
+     *
+     * @since    1.0.0
+     * @param    string    $bytes    The canonical bytes to hash.
+     * @return   string              The prefixed hash.
+     */
+    private function hash_canonical_bytes($bytes) {
+        return 'sha256:' . rtrim(base64_encode(hash('sha256', $bytes, true)), '=');
+    }
+
+    /**
+     * Assert that the shared canonicalization package is loadable.
+     *
+     * The package is a composer dependency (htmltrust/canonicalization); a
+     * missing autoloader is a deployment error, not a content error, so it is
+     * reported distinctly rather than surfacing as a class-not-found fatal.
+     *
+     * @since    1.0.0
+     * @return   void
+     * @throws   RuntimeException    If the package is not installed.
+     */
+    private function require_canonicalization_library() {
+        if (!class_exists(Canonicalize::class)) {
+            throw new RuntimeException(
+                'The htmltrust/canonicalization package is not installed. Run "composer install" in the plugin directory.'
+            );
+        }
+    }
+
+    /**
+     * Serialize a URL as a Web origin.
+     *
+     * @since    1.0.0
+     * @param    string $url The URL to serialize.
+     * @return   string      The serialized origin.
+     */
+    private function serialize_origin($url) {
+        $parts = wp_parse_url($url);
+        $scheme = isset($parts['scheme']) ? strtolower($parts['scheme']) : 'https';
+        $host = isset($parts['host']) ? strtolower($parts['host']) : '';
+
+        if (function_exists('idn_to_ascii') && $host !== '') {
+            $ascii_host = idn_to_ascii($host, 0, defined('INTL_IDNA_VARIANT_UTS46') ? INTL_IDNA_VARIANT_UTS46 : 0);
+            if ($ascii_host) {
+                $host = strtolower($ascii_host);
+            }
+        }
+
+        $origin = $scheme . '://' . $host;
+        if (isset($parts['port']) && !$this->is_default_port($scheme, intval($parts['port']))) {
+            $origin .= ':' . intval($parts['port']);
+        }
+
+        return $origin;
+    }
+
+    /**
+     * Check whether a port is the default for a scheme.
+     *
+     * @since    1.0.0
+     * @param    string $scheme The URL scheme.
+     * @param    int    $port   The port.
+     * @return   bool           Whether the port is default.
+     */
+    private function is_default_port($scheme, $port) {
+        return ($scheme === 'http' && $port === 80) || ($scheme === 'https' && $port === 443);
+    }
+
+    /**
+     * Build direct child meta claims.
+     *
+     * @since    1.0.0
+     * @param    string $author_name   The author display name.
+     * @param    string $signed_at     RFC3339 UTC signing timestamp.
+     * @param    array  $custom_claims Custom claim values.
+     * @return   array                 Direct meta claims keyed by meta name.
+     */
+    private function build_claims($author_name, $signed_at, $custom_claims) {
+        $claims = array(
+            'author' => $author_name,
+            'signed-at' => $signed_at,
+        );
+
+        foreach ($custom_claims as $name => $value) {
+            $claim_name = strpos($name, 'claim:') === 0 ? $name : 'claim:' . $name;
+            if (is_array($value)) {
+                $value = implode(', ', $value);
+            }
+            $claims[$claim_name] = (string) $value;
+        }
+
+        return $claims;
+    }
+
+    /**
+     * Get the post author's display name.
+     *
+     * @since    1.0.0
+     * @param    WP_Post $post The post object.
+     * @return   string        The author display name.
+     */
+    private function get_post_author_name($post) {
+        $user = get_user_by('ID', $post->post_author);
+        if ($user && !empty($user->display_name)) {
+            return $user->display_name;
+        }
+
+        return (string) $post->post_author;
+    }
+
+    /**
+     * Format a stored datetime as RFC3339 UTC.
+     *
+     * @since    1.0.0
+     * @param    string $datetime The stored datetime.
+     * @return   string           The RFC3339 UTC datetime.
+     */
+    private function format_signed_at($datetime) {
+        $timestamp = strtotime($datetime);
+        if (!$timestamp) {
+            $timestamp = time();
+        }
+
+        return gmdate('Y-m-d\TH:i:s\Z', $timestamp);
     }
 
     /**
@@ -438,6 +714,16 @@ public function verify_post_signature($post_id, $signature_id) {
             );
         }
 
+        // The caller was authorized against $post_id, so the signature has to
+        // belong to that post; otherwise the post ID is just decoration and any
+        // signature row is reachable.
+        if (intval($signature->post_id) !== intval($post_id)) {
+            return array(
+                'success' => false,
+                'message' => 'Signature does not belong to this post.',
+            );
+        }
+
         // Get the server for this signature
         $server = $this->db->get_server($signature->server_id);
         if (!$server) {
@@ -454,10 +740,39 @@ public function verify_post_signature($post_id, $signature_id) {
             $this->db
         );
 
+        // Rebuild the signing payload binding. The verifier needs all four
+        // bound fields (draft §5); sending only contentHash and domain makes
+        // the request fail validation before any crypto runs.
+        $claims = json_decode((string) $signature->claims_json, true);
+        if (!is_array($claims) || empty($claims)) {
+            return array(
+                'success' => false,
+                'message' => 'Stored claims are missing; cannot rebuild the signing payload.',
+            );
+        }
+
+        try {
+            $claims_hash = $this->calculate_claims_hash($claims);
+        } catch (Exception $e) {
+            return array(
+                'success' => false,
+                'message' => 'Claims canonicalization failed: ' . $e->getMessage(),
+            );
+        }
+
+        // Prefer the signed-at claim: it is the exact string that was bound
+        // into the signature. The signed_at column is a MySQL datetime and
+        // only reconstructs the RFC3339 form.
+        $signed_at = isset($claims['signed-at']) && $claims['signed-at'] !== ''
+            ? (string) $claims['signed-at']
+            : $this->format_signed_at($signature->signed_at ? $signature->signed_at : $signature->created_at);
+
         // Prepare verification data
         $verification_data = array(
             'contentHash' => $signature->content_hash,
+            'claimsHash' => $claims_hash,
             'domain' => $signature->domain,
+            'signedAt' => $signed_at,
             'authorId' => $signature->signing_author_id,
             'signature' => $signature->signature,
         );
diff --git a/wordpress/includes/db/class-content-signing-db.php b/wordpress/includes/db/class-content-signing-db.php
index 0e792fd..f7f5249 100644
--- a/wordpress/includes/db/class-content-signing-db.php
+++ b/wordpress/includes/db/class-content-signing-db.php
@@ -57,32 +57,126 @@ public function get_table_name($table) {
         return isset($this->tables[$table]) ? $this->tables[$table] : '';
     }
 
+    /**
+     * Derive the symmetric encryption key.
+     *
+     * The key material comes from the HTMLTRUST_ENCRYPTION_KEY constant, which
+     * the site owner defines in wp-config.php. Generate one with:
+     *
+     *     php -r 'echo sodium_bin2base64(sodium_crypto_secretbox_keygen(), SODIUM_BASE64_VARIANT_ORIGINAL), "\n";'
+     *
+     * and add it to wp-config.php:
+     *
+     *     define('HTMLTRUST_ENCRYPTION_KEY', '<the base64 string>');
+     *
+     * A base64 value decoding to exactly 32 bytes is used as the key directly.
+     * Anything else is run through BLAKE2b to produce a 32-byte key, so a
+     * passphrase also works, with correspondingly less entropy.
+     *
+     * @since    1.0.0
+     * @access   private
+     * @return   string|null    The 32-byte key, or null if none is configured.
+     */
+    private function get_encryption_key() {
+        if (!defined('HTMLTRUST_ENCRYPTION_KEY')) {
+            return null;
+        }
+
+        $configured = (string) HTMLTRUST_ENCRYPTION_KEY;
+        if ($configured === '') {
+            return null;
+        }
+
+        $decoded = base64_decode($configured, true);
+        if (false !== $decoded && strlen($decoded) === SODIUM_CRYPTO_SECRETBOX_KEYBYTES) {
+            return $decoded;
+        }
+
+        return sodium_crypto_generichash($configured, '', SODIUM_CRYPTO_SECRETBOX_KEYBYTES);
+    }
+
+    /**
+     * Check whether authenticated encryption is available and configured.
+     *
+     * @since    1.0.0
+     * @return   bool    True when encrypt()/decrypt() can operate.
+     */
+    public function has_encryption_key() {
+        return function_exists('sodium_crypto_secretbox') && null !== $this->get_encryption_key();
+    }
+
     /**
      * Encrypt sensitive data.
      *
+     * Authenticated encryption via XSalsa20-Poly1305 (sodium_crypto_secretbox).
+     * A fresh random nonce is generated per call and prepended to the
+     * ciphertext; the pair is base64-encoded for storage in a text column.
+     *
+     * Fails closed: returns null when no key is configured, rather than
+     * degrading to storing recoverable plaintext.
+     *
+     * MIGRATION: values written by the previous release were base64-encoded
+     * plaintext, not ciphertext. They will not decrypt and are not migrated
+     * automatically, deliberately, because base64 is reversible by anyone with
+     * database read access and those keys must be treated as disclosed. After
+     * defining HTMLTRUST_ENCRYPTION_KEY, revoke every server and author API key
+     * on the signing server and re-enter the replacements in the plugin's
+     * server and author profile screens.
+     *
      * @since    1.0.0
-     * @param    string    $data    The data to encrypt.
-     * @return   string             The encrypted data.
+     * @param    string      $data    The data to encrypt.
+     * @return   string|null          The encrypted data, or null on failure.
      */
     public function encrypt($data) {
-        // For simplicity, we're using base64 encoding here
-        // In a production environment, use a more secure encryption method
-        // Consider using WordPress's Sodium compatibility layer if available
-        return base64_encode($data);
+        if (!function_exists('sodium_crypto_secretbox')) {
+            return null;
+        }
+
+        $key = $this->get_encryption_key();
+        if (null === $key) {
+            return null;
+        }
+
+        $nonce = random_bytes(SODIUM_CRYPTO_SECRETBOX_NONCEBYTES);
+        $ciphertext = sodium_crypto_secretbox((string) $data, $nonce, $key);
+        sodium_memzero($key);
+
+        return base64_encode($nonce . $ciphertext);
     }
 
     /**
      * Decrypt sensitive data.
      *
+     * Splits the stored blob into nonce and ciphertext and verifies the
+     * Poly1305 tag. Any tampering, truncation, or wrong key yields null.
+     *
      * @since    1.0.0
-     * @param    string    $data    The data to decrypt.
-     * @return   string             The decrypted data.
+     * @param    string      $data    The data to decrypt.
+     * @return   string|null          The decrypted data, or null on failure.
      */
     public function decrypt($data) {
-        // For simplicity, we're using base64 decoding here
-        // In a production environment, use a more secure decryption method
-        // Consider using WordPress's Sodium compatibility layer if available
-        return base64_decode($data);
+        if (!function_exists('sodium_crypto_secretbox_open') || !is_string($data) || $data === '') {
+            return null;
+        }
+
+        $key = $this->get_encryption_key();
+        if (null === $key) {
+            return null;
+        }
+
+        $raw = base64_decode($data, true);
+        if (false === $raw || strlen($raw) <= SODIUM_CRYPTO_SECRETBOX_NONCEBYTES) {
+            sodium_memzero($key);
+            return null;
+        }
+
+        $nonce = substr($raw, 0, SODIUM_CRYPTO_SECRETBOX_NONCEBYTES);
+        $ciphertext = substr($raw, SODIUM_CRYPTO_SECRETBOX_NONCEBYTES);
+
+        $plaintext = sodium_crypto_secretbox_open($ciphertext, $nonce, $key);
+        sodium_memzero($key);
+
+        return false === $plaintext ? null : $plaintext;
     }
 
     /**
@@ -106,12 +200,17 @@ public function insert_server($data) {
         
         $data = wp_parse_args($data, $defaults);
         
-        // Encrypt the API key
+        // Encrypt the API key. Refuse the write outright if encryption is
+        // unavailable: storing an unencrypted key would be worse than failing.
         if (!empty($data['api_key'])) {
-            $data['api_key_encrypted'] = $this->encrypt($data['api_key']);
+            $encrypted = $this->encrypt($data['api_key']);
+            if (null === $encrypted) {
+                return false;
+            }
+            $data['api_key_encrypted'] = $encrypted;
             unset($data['api_key']);
         }
-        
+
         // If this is set as default, unset any existing defaults
         if ($data['is_default_server']) {
             $this->wpdb->update(
@@ -140,10 +239,14 @@ public function update_server($server_id, $data) {
         
         // Encrypt the API key if provided
         if (!empty($data['api_key'])) {
-            $data['api_key_encrypted'] = $this->encrypt($data['api_key']);
+            $encrypted = $this->encrypt($data['api_key']);
+            if (null === $encrypted) {
+                return false;
+            }
+            $data['api_key_encrypted'] = $encrypted;
             unset($data['api_key']);
         }
-        
+
         // If this is set as default, unset any existing defaults
         if (isset($data['is_default_server']) && $data['is_default_server']) {
             $this->wpdb->update(
@@ -243,18 +346,23 @@ public function insert_author($data) {
         
         $data = wp_parse_args($data, $defaults);
         
-        // Encrypt the API key
+        // Encrypt the API key. Refuse the write outright if encryption is
+        // unavailable: storing an unencrypted key would be worse than failing.
         if (!empty($data['author_api_key'])) {
-            $data['author_api_key_encrypted'] = $this->encrypt($data['author_api_key']);
+            $encrypted = $this->encrypt($data['author_api_key']);
+            if (null === $encrypted) {
+                return false;
+            }
+            $data['author_api_key_encrypted'] = $encrypted;
             unset($data['author_api_key']);
         }
-        
+
         // Encode default claims as JSON if it's an array
         if (isset($data['default_claims']) && is_array($data['default_claims'])) {
             $data['default_claims_json'] = wp_json_encode($data['default_claims']);
             unset($data['default_claims']);
         }
-        
+
         // Insert the author
         $result = $this->wpdb->insert($this->tables['authors'], $data);
         
@@ -274,10 +382,14 @@ public function update_author($author_profile_id, $data) {
         
         // Encrypt the API key if provided
         if (!empty($data['author_api_key'])) {
-            $data['author_api_key_encrypted'] = $this->encrypt($data['author_api_key']);
+            $encrypted = $this->encrypt($data['author_api_key']);
+            if (null === $encrypted) {
+                return false;
+            }
+            $data['author_api_key_encrypted'] = $encrypted;
             unset($data['author_api_key']);
         }
-        
+
         // Encode default claims as JSON if it's an array
         if (isset($data['default_claims']) && is_array($data['default_claims'])) {
             $data['default_claims_json'] = wp_json_encode($data['default_claims']);
diff --git a/wordpress/public/class-content-signing-display.php b/wordpress/public/class-content-signing-display.php
index f13520a..3fe4141 100644
--- a/wordpress/public/class-content-signing-display.php
+++ b/wordpress/public/class-content-signing-display.php
@@ -63,13 +63,16 @@ public function display_signature($content) {
             return $content;
         }
 
-        // Build the signature HTML
-        $signature_html = $this->get_signature_html($post_id);
+        $primary_signature = $this->get_primary_signature($signatures);
+        if (!$primary_signature) {
+            return $content;
+        }
 
-        // Append the signature HTML to the content
-        $content .= $signature_html;
+        if (stripos($content, '<signed-section') !== false) {
+            return $content . $this->get_signature_html($post_id);
+        }
 
-        return $content;
+        return $this->get_signed_section_html($primary_signature, $content) . $this->get_signature_html($post_id);
     }
 
     /**
@@ -102,16 +105,12 @@ public function get_signature_html($post_id, $options = array()) {
         }
 
         // Get the primary signature (first one with status 'signed')
-        $primary_signature = null;
+        $primary_signature = $this->get_primary_signature($signatures);
         $endorsement_signatures = array();
 
         foreach ($signatures as $signature) {
-            if ($signature->status === 'signed') {
-                if (!$primary_signature) {
-                    $primary_signature = $signature;
-                } else {
-                    $endorsement_signatures[] = $signature;
-                }
+            if ($signature->status === 'signed' && $primary_signature && $signature->signature_id !== $primary_signature->signature_id) {
+                $endorsement_signatures[] = $signature;
             }
         }
 
@@ -166,14 +165,28 @@ public function get_signature_html($post_id, $options = array()) {
 
         $html .= '</div>'; // .content-signing-details
 
-        // Add the signature HTML attributes for verification
-        $html .= $this->get_signature_attributes_html($primary_signature);
-
         $html .= '</div>'; // .content-signing-container
 
         return $html;
     }
 
+    /**
+     * Get the primary signed signature.
+     *
+     * @since    1.0.0
+     * @param    array $signatures The signatures.
+     * @return   object|null       The primary signature.
+     */
+    private function get_primary_signature($signatures) {
+        foreach ($signatures as $signature) {
+            if ($signature->status === 'signed') {
+                return $signature;
+            }
+        }
+
+        return null;
+    }
+
     /**
      * Get the HTML for displaying the signature status.
      *
@@ -354,69 +367,205 @@ private function get_endorsements_html($endorsements, $options) {
     }
 
     /**
-     * Get the HTML attributes for the signature container.
+     * Wrap signed post content in a spec-conformant signed-section element.
      *
      * @since    1.0.0
      * @param    object    $signature    The signature object.
-     * @return   string                  The signature attributes HTML.
+     * @param    string    $content      The rendered post content.
+     * @return   string                  The signed section HTML.
      */
-    private function get_signature_attributes_html($signature) {
-        // Get the author's public key
-        $author_public_key = '';
-
-        // Create an API client for the server
-        $server = $this->db->get_server($signature->server_id);
-        if ($server) {
-            $api_client = new ContentSigning_API_Client(
-                $server->api_url,
-                $this->db->decrypt($server->api_key_encrypted),
-                $this->db
-            );
-
-            // Get the author's public key
-            $result = $api_client->get_author_public_key($signature->signing_author_id);
-            if (!is_wp_error($result) && isset($result['key'])) {
-                $author_public_key = $result['key'];
-            }
+    private function get_signed_section_html($signature, $content) {
+        $key = $this->get_key_metadata($signature);
+        if ($key['keyid'] === '' || $key['algorithm'] === '') {
+            return $content;
         }
 
-        // Build the signed-section element with signature attributes
         $html = '<signed-section ';
         $html .= 'signature="' . esc_attr($signature->signature) . '" ';
-        $html .= 'keyid="' . esc_attr($author_public_key) . '" ';
-        $html .= 'algorithm="ed25519" ';
-        $html .= 'content-hash="' . esc_attr($signature->content_hash) . '" ';
-        $html .= 'style="display: block;">';
-
-        // Inner metadata: timestamp
-        $signed_at = $signature->signed_at ? $signature->signed_at : $signature->created_at;
-        if ($signed_at) {
-            $html .= '<meta name="signed-at" content="' . esc_attr($signed_at) . '">';
+        $html .= 'keyid="' . esc_attr($key['keyid']) . '" ';
+        $html .= 'algorithm="' . esc_attr($key['algorithm']) . '" ';
+        $html .= 'content-hash="' . esc_attr($signature->content_hash) . '">';
+        $html .= $this->get_claim_meta_html($signature);
+        $html .= $content;
+        $html .= '</signed-section>';
+
+        return $html;
+    }
+
+    /**
+     * Get the key identifier and signature algorithm for a signature.
+     *
+     * The `algorithm` attribute has to name the algorithm the signing key
+     * actually uses; a verifier that is handed the wrong identifier fails with
+     * "algorithm-not-supported" or, worse, tries the wrong primitive. The
+     * directory reports it from GET /authors/{id}/public-key.
+     *
+     * The remote lookup is cached because this runs on every rendered view of
+     * a signed post.
+     *
+     * @since    1.0.0
+     * @param    object $signature The signature object.
+     * @return   array             Key metadata: 'keyid' and 'algorithm'.
+     */
+    private function get_key_metadata($signature) {
+        $keyid = '';
+        $algorithm = '';
+
+        $api_response = json_decode($signature->api_response_json, true);
+        if (is_array($api_response)) {
+            foreach (array('keyid', 'keyId', 'publicKeyUrl') as $field) {
+                if (!empty($api_response[$field])) {
+                    $keyid = (string) $api_response[$field];
+                    break;
+                }
+            }
+
+            if (!empty($api_response['algorithm'])) {
+                $algorithm = (string) $api_response['algorithm'];
+            }
         }
 
-        // Inner metadata: author name
-        $author_name = $signature->signing_author_id;
-        $wp_user = get_user_by('ID', $signature->wp_user_id);
-        if ($wp_user) {
-            $author_name = $wp_user->display_name;
+        if ($keyid === '' || $algorithm === '') {
+            $remote = $this->get_remote_key_metadata($signature);
+
+            if ($keyid === '' && $remote['keyid'] !== '') {
+                $keyid = $remote['keyid'];
+            }
+
+            if ($algorithm === '' && $remote['algorithm'] !== '') {
+                $algorithm = $remote['algorithm'];
+            }
+        }
+
+        return array(
+            'keyid' => $keyid,
+            'algorithm' => $algorithm,
+        );
+    }
+
+    /**
+     * Look up key metadata from the signing server, with a short cache.
+     *
+     * @since    1.0.0
+     * @param    object $signature The signature object.
+     * @return   array             Key metadata: 'keyid' and 'algorithm'.
+     */
+    private function get_remote_key_metadata($signature) {
+        $empty = array('keyid' => '', 'algorithm' => '');
+
+        $cache_key = 'content_signing_key_' . md5($signature->server_id . '|' . $signature->signing_author_id);
+        $cached = get_transient($cache_key);
+        if (is_array($cached)) {
+            return $cached;
         }
-        if ($author_name) {
-            $html .= '<meta name="author" content="' . esc_attr($author_name) . '">';
+
+        $server = $this->db->get_server($signature->server_id);
+        if (!$server) {
+            return $empty;
         }
 
-        // Inner metadata: claims from JSON
-        $claims = json_decode($signature->claims_json, true);
-        if (!empty($claims)) {
-            foreach ($claims as $key => $value) {
+        $api_client = new ContentSigning_API_Client(
+            $server->api_url,
+            $this->db->decrypt($server->api_key_encrypted),
+            $this->db
+        );
+
+        $result = $api_client->get_author_public_key($signature->signing_author_id);
+        if (is_wp_error($result) || !is_array($result)) {
+            return $empty;
+        }
+
+        $metadata = $empty;
+        if (!empty($result['id'])) {
+            $metadata['keyid'] = rtrim($server->api_url, '/') . '/keys/' . rawurlencode((string) $result['id']);
+        }
+        if (!empty($result['algorithm'])) {
+            $metadata['algorithm'] = (string) $result['algorithm'];
+        }
+
+        set_transient($cache_key, $metadata, 12 * HOUR_IN_SECONDS);
+
+        return $metadata;
+    }
+
+    /**
+     * Get direct child claim meta HTML for a signed-section.
+     *
+     * @since    1.0.0
+     * @param    object $signature The signature object.
+     * @return   string            The meta HTML.
+     */
+    private function get_claim_meta_html($signature) {
+        $claims = $this->get_protocol_claims($signature);
+        $html = '';
+
+        foreach ($claims as $name => $value) {
+            $html .= '<meta name="' . esc_attr($name) . '" content="' . esc_attr($value) . '">';
+        }
+
+        return $html;
+    }
+
+    /**
+     * Get the protocol claim map for a signature.
+     *
+     * @since    1.0.0
+     * @param    object $signature The signature object.
+     * @return   array             Claims keyed by direct meta name.
+     */
+    private function get_protocol_claims($signature) {
+        $claims = array();
+        $stored_claims = json_decode($signature->claims_json, true);
+
+        if (is_array($stored_claims)) {
+            foreach ($stored_claims as $key => $value) {
+                if (is_array($value) && isset($value['name'], $value['content'])) {
+                    $claims[$value['name']] = $value['content'];
+                    continue;
+                }
+
                 if (is_array($value)) {
                     $value = implode(', ', $value);
                 }
-                $html .= '<meta name="claim:' . esc_attr($key) . '" content="' . esc_attr($value) . '">';
+
+                $name = (string) $key;
+                if ($name !== 'author' && $name !== 'signed-at' && strpos($name, 'claim:') !== 0) {
+                    $name = 'claim:' . $name;
+                }
+
+                $claims[$name] = (string) $value;
             }
         }
 
-        $html .= '</signed-section>';
+        $author_name = $signature->signing_author_id;
+        $wp_user = get_user_by('ID', $signature->wp_user_id);
+        if ($wp_user) {
+            $author_name = $wp_user->display_name;
+        }
+        if ($author_name && empty($claims['author'])) {
+            $claims['author'] = $author_name;
+        }
 
-        return $html;
+        if (empty($claims['signed-at'])) {
+            $claims['signed-at'] = $this->format_signed_at($signature->signed_at ? $signature->signed_at : $signature->created_at);
+        }
+
+        return $claims;
+    }
+
+    /**
+     * Format a stored datetime as RFC3339 UTC.
+     *
+     * @since    1.0.0
+     * @param    string $datetime The stored datetime.
+     * @return   string           The RFC3339 UTC datetime.
+     */
+    private function format_signed_at($datetime) {
+        $timestamp = strtotime($datetime);
+        if (!$timestamp) {
+            $timestamp = time();
+        }
+
+        return gmdate('Y-m-d\TH:i:s\Z', $timestamp);
     }
 }
diff --git a/wordpress/public/class-content-signing-public.php b/wordpress/public/class-content-signing-public.php
index 48c61ff..2383f2a 100644
--- a/wordpress/public/class-content-signing-public.php
+++ b/wordpress/public/class-content-signing-public.php
@@ -52,6 +52,19 @@ public function __construct($db, $api_client) {
         $this->display = new ContentSigning_Display($db, $api_client);
     }
 
+    /**
+     * Get the display handler.
+     *
+     * The signing service needs it to detach the `the_content` wrapper while
+     * rendering the bytes it hashes.
+     *
+     * @since    1.0.0
+     * @return   ContentSigning_Display    The display handler.
+     */
+    public function get_display() {
+        return $this->display;
+    }
+
     /**
      * Register the stylesheets for the public-facing side of the site.
      *
diff --git a/wordpress/public/js/content-signing-public.js b/wordpress/public/js/content-signing-public.js
index 504097c..68ad1fc 100644
--- a/wordpress/public/js/content-signing-public.js
+++ b/wordpress/public/js/content-signing-public.js
@@ -85,7 +85,8 @@
           "content-signing-verification-loading content-signing-verification-error",
         )
         .addClass("content-signing-verification-success")
-        .html(buildVerificationResultHtml(response.data, true));
+        .empty()
+        .append(buildVerificationResult(response.data, true));
     } else {
       // Show error message
       $resultContainer
@@ -93,58 +94,75 @@
           "content-signing-verification-loading content-signing-verification-success",
         )
         .addClass("content-signing-verification-error")
-        .html(buildVerificationResultHtml(response.data, false));
+        .empty()
+        .append(buildVerificationResult(response.data, false));
     }
   }
 
   /**
-   * Build the verification result HTML.
+   * Build the verification result nodes.
+   *
+   * Every value here originates from the trust server and is untrusted: a
+   * directory is not part of the trust root, and its response strings reach
+   * this page verbatim. Nodes are therefore built with .text() rather than
+   * concatenated into markup.
    *
    * @param {Object} data - The verification data.
    * @param {boolean} success - Whether verification was successful.
-   * @return {string} The HTML for the verification result.
+   * @return {jQuery} The nodes for the verification result.
    */
-  function buildVerificationResultHtml(data, success) {
-    let html = "";
+  function buildVerificationResult(data, success) {
+    const $nodes = $();
+    const details = data && data.verification_details;
 
     if (success) {
-      html +=
-        "<p><strong>" + content_signing_public.i18n.verified + "</strong></p>";
+      const $heading = $("<p>").append(
+        $("<strong>").text(content_signing_public.i18n.verified),
+      );
+      let $result = $nodes.add($heading);
 
       // Add verification details if available
-      if (data.verification_details) {
-        html += '<ul class="content-signing-verification-details">';
+      if (details && typeof details === "object") {
+        const $list = $("<ul>").addClass(
+          "content-signing-verification-details",
+        );
 
         // Add each verification detail
-        for (const key in data.verification_details) {
-          if (data.verification_details.hasOwnProperty(key)) {
-            const value = data.verification_details[key];
-            html +=
-              '<li><span class="content-signing-verification-key">' +
-              key +
-              ":</span> ";
-            html +=
-              '<span class="content-signing-verification-value">' +
-              value +
-              "</span></li>";
-          }
-        }
-
-        html += "</ul>";
-      }
-    } else {
-      html +=
-        "<p><strong>" +
-        content_signing_public.i18n.not_verified +
-        "</strong></p>";
-
-      // Add error message if available
-      if (data.message) {
-        html += "<p>" + data.message + "</p>";
+        Object.keys(details).forEach(function (key) {
+          $list.append(
+            $("<li>")
+              .append(
+                $("<span>")
+                  .addClass("content-signing-verification-key")
+                  .text(key + ":"),
+              )
+              .append(document.createTextNode(" "))
+              .append(
+                $("<span>")
+                  .addClass("content-signing-verification-value")
+                  .text(String(details[key])),
+              ),
+          );
+        });
+
+        $result = $result.add($list);
       }
+
+      return $result;
+    }
+
+    let $result = $nodes.add(
+      $("<p>").append(
+        $("<strong>").text(content_signing_public.i18n.not_verified),
+      ),
+    );
+
+    // Add error message if available
+    if (data && data.message) {
+      $result = $result.add($("<p>").text(String(data.message)));
     }
 
-    return html;
+    return $result;
   }
 
   /**
diff --git a/wordpress/tests/bootstrap.php b/wordpress/tests/bootstrap.php
index 36d1952..0004acb 100644
--- a/wordpress/tests/bootstrap.php
+++ b/wordpress/tests/bootstrap.php
@@ -21,8 +21,15 @@
 
 /**
  * Manually load the plugin being tested.
+ *
+ * The encryption key is what wp-config.php supplies on a real site; without it
+ * ContentSigning_DB::encrypt() fails closed and every API-key write is refused.
  */
 function _manually_load_plugin() {
+	if ( ! defined( 'HTMLTRUST_ENCRYPTION_KEY' ) ) {
+		define( 'HTMLTRUST_ENCRYPTION_KEY', base64_encode( str_repeat( "\x01", 32 ) ) );
+	}
+
 	require dirname( dirname( __FILE__ ) ) . '/content-signing.php';
 }
 tests_add_filter( 'muplugins_loaded', '_manually_load_plugin' );
diff --git a/wordpress/tests/class-content-signing-api-client-test-case.php b/wordpress/tests/class-content-signing-api-client-test-case.php
index b4ca4d5..b412922 100644
--- a/wordpress/tests/class-content-signing-api-client-test-case.php
+++ b/wordpress/tests/class-content-signing-api-client-test-case.php
@@ -34,7 +34,7 @@ class ContentSigning_API_Client_TestCase extends ContentSigning_DB_TestCase {
     /**
      * Set up before each test.
      */
-    public function setUp() {
+    public function setUp(): void {
         parent::setUp();
         
         // Create a mock API client
@@ -43,6 +43,15 @@ public function setUp() {
             $this->mock_api_key,
             $this->db
         );
+
+        update_option('content_signing_enable_signing', true);
+        update_option('content_signing_sign_on_publish', true);
+        update_option('content_signing_sign_on_update', false);
+        update_option('content_signing_sign_days_before_publish', 0);
+        update_option('content_signing_sign_days_after_publish', 0);
+        update_option('content_signing_enable_endorsements', false);
+        update_option('content_signing_endorser_profiles', array());
+        wp_clear_scheduled_hook('content_signing_scheduled_signing');
         
         // Add filter to mock API responses
         add_filter('pre_http_request', array($this, 'mock_api_response'), 10, 3);
@@ -51,13 +60,26 @@ public function setUp() {
     /**
      * Tear down after each test.
      */
-    public function tearDown() {
+    public function tearDown(): void {
         // Remove filter
         remove_filter('pre_http_request', array($this, 'mock_api_response'), 10);
         
         parent::tearDown();
     }
 
+    protected function create_test_server($data = array()) {
+        return parent::create_test_server(wp_parse_args($data, array(
+            'api_url' => $this->mock_server_url,
+            'api_key' => $this->mock_api_key,
+        )));
+    }
+
+    protected function create_test_author($data = array()) {
+        return parent::create_test_author(wp_parse_args($data, array(
+            'author_api_key' => 'mock-author-api-key',
+        )));
+    }
+
     /**
      * Mock API response.
      *
@@ -101,19 +123,22 @@ public function mock_api_response($response, $args, $url) {
             );
         }
         
-        // Handle different endpoints
+        // Handle different endpoints. Path parameters are rawurldecode()d
+        // because the client percent-encodes each interpolated segment, and a
+        // real server (Express, in the reference directory) decodes them
+        // before the route handler sees them.
         switch (true) {
             case preg_match('/^authors$/', $endpoint) && $method === 'POST':
                 return $this->mock_create_author_response($body);
                 
             case preg_match('/^authors\/([^\/]+)$/', $endpoint, $matches) && $method === 'GET':
-                return $this->mock_get_author_response($matches[1]);
+                return $this->mock_get_author_response(rawurldecode($matches[1]));
                 
             case preg_match('/^authors\/([^\/]+)$/', $endpoint, $matches) && $method === 'PUT':
-                return $this->mock_update_author_response($matches[1], $body);
+                return $this->mock_update_author_response(rawurldecode($matches[1]), $body);
                 
             case preg_match('/^authors\/([^\/]+)\/public-key$/', $endpoint, $matches) && $method === 'GET':
-                return $this->mock_get_author_public_key_response($matches[1]);
+                return $this->mock_get_author_public_key_response(rawurldecode($matches[1]));
                 
             case preg_match('/^content\/sign$/', $endpoint) && $method === 'POST':
                 return $this->mock_sign_content_response($body);
@@ -125,19 +150,19 @@ public function mock_api_response($response, $args, $url) {
                 return $this->mock_get_claim_types_response();
                 
             case preg_match('/^claims\/([^\/]+)$/', $endpoint, $matches) && $method === 'GET':
-                return $this->mock_get_claim_type_response($matches[1]);
+                return $this->mock_get_claim_type_response(rawurldecode($matches[1]));
                 
             case preg_match('/^directory\/keys$/', $endpoint) && $method === 'GET':
                 return $this->mock_search_public_keys_response();
                 
             case preg_match('/^directory\/keys\/([^\/]+)\/reputation$/', $endpoint, $matches) && $method === 'GET':
-                return $this->mock_get_key_reputation_response($matches[1]);
+                return $this->mock_get_key_reputation_response(rawurldecode($matches[1]));
                 
             case preg_match('/^directory\/content$/', $endpoint) && $method === 'GET':
                 return $this->mock_search_signed_content_response();
                 
             case preg_match('/^directory\/content\/([^\/]+)\/occurrences$/', $endpoint, $matches) && $method === 'GET':
-                return $this->mock_find_content_occurrences_response($matches[1]);
+                return $this->mock_find_content_occurrences_response(rawurldecode($matches[1]));
                 
             default:
                 return array(
@@ -219,6 +244,7 @@ protected function mock_get_author_public_key_response($author_id) {
                 'id' => 'mock-key-id',
                 'type' => 'HUMAN',
                 'publicKey' => 'mock-public-key',
+                'algorithm' => 'ed25519',
             )),
         );
     }
@@ -237,6 +263,8 @@ protected function mock_sign_content_response($body) {
                 'domain' => isset($body['domain']) ? $body['domain'] : 'example.com',
                 'authorId' => 'mock-author-id',
                 'keyId' => 'mock-key-id',
+                'keyid' => $this->mock_server_url . '/keys/mock-key-id',
+                'algorithm' => 'ed25519',
                 'signature' => 'mock-signature',
                 'claims' => isset($body['claims']) ? $body['claims'] : array(),
                 'timestamp' => time(),
@@ -446,4 +474,4 @@ protected function mock_find_content_occurrences_response($content_hash) {
             )),
         );
     }
-}
\ No newline at end of file
+}
diff --git a/wordpress/tests/class-content-signing-db-test-case.php b/wordpress/tests/class-content-signing-db-test-case.php
index c4a902e..bc15feb 100644
--- a/wordpress/tests/class-content-signing-db-test-case.php
+++ b/wordpress/tests/class-content-signing-db-test-case.php
@@ -20,7 +20,7 @@ class ContentSigning_DB_TestCase extends ContentSigning_TestCase {
     /**
      * Set up before each test.
      */
-    public function setUp() {
+    public function setUp(): void {
         parent::setUp();
         
         // Get DB instance
@@ -33,7 +33,7 @@ public function setUp() {
     /**
      * Tear down after each test.
      */
-    public function tearDown() {
+    public function tearDown(): void {
         // Clean up test data
         $this->clean_test_data();
         
@@ -164,4 +164,4 @@ protected function create_test_signature($data = array()) {
         
         return $this->db->insert_signature($data);
     }
-}
\ No newline at end of file
+}
diff --git a/wordpress/tests/class-content-signing-test-case.php b/wordpress/tests/class-content-signing-test-case.php
index b932330..f710916 100644
--- a/wordpress/tests/class-content-signing-test-case.php
+++ b/wordpress/tests/class-content-signing-test-case.php
@@ -10,10 +10,13 @@
  */
 class ContentSigning_TestCase extends WP_UnitTestCase {
 
+    /** @var ContentSigning_Plugin */
+    protected $plugin;
+
     /**
      * Set up before each test.
      */
-    public function setUp() {
+    public function setUp(): void {
         parent::setUp();
         
         // Get plugin instance
@@ -23,7 +26,7 @@ public function setUp() {
     /**
      * Tear down after each test.
      */
-    public function tearDown() {
+    public function tearDown(): void {
         parent::tearDown();
     }
 
@@ -37,7 +40,7 @@ protected function create_test_post($args = array()) {
         $defaults = array(
             'post_title' => 'Test Post',
             'post_content' => 'This is test content for signing.',
-            'post_status' => 'publish',
+            'post_status' => 'draft',
             'post_author' => 1,
             'post_type' => 'post',
         );
@@ -65,4 +68,4 @@ protected function create_test_user($args = array()) {
         
         return wp_insert_user($args);
     }
-}
\ No newline at end of file
+}
diff --git a/wordpress/tests/test-content-signing-api-client.php b/wordpress/tests/test-content-signing-api-client.php
index 1c4080b..7c92fdf 100644
--- a/wordpress/tests/test-content-signing-api-client.php
+++ b/wordpress/tests/test-content-signing-api-client.php
@@ -237,10 +237,6 @@ public function test_find_content_occurrences() {
      * Test API error handling.
      */
     public function test_api_error_handling() {
-        // Temporarily modify the mock API key to trigger an error
-        $original_key = $this->mock_api_key;
-        $this->mock_api_key = 'invalid-key';
-        
         // Create a new API client with the invalid key
         $api_client = new ContentSigning_API_Client(
             $this->mock_server_url,
@@ -256,25 +252,6 @@ public function test_api_error_handling() {
         $this->assertEquals('api_error', $result->get_error_code());
         $this->assertEquals('Invalid API key', $result->get_error_message());
         
-        // Restore original key
-        $this->mock_api_key = $original_key;
-    }
-
-    /**
-     * Helper method to check if a value is not a WP_Error.
-     *
-     * @param mixed $value The value to check.
-     */
-    private function assertNotWPError($value) {
-        $this->assertFalse(is_wp_error($value), 'Value is a WP_Error: ' . (is_wp_error($value) ? $value->get_error_message() : ''));
     }
 
-    /**
-     * Helper method to check if a value is a WP_Error.
-     *
-     * @param mixed $value The value to check.
-     */
-    private function assertWPError($value) {
-        $this->assertTrue(is_wp_error($value), 'Value is not a WP_Error');
-    }
-}
\ No newline at end of file
+}
diff --git a/wordpress/tests/test-content-signing-db.php b/wordpress/tests/test-content-signing-db.php
index 4d3e9ed..b1ca474 100644
--- a/wordpress/tests/test-content-signing-db.php
+++ b/wordpress/tests/test-content-signing-db.php
@@ -30,20 +30,53 @@ public function test_get_table_name() {
      */
     public function test_encrypt_decrypt() {
         $original = 'test-api-key';
-        
+
         // Encrypt
         $encrypted = $this->db->encrypt($original);
-        
+
         // Verify encrypted is different from original
         $this->assertNotEquals($original, $encrypted);
-        
+
+        // Verify the stored value is ciphertext, not reversible encoding
+        $this->assertNotEquals($original, base64_decode($encrypted, true));
+        $this->assertStringNotContainsString($original, (string) base64_decode($encrypted, true));
+
         // Decrypt
         $decrypted = $this->db->decrypt($encrypted);
-        
+
         // Verify decrypted matches original
         $this->assertEquals($original, $decrypted);
     }
 
+    /**
+     * Test that encryption uses a fresh nonce per call.
+     */
+    public function test_encrypt_is_nondeterministic() {
+        $original = 'test-api-key';
+
+        $this->assertNotEquals($this->db->encrypt($original), $this->db->encrypt($original));
+    }
+
+    /**
+     * Test that tampered ciphertext is rejected rather than silently decoded.
+     */
+    public function test_decrypt_rejects_tampered_ciphertext() {
+        $encrypted = $this->db->encrypt('test-api-key');
+        $raw = base64_decode($encrypted, true);
+
+        // Flip a bit in the last ciphertext byte.
+        $raw[strlen($raw) - 1] = chr(ord($raw[strlen($raw) - 1]) ^ 0x01);
+
+        $this->assertNull($this->db->decrypt(base64_encode($raw)));
+    }
+
+    /**
+     * Test that legacy base64 values from the previous release do not decrypt.
+     */
+    public function test_decrypt_rejects_legacy_base64_values() {
+        $this->assertNull($this->db->decrypt(base64_encode('test-api-key')));
+    }
+
     /**
      * Test server CRUD operations.
      */
diff --git a/wordpress/tests/test-content-signing-integration.php b/wordpress/tests/test-content-signing-integration.php
index 53c3f72..630a876 100644
--- a/wordpress/tests/test-content-signing-integration.php
+++ b/wordpress/tests/test-content-signing-integration.php
@@ -27,7 +27,7 @@ class Test_Content_Signing_Integration extends ContentSigning_API_Client_TestCas
     /**
      * Set up before each test.
      */
-    public function setUp() {
+    public function setUp(): void {
         parent::setUp();
         
         // Get components
@@ -68,9 +68,6 @@ public function test_complete_signing_workflow() {
         wp_publish_post($post_id);
         $post = get_post($post_id);
         
-        // Simulate the save_post hook
-        do_action('save_post', $post_id, $post, false);
-        
         // Verify a signature was created
         $signatures = $this->db->get_signatures_by_post_id($post_id);
         $this->assertCount(1, $signatures);
@@ -160,11 +157,9 @@ public function test_scheduled_signing_workflow() {
         // Create a post
         $post_id = $this->create_test_post(array(
             'post_author' => $user_id,
+            'post_status' => 'publish',
         ));
-        $post = get_post($post_id);
-        
-        // Simulate the save_post hook
-        do_action('save_post', $post_id, $post, false);
+        wp_publish_post($post_id);
         
         // Verify no signatures yet
         $signatures = $this->db->get_signatures_by_post_id($post_id);
@@ -220,10 +215,7 @@ public function test_endorsement_workflow() {
         $post_id = $this->create_test_post(array(
             'post_author' => $user_id,
         ));
-        $post = get_post($post_id);
-        
-        // Simulate the save_post hook
-        do_action('save_post', $post_id, $post, false);
+        wp_publish_post($post_id);
         
         // Verify signatures were created (1 primary + 2 endorsements)
         $signatures = $this->db->get_signatures_by_post_id($post_id);
@@ -254,11 +246,73 @@ public function test_post_meta_box_integration() {
         update_post_meta($post_id, '_content_signing_claims', array('ContentType' => 'Article'));
         
         // Verify post meta is saved correctly
-        $this->assertTrue(get_post_meta($post_id, '_content_signing_disable', true));
+        $this->assertTrue((bool) get_post_meta($post_id, '_content_signing_disable', true));
         $claims = get_post_meta($post_id, '_content_signing_claims', true);
         $this->assertEquals('Article', $claims['ContentType']);
     }
 
+    /**
+     * Test public rendering wraps the actual post content in signed-section.
+     */
+    public function test_public_rendering_wraps_actual_signed_content() {
+        $server_id = $this->create_test_server();
+        $user_id = $this->create_test_user(array(
+            'display_name' => 'Alice Example',
+        ));
+        $post_id = $this->create_test_post(array(
+            'post_author' => $user_id,
+            'post_content' => '<p>Signed body</p>',
+        ));
+
+        $signature_id = $this->create_test_signature(array(
+            'post_id' => $post_id,
+            'server_id' => $server_id,
+            'wp_user_id' => $user_id,
+            'content_hash' => 'sha256:47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU',
+            'domain' => 'https://example.org',
+            'signature' => 'qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq',
+            'claims' => array(
+                'author' => 'Alice Example',
+                'signed-at' => '2026-05-01T10:30:00Z',
+                'claim:ContentType' => 'Article',
+            ),
+            'api_response' => array(
+                'keyId' => 'did:web:author.example',
+                'algorithm' => 'ed25519',
+            ),
+        ));
+
+        $display = new ContentSigning_Display($this->db, $this->api_client);
+        $method = new ReflectionMethod($display, 'get_signed_section_html');
+        $method->setAccessible(true);
+        $html = $method->invoke($display, $this->db->get_signature($signature_id), '<p>Signed body</p>');
+
+        $this->assertStringStartsWith('<signed-section ', $html);
+        $this->assertStringContainsString('keyid="did:web:author.example"', $html);
+        $this->assertStringContainsString('<meta name="author" content="Alice Example">', $html);
+        $this->assertStringContainsString('<meta name="signed-at" content="2026-05-01T10:30:00Z">', $html);
+        $this->assertStringContainsString('<meta name="claim:ContentType" content="Article">', $html);
+        $this->assertStringContainsString('<p>Signed body</p></signed-section>', $html);
+    }
+
+    public function test_public_rendering_fails_closed_without_algorithm_metadata() {
+        $post_id = $this->create_test_post(array('post_content' => '<p>Signed body</p>'));
+        $signature_id = $this->create_test_signature(array(
+            'post_id' => $post_id,
+            'server_id' => 999999,
+            'signature' => 'qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq',
+            'api_response' => array('keyId' => 'did:web:author.example'),
+        ));
+        $display = new ContentSigning_Display($this->db, $this->api_client);
+        $method = new ReflectionMethod($display, 'get_signed_section_html');
+        $method->setAccessible(true);
+
+        $this->assertSame(
+            '<p>Signed body</p>',
+            $method->invoke($display, $this->db->get_signature($signature_id), '<p>Signed body</p>')
+        );
+    }
+
     /**
      * Test error handling in the signing process.
      */
@@ -299,4 +353,4 @@ public function test_error_handling() {
         // Restore original key
         $this->mock_api_key = $original_key;
     }
-}
\ No newline at end of file
+}
diff --git a/wordpress/tests/test-content-signing-scheduler.php b/wordpress/tests/test-content-signing-scheduler.php
index a6cb20b..f1c696b 100644
--- a/wordpress/tests/test-content-signing-scheduler.php
+++ b/wordpress/tests/test-content-signing-scheduler.php
@@ -20,7 +20,7 @@ class Test_Content_Signing_Scheduler extends ContentSigning_API_Client_TestCase
     /**
      * Set up before each test.
      */
-    public function setUp() {
+    public function setUp(): void {
         parent::setUp();
         
         // Get scheduler instance
@@ -30,7 +30,7 @@ public function setUp() {
     /**
      * Tear down after each test.
      */
-    public function tearDown() {
+    public function tearDown(): void {
         // Clear any scheduled events
         $this->clear_scheduled_hooks();
         
@@ -241,4 +241,4 @@ private function clear_scheduled_hooks() {
             wp_clear_scheduled_hook('content_signing_scheduled_signing', array($post_id));
         }
     }
-}
\ No newline at end of file
+}
diff --git a/wordpress/tests/test-content-signing-signing-service.php b/wordpress/tests/test-content-signing-signing-service.php
index a3ccd1c..f098a5c 100644
--- a/wordpress/tests/test-content-signing-signing-service.php
+++ b/wordpress/tests/test-content-signing-signing-service.php
@@ -27,7 +27,7 @@ class Test_Content_Signing_Signing_Service extends ContentSigning_API_Client_Tes
     /**
      * Set up before each test.
      */
-    public function setUp() {
+    public function setUp(): void {
         parent::setUp();
         
         // Get scheduler instance
@@ -103,6 +103,7 @@ public function test_process_post_sign_on_publish() {
             'post_author' => $user_id,
         ));
         $post = get_post($post_id);
+        $post->post_status = 'publish';
         
         // Process the post as a new publish
         $this->signing_service->process_post($post_id, $post, false);
@@ -134,6 +135,7 @@ public function test_process_post_sign_on_update() {
             'post_author' => $user_id,
         ));
         $post = get_post($post_id);
+        $post->post_status = 'publish';
         
         // Process the post as an update
         $this->signing_service->process_post($post_id, $post, true);
@@ -164,6 +166,8 @@ public function test_process_post_scheduled_signing() {
             'post_author' => $user_id,
         ));
         $post = get_post($post_id);
+        $post->post_status = 'publish';
+        $post->post_date_gmt = gmdate('Y-m-d H:i:s');
         
         // Process the post
         $this->signing_service->process_post($post_id, $post, false);
@@ -207,6 +211,67 @@ public function test_sign_post() {
         $this->assertEquals('mock-signature', $signatures[0]->signature);
     }
 
+    /**
+     * Test prepared signing data follows the current HTMLTrust wire format.
+     */
+    public function test_prepare_content_data_uses_origin_base64_and_direct_claims() {
+        $server_id = $this->create_test_server();
+        $user_id = $this->create_test_user(array(
+            'display_name' => 'Alice Example',
+        ));
+        $this->create_test_author(array(
+            'wp_user_id' => $user_id,
+            'server_id' => $server_id,
+            'default_claims' => array(
+                'License' => 'CC-BY-4.0',
+            ),
+        ));
+
+        $post_id = $this->create_test_post(array(
+            'post_author' => $user_id,
+            'post_content' => '<p>Read <a href="/about" aria-label="About HTMLTrust">about us</a>.</p>',
+        ));
+        update_post_meta($post_id, '_content_signing_claims', array(
+            'ContentType' => 'Article',
+        ));
+
+        $content_data = $this->invoke_prepare_content_data(get_post($post_id));
+
+        $this->assertMatchesRegularExpression('/^sha256:[A-Za-z0-9+\/]{43}$/', $content_data['contentHash']);
+        $this->assertStringNotContainsString('=', $content_data['contentHash']);
+        $this->assertEquals($this->expected_site_origin(), $content_data['domain']);
+        $this->assertEquals('Alice Example', $content_data['claims']['author']);
+        $this->assertMatchesRegularExpression('/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/', $content_data['claims']['signed-at']);
+        $this->assertEquals('Article', $content_data['claims']['claim:ContentType']);
+        $this->assertEquals('CC-BY-4.0', $content_data['claims']['claim:License']);
+    }
+
+    /**
+     * Test signed semantic attributes affect the content hash.
+     */
+    public function test_prepare_content_data_covers_signed_semantic_attributes() {
+        $server_id = $this->create_test_server();
+        $user_id = $this->create_test_user();
+        $this->create_test_author(array(
+            'wp_user_id' => $user_id,
+            'server_id' => $server_id,
+        ));
+
+        $first_post_id = $this->create_test_post(array(
+            'post_author' => $user_id,
+            'post_content' => '<p><a href="/one" aria-label="Read more">Read more</a></p>',
+        ));
+        $second_post_id = $this->create_test_post(array(
+            'post_author' => $user_id,
+            'post_content' => '<p><a href="/two" aria-label="Read more">Read more</a></p>',
+        ));
+
+        $first = $this->invoke_prepare_content_data(get_post($first_post_id));
+        $second = $this->invoke_prepare_content_data(get_post($second_post_id));
+
+        $this->assertNotEquals($first['contentHash'], $second['contentHash']);
+    }
+
     /**
      * Test sign_post method with missing post.
      */
@@ -234,6 +299,37 @@ public function test_sign_post_missing_author_profile() {
         $this->assertEquals('Author does not have a signing profile.', $result['message']);
     }
 
+    /**
+     * Invoke private prepare_content_data for focused format assertions.
+     *
+     * @param WP_Post $post The post.
+     * @return array        Prepared content data.
+     */
+    private function invoke_prepare_content_data($post) {
+        $method = new ReflectionMethod($this->signing_service, 'prepare_content_data');
+        $method->setAccessible(true);
+
+        return $method->invoke($this->signing_service, $post);
+    }
+
+    /**
+     * Get the expected serialized origin for the test site.
+     *
+     * @return string The serialized origin.
+     */
+    private function expected_site_origin() {
+        $parts = wp_parse_url(get_site_url());
+        $scheme = isset($parts['scheme']) ? strtolower($parts['scheme']) : 'https';
+        $host = isset($parts['host']) ? strtolower($parts['host']) : '';
+        $origin = $scheme . '://' . $host;
+
+        if (isset($parts['port']) && !(($scheme === 'http' && intval($parts['port']) === 80) || ($scheme === 'https' && intval($parts['port']) === 443))) {
+            $origin .= ':' . intval($parts['port']);
+        }
+
+        return $origin;
+    }
+
     /**
      * Test process_endorsements method.
      */
@@ -381,6 +477,7 @@ public function test_calculate_content_hash() {
         
         // Verify hash format
         $this->assertStringStartsWith('sha256:', $hash);
-        $this->assertEquals(71, strlen($hash)); // 'sha256:' + 64 characters for SHA-256 hash
+        $this->assertMatchesRegularExpression('/^sha256:[A-Za-z0-9+\/]{43}$/', $hash);
+        $this->assertStringNotContainsString('=', $hash);
     }
-}
\ No newline at end of file
+}