common.h File Reference

Common declarations and data structures for cryptographic handshake. More...

Go to the source code of this file.

Data Structures
struct	crypto_handshake_context_t
	Cryptographic handshake context structure. More...

Macros
Authentication Requirement Flags
Flags sent in AUTH_CHALLENGE packet to indicate server requirements.
#define	AUTH_REQUIRE_PASSWORD   0x01
	Server requires password authentication.
#define	AUTH_REQUIRE_CLIENT_KEY   0x02
	Server requires client key authentication (whitelist)

Typedefs
typedef struct crypto_handshake_context_t	crypto_handshake_context_t
	Cryptographic handshake context structure.

Enumerations
enum	crypto_handshake_state_t {   CRYPTO_HANDSHAKE_DISABLED = 0 , CRYPTO_HANDSHAKE_INIT , CRYPTO_HANDSHAKE_KEY_EXCHANGE , CRYPTO_HANDSHAKE_AUTHENTICATING ,   CRYPTO_HANDSHAKE_READY , CRYPTO_HANDSHAKE_FAILED }
	Cryptographic handshake state enumeration. More...

Functions
Common Handshake Functions
asciichat_error_t	crypto_handshake_init (const char *name, crypto_handshake_context_t *ctx, bool is_server)
	Initialize named crypto handshake context.
asciichat_error_t	crypto_handshake_set_parameters (crypto_handshake_context_t *ctx, const crypto_parameters_packet_t *params)
	Set crypto parameters from crypto_parameters_packet_t.
asciichat_error_t	crypto_handshake_validate_packet_size (const crypto_handshake_context_t *ctx, uint16_t packet_type, size_t packet_size)
	Validate crypto packet size based on session parameters.
asciichat_error_t	crypto_handshake_init_with_password (const char *name, crypto_handshake_context_t *ctx, bool is_server, const char *password)
	Initialize named crypto handshake context with password authentication.
void	crypto_handshake_destroy (crypto_handshake_context_t *ctx)
	Cleanup crypto handshake context with secure memory wiping.
bool	crypto_handshake_is_ready (const crypto_handshake_context_t *ctx)
	Check if handshake is complete and encryption is ready.
const crypto_context_t *	crypto_handshake_get_context (const crypto_handshake_context_t *ctx)
	Get the crypto context for encryption/decryption.
asciichat_error_t	crypto_handshake_encrypt_packet (const crypto_handshake_context_t *ctx, const uint8_t *plaintext, size_t plaintext_len, uint8_t *ciphertext, size_t ciphertext_size, size_t *ciphertext_len)
	Encrypt a packet using the established crypto context.
asciichat_error_t	crypto_handshake_decrypt_packet (const crypto_handshake_context_t *ctx, const uint8_t *ciphertext, size_t ciphertext_len, uint8_t *plaintext, size_t plaintext_size, size_t *plaintext_len)
	Decrypt a packet using the established crypto context.
asciichat_error_t	crypto_encrypt_packet_or_passthrough (const crypto_handshake_context_t *ctx, bool crypto_ready, const uint8_t *plaintext, size_t plaintext_len, uint8_t *ciphertext, size_t ciphertext_size, size_t *ciphertext_len)
	Encrypt with automatic passthrough if crypto not ready.
asciichat_error_t	crypto_decrypt_packet_or_passthrough (const crypto_handshake_context_t *ctx, bool crypto_ready, const uint8_t *ciphertext, size_t ciphertext_len, uint8_t *plaintext, size_t plaintext_size, size_t *plaintext_len)
	Decrypt with automatic passthrough if crypto not ready.
Session Rekeying Functions
asciichat_error_t	crypto_handshake_rekey_request (crypto_handshake_context_t *ctx, struct acip_transport *transport)
	Send REKEY_REQUEST packet (initiator side)
asciichat_error_t	crypto_handshake_rekey_response (crypto_handshake_context_t *ctx, struct acip_transport *transport)
	Send REKEY_RESPONSE packet (responder side)
asciichat_error_t	crypto_handshake_rekey_complete (crypto_handshake_context_t *ctx, struct acip_transport *transport)
	Send REKEY_COMPLETE packet (initiator side)
asciichat_error_t	crypto_handshake_process_rekey_request (crypto_handshake_context_t *ctx, const uint8_t *packet, size_t packet_len)
	Process received REKEY_REQUEST packet (responder side)
asciichat_error_t	crypto_handshake_process_rekey_response (crypto_handshake_context_t *ctx, const uint8_t *packet, size_t packet_len)
	Process received REKEY_RESPONSE packet (initiator side)
asciichat_error_t	crypto_handshake_process_rekey_complete (crypto_handshake_context_t *ctx, const uint8_t *packet, size_t packet_len)
	Process received REKEY_COMPLETE packet (responder side)
bool	crypto_handshake_should_rekey (const crypto_handshake_context_t *ctx)
	Check if rekeying should be triggered for this handshake context.

Detailed Description

Common declarations and data structures for cryptographic handshake.

Definition in file crypto/handshake/common.h.

Macro Definition Documentation

AUTH_REQUIRE_CLIENT_KEY

#define AUTH_REQUIRE_CLIENT_KEY   0x02

Server requires client key authentication (whitelist)

Definition at line 28 of file crypto/handshake/common.h.

AUTH_REQUIRE_PASSWORD

#define AUTH_REQUIRE_PASSWORD   0x01

Server requires password authentication.

Definition at line 26 of file crypto/handshake/common.h.

Function Documentation

crypto_decrypt_packet_or_passthrough()

asciichat_error_t crypto_decrypt_packet_or_passthrough	(	const crypto_handshake_context_t *	ctx,
		bool	crypto_ready,
		const uint8_t *	ciphertext,
		size_t	ciphertext_len,
		uint8_t *	plaintext,
		size_t	plaintext_size,
		size_t *	plaintext_len
	)

Decrypt with automatic passthrough if crypto not ready.

Parameters

ctx	Handshake context
crypto_ready	True if crypto is ready, false to passthrough
ciphertext	Ciphertext or plaintext data to decrypt
ciphertext_len	Length of ciphertext/plaintext data
plaintext	Output buffer for plaintext
plaintext_size	Size of output buffer
plaintext_len	Output parameter for actual plaintext length

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 365 of file crypto/handshake/common.c.

                                                                              {
  if (!crypto_ready) {
    // No encryption - just copy data
    if (ciphertext_len > plaintext_size) {
      SET_ERRNO(ERROR_BUFFER, "Ciphertext too large for plaintext buffer: %zu > %zu", ciphertext_len, plaintext_size);
      return ERROR_BUFFER;
    }
    memcpy(plaintext, ciphertext, ciphertext_len);
    *plaintext_len = ciphertext_len;
    return ASCIICHAT_OK;
  }
 
  return crypto_handshake_decrypt_packet(ctx, ciphertext, ciphertext_len, plaintext, plaintext_size, plaintext_len);
}

