ra8_net_provision.c

Go to the documentation of this file.

 
#include "ra8_net_provision.h"
 
#include <stddef.h>
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_err.h"
#include "ra8_secure.h"

static const uint8_t s_prefix[k_ra8_net_provision_prefix_bytes] = {
  'R',
  'A',
  '8',
  'N',
  'E',
  'T',
  '1',
  ':',
};

typedef enum : uint8_t {
  k_ra8_net_provision_text_printable_min = 0x20U, 
  k_ra8_net_provision_text_delete        = 0x7FU, 
} ra8_net_provision_text_byte_t;

typedef enum : uint8_t {
  k_ra8_net_provision_hex_alpha_offset = 10U, 
} ra8_net_provision_hex_t;
 
const char k_ra8_net_provision_ready_prompt[] = "ra8_net_provision: READY v1\r\n";

RA8_INTERNAL static bool internal_hex_nibble(uint8_t digit, uint8_t* out)
{
  *out = 0U;
  if ((digit >= (uint8_t)'0') && (digit <= (uint8_t)'9')) {
    *out = (uint8_t)(digit - (uint8_t)'0');
    return true;
  }
  if ((digit >= (uint8_t)'a') && (digit <= (uint8_t)'f')) {
    *out = (uint8_t)(digit - (uint8_t)'a' + (uint8_t)k_ra8_net_provision_hex_alpha_offset);
    return true;
  }
  if ((digit >= (uint8_t)'A') && (digit <= (uint8_t)'F')) {
    *out = (uint8_t)(digit - (uint8_t)'A' + (uint8_t)k_ra8_net_provision_hex_alpha_offset);
    return true;
  }
  return false;
}

RA8_INTERNAL static ra8_err_t internal_decode_field(const uint8_t* line,
                                                    size_t         begin,
                                                    size_t         end,
                                                    char*          output,
                                                    size_t         capacity,
                                                    size_t*        out_length)
{
  const size_t encoded = end - begin;
  if ((encoded % 2U) != 0U) {
    return k_ra8_err_invalid_size;
  }
  const size_t decoded = encoded / 2U;
  if (decoded > capacity) {
    return k_ra8_err_invalid_size;
  }
  for (size_t index = 0U; index < decoded; ++index) {
    uint8_t high = 0U;
    uint8_t low  = 0U;
    if (!internal_hex_nibble(line[begin + (index * 2U)], &high)) {
      return k_ra8_err_protocol_error;
    }
    if (!internal_hex_nibble(line[begin + (index * 2U) + 1U], &low)) {
      return k_ra8_err_protocol_error;
    }
    output[index] = (char)((uint8_t)(high << 4U) | low);
  }
  output[decoded] = '\0';
  *out_length     = decoded;
  return k_ra8_ok;
}

RA8_INTERNAL static bool internal_has_no_controls(const char* text, size_t length)
{
  for (size_t index = 0U; index < length; ++index) {
    const uint8_t byte = (uint8_t)text[index];
    if ((byte < (uint8_t)k_ra8_net_provision_text_printable_min) ||
        (byte == (uint8_t)k_ra8_net_provision_text_delete)) {
      return false;
    }
  }
  return true;
}

RA8_INTERNAL static bool internal_psk_is_hex(const char* psk)
{
  for (size_t index = 0U; index < (size_t)k_ra8_net_provision_psk_bytes_max; ++index) {
    uint8_t ignored = 0U;
    if (!internal_hex_nibble((uint8_t)psk[index], &ignored)) {
      return false;
    }
  }
  return true;
}

