Struct ServerCtx 

pub struct ServerCtx { /* private fields */ }

The server side of a security context

Implementations

impl ServerCtx

pub fn new(cred: Option<Cred>) -> ServerCtx

Create a new uninitialized server context with the specified credentials. You must then call step until the context is fully initialized. The mechanism is not specified because it is dictated by the client.

Examples found in repository

examples/krb5.rs (line 99)

fn setup_server_ctx(
    service_name: &[u8],
    desired_mechs: &OidSet
) -> Result<(ServerCtx, Name), Error> {
    println!("import name");
    let name = Name::new(service_name, Some(&GSS_NT_HOSTBASED_SERVICE))?;
    let cname = name.canonicalize(Some(&GSS_MECH_KRB5))?;
    println!("canonicalize name for kerberos 5");
    println!("server name: {}, server cname: {}", name, cname);
    let server_cred = Cred::acquire(
        Some(&cname), None, CredUsage::Accept, Some(desired_mechs)
    )?;
    println!("acquired server credentials: {:#?}", server_cred.info()?);
    Ok((ServerCtx::new(Some(server_cred)), cname))
}

pub fn step(&mut self, tok: &[u8]) -> Result<Option<Buf>, Error>

Perform 1 step in the initialization of the server context, feeding it a token you received from the client. If initialization is complete from the point of view of the server then this will return Ok(None). Otherwise it will return a token that needs to be sent to the client and fed to ClientCtx::step.

Examples found in repository

examples/krb5.rs (line 127)

fn run(service_name: &[u8]) -> Result<(), Error> {
    let desired_mechs = {
        let mut s = OidSet::new()?;
        s.add(&GSS_MECH_KRB5)?;
        s
    };
    let (mut server_ctx, cname) = setup_server_ctx(service_name, &desired_mechs)?;
    let mut client_ctx = setup_client_ctx(cname, &desired_mechs)?;
    let mut server_tok: Option<Buf> = None;
    loop {
        match client_ctx.step(server_tok.as_ref().map(|b| &**b), None)? {
            None => break,
            Some(client_tok) => match server_ctx.step(&*client_tok)? {
                None => break,
                Some(tok) => { server_tok = Some(tok); }
            }
        }
    }
    println!("security context initialized successfully");
    println!("client ctx info: {:#?}", client_ctx.info()?);
    println!("server ctx info: {:#?}", server_ctx.info()?);
    let secret_msg = client_ctx.wrap(true, b"super secret message")?;
    let decoded_msg = server_ctx.unwrap(&*secret_msg)?;
    println!("the decrypted message is: '{}'", String::from_utf8_lossy(&*decoded_msg));
    Ok(())
}

pub fn delegated_cred(&self) -> Option<&Cred>

pub fn take_delegated_cred(&mut self) -> Option<Cred>

Trait Implementations

impl Debug for ServerCtx

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for ServerCtx

fn drop(&mut self)

Executes the destructor for this type.

impl SecurityContext for ServerCtx

fn wrap(&mut self, encrypt: bool, msg: &[u8]) -> Result<Buf, Error>

Wrap a message with optional encryption. If encrypt is true then only the other side of the context can read the message. In any case the other side can always verify message integrity.

fn wrap_iov( &mut self, encrypt: bool, msg: &mut [GssIov<'_>], ) -> Result<(), Error>

From the MIT kerberos documentation,

fn wrap_iov_length( &mut self, encrypt: bool, msg: &mut [GssIovFake], ) -> Result<(), Error>

This will set the required length of all the buffers except the data buffer, which must be provided as it will be to wrap_iov. The value of the encrypt flag must match what you pass to wrap_iov.

fn unwrap(&mut self, msg: &[u8]) -> Result<Buf, Error>

Unwrap a wrapped message, checking it’s integrity and decrypting it if necessary.

fn unwrap_iov(&mut self, msg: &mut [GssIov<'_>]) -> Result<(), Error>

From the MIT Kerberos documentation,

fn info(&mut self) -> Result<CtxInfo, Error>

Get all information about a security context in one call

fn source_name(&mut self) -> Result<Name, Error>

Get the source name of the security context

fn target_name(&mut self) -> Result<Name, Error>

Get the target name of the security context

fn lifetime(&mut self) -> Result<Duration, Error>

Get the lifetime of the security context

fn mechanism(&mut self) -> Result<&'static Oid, Error>

Get the mechanism of the security context

fn flags(&mut self) -> Result<CtxFlags, Error>

Get the flags of the security context

fn local(&mut self) -> Result<bool, Error>

Return true if the security context was locally initiated

fn open(&mut self) -> Result<bool, Error>

Return true if the security context is open

fn is_complete(&self) -> bool

Return true if the security context is fully initialized

impl Send for ServerCtx

impl Sync for ServerCtx