References ASCIICHAT_OK, crypto_handshake_decrypt_packet(), ERROR_BUFFER, and SET_ERRNO.

Referenced by crypto_client_decrypt_packet(), and crypto_server_decrypt_packet().

crypto_encrypt_packet_or_passthrough()

asciichat_error_t crypto_encrypt_packet_or_passthrough	(	const crypto_handshake_context_t *	ctx,
		bool	crypto_ready,
		const uint8_t *	plaintext,
		size_t	plaintext_len,
		uint8_t *	ciphertext,
		size_t	ciphertext_size,
		size_t *	ciphertext_len
	)

Encrypt with automatic passthrough if crypto not ready.

Parameters

ctx	Handshake context
crypto_ready	True if crypto is ready, false to passthrough
plaintext	Plaintext data to encrypt
plaintext_len	Length of plaintext data
ciphertext	Output buffer for ciphertext or plaintext (if passthrough)
ciphertext_size	Size of output buffer
ciphertext_len	Output parameter for actual length

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 346 of file crypto/handshake/common.c.

                                                                               {
  if (!crypto_ready) {
    // No encryption - just copy data
    if (plaintext_len > ciphertext_size) {
      SET_ERRNO(ERROR_BUFFER, "Plaintext too large for ciphertext buffer: %zu > %zu", plaintext_len, ciphertext_size);
      return ERROR_BUFFER;
    }
    memcpy(ciphertext, plaintext, plaintext_len);
    *ciphertext_len = plaintext_len;
    return ASCIICHAT_OK;
  }
 
  return crypto_handshake_encrypt_packet(ctx, plaintext, plaintext_len, ciphertext, ciphertext_size, ciphertext_len);
}

References ASCIICHAT_OK, crypto_handshake_encrypt_packet(), ERROR_BUFFER, and SET_ERRNO.

Referenced by crypto_client_encrypt_packet(), and crypto_server_encrypt_packet().

crypto_handshake_decrypt_packet()

asciichat_error_t crypto_handshake_decrypt_packet	(	const crypto_handshake_context_t *	ctx,
		const uint8_t *	ciphertext,
		size_t	ciphertext_len,
		uint8_t *	plaintext,
		size_t	plaintext_size,
		size_t *	plaintext_len
	)

Decrypt a packet using the established crypto context.

Parameters

