Struct Session 

pub struct Session<S> { /* private fields */ }

Secure-channel session state.

The phantom parameter S tracks which step of the Annex D.4 handshake the session is in. Each transition consumes the old Session and yields a new one in the next state — calling methods out of order is therefore a compile error rather than a runtime fault.

stateDiagram-v2
    [*] --> Disconnected: Session::new(scbk)
    Disconnected --> Challenged: challenge(RND.A)
    Challenged --> Cryptogrammed: receive_ccrypt(ccrypt) ✔
    Challenged --> Disconnected: receive_ccrypt(ccrypt) ✘<br/>BadCryptogram
    Cryptogrammed --> Secure: confirm_rmac_i(mac) ✔
    Cryptogrammed --> Disconnected: confirm_rmac_i(mac) ✘<br/>BadCryptogram
    Secure --> Secure: mac() / verify()<br/>seal_data() / open_data()

All fields are zeroized when the session is dropped (regardless of which state it is in), so cancelled or panicking flows do not leave the SCBK or derived material in memory. Note that Clone is preserved for ergonomic fork-and-mirror flows: cloning duplicates the key material, and only the dropped clone is zeroized — the surviving clone still holds keys until it is dropped in turn.

Implementations

impl Session<Disconnected>

pub fn new(scbk: [u8; 16]) -> Self

Begin a new session, holding the SCBK we will use.

Example

use osdp::secure::{SCBK_D, Session};
use osdp::secure::session::Disconnected;
let session = Session::<Disconnected>::new(SCBK_D);
// The next step is `session.challenge(rnd_a)` once we've sent osdp_CHLNG.

pub fn challenge(self, rnd_a: [u8; 8]) -> Session<Challenged>

Move to Challenged by capturing the RND.A we are about to send.

impl Session<Challenged>

pub fn receive_ccrypt( self, ccrypt: &CCrypt, ) -> Result<Session<Cryptogrammed>, (Session<Disconnected>, SecureSessionError)>

Verify the PD’s CCrypt and move to Cryptogrammed.

impl Session<Cryptogrammed>

pub fn server_cryptogram(&self) -> [u8; 16]

Compute the server cryptogram to ship in osdp_SCRYPT.

pub fn initial_rmac(&self) -> [u8; 16]

Initial R-MAC, computed from S-MAC1/S-MAC2 over the server cryptogram.

pub fn confirm_rmac_i( self, their_rmac_i: &[u8; 16], ) -> Result<Session<Secure>, (Session<Disconnected>, SecureSessionError)>

PD echoed back our initial R-MAC; advance to fully Secure.

impl Session<Secure>

pub fn mac(&mut self, bytes: &[u8]) -> [u8; 16]

Compute the MAC trailer for an outgoing packet body.

bytes is the SOM..end-of-DATA region (as per super::mac::cbc_mac).

pub fn verify( &mut self, bytes: &[u8], wire_mac: &[u8; 4], ) -> Result<(), SecureSessionError>

Verify a received MAC against our locally-computed value.

pub fn keys(&self) -> &SessionKeys

Borrow the derived session keys (for AES-CBC DATA encryption).

pub fn last_other_mac(&self) -> &[u8; 16]

Last MAC the other end produced (used as encryption ICV per Annex D).

pub fn seal_data(&self, data: &[u8]) -> Vec<u8>

Encrypt data for an SCS_17/SCS_18 payload using the current ICV (!last_other_mac). Returns the ciphertext (always padded to a 16-byte multiple).

Spec: Annex D.5

pub fn open_data(&self, ct: &[u8]) -> Result<Vec<u8>, SecureSessionError>

Decrypt a payload received in an SCS_17/SCS_18 packet, validating the 0x80 padding.

Spec: Annex D.5

Trait Implementations

impl<S: Clone> Clone for Session<S>

fn clone(&self) -> Session<S>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S: Debug> Debug for Session<S>

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

Formats the value using the given formatter.

impl<S> Drop for Session<S>

fn drop(&mut self)

Executes the destructor for this type.

impl<S> Zeroize for Session<S>

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.