runmat-execution-artifact 0.6.2

Canonical execution bundles and program artifacts for RunMat
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
107
108
109
110
111
112
113
114
115
116
117

use hpke::{
    aead::AesGcm128,
    kdf::HkdfSha256,
    kem::{Kem as _, X25519HkdfSha256},
    setup_receiver, setup_sender, Deserializable, OpModeR, OpModeS, Serializable,
};

use super::{
    EncryptedArtifact, EncryptionContext, ExecutionEncryptionProvider, ExecutionHpkeSuite,
    ExecutionRecipientKey,
};
use crate::{ArtifactError, ArtifactResult};

const INFO: &[u8] = b"runmat-execution-artifact-hpke-v1";

#[derive(Clone)]
pub struct NativeExecutionPrivateKey(<X25519HkdfSha256 as hpke::Kem>::PrivateKey);

#[derive(Clone, Copy, Debug, Default)]
pub struct NativeExecutionEncryption;

impl NativeExecutionEncryption {
    pub fn generate_recipient(
        &self,
        fingerprint: impl Into<String>,
        valid_after_unix_millis: u64,
        valid_before_unix_millis: u64,
    ) -> ArtifactResult<(ExecutionRecipientKey, NativeExecutionPrivateKey)> {
        let (private, public) = X25519HkdfSha256::gen_keypair();
        let recipient = ExecutionRecipientKey {
            suite: ExecutionHpkeSuite::X25519HkdfSha256Aes128GcmV1,
            public_key: public.to_bytes().to_vec(),
            fingerprint: fingerprint.into(),
            valid_after_unix_millis,
            valid_before_unix_millis,
            custodian_uri: None,
        };
        recipient.validate()?;
        Ok((recipient, NativeExecutionPrivateKey(private)))
    }
}

impl ExecutionEncryptionProvider for NativeExecutionEncryption {
    type PrivateKey = NativeExecutionPrivateKey;

    fn seal(
        &self,
        recipient: &ExecutionRecipientKey,
        context: EncryptionContext,
        plaintext: &[u8],
    ) -> ArtifactResult<EncryptedArtifact> {
        recipient.validate()?;
        context.validate()?;
        if context.total_length != plaintext.len() as u64
            || context.object_digest != runmat_execution::Digest::sha256(plaintext)
        {
            return Err(ArtifactError::Identity(
                "encryption context does not identify the plaintext".into(),
            ));
        }
        let public = <X25519HkdfSha256 as hpke::Kem>::PublicKey::from_bytes(&recipient.public_key)
            .map_err(encryption)?;
        let (encapsulated, mut sender) =
            setup_sender::<AesGcm128, HkdfSha256, X25519HkdfSha256>(&OpModeS::Base, &public, INFO)
                .map_err(encryption)?;
        let aad = context.aad()?;
        let ciphertext = sender.seal(plaintext, &aad).map_err(encryption)?;
        Ok(EncryptedArtifact {
            schema_version: 1,
            suite: recipient.suite,
            context,
            encapsulated_key: encapsulated.to_bytes().to_vec(),
            ciphertext,
        })
    }

    fn open(
        &self,
        private_key: &Self::PrivateKey,
        artifact: &EncryptedArtifact,
    ) -> ArtifactResult<Vec<u8>> {
        if artifact.schema_version != 1
            || artifact.suite != ExecutionHpkeSuite::X25519HkdfSha256Aes128GcmV1
        {
            return Err(ArtifactError::Invalid(
                "unsupported encrypted execution artifact".into(),
            ));
        }
        let encapsulated =
            <X25519HkdfSha256 as hpke::Kem>::EncappedKey::from_bytes(&artifact.encapsulated_key)
                .map_err(encryption)?;
        let mut receiver = setup_receiver::<AesGcm128, HkdfSha256, X25519HkdfSha256>(
            &OpModeR::Base,
            &private_key.0,
            &encapsulated,
            INFO,
        )
        .map_err(encryption)?;
        let aad = artifact.context.aad()?;
        let plaintext = receiver
            .open(&artifact.ciphertext, &aad)
            .map_err(encryption)?;
        artifact.context.validate()?;
        if artifact.context.total_length != plaintext.len() as u64
            || artifact.context.object_digest != runmat_execution::Digest::sha256(&plaintext)
        {
            return Err(ArtifactError::Identity(
                "decrypted artifact does not match its authenticated identity".into(),
            ));
        }
        Ok(plaintext)
    }
}

fn encryption(error: impl std::fmt::Display) -> ArtifactError {
    ArtifactError::Encryption(error.to_string())
}