ctx	Handshake context (must be ready)
ciphertext	Ciphertext data to decrypt
ciphertext_len	Length of ciphertext data
plaintext	Output buffer for plaintext
plaintext_size	Size of output buffer
plaintext_len	Output parameter for actual plaintext length

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 328 of file crypto/handshake/common.c.

                                                                         {
  if (!ctx || !crypto_handshake_is_ready(ctx)) {
    SET_ERRNO(ERROR_INVALID_STATE, "Invalid state: ctx=%p, ready=%d", ctx, ctx ? crypto_handshake_is_ready(ctx) : 0);
    return ERROR_INVALID_STATE;
  }
 
  crypto_result_t result = crypto_decrypt((crypto_context_t *)&ctx->crypto_ctx, ciphertext, ciphertext_len, plaintext,
                                          plaintext_size, plaintext_len);
  if (result != CRYPTO_OK) {
    return SET_ERRNO(ERROR_NETWORK, "Failed to decrypt packet: %s", crypto_result_to_string(result));
  }
 
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, crypto_handshake_context_t::crypto_ctx, crypto_decrypt(), crypto_handshake_is_ready(), CRYPTO_OK, crypto_result_to_string(), ERROR_INVALID_STATE, ERROR_NETWORK, and SET_ERRNO.

Referenced by crypto_decrypt_packet_or_passthrough().

crypto_handshake_destroy()

void crypto_handshake_destroy

(

crypto_handshake_context_t *

ctx

)

Cleanup crypto handshake context with secure memory wiping.

Parameters

ctx	Handshake context to cleanup

Definition at line 284 of file crypto/handshake/common.c.

                                                               {
  if (!ctx)
    return;
 
  // Cleanup core crypto context
  crypto_destroy(&ctx->crypto_ctx);
 
  // Zero out sensitive data
  sodium_memzero(ctx, sizeof(crypto_handshake_context_t));
}

References crypto_handshake_context_t::crypto_ctx, and crypto_destroy().

Referenced by acds_client_disconnect(), client_cleanup(), client_crypto_init(), client_generate_keypair(), client_handle_crypto_parameters(), client_handle_key_exchange_init(), crypto_client_cleanup(), crypto_server_cleanup_client(), remove_client(), and server_connection_close().

crypto_handshake_encrypt_packet()

asciichat_error_t crypto_handshake_encrypt_packet	(	const crypto_handshake_context_t *	ctx,
		const uint8_t *	plaintext,
		size_t	plaintext_len,
		uint8_t *	ciphertext,
		size_t	ciphertext_size,
		size_t *	ciphertext_len
	)

Encrypt a packet using the established crypto context.

Parameters

ctx	Handshake context (must be ready)
plaintext	Plaintext data to encrypt
plaintext_len	Length of plaintext data
ciphertext	Output buffer for ciphertext
ciphertext_size	Size of output buffer
ciphertext_len	Output parameter for actual ciphertext length

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 310 of file crypto/handshake/common.c.

                                                                          {
  if (!ctx || !crypto_handshake_is_ready(ctx)) {
    SET_ERRNO(ERROR_INVALID_STATE, "Invalid state: ctx=%p, ready=%d", ctx, ctx ? crypto_handshake_is_ready(ctx) : 0);
    return ERROR_INVALID_STATE;
  }
 
  crypto_result_t result = crypto_encrypt((crypto_context_t *)&ctx->crypto_ctx, plaintext, plaintext_len, ciphertext,
                                          ciphertext_size, ciphertext_len);
  if (result != CRYPTO_OK) {
    return SET_ERRNO(ERROR_NETWORK, "Failed to encrypt packet: %s", crypto_result_to_string(result));
  }
 
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, crypto_handshake_context_t::crypto_ctx, crypto_encrypt(), crypto_handshake_is_ready(), CRYPTO_OK, crypto_result_to_string(), ERROR_INVALID_STATE, ERROR_NETWORK, and SET_ERRNO.

Referenced by crypto_encrypt_packet_or_passthrough().

crypto_handshake_get_context()

const crypto_context_t * crypto_handshake_get_context

(

const crypto_handshake_context_t *

ctx

)

Get the crypto context for encryption/decryption.

Parameters

ctx	Handshake context

Returns

Pointer to crypto context, or NULL if ctx is NULL

Definition at line 303 of file crypto/handshake/common.c.

                                                                                            {
  if (!ctx || !crypto_handshake_is_ready(ctx))
    return NULL;
  return &ctx->crypto_ctx;
}

References crypto_handshake_context_t::crypto_ctx, and crypto_handshake_is_ready().

Referenced by broadcast_server_state_to_all_clients(), crypto_client_get_context(), crypto_server_get_context(), disconnect_client_for_bad_data(), and server_crypto_handshake().

crypto_handshake_init()

asciichat_error_t crypto_handshake_init	(	const char *	name,
		crypto_handshake_context_t *	ctx,
		bool	is_server
	)

Initialize named crypto handshake context.

Parameters

name	Debug name for the crypto context (typically "crypto_client_<id>")
ctx	Handshake context to initialize (must not be NULL)
is_server	True if this is the server side, false for client

Returns

ASCIICHAT_OK on success, error code on failure

The context is automatically registered with the debug naming system.

Definition at line 20 of file crypto/handshake/common.c.

                                                                                                           {
  if (!name) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Crypto context name is required");
  }
 
  if (!ctx) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters: ctx=%p", ctx);
  }
 
  // Register crypto context with debug naming system
  NAMED_REGISTER_CRYPTO_CONTEXT(ctx, name, NULL);
 
  // Zero out the context
  memset(ctx, 0, sizeof(crypto_handshake_context_t));
 
  // Initialize core crypto context
#ifndef NDEBUG
  log_info("★★★ BEFORE crypto_init()");
  debug_sync_print_state();
#endif
  crypto_result_t result = crypto_init(&ctx->crypto_ctx);
#ifndef NDEBUG
  log_info("★★★ AFTER crypto_init(), result=%d", result);
  debug_sync_print_state();
#endif
  if (result != CRYPTO_OK) {
    return SET_ERRNO(ERROR_CRYPTO, "Failed to initialize crypto context: %s", crypto_result_to_string(result));
  }
 
  ctx->state = CRYPTO_HANDSHAKE_INIT;
  ctx->is_server = is_server;
  ctx->verify_server_key = false;
  ctx->require_client_auth = false;
  ctx->server_uses_client_auth = false; // Set to true only if authenticated packet received
 
  // Load server keys if this is a server
  if (is_server) {
    log_dev("Server crypto handshake initialized (ephemeral keys)");
  } else {
    log_dev("Client crypto handshake initialized");
  }
 
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, crypto_handshake_context_t::crypto_ctx, CRYPTO_HANDSHAKE_INIT, crypto_init(), CRYPTO_OK, crypto_result_to_string(), debug_sync_print_state(), ERROR_CRYPTO, ERROR_INVALID_PARAM, crypto_handshake_context_t::is_server, log_dev, log_info, NAMED_REGISTER_CRYPTO_CONTEXT, crypto_handshake_context_t::require_client_auth, crypto_handshake_context_t::server_uses_client_auth, SET_ERRNO, crypto_handshake_context_t::state, and crypto_handshake_context_t::verify_server_key.

Referenced by acds_client_handler(), acds_websocket_client_handler(), client_crypto_init(), client_generate_keypair(), client_handle_crypto_parameters(), client_handle_key_exchange_init(), discovery_session_start(), and server_crypto_handshake().

crypto_handshake_init_with_password()

asciichat_error_t crypto_handshake_init_with_password	(	const char *	name,
		crypto_handshake_context_t *	ctx,
		bool	is_server,
		const char *	password
	)

Initialize named crypto handshake context with password authentication.

Parameters

name	Debug name for the crypto context (typically "crypto_client_<id>")
ctx	Handshake context to initialize (must not be NULL)
is_server	True if this is the server side, false for client
password	Password for authentication (must meet length requirements)

Returns

ASCIICHAT_OK on success, error code on failure

The context is automatically registered with the debug naming system.

Definition at line 247 of file crypto/handshake/common.c.

                                                                            {
  if (!name) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Crypto context name is required");
  }
 
  if (!ctx || !password) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters: ctx=%p, password=%p", ctx, password);
  }
 
  // Register crypto context with debug naming system
  NAMED_REGISTER_CRYPTO_CONTEXT(ctx, name, NULL);
 
  // Zero out the context
  memset(ctx, 0, sizeof(crypto_handshake_context_t));
 
  // Initialize core crypto context with password
  crypto_result_t result = crypto_init_with_password(&ctx->crypto_ctx, password);
  if (result != CRYPTO_OK) {
    return SET_ERRNO(ERROR_CRYPTO, "Failed to initialize crypto context with password: %s",
                     crypto_result_to_string(result));
  }
 
  ctx->state = CRYPTO_HANDSHAKE_INIT;
  ctx->is_server = is_server;
  ctx->verify_server_key = false;
  ctx->require_client_auth = false;
  ctx->server_uses_client_auth = false; // Set to true only if authenticated packet received
  ctx->has_password = true;
 
  // Store password temporarily (will be cleared after key derivation)
  SAFE_STRNCPY(ctx->password, password, sizeof(ctx->password) - 1);
 
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, crypto_handshake_context_t::crypto_ctx, CRYPTO_HANDSHAKE_INIT, crypto_init_with_password(), CRYPTO_OK, crypto_result_to_string(), ERROR_CRYPTO, ERROR_INVALID_PARAM, crypto_handshake_context_t::has_password, crypto_handshake_context_t::is_server, NAMED_REGISTER_CRYPTO_CONTEXT, crypto_handshake_context_t::password, crypto_handshake_context_t::require_client_auth, SAFE_STRNCPY, crypto_handshake_context_t::server_uses_client_auth, SET_ERRNO, crypto_handshake_context_t::state, and crypto_handshake_context_t::verify_server_key.

Referenced by client_crypto_init(), and server_crypto_handshake().

crypto_handshake_is_ready()

bool crypto_handshake_is_ready

(

const crypto_handshake_context_t *

ctx

)

Check if handshake is complete and encryption is ready.

Parameters

ctx	Handshake context

Returns

true if handshake is complete and encryption is ready, false otherwise

Definition at line 296 of file crypto/handshake/common.c.

                                                                      {
  if (!ctx)
    return false;
  return ctx->state == CRYPTO_HANDSHAKE_READY && crypto_is_ready(&ctx->crypto_ctx);
}

