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

use alloc::str::Utf8Error;
use thiserror::Error;

#[derive(Debug, Error)]
pub enum ParseError {
    #[error("input is missing a required part")]
    MissingPart,
    #[error("final terminator is missing. Incomplete input?")]
    MissingEnd,
    #[error("required 'auth' field is missing")]
    MissingToken,
    #[error("gs2-header is invalid")]
    InvalidGs2,
    #[error("OAUTHBEARER can't support channel bindings")]
    ChannelBindings,
    #[error("K/V pair is invalid")]
    InvalidKVPair,
    #[error("Invalid UTF-8")]
    InvalidUtf8(
        #[from]
        #[source]
        Utf8Error,
    ),
}

pub struct OAuthBearerMsg<'a> {
    pub authzid: Option<&'a str>,
    pub token: &'a str,
    pub fields: Vec<(&'a str, &'a str)>,
}

impl<'a> OAuthBearerMsg<'a> {
    pub fn parse(bytes: &'a [u8]) -> Result<Self, ParseError> {
        // Make sure the token isn't trimmed but contains the end bytes
        if let Some(bytes) = bytes.strip_suffix(b"\x01\x01") {
            let mut it = bytes.split(|b| matches!(b, b'\x01'));
            let gs2 = it.next().ok_or(ParseError::MissingPart)?;
            let mut gs2iter = gs2.split(|b| matches!(b, b','));
            let gs2_first = gs2iter.next().ok_or(ParseError::InvalidGs2)?;
            if gs2_first != b"n" {
                return Err(ParseError::ChannelBindings);
            }
            let gs2_authzid = gs2iter.next().ok_or(ParseError::InvalidGs2)?;

            let authzid = if gs2_authzid.is_empty() {
                None
            } else if let Some(rem) = gs2_authzid.strip_prefix(b"a=") {
                Some(core::str::from_utf8(rem)?)
            } else {
                return Err(ParseError::InvalidGs2);
            };

            let mut token = None;
            let mut fields = Vec::new();

            for kv in it {
                if let Some(t) = kv.strip_prefix(b"auth=") {
                    token = Some(core::str::from_utf8(t)?);
                } else {
                    let mut kviter = kv.split(|b| matches!(b, b'='));
                    let key = kviter.next().ok_or(ParseError::InvalidKVPair)?;
                    let val = kviter.next().ok_or(ParseError::InvalidKVPair)?;
                    if kviter.next().is_some() {
                        return Err(ParseError::InvalidKVPair);
                    }
                    let key = core::str::from_utf8(key)?;
                    let val = core::str::from_utf8(val)?;
                    fields.push((key, val));
                }
            }

            let token = token.ok_or(ParseError::MissingToken)?;
            Ok(Self {
                authzid,
                token,
                fields,
            })
        } else {
            Err(ParseError::MissingEnd)
        }
    }
}