Runners sign their receipts 47c1d64dec8a

    /// The receipt bound to the job's state and signed by the runner

    /// (Oxygen spec §14.6), hex of the signed receipt's bytes.

    #[serde(default, skip_serializing_if = "Option::is_none")]

    pub signed_receipt: Option<String>,

    /// The same receipt as an Oxygen object (Oxygen spec §14.6), which a

    /// runner signs and a repository keeps.

    pub fn to_oxy(&self) -> oxy_core::receipt::Receipt {

        use oxy_core::hash::ObjectRef;

        oxy_core::receipt::Receipt {

            job_name: self.job_name.clone(),

            pipeline_hash: ObjectRef(self.pipeline_hash),

            scope_tree_hash: ObjectRef(self.scope_tree_hash),

            inputs: self.inputs.iter().map(|h| ObjectRef(*h)).collect(),

            environment: ObjectRef(self.environment),

            outputs: self.outputs.iter().map(|h| ObjectRef(*h)).collect(),

            exit_code: self.exit_code,

            duration_ms: self.duration_ms,

        }

    }

    // The same receipt as the Oxygen object a runner signs.

    assert_eq!(r.to_oxy().hash().0, r.hash());

    assert_eq!(r.to_oxy().encode(), body);

//!

//! A runner signs its receipts with a composite key kept beside `flow.toml`

//! (`runner.key`, `runner.identity`), made on first start.

}

/// The key a runner signs receipts with (Oxygen spec §14.6).

pub struct RunnerKey {

    pub identity: oxy_core::identity::Identity,

    pub secret: oxy_core::identity::SecretKey,

}

impl Home {

    /// The runner's key, made on first use as `runner.key` (owner-only)

    /// and `runner.identity`, named `name`.

    pub fn runner_key(&self, name: &str) -> Result<RunnerKey> {

        use oxy_core::identity::{Identity, SecretKey};

        let key_path = self.root.join("runner.key");

        let id_path = self.root.join("runner.identity");

        if key_path.exists() {

            let (key, secret) = SecretKey::decode(&std::fs::read(&key_path)?).context("runner.key")?;

            let identity = Identity::decode(&std::fs::read(&id_path)?).context("runner.identity")?;

            if identity.hash() != key {

                bail!("runner.identity does not belong to runner.key");

            }

            return Ok(RunnerKey { identity, secret });

        }

        let secret = SecretKey::generate();

        let now = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(|d| d.as_millis() as u64).unwrap_or(0);

        let identity = secret.identity(&format!("{name} (OxygenFlow runner)"), "", now);

        std::fs::write(&id_path, identity.encode())?;

        let tmp = self.root.join("runner.key.tmp");

        {

            use std::io::Write;

            use std::os::unix::fs::OpenOptionsExt;

            let mut f = std::fs::OpenOptions::new().write(true).create(true).truncate(true).mode(0o600).open(&tmp)?;

            f.write_all(&secret.encode(&identity.hash()))?;

            f.sync_all()?;

        }

        std::fs::rename(&tmp, &key_path)?;

        Ok(RunnerKey { identity, secret })

    }

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn the_runner_key_is_made_once_and_kept_private() {

        use std::os::unix::fs::PermissionsExt;

        let dir = tempfile::tempdir().unwrap();

        let home = Home::locate(Some(dir.path())).unwrap();

        let a = home.runner_key("earth-1").unwrap();

        assert_eq!(a.identity.name, "earth-1 (OxygenFlow runner)");

        let mode = std::fs::metadata(dir.path().join("runner.key")).unwrap().permissions().mode();

        assert_eq!(mode & 0o777, 0o600);

        let b = home.runner_key("renamed").unwrap();

        assert_eq!(a.identity, b.identity, "the same key after a restart");

        let sig = b.secret.sign(oxy_core::identity::Domain::Attest, &b.identity.hash(), &oxy_core::hash::ObjectRef([1; 32]));

        oxy_core::identity::verify(&a.identity, &sig, oxy_core::identity::Domain::Attest, &oxy_core::hash::ObjectRef([1; 32])).unwrap();

    }

use crate::home::{Home, RunnerConfig, RunnerKey};

    let key = home.runner_key(&name)?;

    eprintln!(

        "flow runner {name}: polling {} (up to {} jobs at once), signing receipts as {}",

        cfg.hub,

        budget.max_jobs,

        key.identity.hash().to_hex()

    );

                let (home, hub, cfg, used, key) = (home, &hub, &cfg, &used, &key);

                    let finish = run_claim(home, hub, cfg, key, &claim).unwrap_or_else(|e| Finish {

                        signed_receipt: None,

fn run_claim(home: &Home, hub: &Hub, cfg: &RunnerConfig, key: &RunnerKey, claim: &Claim) -> Result<Finish> {

        let signed_receipt = match &receipt {

            Some(r) => Some(hex::encode(sign_receipt(&repo, &heads, cfg, key, claim, r)?.encode())),

            None => None,

        };

            signed_receipt,

}

/// Bind `receipt` to the state of `heads` in `repo` and sign it as the

/// runner (Oxygen spec §14.6). The state is computed here, not taken from

/// the claim, so the runner vouches only for what it fetched.

fn sign_receipt(

    repo: &Repo,

    heads: &[ChangeHash],

    cfg: &RunnerConfig,

    key: &RunnerKey,

    claim: &Claim,

    receipt: &Receipt,

) -> Result<oxy_core::receipt::SignedReceipt> {

    let state = state_of(heads);

    let run = format!("{}/{}/flow/{}", cfg.hub.trim_end_matches('/'), claim.repo, claim.run_number);

    Ok(oxy_core::receipt::SignedReceipt::sign(receipt.to_oxy(), repo.id()?, state, &run, &key.identity, &key.secret))

}

/// The ObjectRef of the state whose heads are `heads` (Oxygen spec §10.1).

pub fn state_of(heads: &[ChangeHash]) -> oxy_core::hash::ObjectRef {

    use oxy_core::hash::{hash_object, ObjectType};

    hash_object(ObjectType::State, &oxy_core::objects::StateObject::new(heads.to_vec()).encode())

hashed as `BLAKE3("oxy1 receipt " || len || 0x00 || body)`, the `receipt`

object of the Oxygen spec (§14.6).

**Signed receipts.** A runner keeps a composite key in its home

(`runner.key`, owner-only, and `runner.identity`), made on first start and

named after the runner. After each job it binds the receipt to the state of

the heads it fetched (computed by the runner, not taken from the claim) and

to the run's URL, signs that attestation, and sends the signed receipt with

`finish` as `signed_receipt` (hex). The hub checks it and keeps it in the

repository; anyone can then check it with `oxy receipt verify`. Cache reuse

(§6.2) follows.