References crypto_handshake_context_t::crypto_ctx, CRYPTO_HANDSHAKE_READY, crypto_is_ready(), and crypto_handshake_context_t::state.

Referenced by add_client(), client_send_thread_func(), crypto_client_is_ready(), crypto_handshake_decrypt_packet(), crypto_handshake_encrypt_packet(), crypto_handshake_get_context(), crypto_handshake_process_rekey_complete(), crypto_handshake_process_rekey_request(), crypto_handshake_process_rekey_response(), crypto_handshake_rekey_complete(), crypto_handshake_rekey_request(), crypto_handshake_rekey_response(), crypto_handshake_should_rekey(), and crypto_server_is_ready().

crypto_handshake_process_rekey_complete()

asciichat_error_t crypto_handshake_process_rekey_complete	(	crypto_handshake_context_t *	ctx,
		const uint8_t *	packet,
		size_t	packet_len
	)

Process received REKEY_COMPLETE packet (responder side)

Parameters

ctx	Crypto handshake context (must be ready)
packet	Encrypted packet (empty payload, encrypted with NEW key)
packet_len	Packet length

Returns

ASCIICHAT_OK on success, error code on failure

Process received REKEY_COMPLETE packet (responder side). Verifies that the packet decrypts with the new shared secret. If successful, commits to the new key.

Definition at line 589 of file crypto/handshake/common.c.

                                                                             {
  if (!ctx || !crypto_handshake_is_ready(ctx)) {
    return SET_ERRNO(ERROR_INVALID_STATE, "Handshake not ready for rekeying: ctx=%p, ready=%d", ctx,
                     ctx ? crypto_handshake_is_ready(ctx) : 0);
  }
 
  if (!ctx->crypto_ctx.rekey_in_progress || !ctx->crypto_ctx.has_temp_key) {
    return SET_ERRNO(ERROR_INVALID_STATE, "No rekey in progress or temp key missing");
  }
 
  log_debug("Received REKEY_COMPLETE packet (%zu bytes), verifying with NEW key", packet_len);
 
  // Temporarily swap keys to decrypt with NEW key
  uint8_t old_shared_key[CRYPTO_SHARED_KEY_SIZE];
  memcpy(old_shared_key, ctx->crypto_ctx.shared_key, CRYPTO_SHARED_KEY_SIZE);
  memcpy(ctx->crypto_ctx.shared_key, ctx->crypto_ctx.temp_shared_key, CRYPTO_SHARED_KEY_SIZE);
 
  // Attempt to decrypt with NEW key
  uint8_t plaintext[256];
  size_t plaintext_len = 0;
  crypto_result_t result =
      crypto_decrypt(&ctx->crypto_ctx, packet, packet_len, plaintext, sizeof(plaintext), &plaintext_len);
 
  // Restore old key immediately
  memcpy(ctx->crypto_ctx.shared_key, old_shared_key, CRYPTO_SHARED_KEY_SIZE);
  sodium_memzero(old_shared_key, sizeof(old_shared_key));
 
  if (result != CRYPTO_OK) {
    crypto_rekey_abort(&ctx->crypto_ctx);
    return SET_ERRNO(ERROR_CRYPTO, "REKEY_COMPLETE decryption failed (key mismatch): %s",
                     crypto_result_to_string(result));
  }
 
  log_debug("REKEY_COMPLETE verified successfully, committing to new key");
 
  // Commit to new key (atomic switch)
  result = crypto_rekey_commit(&ctx->crypto_ctx);
  if (result != CRYPTO_OK) {
    return SET_ERRNO(ERROR_CRYPTO, "Failed to commit rekey: %s", crypto_result_to_string(result));
  }
 
  log_debug("Session rekeying completed successfully (responder side)");
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, crypto_handshake_context_t::crypto_ctx, crypto_decrypt(), crypto_handshake_is_ready(), CRYPTO_OK, crypto_rekey_abort(), crypto_rekey_commit(), crypto_result_to_string(), CRYPTO_SHARED_KEY_SIZE, ERROR_CRYPTO, ERROR_INVALID_STATE, crypto_context_t::has_temp_key, log_debug, crypto_context_t::rekey_in_progress, SET_ERRNO, crypto_context_t::shared_key, and crypto_context_t::temp_shared_key.

crypto_handshake_process_rekey_request()

asciichat_error_t crypto_handshake_process_rekey_request	(	crypto_handshake_context_t *	ctx,
		const uint8_t *	packet,
		size_t	packet_len
	)

Process received REKEY_REQUEST packet (responder side)

Parameters

ctx	Crypto handshake context (must be ready)
packet	Packet payload (32-byte public key)
packet_len	Packet length (should be 32)

Returns

ASCIICHAT_OK on success, error code on failure

Process received REKEY_REQUEST packet (responder side). Extracts peer's new ephemeral public key and computes new shared secret.

Definition at line 503 of file crypto/handshake/common.c.

                                                                            {
  if (!ctx || !crypto_handshake_is_ready(ctx)) {
    return SET_ERRNO(ERROR_INVALID_STATE, "Handshake not ready for rekeying: ctx=%p, ready=%d", ctx,
                     ctx ? crypto_handshake_is_ready(ctx) : 0);
  }
 
  // DDoS PROTECTION: Rate limit rekey requests
  time_t now = time(NULL);
  if (ctx->crypto_ctx.rekey_last_request_time > 0) {
    time_t elapsed = now - ctx->crypto_ctx.rekey_last_request_time;
    time_t min_request_interval_seconds = (time_t)(REKEY_MIN_REQUEST_INTERVAL / NS_PER_SEC_INT);
    if (elapsed < min_request_interval_seconds) {
      return SET_ERRNO(ERROR_CRYPTO,
                       "SECURITY: Rekey request rejected - too frequent (%ld sec since last, minimum %ld sec required)",
                       (long)elapsed, (long)min_request_interval_seconds);
    }
  }
 
  // Update last request time
  ctx->crypto_ctx.rekey_last_request_time = now;
 
  // Validate packet size (should be 32 bytes for X25519 public key)
  if (packet_len != CRYPTO_PUBLIC_KEY_SIZE) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid REKEY_REQUEST packet size: %zu (expected %d)", packet_len,
                     CRYPTO_PUBLIC_KEY_SIZE);
  }
 
  log_debug("Received REKEY_REQUEST with peer's new ephemeral public key (32 bytes)");
 
  // Initialize our rekey process (generates our new ephemeral keypair)
  crypto_result_t result = crypto_rekey_init(&ctx->crypto_ctx);
  if (result != CRYPTO_OK) {
    return SET_ERRNO(ERROR_CRYPTO, "Failed to initialize rekey: %s", crypto_result_to_string(result));
  }
 
  // Process peer's public key and compute new shared secret
  result = crypto_rekey_process_request(&ctx->crypto_ctx, packet);
  if (result != CRYPTO_OK) {
    crypto_rekey_abort(&ctx->crypto_ctx);
    return SET_ERRNO(ERROR_CRYPTO, "Failed to process REKEY_REQUEST: %s", crypto_result_to_string(result));
  }
 
  log_debug("REKEY_REQUEST processed successfully, new shared secret computed (responder side)");
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, crypto_handshake_context_t::crypto_ctx, crypto_handshake_is_ready(), CRYPTO_OK, CRYPTO_PUBLIC_KEY_SIZE, crypto_rekey_abort(), crypto_rekey_init(), crypto_rekey_process_request(), crypto_result_to_string(), ERROR_CRYPTO, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, log_debug, NS_PER_SEC_INT, crypto_context_t::rekey_last_request_time, REKEY_MIN_REQUEST_INTERVAL, and SET_ERRNO.

