prepare.h File Reference

Go to the source code of this file.

Data Structures
struct	acip_packet_plan_t

Functions
asciichat_error_t	acip_packet_plan (crypto_context_t *crypto, const socket_buffer_t *buffers, size_t count, acip_packet_plan_t *plan)
asciichat_error_t	acip_packet_encrypt (crypto_context_t *crypto, const acip_packet_plan_t *plan, buffer_domain_t *domain, void *ciphertext, size_t capacity, packet_header_t *header, size_t *length)
	The useful part of acip packet plan is in buffers, count, plaintext_size, ciphertext_capacity: together they describe what is pending, who owns it, and how much data is valid. Keep the object with its parent operation and use the parent cleanup path. Encrypt a successful encrypted plan into caller-owned ciphertext storage and construct its wire header. The caller chooses contiguous or vectored delivery, and must release storage only after delivery has consumed/copied it. This helper owns and releases only its temporary gather buffer, allocated from domain. Output length is zero on failure; no output may be sent on failure.
asciichat_error_t	acip_packet_seal (crypto_record_t *, acip_traffic_class_t, acip_delivery_t, const void *, size_t, uint8_t **, size_t *)
asciichat_error_t	acip_packet_open_sequence (crypto_record_t *, acip_traffic_class_t, acip_delivery_t, const void *, size_t, uint8_t **, size_t *, uint64_t *)
asciichat_error_t	acip_packet_open (crypto_record_t *, acip_traffic_class_t, acip_delivery_t, const void *, size_t, uint8_t **, size_t *)
asciichat_error_t	acip_packet_decrypt_payload (crypto_record_t *, unsigned channel, unsigned delivery, const void *, size_t, uint8_t **, size_t *, uint64_t *)

Function Documentation

acip_packet_decrypt_payload()

asciichat_error_t acip_packet_decrypt_payload	(	crypto_record_t *	records,
		unsigned	channel,
		unsigned	delivery,
		const void *	payload,
		size_t	length,
		uint8_t **	output,
		size_t *	written,
		uint64_t *	sequence )

Definition at line 188 of file prepare.c.

                                                                  {
  return crypto_record_open_sequence(records, flow, delivery, payload, length, output, written, sequence,
                                     validate_record_packet, NULL);
}

References crypto_record_open_sequence().

Referenced by acip_packet_open_sequence(), and acip_security_decrypt().

acip_packet_encrypt()

asciichat_error_t acip_packet_encrypt	(	crypto_context_t *	crypto,
		const acip_packet_plan_t *	plan,
		buffer_domain_t *	domain,
		void *	ciphertext,
		size_t	capacity,
		packet_header_t *	header,
		size_t *	length )

The useful part of acip packet plan is in buffers, count, plaintext_size, ciphertext_capacity: together they describe what is pending, who owns it, and how much data is valid. Keep the object with its parent operation and use the parent cleanup path. Encrypt a successful encrypted plan into caller-owned ciphertext storage and construct its wire header. The caller chooses contiguous or vectored delivery, and must release storage only after delivery has consumed/copied it. This helper owns and releases only its temporary gather buffer, allocated from domain. Output length is zero on failure; no output may be sent on failure.

