TLA  Line data    Source code

       1                 : //! Simple Authentication and Security Layer.
       2                 : //!
       3                 : //! RFC: <https://datatracker.ietf.org/doc/html/rfc4422>.
       4                 : //!
       5                 : //! Reference implementation:
       6                 : //! * <https://github.com/postgres/postgres/blob/94226d4506e66d6e7cbf4b391f1e7393c1962841/src/backend/libpq/auth-sasl.c>
       7                 : //! * <https://github.com/postgres/postgres/blob/94226d4506e66d6e7cbf4b391f1e7393c1962841/src/interfaces/libpq/fe-auth.c>
       8                 : 
       9                 : mod channel_binding;
      10                 : mod messages;
      11                 : mod stream;
      12                 : 
      13                 : use crate::error::UserFacingError;
      14                 : use std::io;
      15                 : use thiserror::Error;
      16                 : 
      17                 : pub use channel_binding::ChannelBinding;
      18                 : pub use messages::FirstMessage;
      19                 : pub use stream::{Outcome, SaslStream};
      20                 : 
      21                 : /// Fine-grained auth errors help in writing tests.
      22 UBC           0 : #[derive(Error, Debug)]
      23                 : pub enum Error {
      24                 :     #[error("Channel binding failed: {0}")]
      25                 :     ChannelBindingFailed(&'static str),
      26                 : 
      27                 :     #[error("Unsupported channel binding method: {0}")]
      28                 :     ChannelBindingBadMethod(Box<str>),
      29                 : 
      30                 :     #[error("Bad client message: {0}")]
      31                 :     BadClientMessage(&'static str),
      32                 : 
      33                 :     #[error(transparent)]
      34                 :     Io(#[from] io::Error),
      35                 : }
      36                 : 
      37                 : impl UserFacingError for Error {
      38               0 :     fn to_string_client(&self) -> String {
      39               0 :         use Error::*;
      40               0 :         match self {
      41                 :             // TODO: add support for channel binding
      42               0 :             ChannelBindingFailed(_) => "channel binding is not supported yet".to_string(),
      43               0 :             ChannelBindingBadMethod(m) => format!("unsupported channel binding method {m}"),
      44               0 :             _ => "authentication protocol violation".to_string(),
      45                 :         }
      46               0 :     }
      47                 : }
      48                 : 
      49                 : /// A convenient result type for SASL exchange.
      50                 : pub type Result<T> = std::result::Result<T, Error>;
      51                 : 
      52                 : /// A result of one SASL exchange.
      53                 : #[must_use]
      54                 : pub enum Step<T, R> {
      55                 :     /// We should continue exchanging messages.
      56                 :     Continue(T, String),
      57                 :     /// The client has been authenticated successfully.
      58                 :     Success(R, String),
      59                 :     /// Authentication failed (reason attached).
      60                 :     Failure(&'static str),
      61                 : }
      62                 : 
      63                 : /// Every SASL mechanism (e.g. [SCRAM](crate::scram)) is expected to implement this trait.
      64                 : pub trait Mechanism: Sized {
      65                 :     /// What's produced as a result of successful authentication.
      66                 :     type Output;
      67                 : 
      68                 :     /// Produce a server challenge to be sent to the client.
      69                 :     /// This is how this method is called in PostgreSQL (`libpq/sasl.h`).
      70                 :     fn exchange(self, input: &str) -> Result<Step<Self, Self::Output>>;
      71                 : }