Add Wireguard support to vpn block

Cargo.toml

@@ -48,7 +48,7 @@ log = "0.4"
 maildir = { version = "0.6", optional = true }
 neli = { version = "0.6", features = ["async"] }
 neli-wifi = { version = "0.6", features = ["async"] }
-nix = { version = "0.27", features = ["fs", "process"] }
+nix = { version = "0.27", features = ["fs", "process", "user"] }
 nom = "7.1.2"
 notmuch = { version = "0.8", optional = true }
 once_cell = "1"

src/blocks/vpn.rs

@@ -12,6 +12,7 @@
 //! `format_disconnected` | A string to customise the output in case the network is disconnected. See below for available placeholders. | `" VPN: $icon "`
 //! `state_connected` | The widgets state if the vpn network is connected. | `info`
 //! `state_disconnected` | The widgets state if the vpn network is disconnected | `idle`
+//! `wireguard_interface` | The wireguard interface name | `wg0`
 //!
 //! Placeholder | Value | Type | Unit
 //! ------------|-----------------------------------------------------------|--------|------
@@ -32,6 +33,21 @@
 //! ## Mullvad
 //! Behind the scenes the mullvad driver uses the `mullvad` command line binary. In order for this to work properly the binary should be executable and mullvad daemon should be running.
 //!
+//! ## Wireguard
+//! Behind the scenes the wireguard driver uses the `wg` and `wg-quick` command line binaries.
+//! The binaries are executed through sudo, so you need to configure your sudoers file to allow password-less execution of these binaries.
+//!
+//! Sample sudoers file (`/etc/sudoers.d/wireguard`):
+//! ```text
+//! your_user ALL=(ALL:ALL) NOPASSWD: /usr/bin/wg-quick up wg0, \
+//! /usr/bin/wg-quick down wg0, \
+//! /usr/bin/wg show wg0
+//! ```
+//! Be careful to include the interface name, and make sure that the config file is owned by root and not writable by others.
+//! Otherwise the PreUp and PostDown scripts can be used to run arbitrary commands as root.
+//!
+//! The country and flag placeholders are empty strings when connected to Wireguard.
+//!
 //! # Example
 //!
 //! Shows the current vpn network state:
@@ -70,6 +86,9 @@
 mod nordvpn;
 use nordvpn::NordVpnDriver;
 mod mullvad;
+mod wireguard;
+
+use crate::blocks::vpn::wireguard::WireguardDriver;
 use mullvad::MullvadDriver;
 
 use super::prelude::*;
@@ -80,6 +99,7 @@ pub enum DriverType {
  #[default]
  Nordvpn,
  Mullvad,
+ Wireguard,
 }
 
 #[derive(Deserialize, Debug, SmartDefault)]
@@ -92,6 +112,8 @@ pub struct Config {
  pub format_disconnected: FormatConfig,
  pub state_connected: State,
  pub state_disconnected: State,
+ #[default("wg0".into())]
+ pub wireguard_interface: String,
 }
 
 enum Status {
@@ -123,6 +145,9 @@ pub async fn run(config: &Config, api: &CommonApi) -> Result<()> {
  let driver: Box<dyn Driver> = match config.driver {
  DriverType::Nordvpn => Box::new(NordVpnDriver::new().await),
  DriverType::Mullvad => Box::new(MullvadDriver::new().await),
+ DriverType::Wireguard => {
+ Box::new(WireguardDriver::new(config.wireguard_interface.to_owned()).await)
+ }
  };
 
  loop {

src/blocks/vpn/wireguard.rs

@@ -0,0 +1,95 @@
+use std::process::Stdio;
+
+use async_trait::async_trait;
+use nix::unistd::getuid;
+use tokio::process::Command;
+
+use crate::blocks::prelude::*;
+
+use super::{Driver, Status};
+
+pub struct WireguardDriver {
+ interface: String,
+}
+
+impl WireguardDriver {
+ pub async fn new(interface: String) -> WireguardDriver {
+ WireguardDriver { interface }
+ }
+}
+
+const SUDO_CMD: &str = "/usr/bin/sudo";
+const WG_QUICK_CMD: &str = "/usr/bin/wg-quick";
+const WG_CMD: &str = "/usr/bin/wg";
+
+#[async_trait]
+impl Driver for WireguardDriver {
+ async fn get_status(&self) -> Result<Status> {
+ let status = run_wg(vec!["show", self.interface.as_str()]).await;
+
+ match status {
+ Ok(status) => {
+ if status.contains(format!("interface: {}", self.interface).as_str()) {
+ Ok(Status::Connected {
+ country: "".to_owned(),
+ country_flag: "".to_owned(),
+ })
+ } else {
+ Ok(Status::Disconnected)
+ }
+ }
+ Err(_) => Ok(Status::Error),
+ }
+ }
+
+ async fn toggle_connection(&self, status: &Status) -> Result<()> {
+ match status {
+ Status::Connected { .. } => {
+ run_wg_quick(vec!["down", self.interface.as_str()]).await?;
+ }
+ Status::Disconnected => {
+ run_wg_quick(vec!["up", self.interface.as_str()]).await?;
+ }
+ Status::Error => (),
+ }
+ Ok(())
+ }
+}
+
+async fn run_wg(args: Vec<&str>) -> Result<String> {
+ let stdout = make_command(should_use_sudo(), WG_CMD)
+ .args(&args)
+ .output()
+ .await
+ .error(format!("Problem running wg command: {args:?}"))?
+ .stdout;
+ let stdout =
+ String::from_utf8(stdout).error(format!("wg produced non-UTF8 output: {args:?}"))?;
+ Ok(stdout)
+}
+
+async fn run_wg_quick(args: Vec<&str>) -> Result<()> {
+ make_command(should_use_sudo(), WG_QUICK_CMD)
+ .args(&args)
+ .stdin(Stdio::null())
+ .stdout(Stdio::null())
+ .spawn()
+ .error(format!("Problem running wg-quick command: {args:?}"))?
+ .wait()
+ .await
+ .error(format!("Problem running wg-quick command: {args:?}"))?;
+ Ok(())
+}
+
+fn make_command(use_sudo: bool, cmd: &str) -> Command {
+ let mut command = Command::new(if use_sudo { SUDO_CMD } else { cmd });
+
+ if use_sudo {
+ command.arg("-n").arg(cmd);
+ }
+ command
+}
+
+fn should_use_sudo() -> bool {
+ !(getuid().is_root())
+}