CC3235SF: Generating ES256 Signature on CC3235SF

Hi Kobi,

Thanks for the reply!  Ultimately, this is for use with a JWT to connect to Google's MQTT platform.  I have a couple questions while I continue working on this in tandem:

Since we're using the ECC key pair from silicon, I have written code to extract the x9.63 public ECC key to the host.  This key is then converted to a public.pem format, and placed on Google's Cloud Platform for that specific device.  Is this feasible?

Secondly, would you mind briefly looking at my code to see if I am creating the signature correctly?

/*
 * This file was based on source code from Google's IOT Core SDK.
 */

#include <stdio.h>
#include <string.h>
#include <stdbool.h>
#include <stdint.h>
/* TI-DRIVERS Header files */
#include <ti/drivers/net/wifi/simplelink.h>
#include <ti/drivers/net/wifi/netutil.h>
#include <net/utils/str_mpl.h>

#include "jwt.h"

#define JWT_HEADER_BUF_SIZE     40
#define JWT_PAYLOAD_BUF_SIZE    256
#define JWT_MAX_SIGNATURE_SIZE  132
#define JWT_PROJECTID_MAX_LEN   200

static char jwt[256];

static void jwt_url_base64_encode_buffer(uint8_t* data_to_encode,
                                         size_t data_to_encode_size,
                                         char* encoded_data_destination,
                                         size_t* encoded_data_size)
{
    *encoded_data_size = sizeof(jwt) - strlen(&jwt[0]);

    StrMpl_encodeBase64(data_to_encode,
                        data_to_encode_size,
                        (uint8_t*) encoded_data_destination,
                        encoded_data_size);

    size_t i;

    for (i = 0; i < *encoded_data_size; i++)
    {
        switch (encoded_data_destination[i])
        {
            case '+':
                encoded_data_destination[i] = '-';
                break;
            case '/':
                encoded_data_destination[i] = '_';
                break;
            case '=':
                encoded_data_destination[i] = 0;
                *encoded_data_size--;
                break;
            default:
                break;
        }
    }
}


static void jwt_create_b64h_b64p(const char* project_id, uint32_t expiration_period_sec)
{
  size_t bytes_written = 0;
  size_t index = 0;

  /* create header */
  char header[JWT_HEADER_BUF_SIZE];
  memset(&header[0], 0, JWT_HEADER_BUF_SIZE);
  memcpy(&header[0], "{\"alg\":\"ES256\",\"typ\":\"JWT\"}", strlen("{\"alg\":\"ES256\",\"typ\":\"JWT\"}"));

  /* create payload */
  //todo, as of now set to today's date, time = 12:00PM UTC
  uint32_t current_time_in_sec = 1587470400;
  char payload[JWT_PAYLOAD_BUF_SIZE];
  memset(&payload[0], 0, JWT_PAYLOAD_BUF_SIZE);

  snprintf(payload,
           JWT_PAYLOAD_BUF_SIZE,
           "{\"iat\":%ld,\"exp\":%ld,\"aud\":\"%s\"}",
           current_time_in_sec,
           current_time_in_sec + expiration_period_sec,
           project_id);

  /* base64 encode header */
  jwt_url_base64_encode_buffer((uint8_t*) &header[0],
                               strlen(header),
                               &jwt[index],
                               &bytes_written);
  index += bytes_written;
  /* add first dot separating b64(h) and b64(p) */
  jwt[index++] = '.';

  jwt_url_base64_encode_buffer((uint8_t*) &payload[0],
                               strlen(payload),
                               &jwt[index],
                               &bytes_written);
}

// create the JWT: b64(h).b64(p).b64(ecc(sha256(b64(h).b64(p))))
// h = header
// p = payload
// b64 = base64
// sha = Secure Hash Algorithm
// ecc = Elliptic Curve Cryptography
void jwt_create(const char* project_id, uint32_t expiration_period_sec)
{
    size_t bytes_written = 0;
    size_t index = 0;

    /* clear JWT */
    memset(&jwt[0], 0, sizeof(jwt));

    /* create base64 encoded header and payload: b64(h).b64(p) */
    jwt_create_b64h_b64p(project_id, expiration_period_sec);

    /* create es256 signature of b64(h).b64(p): sha256(b64(h).b64(p)) */
    uint16_t bytes_written_ecc_signature = 255;
    uint8_t ecc_signature[JWT_MAX_SIGNATURE_SIZE];
    memset(&ecc_signature[0], 0, JWT_MAX_SIGNATURE_SIZE);

    SlNetUtilCryptoCmdSignAttrib_t signAttrib;
    signAttrib.Flags = 0;
    signAttrib.ObjId = 0;
    signAttrib.SigType = SL_NETUTIL_CRYPTO_SIG_SHA256wECDSA; /* this is the only type supported */

    sl_NetUtilCmd(SL_NETUTIL_CRYPTO_CMD_SIGN_MSG,
                  (uint8_t *)&signAttrib,
                  sizeof(SlNetUtilCryptoCmdSignAttrib_t),
                  (const uint8_t *) &jwt[0],
                  strlen(&jwt[0]),
                  &ecc_signature[0],
                  &bytes_written_ecc_signature);

  /* add second dot separating b64(h).b64(p) and b64(eccsignature) */
  index = strlen(&jwt[0]);
  jwt[index++] = '.';

  jwt_url_base64_encode_buffer(&ecc_signature[0],
                               bytes_written_ecc_signature,
                               &jwt[index],
                               &bytes_written);
}

const char* jwt_get()
{
    return &jwt[0];
}

Hi Kobi,

I have already connected to Google by loading Google's root CA's via Uniflash.  I hardcoded the JWT to successfully do this.

I guess, in your opinion, is the crypto library capable of creating an ES256 signature using it's constant key pair's private x9.63 raw private key?  I'm quite certain this is where my issue lies.

I'm good on all the certificate stuff, it was actually pretty intuitive; nonetheless, thank you for your time!

-Ben

if you sign the JWT with the device private key how does the server verifies the signature? how do you provide the public key to the server?

See chapter 17.1 of http://www.ti.com/lit/ug/swru455j/swru455j.pdf for more details on the NetUtil command. I think it fits the ES256 requirements,