use engine::{ActorId, Engine, EventType, ObjectEvent, SubscriptionId, Timestamp, VirtualPath};
use os::linux::Linux;
use os::macos::MacOS;
use os::unix::user::UserId;
use os::windows::Windows;
use os::{FileMode, HostIdentity, OperatingSystem, OsError, UnixFlavor};
use crate::{CommandOutput, Session, SessionError, ShellChoice};
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[non_exhaustive]
pub enum Capability {
Identity,
Services,
FirewallRules,
FileMetadata,
CheckedCommandExecution,
SessionCancellation,
Processes,
Packages,
PackageUpdates,
StartupEntries,
ScheduledTasks,
AuthenticationPolicy,
Audit,
FileAcls,
Registry,
Preferences,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Account {
pub name: String,
pub id: u32,
pub primary_group_id: u32,
pub full_name: String,
pub home: String,
pub shell: String,
pub password_locked: bool,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Group {
pub name: String,
pub id: u32,
pub members: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Service {
pub name: String,
pub description: String,
pub state: String,
pub start_type: String,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct FirewallRule {
pub port: u16,
pub protocol: String,
pub action: String,
pub direction: String,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct FileMetadata {
pub owner: String,
pub group: String,
pub mode: FileMode,
pub size: u64,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Process {
pub pid: u32,
pub user: String,
pub executable: String,
pub arguments: String,
pub state: String,
pub cwd: String,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct PasswordPolicy {
pub min_length: u32,
pub max_age_days: u32,
pub min_age_days: u32,
pub history: u32,
pub complexity: bool,
pub reversible_encryption: bool,
pub lockout_threshold: u32,
pub lockout_duration: u32,
pub lockout_window: u32,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct AuditCategory {
pub name: String,
pub success: bool,
pub failure: bool,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct RegistryValue {
pub name: String,
pub value_type: String,
pub data: String,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum PreferenceValue {
String(String),
Integer(i64),
Boolean(bool),
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum OsKind {
Linux,
MacOS,
Windows,
}
#[derive(Clone, Debug)]
pub struct MachineBuilder {
kind: OsKind,
username: String,
hostname: String,
boot_time: Timestamp,
}
impl MachineBuilder {
pub fn new(kind: OsKind) -> Self {
Self {
kind,
username: "demo".to_owned(),
hostname: "vce".to_owned(),
boot_time: Timestamp::ZERO,
}
}
pub fn username(mut self, username: impl Into<String>) -> Self {
self.username = username.into();
self
}
pub fn hostname(mut self, hostname: impl Into<String>) -> Self {
self.hostname = hostname.into();
self
}
pub const fn boot_time(mut self, boot_time: Timestamp) -> Self {
self.boot_time = boot_time;
self
}
pub fn build(self) -> Result<Machine, MachineError> {
let identity = HostIdentity::new(self.username.clone(), self.hostname);
if identity.is_reserved_username() {
return Err(MachineError::InvalidConfiguration(format!(
"'{}' is a reserved system account name",
identity.username()
)));
}
let default_user = identity.username().to_owned();
let inner = match self.kind {
OsKind::Linux => MachineInner::Linux(
Linux::with_identity(&identity, self.boot_time)
.map_err(|error| identity_boot_error(&identity, error))?,
),
OsKind::MacOS => MachineInner::MacOS(
MacOS::with_identity(&identity, self.boot_time)
.map_err(|error| identity_boot_error(&identity, error))?,
),
OsKind::Windows => MachineInner::Windows(
Windows::with_identity(&identity, self.boot_time)
.map_err(|error| identity_boot_error(&identity, error))?,
),
};
Ok(Machine {
inner,
default_user,
hostname: identity.hostname().to_owned(),
})
}
}
fn identity_boot_error(identity: &HostIdentity, error: OsError) -> MachineError {
match &error {
OsError::UserAlreadyExists(value) | OsError::GroupAlreadyExists(value)
if value == identity.username() =>
{
MachineError::InvalidConfiguration(format!(
"'{}' conflicts with a built-in account or group",
identity.username()
))
}
_ => error.into(),
}
}
enum MachineInner {
Linux(Linux),
MacOS(MacOS),
Windows(Windows),
}
pub struct Machine {
inner: MachineInner,
default_user: String,
hostname: String,
}
impl Machine {
pub fn builder(kind: OsKind) -> MachineBuilder {
MachineBuilder::new(kind)
}
pub const fn os_kind(&self) -> OsKind {
match self.inner {
MachineInner::Linux(_) => OsKind::Linux,
MachineInner::MacOS(_) => OsKind::MacOS,
MachineInner::Windows(_) => OsKind::Windows,
}
}
pub fn capabilities(&self) -> Vec<Capability> {
let mut capabilities = vec![
Capability::CheckedCommandExecution,
Capability::FileMetadata,
Capability::SessionCancellation,
];
match self.os_kind() {
OsKind::Linux => capabilities.extend([
Capability::Identity,
Capability::Services,
Capability::FirewallRules,
Capability::Processes,
]),
OsKind::MacOS => capabilities.extend([
Capability::Identity,
Capability::Processes,
Capability::Preferences,
]),
OsKind::Windows => capabilities.retain(|capability| {
matches!(
capability,
Capability::CheckedCommandExecution | Capability::SessionCancellation
)
}),
}
if self.os_kind() == OsKind::Windows {
capabilities.extend([
Capability::Processes,
Capability::AuthenticationPolicy,
Capability::Audit,
Capability::Registry,
]);
}
capabilities.sort_unstable();
capabilities
}
pub fn supports(&self, capability: Capability) -> bool {
self.capabilities().contains(&capability)
}
pub fn require(&self, capability: Capability) -> Result<(), MachineError> {
if self.supports(capability) {
Ok(())
} else {
Err(MachineError::UnsupportedCapability {
capability,
os: self.os_kind(),
})
}
}
pub fn accounts(&self) -> Result<Vec<Account>, MachineError> {
let unix = match &self.inner {
MachineInner::Linux(os) => os.unix(),
MachineInner::MacOS(os) => os.unix(),
MachineInner::Windows(_) => {
return Err(MachineError::UnsupportedCapability {
capability: Capability::Identity,
os: self.os_kind(),
});
}
};
Ok(unix
.users()
.users()
.into_iter()
.map(|user| Account {
name: user.name().to_owned(),
id: user.uid().get(),
primary_group_id: user.primary_group().get(),
full_name: user.gecos().to_owned(),
home: user.home().to_owned(),
shell: user.shell().to_owned(),
password_locked: matches!(
user.password(),
os::unix::password::PasswordState::Locked
),
})
.collect())
}
pub fn groups(&self) -> Result<Vec<Group>, MachineError> {
let unix = match &self.inner {
MachineInner::Linux(os) => os.unix(),
MachineInner::MacOS(os) => os.unix(),
MachineInner::Windows(_) => {
return Err(MachineError::UnsupportedCapability {
capability: Capability::Identity,
os: self.os_kind(),
});
}
};
Ok(unix
.groups()
.groups()
.into_iter()
.map(|group| Group {
name: group.name().to_owned(),
id: group.gid().get(),
members: group
.members()
.iter()
.filter_map(|uid| unix.users().get(*uid))
.map(|user| user.name().to_owned())
.collect(),
})
.collect())
}
pub fn services(&self) -> Result<Vec<Service>, MachineError> {
let MachineInner::Linux(os) = &self.inner else {
return Err(MachineError::UnsupportedCapability {
capability: Capability::Services,
os: self.os_kind(),
});
};
let actor = Some(self.admin_actor()?);
let state = os.unix().service_state()?;
state
.unit_names(actor)?
.into_iter()
.map(|name| {
Ok(Service {
description: state.description(actor, &name),
state: state.state(actor, &name),
start_type: state.start_type(actor, &name),
name,
})
})
.collect()
}
pub fn firewall_rules(&self) -> Result<Vec<FirewallRule>, MachineError> {
let MachineInner::Linux(os) = &self.inner else {
return Err(MachineError::UnsupportedCapability {
capability: Capability::FirewallRules,
os: self.os_kind(),
});
};
Ok(os
.unix()
.firewall()?
.rules(Some(self.admin_actor()?))?
.into_iter()
.map(|rule| FirewallRule {
port: rule.port,
protocol: rule.protocol,
action: rule.action,
direction: if rule.direction.is_empty() {
"in".to_owned()
} else {
rule.direction
},
})
.collect())
}
pub fn file_metadata(&self, path: &str) -> Result<FileMetadata, MachineError> {
let unix = match &self.inner {
MachineInner::Linux(os) => os.unix(),
MachineInner::MacOS(os) => os.unix(),
MachineInner::Windows(_) => {
return Err(MachineError::UnsupportedCapability {
capability: Capability::FileMetadata,
os: self.os_kind(),
});
}
};
let path: VirtualPath = path.parse()?;
let actor = Some(self.admin_actor()?);
let object = self.engine().lookup(actor, &path)?;
let metadata = self.engine().metadata(actor, object)?;
let attrs = unix.attrs(object)?;
let owner = metadata
.owner()
.and_then(os::unix::user::UserId::from_actor)
.and_then(|uid| unix.users().get(uid))
.map_or_else(|| "UNKNOWN".to_owned(), |user| user.name().to_owned());
let group = unix
.groups()
.get(attrs.gid)
.map_or_else(|| "UNKNOWN".to_owned(), |group| group.name().to_owned());
Ok(FileMetadata {
owner,
group,
mode: attrs.mode,
size: self.engine().size(actor, object)?,
})
}
pub fn processes(&self) -> Result<Vec<Process>, MachineError> {
let actor = Some(self.admin_actor()?);
let namespace = match &self.inner {
MachineInner::Linux(os) => os.unix().namespace("processes")?,
MachineInner::MacOS(os) => os.unix().namespace("processes")?,
MachineInner::Windows(os) => os.processes()?.id(),
};
os::process::reconcile(self.engine(), actor, namespace)?;
Ok(os::process::list(self.engine(), actor, namespace)?
.into_iter()
.map(|(_, process)| Process {
pid: process.pid,
user: process.user,
executable: process.executable,
arguments: process.arguments,
state: process.state,
cwd: process.cwd,
})
.collect())
}
pub fn password_policy(&self) -> Result<PasswordPolicy, MachineError> {
let MachineInner::Windows(os) = &self.inner else {
return Err(MachineError::UnsupportedCapability {
capability: Capability::AuthenticationPolicy,
os: self.os_kind(),
});
};
let policy = os.policy();
Ok(PasswordPolicy {
min_length: policy.min_length,
max_age_days: policy.max_age_days,
min_age_days: policy.min_age_days,
history: policy.history,
complexity: policy.complexity,
reversible_encryption: policy.reversible_encryption,
lockout_threshold: policy.lockout_threshold,
lockout_duration: policy.lockout_duration,
lockout_window: policy.lockout_window,
})
}
pub fn audit_policy(&self) -> Result<Vec<AuditCategory>, MachineError> {
let MachineInner::Windows(os) = &self.inner else {
return Err(MachineError::UnsupportedCapability {
capability: Capability::Audit,
os: self.os_kind(),
});
};
let policy = os.audit_policy();
Ok([
("System", policy.system),
("Logon/Logoff", policy.logon),
("Account Management", policy.account_management),
("Account Logon", policy.account_logon),
("Policy Change", policy.policy_change),
("Privilege Use", policy.privilege_use),
("Object Access", policy.object_access),
]
.into_iter()
.map(|(name, (success, failure))| AuditCategory {
name: name.to_owned(),
success,
failure,
})
.collect())
}
pub fn registry_values(
&self,
hive: &str,
path: &str,
) -> Result<Vec<RegistryValue>, MachineError> {
let MachineInner::Windows(os) = &self.inner else {
return Err(MachineError::UnsupportedCapability {
capability: Capability::Registry,
os: self.os_kind(),
});
};
let actor = Some(self.admin_actor()?);
let registry = os.registry()?;
let Some(key) = registry.key(actor, hive, path)? else {
return Ok(Vec::new());
};
Ok(registry
.values(actor, key)?
.into_iter()
.map(|value| RegistryValue {
name: value.name,
value_type: value.value_type,
data: value.data,
})
.collect())
}
pub fn preferences(
&self,
domain: &str,
) -> Result<std::collections::BTreeMap<String, PreferenceValue>, MachineError> {
let MachineInner::MacOS(os) = &self.inner else {
return Err(MachineError::UnsupportedCapability {
capability: Capability::Preferences,
os: self.os_kind(),
});
};
let user = os
.unix()
.users()
.by_name(&self.default_user)
.ok_or_else(|| MachineError::Login("default macOS account is missing".to_owned()))?;
let preferences =
os::macos::preferences::Preferences::new(os.unix(), user.uid(), user.home());
Ok(preferences
.domain(Some(self.admin_actor()?), domain)?
.unwrap_or_default()
.into_iter()
.map(|(key, value)| (key, preference_from_os(value)))
.collect())
}
pub fn default_user(&self) -> &str {
&self.default_user
}
pub fn display_name(&self) -> String {
match &self.inner {
MachineInner::Linux(os) => os.display_name(),
MachineInner::MacOS(os) => os.display_name(),
MachineInner::Windows(os) => os.display_name(),
}
}
pub fn hostname(&self) -> &str {
&self.hostname
}
pub fn engine(&self) -> &Engine {
match &self.inner {
MachineInner::Linux(os) => os.engine(),
MachineInner::MacOS(os) => os.engine(),
MachineInner::Windows(os) => os.engine(),
}
}
pub fn configuration(&self) -> Configuration<'_> {
Configuration { machine: self }
}
pub fn read_file(&self, path: &str) -> Result<Option<Vec<u8>>, MachineError> {
let path: VirtualPath = path.parse()?;
let object = match self.engine().lookup(Some(self.admin_actor()?), &path) {
Ok(object) => object,
Err(engine::Error::PathNotFound(_)) => return Ok(None),
Err(error) => return Err(error.into()),
};
Ok(self.engine().read(Some(self.admin_actor()?), object)?)
}
pub fn path_exists(&self, path: &str) -> bool {
let Ok(path) = path.parse::<VirtualPath>() else {
return false;
};
let Ok(actor) = self.admin_actor() else {
return false;
};
self.engine().lookup(Some(actor), &path).is_ok()
}
pub fn subscribe(
&self,
filter: impl Into<Option<EventType>>,
callback: impl FnMut(&ObjectEvent) + Send + Sync + 'static,
) -> SubscriptionId {
self.engine().subscribe(filter, callback)
}
pub fn unsubscribe(&self, subscription: SubscriptionId) {
self.engine().unsubscribe(subscription);
}
pub fn time(&self) -> Timestamp {
self.engine().time()
}
pub fn advance_time(&self, duration: std::time::Duration) {
self.engine().advance_time(duration);
}
pub fn login(
&self,
username: &str,
password: &str,
shell: Option<ShellChoice>,
) -> Result<Session<'_>, MachineError> {
match &self.inner {
MachineInner::Linux(os) => self.login_unix(os, username, password, shell),
MachineInner::MacOS(os) => self.login_unix(os, username, password, shell),
MachineInner::Windows(os) => {
let actor = crate::login_windows(os, username, Some(password), false)
.map_err(MachineError::Login)?;
Ok(Session::windows(
os,
actor,
shell.unwrap_or_else(Session::default_windows_choice),
)?)
}
}
}
pub fn session(&self, shell: Option<ShellChoice>) -> Result<Session<'_>, MachineError> {
self.login(&self.default_user, &self.default_user, shell)
}
pub fn interactive_session(
&self,
shell: Option<ShellChoice>,
) -> Result<Session<'_>, MachineError> {
match &self.inner {
MachineInner::Linux(os) => {
let credentials = crate::login_screen::run(
os.unix(),
&os.display_name(),
&self.hostname,
&self.default_user,
)
.map_err(MachineError::Login)?;
let choice = shell.unwrap_or_else(|| Session::default_choice(&credentials));
Ok(Session::unix(os.unix(), credentials, choice)?)
}
MachineInner::MacOS(os) => {
let credentials = crate::login_screen::run(
os.unix(),
&os.display_name(),
&self.hostname,
&self.default_user,
)
.map_err(MachineError::Login)?;
let choice = shell.unwrap_or_else(|| Session::default_choice(&credentials));
Ok(Session::unix(os.unix(), credentials, choice)?)
}
MachineInner::Windows(os) => {
let actor = crate::login_screen::run_windows(
os,
&os.display_name(),
&self.hostname,
&self.default_user,
)
.map_err(MachineError::Login)?;
Ok(Session::windows(
os,
actor,
shell.unwrap_or_else(Session::default_windows_choice),
)?)
}
}
}
fn login_unix<'a>(
&'a self,
os: &'a impl UnixFlavor,
username: &str,
password: &str,
shell: Option<ShellChoice>,
) -> Result<Session<'a>, MachineError> {
let credentials = crate::login_with_password(os.unix(), username, password)?;
let choice = shell.unwrap_or_else(|| Session::default_choice(&credentials));
Ok(Session::unix(os.unix(), credentials, choice)?)
}
fn admin_actor(&self) -> Result<ActorId, MachineError> {
match &self.inner {
MachineInner::Linux(_) | MachineInner::MacOS(_) => Ok(UserId::ROOT.actor_id()),
MachineInner::Windows(os) => os
.users()
.by_name("Administrator")
.map(|user| ActorId::new(u64::from(user.rid())))
.ok_or_else(|| MachineError::Login("Administrator account is missing".to_owned())),
}
}
fn configuration_session(&self) -> Result<Session<'_>, MachineError> {
match &self.inner {
MachineInner::Linux(os) => configuration_unix_session(os.unix(), ShellChoice::Bash),
MachineInner::MacOS(os) => configuration_unix_session(os.unix(), ShellChoice::Zsh),
MachineInner::Windows(os) => Ok(Session::windows(
os,
self.admin_actor()?,
ShellChoice::PowerShell,
)?),
}
}
#[allow(clippy::too_many_arguments)]
pub fn add_user(
&self,
username: &str,
uid: u32,
gid: u32,
full_name: &str,
home_dir: &str,
shell: &str,
password: &str,
) -> Result<(), MachineError> {
use os::unix::group::GroupId;
use os::unix::password::PasswordState;
use os::unix::user::{UnixUser, UserId};
let user = UnixUser::new(
username,
UserId::new(uid),
GroupId::new(gid),
full_name,
home_dir,
shell,
PasswordState::hashed(password),
);
match &self.inner {
MachineInner::Linux(os) => {
if os.unix().groups().get(GroupId::new(gid)).is_none() {
return Err(OsError::UnknownGroupId(gid).into());
}
os.unix().users().add(user)?;
os::setup::rerender_accounts(os.unix())?;
Ok(())
}
MachineInner::MacOS(os) => {
if os.unix().groups().get(GroupId::new(gid)).is_none() {
return Err(OsError::UnknownGroupId(gid).into());
}
os.unix().users().add(user)?;
os::setup::rerender_accounts(os.unix())?;
Ok(())
}
MachineInner::Windows(_) => Err(MachineError::Unsupported(
"add_user is not available on Windows",
)),
}
}
pub fn delete_user(&self, username: &str) -> Result<(), MachineError> {
match &self.inner {
MachineInner::Linux(os) => {
os.unix().users().delete(username);
os::setup::rerender_accounts(os.unix())?;
Ok(())
}
MachineInner::MacOS(os) => {
os.unix().users().delete(username);
os::setup::rerender_accounts(os.unix())?;
Ok(())
}
MachineInner::Windows(_) => Err(MachineError::Unsupported(
"delete_user is not available on Windows",
)),
}
}
pub fn user_exists(&self, username: &str) -> bool {
match &self.inner {
MachineInner::Linux(os) => os.unix().users().by_name(username).is_some(),
MachineInner::MacOS(os) => os.unix().users().by_name(username).is_some(),
MachineInner::Windows(_) => false,
}
}
pub fn add_group(&self, name: &str, gid: u32) -> Result<(), MachineError> {
use os::unix::group::{GroupId, UnixGroup};
let group = UnixGroup::new(name, GroupId::new(gid), []);
match &self.inner {
MachineInner::Linux(os) => {
if os.unix().groups().by_name(name).is_some() {
return Ok(());
}
os.unix().groups().add(group)?;
os::setup::rerender_accounts(os.unix())?;
Ok(())
}
MachineInner::MacOS(os) => {
if os.unix().groups().by_name(name).is_some() {
return Ok(());
}
os.unix().groups().add(group)?;
os::setup::rerender_accounts(os.unix())?;
Ok(())
}
MachineInner::Windows(_) => Err(MachineError::Unsupported(
"add_group is not available on Windows",
)),
}
}
pub fn add_user_to_group(&self, username: &str, group_name: &str) -> Result<(), MachineError> {
match &self.inner {
MachineInner::Linux(os) => {
let unix = os.unix();
let user = unix
.users()
.by_name(username)
.ok_or_else(|| MachineError::Login(format!("user '{username}' not found")))?;
let group = unix.groups().by_name(group_name).ok_or_else(|| {
MachineError::Login(format!("group '{group_name}' not found"))
})?;
unix.groups().add_member(group.gid(), user.uid())?;
os::setup::rerender_accounts(unix)?;
Ok(())
}
MachineInner::MacOS(os) => {
let unix = os.unix();
let user = unix
.users()
.by_name(username)
.ok_or_else(|| MachineError::Login(format!("user '{username}' not found")))?;
let group = unix.groups().by_name(group_name).ok_or_else(|| {
MachineError::Login(format!("group '{group_name}' not found"))
})?;
unix.groups().add_member(group.gid(), user.uid())?;
os::setup::rerender_accounts(unix)?;
Ok(())
}
MachineInner::Windows(_) => Err(MachineError::Unsupported(
"add_user_to_group is not available on Windows",
)),
}
}
pub fn user_in_group(&self, username: &str, group_name: &str) -> bool {
match &self.inner {
MachineInner::Linux(os) => {
let unix = os.unix();
let Some(user) = unix.users().by_name(username) else {
return false;
};
let Some(group) = unix.groups().by_name(group_name) else {
return false;
};
user.primary_group() == group.gid() || group.members().contains(&user.uid())
}
MachineInner::MacOS(os) => {
let unix = os.unix();
let Some(user) = unix.users().by_name(username) else {
return false;
};
let Some(group) = unix.groups().by_name(group_name) else {
return false;
};
user.primary_group() == group.gid() || group.members().contains(&user.uid())
}
MachineInner::Windows(_) => false,
}
}
pub fn set_firewall_enabled(&self, enabled: bool) -> Result<(), MachineError> {
match &self.inner {
MachineInner::Linux(os) => {
os.unix()
.firewall()?
.set_enabled(Some(self.admin_actor()?), enabled)?;
Ok(())
}
MachineInner::MacOS(_) => Err(MachineError::Unsupported(
"use the macOS application-firewall API or socketfilterfw",
)),
MachineInner::Windows(_) => Err(MachineError::Unsupported(
"set_firewall_enabled is not available on Windows",
)),
}
}
pub fn firewall_enabled(&self) -> Result<bool, MachineError> {
match &self.inner {
MachineInner::Linux(os) => {
let enabled = os
.unix()
.firewall()?
.is_enabled(Some(self.admin_actor()?))?;
Ok(enabled)
}
MachineInner::MacOS(_) => Err(MachineError::Unsupported(
"use the macOS application-firewall API or socketfilterfw",
)),
MachineInner::Windows(_) => Err(MachineError::Unsupported(
"firewall_enabled is not available on Windows",
)),
}
}
pub fn set_file_mode(&self, path: &str, mode: FileMode) -> Result<(), MachineError> {
match &self.inner {
MachineInner::Linux(os) => {
os::setup::set_file_mode(os.unix(), Some(self.admin_actor()?), path, mode)?;
Ok(())
}
MachineInner::MacOS(os) => {
os::setup::set_file_mode(os.unix(), Some(self.admin_actor()?), path, mode)?;
Ok(())
}
MachineInner::Windows(_) => Err(MachineError::Unsupported(
"set_file_mode is not available on Windows",
)),
}
}
pub fn rerender_accounts(&self) -> Result<(), MachineError> {
match &self.inner {
MachineInner::Linux(os) => {
os::setup::rerender_accounts(os.unix())?;
Ok(())
}
MachineInner::MacOS(os) => {
os::setup::rerender_accounts(os.unix())?;
Ok(())
}
MachineInner::Windows(_) => Err(MachineError::Unsupported(
"rerender_accounts is not available on Windows",
)),
}
}
pub fn file_mode(&self, path: &str) -> Result<FileMode, MachineError> {
if self.os_kind() == OsKind::Windows {
return Err(MachineError::Unsupported(
"Unix file modes are unavailable on Windows",
));
}
let path: VirtualPath = path.parse()?;
let object = self.engine().lookup(Some(self.admin_actor()?), &path)?;
let metadata = self.engine().metadata(Some(self.admin_actor()?), object)?;
let attrs = os::unix::attrs::UnixAttrs::from_authorization(metadata.authorization())
.map_err(|reason| MachineError::Os(OsError::InvalidUnixAttrs(object, reason)))?;
Ok(attrs.mode)
}
pub fn install_service(
&self,
name: &str,
description: &str,
state: &str,
enabled: bool,
) -> Result<(), MachineError> {
match &self.inner {
MachineInner::Linux(os) => {
os.unix().service_state()?.install_unit(
Some(self.admin_actor()?),
name,
description,
state,
enabled,
)?;
Ok(())
}
MachineInner::MacOS(_) => Err(MachineError::Unsupported(
"install_service is not available on macOS",
)),
MachineInner::Windows(_) => Err(MachineError::Unsupported(
"install_service is not available on Windows",
)),
}
}
pub fn set_service_state(&self, name: &str, state: &str) -> Result<(), MachineError> {
match &self.inner {
MachineInner::Linux(os) => {
os.unix()
.service_state()?
.set_state(Some(self.admin_actor()?), name, state)?;
Ok(())
}
MachineInner::MacOS(_) => Err(MachineError::Unsupported(
"set_service_state is not available on macOS",
)),
MachineInner::Windows(_) => Err(MachineError::Unsupported(
"set_service_state is not available on Windows",
)),
}
}
pub fn set_service_start_type(&self, name: &str, start_type: &str) -> Result<(), MachineError> {
match &self.inner {
MachineInner::Linux(os) => {
os.unix().service_state()?.set_start_type(
Some(self.admin_actor()?),
name,
start_type,
)?;
Ok(())
}
MachineInner::MacOS(_) => Err(MachineError::Unsupported(
"set_service_start_type is not available on macOS",
)),
MachineInner::Windows(_) => Err(MachineError::Unsupported(
"set_service_start_type is not available on Windows",
)),
}
}
}
fn configuration_unix_session(
unix: &os::UnixOs,
shell: ShellChoice,
) -> Result<Session<'_>, MachineError> {
let root = unix
.users()
.by_name("root")
.ok_or_else(|| MachineError::Login("root account is missing".to_owned()))?;
let credentials =
os::Credentials::login(root.clone(), unix.groups().memberships_of(root.uid()));
Ok(Session::unix(unix, credentials, shell)?)
}
pub struct Configuration<'machine> {
machine: &'machine Machine,
}
impl Configuration<'_> {
pub fn session(&self) -> Result<Session<'_>, MachineError> {
self.machine.configuration_session()
}
pub fn write_file(
&self,
path: &str,
content: impl AsRef<[u8]>,
mode: FileMode,
) -> Result<(), MachineError> {
if self.machine.os_kind() == OsKind::Windows {
return Err(MachineError::Unsupported(
"Unix file modes are unavailable on Windows",
));
}
os::setup::write_system_file(
self.machine.engine(),
Some(UserId::ROOT.actor_id()),
path,
content.as_ref(),
mode,
)?;
Ok(())
}
pub fn write_file_with_metadata(
&self,
path: &str,
content: impl AsRef<[u8]>,
owner: &str,
group: &str,
mode: FileMode,
) -> Result<(), MachineError> {
let unix = match &self.machine.inner {
MachineInner::Linux(os) => os.unix(),
MachineInner::MacOS(os) => os.unix(),
MachineInner::Windows(_) => {
return Err(MachineError::UnsupportedCapability {
capability: Capability::FileMetadata,
os: self.machine.os_kind(),
});
}
};
os::setup::write_file_with_metadata(
unix,
Some(self.machine.admin_actor()?),
path,
content.as_ref(),
owner,
group,
mode,
)?;
Ok(())
}
pub fn append_file(&self, path: &str, content: impl AsRef<[u8]>) -> Result<(), MachineError> {
if self.machine.os_kind() == OsKind::Windows {
return Err(MachineError::Unsupported(
"Unix system-file configuration is unavailable on Windows",
));
}
os::setup::append_system_file(
self.machine.engine(),
Some(UserId::ROOT.actor_id()),
path,
content.as_ref(),
)?;
Ok(())
}
pub fn set_mode(&self, path: &str, mode: FileMode) -> Result<(), MachineError> {
let unix = match &self.machine.inner {
MachineInner::Linux(os) => os.unix(),
MachineInner::MacOS(os) => os.unix(),
MachineInner::Windows(_) => {
return Err(MachineError::Unsupported(
"Unix file modes are unavailable on Windows",
));
}
};
os::setup::set_file_mode(unix, Some(UserId::ROOT.actor_id()), path, mode)?;
Ok(())
}
pub fn run(&self, command: &str) -> Result<CommandOutput, MachineError> {
Ok(self.session()?.execute(command)?)
}
pub fn run_checked(&self, command: &str) -> Result<CommandOutput, MachineError> {
let output = self.run(command)?;
if output.success() {
Ok(output)
} else {
Err(MachineError::CommandFailed(output))
}
}
pub fn set_password_policy(&self, policy: &PasswordPolicy) -> Result<(), MachineError> {
let MachineInner::Windows(os) = &self.machine.inner else {
return Err(MachineError::UnsupportedCapability {
capability: Capability::AuthenticationPolicy,
os: self.machine.os_kind(),
});
};
os.set_policy(os::windows::PasswordPolicy {
min_length: policy.min_length,
max_age_days: policy.max_age_days,
min_age_days: policy.min_age_days,
history: policy.history,
complexity: policy.complexity,
reversible_encryption: policy.reversible_encryption,
lockout_threshold: policy.lockout_threshold,
lockout_duration: policy.lockout_duration,
lockout_window: policy.lockout_window,
});
Ok(())
}
pub fn set_audit_policy(&self, categories: &[AuditCategory]) -> Result<(), MachineError> {
let MachineInner::Windows(os) = &self.machine.inner else {
return Err(MachineError::UnsupportedCapability {
capability: Capability::Audit,
os: self.machine.os_kind(),
});
};
let setting = |name: &str| {
categories
.iter()
.find(|category| category.name.eq_ignore_ascii_case(name))
.map_or((false, false), |category| {
(category.success, category.failure)
})
};
os.set_audit_policy(os::windows::AuditPolicy {
system: setting("System"),
logon: setting("Logon/Logoff"),
account_management: setting("Account Management"),
account_logon: setting("Account Logon"),
policy_change: setting("Policy Change"),
privilege_use: setting("Privilege Use"),
object_access: setting("Object Access"),
});
Ok(())
}
pub fn set_registry_value(
&self,
hive: &str,
path: &str,
name: &str,
value_type: &str,
data: &str,
) -> Result<(), MachineError> {
let MachineInner::Windows(os) = &self.machine.inner else {
return Err(MachineError::UnsupportedCapability {
capability: Capability::Registry,
os: self.machine.os_kind(),
});
};
os.registry()?.set_value(
Some(self.machine.admin_actor()?),
hive,
path,
name,
value_type,
data,
)?;
Ok(())
}
pub fn set_preference(
&self,
domain: &str,
key: &str,
value: PreferenceValue,
) -> Result<(), MachineError> {
let MachineInner::MacOS(os) = &self.machine.inner else {
return Err(MachineError::UnsupportedCapability {
capability: Capability::Preferences,
os: self.machine.os_kind(),
});
};
let user = os
.unix()
.users()
.by_name(&self.machine.default_user)
.ok_or_else(|| MachineError::Login("default macOS account is missing".to_owned()))?;
os::macos::preferences::Preferences::new(os.unix(), user.uid(), user.home()).set(
Some(self.machine.admin_actor()?),
domain,
key,
preference_to_os(value),
)?;
Ok(())
}
}
fn preference_from_os(value: os::macos::plist::PlistValue) -> PreferenceValue {
match value {
os::macos::plist::PlistValue::String(value) => PreferenceValue::String(value),
os::macos::plist::PlistValue::Integer(value) => PreferenceValue::Integer(value),
os::macos::plist::PlistValue::Boolean(value) => PreferenceValue::Boolean(value),
}
}
fn preference_to_os(value: PreferenceValue) -> os::macos::plist::PlistValue {
match value {
PreferenceValue::String(value) => os::macos::plist::PlistValue::String(value),
PreferenceValue::Integer(value) => os::macos::plist::PlistValue::Integer(value),
PreferenceValue::Boolean(value) => os::macos::plist::PlistValue::Boolean(value),
}
}
#[derive(Debug)]
#[non_exhaustive]
pub enum MachineError {
InvalidConfiguration(String),
Os(OsError),
Engine(engine::Error),
Session(SessionError),
Login(String),
Unsupported(&'static str),
UnsupportedCapability {
capability: Capability,
os: OsKind,
},
CommandFailed(CommandOutput),
}
impl std::fmt::Display for MachineError {
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::InvalidConfiguration(message) => {
write!(formatter, "invalid machine configuration: {message}")
}
Self::Os(error) => error.fmt(formatter),
Self::Engine(error) => error.fmt(formatter),
Self::Session(error) => error.fmt(formatter),
Self::Login(message) => formatter.write_str(message),
Self::Unsupported(message) => formatter.write_str(message),
Self::UnsupportedCapability { capability, os } => {
write!(formatter, "{capability:?} is not supported by {os:?}")
}
Self::CommandFailed(output) => write!(
formatter,
"command failed with status {}: {}",
output.status(),
output.stderr_text().trim_end()
),
}
}
}
impl std::error::Error for MachineError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match self {
Self::Os(error) => Some(error),
Self::Engine(error) => Some(error),
Self::Session(error) => Some(error),
Self::InvalidConfiguration(_)
| Self::Login(_)
| Self::Unsupported(_)
| Self::UnsupportedCapability { .. }
| Self::CommandFailed(_) => None,
}
}
}
impl From<OsError> for MachineError {
fn from(error: OsError) -> Self {
Self::Os(error)
}
}
impl From<engine::Error> for MachineError {
fn from(error: engine::Error) -> Self {
Self::Engine(error)
}
}
impl From<SessionError> for MachineError {
fn from(error: SessionError) -> Self {
Self::Session(error)
}
}