rekey.c File Reference

Go to the source code of this file.

Macros
#define	CRYPTO_REKEY_TIMEOUT_NS   (30ULL * NS_PER_SEC_INT)

Functions
asciichat_error_t	crypto_rekey_session_init (crypto_rekey_session_t *s, crypto_record_t *security, crypto_rekey_emit_fn send, void *context, uint64_t now)
asciichat_error_t	crypto_rekey_session_tick (crypto_rekey_session_t *s, uint64_t now)
asciichat_error_t	crypto_rekey_session_request (crypto_rekey_session_t *s, uint64_t now)
asciichat_error_t	crypto_rekey_session_receive (crypto_rekey_session_t *s, unsigned flow, unsigned delivery, crypto_rekey_message_t type, const void *payload, size_t bytes, uint64_t now, bool *consumed)
void	crypto_rekey_session_cleanup (crypto_rekey_session_t *s)

Macro Definition Documentation

CRYPTO_REKEY_TIMEOUT_NS

#define CRYPTO_REKEY_TIMEOUT_NS   (30ULL * NS_PER_SEC_INT)

Definition at line 6 of file rekey.c.

Referenced by crypto_rekey_session_tick().

Function Documentation

crypto_rekey_session_cleanup()

void crypto_rekey_session_cleanup

(

crypto_rekey_session_t *

s

)

Definition at line 203 of file rekey.c.

                                                             {
  if (!s)
    return;
  if (s->exchange_ns && s->security && s->security->crypto && s->security->crypto->rekey_in_progress)
    crypto_rekey_abort(s->security->crypto);
  sodium_memzero(s, sizeof(*s));
}

References crypto_record::crypto, crypto_rekey_abort(), crypto_rekey_session_t::exchange_ns, crypto_context_t::rekey_in_progress, and crypto_rekey_session_t::security.

Referenced by crypto_session_destroy().

crypto_rekey_session_init()

asciichat_error_t crypto_rekey_session_init	(	crypto_rekey_session_t *	s,
		crypto_record_t *	security,
		crypto_rekey_emit_fn	send,
		void *	context,
		uint64_t	now_ns )

The caller serializes access with the associated record context.

