ab_gp_takeover_key.c

Go to the documentation of this file.

#include "ab_gp_takeover_key.h"
 
#include <stdio.h>
#include <string.h>
 
#include "safecomm/mac/mac.h"
 
static uint8_t s_key[SAFECOMM_MAC_KEY_LEN];
static bool    s_key_loaded = false;
 
static int hex_nibble(char c)
{
    if ((c >= '0') && (c <= '9'))
    {
        return c - '0';
    }
    if ((c >= 'a') && (c <= 'f'))
    {
        return (c - 'a') + 10;
    }
    if ((c >= 'A') && (c <= 'F'))
    {
        return (c - 'A') + 10;
    }
    return -1;
}
 
/* Exactly 2 * len hex characters from hex into out; false on any non-hex character. */
static bool decode_hex(const char *hex, uint8_t *out, size_t len)
{
    size_t i;
 
    for (i = 0U; i < len; i++)
    {
        int hi = hex_nibble(hex[2U * i]);
        int lo = hex_nibble(hex[(2U * i) + 1U]);
 
        if ((hi < 0) || (lo < 0))
        {
            return false;
        }
        out[i] = (uint8_t)((hi << 4) | lo);
    }
    return true;
}
 
/* Strips a `#` comment and surrounding whitespace in place; returns the remaining text (may be empty). */
static char *trim_line(char *line)
{
    char *hash = strchr(line, '#');
    char *p = line;
    size_t n;
 
    if (hash != NULL)
    {
        *hash = '\0';
    }
    while ((*p == ' ') || (*p == '\t'))
    {
        p++;
    }
    n = strlen(p);
    while ((n > 0U) && ((p[n - 1U] == ' ') || (p[n - 1U] == '\t') || (p[n - 1U] == '\r') || (p[n - 1U] == '\n')))
    {
        p[n - 1U] = '\0';
        n--;
    }
    return p;
}
 
bool ab_gp_takeover_key_load_file(const char *path)
{
    FILE *fp;
    char line[160];
    uint8_t key[SAFECOMM_MAC_KEY_LEN];
    uint32_t keys = 0U;
    bool ok = true;
 
    s_key_loaded = false;
    (void)memset(s_key, 0, sizeof(s_key));
    if (path == NULL)
    {
        return false;
    }
    fp = fopen(path, "r");
    if (fp == NULL)
    {
        return false;
    }
    while (ok && (fgets(line, (int)sizeof(line), fp) != NULL))
    {
        char *p = trim_line(line);
 
        if (*p == '\0')
        {
            continue;
        }
        keys++;
        ok = (keys == 1U) && (strlen(p) == (2U * SAFECOMM_MAC_KEY_LEN)) && decode_hex(p, key, sizeof(key));
    }
    (void)fclose(fp);
    (void)memset(line, 0, sizeof(line));
    if (ok && (keys == 1U))
    {
        (void)memcpy(s_key, key, sizeof(s_key));
        s_key_loaded = true;
    }
    (void)memset(key, 0, sizeof(key));
    return s_key_loaded;
}
 
bool ab_gp_takeover_key_loaded(void)
{
    return s_key_loaded;
}
 
bool ab_gp_takeover_verify_mac(void *user, const uint8_t *msg, size_t msg_len,
                               const uint8_t mac[RTE_SITE_ROLE_TOKEN_MAC_LEN])
{
    safecomm_mac_ctx_t mac_ctx;
    bool match;
 
    (void)user;
    if ((!s_key_loaded) || (msg == NULL) || (mac == NULL))
    {
        return false;
    }
    (void)memcpy(mac_ctx.ksmac, s_key, sizeof(mac_ctx.ksmac));
    mac_ctx.alg = SAFECOMM_MAC_ALG_3DES_SS037;
    match = (safecomm_mac_verify(&mac_ctx, msg, msg_len, mac) == SAFECOMM_STATUS_OK);
    (void)memset(&mac_ctx, 0, sizeof(mac_ctx));
    return match;
}
 
bool ab_gp_takeover_token_from_payload(const char *payload, uint8_t out[RTE_SITE_ROLE_TOKEN_LEN])
{
    const size_t prefix_len = sizeof(AB_GP_TAKEOVER_TOKEN_PREFIX) - 1U;
 
    if ((payload == NULL) || (out == NULL) || (strncmp(payload, AB_GP_TAKEOVER_TOKEN_PREFIX, prefix_len) != 0) ||
        (strlen(&payload[prefix_len]) != (2U * (size_t)RTE_SITE_ROLE_TOKEN_LEN)))
    {
        return false;
    }
    return decode_hex(&payload[prefix_len], out, (size_t)RTE_SITE_ROLE_TOKEN_LEN);
}
 
bool ab_gp_takeover_token_build(uint8_t site_id, uint8_t channel_id, uint32_t challenge, uint32_t seq,
                                uint8_t out[RTE_SITE_ROLE_TOKEN_LEN])
{
    safecomm_mac_ctx_t mac_ctx;
    bool ok;
 
    if ((!s_key_loaded) || (out == NULL))
    {
        return false;
    }
    (void)memset(out, 0, RTE_SITE_ROLE_TOKEN_LEN);
    out[0] = (uint8_t)RTE_SITE_ROLE_TOKEN_VERSION;
    out[1] = site_id;
    out[2] = channel_id;
    out[4] = (uint8_t)(challenge & 0xFFU);
    out[5] = (uint8_t)((challenge >> 8U) & 0xFFU);
    out[6] = (uint8_t)((challenge >> 16U) & 0xFFU);
    out[7] = (uint8_t)((challenge >> 24U) & 0xFFU);
    out[8] = (uint8_t)(seq & 0xFFU);
    out[9] = (uint8_t)((seq >> 8U) & 0xFFU);
    out[10] = (uint8_t)((seq >> 16U) & 0xFFU);
    out[11] = (uint8_t)((seq >> 24U) & 0xFFU);
    (void)memcpy(mac_ctx.ksmac, s_key, sizeof(mac_ctx.ksmac));
    mac_ctx.alg = SAFECOMM_MAC_ALG_3DES_SS037;
    ok = (safecomm_mac_compute(&mac_ctx, out, (size_t)RTE_SITE_ROLE_TOKEN_MSG_LEN, &out[RTE_SITE_ROLE_TOKEN_MSG_LEN]) ==
          SAFECOMM_STATUS_OK);
    (void)memset(&mac_ctx, 0, sizeof(mac_ctx));
    return ok;
}
 
bool ab_gp_takeover_token_to_payload(const uint8_t token[RTE_SITE_ROLE_TOKEN_LEN], char *out, size_t out_size)
{
    static const char digits[] = "0123456789abcdef";
    const size_t prefix_len = sizeof(AB_GP_TAKEOVER_TOKEN_PREFIX) - 1U;
    size_t i;
 
    if ((token == NULL) || (out == NULL) || (out_size < (prefix_len + (2U * (size_t)RTE_SITE_ROLE_TOKEN_LEN) + 1U)))
    {
        return false;
    }
    (void)memcpy(out, AB_GP_TAKEOVER_TOKEN_PREFIX, prefix_len);
    for (i = 0U; i < (size_t)RTE_SITE_ROLE_TOKEN_LEN; i++)
    {
        out[prefix_len + (2U * i)] = digits[(token[i] >> 4U) & 0x0FU];
        out[prefix_len + (2U * i) + 1U] = digits[token[i] & 0x0FU];
    }
    out[prefix_len + (2U * (size_t)RTE_SITE_ROLE_TOKEN_LEN)] = '\0';
    return true;
}