Skip to main content

ploit_malper/frontend/
assets.rs

1use crate::config::ConfigManager;
2use crate::db::models::Asset;
3use crate::error::{AppError, Result};
4use crate::frontend::{
5    bold, fmt_ts, open_backend, parse_ts, print_json, ts_since, Args, Cell, ChangeState, IdMaps,
6    ObsIndex, Table,
7};
8
9pub fn usage() {
10    println!(
11        "Usage: ploit-malper assets [--new] [--changed] [--since DATE] [--target TERM] \
12         [--verbose] [--json] [--backend pocketbase|sqlite]"
13    );
14}
15
16pub fn cmd_assets(args: &[String], config_mgr: &mut ConfigManager) -> Result<()> {
17    let parsed = Args::parse(args)?;
18    if parsed.has("help") {
19        usage();
20        return Ok(());
21    }
22
23    let mut storage = open_backend(config_mgr, &parsed)?;
24
25    let assets = storage.list_assets()?;
26    let observations = storage.list_all_observations()?;
27    let obs_index = ObsIndex::build(&observations);
28    let maps = IdMaps::load(&mut storage)?;
29
30    let since = match parsed.get("since") {
31        Some(raw) => Some(
32            parse_ts(raw)
33                .ok_or_else(|| AppError::Message(format!("invalid --since date: '{}'", raw)))?,
34        ),
35        None => None,
36    };
37
38    let mut selected: Vec<&Asset> = Vec::new();
39    for asset in &assets {
40        if let Some(target) = parsed.get("target") {
41            let needle = target.to_lowercase();
42            let hit = asset.name.to_lowercase().contains(&needle)
43                || asset
44                    .ip
45                    .as_deref()
46                    .is_some_and(|i| i.to_lowercase().contains(&needle))
47                || asset
48                    .fqdn
49                    .as_deref()
50                    .is_some_and(|f| f.to_lowercase().contains(&needle))
51                || asset
52                    .reverse_dns
53                    .as_deref()
54                    .is_some_and(|r| r.to_lowercase().contains(&needle));
55            if !hit {
56                continue;
57            }
58        }
59        if let Some(since) = since {
60            if !ts_since(&asset.last_seen, since) {
61                continue;
62            }
63        }
64        let state = obs_index.state(&asset.stable_id, &asset.status);
65        if parsed.has("new") && state != ChangeState::New {
66            continue;
67        }
68        if parsed.has("changed") && state != ChangeState::Changed {
69            continue;
70        }
71        selected.push(asset);
72    }
73
74    if parsed.has("json") {
75        let data: Vec<Asset> = selected.into_iter().cloned().collect();
76        return print_json(&data);
77    }
78
79    if selected.is_empty() {
80        crate::frontend::empty_result("assets");
81        return Ok(());
82    }
83
84    let mut table = Table::new(vec![
85        "NAME".to_string(),
86        "TYPE".to_string(),
87        "SERVICES".to_string(),
88        "FIRST SEEN".to_string(),
89        "LAST SEEN".to_string(),
90        "CHANGE".to_string(),
91    ]);
92    for asset in &selected {
93        let state = obs_index.state(&asset.stable_id, &asset.status);
94        table.add_row(vec![
95            Cell::plain(asset.name.clone()),
96            Cell::plain(asset.asset_type.clone()),
97            Cell::plain(maps.service_summary(&asset.stable_id)),
98            Cell::plain(fmt_ts(&asset.first_seen)),
99            Cell::plain(fmt_ts(&asset.last_seen)),
100            Cell::styled(state.label().to_string(), state_style(state)),
101        ]);
102    }
103    println!("{}", table.render());
104
105    if parsed.has("verbose") {
106        println!();
107        for asset in &selected {
108            println!(
109                "{} ({})  [{}]",
110                bold(&asset.name),
111                asset.asset_type,
112                asset.stable_id
113            );
114            println!(
115                "    ip={} fqdn={} reverse_dns={} status={}",
116                asset.ip.as_deref().unwrap_or("-"),
117                asset.fqdn.as_deref().unwrap_or("-"),
118                asset.reverse_dns.as_deref().unwrap_or("-"),
119                asset.status
120            );
121            if !asset.metadata.is_null() && asset.metadata.as_object().is_some() {
122                println!("    metadata={}", asset.metadata);
123            }
124            let observations = obs_index.observations_for(&asset.stable_id);
125            if !observations.is_empty() {
126                let last = observations.last().unwrap();
127                println!("    last change: {} ({})", last.kind, last.observed_at);
128            }
129        }
130    }
131
132    Ok(())
133}
134
135fn state_style(state: ChangeState) -> &'static str {
136    match state {
137        ChangeState::New => "32",
138        ChangeState::Changed => "33",
139        ChangeState::Removed => "31",
140        ChangeState::Unchanged => "2",
141    }
142}