openiwan 0.2.0

An independently implemented iWAN client and protocol library
Documentation
use super::provider::ProviderConfig;
use super::store::ManagedServer;
use crate::{Error, Result};
use aes_gcm::aead::{Aead, KeyInit, Payload};
use aes_gcm::{Aes256Gcm, Nonce};
use base64::Engine;
use sha2::{Digest, Sha256};
use zeroize::Zeroizing;

pub fn decrypt_server_password(
    provider: &ProviderConfig,
    server: &ManagedServer,
) -> Result<Zeroizing<String>> {
    let mut key_input = format!(
        "{}|{}|{}",
        provider.controller.app_secret, provider.controller.domain, server.username
    );
    let key = Sha256::digest(key_input.as_bytes());
    zeroize::Zeroize::zeroize(&mut key_input);

    let encoded = &server.encrypted_password;
    let data = base64::engine::general_purpose::URL_SAFE_NO_PAD
        .decode(encoded)
        .or_else(|_| base64::engine::general_purpose::URL_SAFE.decode(encoded))
        .or_else(|_| base64::engine::general_purpose::STANDARD.decode(encoded))
        .map_err(|_| Error::Controller("line password is not valid base64".into()))?;
    if data.len() < 28 {
        return Err(Error::Controller(
            "encrypted line password is too short".into(),
        ));
    }
    let nonce = Nonce::from_slice(&data[..12]);
    let aad = format!("{}|{}", provider.controller.domain, server.username);
    let cipher = Aes256Gcm::new_from_slice(&key)
        .map_err(|_| Error::Crypto("invalid managed password key"))?;
    let plaintext = cipher
        .decrypt(
            nonce,
            Payload {
                msg: &data[12..],
                aad: aad.as_bytes(),
            },
        )
        .map_err(|_| Error::Controller("line password authentication failed".into()))?;
    let password = String::from_utf8(plaintext)
        .map_err(|_| Error::Controller("line password is not valid UTF-8".into()))?;
    Ok(Zeroizing::new(password))
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::managed::provider::{
        ControllerConfig, OidcConfig, PROVIDER_VERSION, TokenRequestFormat,
    };
    use aes_gcm::aead::Aead;
    use base64::engine::general_purpose::URL_SAFE_NO_PAD;

    fn provider() -> ProviderConfig {
        ProviderConfig {
            version: PROVIDER_VERSION,
            id: "test".into(),
            display_name: "Test".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: "app".into(),
                app_secret: "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 decrypts_and_authenticates_password() {
        let provider = provider();
        let username = "line-user";
        let key = Sha256::digest(
            format!(
                "{}|{}|{username}",
                provider.controller.app_secret, provider.controller.domain
            )
            .as_bytes(),
        );
        let cipher = Aes256Gcm::new_from_slice(&key).unwrap();
        let nonce = [7_u8; 12];
        let aad = format!("{}|{username}", provider.controller.domain);
        let encrypted = cipher
            .encrypt(
                Nonce::from_slice(&nonce),
                Payload {
                    msg: b"line-password",
                    aad: aad.as_bytes(),
                },
            )
            .unwrap();
        let mut wire = nonce.to_vec();
        wire.extend_from_slice(&encrypted);
        let server = ManagedServer {
            name: "Line".into(),
            host: "192.0.2.1".into(),
            port: 6001,
            username: username.into(),
            encrypted_password: URL_SAFE_NO_PAD.encode(wire),
        };

        assert_eq!(
            decrypt_server_password(&provider, &server)
                .unwrap()
                .as_str(),
            "line-password"
        );

        let mut tampered = server;
        tampered.encrypted_password.push('A');
        assert!(decrypt_server_password(&provider, &tampered).is_err());
    }
}