audio2face3d-server 0.1.0

Audio2Face-3D compatible gRPC server
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

use audio2face3d_server::auth::{
    AuthError, AuthRequest, AuthResult, Authenticator, Principal, validate_api_key,
};
use std::ffi::OsString;
use subtle::ConstantTimeEq;

/// The concrete single-key policy belongs to this executable.
pub(super) fn resolve(cli: Option<OsString>) -> Result<Option<impl Authenticator>, &'static str> {
    resolve_with(cli, || std::env::var_os("AUDIO2FACE3D_API_KEY"))
}
fn resolve_with(
    cli: Option<OsString>,
    environment: impl FnOnce() -> Option<OsString>,
) -> Result<Option<impl Authenticator>, &'static str> {
    let selected = cli.or_else(environment);
    let selected = selected
        .map(|value| {
            let key = value.into_string().map_err(|_| "API key must be Unicode")?;
            validate_api_key(&key).map_err(|_| "invalid API key format")?;
            Ok::<_, &'static str>(key)
        })
        .transpose()?;
    Ok(selected.map(|expected| {
        move |request: AuthRequest<'_>| -> AuthResult {
            if bool::from(
                expected
                    .as_bytes()
                    .ct_eq(request.api_key.expose().as_bytes()),
            ) {
                Principal::new("default")
            } else {
                Err(AuthError::InvalidCredential)
            }
        }
    }))
}
#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn precedence_missing_and_invalid_values() {
        assert!(resolve_with(None, || None).unwrap().is_none());
        assert!(
            resolve_with(Some("valid".into()), || panic!(
                "environment must not be read"
            ))
            .unwrap()
            .is_some()
        );
        assert!(
            resolve_with(None, || Some("valid".into()))
                .unwrap()
                .is_some()
        );
        for key in ["", " bad", "bad ", "bad,key", "bad=key"] {
            assert!(resolve_with(Some(key.into()), || Some("valid".into())).is_err());
            assert!(resolve_with(None, || Some(key.into())).is_err());
        }
        assert!(resolve_with(Some("x".repeat(4097).into()), || None).is_err());
        #[cfg(windows)]
        {
            use std::os::windows::ffi::OsStringExt;
            assert!(resolve_with(None, || Some(OsString::from_wide(&[0xd800]))).is_err());
        }
    }
}