#[cfg(feature = "http-proxy")]
#[path = "openiwan/http_proxy.rs"]
mod http_proxy;
use clap::{Args, Parser, Subcommand};
use openiwan::client;
#[cfg(feature = "managed")]
use openiwan::managed::{
ManagedClient, ManagedServer, ManagedState, ProviderConfig, default_state_path, load_state,
new_device_id, save_state, select_server,
};
use openiwan::protocol::{self, Tlv};
use openiwan::tun::{RouteGuard, TunDevice, resolve_route_targets};
use openiwan::{Client, ClientConfig, EncryptionMethod, Error, PacketDevice, Result};
use std::fs;
#[cfg(feature = "managed")]
use std::io::Write;
#[cfg(feature = "http-proxy")]
use std::net::{IpAddr, SocketAddr};
use std::path::{Path, PathBuf};
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use std::time::Duration;
use tracing_subscriber::EnvFilter;
use zeroize::Zeroize;
#[derive(Debug, Parser)]
#[command(name = "openiwan", version, about)]
struct Cli {
#[arg(short, long, action = clap::ArgAction::Count, global = true)]
verbose: u8,
#[command(subcommand)]
command: Command,
}
#[derive(Debug, Subcommand)]
enum Command {
Ping(PingArgs),
Auth(ConnectionArgs),
Connect(ConnectArgs),
#[cfg(feature = "http-proxy")]
Serve(ServeArgs),
Decode(DecodeArgs),
#[cfg(feature = "managed")]
Managed(ManagedArgs),
}
#[derive(Debug, Args)]
struct PingArgs {
#[arg(long)]
server: String,
#[arg(long, default_value_t = 3_000)]
timeout_ms: u64,
}
#[derive(Debug, Clone, Args)]
struct ConnectionArgs {
#[arg(long)]
config: Option<PathBuf>,
#[arg(long)]
server: Option<String>,
#[arg(long)]
username: String,
#[arg(long, default_value = "OPENIWAN_PASSWORD")]
password_env: String,
#[arg(long)]
password_file: Option<PathBuf>,
#[arg(long)]
mtu: Option<u16>,
#[arg(long)]
encryption: Option<EncryptionMethod>,
}
#[derive(Debug, Args)]
struct ConnectArgs {
#[command(flatten)]
connection: ConnectionArgs,
#[arg(long)]
tun: Option<String>,
#[command(flatten)]
routes: RouteArgs,
}
#[cfg(feature = "http-proxy")]
#[derive(Debug, Args)]
struct ServeArgs {
#[command(flatten)]
connection: ConnectionArgs,
#[command(flatten)]
proxy: HttpProxyArgs,
}
#[cfg(feature = "http-proxy")]
#[derive(Debug, Clone, Args)]
struct HttpProxyArgs {
#[arg(long)]
upstream: String,
#[arg(long = "upstream-ip", value_delimiter = ',')]
upstream_ips: Vec<IpAddr>,
#[arg(long, value_enum, default_value = "auto")]
dns_mode: DnsModeArg,
#[arg(long = "dns-server", value_parser = parse_dns_server)]
dns_servers: Vec<SocketAddr>,
#[arg(long, default_value_t = 3_000)]
dns_timeout_ms: u64,
#[arg(long, default_value = "127.0.0.1:8080")]
listen: SocketAddr,
#[arg(long = "ca-cert")]
ca_certificates: Vec<PathBuf>,
#[arg(long, default_value_t = 10_000)]
upstream_timeout_ms: u64,
}
#[cfg(feature = "http-proxy")]
#[derive(Debug, Clone, Copy, clap::ValueEnum)]
enum DnsModeArg {
Auto,
Iwan,
System,
}
#[cfg(feature = "http-proxy")]
impl From<DnsModeArg> for http_proxy::DnsMode {
fn from(value: DnsModeArg) -> Self {
match value {
DnsModeArg::Auto => Self::Auto,
DnsModeArg::Iwan => Self::Iwan,
DnsModeArg::System => Self::System,
}
}
}
#[cfg(feature = "http-proxy")]
fn parse_dns_server(value: &str) -> std::result::Result<SocketAddr, String> {
if let Ok(address) = value.parse::<IpAddr>() {
return Ok(SocketAddr::new(address, 53));
}
value
.parse::<SocketAddr>()
.map_err(|error| format!("invalid DNS server {value}: {error}"))
}
#[derive(Debug, Clone, Default, Args)]
struct RouteArgs {
#[arg(long = "route", value_delimiter = ',')]
routes: Vec<String>,
#[arg(long = "route-ip", value_delimiter = ',')]
route_ips: Vec<String>,
#[arg(long = "route-domain", value_delimiter = ',')]
route_domains: Vec<String>,
}
#[derive(Debug, Args)]
struct DecodeArgs {
hex: String,
}
#[cfg(feature = "managed")]
#[derive(Debug, Args)]
struct ManagedArgs {
#[arg(long)]
provider: PathBuf,
#[arg(long)]
state_dir: Option<PathBuf>,
#[command(subcommand)]
action: ManagedCommand,
}
#[cfg(feature = "managed")]
#[derive(Debug, Subcommand)]
enum ManagedCommand {
Fetch,
List,
Connect(ManagedConnectArgs),
All(ManagedConnectArgs),
#[cfg(feature = "http-proxy")]
Serve(ManagedServeArgs),
}
#[cfg(feature = "managed")]
#[derive(Debug, Args)]
struct ManagedConnectArgs {
#[arg(long, conflicts_with = "line_name")]
line_index: Option<usize>,
#[arg(long, conflicts_with = "line_index")]
line_name: Option<String>,
#[arg(long)]
tun: Option<String>,
#[arg(long)]
mtu: Option<u16>,
#[arg(long)]
encryption: Option<EncryptionMethod>,
#[command(flatten)]
routes: RouteArgs,
}
#[cfg(all(feature = "managed", feature = "http-proxy"))]
#[derive(Debug, Args)]
struct ManagedServeArgs {
#[arg(long, conflicts_with = "line_name")]
line_index: Option<usize>,
#[arg(long, conflicts_with = "line_index")]
line_name: Option<String>,
#[arg(long)]
mtu: Option<u16>,
#[arg(long)]
encryption: Option<EncryptionMethod>,
#[command(flatten)]
proxy: HttpProxyArgs,
}
fn main() {
if let Err(error) = run() {
eprintln!("error: {error}");
std::process::exit(1);
}
}
fn run() -> Result<()> {
let cli = Cli::parse();
init_logging(cli.verbose);
match cli.command {
Command::Ping(arguments) => {
let address = ClientConfig::new(arguments.server, true, 16).resolve_server()?;
let elapsed = client::ping(address, Duration::from_millis(arguments.timeout_ms))?;
println!(
"reply from {address}: {:.3} ms",
elapsed.as_secs_f64() * 1_000.0
);
}
Command::Auth(arguments) => {
let client = build_client(&arguments)?;
let session = client.authenticate()?;
print_session(session.info());
session.close()?;
}
Command::Connect(arguments) => connect(arguments)?,
#[cfg(feature = "http-proxy")]
Command::Serve(arguments) => serve(arguments)?,
Command::Decode(arguments) => decode(&arguments.hex)?,
#[cfg(feature = "managed")]
Command::Managed(arguments) => managed(arguments)?,
}
Ok(())
}
fn connect(arguments: ConnectArgs) -> Result<()> {
let client = build_client(&arguments.connection)?;
run_client(client, arguments.tun.as_deref(), &arguments.routes)
}
#[cfg(feature = "http-proxy")]
fn serve(arguments: ServeArgs) -> Result<()> {
let client = build_client(&arguments.connection)?;
run_http_proxy(client, &arguments.proxy, &[])
}
fn run_client(client: Client, tun: Option<&str>, route_arguments: &RouteArgs) -> Result<()> {
let session = client.authenticate()?;
print_session(session.info());
let routes = resolve_route_targets(
&route_arguments.routes,
&route_arguments.route_ips,
&route_arguments.route_domains,
Some(session.info().peer.ip()),
)?;
let device = Arc::new(TunDevice::open(tun, session.info())?);
let _routes = RouteGuard::configure(&device, &routes)?;
for route in &routes {
println!("route {route} -> {}", device.name());
}
println!("TUN {} is active; press Ctrl-C to stop", device.name());
let shutdown = install_shutdown_handler()?;
let end = client.run_reconnecting_from(session, device, shutdown)?;
println!("session ended: {end:?}");
Ok(())
}
fn install_shutdown_handler() -> Result<Arc<AtomicBool>> {
let shutdown = Arc::new(AtomicBool::new(false));
let signal = Arc::clone(&shutdown);
ctrlc::set_handler(move || signal.store(true, Ordering::Release)).map_err(|error| {
Error::InvalidConfig(format!("failed to install signal handler: {error}"))
})?;
Ok(shutdown)
}
#[cfg(feature = "http-proxy")]
fn run_http_proxy(
client: Client,
arguments: &HttpProxyArgs,
provider_dns_servers: &[IpAddr],
) -> Result<()> {
let mut dns_servers = arguments.dns_servers.clone();
if dns_servers.is_empty() {
dns_servers.extend(
provider_dns_servers
.iter()
.copied()
.map(|address| SocketAddr::new(address, 53)),
);
}
let dns = http_proxy::DnsConfig::new(
arguments.dns_mode.into(),
dns_servers,
Duration::from_millis(arguments.dns_timeout_ms),
)?;
let config = http_proxy::HttpProxyConfig::new(
arguments.listen,
&arguments.upstream,
arguments.upstream_ips.clone(),
dns,
arguments.ca_certificates.clone(),
Duration::from_millis(arguments.upstream_timeout_ms),
)?;
let session = client.authenticate()?;
print_session(session.info());
let shutdown = install_shutdown_handler()?;
let end = http_proxy::run(client, session, config, shutdown)?;
println!("session ended: {end:?}");
Ok(())
}
#[cfg(feature = "managed")]
fn managed(arguments: ManagedArgs) -> Result<()> {
let provider = ProviderConfig::load(&arguments.provider)?;
let state_path = default_state_path(&provider.id, arguments.state_dir.as_deref())?;
let client = ManagedClient::new(provider);
match arguments.action {
ManagedCommand::Fetch => {
let state = managed_fetch(&client, &state_path)?;
print_servers(&state);
}
ManagedCommand::List => {
let state = load_managed_state(&client, &state_path)?;
print_servers(&state);
}
ManagedCommand::Connect(connect) => {
let state = load_managed_state(&client, &state_path)?;
print_servers(&state);
managed_connect(&client, &state, &connect)?;
}
ManagedCommand::All(connect) => {
let state = managed_fetch(&client, &state_path)?;
print_servers(&state);
managed_connect(&client, &state, &connect)?;
}
#[cfg(feature = "http-proxy")]
ManagedCommand::Serve(serve) => {
let state = load_managed_state(&client, &state_path)?;
print_servers(&state);
managed_serve(&client, &state, &serve)?;
}
}
Ok(())
}
#[cfg(feature = "managed")]
fn managed_fetch(client: &ManagedClient, state_path: &Path) -> Result<ManagedState> {
let device_id = if state_path.exists() {
let state = load_managed_state(client, state_path)?;
state.device_id
} else {
new_device_id()
};
let pending = client.begin_authorization()?;
println!(
"Open this URL in a browser and complete authentication:\n\n{}\n",
pending.authorization_url()
);
let redirect = prompt_line("Paste the complete callback URL: ")?;
let state = client.fetch(&pending, &redirect, &device_id)?;
save_state(state_path, &state)?;
println!(
"saved {} line(s) to {}",
state.servers.len(),
state_path.display()
);
Ok(state)
}
#[cfg(feature = "managed")]
fn load_managed_state(client: &ManagedClient, state_path: &Path) -> Result<ManagedState> {
let state = load_state(state_path)?;
state.validate_for(&client.provider().id, &client.provider().controller.domain)?;
Ok(state)
}
#[cfg(feature = "managed")]
fn managed_connect(
client: &ManagedClient,
state: &ManagedState,
arguments: &ManagedConnectArgs,
) -> Result<()> {
let selected = select_server(state, arguments.line_index, arguments.line_name.as_deref())?
.map_or_else(|| prompt_for_server(state), Ok)?;
println!("connecting to {} ({})", selected.name, selected.endpoint());
let mut config = ClientConfig::new(
selected.endpoint(),
client.provider().require_auth_verify_echo,
client.provider().xor_key_bytes,
);
if let Some(mtu) = arguments.mtu {
config.mtu = mtu;
}
if let Some(encryption) = arguments.encryption {
config.encryption = encryption;
}
let iwan_client = client.build_client(state, selected, config)?;
run_client(iwan_client, arguments.tun.as_deref(), &arguments.routes)
}
#[cfg(all(feature = "managed", feature = "http-proxy"))]
fn managed_serve(
client: &ManagedClient,
state: &ManagedState,
arguments: &ManagedServeArgs,
) -> Result<()> {
let selected = select_server(state, arguments.line_index, arguments.line_name.as_deref())?
.map_or_else(|| prompt_for_server(state), Ok)?;
println!("connecting to {} ({})", selected.name, selected.endpoint());
let mut config = ClientConfig::new(
selected.endpoint(),
client.provider().require_auth_verify_echo,
client.provider().xor_key_bytes,
);
if let Some(mtu) = arguments.mtu {
config.mtu = mtu;
}
if let Some(encryption) = arguments.encryption {
config.encryption = encryption;
}
let iwan_client = client.build_client(state, selected, config)?;
run_http_proxy(
iwan_client,
&arguments.proxy,
&client.provider().dns_servers,
)
}
#[cfg(feature = "managed")]
fn print_servers(state: &ManagedState) {
for (index, server) in state.servers.iter().enumerate() {
println!("{}. {} ({})", index + 1, server.name, server.endpoint());
}
}
#[cfg(feature = "managed")]
fn prompt_for_server(state: &ManagedState) -> Result<&ManagedServer> {
loop {
let value = prompt_line(&format!("Select line [1-{}]: ", state.servers.len()))?;
if let Ok(index) = value.parse::<usize>()
&& let Ok(Some(server)) = select_server(state, Some(index), None)
{
return Ok(server);
}
eprintln!("invalid line selection");
}
}
#[cfg(feature = "managed")]
fn prompt_line(prompt: &str) -> Result<String> {
print!("{prompt}");
std::io::stdout().flush()?;
let mut value = String::new();
std::io::stdin().read_line(&mut value)?;
let value = value.trim().to_owned();
if value.is_empty() {
return Err(Error::InvalidConfig("input must not be empty".into()));
}
Ok(value)
}
fn build_client(arguments: &ConnectionArgs) -> Result<Client> {
let mut config = if let Some(path) = &arguments.config {
let contents = fs::read_to_string(path)?;
toml::from_str::<ClientConfig>(&contents)
.map_err(|error| Error::InvalidConfig(format!("{}: {error}", path.display())))?
} else {
ClientConfig::new(
arguments
.server
.clone()
.ok_or_else(|| Error::InvalidConfig("--server or --config is required".into()))?,
true,
16,
)
};
if let Some(server) = &arguments.server {
config.server.clone_from(server);
}
if let Some(mtu) = arguments.mtu {
config.mtu = mtu;
}
if let Some(encryption) = arguments.encryption {
config.encryption = encryption;
}
let password = read_secret(arguments)?;
Client::new(config, arguments.username.clone(), password)
}
fn read_secret(arguments: &ConnectionArgs) -> Result<String> {
if let Some(path) = &arguments.password_file {
validate_secret_file(path)?;
let mut contents = fs::read_to_string(path)?;
let password = contents
.lines()
.next()
.map(str::to_owned)
.filter(|password| !password.is_empty())
.ok_or_else(|| Error::InvalidConfig("password file is empty".into()));
contents.zeroize();
return password;
}
if let Ok(password) = std::env::var(&arguments.password_env)
&& !password.is_empty()
{
return Ok(password);
}
prompt_password("iWAN password: ")
}
#[cfg(unix)]
fn validate_secret_file(path: &Path) -> Result<()> {
use std::os::unix::fs::PermissionsExt;
let mode = fs::metadata(path)?.permissions().mode();
if mode & 0o077 != 0 {
return Err(Error::InvalidConfig(format!(
"{} must not be accessible by group or other users",
path.display()
)));
}
Ok(())
}
#[cfg(not(unix))]
#[allow(clippy::unnecessary_wraps)]
fn validate_secret_file(_path: &Path) -> Result<()> {
Ok(())
}
fn prompt_password(prompt: &str) -> Result<String> {
let mut password = rpassword::prompt_password(prompt)?;
if password.is_empty() {
password.zeroize();
return Err(Error::InvalidConfig("password must not be empty".into()));
}
Ok(password)
}
fn decode(hex: &str) -> Result<()> {
let bytes = decode_hex(hex)?;
let packet = protocol::decode_packet(&bytes)?;
println!(
"type={} encryption={} session_id={} token={:#010x}",
packet.header.packet_type,
packet.header.encryption,
packet.header.session_id,
packet.header.token
);
println!("signature={}", packet.signature.is_some());
if matches!(
packet.header.packet_type,
protocol::PacketType::Open
| protocol::PacketType::OpenAck
| protocol::PacketType::OpenReject
) {
for attribute in Tlv::parse_all(&packet.body)? {
println!(
"tlv={} length={} value={}",
attribute.kind.name(),
attribute.value.len(),
encode_hex(&attribute.value)
);
}
} else {
println!("body={}", encode_hex(&packet.body));
}
Ok(())
}
fn decode_hex(value: &str) -> Result<Vec<u8>> {
let compact: String = value
.chars()
.filter(|character| !character.is_ascii_whitespace() && !matches!(character, ':' | '-'))
.collect();
if !compact.len().is_multiple_of(2) {
return Err(Error::InvalidConfig(
"hexadecimal input has an odd number of digits".into(),
));
}
(0..compact.len())
.step_by(2)
.map(|offset| {
u8::from_str_radix(&compact[offset..offset + 2], 16)
.map_err(|_| Error::InvalidConfig(format!("invalid hex at digit {offset}")))
})
.collect()
}
fn encode_hex(bytes: &[u8]) -> String {
use std::fmt::Write as _;
let mut output = String::with_capacity(bytes.len() * 2);
for byte in bytes {
let _ = write!(output, "{byte:02x}");
}
output
}
fn print_session(session: &openiwan::SessionInfo) {
println!("authenticated");
println!(" peer: {}", session.peer);
println!(" session: {:#06x}", session.session_id);
println!(" token: {:#010x}", session.token);
println!(" encryption: {}", session.encryption);
println!(" MTU: {}", session.mtu);
println!(
" address: {}",
session
.address
.map_or_else(|| "<none>".into(), |value| value.to_string())
);
println!(
" gateway: {}",
session
.gateway
.map_or_else(|| "<none>".into(), |value| value.to_string())
);
if !session.dns_servers.is_empty() {
println!(
" DNS: {}",
session
.dns_servers
.iter()
.map(ToString::to_string)
.collect::<Vec<_>>()
.join(", ")
);
}
}
fn init_logging(verbosity: u8) {
let default = match verbosity {
0 => "openiwan=info",
1 => "openiwan=debug",
_ => "openiwan=trace",
};
let filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new(default));
tracing_subscriber::fmt()
.with_env_filter(filter)
.with_target(false)
.compact()
.init();
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn hex_decoder_accepts_capture_formats() {
assert_eq!(decode_hex("11:22 aa-bb").unwrap(), [0x11, 0x22, 0xaa, 0xbb]);
assert!(decode_hex("abc").is_err());
}
#[test]
fn tun_name_is_optional_and_can_be_overridden() {
let base = [
"openiwan",
"connect",
"--server",
"192.0.2.10:6001",
"--username",
"alice",
];
let parsed = Cli::try_parse_from(base).unwrap();
assert!(matches!(
parsed.command,
Command::Connect(ConnectArgs { tun: None, .. })
));
let parsed = Cli::try_parse_from(
base.into_iter()
.chain(["--tun", "custom-tun"])
.collect::<Vec<_>>(),
)
.unwrap();
assert!(matches!(
parsed.command,
Command::Connect(ConnectArgs {
tun: Some(ref name),
..
}) if name == "custom-tun"
));
}
#[cfg(feature = "managed")]
#[test]
fn parses_managed_commands_and_rejects_conflicting_selectors() {
let parsed = Cli::try_parse_from([
"openiwan",
"managed",
"--provider",
"provider.toml",
"connect",
"--line-index",
"2",
"--route-ip",
"192.0.2.10",
])
.unwrap();
assert!(matches!(
parsed.command,
Command::Managed(ManagedArgs {
action: ManagedCommand::Connect(ManagedConnectArgs {
line_index: Some(2),
..
}),
..
})
));
assert!(
Cli::try_parse_from([
"openiwan",
"managed",
"--provider",
"provider.toml",
"connect",
"--line-index",
"1",
"--line-name",
"Education",
])
.is_err()
);
}
#[cfg(feature = "http-proxy")]
#[test]
fn parses_manual_route_free_proxy_without_tun_options() {
let parsed = Cli::try_parse_from([
"openiwan",
"serve",
"--server",
"192.0.2.10:6001",
"--username",
"alice",
"--upstream",
"https://api.example.test",
"--upstream-ip",
"192.0.2.25",
"--dns-mode",
"iwan",
"--dns-server",
"192.0.2.53",
"--listen",
"127.0.0.1:9080",
])
.unwrap();
assert!(matches!(
parsed.command,
Command::Serve(ServeArgs {
proxy: HttpProxyArgs {
listen,
upstream,
upstream_ips,
dns_mode: DnsModeArg::Iwan,
dns_servers,
..
},
..
}) if listen == "127.0.0.1:9080".parse().unwrap()
&& upstream == "https://api.example.test"
&& upstream_ips == vec!["192.0.2.25".parse::<IpAddr>().unwrap()]
&& dns_servers == vec!["192.0.2.53:53".parse::<SocketAddr>().unwrap()]
));
assert!(
Cli::try_parse_from([
"openiwan",
"serve",
"--server",
"192.0.2.10:6001",
"--username",
"alice",
"--upstream",
"https://api.example.test",
"--route",
"10.0.0.0/8",
])
.is_err()
);
}
#[cfg(all(feature = "managed", feature = "http-proxy"))]
#[test]
fn parses_managed_route_free_proxy() {
let parsed = Cli::try_parse_from([
"openiwan",
"managed",
"--provider",
"provider.toml",
"serve",
"--line-name",
"Education",
"--upstream",
"https://api.example.test",
])
.unwrap();
assert!(matches!(
parsed.command,
Command::Managed(ManagedArgs {
action: ManagedCommand::Serve(ManagedServeArgs {
line_name: Some(name),
..
}),
..
}) if name == "Education"
));
}
}