Definition at line 64 of file prepare.c.

                                                                                                                  {
  if (length)
    *length = 0;
  if (!crypto || !plan || !plan->encrypt || !plan->buffers || !plan->count || !ciphertext || !header || !length)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid ACIP encryption arguments");
  if (capacity < plan->ciphertext_capacity)
    return SET_ERRNO(ERROR_NETWORK_SIZE, "ACIP ciphertext storage too small");
  const uint8_t *plaintext = plan->buffers[0].data;
  uint8_t *gathered = NULL;
  if (plan->count > 1) {
    gathered = buffer_alloc(domain, plan->plaintext_size);
    if (!gathered)
      return SET_ERRNO(ERROR_MEMORY, "Cannot gather ACIP encryption input");
    size_t offset = 0;
    for (size_t i = 0; i < plan->count; ++i) {
      if (plan->buffers[i].len)
        memcpy(gathered + offset, plan->buffers[i].data, plan->buffers[i].len);
      offset += plan->buffers[i].len;
    }
    plaintext = gathered;
  }
  size_t encrypted_length = 0;
  crypto_session_t *session = NULL;
  bool shared = !plan->records_locked && crypto && crypto->session && plan->records == &crypto->session->records;
  asciichat_error_t encrypted = shared ? crypto_session_lock(crypto, &session) : ASCIICHAT_OK;
  if (encrypted == ASCIICHAT_OK)
    encrypted = plan->records ? crypto_record_seal_into_domain(plan->records, plan->options.traffic_class,
                                                               plan->options.delivery, plaintext, plan->plaintext_size,
                                                               ciphertext, capacity, &encrypted_length, domain)
                              : SET_ERRNO(ERROR_INVALID_STATE, "Missing authenticated record context");
  if (session)
    crypto_session_unlock(session);
  buffer_release(gathered);
  if (encrypted != ASCIICHAT_OK)
    return encrypted;
  socket_buffer_t slice = {ciphertext, encrypted_length};
  asciichat_error_t result = packet_header_build(header, PACKET_TYPE_ENCRYPTED, &slice, 1, 0);
  if (result != ASCIICHAT_OK)
    return result;
  *length = encrypted_length;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, buffer_alloc(), buffer_release, acip_packet_plan_t::buffers, acip_packet_plan_t::count, crypto_record_seal_into_domain(), crypto_session_lock(), crypto_session_unlock(), acip_send_options_t::delivery, acip_packet_plan_t::encrypt, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, ERROR_MEMORY, ERROR_NETWORK_SIZE, acip_packet_plan_t::options, packet_header_build(), PACKET_TYPE_ENCRYPTED, acip_packet_plan_t::plaintext_size, acip_packet_plan_t::records, crypto_session::records, acip_packet_plan_t::records_locked, crypto_context_t::session, SET_ERRNO, and acip_send_options_t::traffic_class.

Referenced by acip_packet_seal(), and send_packet_secure().

acip_packet_open()

asciichat_error_t acip_packet_open	(	crypto_record_t *	records,
		acip_traffic_class_t	flow,
		acip_delivery_t	delivery,
		const void *	packet,
		size_t	length,
		uint8_t **	output,
		size_t *	written )

Definition at line 183 of file prepare.c.

                                                                                                         {
  return acip_packet_open_sequence(records, flow, delivery, packet, length, output, written, NULL);
}

References acip_packet_open_sequence().

acip_packet_open_sequence()

asciichat_error_t acip_packet_open_sequence	(	crypto_record_t *	records,
		acip_traffic_class_t	flow,
		acip_delivery_t	delivery,
		const void *	packet,
		size_t	length,
		uint8_t **	output,
		size_t *	written,
		uint64_t *	sequence )

Definition at line 166 of file prepare.c.

                                                                                                   {
  if (!output || !written)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing decrypted packet output");
  *output = NULL;
  *written = 0;
  packet_header_t header;
  asciichat_error_t result = packet_validate(packet, length, 0, &header);
  if (result != ASCIICHAT_OK)
    return result;
  if (NET_TO_HOST_U16(header.type) != PACKET_TYPE_ENCRYPTED)
    return SET_ERRNO(ERROR_CRYPTO, "Expected encrypted packet");
  return acip_packet_decrypt_payload(records, flow, delivery, (const uint8_t *)packet + sizeof(header),
                                     length - sizeof(header), output, written, sequence);
}

References acip_packet_decrypt_payload(), ASCIICHAT_OK, ERROR_CRYPTO, ERROR_INVALID_PARAM, NET_TO_HOST_U16, PACKET_TYPE_ENCRYPTED, packet_validate(), and SET_ERRNO.

Referenced by acip_packet_open().

acip_packet_plan()

asciichat_error_t acip_packet_plan	(	crypto_context_t *	crypto,
		const socket_buffer_t *	buffers,
		size_t	count,
		acip_packet_plan_t *	plan )

Validate sizes and decide eligibility without allocating or advancing crypto state.

Definition at line 9 of file prepare.c.

                                                             {
  if (!plan)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing ACIP packet plan");
  *plan = (acip_packet_plan_t){0};
  if (!buffers || !count || count > SOCKET_IOV_MAX)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid ACIP packet vectors");
  size_t size = 0;
  for (size_t i = 0; i < count; ++i) {
    if ((buffers[i].len && !buffers[i].data) || buffers[i].len > SOCKET_SEND_BUFFER_MAX - size)
      return SET_ERRNO(ERROR_NETWORK_SIZE, "Invalid ACIP packet vector size");
    size += buffers[i].len;
  }
  bool encrypt = false;
  acip_send_options_t options = {.delivery = ACIP_DELIVERY_RELIABLE};
  buffer_domain_t *domain = NULL;
  if (buffers[0].len >= sizeof(packet_header_t)) {
    packet_header_t header;
    memcpy(&header, buffers[0].data, sizeof(header));
    packet_type_t type = NET_TO_HOST_U16(header.type);
    if (packet_is_handshake_type(type) || type == PACKET_TYPE_ERROR_MESSAGE)
      domain = buffer_control_domain();
    options.traffic_class = type == PACKET_TYPE_CRYPTO_EPOCH_MARKER
                                ? (acip_traffic_class_t)NET_TO_HOST_U32(header.client_id)
                                : acip_packet_traffic_class(type);
    encrypt = crypto && crypto->encrypt_data && crypto_is_ready(crypto) && type != PACKET_TYPE_ENCRYPTED &&
              !packet_is_initial_handshake_type(type);
  } else {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing ACIP packet header");
  }
  size_t capacity = 0;
  crypto_record_t *records = NULL;
  if (encrypt) {
    if (size > CRYPTO_MAX_PLAINTEXT_SIZE - 24 ||
        size > SOCKET_SEND_BUFFER_MAX - sizeof(packet_header_t) - CRYPTO_NONCE_SIZE - CRYPTO_MAC_SIZE)
      return SET_ERRNO(ERROR_NETWORK_SIZE, "Encrypted ACIP packet too large");
    crypto_session_t *session = NULL;
    asciichat_error_t result = crypto_session_lock(crypto, &session);
    if (result != ASCIICHAT_OK)
      return result;
    records = &session->records;
    crypto_session_unlock(session);
    capacity = size + 32 + crypto->nonce_size + crypto->mac_size;
  }
  *plan = (acip_packet_plan_t){.buffers = buffers,
                               .count = count,
                               .plaintext_size = size,
                               .ciphertext_capacity = capacity,
                               .encrypt = encrypt,
                               .domain = domain,
                               .records = records,
                               .options = options};
  return ASCIICHAT_OK;
}

References ACIP_DELIVERY_RELIABLE, acip_packet_traffic_class(), ASCIICHAT_OK, buffer_control_domain(), crypto_is_ready(), CRYPTO_MAC_SIZE, CRYPTO_MAX_PLAINTEXT_SIZE, CRYPTO_NONCE_SIZE, crypto_session_lock(), crypto_session_unlock(), crypto_context_t::encrypt_data, ERROR_INVALID_PARAM, ERROR_NETWORK_SIZE, crypto_context_t::mac_size, NET_TO_HOST_U16, NET_TO_HOST_U32, crypto_context_t::nonce_size, PACKET_TYPE_CRYPTO_EPOCH_MARKER, PACKET_TYPE_ENCRYPTED, PACKET_TYPE_ERROR_MESSAGE, crypto_session::records, SET_ERRNO, and acip_send_options_t::traffic_class.

Referenced by send_packet_secure().

acip_packet_seal()

asciichat_error_t acip_packet_seal	(	crypto_record_t *	records,
		acip_traffic_class_t	flow,
		acip_delivery_t	delivery,
		const void *	packet,
		size_t	length,
		uint8_t **	output,
		size_t *	written )

Definition at line 125 of file prepare.c.

                                                                                                         {
  if (!output || !written || !records || !records->crypto)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid packet encryption arguments");
  *output = NULL;
  *written = 0;
  if ((unsigned)flow > ACIP_TRAFFIC_VISUAL || (unsigned)delivery > ACIP_DELIVERY_DATAGRAM ||
      (flow == ACIP_TRAFFIC_CONTROL && delivery == ACIP_DELIVERY_DATAGRAM))
    return SET_ERRNO(ERROR_INVALID_STATE, "Invalid packet output channel");
  asciichat_error_t result = validate_record_packet(NULL, flow, delivery, packet, length);
  if (result != ASCIICHAT_OK)
    return result;
  socket_buffer_t slice = {packet, length};
  if (length > CRYPTO_MAX_PLAINTEXT_SIZE - 24)
    return SET_ERRNO(ERROR_NETWORK_SIZE, "Packet exceeds record plaintext capacity");
  acip_packet_plan_t plan = {.buffers = &slice,
                             .count = 1,
                             .plaintext_size = length,
                             .encrypt = true,
                             .records = records,
                             .records_locked = true,
                             .options = {.traffic_class = flow, .delivery = delivery},
                             .ciphertext_capacity =
                                 length + 32 + records->crypto->nonce_size + records->crypto->mac_size};
  uint8_t *wire = buffer_alloc(plan.domain, sizeof(packet_header_t) + plan.ciphertext_capacity);
  if (!wire)
    return SET_ERRNO(ERROR_MEMORY, "Cannot allocate encrypted packet");
  packet_header_t header;
  size_t encrypted_length = 0;
  result = acip_packet_encrypt(records->crypto, &plan, plan.domain, wire + sizeof(header), plan.ciphertext_capacity,
                               &header, &encrypted_length);
  if (result != ASCIICHAT_OK) {
    buffer_release(wire);
    return result;
  }
  memcpy(wire, &header, sizeof(header));
  *output = wire;
  *written = sizeof(header) + encrypted_length;
  return ASCIICHAT_OK;
}

References ACIP_DELIVERY_DATAGRAM, acip_packet_encrypt(), ACIP_TRAFFIC_CONTROL, ACIP_TRAFFIC_VISUAL, ASCIICHAT_OK, buffer_alloc(), buffer_release, acip_packet_plan_t::ciphertext_capacity, crypto_record::crypto, CRYPTO_MAX_PLAINTEXT_SIZE, acip_packet_plan_t::domain, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, ERROR_MEMORY, ERROR_NETWORK_SIZE, crypto_context_t::mac_size, crypto_context_t::nonce_size, and SET_ERRNO.

Referenced by acip_security_rekey_seal(), and acip_security_seal().