758 lines
22 KiB
C
758 lines
22 KiB
C
#include "system/includes.h"
|
||
#include "json_c/json_object.h"
|
||
#include "common/base64.h"
|
||
#include "common/aes.h"
|
||
#include "sock_api/sock_api.h"
|
||
#include "lwip.h"
|
||
#include "wifi/wifi_connect.h"
|
||
#include "mbedtls/aes.h"
|
||
#include "mbedtls/dhm.h"
|
||
#include "mbedtls/rsa.h"
|
||
#include "mbedtls/sha1.h"
|
||
#include "mbedtls/entropy.h"
|
||
#include "mbedtls/ctr_drbg.h"
|
||
|
||
#include "time.h"
|
||
#include <stdlib.h>
|
||
|
||
#if 1
|
||
#define log_info(x, ...) printf("\n\n>>>>>>[aplink_test]" x " ", ## __VA_ARGS__)
|
||
#else
|
||
#define log_info(...)
|
||
#endif
|
||
|
||
#define DH_INFO "{\"type\":\"dh\",\"sequence\":2,\"data\":{\"dh_key\":\"%s\",\"dh_p\":\"%s\",\"dh_g\":\"%s\"}}"
|
||
#define KEYNGREQ 0x01
|
||
#define DH 0x02
|
||
#define QPLINK 0x03
|
||
#define ACK 0x04
|
||
#define ELINK_SRV_PORT 32769 //服务器端口
|
||
#define IOT_SSID "ChinaIOT-%s-%02X%02X" //ssid格式
|
||
#define IOT_PWD "" //AP模式下登录密码，这里不设置密码
|
||
#define VENDOR "Vendor" //设备厂商
|
||
|
||
extern struct json_object *json_tokener_parse(const char *str);
|
||
const static int iot_device_send_keyngack(char *buf, int buf_len);
|
||
const static int iot_device_send_dh(char *buf, int buf_len);
|
||
const static int iot_device_send_aplinkget(char *buf, int buf_len);
|
||
static int dh_base64_decode(const unsigned char *input, unsigned char *output);
|
||
static int ap_elink_start(void);
|
||
void Hex2Str(const unsigned char *hex, char *str, int len);
|
||
static int dh_base64_encode(const unsigned char *input, const int len, unsigned char *output);
|
||
static int calculate_common_key(mbedtls_dhm_context *context, unsigned char *srv_pub, char *out_put);
|
||
static void iot_interact_to_app(void *client_sock);
|
||
static int aes_cbc_encode(unsigned char *input_buf, unsigned int input_len, unsigned char *key, unsigned char *encode_buf);
|
||
static int aes_cbc_decode(unsigned char *input_buf, unsigned int input_len, unsigned char *key, unsigned char *decode_buf);
|
||
static int iot_device_rec_handle(const char *object);
|
||
static int aplink_sock_write(void *sockhdl, const char *buf, size_t n);
|
||
extern int elink_aplink_set_ssid_pwd(const char *ssid, const char *pwd);
|
||
extern void get_wifi_mac_addr(u8 *mac_addr);
|
||
static void iot_device_enter_ap_mode(void);
|
||
static int flag;
|
||
|
||
typedef enum {
|
||
aplink_idel_state = 1,
|
||
aplink_wait_keyngreq,
|
||
aplink_wait_dh_info,
|
||
aplink_wait_aplink_info,
|
||
aplink_wait_ack,
|
||
aplink_qlink_finish,
|
||
} aplink_state;
|
||
|
||
typedef enum {
|
||
aplink_receive_keyngreq = 1,
|
||
aplink_receive_dh_info,
|
||
aplink_receive_aplink_info,
|
||
aplink_receive_ack,
|
||
} aplink_event;
|
||
|
||
typedef struct {
|
||
aplink_state curState;
|
||
aplink_event event;
|
||
const int (*aplink_action)(char *, int);
|
||
aplink_state nextState;
|
||
} aplink_state_change;
|
||
|
||
typedef struct {
|
||
aplink_state curState;
|
||
int stuNum;
|
||
aplink_state_change *form;
|
||
} elink_aplink;
|
||
|
||
typedef struct _iot_device_info {
|
||
unsigned char common_key[16];
|
||
char ssid[32];
|
||
char pwd[32];
|
||
unsigned char dh_key[36];
|
||
unsigned char dh_p[36];
|
||
unsigned char dh_g[12];
|
||
mbedtls_dhm_context dhm_cli;
|
||
elink_aplink e_aplink;
|
||
aplink_event e_event;
|
||
int protected;
|
||
} iot_device_info;
|
||
|
||
typedef struct _iot_rec_type {
|
||
char *rec_string;
|
||
uint8_t type;
|
||
} iot_rec_type;
|
||
|
||
static iot_device_info iot_device_local;
|
||
static mbedtls_ctr_drbg_context ctr_drbg;
|
||
static const char aplink_ver[] = "V1.0";
|
||
|
||
static void *ap_elink_sock = NULL;
|
||
static void *cli_sock = NULL;
|
||
static int aplink_get_ssid_pwd_success = 0;
|
||
static int local_pid = 0;
|
||
|
||
static iot_rec_type type_table[] = {
|
||
{"keyngreq", KEYNGREQ},
|
||
{"dh", DH},
|
||
{"aplink", QPLINK},
|
||
{"ack", ACK},
|
||
{NULL, 0}
|
||
};
|
||
|
||
//State Table : 当前状态 激发事件 回调函数 下一个状态
|
||
static aplink_state_change aplink_table[] = {
|
||
{aplink_idel_state, aplink_receive_keyngreq, iot_device_send_keyngack, aplink_wait_dh_info},
|
||
{aplink_wait_dh_info, aplink_receive_dh_info, iot_device_send_dh, aplink_wait_aplink_info},
|
||
{aplink_wait_aplink_info, aplink_receive_aplink_info, iot_device_send_aplinkget, aplink_wait_ack},
|
||
{aplink_wait_ack, aplink_receive_ack, NULL, aplink_qlink_finish},
|
||
};
|
||
|
||
const char *aplink_version(void)
|
||
{
|
||
return aplink_ver;
|
||
}
|
||
|
||
void Hex2Str(const unsigned char *hex, char *str, int len)
|
||
{
|
||
int i;
|
||
char temp[3];
|
||
|
||
for (i = 0; i < len; i++) {
|
||
sprintf(temp, "%02X", (unsigned char)hex[i]);
|
||
memcpy(&str[i * 2], temp, 2);
|
||
}
|
||
|
||
str[2 * len] = '\0';
|
||
}
|
||
|
||
static void aplink_state_transFer(elink_aplink *aplink, aplink_state state)
|
||
{
|
||
aplink->curState = state;
|
||
}
|
||
|
||
static int aplink_sock_write(void *sockhdl, const char *buf, size_t n)
|
||
{
|
||
size_t nLeft = n;
|
||
size_t nWrite = 0;
|
||
int ret;
|
||
|
||
while (nLeft > 0) {
|
||
ret = sock_send(sockhdl, buf + nWrite, nLeft, 0);
|
||
if (ret != nLeft) {
|
||
log_info("aplink_sock_write error occurred:%d\n", sock_get_error(sockhdl));
|
||
break;
|
||
} else {
|
||
nLeft -= ret;
|
||
nWrite += ret;
|
||
}
|
||
}
|
||
return nWrite == n ? n : -1;
|
||
}
|
||
|
||
static int aplink_eventHandle(elink_aplink *aqlink, const aplink_event event, void *parm)
|
||
{
|
||
aplink_state_change *changeTable = aqlink->form;
|
||
const int (*aplink_action)(char *, int) = NULL;
|
||
aplink_state nextState;
|
||
aplink_state curState = aqlink->curState;
|
||
unsigned something_happen = 0;
|
||
unsigned int i;
|
||
unsigned int ret;
|
||
char send_buf[512];
|
||
unsigned int len;
|
||
void *cli_sock = parm;
|
||
|
||
for (i = 0; i < aqlink->stuNum; i++) {
|
||
if (event == changeTable[i].event && curState == changeTable[i].curState) {
|
||
aplink_action = changeTable[i].aplink_action;
|
||
nextState = changeTable[i].nextState;
|
||
something_happen = 1;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (something_happen) {
|
||
if (aplink_action != NULL) {
|
||
len = aplink_action(send_buf, sizeof(send_buf));
|
||
if (len == -1) {
|
||
return -1;
|
||
}
|
||
|
||
os_time_dly(50);
|
||
|
||
ret = aplink_sock_write(cli_sock, send_buf, len);
|
||
if (ret == -1) {
|
||
log_info("sock_sendto err!!!");
|
||
return -1;
|
||
}
|
||
}
|
||
|
||
aplink_state_transFer(aqlink, nextState);
|
||
something_happen = 0;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
static void aplink_init(elink_aplink *aqlink, aplink_state curState, const int num, aplink_state_change *form)
|
||
{
|
||
aqlink->form = form;
|
||
aqlink->stuNum = num;
|
||
aqlink->curState = curState;
|
||
return;
|
||
}
|
||
|
||
static int dh_calculate_public_key(mbedtls_dhm_context *context, const char *p, const char *g, unsigned char *public)
|
||
{
|
||
int ret = 0;
|
||
const char *pers = "aplink";
|
||
unsigned char cli_pub[16];
|
||
mbedtls_entropy_context entropy;
|
||
|
||
mbedtls_dhm_init(context);
|
||
mbedtls_entropy_init(&entropy);
|
||
mbedtls_ctr_drbg_init(&ctr_drbg);
|
||
|
||
if ((ret = mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func, &entropy,
|
||
(const unsigned char *) pers,
|
||
strlen(pers))) != 0) {
|
||
|
||
mbedtls_printf("error!!! mbedtls_ctr_drbg_seed returned %d\n", ret);
|
||
goto EXIT;
|
||
}
|
||
|
||
mbedtls_mpi_read_string(&(context->P), 16, p);
|
||
mbedtls_mpi_read_string(&(context->G), 10, g);
|
||
context->len = mbedtls_mpi_size(&(context->P));
|
||
|
||
ret = mbedtls_dhm_make_public(context, 16, cli_pub, sizeof(cli_pub), mbedtls_ctr_drbg_random, &ctr_drbg);
|
||
if (ret != 0) {
|
||
mbedtls_printf(" error!!! mbedtls_dhm_make_public %d\n", ret);
|
||
goto EXIT;
|
||
}
|
||
|
||
memcpy(public, cli_pub, sizeof(cli_pub));
|
||
|
||
mbedtls_entropy_free(&entropy);
|
||
/* mbedtls_ctr_drbg_free(&ctr_drbg); */
|
||
return 0;
|
||
|
||
EXIT:
|
||
mbedtls_dhm_free(context);
|
||
mbedtls_entropy_free(&entropy);
|
||
mbedtls_ctr_drbg_free(&ctr_drbg);
|
||
return -1;
|
||
}
|
||
|
||
void aplink_cfg_start(void)
|
||
{
|
||
iot_device_enter_ap_mode();
|
||
}
|
||
|
||
static void wifi_set_lan_setting_info(void)
|
||
{
|
||
struct lan_setting lan_setting_info = {
|
||
|
||
.WIRELESS_IP_ADDR0 = 192,
|
||
.WIRELESS_IP_ADDR1 = 168,
|
||
.WIRELESS_IP_ADDR2 = 1,
|
||
.WIRELESS_IP_ADDR3 = 1,
|
||
|
||
.WIRELESS_NETMASK0 = 255,
|
||
.WIRELESS_NETMASK1 = 255,
|
||
.WIRELESS_NETMASK2 = 255,
|
||
.WIRELESS_NETMASK3 = 0,
|
||
|
||
.WIRELESS_GATEWAY0 = 192,
|
||
.WIRELESS_GATEWAY1 = 168,
|
||
.WIRELESS_GATEWAY2 = 1,
|
||
.WIRELESS_GATEWAY3 = 1,
|
||
|
||
.SERVER_IPADDR1 = 192,
|
||
.SERVER_IPADDR2 = 168,
|
||
.SERVER_IPADDR3 = 1,
|
||
.SERVER_IPADDR4 = 1,
|
||
|
||
.CLIENT_IPADDR1 = 192,
|
||
.CLIENT_IPADDR2 = 168,
|
||
.CLIENT_IPADDR3 = 1,
|
||
.CLIENT_IPADDR4 = 2,
|
||
|
||
.SUB_NET_MASK1 = 255,
|
||
.SUB_NET_MASK2 = 255,
|
||
.SUB_NET_MASK3 = 255,
|
||
.SUB_NET_MASK4 = 0,
|
||
};
|
||
net_set_lan_info(&lan_setting_info);
|
||
}
|
||
|
||
static void iot_device_enter_ap_mode(void)
|
||
{
|
||
u8 mac[6];
|
||
char device_mac[32];
|
||
|
||
wifi_get_mac(mac);
|
||
|
||
sprintf(device_mac, IOT_SSID, VENDOR, mac[0], mac[1]);
|
||
|
||
log_info("aplink ssid: %s", device_mac);
|
||
|
||
wifi_set_lan_setting_info(); //STA转AP模式,需要重新配置一下IP信息和DHCP池起始分配地址
|
||
wifi_enter_ap_mode(device_mac, IOT_PWD);
|
||
|
||
ap_elink_start();
|
||
}
|
||
|
||
/* void iot_device_enter_sta_mode(const char *ssid, const char *pwd) */
|
||
void iot_device_enter_sta_mode(char *ssid, char *pwd)
|
||
{
|
||
wifi_set_sta_connect_timeout(0);
|
||
wifi_enter_sta_mode(ssid, pwd);
|
||
wifi_store_mode_info(STA_MODE, ssid, pwd);
|
||
}
|
||
|
||
static void ap_elink_tcp_init(void *priv)
|
||
{
|
||
struct sockaddr_in client_addr;
|
||
socklen_t socketLength = sizeof(struct sockaddr_in);
|
||
|
||
ap_elink_sock = sock_reg(AF_INET, SOCK_STREAM, 0, NULL, NULL);
|
||
if (ap_elink_sock == NULL) {
|
||
log_info("ap_elink_tcp_init socket error");
|
||
goto EXIT;
|
||
}
|
||
|
||
if (sock_set_reuseaddr(ap_elink_sock)) {
|
||
log_info("sock_set_reuseaddr error");
|
||
goto EXIT;
|
||
}
|
||
|
||
struct sockaddr _ss;
|
||
struct sockaddr_in *dest_addr = (struct sockaddr_in *)&_ss;
|
||
dest_addr->sin_family = AF_INET;
|
||
dest_addr->sin_addr.s_addr = htonl(INADDR_ANY);
|
||
dest_addr->sin_port = htons(ELINK_SRV_PORT);
|
||
|
||
if (sock_bind(ap_elink_sock, (struct sockaddr *)&_ss, sizeof(_ss))) {
|
||
log_info("ap_elink_tcp_init bind error");
|
||
goto EXIT;
|
||
}
|
||
|
||
if (sock_listen(ap_elink_sock, 5)) {
|
||
log_info("ap_elink_tcp_init sock_listen error");
|
||
goto EXIT;
|
||
}
|
||
|
||
log_info("sock_accept starting......................");
|
||
cli_sock = sock_accept(ap_elink_sock, (struct sockaddr *)&client_addr, &socketLength, NULL, NULL);
|
||
flag = 0;
|
||
if (cli_sock == NULL) {
|
||
log_info("ap_elink_tcp_init sock_accept error");
|
||
goto EXIT;
|
||
}
|
||
|
||
log_info("Successfully connected. Network configuration is starting!!!.....................");
|
||
|
||
memset(&iot_device_local, 0, sizeof(iot_device_info));
|
||
|
||
aplink_init(&(iot_device_local.e_aplink), aplink_idel_state, sizeof(aplink_table) / sizeof(aplink_state_change), aplink_table);
|
||
|
||
extern int wifi_is_on(void);
|
||
while (wifi_is_on() == 0) {
|
||
os_time_dly(1);
|
||
}
|
||
|
||
iot_interact_to_app(cli_sock);
|
||
|
||
if (ap_elink_sock) {
|
||
sock_unreg(ap_elink_sock);
|
||
ap_elink_sock = NULL;
|
||
}
|
||
|
||
EXIT:
|
||
if (ap_elink_sock) {
|
||
sock_unreg(ap_elink_sock);
|
||
ap_elink_sock = NULL;
|
||
}
|
||
}
|
||
|
||
static int ap_elink_start(void)
|
||
{
|
||
if (thread_fork("ap_elink_tcp_init", 17, 2024, 0, &local_pid, ap_elink_tcp_init, NULL) != OS_NO_ERR) {
|
||
return -1;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
static void iot_interact_to_app(void *client_sock)
|
||
{
|
||
int recv_len = 0;
|
||
unsigned char recv_buf[1024] = {0};
|
||
unsigned char decode_buf[512] = {0};
|
||
int decode_len = 0;
|
||
int err = 0;
|
||
|
||
for (;;) {
|
||
recv_len = sock_recvfrom(client_sock, recv_buf, sizeof(recv_buf), 0, NULL, NULL);
|
||
if ((recv_len != -1) && (recv_len != 0)) {
|
||
if (iot_device_local.protected) {
|
||
/* put_buf(recv_buf, recv_len); */
|
||
|
||
decode_len = aes_cbc_decode(recv_buf + 8, recv_len - 8, iot_device_local.common_key, decode_buf);
|
||
decode_buf[decode_len] = '\0';
|
||
/* put_buf(iot_device_local.common_key, 16); */
|
||
log_info("recv string : %s", decode_buf);
|
||
err = iot_device_rec_handle((char *)decode_buf);
|
||
if (err == -1) {
|
||
log_info("iot_device_rec_handle err!!!\n");
|
||
goto EXIT;
|
||
}
|
||
} else {
|
||
recv_buf[recv_len] = '\0';
|
||
log_info("recv string : %s", recv_buf + 8);
|
||
err = iot_device_rec_handle((char *)(recv_buf + 8));
|
||
if (err == -1) {
|
||
log_info("iot_device_rec_handle err!!!\n");
|
||
goto EXIT;
|
||
}
|
||
}
|
||
|
||
memset(recv_buf, 0, sizeof(recv_buf));
|
||
|
||
os_time_dly(30);
|
||
} else {
|
||
log_info("sock_recvfrom err!!!");
|
||
goto EXIT;
|
||
}
|
||
|
||
err = aplink_eventHandle(&(iot_device_local.e_aplink), iot_device_local.e_event, client_sock);
|
||
if (err == -1) {
|
||
log_info("aplink_eventHandle err!!!\n");
|
||
goto EXIT;
|
||
}
|
||
|
||
/* if(iot_device_local.e_aplink.curState == aplink_qlink_finish) */
|
||
if (iot_device_local.e_aplink.curState == aplink_wait_ack) {
|
||
break;
|
||
}
|
||
}
|
||
|
||
aplink_get_ssid_pwd_success = 1;
|
||
log_info("Successfully obtained distribution network information.Connecting to network..........");
|
||
log_info("get ssid: %s, pwd: %s", iot_device_local.ssid, iot_device_local.pwd);
|
||
|
||
elink_aplink_set_ssid_pwd(iot_device_local.ssid, iot_device_local.pwd);
|
||
|
||
EXIT:
|
||
/* sock_unreg(client_sock); */
|
||
|
||
if (!aplink_get_ssid_pwd_success) {
|
||
log_info("Failed to connect to the Internet, please help me connect to the Internet again");
|
||
}
|
||
|
||
aplink_get_ssid_pwd_success = 0;
|
||
}
|
||
|
||
const static uint8_t check_rec_type(const char *string)
|
||
{
|
||
iot_rec_type *type_t = type_table;
|
||
while (type_t->rec_string) {
|
||
if (0 == strcmp(string, type_t->rec_string)) {
|
||
return type_t->type;
|
||
}
|
||
|
||
type_t++;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
static int iot_device_rec_handle(const char *object)
|
||
{
|
||
json_object *json = NULL;
|
||
json_object *result = NULL;
|
||
char *type = NULL;
|
||
int len = 0;
|
||
char dh_key[32];
|
||
unsigned char dh_cli_key[32];
|
||
unsigned char dh_ap_key[32];
|
||
char dh_p[64];
|
||
char dh_g[12];
|
||
unsigned char rec_buf[64];
|
||
|
||
if (NULL == object) {
|
||
log_info("Input is empty");
|
||
return -1;
|
||
}
|
||
|
||
json = json_tokener_parse(object);
|
||
if (NULL == json) {
|
||
log_info("Parsing error");
|
||
return -1;
|
||
}
|
||
|
||
type = (char *)json_object_get_string(json_object_object_get(json, "type"));
|
||
|
||
switch (check_rec_type(type)) {
|
||
case KEYNGREQ :
|
||
log_info("%s\n", object);
|
||
result = json_object_array_get_idx(json_object_object_get(json, "keymodelist"), 0);
|
||
log_info("the keymode is :%s\n", json_object_get_string(json_object_object_get(result, "keymode")));
|
||
iot_device_local.protected = 0;
|
||
iot_device_local.e_event = aplink_receive_keyngreq;
|
||
break;
|
||
|
||
case DH :
|
||
log_info("DH");
|
||
log_info("%s\n", object);
|
||
json_object_object_get_ex(json, "data", &result);
|
||
log_info("dh_key : %s\n", json_object_get_string(json_object_object_get(result, "dh_key")));
|
||
|
||
strcpy((char *)iot_device_local.dh_p, json_object_get_string(json_object_object_get(result, "dh_p")));
|
||
strcpy((char *)iot_device_local.dh_g, json_object_get_string(json_object_object_get(result, "dh_g")));
|
||
log_info("dh_p : %s\n", iot_device_local.dh_p);
|
||
log_info("dh_g : %s\n", iot_device_local.dh_g);
|
||
|
||
len = dh_base64_decode(iot_device_local.dh_p, rec_buf);
|
||
Hex2Str(rec_buf, dh_p, len);
|
||
log_info("dh_p : %s", dh_p);
|
||
|
||
len = dh_base64_decode((unsigned char *)iot_device_local.dh_g, rec_buf);
|
||
Hex2Str(rec_buf, dh_g, len);
|
||
log_info("dh_g : %s", dh_g);
|
||
|
||
dh_calculate_public_key(&(iot_device_local.dhm_cli), dh_p, dh_g, dh_ap_key);
|
||
|
||
dh_base64_encode(dh_ap_key, 16, iot_device_local.dh_key);
|
||
log_info("public_key encode : %s", iot_device_local.dh_key);
|
||
|
||
len = dh_base64_decode((unsigned char *)json_object_get_string(json_object_object_get(result, "dh_key")), dh_cli_key);
|
||
calculate_common_key(&(iot_device_local.dhm_cli), dh_cli_key, (char *)iot_device_local.common_key);
|
||
/* put_buf(iot_device_local.common_key, 16); */
|
||
|
||
iot_device_local.protected = 1;
|
||
iot_device_local.e_event = aplink_receive_dh_info;
|
||
os_time_dly(30);
|
||
break;
|
||
|
||
case QPLINK :
|
||
log_info("QPLINK");
|
||
log_info("%s\n", object);
|
||
if (0 != strcmp(json_object_get_string(json_object_object_get(json, "result")), "allow")) {
|
||
log_info("Failed to obtain information");
|
||
break;
|
||
}
|
||
|
||
json_object_object_get_ex(json, "wifi", &result);
|
||
|
||
strcpy(iot_device_local.ssid, json_object_get_string(json_object_object_get(result, "ssid")));
|
||
strcpy(iot_device_local.pwd, json_object_get_string(json_object_object_get(result, "password")));
|
||
log_info("ssid : %s\n", iot_device_local.ssid);
|
||
log_info("password : %s\n", iot_device_local.pwd);
|
||
iot_device_local.protected = 0;
|
||
iot_device_local.e_event = aplink_receive_aplink_info;
|
||
break;
|
||
|
||
case ACK :
|
||
log_info("ACK");
|
||
log_info("%s\n", object);
|
||
iot_device_local.e_event = aplink_receive_ack;
|
||
break;
|
||
|
||
default:
|
||
log_info("Data is not defined");
|
||
break;
|
||
}
|
||
|
||
json_object_put(json);
|
||
|
||
return 0;
|
||
}
|
||
|
||
static int dh_p_base64_encode(const unsigned char *p, const int p_len, unsigned char *output)
|
||
{
|
||
int out_len;
|
||
|
||
memcpy(output, base64_encode(p, p_len, &out_len), out_len);
|
||
*(output + out_len) = '\0';
|
||
|
||
return out_len;
|
||
}
|
||
|
||
static int dh_base64_encode(const unsigned char *input, const int len, unsigned char *output)
|
||
{
|
||
int out_len;
|
||
|
||
memcpy(output, base64_encode(input, len, &out_len), out_len);
|
||
*(output + out_len) = '\0';
|
||
|
||
return out_len;
|
||
}
|
||
|
||
static int dh_g_base64_encode(const unsigned char *g, const int g_len, unsigned char *output)
|
||
{
|
||
int out_len;
|
||
|
||
memcpy(output, base64_encode(g, g_len, &out_len), out_len);
|
||
*(output + out_len) = '\0';
|
||
|
||
return out_len;
|
||
}
|
||
|
||
static int calculate_common_key(mbedtls_dhm_context *context, unsigned char *srv_pub, char *out_put)
|
||
{
|
||
unsigned char secret[16];
|
||
int ret;
|
||
size_t n = 0;
|
||
|
||
/* mbedtls_ctr_drbg_context ctr_drbg; */
|
||
|
||
mbedtls_ctr_drbg_init(&ctr_drbg);
|
||
|
||
ret = mbedtls_dhm_read_public(context, srv_pub, 16);
|
||
|
||
ret = mbedtls_dhm_calc_secret(context, secret, sizeof(secret), &n, mbedtls_ctr_drbg_random, &ctr_drbg);
|
||
if (ret != 0) {
|
||
mbedtls_printf(" failed\n! mbedtls_dhm_calc_secret %d\n", ret);
|
||
return -1;
|
||
}
|
||
|
||
memcpy(out_put, secret, 16);
|
||
|
||
mbedtls_dhm_free(context);
|
||
mbedtls_ctr_drbg_free(&ctr_drbg);
|
||
|
||
return 0;
|
||
}
|
||
|
||
static int dh_base64_decode(const unsigned char *input, unsigned char *output)
|
||
{
|
||
int out_len;
|
||
|
||
memcpy(output, base64_decode(input, strlen((char *)input), &out_len), out_len);
|
||
/* put_buf(output, out_len); */
|
||
|
||
return out_len;
|
||
}
|
||
|
||
static int aes_cbc_encode(unsigned char *input_buf, unsigned int input_len, unsigned char *key, unsigned char *encode_buf)
|
||
{
|
||
|
||
unsigned char iv[16] = {0};
|
||
unsigned int encode_len;
|
||
|
||
CT_AES_CBC_Encrypt(input_buf, input_len, key, 16, iv, 16, encode_buf, &encode_len);
|
||
return encode_len;
|
||
}
|
||
|
||
static int aes_cbc_decode(unsigned char *input_buf, unsigned int input_len, unsigned char *key, unsigned char *decode_buf)
|
||
{
|
||
unsigned char iv[16] = {0};
|
||
unsigned int decode_len;
|
||
|
||
CT_AES_CBC_Decrypt(input_buf, input_len, key, 16, iv, 16, decode_buf, &decode_len);
|
||
return decode_len;
|
||
}
|
||
|
||
static int aqlink_package_assembly(char *data, int data_len, char *package, int package_buf_len)
|
||
{
|
||
if (data == NULL || data_len <= 0 || package == NULL || (data_len + 8) > package_buf_len) {
|
||
return -1;
|
||
}
|
||
|
||
package[0] = 0x3f;
|
||
package[1] = 0x72;
|
||
package[2] = 0x1f;
|
||
package[3] = 0xb5;
|
||
|
||
package[4] = (u8)(((u32)data_len >> 24) & 0x00ff);
|
||
package[5] = (u8)(((u32)data_len >> 16) & 0x00ff);
|
||
package[6] = (u8)(((u32)data_len >> 8) & 0x00ff);
|
||
package[7] = (u8)(((u32)data_len >> 0) & 0x00ff);
|
||
|
||
memcpy(package + 8, data, data_len);
|
||
|
||
return (data_len + 8);
|
||
}
|
||
|
||
const static int iot_device_send_keyngack(char *buf, int buf_len)
|
||
{
|
||
char temp_buf[512];
|
||
unsigned int len;
|
||
|
||
char *keyngack = "{\"type\":\"keyngack\",\"sequence\":1,\"keymode\":\"dh\"}";
|
||
|
||
len = aqlink_package_assembly(keyngack, strlen(keyngack), buf, buf_len);
|
||
|
||
return len;
|
||
}
|
||
|
||
const static int iot_device_send_dh(char *buf, int buf_len)
|
||
{
|
||
char temp_buf[256];
|
||
char key[64];
|
||
char dh_p[64];
|
||
char dh_g[64];
|
||
unsigned int len;
|
||
|
||
snprintf(temp_buf, sizeof(temp_buf), DH_INFO,
|
||
iot_device_local.dh_key,
|
||
iot_device_local.dh_p,
|
||
iot_device_local.dh_g);
|
||
|
||
log_info("iot_device_send_dh : %s", temp_buf);
|
||
|
||
len = aqlink_package_assembly(temp_buf, strlen(temp_buf), buf, buf_len);
|
||
|
||
return len;
|
||
}
|
||
|
||
const static int iot_device_send_aplinkget(char *buf, int buf_len)
|
||
{
|
||
unsigned int len;
|
||
unsigned char encode_buf[512];
|
||
int encode_len;
|
||
|
||
char *aplinkget = "{\"type\":\"aplinkget\",\"sequence\":3,\"result\":\"get\"}";
|
||
|
||
encode_len = aes_cbc_encode((unsigned char *)aplinkget, strlen((char *)aplinkget), iot_device_local.common_key, encode_buf);
|
||
|
||
len = aqlink_package_assembly((char *)encode_buf, encode_len, buf, buf_len);
|
||
|
||
/* char decode_buf[256]; */
|
||
/* int decode_len; */
|
||
/* decode_len = aes_cbc_decode(encode_buf, encode_len, iot_device_local.common_key, decode_buf); */
|
||
/* decode_buf[decode_len] = '\0'; */
|
||
/* log_info("aplinkget decode: %s", decode_buf); */
|
||
|
||
return len;
|
||
}
|
||
|
||
void qlink_cfg_stop(void)
|
||
{
|
||
if (ap_elink_sock) {
|
||
flag = 1;
|
||
sock_set_quit(ap_elink_sock);
|
||
while (flag) {
|
||
os_time_dly(20);
|
||
}
|
||
sock_unreg(ap_elink_sock);
|
||
ap_elink_sock = NULL;
|
||
}
|
||
}
|