Referenced by crypto_client_process_rekey_request().

crypto_handshake_process_rekey_response()

asciichat_error_t crypto_handshake_process_rekey_response	(	crypto_handshake_context_t *	ctx,
		const uint8_t *	packet,
		size_t	packet_len
	)

Process received REKEY_RESPONSE packet (initiator side)

Parameters

ctx	Crypto handshake context (must be ready)
packet	Packet payload (32-byte public key)
packet_len	Packet length (should be 32)

Returns

ASCIICHAT_OK on success, error code on failure

Process received REKEY_RESPONSE packet (initiator side). Extracts peer's new ephemeral public key and computes new shared secret.

Definition at line 554 of file crypto/handshake/common.c.

                                                                             {
  if (!ctx || !crypto_handshake_is_ready(ctx)) {
    return SET_ERRNO(ERROR_INVALID_STATE, "Handshake not ready for rekeying: ctx=%p, ready=%d", ctx,
                     ctx ? crypto_handshake_is_ready(ctx) : 0);
  }
 
  // Validate packet size (should be 32 bytes for X25519 public key)
  if (packet_len != CRYPTO_PUBLIC_KEY_SIZE) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid REKEY_RESPONSE packet size: %zu (expected %d)", packet_len,
                     CRYPTO_PUBLIC_KEY_SIZE);
  }
 
  if (!ctx->crypto_ctx.rekey_in_progress || !ctx->crypto_ctx.has_temp_key) {
    return SET_ERRNO(ERROR_INVALID_STATE, "No rekey in progress or temp key missing");
  }
 
  log_debug("Received REKEY_RESPONSE with peer's new ephemeral public key (32 bytes)");
 
  // Process peer's public key and compute new shared secret
  crypto_result_t result = crypto_rekey_process_response(&ctx->crypto_ctx, packet);
  if (result != CRYPTO_OK) {
    crypto_rekey_abort(&ctx->crypto_ctx);
    return SET_ERRNO(ERROR_CRYPTO, "Failed to process REKEY_RESPONSE: %s", crypto_result_to_string(result));
  }
 
  log_debug("REKEY_RESPONSE processed successfully, new shared secret computed (initiator side)");
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, crypto_handshake_context_t::crypto_ctx, crypto_handshake_is_ready(), CRYPTO_OK, CRYPTO_PUBLIC_KEY_SIZE, crypto_rekey_abort(), crypto_rekey_process_response(), crypto_result_to_string(), ERROR_CRYPTO, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, crypto_context_t::has_temp_key, log_debug, crypto_context_t::rekey_in_progress, and SET_ERRNO.

Referenced by crypto_client_process_rekey_response().

crypto_handshake_rekey_complete()

asciichat_error_t crypto_handshake_rekey_complete	(	crypto_handshake_context_t *	ctx,
		acip_transport_t *	transport
	)

Send REKEY_COMPLETE packet (initiator side)

Parameters

ctx	Crypto handshake context (must be ready)
transport	Transport to send on

Returns

ASCIICHAT_OK on success, error code on failure

Send REKEY_COMPLETE packet (initiator side). Note: This packet is encrypted with the new shared secret. It proves that both sides have computed the same shared secret.

Definition at line 454 of file crypto/handshake/common.c.

                                                                                                                {
  if (!ctx || !crypto_handshake_is_ready(ctx)) {
    return SET_ERRNO(ERROR_INVALID_STATE, "Handshake not ready for rekeying: ctx=%p, ready=%d", ctx,
                     ctx ? crypto_handshake_is_ready(ctx) : 0);
  }
  if (!transport) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Transport is NULL");
  }
 
  if (!ctx->crypto_ctx.rekey_in_progress || !ctx->crypto_ctx.has_temp_key) {
    return SET_ERRNO(ERROR_INVALID_STATE, "No rekey in progress or temp key missing");
  }
 
  // Encrypt empty payload with NEW key to prove possession
  uint8_t plaintext[1] = {0}; // Minimal payload
 
  // Temporarily swap keys to encrypt with NEW key
  uint8_t old_shared_key[CRYPTO_SHARED_KEY_SIZE];
  memcpy(old_shared_key, ctx->crypto_ctx.shared_key, CRYPTO_SHARED_KEY_SIZE);
  memcpy(ctx->crypto_ctx.shared_key, ctx->crypto_ctx.temp_shared_key, CRYPTO_SHARED_KEY_SIZE);
 
  // Restore old key immediately after the transport send completes.
  // The transport encrypts the packet using the active shared key, so we
  // keep the temporary key installed only for the duration of this send.
  asciichat_error_t send_result =
      packet_send_via_transport(transport, PACKET_TYPE_CRYPTO_REKEY_COMPLETE, plaintext, sizeof(plaintext), 0);
 
  memcpy(ctx->crypto_ctx.shared_key, old_shared_key, CRYPTO_SHARED_KEY_SIZE);
  sodium_memzero(old_shared_key, sizeof(old_shared_key));
 
  if (send_result != ASCIICHAT_OK) {
    crypto_rekey_abort(&ctx->crypto_ctx);
    return SET_ERRNO(ERROR_NETWORK, "Failed to send REKEY_COMPLETE packet");
  }
 
  // Commit to new key (atomic switch)
  crypto_result_t commit_result = crypto_rekey_commit(&ctx->crypto_ctx);
  if (commit_result != CRYPTO_OK) {
    return SET_ERRNO(ERROR_CRYPTO, "Failed to commit rekey: %s", crypto_result_to_string(commit_result));
  }
 
  log_debug("Session rekeying completed successfully (initiator side)");
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, crypto_handshake_context_t::crypto_ctx, crypto_handshake_is_ready(), CRYPTO_OK, crypto_rekey_abort(), crypto_rekey_commit(), crypto_result_to_string(), CRYPTO_SHARED_KEY_SIZE, ERROR_CRYPTO, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, ERROR_NETWORK, crypto_context_t::has_temp_key, log_debug, packet_send_via_transport(), PACKET_TYPE_CRYPTO_REKEY_COMPLETE, crypto_context_t::rekey_in_progress, SET_ERRNO, crypto_context_t::shared_key, and crypto_context_t::temp_shared_key.