Definition at line 53 of file rekey.c.

                                                                                                    {
  if (!s || s->security || !security || !security->crypto || !send || now == UINT64_MAX)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid session rekey initialization");
  *s = (crypto_rekey_session_t){.security = security,
                                .send = send,
                                .context = context,
                                .activated_ns = now,
                                .last_ns = now,
                                .seen_epoch = security->key_epoch,
                                .peer_ack = security->key_epoch};
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, crypto_record::crypto, ERROR_INVALID_PARAM, crypto_record::key_epoch, crypto_rekey_session_t::security, and SET_ERRNO.

Referenced by crypto_session_lock().

crypto_rekey_session_receive()

asciichat_error_t crypto_rekey_session_receive	(	crypto_rekey_session_t *	s,
		unsigned	flow,
		unsigned	delivery,
		crypto_rekey_message_t	type,
		const void *	payload,
		size_t	bytes,
		uint64_t	now,
		bool *	consumed )

Definition at line 127 of file rekey.c.

                                                                             {
  if (!consumed || (!payload && bytes) || flow >= CRYPTO_RECORD_CHANNELS || type > CRYPTO_REKEY_NEEDED)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid rekey input");
  *consumed = false;
  asciichat_error_t result = clock_step(s, now);
  if (result != ASCIICHAT_OK)
    return result;
  result = observe_epoch(s);
  if (result != ASCIICHAT_OK)
    return result;
  if (type == CRYPTO_REKEY_NONE)
    return crypto_rekey_session_tick(s, now);
  *consumed = true;
  uint64_t epoch = s->security->key_epoch;
  if (delivery != CRYPTO_RECORD_RELIABLE || s->security->last_receive_epoch != epoch ||
      (type != CRYPTO_REKEY_MARKER && flow != 0))
    return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "session rekey message has invalid flow, delivery, or epoch");
  crypto_context_t *crypto = s->security->crypto;
  if (type == CRYPTO_REKEY_MARKER || type == CRYPTO_REKEY_ACK) {
    uint64_t value;
    if (bytes != sizeof(value))
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid session epoch marker length");
    memcpy(&value, payload, sizeof(value));
    if (!epoch || NET_TO_HOST_U64(value) != epoch || !s->markers_sent)
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Unexpected session epoch marker");
    if (type == CRYPTO_REKEY_MARKER) {
      if (!s->security->previous_valid || !s->security->previous_allowed[flow])
        return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Duplicate session flow retirement marker");
      result = crypto_record_retire_epoch_flow(s->security, flow, epoch);
    } else {
      s->peer_ack = epoch;
    }
  } else if (type == CRYPTO_REKEY_NEEDED) {
    if (!s->security->server || bytes)
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid session rekey request signal");
    if (!s->exchange_ns)
      s->requested = true;
  } else if (type == CRYPTO_REKEY_REQUEST) {
    if (s->security->server || bytes != CRYPTO_PUBLIC_KEY_SIZE || s->waiting_response || s->expecting_complete ||
        s->deferred_request || s->security->previous_valid || s->security->pending_prepared || s->peer_ack != epoch)
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Unexpected session ephemeral rekey request");
    s->exchange_ns = now;
    s->remote_requested = false;
    s->deferred_request = true;
    memcpy(s->deferred_key, payload, sizeof(s->deferred_key));
  } else if (type == CRYPTO_REKEY_RESPONSE) {
    if (!s->security->server || !s->waiting_response || bytes != CRYPTO_PUBLIC_KEY_SIZE)
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Unexpected session ephemeral rekey response");
    if (crypto_rekey_process_response(crypto, payload) != CRYPTO_OK)
      return SET_ERRNO(ERROR_CRYPTO, "Cannot compute session next epoch");
    result = crypto_record_prepare_epoch(s->security);
    if (result == ASCIICHAT_OK)
      result = crypto_record_commit_epoch(s->security);
    if (result == ASCIICHAT_OK) {
      s->waiting_response = false;
      s->activated_ns = now;
      uint8_t proof = 0;
      result = send_rekey_packet(s, 0, CRYPTO_REKEY_COMPLETE, &proof, 1);
    }
  } else {
    if (s->security->server || !s->expecting_complete || bytes != 1 || ((const uint8_t *)payload)[0] || !epoch ||
        s->security->pending_prepared)
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Unexpected session rekey confirmation");
    s->expecting_complete = false;
    s->activated_ns = now;
  }
  if (result != ASCIICHAT_OK)
    return result;
  result = observe_epoch(s);
  if (result != ASCIICHAT_OK)
    return result;
  return crypto_rekey_session_tick(s, now);
}

References crypto_rekey_session_t::activated_ns, ASCIICHAT_OK, crypto_record::crypto, CRYPTO_OK, CRYPTO_PUBLIC_KEY_SIZE, CRYPTO_RECORD_CHANNELS, crypto_record_commit_epoch(), crypto_record_prepare_epoch(), CRYPTO_RECORD_RELIABLE, crypto_record_retire_epoch_flow(), CRYPTO_REKEY_ACK, CRYPTO_REKEY_COMPLETE, CRYPTO_REKEY_MARKER, CRYPTO_REKEY_NEEDED, CRYPTO_REKEY_NONE, crypto_rekey_process_response(), CRYPTO_REKEY_REQUEST, CRYPTO_REKEY_RESPONSE, crypto_rekey_session_tick(), crypto_rekey_session_t::deferred_key, crypto_rekey_session_t::deferred_request, ERROR_CRYPTO, ERROR_INVALID_PARAM, ERROR_NETWORK_PROTOCOL, crypto_rekey_session_t::exchange_ns, crypto_rekey_session_t::expecting_complete, crypto_record::key_epoch, crypto_record::last_receive_epoch, crypto_rekey_session_t::markers_sent, NET_TO_HOST_U64, crypto_rekey_session_t::peer_ack, crypto_record::pending_prepared, crypto_record::previous_allowed, crypto_record::previous_valid, crypto_rekey_session_t::remote_requested, crypto_rekey_session_t::requested, crypto_rekey_session_t::security, crypto_record::server, SET_ERRNO, and crypto_rekey_session_t::waiting_response.

Referenced by acip_security_rekey_receive(), and crypto_session_receive().

crypto_rekey_session_request()

asciichat_error_t crypto_rekey_session_request	(	crypto_rekey_session_t *	s,
		uint64_t	now )

Definition at line 118 of file rekey.c.

                                                                                        {
  asciichat_error_t result = clock_step(s, now);
  if (result != ASCIICHAT_OK)
    return result;
  if (!s->exchange_ns)
    s->requested = true;
  return crypto_rekey_session_tick(s, now);
}

