provider

Types

ProviderState

pub type ProviderState {
  ProviderState
}

Constructors

```
ProviderState
```

SecureContext

</>

pub type SecureContext {
  SecureContext
}

Constructors

```
SecureContext
```

Values

close

</>

pub fn close(state: ProviderState) -> Nil

Close the provider and release resources.

Called when the provider is shutting down. Implementations should clean up any allocated resources and zero sensitive memory.

decrypt

</>

pub fn decrypt(
  context: SecureContext,
  cipher: BitArray,
) -> Result(BitArray, String)

Decrypt ciphertext using a secure context.

Decrypts the given data using the established secure context.

Arguments

context - Secure context from completed handshake
cipher - Ciphertext data to decrypt

Returns

Ok(plaintext) - Decrypted data
Error(reason) - Decryption failed (e.g., tampered data)

encrypt

</>

pub fn encrypt(
  context: SecureContext,
  plain: BitArray,
) -> Result(BitArray, String)

Encrypt plaintext using a secure context.

Encrypts the given data using the established secure context.

Arguments

context - Secure context from completed handshake
plain - Plaintext data to encrypt

Returns

Ok(ciphertext) - Encrypted data
Error(reason) - Encryption failed

handle_key_exchange

</>

pub fn handle_key_exchange(
  state: ProviderState,
  incoming: BitArray,
) -> #(
  option.Option(BitArray),
  ProviderState,
  option.Option(SecureContext),
)

Handle an incoming key exchange message.

Processes a message from the peer during key exchange and returns the next state of the protocol.

Arguments

state - Current provider state
incoming - Message received from peer

Returns

Tuple of (optional_response, updated_state, optional_secure_context). When secure_context is Some, the handshake is complete.

init

</>

pub fn init() -> ProviderState

Initialize the provider state.

Called once when the provider is started. Implementations must allocate any required resources and prepare for key exchange operations.

Returns

Initial ProviderState for subsequent operations.

rekey

</>

pub fn rekey(
  context: SecureContext,
) -> Result(SecureContext, String)

Rotate the encryption key for a secure context.

Derives a new encryption key while maintaining the connection. The old key is discarded.

Arguments

context - Current secure context

Returns

Ok(new_context) - Context with new key material
Error(reason) - Rekey operation failed

start_key_exchange

</>

pub fn start_key_exchange(
  state: ProviderState,
  local_params: BitArray,
) -> #(BitArray, ProviderState)

Start a key exchange with local parameters.

Initiates the key exchange protocol by generating the first message to send to the peer.

Arguments

state - Current provider state
local_params - Local parameters for key exchange

Returns

Tuple of (outgoing_message, updated_state).