Referenced by crypto_client_send_rekey_complete().

crypto_handshake_rekey_request()

asciichat_error_t crypto_handshake_rekey_request	(	crypto_handshake_context_t *	ctx,
		acip_transport_t *	transport
	)

Send REKEY_REQUEST packet (initiator side)

Parameters

ctx	Crypto handshake context (must be ready)
transport	Transport to send on

Returns

ASCIICHAT_OK on success, error code on failure

Send REKEY_REQUEST packet (initiator side). Sends the initiator's new ephemeral public key to the peer.

Definition at line 391 of file crypto/handshake/common.c.

                                                                                                               {
  if (!ctx || !crypto_handshake_is_ready(ctx)) {
    return SET_ERRNO(ERROR_INVALID_STATE, "Handshake not ready for rekeying: ctx=%p, ready=%d", ctx,
                     ctx ? crypto_handshake_is_ready(ctx) : 0);
  }
  if (!transport) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Transport is NULL");
  }
 
  // Initialize rekey process (generates new ephemeral keypair)
  crypto_result_t result = crypto_rekey_init(&ctx->crypto_ctx);
  if (result != CRYPTO_OK) {
    return SET_ERRNO(ERROR_CRYPTO, "Failed to initialize rekey: %s", crypto_result_to_string(result));
  }
 
  // Send REKEY_REQUEST with new ephemeral public key (32 bytes)
  log_debug("Sending REKEY_REQUEST with new ephemeral X25519 public key (32 bytes)");
  asciichat_error_t send_result = packet_send_via_transport(transport, PACKET_TYPE_CRYPTO_REKEY_REQUEST,
                                                            ctx->crypto_ctx.temp_public_key, CRYPTO_PUBLIC_KEY_SIZE, 0);
  if (send_result != ASCIICHAT_OK) {
    crypto_rekey_abort(&ctx->crypto_ctx); // Clean up temp keys on failure
    return SET_ERRNO(ERROR_NETWORK, "Failed to send REKEY_REQUEST packet");
  }
 
  log_debug("REKEY_REQUEST sent successfully, awaiting REKEY_RESPONSE");
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, crypto_handshake_context_t::crypto_ctx, crypto_handshake_is_ready(), CRYPTO_OK, CRYPTO_PUBLIC_KEY_SIZE, crypto_rekey_abort(), crypto_rekey_init(), crypto_result_to_string(), ERROR_CRYPTO, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, ERROR_NETWORK, log_debug, packet_send_via_transport(), PACKET_TYPE_CRYPTO_REKEY_REQUEST, SET_ERRNO, and crypto_context_t::temp_public_key.

Referenced by client_send_thread_func(), and crypto_client_initiate_rekey().

crypto_handshake_rekey_response()

asciichat_error_t crypto_handshake_rekey_response	(	crypto_handshake_context_t *	ctx,
		acip_transport_t *	transport
	)

Send REKEY_RESPONSE packet (responder side)

Parameters

ctx	Crypto handshake context (must be ready)
transport	Transport to send on

Returns

ASCIICHAT_OK on success, error code on failure

Send REKEY_RESPONSE packet (responder side). Sends the responder's new ephemeral public key to the peer.

Definition at line 423 of file crypto/handshake/common.c.

                                                                                                                {
  if (!ctx || !crypto_handshake_is_ready(ctx)) {
    return SET_ERRNO(ERROR_INVALID_STATE, "Handshake not ready for rekeying: ctx=%p, ready=%d", ctx,
                     ctx ? crypto_handshake_is_ready(ctx) : 0);
  }
  if (!transport) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Transport is NULL");
  }
 
  if (!ctx->crypto_ctx.rekey_in_progress || !ctx->crypto_ctx.has_temp_key) {
    return SET_ERRNO(ERROR_INVALID_STATE, "No rekey in progress or temp key missing");
  }
 
  // Send REKEY_RESPONSE with new ephemeral public key (32 bytes)
  log_debug("Sending REKEY_RESPONSE with new ephemeral X25519 public key (32 bytes)");
  asciichat_error_t send_result = packet_send_via_transport(transport, PACKET_TYPE_CRYPTO_REKEY_RESPONSE,
                                                            ctx->crypto_ctx.temp_public_key, CRYPTO_PUBLIC_KEY_SIZE, 0);
  if (send_result != ASCIICHAT_OK) {
    crypto_rekey_abort(&ctx->crypto_ctx); // Clean up temp keys on failure
    return SET_ERRNO(ERROR_NETWORK, "Failed to send REKEY_RESPONSE packet");
  }
 
  log_debug("REKEY_RESPONSE sent successfully, awaiting REKEY_COMPLETE");
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, crypto_handshake_context_t::crypto_ctx, crypto_handshake_is_ready(), CRYPTO_PUBLIC_KEY_SIZE, crypto_rekey_abort(), ERROR_INVALID_PARAM, ERROR_INVALID_STATE, ERROR_NETWORK, crypto_context_t::has_temp_key, log_debug, packet_send_via_transport(), PACKET_TYPE_CRYPTO_REKEY_RESPONSE, crypto_context_t::rekey_in_progress, SET_ERRNO, and crypto_context_t::temp_public_key.

Referenced by crypto_client_send_rekey_response().

crypto_handshake_set_parameters()

asciichat_error_t crypto_handshake_set_parameters	(	crypto_handshake_context_t *	ctx,
		const crypto_parameters_packet_t *	params
	)

Set crypto parameters from crypto_parameters_packet_t.

Parameters

