Data Structures
struct	crypto_session_message_t
struct	crypto_session
	For crypto session, this is the live record that ties owner, mutex, records, rotation together. The owning code creates it, updates it while work is active, and releases its handles and pointed-to storage before freeing the record. More...

Macros
#define	CRYPTO_SESSION_MESSAGES 16

Typedefs
typedef struct crypto_session	crypto_session_t
	For crypto session, this is the live record that ties owner, mutex, records, rotation together. The owning code creates it, updates it while work is active, and releases its handles and pointed-to storage before freeing the record.

Functions
asciichat_error_t	crypto_session_create (crypto_context_t *)
void	crypto_session_destroy (crypto_context_t *)
asciichat_error_t	crypto_session_lock (crypto_context_t , crypto_session_t *)
void	crypto_session_unlock (crypto_session_t *)
asciichat_error_t	crypto_session_tick (crypto_session_t *, uint64_t now_ns)
asciichat_error_t	crypto_session_receive (crypto_session_t , unsigned, unsigned, crypto_rekey_message_t, const void , size_t, uint64_t now_ns, bool *consumed)

Macro Definition Documentation

◆ CRYPTO_SESSION_MESSAGES

#define CRYPTO_SESSION_MESSAGES 16

Definition at line 5 of file include/ascii-chat/crypto/session.h.

Referenced by acip_security_flush(), and acip_security_next_control().

Typedef Documentation

◆ crypto_session_t

typedef struct crypto_session crypto_session_t

For crypto session, this is the live record that ties owner, mutex, records, rotation together. The owning code creates it, updates it while work is active, and releases its handles and pointed-to storage before freeing the record.

Function Documentation

◆ crypto_session_create()

asciichat_error_t crypto_session_create ( crypto_context_t * crypto )

Definition at line 19 of file lib/crypto/session.c.

                                                                  {
  if (!crypto || crypto->session)
    return SET_ERRNO(ERROR_INVALID_STATE, "Invalid security session owner");
  crypto_session_t *session = SAFE_CALLOC(1, sizeof(*session), crypto_session_t *);
  if (!session)
    return SET_ERRNO(ERROR_MEMORY, "Cannot allocate security session");
  if (mutex_init(&session->mutex, "crypto_session") != 0) {
    SAFE_FREE(session);
    return SET_ERRNO(ERROR_THREAD, "Cannot initialize security session mutex");
  }
  session->owner = crypto;
  crypto->session = session;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_STATE, ERROR_MEMORY, ERROR_THREAD, crypto_session::mutex, crypto_session::owner, SAFE_CALLOC, SAFE_FREE, crypto_context_t::session, and SET_ERRNO.

Referenced by crypto_init().

◆ crypto_session_destroy()

void crypto_session_destroy ( crypto_context_t * crypto )

Definition at line 34 of file lib/crypto/session.c.

                                                      {
  if (!crypto || !crypto->session)
    return;
  crypto_session_t *session = crypto->session;
  crypto->session = NULL;
  crypto_rekey_session_cleanup(&session->rotation);
  crypto_record_cleanup(&session->records);
  mutex_destroy(&session->mutex);
  sodium_memzero(session, sizeof(*session));
  SAFE_FREE(session);
}

References crypto_record_cleanup(), crypto_rekey_session_cleanup(), crypto_session::mutex, crypto_session::records, crypto_session::rotation, SAFE_FREE, and crypto_context_t::session.

Referenced by crypto_destroy().

◆ crypto_session_lock()

asciichat_error_t crypto_session_lock	(	crypto_context_t *	crypto,
		crypto_session_t **	output )

Lock and activate the common authenticated-record session. The caller must unlock on every successful return. No transport callbacks run under this lock.

Definition at line 46 of file lib/crypto/session.c.

                                                                                           {
  if (!crypto || !output || !crypto->session || crypto->session->owner != crypto)
    return SET_ERRNO(ERROR_INVALID_STATE, "Missing security session owner");
  crypto_session_t *session = crypto->session;
  mutex_lock(&session->mutex);
  if (!session->failure && !session->records.crypto) {
    bool server = crypto->server_role_known
                      ? crypto->server_role
                      : memcmp(crypto->public_key, crypto->peer_public_key, CRYPTO_PUBLIC_KEY_SIZE) > 0;
    session->failure = crypto_record_init(&session->records, crypto, server);
    if (!session->failure)
      session->failure =
          crypto_rekey_session_init(&session->rotation, &session->records, emit_message, session, time_get_ns());
  }
  if (session->failure) {
    asciichat_error_t result = session->failure;
    mutex_unlock(&session->mutex);
    return result;
  }
  *output = session;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, crypto_record::crypto, CRYPTO_PUBLIC_KEY_SIZE, crypto_record_init(), crypto_rekey_session_init(), ERROR_INVALID_STATE, crypto_session::failure, crypto_session::mutex, crypto_session::owner, crypto_context_t::peer_public_key, crypto_context_t::public_key, crypto_session::records, crypto_session::rotation, crypto_context_t::server_role, crypto_context_t::server_role_known, crypto_context_t::session, and SET_ERRNO.

Referenced by acip_packet_encrypt(), acip_packet_plan(), acip_security_activate(), acip_security_decrypt(), acip_security_next_control(), acip_security_request_rekey(), acip_security_seal(), browser_security_epoch(), browser_security_init(), browser_security_tick(), and quic_connection_enable_security().

◆ crypto_session_receive()

asciichat_error_t crypto_session_receive	(	crypto_session_t *	session,
		unsigned	channel,
		unsigned	delivery,
		crypto_rekey_message_t	type,
		const void *	payload,
		size_t	length,
		uint64_t	now_ns,
		bool *	consumed )

Definition at line 79 of file lib/crypto/session.c.

                                                         {
  if (!session->failure)
    session->failure =
        crypto_rekey_session_receive(&session->rotation, channel, delivery, type, payload, length, now, consumed);
  return session->failure;
}

References crypto_rekey_session_receive(), crypto_session::failure, and crypto_session::rotation.

Referenced by acip_security_decrypt().

◆ crypto_session_tick()

asciichat_error_t crypto_session_tick	(	crypto_session_t *	session,
		uint64_t	now_ns )

Definition at line 73 of file lib/crypto/session.c.

                                                                               {
  if (!session->failure)
    session->failure = crypto_rekey_session_tick(&session->rotation, now);
  return session->failure;
}

References crypto_rekey_session_tick(), crypto_session::failure, and crypto_session::rotation.

Referenced by acip_security_next_control(), and browser_security_tick().

◆ crypto_session_unlock()

void crypto_session_unlock ( crypto_session_t * session )

Definition at line 69 of file lib/crypto/session.c.

                                                      {
  mutex_unlock(&session->mutex);
}

References crypto_session::mutex.