Skip to main content

observe_process/
observe-process.rs

1// SPDX-License-Identifier: MIT OR Apache-2.0
2
3//! Emit a canonical JSON `native-process-observation:v0` payload for a target PID.
4
5use std::io::Write;
6use std::process::ExitCode;
7
8use sysprims_evidence::{admit_report_bytes, ProfileRef};
9use sysprims_proc::observation::{observe_process, HostScope, ObservationOptions};
10
11const DEFAULT_DERIVATION_REV: &str =
12    "sha256:0000000000000000000000000000000000000000000000000000000000000000";
13
14fn main() -> ExitCode {
15    let mut args = std::env::args().skip(1);
16    let mut pid: Option<u32> = None;
17    let mut observed_at: Option<String> = None;
18    let mut subject_ref = String::from("process-target");
19    let mut all_context = false;
20    let mut host_id_ref = Some(String::from("id-host-local"));
21    let mut host_ns = String::from("urn:3leaps:identity-evidence:host-scope:test-fixture:v0");
22    let mut host_val = String::from("local-qualification-host");
23    let mut host_deriv_id =
24        String::from("urn:3leaps:identity-evidence:derivation:caller-supplied-host-scope:v0");
25    let mut host_deriv_rev = String::from(DEFAULT_DERIVATION_REV);
26    let mut host_stability = String::from("boot");
27    let mut host_clone = String::from("regenerated");
28
29    while let Some(arg) = args.next() {
30        match arg.as_str() {
31            "--pid" => {
32                let Some(raw) = args.next() else {
33                    eprintln!("error: --pid requires a numeric value");
34                    return ExitCode::from(2);
35                };
36                match raw.parse::<u32>() {
37                    Ok(v) => pid = Some(v),
38                    Err(_) => {
39                        eprintln!("error: invalid --pid value: {raw}");
40                        return ExitCode::from(2);
41                    }
42                }
43            }
44            "--observed-at" => {
45                let Some(v) = args.next() else {
46                    eprintln!("error: --observed-at requires a value");
47                    return ExitCode::from(2);
48                };
49                observed_at = Some(v);
50            }
51            "--subject-ref" => {
52                let Some(v) = args.next() else {
53                    eprintln!("error: --subject-ref requires a value");
54                    return ExitCode::from(2);
55                };
56                subject_ref = v;
57            }
58            "--all-context" => {
59                all_context = true;
60            }
61            "--no-host-id-ref" => {
62                host_id_ref = None;
63            }
64            "--host-id-ref" => {
65                let Some(v) = args.next() else {
66                    eprintln!("error: --host-id-ref requires a value");
67                    return ExitCode::from(2);
68                };
69                host_id_ref = Some(v);
70            }
71            "--host-namespace" => {
72                let Some(v) = args.next() else {
73                    eprintln!("error: --host-namespace requires a value");
74                    return ExitCode::from(2);
75                };
76                host_ns = v;
77            }
78            "--host-value" => {
79                let Some(v) = args.next() else {
80                    eprintln!("error: --host-value requires a value");
81                    return ExitCode::from(2);
82                };
83                host_val = v;
84            }
85            "--host-derivation-id" => {
86                let Some(v) = args.next() else {
87                    eprintln!("error: --host-derivation-id requires a value");
88                    return ExitCode::from(2);
89                };
90                host_deriv_id = v;
91            }
92            "--host-derivation-rev" => {
93                let Some(v) = args.next() else {
94                    eprintln!("error: --host-derivation-rev requires a value");
95                    return ExitCode::from(2);
96                };
97                host_deriv_rev = v;
98            }
99            "--host-stability" => {
100                let Some(v) = args.next() else {
101                    eprintln!("error: --host-stability requires a value");
102                    return ExitCode::from(2);
103                };
104                host_stability = v;
105            }
106            "--host-clone-behavior" => {
107                let Some(v) = args.next() else {
108                    eprintln!("error: --host-clone-behavior requires a value");
109                    return ExitCode::from(2);
110                };
111                host_clone = v;
112            }
113            other => {
114                eprintln!("error: unrecognized flag {other}");
115                return ExitCode::from(2);
116            }
117        }
118    }
119
120    let Some(target_pid) = pid else {
121        eprintln!("error: --pid <1..=2147483647> is required");
122        return ExitCode::from(2);
123    };
124
125    let host_scope = HostScope {
126        identifier_ref: host_id_ref,
127        namespace: host_ns,
128        value: host_val,
129        derivation: ProfileRef::new(host_deriv_id, host_deriv_rev),
130        stability: host_stability,
131        clone_behavior: host_clone,
132    };
133
134    let mut options = ObservationOptions {
135        subject_ref,
136        observed_at,
137        ..ObservationOptions::default()
138    };
139    if all_context {
140        options = options.with_all_context_facts();
141    }
142
143    let obs = match observe_process(target_pid, &host_scope, &options) {
144        Ok(v) => v,
145        Err(refusal) => {
146            eprintln!("refused:{refusal}");
147            return ExitCode::from(1);
148        }
149    };
150
151    let raw = match serde_json::to_vec(&obs) {
152        Ok(b) => b,
153        Err(e) => {
154            eprintln!("serialization-error:{e}");
155            return ExitCode::from(1);
156        }
157    };
158    let admitted = match admit_report_bytes(&raw) {
159        Ok(a) => a,
160        Err(e) => {
161            eprintln!("canonicalization-error:{e}");
162            return ExitCode::from(1);
163        }
164    };
165
166    let mut out = std::io::stdout().lock();
167    if out.write_all(&admitted.canonical_bytes).is_err() || out.write_all(b"\n").is_err() {
168        return ExitCode::from(1);
169    }
170    ExitCode::SUCCESS
171}