Revert Pattern B (key endorsement via countersignature)

Pattern B was added in 776873b alongside Pattern A but is no longer in
scope. This commit drops the entire Pattern B surface:

- spec: removes Section 12.2 (Key Endorsement via Countersignature) and
  Section 12.2.1 (Issuance Workflows), trims the Section 6.4 pointer
  back to Section 12.1 only, and removes the corresponding TOC entries.
- impl: removes src/endorse.rs, removes verify::key_endorsements, and
  drops the related exports from lib.rs.
- tests: removes all pattern_b_* tests and the issue_endorsement /
  embed_endorsement coverage from tests/multi_signer.rs.
- README: removes the Pattern B paragraphs and code snippets from the
  Trust patterns section, leaving only Pattern A.

Pattern A (self-binding key attestations) is unchanged.

https://claude.ai/code/session_01ST4PcjqvobURus32WuyEi5

Author: claude

reference/PCF-SIG-v1.0/README.md

@@ -77,8 +77,8 @@ for report in verify_all_with_recheck(&mut c)? {
 
 ## Trust patterns
 
-The profile defines two non-X.509 ways for an application to express trust;
-both are described in spec Section 12.
+The profile describes one non-X.509 way for an application to express trust
+in spec Section 12.
 
 **Pattern A — self-binding key attestations.** Carry a JWT, SCITT statement,
 or custom signed envelope as an application-private TLV entry (tag range
@@ -88,49 +88,6 @@ JWT `cnf.jkt`); otherwise the binding is meaningless because the fingerprint
 covers only `key_data`, not the TLV. The application verifies the
 attestation independently of PCF-SIG.
 
-**Pattern B — key endorsement via countersignature.** A "CA" emits a
-`PCFSIG_SIG` partition whose manifest covers the leaf signer's `PCFSIG_KEY`
-partition by uid. Verifiers report it like any other signature; the
-application checks whether any trusted CA fingerprint endorses the leaf key.
-
-```rust
-use pcf_sig::{key_endorsements, verify_all_with_recheck};
-
-let reports = verify_all_with_recheck(&mut container)?;
-let endorsers = key_endorsements(&mut container, &reports, &leaf_fingerprint)?;
-let trusted = endorsers.iter().any(|fp| my_trusted_ca_set.contains(fp));
-# Ok::<(), pcf_sig::Error>(())
-```
-
-For Pattern B the CA does NOT need the leaf's PCF file. The stateless
-workflow (spec 12.2.1 W2): the client sends only the leaf key bytes plus the
-planned partition identity; the CA returns a self-contained response that
-the client embeds locally.
-
-```rust
-use pcf_sig::{embed_endorsement, issue_endorsement, EndorsementRequest, KeyFormat};
-use pcf::HashAlgo;
-
-// CA side (stateless; no I/O, no file):
-let request = EndorsementRequest {
-    key_format: KeyFormat::Ed25519Raw,
-    key_data: leaf_public_key_bytes,
-    intended_uid: agreed_uid,           // stable across leaf and CA
-    intended_label: agreed_label,
-    data_hash_algo: HashAlgo::Sha256,
-};
-let response = issue_endorsement(&ca_signer, &request, signed_at)?;
-
-// Client side: embed into the local container:
-embed_endorsement(&mut container, &response, ca_key_uid, ca_sig_uid, "ca-key", "ca-sig")?;
-# Ok::<(), pcf_sig::Error>(())
-```
-
-Because the response commits to the leaf `PCFSIG_KEY` bytes (not to any file
-location), a client may also cache and re-use the same response across many
-PCF files in which the leaf KEY partition is reproduced byte-identical
-(workflow W3, license pattern).
-
 ## Relocation stability
 
 The central property: a PCFSIG_SIG signature remains valid across any

reference/PCF-SIG-v1.0/src/endorse.rs

@@ -49,7 +49,6 @@
 
 mod algo;
 pub mod consts;
-mod endorse;
 mod error;
 mod key;
 mod manifest;
@@ -59,10 +58,6 @@ mod verify;
 
 pub use algo::{KeyFormat, SigAlgo};
 pub use consts::*;
-pub use endorse::{
-    embed_endorsement, expected_leaf_key_data_hash, fingerprint_of, issue_endorsement,
-    EndorsementRequest, EndorsementResponse,
-};
 pub use error::{Error, Result};
 pub use key::{compute_fingerprint, KeyMetadata, KeyRecord};
 pub use manifest::{is_crypto_hash, Manifest, SignedEntry};
@@ -71,6 +66,6 @@ pub use sign::{
     ensure_key_partition, sign_partitions, signed_entry_from_partition, SigningMaterial,
 };
 pub use verify::{
-    key_endorsements, verify_all, verify_all_with_recheck, DataRecheck, EntryReport, EntryVerdict,
-    ManifestVerdict, SignatureReport, UnverifiableReason,
+    verify_all, verify_all_with_recheck, DataRecheck, EntryReport, EntryVerdict, ManifestVerdict,
+    SignatureReport, UnverifiableReason,
 };

reference/PCF-SIG-v1.0/src/lib.rs

@@ -98,63 +98,6 @@ pub enum DataRecheck {
     Recompute,
 }
 
-/// Find every signer whose Valid signature in `reports` countersigns the
-/// PCFSIG_KEY partition whose fingerprint is `leaf_key_fingerprint` (spec
-/// Section 12.2). Returns the deduplicated `signer_key_fingerprint`s of those
-/// signers, in first-seen order. Self-endorsement (a signer endorsing its own
-/// key) is filtered out as semantically vacuous.
-///
-/// The container is consulted to locate the leaf PCFSIG_KEY partition by
-/// fingerprint; if no such partition exists in the file the result is empty.
-///
-/// The reports passed in MUST come from [`verify_all`] or
-/// [`verify_all_with_recheck`] on the same container; the function does not
-/// re-verify any signatures.
-pub fn key_endorsements<S: Read + Write + Seek>(
-    container: &mut Container<S>,
-    reports: &[SignatureReport],
-    leaf_key_fingerprint: &[u8; FINGERPRINT_SIZE],
-) -> Result<Vec<[u8; FINGERPRINT_SIZE]>> {
-    // 1. Locate the leaf PCFSIG_KEY partition's PCF uid by fingerprint.
-    let entries = container.entries()?;
-    let mut leaf_key_uid: Option<[u8; UID_SIZE]> = None;
-    for e in &entries {
-        if e.partition_type == TYPE_PCFSIG_KEY {
-            let data = container.read_partition_data(e)?;
-            if let Ok(rec) = KeyRecord::from_bytes(&data) {
-                if &rec.fingerprint == leaf_key_fingerprint {
-                    leaf_key_uid = Some(e.uid);
-                    break;
-                }
-            }
-        }
-    }
-    let leaf_key_uid = match leaf_key_uid {
-        Some(u) => u,
-        None => return Ok(Vec::new()),
-    };
-
-    // 2. Scan reports for Valid signatures whose manifests cover that uid.
-    let mut endorsers: Vec<[u8; FINGERPRINT_SIZE]> = Vec::new();
-    for r in reports {
-        if !matches!(r.verdict, ManifestVerdict::Valid) {
-            continue;
-        }
-        if &r.signer_key_fingerprint == leaf_key_fingerprint {
-            // Self-endorsement is semantically empty.
-            continue;
-        }
-        let endorses = r
-            .entries
-            .iter()
-            .any(|er| er.uid == leaf_key_uid && matches!(er.verdict, EntryVerdict::Valid));
-        if endorses && !endorsers.contains(&r.signer_key_fingerprint) {
-            endorsers.push(r.signer_key_fingerprint);
-        }
-    }
-    Ok(endorsers)
-}
-
 /// Verify every PCFSIG_SIG partition in `container` and return one report
 /// each. Returns an empty vector if the container has no signatures.
 pub fn verify_all<S: Read + Write + Seek>(