Function verify_value

atomic-canonical/src/proof.rs:157–209

Generic verify over a JSON-LD value — the same three checks as the typed path: (1) the content hash recomputes over `hashing_view`, (2) the signature verifies over `jcs(signing_view)`, (3) the proof's verificationMethod DID belongs to this key.

(value: &Value, public_key: &PublicKey)

/// verifies over `jcs(signing_view)`, (3) the proof's verificationMethod DID
/// belongs to this key.
pub fn verify_value(value: &Value, public_key: &PublicKey) -> Result<()> {
    let obj = value
        .as_object()
        .ok_or_else(|| CanonicalError::Proof("value is not a JSON object".into()))?;

    // 1. Content hash integrity.
    let expected = obj
        .get(PROP_CONTENT_HASH)
        .and_then(Value::as_str)
        .ok_or_else(|| CanonicalError::Proof("node carries no contentHash".into()))?;
    let actual = hash::content_hash(&hashing_view(value));
    if expected != actual {
        return Err(CanonicalError::HashMismatch {
            expected: expected.to_string(),
            actual,
        });
    }

    // 2. Signature over the canonical signing bytes.
    let proof: Proof = obj
        .get(PROP_PROOF)
        .cloned()
        .and_then(|p| serde_json::from_value(p).ok())
        .ok_or_else(|| CanonicalError::Proof("node carries no proof".into()))?;

    // The proof's own metadata is stripped by `signing_view`, so it is not
    // covered by the signature. Enforce the suite/purpose/type we expect here,
    // otherwise a stored node's declared cryptosuite is silently mutable.
    if proof.type_ != PROOF_TYPE
        || proof.cryptosuite != CRYPTOSUITE
        || proof.proof_purpose != PROOF_PURPOSE
    {
        return Err(CanonicalError::Verification(format!(
            "unexpected proof metadata: type='{}' cryptosuite='{}' proofPurpose='{}'",
            proof.type_, proof.cryptosuite, proof.proof_purpose
        )));
    }

    let signature = decode_proof_value(&proof.proof_value)?;
    let signing_bytes = jcs::canonicalize(&signing_view(value)).into_bytes();
    signature
        .verify(&signing_bytes, public_key)
        .map_err(|e| CanonicalError::Verification(e.to_string()))?;

    // 3. The proof's verificationMethod DID must belong to this key.
    let did = did::did_from_verification_method(&proof.verification_method);
    if !did::did_matches_public_key(did, public_key) {
        return Err(CanonicalError::Verification(
            "verificationMethod DID does not match the public key".into(),
        ));
    }
    Ok(())
}

/// Produce a fully attested Intent node — a thin wrapper over
/// [`attest_value`] so hash and signature can never drift from any other node