RA8_INTERNAL static ra8_err_t internal_validate_candidate(const ra8_net_credentials_t* candidate)
{
  if (candidate->ssid_len == 0U) {
    return k_ra8_err_invalid_size;
  }
  if (candidate->psk_len < 8U) {
    return k_ra8_err_invalid_size;
  }
  if (!internal_has_no_controls(candidate->ssid, candidate->ssid_len)) {
    return k_ra8_err_protocol_error;
  }
  if (!internal_has_no_controls(candidate->psk, candidate->psk_len)) {
    return k_ra8_err_protocol_error;
  }
  if (!internal_has_no_controls(candidate->url, candidate->url_len)) {
    return k_ra8_err_protocol_error;
  }
  if ((candidate->psk_len == (uint8_t)k_ra8_net_provision_psk_bytes_max) &&
      !internal_psk_is_hex(candidate->psk)) {
    return k_ra8_err_protocol_error;
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t
internal_decode_line(const uint8_t* line, size_t line_length, ra8_net_credentials_t* candidate)
{
  size_t  separators[2]   = {};
  uint8_t separator_count = 0U;
  for (size_t index = (size_t)k_ra8_net_provision_prefix_bytes; index < (line_length - 1U);
       ++index) {
    if (line[index] == (uint8_t)':') {
      if (separator_count >= 2U) {
        return k_ra8_err_protocol_error;
      }
      separators[separator_count] = index;
      separator_count++;
    }
  }
  if (separator_count != 2U) {
    return k_ra8_err_protocol_error;
  }
 
  size_t    decoded_length = 0U;
  ra8_err_t err            = internal_decode_field(line,
                                                   (size_t)k_ra8_net_provision_prefix_bytes,
                                                   separators[0],
                                                   candidate->ssid,
                                                   (size_t)k_ra8_net_provision_ssid_bytes_max,
                                                   &decoded_length);
  candidate->ssid_len      = (uint8_t)decoded_length;
  if (err == k_ra8_ok) {
    err                = internal_decode_field(line,
                                               separators[0] + 1U,
                                               separators[1],
                                               candidate->psk,
                                               (size_t)k_ra8_net_provision_psk_bytes_max,
                                               &decoded_length);
    candidate->psk_len = (uint8_t)decoded_length;
  }
  if (err == k_ra8_ok) {
    err                = internal_decode_field(line,
                                               separators[1] + 1U,
                                               line_length - 1U,
                                               candidate->url,
                                               (size_t)k_ra8_net_provision_url_bytes_max,
                                               &decoded_length);
    candidate->url_len = (uint16_t)decoded_length;
  }
  return (err == k_ra8_ok) ? internal_validate_candidate(candidate) : err;
}

RA8_INTERNAL static bool internal_prefix_matches(const uint8_t* line)
{
  for (size_t index = 0U; index < (size_t)k_ra8_net_provision_prefix_bytes; ++index) {
    if (line[index] != s_prefix[index]) {
      return false;
    }
  }
  return true;
}
 
void ra8_net_provision_clear(ra8_net_credentials_t* credentials)
{
  if (credentials != nullptr) {
    ra8_secure_memzero(credentials, sizeof(*credentials));
  }
}
 
ra8_err_t
ra8_net_provision_parse(const uint8_t* line, size_t line_length, ra8_net_credentials_t* out)
{
  if (out == nullptr) {
    return k_ra8_err_null_ptr;
  }
  ra8_net_provision_clear(out);
  if (line == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if ((line_length <= (size_t)k_ra8_net_provision_prefix_bytes) ||
      (line_length > (size_t)k_ra8_net_provision_line_bytes_max)) {
    return k_ra8_err_invalid_size;
  }
  if (!internal_prefix_matches(line)) {
    return k_ra8_err_protocol_error;
  }
  if (line[line_length - 1U] != (uint8_t)'\n') {
    return k_ra8_err_protocol_error;
  }
 
  ra8_net_credentials_t candidate = {};
  const ra8_err_t       err       = internal_decode_line(line, line_length, &candidate);
  if (err == k_ra8_ok) {
    *out = candidate;
  }
  ra8_net_provision_clear(&candidate);
  return err;
}

RA8_INTERNAL static ra8_err_t internal_validate_receiver(const ra8_net_provision_uart_t* uart,
                                                         uint32_t                        timeout_ms)
{
  if (uart == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (uart->write == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (uart->read == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (uart->wait_ms == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if ((timeout_ms == 0U) || (timeout_ms > (uint32_t)k_ra8_net_provision_timeout_ms_max)) {
    return k_ra8_err_invalid_arg;
  }
  return k_ra8_ok;
}

RA8_INTERNAL static bool
internal_find_newline(const uint8_t* chunk, size_t length, size_t* newline_offset)
{
  *newline_offset = 0U;
  for (size_t index = 0U; index < length; ++index) {
    if (chunk[index] == (uint8_t)'\n') {
      *newline_offset = index;
      return true;
    }
  }
  return false;
}

RA8_INTERNAL static ra8_err_t internal_receive_line(const ra8_net_provision_uart_t* uart,
                                                    uint32_t                        timeout_ms,
                                                    uint8_t*                        line,
                                                    size_t                          line_capacity,
                                                    size_t*                         line_length)
{
  ra8_err_t err      = k_ra8_ok;
  size_t    used     = 0U;
  bool      complete = false;
  for (uint32_t elapsed = 0U; elapsed < timeout_ms; ++elapsed) {
    size_t       received  = 0U;
    const size_t remaining = line_capacity - used;
    err                    = uart->read(&line[used], remaining, &received);
    if (err != k_ra8_ok) {
      break;
    }
    if (received > remaining) {
      err = k_ra8_err_protocol_error;
      break;
    }
    size_t newline_offset = 0U;
    if (internal_find_newline(&line[used], received, &newline_offset)) {
      used += newline_offset + 1U;
      if ((newline_offset + 1U) != received) {
        err = k_ra8_err_protocol_error;
      }
      complete = true;
      break;
    }
    used += received;
    if (used == line_capacity) {
      err = k_ra8_err_invalid_size;
      break;
    }
    uart->wait_ms(1U);
  }
  if ((err == k_ra8_ok) && !complete) {
    err = k_ra8_err_timeout;
  }
  *line_length = used;
  return err;
}
 
ra8_err_t ra8_net_provision_receive(const ra8_net_provision_uart_t* uart,
                                    uint32_t                        timeout_ms,
                                    ra8_net_credentials_t*          out)
{
  if (out == nullptr) {
    return k_ra8_err_null_ptr;
  }
  ra8_net_provision_clear(out);
  ra8_err_t err = internal_validate_receiver(uart, timeout_ms);
  if (err != k_ra8_ok) {
    return err;
  }
 
  const size_t prompt_length = sizeof(k_ra8_net_provision_ready_prompt) - 1U;
  err = uart->write((const uint8_t*)k_ra8_net_provision_ready_prompt, prompt_length);
  uint8_t line[k_ra8_net_provision_line_bytes_max] = {};
  size_t  used                                     = 0U;
  if (err == k_ra8_ok) {
    err = internal_receive_line(uart, timeout_ms, line, sizeof(line), &used);
  }
  if (err == k_ra8_ok) {
    err = ra8_net_provision_parse(line, used, out);
  }
  ra8_secure_memzero(line, sizeof(line));
  if (err != k_ra8_ok) {
    ra8_net_provision_clear(out);
  }
  return err;
}