use super::http::{HttpRequest, HttpTransport};
use super::oidc::OidcIdentity;
use super::provider::ProviderConfig;
use super::store::{ManagedServer, ManagedState, STATE_VERSION};
use crate::{Error, Result};
use hmac::{Hmac, Mac};
use rand::RngCore;
use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha256};
use std::fmt::Write as _;
use std::time::{SystemTime, UNIX_EPOCH};
use url::Url;
type HmacSha256 = Hmac<Sha256>;
#[derive(Clone, Serialize)]
struct DeviceRequest<'a> {
domain: &'a str,
#[serde(rename = "type")]
device_type: &'a str,
oem_name: &'a str,
device_id: &'a str,
#[serde(rename = "userName")]
username: &'a str,
serverlist_version: &'static str,
ipfilter_version: &'static str,
branding_version: &'static str,
}
#[derive(Deserialize)]
struct ConfigResponse {
serverlist: ServerList,
}
#[derive(Deserialize)]
struct ServerList {
serverlist: Vec<WireServer>,
}
#[derive(Deserialize)]
struct WireServer {
name: String,
#[serde(rename = "serverName")]
host: String,
#[serde(rename = "serverPort", deserialize_with = "deserialize_port")]
port: u16,
#[serde(rename = "userName")]
username: String,
#[serde(rename = "passWord")]
encrypted_password: String,
}
pub(crate) fn fetch<T: HttpTransport>(
provider: &ProviderConfig,
transport: &T,
identity: &OidcIdentity,
device_id: &str,
) -> Result<ManagedState> {
let request = DeviceRequest {
domain: &provider.controller.domain,
device_type: &provider.controller.device_type,
oem_name: &provider.controller.oem_name,
device_id,
username: &identity.username,
serverlist_version: "0",
ipfilter_version: "0",
branding_version: "0",
};
let auth_response = signed_post(
provider,
transport,
&provider.controller.auth_path,
&request,
&identity.access_token,
)?;
require_ok("auth", auth_response.status)?;
let keepalive = DeviceRequest {
device_type: "keepalive",
..request.clone()
};
let keepalive_response = signed_post(
provider,
transport,
&provider.controller.keepalive_path,
&keepalive,
&identity.access_token,
)?;
if keepalive_response.status != 200 {
tracing::warn!(
status = keepalive_response.status,
"controller keepalive returned a non-success status"
);
}
let response = signed_post(
provider,
transport,
&provider.controller.config_path,
&request,
&identity.access_token,
)?;
require_ok("config", response.status)?;
let response: ConfigResponse = serde_json::from_slice(&response.body)
.map_err(|error| Error::Controller(format!("invalid config response: {error}")))?;
let mut servers = Vec::with_capacity(response.serverlist.serverlist.len());
for server in response.serverlist.serverlist {
if server.name.trim().is_empty()
|| server.host.trim().is_empty()
|| server.port == 0
|| server.username.trim().is_empty()
|| server.encrypted_password.is_empty()
{
return Err(Error::Controller(
"controller returned an incomplete line".into(),
));
}
servers.push(ManagedServer {
name: server.name,
host: server.host,
port: server.port,
username: server.username,
encrypted_password: server.encrypted_password,
});
}
if servers.is_empty() {
return Err(Error::Controller(
"controller returned no available lines".into(),
));
}
let fetched_at_unix = SystemTime::now()
.duration_since(UNIX_EPOCH)
.map_err(|_| Error::Controller("system clock is before the Unix epoch".into()))?
.as_secs();
Ok(ManagedState {
version: STATE_VERSION,
provider_id: provider.id.clone(),
domain: provider.controller.domain.clone(),
device_id: device_id.into(),
fetched_at_unix,
servers,
})
}
fn signed_post<T: HttpTransport, B: Serialize>(
provider: &ProviderConfig,
transport: &T,
path: &str,
body: &B,
access_token: &str,
) -> Result<super::http::HttpResponse> {
let body = serde_json::to_vec(body)
.map_err(|error| Error::Controller(format!("serialize request: {error}")))?;
let timestamp = SystemTime::now()
.duration_since(UNIX_EPOCH)
.map_err(|_| Error::Controller("system clock is before the Unix epoch".into()))?
.as_secs()
.to_string();
let nonce = random_nonce();
let body_hash = hex_lower(&Sha256::digest(&body));
let canonical = format!("POST\n{path}\n\n{body_hash}\n{timestamp}\n{nonce}");
let mut mac = HmacSha256::new_from_slice(provider.controller.app_secret.as_bytes())
.map_err(|_| Error::Crypto("invalid controller HMAC key"))?;
mac.update(canonical.as_bytes());
let signature = hex_lower(&mac.finalize().into_bytes());
let base = Url::parse(&provider.controller.base_url)
.map_err(|error| Error::Controller(format!("invalid controller URL: {error}")))?;
let url = base
.join(path)
.map_err(|error| Error::Controller(format!("invalid controller path: {error}")))?;
transport.execute(HttpRequest {
method: "POST",
url: url.into(),
headers: vec![
("Content-Type".into(), "application/json".into()),
("Authorization".into(), format!("Bearer {access_token}")),
("X-Auth-AppId".into(), provider.controller.app_id.clone()),
("X-Auth-Timestamp".into(), timestamp),
("X-Auth-Nonce".into(), nonce),
("X-Auth-Sign".into(), signature),
],
body,
})
}
fn require_ok(operation: &str, status: u16) -> Result<()> {
if status == 200 {
Ok(())
} else {
Err(Error::Controller(format!(
"{operation} returned HTTP {status}"
)))
}
}
fn random_nonce() -> String {
let mut bytes = [0_u8; 16];
rand::rngs::OsRng.fill_bytes(&mut bytes);
let mut output = String::with_capacity(bytes.len() * 2);
for byte in bytes {
let _ = write!(output, "{byte:02X}");
}
output
}
fn hex_lower(bytes: &[u8]) -> String {
let mut output = String::with_capacity(bytes.len() * 2);
for byte in bytes {
let _ = write!(output, "{byte:02x}");
}
output
}
fn deserialize_port<'de, D>(deserializer: D) -> std::result::Result<u16, D::Error>
where
D: serde::Deserializer<'de>,
{
let value = serde_json::Value::deserialize(deserializer)?;
match value {
serde_json::Value::Number(number) => number
.as_u64()
.and_then(|port| u16::try_from(port).ok())
.filter(|port| *port != 0)
.ok_or_else(|| serde::de::Error::custom("invalid server port")),
serde_json::Value::String(port) => port
.parse::<u16>()
.ok()
.filter(|port| *port != 0)
.ok_or_else(|| serde::de::Error::custom("invalid server port")),
_ => Err(serde::de::Error::custom("invalid server port")),
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::managed::http::{HttpResponse, HttpTransport};
use crate::managed::provider::{
ControllerConfig, OidcConfig, PROVIDER_VERSION, TokenRequestFormat,
};
use std::collections::VecDeque;
use std::sync::Mutex;
use zeroize::Zeroizing;
#[derive(Default)]
struct MockTransport {
requests: Mutex<Vec<HttpRequest>>,
responses: Mutex<VecDeque<HttpResponse>>,
}
impl HttpTransport for MockTransport {
fn execute(&self, request: HttpRequest) -> Result<HttpResponse> {
self.requests.lock().unwrap().push(request);
self.responses
.lock()
.unwrap()
.pop_front()
.ok_or_else(|| Error::Http("missing mock response".into()))
}
}
fn provider() -> ProviderConfig {
ProviderConfig {
version: PROVIDER_VERSION,
id: "example".into(),
display_name: "Example".into(),
dns_servers: Vec::new(),
require_auth_verify_echo: false,
xor_key_bytes: 16,
oidc: OidcConfig {
issuer: "https://auth.example.test".into(),
client_id: "client".into(),
redirect_uri: "com.example://callback".into(),
scopes: vec!["openid".into()],
username_claims: vec!["sub".into()],
token_request_format: TokenRequestFormat::Json,
},
controller: ControllerConfig {
base_url: "https://controller.example.test".into(),
domain: "iwan.example".into(),
app_id: "controller-example".into(),
app_secret: "app-secret".into(),
auth_path: "/m/auth".into(),
keepalive_path: "/m/keepalive".into(),
config_path: "/m/config".into(),
device_type: "android".into(),
oem_name: "example-oem".into(),
},
}
}
#[test]
fn fetches_typed_lines_with_signed_requests() {
let transport = MockTransport::default();
let mut responses = transport.responses.lock().unwrap();
responses.push_back(HttpResponse {
status: 200,
body: b"{}".to_vec(),
});
responses.push_back(HttpResponse {
status: 204,
body: Vec::new(),
});
responses.push_back(HttpResponse {
status: 200,
body: serde_json::to_vec(&serde_json::json!({
"serverlist": {
"serverlist": [{
"name": "Education",
"serverName": "192.0.2.10",
"serverPort": "6001",
"userName": "line-user",
"passWord": "encrypted"
}]
}
}))
.unwrap(),
});
drop(responses);
let provider = provider();
let identity = OidcIdentity {
access_token: Zeroizing::new("access-token".into()),
username: "alice".into(),
};
let state = fetch(&provider, &transport, &identity, "0011223344556677").unwrap();
assert_eq!(state.provider_id, "example");
assert_eq!(state.servers[0].port, 6001);
let requests = transport.requests.lock().unwrap();
assert_eq!(requests.len(), 3);
for request in requests.iter() {
assert!(
request
.headers
.iter()
.any(|(name, value)| name == "Authorization" && value == "Bearer access-token")
);
assert!(
request
.headers
.iter()
.any(|(name, value)| name == "X-Auth-Sign" && value.len() == 64)
);
let timestamp = header(request, "X-Auth-Timestamp");
let nonce = header(request, "X-Auth-Nonce");
let body_hash = hex_lower(&Sha256::digest(&request.body));
let path = Url::parse(&request.url).unwrap().path().to_owned();
let canonical = format!("POST\n{path}\n\n{body_hash}\n{timestamp}\n{nonce}");
let mut mac = HmacSha256::new_from_slice(b"app-secret").unwrap();
mac.update(canonical.as_bytes());
assert_eq!(
header(request, "X-Auth-Sign"),
hex_lower(&mac.finalize().into_bytes())
);
}
assert!(String::from_utf8_lossy(&requests[1].body).contains("\"type\":\"keepalive\""));
}
fn header<'a>(request: &'a HttpRequest, name: &str) -> &'a str {
request
.headers
.iter()
.find_map(|(candidate, value)| (candidate == name).then_some(value.as_str()))
.unwrap()
}
}