References ASCIICHAT_OK, crypto_rekey_session_tick(), crypto_rekey_session_t::exchange_ns, and crypto_rekey_session_t::requested.

Referenced by acip_security_request_rekey().

crypto_rekey_session_tick()

asciichat_error_t crypto_rekey_session_tick	(	crypto_rekey_session_t *	s,
		uint64_t	now )

Definition at line 72 of file rekey.c.

                                                                                     {
  asciichat_error_t result = clock_step(s, now);
  if (result != ASCIICHAT_OK)
    return result;
  result = observe_epoch(s);
  if (result != ASCIICHAT_OK)
    return result;
  if (s->exchange_ns && now - s->exchange_ns > CRYPTO_REKEY_TIMEOUT_NS)
    return SET_ERRNO(ERROR_NETWORK_TIMEOUT, "session key exchange or flow retirement timed out");
  // A peer measures its interval at send time. Keep one authenticated request
  // until our receive-side interval elapses; network jitter must not turn a
  // valid rotation into a protocol violation or bypass the rate limit.
  if (s->deferred_request && request_allowed(s, now)) {
    crypto_context_t *crypto = s->security->crypto;
    s->deferred_request = false;
    s->expecting_complete = true;
    s->last_request_ns = now;
    if (crypto_rekey_init(crypto) != CRYPTO_OK || crypto_rekey_process_request(crypto, s->deferred_key) != CRYPTO_OK)
      return SET_ERRNO(ERROR_CRYPTO, "Cannot compute session rekey response");
    sodium_memzero(s->deferred_key, sizeof(s->deferred_key));
    result = crypto_record_prepare_epoch(s->security);
    if (result == ASCIICHAT_OK)
      result = send_rekey_packet(s, 0, CRYPTO_REKEY_RESPONSE, crypto->temp_public_key, CRYPTO_PUBLIC_KEY_SIZE);
    return result;
  }
  if (!settled(s) || !request_allowed(s, now))
    return ASCIICHAT_OK;
  crypto_context_t *crypto = s->security->crypto;
  bool threshold =
      crypto->rekey_packet_count >= crypto->rekey_packet_threshold ||
      (crypto->rekey_time_threshold > 0 && now - s->activated_ns >= (uint64_t)crypto->rekey_time_threshold);
  if (!s->requested && !threshold)
    return ASCIICHAT_OK;
  s->requested = false;
  s->exchange_ns = now;
  if (!s->security->server) {
    s->remote_requested = true;
    return send_rekey_packet(s, 0, CRYPTO_REKEY_NEEDED, NULL, 0);
  }
  if (crypto_rekey_init(crypto) != CRYPTO_OK)
    return SET_ERRNO(ERROR_CRYPTO, "Cannot initiate session ephemeral rekey");
  s->waiting_response = true;
  s->last_request_ns = now;
  return send_rekey_packet(s, 0, CRYPTO_REKEY_REQUEST, crypto->temp_public_key, CRYPTO_PUBLIC_KEY_SIZE);
}

References crypto_rekey_session_t::activated_ns, ASCIICHAT_OK, crypto_record::crypto, CRYPTO_OK, CRYPTO_PUBLIC_KEY_SIZE, crypto_record_prepare_epoch(), crypto_rekey_init(), CRYPTO_REKEY_NEEDED, crypto_rekey_process_request(), CRYPTO_REKEY_REQUEST, CRYPTO_REKEY_RESPONSE, CRYPTO_REKEY_TIMEOUT_NS, crypto_rekey_session_t::deferred_key, crypto_rekey_session_t::deferred_request, ERROR_CRYPTO, ERROR_NETWORK_TIMEOUT, crypto_rekey_session_t::exchange_ns, crypto_rekey_session_t::expecting_complete, crypto_rekey_session_t::last_request_ns, crypto_context_t::rekey_packet_count, crypto_context_t::rekey_packet_threshold, crypto_context_t::rekey_time_threshold, crypto_rekey_session_t::remote_requested, crypto_rekey_session_t::requested, crypto_rekey_session_t::security, crypto_record::server, SET_ERRNO, crypto_context_t::temp_public_key, and crypto_rekey_session_t::waiting_response.

Referenced by crypto_rekey_session_receive(), crypto_rekey_session_request(), and crypto_session_tick().