Self-Custody Signing

from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives import serialization

# Generate P-256 keypair
private_key = ec.generate_private_key(ec.SECP256R1())

# Save private key
with open("private_key.pem", "wb") as f:
    f.write(private_key.private_bytes(
        encoding=serialization.Encoding.PEM,
        format=serialization.PrivateFormat.PKCS8,
        encryption_algorithm=serialization.NoEncryption(),
    ))

# Save public key
public_key = private_key.public_key()
with open("public_key.pem", "wb") as f:
    f.write(public_key.public_bytes(
        encoding=serialization.Encoding.PEM,
        format=serialization.PublicFormat.SubjectPublicKeyInfo,
    ))

print("Keypair generated: private_key.pem, public_key.pem")

import { generateKeyPairSync } from "node:crypto";
import { writeFileSync } from "node:fs";

// Generate P-256 keypair
const { publicKey, privateKey } = generateKeyPairSync("ec", {
  namedCurve: "P-256",
  publicKeyEncoding: {
    type: "spki",
    format: "pem",
  },
  privateKeyEncoding: {
    type: "pkcs8",
    format: "pem",
  },
});

writeFileSync("private_key.pem", privateKey, { mode: 0o600 });
writeFileSync("public_key.pem", publicKey, { mode: 0o644 });

console.log("Keypair generated: private_key.pem, public_key.pem");

import json
import base64
from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives import hashes, serialization

# Build payload
payload = {
    "account_id": "alice@example.com",
    "amount": "100.00",
    "type": "debit",
    "idempotency_key": "txn-20260403-001",
}

# Canonicalize
canonical = json.dumps(payload, sort_keys=True, separators=(",", ":"))

# Load private key
with open("private_key.pem", "rb") as f:
    private_key = serialization.load_pem_private_key(f.read(), password=None)

# Sign (ECDSA with SHA-256)
signature_bytes = private_key.sign(
    canonical.encode(),
    ec.ECDSA(hashes.SHA256()),
)

# Base64url encode
signature = base64.urlsafe_b64encode(signature_bytes).decode().rstrip("=")
print("Signature:", signature)

import { createSign, createPrivateKey } from "node:crypto";
import { readFileSync } from "node:fs";

// Build payload
const payload = {
  account_id: "alice@example.com",
  amount: "100.00",
  idempotency_key: "txn-20260403-001",
  type: "debit",
};

// Canonicalize (keys sorted alphabetically)
const canonical = JSON.stringify(payload, Object.keys(payload).sort());

// Load private key
const privateKey = createPrivateKey(readFileSync("private_key.pem"));

// Sign (ECDSA with SHA-256)
const signer = createSign("SHA256");
signer.update(canonical);
const signatureDer = signer.sign(privateKey);

// Base64url encode
const signature = signatureDer
  .toString("base64url");

console.log("Signature:", signature);

import json
import base64
from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives import hashes, serialization

# Receipt payload fields (from the finalized transaction response)
receipt = {
    "group_id": "grp_01HYX3MQNW8RDAZ5T7F4HS6K3D",
    "account_id": "alice@example.com",
    "amount": "100.00",
    "type": "debit",
    "audit_hash": "sha256:a3f8c2d1e9b04567...",
    "shard_id": "shard-07",
    "timestamp": "2026-04-03T14:22:02.112Z",
}

# Canonicalize
canonical = json.dumps(receipt, sort_keys=True, separators=(",", ":"))

# Load engine's public key
with open("engine_public_key.pem", "rb") as f:
    public_key = serialization.load_pem_public_key(f.read())

# Decode receipt signature
sig_b64 = "MEYCIQDy...base64url-encoded..."
sig_bytes = base64.urlsafe_b64decode(sig_b64 + "==")

# Verify
try:
    public_key.verify(sig_bytes, canonical.encode(), ec.ECDSA(hashes.SHA256()))
    print("Receipt signature valid: True")
except Exception:
    print("Receipt signature valid: False")

import { createVerify, createPublicKey } from "node:crypto";
import { readFileSync } from "node:fs";

// Receipt payload fields (from the finalized transaction response)
const receipt = {
  account_id: "alice@example.com",
  amount: "100.00",
  audit_hash: "sha256:a3f8c2d1e9b04567...",
  group_id: "grp_01HYX3MQNW8RDAZ5T7F4HS6K3D",
  shard_id: "shard-07",
  timestamp: "2026-04-03T14:22:02.112Z",
  type: "debit",
};

// Canonicalize (keys sorted alphabetically)
const canonical = JSON.stringify(receipt, Object.keys(receipt).sort());

// Load engine's public key
const publicKey = createPublicKey(readFileSync("engine_public_key.pem"));

// Decode receipt signature
const sigB64 = "MEYCIQDy...base64url-encoded...";
const sigBuffer = Buffer.from(sigB64, "base64url");

// Verify
const verifier = createVerify("SHA256");
verifier.update(canonical);
const valid = verifier.verify(publicKey, sigBuffer);

console.log("Receipt signature valid:", valid);