ctx	Handshake context
params	Negotiated crypto parameters (from capabilities negotiation)

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 66 of file crypto/handshake/common.c.

                                                                                            {
  if (!ctx || !params) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters: ctx=%p, params=%p", ctx, params);
  }
 
  // Client receives network byte order and must convert
  // Server uses host byte order and must NOT convert
  if (ctx->is_server) {
    // Server: values are already in host byte order
    // Update crypto context with negotiated parameters directly
    ctx->crypto_ctx.public_key_size = params->kex_public_key_size;
    ctx->crypto_ctx.auth_public_key_size = params->auth_public_key_size;
    ctx->crypto_ctx.shared_key_size = params->shared_secret_size;
    ctx->crypto_ctx.signature_size = params->signature_size;
  } else {
    // Client: convert from network byte order
    // Update crypto context with negotiated parameters directly
    ctx->crypto_ctx.public_key_size = NET_TO_HOST_U16(params->kex_public_key_size);
    ctx->crypto_ctx.auth_public_key_size = NET_TO_HOST_U16(params->auth_public_key_size);
    ctx->crypto_ctx.shared_key_size = NET_TO_HOST_U16(params->shared_secret_size);
    ctx->crypto_ctx.signature_size = NET_TO_HOST_U16(params->signature_size);
  }
  // Update crypto context with negotiated parameters directly
  ctx->crypto_ctx.nonce_size = params->nonce_size;
  ctx->crypto_ctx.mac_size = params->mac_size;
  ctx->crypto_ctx.hmac_size = params->hmac_size;
  ctx->crypto_ctx.auth_challenge_size =
      AUTH_CHALLENGE_SIZE; // Auth challenge size is fixed for now, could be negotiated later
  ctx->crypto_ctx.encryption_key_size =
      (uint8_t)ctx->crypto_ctx.shared_key_size;                       // Use shared key size as encryption key size
  ctx->crypto_ctx.private_key_size = ctx->crypto_ctx.public_key_size; // Same as public key for X25519
  ctx->crypto_ctx.salt_size = ARGON2ID_SALT_SIZE;                     // Salt size doesn't change
 
  log_debug("Crypto parameters set: kex_key=%u, auth_key=%u, sig=%u, "
            "secret=%u, nonce=%u, mac=%u, hmac=%u",
            ctx->crypto_ctx.public_key_size, ctx->crypto_ctx.auth_public_key_size, ctx->crypto_ctx.signature_size,
            ctx->crypto_ctx.shared_key_size, ctx->crypto_ctx.nonce_size, ctx->crypto_ctx.mac_size,
            ctx->crypto_ctx.hmac_size);
 
  return ASCIICHAT_OK;
}

References ARGON2ID_SALT_SIZE, ASCIICHAT_OK, AUTH_CHALLENGE_SIZE, crypto_context_t::auth_challenge_size, crypto_context_t::auth_public_key_size, crypto_parameters_packet_t::auth_public_key_size, crypto_handshake_context_t::crypto_ctx, crypto_context_t::encryption_key_size, ERROR_INVALID_PARAM, crypto_context_t::hmac_size, crypto_parameters_packet_t::hmac_size, crypto_handshake_context_t::is_server, crypto_parameters_packet_t::kex_public_key_size, log_debug, crypto_context_t::mac_size, crypto_parameters_packet_t::mac_size, NET_TO_HOST_U16, crypto_context_t::nonce_size, crypto_parameters_packet_t::nonce_size, crypto_context_t::private_key_size, crypto_context_t::public_key_size, crypto_context_t::salt_size, SET_ERRNO, crypto_context_t::shared_key_size, crypto_parameters_packet_t::shared_secret_size, crypto_context_t::signature_size, and crypto_parameters_packet_t::signature_size.

Referenced by client_crypto_handshake(), client_handle_crypto_parameters(), crypto_handshake_server_send_parameters(), discovery_session_start(), and server_crypto_handshake().

crypto_handshake_should_rekey()

bool crypto_handshake_should_rekey

(

const crypto_handshake_context_t *

ctx

)

Check if rekeying should be triggered for this handshake context.

Parameters

ctx	Crypto handshake context

Returns

true if rekey should be initiated, false otherwise

Check if rekeying should be triggered for this handshake context. Wrapper around crypto_should_rekey() for handshake context.

Definition at line 639 of file crypto/handshake/common.c.

                                                                          {
  if (!ctx || !crypto_handshake_is_ready(ctx)) {
    return false;
  }
  return crypto_should_rekey(&ctx->crypto_ctx);
}

References crypto_handshake_context_t::crypto_ctx, crypto_handshake_is_ready(), and crypto_should_rekey().

Referenced by client_send_thread_func(), and crypto_client_should_rekey().

crypto_handshake_validate_packet_size()

asciichat_error_t crypto_handshake_validate_packet_size	(	const crypto_handshake_context_t *	ctx,
		uint16_t	packet_type,
		size_t	packet_size
	)

Validate crypto packet size based on session parameters.

Parameters

ctx	Handshake context (must have parameters set)
packet_type	Packet type to validate
packet_size	Actual packet size received

Returns

ASCIICHAT_OK if valid, error code on failure

