rsasl 2.3.0

The Rust SASL framework, aimed at both middleware-style protocol implementation and application code. Designed to make SASL authentication simple and safe while handing as much control to the user as possible.
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

use crate::context::EmptyProvider;
use crate::error::SessionError;
use crate::mechanism::{Authentication, MechanismData, State};
use crate::mechanisms::oauthbearer::properties::{Error, OAuthBearerErrored};
use crate::property::{AuthzId, OAuthBearerKV, OAuthBearerToken};
use crate::session::MessageSent;
use crate::vectored_io::VectoredWriter;
use crate::io::Write;

#[derive(Debug, Default, Clone)]
pub struct OAuthBearer {
    state: OAuthBearerState,
}

#[derive(Debug, Clone, Default)]
enum OAuthBearerState {
    #[default]
    Initial,
    WaitingServerResponse,
    Done,
}

impl Authentication for OAuthBearer {
    fn step(
        &mut self,
        session: &mut MechanismData,
        input: Option<&[u8]>,
        writer: &mut dyn Write,
    ) -> Result<State, SessionError> {
        match self.state {
            OAuthBearerState::Initial => {
                writer.write_all(b"n,")?;
                session.maybe_need_with::<AuthzId, _, _>(&EmptyProvider, |authzid| {
                    writer.write_all(b"a=")?;
                    writer.write_all(authzid.as_bytes())?;
                    Ok(())
                })?;
                writer.write_all(b",")?;

                session.maybe_need_with::<OAuthBearerKV, _, _>(&EmptyProvider, |kvpairs| {
                    for (k, v) in kvpairs {
                        let data = [b"\x01", k.as_bytes(), b"=", v.as_bytes()];
                        let mut vecw = VectoredWriter::new(data);
                        vecw.write_all_vectored(&mut *writer)?;
                    }
                    Ok(())
                })?;

                session.need_with::<OAuthBearerToken, _, _>(&EmptyProvider, |token| {
                    let data = [b"\x01auth=Bearer ", token.as_bytes(), b"\x01\x01"];
                    let mut vecw = VectoredWriter::new(data);
                    vecw.write_all_vectored(writer)?;
                    Ok(())
                })?;

                self.state = OAuthBearerState::WaitingServerResponse;

                Ok(State::Running)
            }
            OAuthBearerState::WaitingServerResponse => {
                // whatever happens, afterwards this mechanisms won't be stepable again, so we
                // can set to done right here too
                self.state = OAuthBearerState::Done;

                let input = input.unwrap_or(&[]);
                // Empty case is specifically *no error message*. So yeah, that's finished then?
                // Most protocols will indicate success via the protocol immediately so this
                // should only be hit if we get protocol handlers being cautious and calling step in
                // that case too. Which, granted, is a good thing! We want that!
                if input.is_empty() {
                    return Ok(State::Finished(MessageSent::No));
                }

                let error = serde_json::from_slice(input).map_err(Error::Serde)?;

                // If the user callback *doesn't*, we must error, so '?' is correct.
                session.action::<OAuthBearerErrored>(&EmptyProvider, &error)?;
                Ok(State::Finished(MessageSent::Yes))
            }
            OAuthBearerState::Done => Err(SessionError::MechanismDone),
        }
    }
}