add wireguard-show binary and optional handshake timestamps

1 files changed, 80 insertions, 0 deletions

diff --git a/bin/wireguard-show.rs b/bin/wireguard-show.rs
new file mode 100644
index 0000000..17476d6
--- /dev/null
+++ b/bin/wireguard-show.rs
@@ -0,0 +1,80 @@
+use anyhow::Result;
+use wireguard::WireGuard;
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    let mut wireguard = WireGuard::new().await?;
+    let devices = wireguard.view_devices().await?;
+
+    if devices.is_empty() {
+        println!("no wireguard devices found");
+        return Ok(());
+    }
+
+    for device in devices {
+        println!("device: {}", device.name);
+        println!("  ifindex: {}", device.ifindex);
+        println!("  private_key: {}", format_optional_key(device.private_key));
+        println!("  public_key: {}", format_optional_key(device.public_key));
+        println!("  listen_port: {}", device.listen_port);
+        println!("  fwmark: {}", device.fwmark);
+        println!("  peers: {}", device.peers.len());
+
+        for (index, peer) in device.peers.iter().enumerate() {
+            println!("  peer {}:", index + 1);
+            println!("    public_key: {}", peer.public_key);
+            println!(
+                "    preshared_key: {}",
+                format_optional_key(peer.preshared_key)
+            );
+            println!(
+                "    endpoint: {}",
+                peer.endpoint
+                    .map(|endpoint| endpoint.to_string())
+                    .unwrap_or_else(|| "none".to_string())
+            );
+            println!(
+                "    persistent_keepalive: {}",
+                peer.persistent_keepalive
+                    .map(|keepalive| keepalive.to_string())
+                    .unwrap_or_else(|| "none".to_string())
+            );
+            println!(
+                "    last_handshake: {}",
+                format_duration(peer.last_handshake)
+            );
+            println!("    rx_bytes: {}", peer.rx_bytes);
+            println!("    tx_bytes: {}", peer.tx_bytes);
+            if peer.allowed_ips.is_empty() {
+                println!("    allowed_ips: none");
+            } else {
+                let allowed_ips = peer
+                    .allowed_ips
+                    .iter()
+                    .map(|ip| ip.to_string())
+                    .collect::<Vec<_>>()
+                    .join(", ");
+                println!("    allowed_ips: {}", allowed_ips);
+            }
+        }
+
+        println!();
+    }
+
+    Ok(())
+}
+
+fn format_optional_key(key: Option<wireguard::Key>) -> String {
+    key.map(|value| value.to_string())
+        .unwrap_or_else(|| "none".to_string())
+}
+
+fn format_duration(time: Option<std::time::SystemTime>) -> String {
+    match time {
+        Some(time) => match time.duration_since(std::time::UNIX_EPOCH) {
+            Ok(duration) => format!("{}.{}", duration.as_secs(), duration.subsec_nanos()),
+            Err(_) => "before-epoch".to_string(),
+        },
+        None => "none".to_string(),
+    }
+}