241 lines
14 KiB
C
241 lines
14 KiB
C
|
#include "ble_cloud.h"
|
||
|
|
#include "call_client.h"
|
||
|
|
#include <stdio.h>
|
||
|
|
#include <stdlib.h>
|
||
|
|
#include <string.h>
|
||
|
|
#include <sys/time.h>
|
||
|
|
#include "cJSON.h"
|
||
|
|
#include "esp_crt_bundle.h"
|
||
|
|
#include "esp_random.h"
|
||
|
|
#include "esp_timer.h"
|
||
|
|
#include "mbedtls/base64.h"
|
||
|
|
#include "mbedtls/md.h"
|
||
|
|
#include "mbedtls/sha256.h"
|
||
|
|
#include "mbedtls/platform_util.h"
|
||
|
|
#include "nvs.h"
|
||
|
|
#include "nvs_flash.h"
|
||
|
|
|
||
|
|
static char factory_id[18], model[33], origin[160];
|
||
|
|
static uint8_t device_key[32];
|
||
|
|
static uint32_t key_version;
|
||
|
|
static bool configured;
|
||
|
|
static char voice_boot[37], time_challenge[37];
|
||
|
|
const char *ble_cloud_origin(void) { return origin; }
|
||
|
|
const char *ble_cloud_boot_id(void) { if (!voice_boot[0]) ble_random_uuid(voice_boot); return voice_boot; }
|
||
|
|
const char *ble_cloud_challenge_id(void) { return time_challenge; }
|
||
|
|
typedef struct { char data[4097]; size_t len; } response_t;
|
||
|
|
|
||
|
|
static esp_err_t response_event(esp_http_client_event_t *event)
|
||
|
|
{
|
||
|
|
response_t *r = event->user_data;
|
||
|
|
if (event->event_id == HTTP_EVENT_ON_DATA && event->data_len > 0) {
|
||
|
|
if (r->len + event->data_len >= sizeof(r->data)) return ESP_ERR_INVALID_SIZE;
|
||
|
|
memcpy(r->data + r->len, event->data, event->data_len);
|
||
|
|
r->len += event->data_len;
|
||
|
|
r->data[r->len] = 0;
|
||
|
|
}
|
||
|
|
return ESP_OK;
|
||
|
|
}
|
||
|
|
static const char *string(cJSON *obj, const char *key)
|
||
|
|
{
|
||
|
|
cJSON *v = cJSON_GetObjectItemCaseSensitive(obj, key);
|
||
|
|
return cJSON_IsString(v) ? v->valuestring : "";
|
||
|
|
}
|
||
|
|
static esp_err_t getstr(nvs_handle_t nvs, const char *key, char *out, size_t len)
|
||
|
|
{ return nvs_get_str(nvs, key, out, &len); }
|
||
|
|
esp_err_t ble_cloud_init(void)
|
||
|
|
{
|
||
|
|
if (configured) return ESP_OK;
|
||
|
|
esp_err_t err = nvs_flash_init_partition("ble_factory");
|
||
|
|
if (err != ESP_OK) return err; // Never erase factory credentials on an init error.
|
||
|
|
nvs_handle_t nvs;
|
||
|
|
err = nvs_open_from_partition("ble_factory", "identity", NVS_READONLY, &nvs);
|
||
|
|
if (err != ESP_OK) return err;
|
||
|
|
size_t len = sizeof(device_key);
|
||
|
|
err = getstr(nvs,"factory_id",factory_id,sizeof(factory_id));
|
||
|
|
if (err == ESP_OK) err = getstr(nvs,"model",model,sizeof(model));
|
||
|
|
if (err == ESP_OK) err = getstr(nvs,"origin",origin,sizeof(origin));
|
||
|
|
if (err == ESP_OK) err = nvs_get_blob(nvs,"device_key",device_key,&len);
|
||
|
|
if (err == ESP_OK && len != 32) err = ESP_ERR_INVALID_SIZE;
|
||
|
|
if (err == ESP_OK) err = nvs_get_u32(nvs,"key_version",&key_version);
|
||
|
|
nvs_close(nvs);
|
||
|
|
if (err != ESP_OK || strlen(factory_id) != 17 || strncmp(factory_id,"KP01-",5) ||
|
||
|
|
strspn(factory_id+5,"0123456789ABCDEF") != 12 || !model[0] || !key_version ||
|
||
|
|
strncmp(origin,"https://",8) || strchr(origin+8,'/') || strchr(origin,'@') ||
|
||
|
|
strpbrk(origin,"\r\n?#")) { mbedtls_platform_zeroize(device_key,32); return ESP_ERR_INVALID_ARG; }
|
||
|
|
// Move this project's old server address without rewriting factory keys.
|
||
|
|
if (!strcmp(origin,"https://121.41.46.238"))
|
||
|
|
snprintf(origin,sizeof(origin),"https://82.157.201.114");
|
||
|
|
configured = true;
|
||
|
|
return ESP_OK;
|
||
|
|
}
|
||
|
|
bool ble_cloud_configured(void) { return configured; }
|
||
|
|
const char *ble_factory_id(void) { return factory_id; }
|
||
|
|
const char *ble_factory_model(void) { return model; }
|
||
|
|
esp_err_t ble_factory_security(uint8_t salt[16], uint8_t verifier[384])
|
||
|
|
{
|
||
|
|
nvs_handle_t nvs;
|
||
|
|
esp_err_t err = nvs_open_from_partition("ble_factory","identity",NVS_READONLY,&nvs);
|
||
|
|
if (err != ESP_OK) return err;
|
||
|
|
size_t len = 16;
|
||
|
|
err = nvs_get_blob(nvs,"salt",salt,&len);
|
||
|
|
if (err == ESP_OK && len != 16) err = ESP_ERR_INVALID_SIZE;
|
||
|
|
len = 384;
|
||
|
|
if (err == ESP_OK) err = nvs_get_blob(nvs,"verifier",verifier,&len);
|
||
|
|
if (err == ESP_OK && len != 384) err = ESP_ERR_INVALID_SIZE;
|
||
|
|
nvs_close(nvs);
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
void ble_random_uuid(char out[37])
|
||
|
|
{
|
||
|
|
uint8_t b[16]; esp_fill_random(b,16); b[6]=(b[6]&15)|64; b[8]=(b[8]&63)|128;
|
||
|
|
snprintf(out,37,"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",b[0],b[1],b[2],b[3],b[4],b[5],b[6],b[7],b[8],b[9],b[10],b[11],b[12],b[13],b[14],b[15]);
|
||
|
|
}
|
||
|
|
static void hex(const uint8_t *in, size_t n, char *out)
|
||
|
|
{ for(size_t i=0;i<n;i++) snprintf(out+i*2,3,"%02x",in[i]); }
|
||
|
|
static void mac(const char *input, char out[65])
|
||
|
|
{
|
||
|
|
uint8_t h[32];
|
||
|
|
mbedtls_md_hmac(mbedtls_md_info_from_type(MBEDTLS_MD_SHA256),device_key,32,(const uint8_t*)input,strlen(input),h);
|
||
|
|
hex(h,32,out); mbedtls_platform_zeroize(h,32);
|
||
|
|
}
|
||
|
|
static void nonce(char out[23])
|
||
|
|
{
|
||
|
|
uint8_t b[16], encoded[25]; size_t len;
|
||
|
|
esp_fill_random(b,16); mbedtls_base64_encode(encoded,sizeof(encoded),&len,b,16);
|
||
|
|
for(size_t i=0;i<22;i++) out[i]=encoded[i]=='+'?'-':encoded[i]=='/'?'_':encoded[i];
|
||
|
|
out[22]=0;
|
||
|
|
}
|
||
|
|
esp_err_t ble_cloud_bootstrap(const char *client_nonce, char **response, char password[65])
|
||
|
|
{
|
||
|
|
if(!configured||!client_nonce||strlen(client_nonce)!=22||strspn(client_nonce,"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_")!=22)return ESP_ERR_INVALID_ARG;
|
||
|
|
char server_nonce[23],transcript[256],proof[65];nonce(server_nonce);
|
||
|
|
snprintf(transcript,sizeof(transcript),"BLE-PROOF1\n%s\n%s\n%lu\n%s\n%s",factory_id,model,(unsigned long)key_version,client_nonce,server_nonce);
|
||
|
|
mac(transcript,proof);
|
||
|
|
snprintf(transcript,sizeof(transcript),"BLE-PASS1\n%s\n%s\n%lu\n%s\n%s",factory_id,model,(unsigned long)key_version,client_nonce,server_nonce);
|
||
|
|
mac(transcript,password);
|
||
|
|
cJSON *out=cJSON_CreateObject();if(!out)return ESP_ERR_NO_MEM;
|
||
|
|
cJSON_AddStringToObject(out,"device_id",factory_id);cJSON_AddStringToObject(out,"model",model);
|
||
|
|
cJSON_AddNumberToObject(out,"key_version",key_version);
|
||
|
|
cJSON_AddStringToObject(out,"client_nonce",client_nonce);cJSON_AddStringToObject(out,"server_nonce",server_nonce);cJSON_AddStringToObject(out,"proof",proof);
|
||
|
|
*response=cJSON_PrintUnformatted(out);cJSON_Delete(out);
|
||
|
|
mbedtls_platform_zeroize(transcript,sizeof(transcript));
|
||
|
|
return *response?ESP_OK:ESP_ERR_NO_MEM;
|
||
|
|
}
|
||
|
|
esp_err_t ble_cloud_headers(esp_http_client_handle_t client,const char *method,const char *path,const char *body,const char *request_id)
|
||
|
|
{
|
||
|
|
if (!configured) return ESP_ERR_INVALID_STATE;
|
||
|
|
char timestamp[24], version[16], random[23], digest[65], signature[65], auth[86], canonical[768];
|
||
|
|
struct timeval tv; gettimeofday(&tv,NULL);
|
||
|
|
snprintf(timestamp,sizeof(timestamp),"%lld",(long long)tv.tv_sec*1000+tv.tv_usec/1000);
|
||
|
|
snprintf(version,sizeof(version),"%lu",(unsigned long)key_version);
|
||
|
|
nonce(random); uint8_t hash[32]; mbedtls_sha256((const uint8_t*)body,strlen(body),hash,0); hex(hash,32,digest);
|
||
|
|
int n=snprintf(canonical,sizeof(canonical),"DEVREQ1\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s",method,path,factory_id,version,timestamp,random,request_id,digest);
|
||
|
|
if(n<0 || n>=sizeof(canonical)) return ESP_ERR_INVALID_SIZE;
|
||
|
|
mac(canonical,signature); snprintf(auth,sizeof(auth),"Device-HMAC-SHA256 %s",signature);
|
||
|
|
esp_err_t err=esp_http_client_set_header(client,"X-Device-ID",factory_id);
|
||
|
|
if(err==ESP_OK) err=esp_http_client_set_header(client,"X-Key-Version",version);
|
||
|
|
if(err==ESP_OK) err=esp_http_client_set_header(client,"X-Timestamp-Ms",timestamp);
|
||
|
|
if(err==ESP_OK) err=esp_http_client_set_header(client,"X-Nonce",random);
|
||
|
|
if(err==ESP_OK) err=esp_http_client_set_header(client,"X-Request-ID",request_id);
|
||
|
|
if(err==ESP_OK) err=esp_http_client_set_header(client,"Authorization",auth);
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
static esp_err_t post(const char *path,const char *body,const char *request_id,response_t *out,int *status,bool signed_request)
|
||
|
|
{
|
||
|
|
char url[256];
|
||
|
|
// TIME1 is the sole HTTP endpoint: its response is bound to a fresh nonce
|
||
|
|
// and authenticated with the factory key. Every credential-bearing call is HTTPS.
|
||
|
|
if(!signed_request && !strcmp(path,"/api/v1/device/time-challenges"))snprintf(url,sizeof(url),"http://%s%s",origin+8,path);
|
||
|
|
else snprintf(url,sizeof(url),"%s%s",origin,path);
|
||
|
|
esp_http_client_config_t cfg={.url=url,.timeout_ms=!strcmp(path,"/api/v1/device/ble-bind")?45000:15000,.crt_bundle_attach=esp_crt_bundle_attach,
|
||
|
|
.event_handler=response_event,.user_data=out,.disable_auto_redirect=true,.buffer_size=1024,.buffer_size_tx=1536};
|
||
|
|
esp_http_client_handle_t client=esp_http_client_init(&cfg);
|
||
|
|
if(!client) return ESP_ERR_NO_MEM;
|
||
|
|
esp_http_client_set_method(client,HTTP_METHOD_POST);
|
||
|
|
esp_http_client_set_header(client,"Content-Type","application/json");
|
||
|
|
esp_http_client_set_post_field(client,body,strlen(body));
|
||
|
|
esp_err_t err=signed_request?ble_cloud_headers(client,"POST",path,body,request_id):ESP_OK;
|
||
|
|
if(err==ESP_OK) err=esp_http_client_perform(client);
|
||
|
|
*status=esp_http_client_get_status_code(client); esp_http_client_cleanup(client);
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
esp_err_t ble_cloud_sync_time(void)
|
||
|
|
{
|
||
|
|
const char *boot=ble_cloud_boot_id(); char random[23], body[256]; nonce(random);
|
||
|
|
snprintf(body,sizeof(body),"{\"device_id\":\"%s\",\"key_version\":%lu,\"boot_id\":\"%s\",\"client_nonce\":\"%s\"}",factory_id,(unsigned long)key_version,boot,random);
|
||
|
|
response_t *r=calloc(1,sizeof(*r)); if(!r) return ESP_ERR_NO_MEM;
|
||
|
|
int status=0; int64_t start=esp_timer_get_time();
|
||
|
|
esp_err_t err=post("/api/v1/device/time-challenges",body,NULL,r,&status,false);
|
||
|
|
if(err!=ESP_OK || status!=200){free(r);return ESP_FAIL;}
|
||
|
|
cJSON *root=cJSON_Parse(r->data);
|
||
|
|
const char *payload=string(root,"payload_b64"), *signature=string(root,"mac_hex");
|
||
|
|
char expected[65], canonical[3600];
|
||
|
|
if(strlen(payload)>3400 || strlen(signature)!=64){cJSON_Delete(root);free(r);return ESP_FAIL;}
|
||
|
|
snprintf(canonical,sizeof(canonical),"TIME1\n%s",payload); mac(canonical,expected);
|
||
|
|
unsigned mismatch=0; for(int i=0;i<64;i++) mismatch|=expected[i]^signature[i];
|
||
|
|
uint8_t decoded[2600]; char encoded[3500]; size_t len=strlen(payload),decoded_len=0;
|
||
|
|
memcpy(encoded,payload,len);
|
||
|
|
for(size_t i=0;i<len;i++){if(encoded[i]=='-')encoded[i]='+';else if(encoded[i]=='_')encoded[i]='/';}
|
||
|
|
while(len%4) encoded[len++]='=';
|
||
|
|
if(mismatch || mbedtls_base64_decode(decoded,sizeof(decoded)-1,&decoded_len,(uint8_t*)encoded,len)!=0){cJSON_Delete(root);free(r);return ESP_FAIL;}
|
||
|
|
decoded[decoded_len]=0; cJSON *p=cJSON_Parse((char*)decoded); cJSON *time=cJSON_GetObjectItemCaseSensitive(p,"server_time_ms");
|
||
|
|
bool valid=!strcmp(string(p,"device_id"),factory_id)&&!strcmp(string(p,"boot_id"),boot)&&!strcmp(string(p,"client_nonce"),random)&&cJSON_IsNumber(time)&&time->valuedouble>1700000000000.0&&esp_timer_get_time()-start<15000000;
|
||
|
|
if(valid){int64_t ms=(int64_t)time->valuedouble;struct timeval tv={.tv_sec=ms/1000,.tv_usec=(ms%1000)*1000};settimeofday(&tv,NULL);snprintf(time_challenge,sizeof(time_challenge),"%s",string(p,"challenge_id"));}
|
||
|
|
cJSON_Delete(p);cJSON_Delete(root);free(r);return valid?ESP_OK:ESP_FAIL;
|
||
|
|
}
|
||
|
|
esp_err_t ble_cloud_bind(const char *token,const char *request_id)
|
||
|
|
{
|
||
|
|
if(!configured) return ESP_ERR_INVALID_STATE;
|
||
|
|
if(ble_cloud_sync_time()!=ESP_OK) return ESP_FAIL;
|
||
|
|
char body[80];snprintf(body,sizeof(body),"{\"bind_token\":\"%s\"}",token);
|
||
|
|
response_t *r=calloc(1,sizeof(*r));if(!r)return ESP_ERR_NO_MEM;
|
||
|
|
int status=0;esp_err_t err=post("/api/v1/device/ble-bind",body,request_id,r,&status,true);
|
||
|
|
if(err==ESP_OK){
|
||
|
|
cJSON *root=cJSON_Parse(r->data),*data=cJSON_GetObjectItemCaseSensitive(root,"data");
|
||
|
|
if(status==200&&cJSON_IsTrue(cJSON_GetObjectItemCaseSensitive(root,"ok"))&&!strcmp(string(data,"status"),"success")) {
|
||
|
|
err=call_client_save_bind_voice(data);
|
||
|
|
// Incomplete responses/storage failures retain the same pending
|
||
|
|
// token for retry; they do not mean the account binding was denied.
|
||
|
|
if(err!=ESP_OK)err=ESP_FAIL;
|
||
|
|
}
|
||
|
|
else if(status>=400&&status<500&&status!=408&&status!=429) err=ESP_ERR_INVALID_RESPONSE;
|
||
|
|
else err=ESP_FAIL;
|
||
|
|
cJSON *secret=cJSON_GetObjectItemCaseSensitive(data,"device_secret");
|
||
|
|
if(cJSON_IsString(secret))mbedtls_platform_zeroize(secret->valuestring,strlen(secret->valuestring));
|
||
|
|
cJSON_Delete(root);
|
||
|
|
}
|
||
|
|
mbedtls_platform_zeroize(r,sizeof(*r));free(r);return err;
|
||
|
|
}
|
||
|
|
esp_err_t ble_cloud_check_bound(const char *request_id)
|
||
|
|
{
|
||
|
|
if(!configured)return ESP_ERR_INVALID_STATE;
|
||
|
|
if(ble_cloud_sync_time()!=ESP_OK)return ESP_FAIL;
|
||
|
|
response_t *r=calloc(1,sizeof(*r));if(!r)return ESP_ERR_NO_MEM;
|
||
|
|
int status=0;esp_err_t err=post("/api/v1/device/ble-state","{}",request_id,r,&status,true);
|
||
|
|
if(err==ESP_OK){
|
||
|
|
cJSON *root=cJSON_Parse(r->data),*data=cJSON_GetObjectItemCaseSensitive(root,"data"),*bound=cJSON_GetObjectItemCaseSensitive(data,"bound");
|
||
|
|
if(status==200&&cJSON_IsTrue(cJSON_GetObjectItemCaseSensitive(root,"ok"))&&cJSON_IsBool(bound))err=cJSON_IsTrue(bound)?ESP_OK:ESP_ERR_INVALID_RESPONSE;
|
||
|
|
else if(status>=400&&status<500&&status!=408&&status!=429)err=ESP_ERR_INVALID_RESPONSE;
|
||
|
|
else err=ESP_FAIL;
|
||
|
|
cJSON_Delete(root);
|
||
|
|
}
|
||
|
|
mbedtls_platform_zeroize(r,sizeof(*r));free(r);return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
char *ble_cloud_decode(const char *domain,const char *encoded,const char *signature)
|
||
|
|
{
|
||
|
|
if(!configured || !domain || !encoded || !signature || strlen(signature)!=64 || strlen(encoded)>32768 ||
|
||
|
|
strspn(encoded,"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_")!=strlen(encoded))return NULL;
|
||
|
|
size_t n=strlen(encoded),d=strlen(domain),out_len=0;
|
||
|
|
char *canonical=malloc(n+d+2),*padded=calloc(1,n+5),*out=calloc(1,n+1);
|
||
|
|
if(!canonical||!padded||!out){free(canonical);free(padded);free(out);return NULL;}
|
||
|
|
snprintf(canonical,n+d+2,"%s\n%s",domain,encoded);
|
||
|
|
char expected[65];mac(canonical,expected);unsigned mismatch=0;
|
||
|
|
for(int i=0;i<64;i++)mismatch|=expected[i]^signature[i];
|
||
|
|
memcpy(padded,encoded,n);for(size_t i=0;i<n;i++){if(padded[i]=='-')padded[i]='+';else if(padded[i]=='_')padded[i]='/';}
|
||
|
|
size_t len=n;while(len%4)padded[len++]='=';
|
||
|
|
bool ok=!mismatch&&mbedtls_base64_decode((uint8_t*)out,n,&out_len,(uint8_t*)padded,len)==0;
|
||
|
|
free(canonical);free(padded);if(!ok){free(out);return NULL;}out[out_len]=0;return out;
|
||
|
|
}
|