heddle-crypto 0.25.6

An AI-native version control system
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

//! Executor-signed testimony with one fixed canonical format, without API or
//! storage dependencies. Neither a signature nor its carried key creates trust.
use heddle_object_model::object::{
    thread_authority_admission::{FORMAT, ThreadAuthorityAdmission},
    thread_replication::integration::TrustedHostedExecutor,
};
use serde::{Deserialize, Serialize};

use crate::{
    Ed25519Signer, Signer,
    thread_operation::{Error, SignedOperation},
};

#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
pub struct SignedAuthorityAdmission {
    pub canonical: Vec<u8>,
    pub signature: Vec<u8>,
    pub boundary_acceptance:
        Option<std::sync::Arc<crate::original_boundary_acceptance::SignedBoundaryAcceptance>>,
}
impl SignedAuthorityAdmission {
    pub fn sign(value: &ThreadAuthorityAdmission, signer: &impl Signer) -> Result<Self, Error> {
        if signer.public_key() != value.executor {
            return Err(Error::Publisher);
        }
        let canonical = value.encode()?;
        let signature = signer.sign(&signing_bytes(&canonical))?;
        Ok(Self {
            canonical,
            signature,
            boundary_acceptance: None,
        })
    }
    /// Signature-only verification does not establish independent executor trust.
    pub fn verify_signature(&self) -> Result<ThreadAuthorityAdmission, Error> {
        let value = ThreadAuthorityAdmission::decode(&self.canonical)?;
        Ed25519Signer::verify_with_public_key(
            &signing_bytes(&self.canonical),
            &value.executor,
            &self.signature,
        )?;
        Ok(value)
    }
    pub fn verify(
        &self,
        original: &SignedOperation,
        trust: &TrustedHostedExecutor,
    ) -> Result<ThreadAuthorityAdmission, Error> {
        let value = self.verify_signature()?;
        let evidence = self
            .boundary_acceptance
            .as_ref()
            .map(|value| value.verify_signature())
            .transpose()?;
        value.authorize_with_acceptance(&original.verify()?, trust, evidence.as_ref())?;
        Ok(value)
    }
    pub fn verify_claim(
        &self,
        original: &crate::thread_ownership_claim::SignedOwnershipClaim,
        genesis: &heddle_object_model::object::thread_replication::ThreadGenesis,
        trust: &TrustedHostedExecutor,
    ) -> Result<ThreadAuthorityAdmission, Error> {
        let value = self.verify_signature()?;
        let evidence = self
            .boundary_acceptance
            .as_ref()
            .map(|value| value.verify_signature())
            .transpose()?;
        value.authorize_claim_with_acceptance(
            &original.verify()?,
            genesis,
            trust,
            evidence.as_ref(),
        )?;
        Ok(value)
    }
    pub fn verify_resolution(
        &self,
        original: &crate::thread_ownership_resolution::SignedOwnershipResolution,
        winning_claim: &heddle_object_model::object::thread_replication::ownership_claim::ThreadOwnershipClaim,
        genesis: &heddle_object_model::object::thread_replication::ThreadGenesis,
        trust: &TrustedHostedExecutor,
    ) -> Result<ThreadAuthorityAdmission, Error> {
        let value = self.verify_signature()?;
        let evidence = self
            .boundary_acceptance
            .as_ref()
            .map(|value| value.verify_signature())
            .transpose()?;
        value.authorize_resolution_with_acceptance(
            &original.verify(winning_claim)?,
            genesis,
            trust,
            evidence.as_ref(),
        )?;
        Ok(value)
    }
}
fn signing_bytes(canonical: &[u8]) -> Vec<u8> {
    let mut bytes = Vec::with_capacity(FORMAT.len() + 1 + canonical.len());
    bytes.extend_from_slice(FORMAT.as_bytes());
    bytes.push(0);
    bytes.extend_from_slice(canonical);
    bytes
}