Using OpenChainGraph with SLSA buildType

https://ainumbers.co/chaingraph/context/v0.2#WebCryptoSHA256

{
  "@context": "https://ainumbers.co/chaingraph/context/v0.3",
  "tool_id": "basel_rwa_calculator_v2",
  "mandate_type": "capital_requirement",
  "policy_parameters": {
    "exposure_class": "corporate",
    "risk_weight": 0.75,
    "ead": 1000000
  },
  "output_payload": {
    "rwa": 750000,
    "capital_charge": 60000
  },
  "execution_hash": "sha256:a4c2f8e1b7d93...",  // computed per buildType below
  "buildType": "https://ainumbers.co/chaingraph/context/v0.2#WebCryptoSHA256",  // ← THIS
  "chain": {
    "parent_hashes": [],
    "depth": 0,
    "chain_name": "q3_capital_review"
  },
  "audit_signature": { /* in-toto envelope — see Guide #3 */ }
}

// Input: a conformant OCG v0.3 artifact object
function ocgToSlsaProvenance(artifact) {
  const { tool_id, buildType, policy_parameters, output_payload,
          execution_hash, chain, timestamp } = artifact;

  return {
    "_type": "https://in-toto.io/Statement/v0.1",
    "predicateType": "https://slsa.dev/provenance/v1",

    // subject: the artifact being attested
    "subject": [{
      "name": tool_id,
      "digest": {
        "sha256": execution_hash.replace(/^sha256:/, '')
      }
    }],

    "predicate": {
      "buildDefinition": {
        "buildType": buildType || "https://ainumbers.co/chaingraph/context/v0.2#WebCryptoSHA256",
        "externalParameters": policy_parameters,   // the inputs
        "internalParameters": {}                      // no server-side state
      },
      "runDetails": {
        "builder": {
          "id": "https://ainumbers.co/tools/" + tool_id,
          "version": {}
        },
        "metadata": {
          "invocationId": execution_hash,             // hash is the stable run ID
          "startedOn":   timestamp || null,
          "finishedOn":  timestamp || null
        },
        "byProducts": [{                               // OCG-specific additions
          "name": "output_payload",
          "content": btoa(JSON.stringify(output_payload))
        }]
      }
    }
  };
}

// Usage
const provenance = ocgToSlsaProvenance(myArtifact);
console.log(JSON.stringify(provenance, null, 2));

# Write the provenance statement to a file
node -e "
  const art = require('./artifact.json');
  const prov = ocgToSlsaProvenance(art);
  require('fs').writeFileSync('provenance.json', JSON.stringify(prov));
"

# Sign and submit to Rekor via cosign
cosign attest \
  --predicate provenance.json \
  --type slsaprovenance1 \
  --key cosign.key \
  --rekor-url https://rekor.sigstore.dev \
  "${ARTIFACT_URI}"

# Verify: any party can check the Rekor entry
cosign verify-attestation \
  --type slsaprovenance1 \
  --certificate-identity-regexp ".*ainumbers.co.*" \
  "${ARTIFACT_URI}"

{
  "@context": "https://ainumbers.co/chaingraph/context/v0.3",
  "tool_id": "proprietary_scoring_v1",
  "buildType": "https://example-vendor.com/ocg-buildtype/v1#HMAC-SHA256",
  // The URI above must resolve to documentation describing:
  //   1. What fields are included in the preimage
  //   2. Key derivation procedure
  //   3. Serialization format
  //   4. Any canonical ordering rules
  "execution_hash": "sha256:b9f3a2c1..."
}

/**
 * Verify an OCG artifact's execution_hash against its declared buildType.
 * Works in any browser or Node.js 18+ environment.
 *
 * buildType: https://ainumbers.co/chaingraph/context/v0.2#WebCryptoSHA256
 *   Preimage: JSON.stringify({ policy_parameters, output_payload })
 *             with keys sorted recursively, no whitespace
 */
async function verifyOcgArtifact(artifact) {
  const { buildType, policy_parameters, output_payload, execution_hash } = artifact;

  // Enforce default buildType — reject unknown constructions
  if (buildType !== "https://ainumbers.co/chaingraph/context/v0.2#WebCryptoSHA256") {
    throw new Error(`Unknown buildType: ${buildType}. Cannot verify.`);
  }

  // 1. Build preimage: recursively sort all object keys
  function sortedStringify(obj) {
    if (obj === null || typeof obj !== 'object' || Array.isArray(obj)) {
      return JSON.stringify(obj);
    }
    const sorted = Object.fromEntries(
      Object.keys(obj).sort().map(k => [k, JSON.parse(sortedStringify(obj[k]))])
    );
    return JSON.stringify(sorted);
  }

  const preimage = sortedStringify({ policy_parameters, output_payload });

  // 2. Hash via WebCrypto SHA-256
  const encoded = new TextEncoder().encode(preimage);
  const hashBuf = await crypto.subtle.digest('SHA-256', encoded);
  const hashHex = Array.from(new Uint8Array(hashBuf))
    .map(b => b.toString(16).padStart(2, '0')).join('');

  // 3. Compare to stored hash
  const expected = "sha256:" + hashHex;
  const valid = expected === execution_hash;

  return {
    valid,
    expected,
    stored:   execution_hash,
    mismatch: valid ? null : { expected, stored: execution_hash }
  };
}

// Usage
const result = await verifyOcgArtifact(artifact);
if (!result.valid) {
  console.error('Hash mismatch — artifact may have been tampered with', result.mismatch);
} else {
  console.log('✓ Artifact integrity verified', result.stored);
}

import hashlib, json

def sorted_stringify(obj):
    if not isinstance(obj, dict):
        return json.dumps(obj, separators=(',', ':'))
    sorted_obj = {k: json.loads(sorted_stringify(obj[k])) for k in sorted(obj)}
    return json.dumps(sorted_obj, separators=(',', ':'))

def verify_ocg_artifact(artifact):
    preimage = sorted_stringify({
        "output_payload":   artifact["output_payload"],
        "policy_parameters": artifact["policy_parameters"]
    })
    digest = hashlib.sha256(preimage.encode()).hexdigest()
    expected = f"sha256:{digest}"
    stored   = artifact["execution_hash"]
    return {
        "valid":    expected == stored,
        "expected": expected,
        "stored":   stored
    }

result = verify_ocg_artifact(artifact)
print("✓ Valid" if result["valid"] else f"✗ Mismatch: {result}")

1. OCG tool runs in browser
   └─ emits artifact.json with execution_hash + buildType

2. Pipeline picks up artifact.json
   └─ calls ocgToSlsaProvenance(artifact) → provenance.json

3. cosign attest signs provenance.json with vendor Ed25519 key
   └─ produces DSSE-wrapped attestation

4. cosign pushes attestation to Rekor transparency log
   └─ Rekor returns a UUID entry

5. Auditor (regulator, counterparty) independently:
   a. Fetches artifact.json
   b. Re-runs verification (§6) → confirms execution_hash
   c. Looks up Rekor entry → confirms signed attestation
   d. Confirms buildType URI resolves to published spec
   ✓  Full chain of custody, no trusted third party required