yubico 0.11.0

Yubikey client API library
Documentation 
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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

use reqwest::header::USER_AGENT;
use reqwest::Client;

use crate::config::Config;
use crate::yubicoerror::YubicoError;
use crate::{build_request, Request, Result};
use futures::stream::FuturesUnordered;
use futures::StreamExt;
use std::sync::Arc;

pub async fn verify_async<S>(otp: S, config: Config) -> Result<()>
where
    S: Into<String>,
{
    AsyncVerifier::new(config)?.verify(otp).await
}

pub struct AsyncVerifier {
    client: Client,
    config: Config,
}

impl AsyncVerifier {
    pub fn new(config: Config) -> Result<AsyncVerifier> {
        let client = 
            if config.proxy_url != "" && config.proxy_username == "" {
                AsyncVerifier::get_client_proxy(config.clone())?
            } else if config.proxy_url != "" && config.proxy_username != "" {
                AsyncVerifier::get_client_proxy_with_auth(config.clone())?
            } else {
                Client::builder().timeout(config.request_timeout).build()?
            };

        Ok(AsyncVerifier { client, config })
    }

    pub async fn verify<S>(&self, otp: S) -> Result<()>
    where
        S: Into<String>,
    {
        let request = Arc::new(build_request(otp, &self.config)?); // Arc because we need the future to be Send.

        let mut responses = FuturesUnordered::new();
        self.config
            .api_hosts
            .iter()
            .for_each(|api_host| responses.push(self.request(request.clone(), api_host)));

        let mut errors = vec![];

        while let Some(response) = responses.next().await {
            match response {
                Ok(()) => return Ok(()),
                Err(err @ YubicoError::ReplayedRequest) => errors.push(err),
                Err(YubicoError::HTTPStatusCode(code)) => {
                    errors.push(YubicoError::HTTPStatusCode(code))
                }
                Err(err) => return Err(err),
            }
        }

        Err(YubicoError::MultipleErrors(errors))
    }

    async fn request(&self, request: Arc<Request>, api_host: &str) -> Result<()> {
        let url = request.build_url(api_host);
        let http_request = self
            .client
            .get(&url)
            .header(USER_AGENT, self.config.user_agent.clone());

        let response = http_request.send().await?;
        let status_code = response.status();

        if !status_code.is_success() {
            return Err(YubicoError::HTTPStatusCode(status_code));
        }

        let text = response.text().await?;

        request.response_verifier.verify_response(text)
    }

    fn get_client_proxy(config: Config) -> Result<Client> {
        Ok(Client::builder()
            .timeout(config.request_timeout)
            .proxy(reqwest::Proxy::all(&config.proxy_url)?).build()?)
    }

    fn get_client_proxy_with_auth(config: Config) -> Result<Client> {
        let proxy = reqwest::Proxy::all(&config.proxy_url)?
            .basic_auth(&config.proxy_username, &config.proxy_password);
        Ok(Client::builder().timeout(config.request_timeout).proxy(proxy).build()?)
    }
}