Definition at line 110 of file crypto/handshake/common.c.

                                                                            {
  if (!ctx) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters: ctx=%p", ctx);
  }
 
  switch (packet_type) {
  case PACKET_TYPE_CRYPTO_CAPABILITIES:
    if (packet_size != sizeof(crypto_capabilities_packet_t)) {
      // Don't  return an error code, just set the errno and return the error code
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid crypto capabilities packet size: %zu (expected %zu)",
                       packet_size, sizeof(crypto_capabilities_packet_t));
    }
    break;
 
  case PACKET_TYPE_CRYPTO_PARAMETERS:
    if (packet_size != sizeof(crypto_parameters_packet_t)) {
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid crypto parameters packet size: %zu (expected %zu)", packet_size,
                       sizeof(crypto_parameters_packet_t));
    }
    break;
 
  case PACKET_TYPE_CRYPTO_KEY_EXCHANGE_INIT:
    // Server can send either:
    // 1. Simple format: kex_public_key_size (when server has no identity key)
    // 2. Authenticated format: kex_public_key_size + auth_public_key_size + signature_size
    {
      size_t simple_size = ctx->crypto_ctx.public_key_size;
      size_t authenticated_size =
          ctx->crypto_ctx.public_key_size + ctx->crypto_ctx.auth_public_key_size + ctx->crypto_ctx.signature_size;
 
      if (packet_size != simple_size && packet_size != authenticated_size) {
        return SET_ERRNO(ERROR_NETWORK_PROTOCOL,
                         "Invalid KEY_EXCHANGE_INIT size: %zu (expected %zu for simple or %zu for authenticated: "
                         "kex=%u + auth=%u + sig=%u)",
                         packet_size, simple_size, authenticated_size, ctx->crypto_ctx.public_key_size,
                         ctx->crypto_ctx.auth_public_key_size, ctx->crypto_ctx.signature_size);
      }
    }
    break;
 
  case PACKET_TYPE_CRYPTO_KEY_EXCHANGE_RESP:
    // Client can send either:
    // 1. Simple format: kex_public_key_size (when server has no identity key)
    // 2. Authenticated format: kex_public_key_size + client_auth_key_size + client_sig_size + [gpg_key_id_len:1] +
    // [gpg_key_id:0-16]
    {
      size_t simple_size = ctx->crypto_ctx.public_key_size;
      // For authenticated format, use Ed25519 sizes since client has Ed25519 key
      size_t ed25519_auth_size = ED25519_PUBLIC_KEY_SIZE; // Ed25519 public key is always 32 bytes
      size_t ed25519_sig_size = ED25519_SIGNATURE_SIZE;   // Ed25519 signature is always 64 bytes
      size_t authenticated_min_size = ctx->crypto_ctx.public_key_size + ed25519_auth_size + ed25519_sig_size;
      size_t authenticated_max_size = authenticated_min_size + 1 + 40; // +1 for length, +40 for max GPG key ID
 
      if (packet_size != simple_size &&
          (packet_size < authenticated_min_size || packet_size > authenticated_max_size)) {
        return SET_ERRNO(ERROR_NETWORK_PROTOCOL,
                         "Invalid KEY_EXCHANGE_RESP size: %zu (expected %zu for simple or %zu-%zu for authenticated: "
                         "kex=%u + auth=%u + sig=%u + optional GPG key ID)",
                         packet_size, simple_size, authenticated_min_size, authenticated_max_size,
                         ctx->crypto_ctx.public_key_size, ed25519_auth_size, ed25519_sig_size);
      }
    }
    break;
 
  case PACKET_TYPE_CRYPTO_AUTH_CHALLENGE:
    // Server sends: 1 byte auth_flags + auth_challenge_size byte nonce
    {
      size_t expected_size = AUTH_CHALLENGE_FLAGS_SIZE + ctx->crypto_ctx.auth_challenge_size;
      if (packet_size != expected_size) {
        return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid AUTH_CHALLENGE size: %zu (expected %zu: flags=%d + nonce=%u)",
                         packet_size, expected_size, AUTH_CHALLENGE_FLAGS_SIZE, ctx->crypto_ctx.auth_challenge_size);
      }
    }
    break;
 
  case PACKET_TYPE_CRYPTO_AUTH_RESPONSE:
    // Client sends: hmac_size + auth_challenge_size bytes client_nonce + [gpg_key_id_len:1] + [gpg_key_id:0-40]
    {
      size_t min_size = ctx->crypto_ctx.hmac_size + ctx->crypto_ctx.auth_challenge_size;
      size_t max_size = min_size + 1 + 40; // +1 for length, +40 for max GPG key ID
      if (packet_size < min_size || packet_size > max_size) {
        return SET_ERRNO(ERROR_NETWORK_PROTOCOL,
                         "Invalid AUTH_RESPONSE size: %zu (expected %zu-%zu: hmac=%u + "
                         "nonce=%u + optional GPG key ID)",
                         packet_size, min_size, max_size, ctx->crypto_ctx.hmac_size,
                         ctx->crypto_ctx.auth_challenge_size);
      }
    }
    break;
 
  case PACKET_TYPE_CRYPTO_AUTH_FAILED:
    // Variable size - just check reasonable limits
    if (packet_size > MAX_AUTH_FAILED_PACKET_SIZE) {
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid AUTH_FAILED size: %zu (max %d)", packet_size,
                       MAX_AUTH_FAILED_PACKET_SIZE);
    }
    break;
 
  case PACKET_TYPE_CRYPTO_SERVER_AUTH_RESP:
    // Server sends: hmac_size bytes
    if (packet_size != ctx->crypto_ctx.hmac_size) {
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid SERVER_AUTH_RESP size: %zu (expected %u)", packet_size,
                       ctx->crypto_ctx.hmac_size);
    }
    break;
 
  case PACKET_TYPE_CRYPTO_HANDSHAKE_COMPLETE:
    // Empty packet
    if (packet_size != 0) {
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid HANDSHAKE_COMPLETE size: %zu (expected 0)", packet_size);
    }
    break;
 
  case PACKET_TYPE_CRYPTO_NO_ENCRYPTION:
    // Empty packet
    if (packet_size != 0) {
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid NO_ENCRYPTION size: %zu (expected 0)", packet_size);
    }
    break;
 
  case PACKET_TYPE_ENCRYPTED:
    // Variable size - check reasonable limits
    if (packet_size > MAX_ENCRYPTED_PACKET_SIZE) { // 64KB max for encrypted packets
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid ENCRYPTED size: %zu (max %d)", packet_size,
                       MAX_ENCRYPTED_PACKET_SIZE);
    }
    break;
 
  default:
    return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Unknown crypto packet type: %u", packet_type);
  }
 
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, AUTH_CHALLENGE_FLAGS_SIZE, crypto_context_t::auth_challenge_size, crypto_context_t::auth_public_key_size, crypto_handshake_context_t::crypto_ctx, ED25519_PUBLIC_KEY_SIZE, ED25519_SIGNATURE_SIZE, ERROR_INVALID_PARAM, ERROR_NETWORK_PROTOCOL, crypto_context_t::hmac_size, MAX_AUTH_FAILED_PACKET_SIZE, MAX_ENCRYPTED_PACKET_SIZE, PACKET_TYPE_CRYPTO_AUTH_CHALLENGE, PACKET_TYPE_CRYPTO_AUTH_FAILED, PACKET_TYPE_CRYPTO_AUTH_RESPONSE, PACKET_TYPE_CRYPTO_CAPABILITIES, PACKET_TYPE_CRYPTO_HANDSHAKE_COMPLETE, PACKET_TYPE_CRYPTO_KEY_EXCHANGE_INIT, PACKET_TYPE_CRYPTO_KEY_EXCHANGE_RESP, PACKET_TYPE_CRYPTO_NO_ENCRYPTION, PACKET_TYPE_CRYPTO_PARAMETERS, PACKET_TYPE_CRYPTO_SERVER_AUTH_RESP, PACKET_TYPE_ENCRYPTED, crypto_context_t::public_key_size, SET_ERRNO, and crypto_context_t::signature_size.

Referenced by crypto_handshake_client_auth_response(), crypto_handshake_client_key_exchange(), crypto_handshake_server_auth_challenge(), and crypto_handshake_server_complete().