push-seal: hand-seal examples, so tonight's milestone needs no new code

CKIOS proposes the right milestone for tonight: ONE notification, sealed by hand,
that opens on the phone. Not the feature. It exercises every unknown -- key
custody across two processes, seal/open agreement, the APNs environment (which is
currently operator testimony rather than a measurement), and the deep link --
while each piece is small enough that a failure has one candidate cause.

The room listed the sealer as STARTED and the corpus as NOT STARTED, and read
that as blocking. It is not: sealing one payload needs the crate, not the corpus.
The corpus proves CONFORMANCE between two implementations, which is a later
question than whether a blob opens.

So these three examples close that gap with no new library code:
  kp        generate an X25519 recipient keypair
  handseal  seal a payload to a public key, print hex, report the size delta
  handopen  open one, or print the refusal AND its wire code

MEASURED RATHER THAN ESTIMATED, on a realistic ask payload:
  111 bytes plaintext -> 160 bytes sealed. 49 bytes of overhead: 1 version + 32
  encapsulated key + 16 authentication tag.

That number retires a question I had left open in the spec deliberately -- I
refused to state a derived sealed-size figure before measuring one, because a
derived number stated early becomes normative by accident. Now it is measured:
the 2048-byte plaintext cap yields ~2097 sealed, comfortably inside APNs' 4KB
ceiling, so the cap needs no revision.

Round trip verified with its control: the correct key opens to the exact
plaintext; a wrong recipient refuses as Aead, wire code `malformed`, which is the
three-into-one collapse the spec requires rather than a leak about which part of
the envelope was wrong.

Examples rather than a binary or a script, so they live beside the crate they
exercise and cannot drift from it.

Author: ualtinok

crates/cortexkit-push-seal/examples/handopen.rs

@@ -0,0 +1,13 @@
+fn main() {
+    let a: Vec<String> = std::env::args().collect();
+    let hx = |s: &str| {
+        (0..s.len())
+            .step_by(2)
+            .map(|i| u8::from_str_radix(&s[i..i + 2], 16).unwrap())
+            .collect::<Vec<u8>>()
+    };
+    match cortexkit_push_seal::open(&hx(&a[1]), &hx(&a[2])) {
+        Ok(p) => println!("OPENED: {}", String::from_utf8_lossy(&p)),
+        Err(e) => println!("REFUSED: {:?} wire={}", e, e.wire_code()),
+    }
+}

crates/cortexkit-push-seal/examples/handseal.rs

@@ -0,0 +1,22 @@
+// Proves the crate can seal a real payload to a real recipient key TODAY.
+// Run: cargo run -p cortexkit-push-seal --example handseal -- <recipient_pk_hex> '<json>'
+fn main() {
+    let a: Vec<String> = std::env::args().collect();
+    let pk = (0..a[1].len())
+        .step_by(2)
+        .map(|i| u8::from_str_radix(&a[1][i..i + 2], 16).unwrap())
+        .collect::<Vec<u8>>();
+    let sealed = cortexkit_push_seal::seal(&pk, a[2].as_bytes()).expect("seal");
+    println!(
+        "{}",
+        sealed
+            .iter()
+            .map(|b| format!("{b:02x}"))
+            .collect::<String>()
+    );
+    eprintln!(
+        "plaintext {} bytes -> sealed {} bytes",
+        a[2].len(),
+        sealed.len()
+    );
+}

crates/cortexkit-push-seal/examples/kp.rs

@@ -0,0 +1,7 @@
+fn main() {
+    use hpke::{Kem, Serializable};
+    let (sk, pk) = hpke::kem::X25519HkdfSha256::gen_keypair();
+    let h = |b: &[u8]| b.iter().map(|x| format!("{x:02x}")).collect::<String>();
+    println!("SK {}", h(&sk.to_bytes()));
+    println!("PK {}", h(&pk.to_bytes()));
+}