Function verify

atomic-canonical/src/delegation.rs:146–191

Verify a certificate against the delegator's public key and return the typed view. Checks, in order: 1. the document is an `AgentDelegation`; 2. content hash recomputes, the proof verifies, and its `verificationMethod` belongs to `delegator_public_key` ([`proof::verify_value`]); 3. the `delegator` DID is that same key — otherwise a certificate signed by one key could name another as the delegato

(document: &Value, delegator_public_key: &PublicKey)

/// 5. `@id` recomputes from the body, so the identifier cannot be swapped for
///    one belonging to a different (perhaps revoked) certificate.
pub fn verify(document: &Value, delegator_public_key: &PublicKey) -> Result<Delegation> {
    expect_type(document, TYPE_DELEGATION)?;
    proof::verify_value(document, delegator_public_key)?;

    let parsed = parse(document)?;

    // 3. The signer must be the delegator the document names.
    let delegator_id = IdentityId::from_did(&parsed.delegator)
        .map_err(|e| CanonicalError::Verification(format!("delegator DID is malformed: {e}")))?;
    if !delegator_id.matches_public_key(delegator_public_key) {
        return Err(CanonicalError::Verification(
            "delegator DID does not match the verifying key".into(),
        ));
    }

    // 3b. The delegator's own two renderings must agree too, so a
    //     self-contained verifier that starts from `delegatorKey` reaches the
    //     same conclusion as one that starts from a key it already trusts.
    let stated_delegator_key = self::delegator_public_key(&parsed)?;
    if &stated_delegator_key != delegator_public_key {
        return Err(CanonicalError::Verification(
            "delegatorKey does not match the verifying key".into(),
        ));
    }

    // 4. The two renderings of the delegate's key must agree. Without this a
    //    certificate could name agent A in `delegate` while handing out agent
    //    B's key in `delegateKey`.
    let delegate_key = delegate_public_key(&parsed)?;
    let delegate_id = IdentityId::from_did(&parsed.delegate)
        .map_err(|e| CanonicalError::Verification(format!("delegate DID is malformed: {e}")))?;
    if !delegate_id.matches_public_key(&delegate_key) {
        return Err(CanonicalError::Verification(
            "delegateKey does not match the delegate DID".into(),
        ));
    }

    // 5. The id is a claim like any other; recompute it.
    if !parsed.id_matches(&delegator_id, &delegate_id) {
        return Err(CanonicalError::Verification(
            "delegation @id does not match its delegator, delegate and issue time".into(),
        ));
    }

    Ok(parsed)
}

/// Parse a certificate into its typed view **without** verifying the proof.
///