Network-Modules/Drivers/Modules/Tuoreniot.c

#include "stm32f10x.h"
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <stdlib.h>
#include "Tuoreniot.h"

#include "mbedtls_util.h"
#include "Log_Module.h"
#include "At_Module.h"
#include "Common_Util.h"
#include "ec800m.h"
#include "cJSON.h"
#include "FlashSetup.h"
#include "Timer_Module.h"
#include "CoAP_Util.h"

// 泵号
extern uint8_t mcu_id[8];

// 注册时用的密钥
char regist_key[17]="tuorenzhinenghua";

// 注册数据
uint8_t regist_data[1024];
uint16_t regist_data_length;

#if  PROD_ENV
// 生产环境
char * REGIST_SERVER = "iot.tuoren.com" ; //注册服务器地址
uint16_t REGIST_PORT = 8888; //端口号
#endif

#if TEST_ENV

char * REGIST_SERVER = "18017zi0ec26.vicp.fun" ; //注册服务器地址
uint16_t REGIST_PORT = 58562; //端口号

#endif



// 从flash中读取注册响应
static void ReadRegistResponseFromFlash(void);
// 将注册响应写入到flash中
static void WriteRegistResponseToFlash(void);

// 注册结果
struct TUORENIOT_RegistResponseStruct regist_response = {
	.version = 1
};

// 初始化clientID
static char ClientID[60];
static void InitClientId(void)
{
	// 设置clientid
	memset(ClientID, 0, sizeof(ClientID));
	strcat(ClientID, regist_response.productKey);
	strcat(ClientID, "&");
	strcat(ClientID, regist_response.deviceId);
}

/*************************************** 注册信息打包函数 ***************************************/
void TUORENIOT_PackRegistRequest(uint8_t * pack_data, uint16_t * pack_data_length, struct TUORENIOT_RegistRequestStruct * registParams)
{
	
	Log_Printf_Debug("mcu_id: %s\r\n", mcu_id);
	byteToHexStr(mcu_id, registParams->deviceId, sizeof(mcu_id));

	sprintf((char *)(pack_data + 2), "{\"version\":\"%d\",\"networkType\":\"%d\",\"networkProtocol\":\"%d\",\"productId\":\"%s\",\"deviceId\":\"%s\",\"userId\":\"%s\",\"sim\":\"%s\"}", 
	registParams->version, registParams->networkType, registParams->networkProtocol, registParams->productId, registParams->deviceId, registParams->userId, registParams->sim); // 拼接AT指令
	Log_Printf_Debug("%s\r\n", (char *)(pack_data + 2));
	
	uint16_t datalen = utils_aes128_ECB_base64_enc_with_length(regist_key, (pack_data + 2));
	
	pack_data[0] = datalen>>8;//头2个字节赋值数据长度
	pack_data[1] = datalen;

	* pack_data_length = datalen + 2;
}

/*************************************** 注册数据解密函数 ***************************************/

static int wifi_count=0;	//WiFi信息计数变量
uint8_t TUORENIOT_AnalysisRegistData(uint8_t * regist_data, uint16_t regist_data_length)
{
	Log_Printf_Debug("regist_data: \r\n");
	Log_SendHex(regist_data, regist_data_length);
	Log_Printf_Debug("\r\n");

	uint8_t result;
	utils_aes128_ECB_base64_dec(regist_key,regist_data,regist_data_length);
	Log_Printf_Debug("解密数据(%d):%s\r\n", regist_data_length, (char *)regist_data);

	cJSON *json = cJSON_Parse((char *)regist_data);
	if(!json)
	{
		Log_Printf_Debug("json parse error,%s\r\n",cJSON_GetErrorPtr());
		result = 0;
	}
	else if(cJSON_GetObjectItem(json, "code")->valueint == 200)
	{
		regist_response.code = cJSON_GetObjectItem(json, "code")->valueint;
		regist_response.version = cJSON_GetObjectItem(json, "version")->valueint;
		regist_response.platform = cJSON_GetObjectItem(json, "platform")->valueint;
		regist_response.networkType = cJSON_GetObjectItem(json, "networkType")->valueint;
		regist_response.networkProtocol = cJSON_GetObjectItem(json, "networkProtocol")->valueint;
		strcpy(regist_response.productId, cJSON_GetObjectItem(json, "productId")->valuestring);
		strcpy(regist_response.deviceId, cJSON_GetObjectItem(json, "deviceId")->valuestring);
		strcpy(regist_response.userId, cJSON_GetObjectItem(json, "userId")->valuestring);
		strcpy(regist_response.deviceSecret, cJSON_GetObjectItem(json, "deviceSecret")->valuestring);
		strcpy(regist_response.remoteAddress, cJSON_GetObjectItem(json, "remoteAddress")->valuestring);
		regist_response.remotePort = cJSON_GetObjectItem(json, "remotePort")->valueint;
		
		if(regist_response.platform == 1)
		{
			strcpy(regist_response.productKey, cJSON_GetObjectItem(json, "productKey")->valuestring);
		}
		else 
		{
			strcpy(regist_response.productKey, regist_response.productId);
		}
		
		// 判断是否解析WiFi信息
		if(regist_response.networkType == 3)
		{
			Log_Printf_Debug("---------------------解析WiFi信息----------------------\r\n");
			cJSON *wifi_Array = cJSON_GetObjectItem(json, "wifi");
			regist_response.wifiNumber = cJSON_GetArraySize(wifi_Array);
			Log_Printf_Debug("wifiNumber=%d\r\n",regist_response.wifiNumber);
			if (cJSON_IsArray(wifi_Array)) 
			{  	
				cJSON *wifiElement = NULL;  
				cJSON_ArrayForEach(wifiElement, wifi_Array) 
				{  
					// 提取wifiName  
					cJSON *wifiName = cJSON_GetObjectItem(wifiElement, "wifiName");
					strcpy(regist_response.wifi[wifi_count].wifiName,wifiName->valuestring);	
					// 提取wifiPassword  
					cJSON *wifiPassword = cJSON_GetObjectItem(wifiElement, "wifiPassword"); 
					strcpy(regist_response.wifi[wifi_count].wifiPassword,wifiPassword->valuestring);
					//解析WiFi信息计数
					wifi_count++;
				}	
			}
			//校验解析的WiFi信息数目是否正确
			if(wifi_count != regist_response.wifiNumber)
			{
				Log_Printf_Debug("wifi_count=%d\r\n",wifi_count);
				Log_Printf_Debug("解析wifi信息ERROR!!!\r\n");
				result = 0;
				cJSON_Delete(json);
				return result;
			}
			//打印解析的WiFi信息
			Log_Printf_Debug("解析出%d组wifi信息如下:\r\n",wifi_count);
			for(int i=0;i<wifi_count;i++)
			{
				Log_Printf_Debug("wifi[%d]->wifiName: %s\r\n", i,regist_response.wifi[i].wifiName);
				Log_Printf_Debug("wifi[%d]->wifiPassword: %s\r\n", i,regist_response.wifi[i].wifiPassword);
			}
			Log_Printf_Debug("-------------------------结束--------------------------\r\n");
		}
		result = 1;
		WriteRegistResponseToFlash();
	}
	else
	{
		result = 0;
	}
	cJSON_Delete(json);
	return result;
}



static uint32_t SeqOffset = 0;
static char Random[20];
static char Token[50];

// 判断是否认证
uint8_t TUORENIOT_IsAuthentication(void)
{
	if(strlen(Token) > 0) // 已认证
	{
		return 1;
	}
	else
	{
		return 0;
	}
}



// 拼接认证报文

static char StrForSignature[100];
static char sign[50];
static uint8_t payload[256];
void TUORENIOT_PackAuthMessage(uint8_t * coap_message, uint16_t * coap_message_length)
{
//	Log_Printf_Debug("<<STEP: 拼接认证报文\r\n");
//	TUORENIOT_PrintfRegistResponseStruct();
	SeqOffset = 888;
	// 初始化clientId
	InitClientId();
	// CoAP协议
	CoAP_Init(coap_message);
	CoAP_Set_T(0);
	CoAP_Set_Code(2);
	CoAP_Set_MessageID(SeqOffset);
	// option
	// host
	CoAP_Set_Option_Str(3, regist_response.remoteAddress);
	// port
	CoAP_Set_Option_Short(7, regist_response.remotePort);
	// path
	CoAP_Set_Option_Str(11, "auth");
	// content-format
	CoAP_Set_Option_Short(12, 50);
	// accept
	CoAP_Set_Option_Short(17, 50);
	
	// 待签名数据
	// 签名相关
	memset(StrForSignature, 0, sizeof(StrForSignature));
	sprintf(StrForSignature, "clientId%sdeviceName%sproductKey%sseq%d", ClientID, regist_response.deviceId,regist_response.productKey, SeqOffset);
//	Log_Printf_Debug("认证报文StrForSignature:\r\n%s\r\n", StrForSignature);
	// 签名
	memset(sign, 0, sizeof(sign));
	utils_hmac_sha1_str(StrForSignature, strlen((char * )StrForSignature), sign, regist_response.deviceSecret, strlen(regist_response.deviceSecret));

//	Log_Printf_Debug("签名sign:\r\n%s\r\n", sign);

	// payload
	memset(payload, 0, sizeof(payload));
	sprintf((char * )payload, "{\"clientId\":\"%s\",\"signmethod\":\"hmacsha1\",\"sign\":\"%s\",\"productKey\":\"%s\",\"deviceName\":\"%s\",\"seq\":\"%d\"}", ClientID, sign, regist_response.productKey, regist_response.deviceId, SeqOffset);
	// 设置payload
	CoAP_Set_Payload_Str((char *)payload);
	
	
//	Log_Printf_Debug("payload:\r\n%s\r\n", payload);
	
	// 生成报文
	* coap_message_length = CoAP_Get_Length();
//	Log_Printf_Debug("STEP: 拼接认证报文>>\r\n");
}


// 拼接数据报文
// aes cbc

static uint8_t aes_key[16] = {0};
static char iv[] = "543yhjy97ae7fyfg";
static char out[80];
static char sha256_source[100];

static char Rand2089[10] = {'\0'};
static uint8_t Opt2089[20];
void TUORENIOT_PackDataMessage(uint8_t * data, uint8_t data_length, uint8_t * coap_message, uint16_t * coap_message_length)
{
//	Log_Printf_Debug("<<STEP: 拼接数据报文\r\n");
	// 初始化clientId
	InitClientId();

//	Log_Printf_Debug("SeqOffset：%d\r\n", SeqOffset);
	
	// 获取密钥
	memset(sha256_source, 0, sizeof(sha256_source));
	snprintf(sha256_source, sizeof(sha256_source), "%s,%s" ,regist_response.deviceSecret ,Random);
//	Log_Printf_Debug("sha256_source:\r\n%s\r\n", sha256_source);
	memset(out, 0, sizeof(out));
	utils_sha256(sha256_source, strlen(sha256_source), out);
	
//	Log_Printf_Debug("out:\r\n");
//	Log_SendHex((uint8_t *)out, strlen(out));
//	Log_Printf_Debug("\r\n");
	
	
	memset(aes_key, 0, sizeof(aes_key));
	memcpy(aes_key, out+8, 16); //获取key
//	Log_Printf_Debug("aes_key:\r\n");
//	Log_SendHex(aes_key, 16);
//	Log_Printf_Debug("\r\n");
	
	// CoAP协议
	CoAP_Init(coap_message);
	CoAP_Set_T(0);
	CoAP_Set_Code(2);
	CoAP_Set_MessageID(++SeqOffset);
	// option
	// host
	CoAP_Set_Option_Str(3, regist_response.remoteAddress);
	// port
	CoAP_Set_Option_Short(7, regist_response.remotePort);
	// path
	CoAP_Set_Option_Str(11, "topic");
	CoAP_Set_Option_Str(11, "sys");
	CoAP_Set_Option_Str(11, regist_response.productKey);
	CoAP_Set_Option_Str(11, regist_response.deviceId);
	CoAP_Set_Option_Str(11, "thing");
	CoAP_Set_Option_Str(11, "model");
	CoAP_Set_Option_Str(11, "up_raw");
	// content-format
	CoAP_Set_Option_Short(12, 50);
	// accept
	CoAP_Set_Option_Short(17, 50);
	// 2088
	CoAP_Set_Option_Str(2088, Token);
	// 2089
	memset(Rand2089, 0, sizeof(Rand2089));
	memset(Opt2089, 0, sizeof(Opt2089));
	my_itoa(SeqOffset, Rand2089, 10);
	int Opt2089_Length = utils_aes128_cbc_enc_with_length(aes_key, iv, (uint8_t *)Rand2089, strlen(Rand2089), Opt2089);
	CoAP_Set_Option(2089,Opt2089_Length, Opt2089);
	
//	Log_Printf_Debug("Opt2089:\r\n");
//	Log_SendHex(Opt2089, Opt2089_Length);
//	Log_Printf_Debug("\r\n");
	
//	Log_Printf_Debug("data:\r\n");
//	Log_SendHex(data, data_length);
//	Log_Printf_Debug("\r\n");
	// payload
	memset(payload, 0, sizeof(payload));
	int payload_length = utils_aes128_cbc_enc_with_length(aes_key, iv, data, data_length, payload);
	
	CoAP_Set_Payload(payload, payload_length);
	
//	Log_Printf_Debug("payload:\r\n");
//	Log_SendHex(payload, payload_length);
//	Log_Printf_Debug("\r\n");
	
	// 生成报文
	* coap_message_length = CoAP_Get_Length();
//	Log_Printf_Debug("STEP: 拼接数据报文>>\r\n");
}



// 设置Token
static void set_token(char * token)
{
	memset(Token, 0, sizeof(Token));
	strcpy(Token, token);
}
static void set_random(char * random)
{
	memset(Random, 0, sizeof(Random));
	strcpy(Random, random);
}
static void set_seqOffset(uint32_t seqOffset)
{
	SeqOffset = seqOffset;
}
// 接收数据处理
static uint8_t plaintext[256]; // 明文
uint8_t TUORENIOT_AnalysisMessage(uint8_t * coap_message, uint16_t coap_message_length)
{
//	Log_Printf_Debug("coap_message(%d):\r\n", coap_message_length);
//	Log_SendHex(coap_message, coap_message_length);
//	Log_Printf_Debug("\r\n");
	
	memset(payload, 0, sizeof(payload));
	uint16_t payload_length = CoAP_Get_Payload(coap_message, coap_message_length, payload);
	
	Log_Printf_Debug("payload长度: %d\r\n", payload_length);
	
	// 判断是认证返回，还是数据发送返回
	if(payload_length == 0) // 无返回
	{
		// 清空Token，重新认证
		memset(Token, '\0', sizeof(Token));
		
		return 0;
	}
	else if(payload[0] == '{' && payload[payload_length-1] == '}') // 认证返回
	{
		// 解析json
		cJSON * cjson = cJSON_Parse((char * )payload);
		Log_Printf_Debug("plaintext(%d): %s\r\n",payload_length, payload);
		if(cJSON_HasObjectItem(cjson, "random"))
		{
			char * random = cJSON_GetObjectItem(cjson, "random")->valuestring;
			set_random(random);
		}
		if(cJSON_HasObjectItem(cjson, "seqOffset"))
		{
			uint16_t seqOffset = cJSON_GetObjectItem(cjson, "seqOffset")->valueint;
			set_seqOffset(seqOffset);
		}
		if(cJSON_HasObjectItem(cjson, "token"))
		{
			char * token = cJSON_GetObjectItem(cjson, "token")->valuestring;
			set_token(token);
		}
		cJSON_Delete(cjson);//清除结构体 
		return 1;
	}
	else
	{
		// 数据发送成功返回
		memset(plaintext, 0, sizeof(plaintext));
		uint16_t plaintext_length = utils_aes128_cbc_dec(aes_key, iv, (char * )payload, payload_length, (char * )plaintext);
		Log_Printf_Debug("\r\nplaintext(%d): %s\r\n",plaintext_length, (char *)plaintext);
		return 2;
	}
}




void TUORENIOT_PrintfRegistRequestStruct(struct TUORENIOT_RegistRequestStruct * regist_params_struct)
{
	Log_Printf("------print regist params start------\r\n");
	Log_Printf("version=%d\r\n", regist_params_struct->version);
	Log_Printf("networkType=%d\r\n", regist_params_struct->networkType);
	Log_Printf("networkProtocol=%d\r\n", regist_params_struct->networkProtocol);
	Log_Printf("productId=%s\r\n", regist_params_struct->productId);
	Log_Printf("deviceId=%s\r\n", regist_params_struct->deviceId);
	Log_Printf("userId=%s\r\n", regist_params_struct->userId);
	Log_Printf("sim=%s\r\n", regist_params_struct->sim);
	Log_Printf("------print regist params end------\r\n");
}

void TUORENIOT_PrintfRegistResponseStruct(void)
{
	Log_Printf("------print regist result start------\r\n");
	Log_Printf("code=%d\r\n", regist_response.code);
	Log_Printf("version=%d\r\n", regist_response.version);
	Log_Printf("platform=%d\r\n", regist_response.platform);
	Log_Printf("networkType=%d\r\n", regist_response.networkType);
	Log_Printf("networkProtocol=%d\r\n", regist_response.networkProtocol);
	Log_Printf("productId=%s\r\n", regist_response.productId);
	Log_Printf("productKey=%s\r\n", regist_response.productKey);
	Log_Printf("deviceId=%s\r\n", regist_response.deviceId);
	Log_Printf("userId=%s\r\n", regist_response.userId);
	Log_Printf("deviceSecret=%s\r\n", regist_response.deviceSecret);
	Log_Printf("remoteAddress=%s\r\n", regist_response.remoteAddress);
	Log_Printf("remotePort=%d\r\n", regist_response.remotePort);
	Log_Printf("wifiNumber=%d\r\n", regist_response.wifiNumber);
	Log_Printf("------print regist result end------\r\n");
}


// 初始化
void TUORENIOT_Init(void)
{
	// 从flash中读取注册结果
	ReadRegistResponseFromFlash();
}


// 清空flash中的注册响应
void TUORENIOT_ClearRegistResponseFromFlash(void)
{
	regist_response.code = 0;
	FlashWriteOperate((uint8_t*)&regist_response, sizeof(regist_response), FLASH_SAVE_ADDR);
	Log_Printf_Debug("清空注册数据完成\r\n");
}


// 从flash中读取注册响应
static void ReadRegistResponseFromFlash(void)
{
	Log_Printf_Debug("sizeof(regist_response): %d\r\n", sizeof(regist_response));
	//读取flash
	Log_Printf_Debug("读取前code：%d\r\n", regist_response.code);
	Log_Printf_Debug("sizeof(regist_result): %d\r\n", sizeof(regist_response));
	FlashReadOperate((uint8_t*)&regist_response, sizeof(regist_response), FLASH_SAVE_ADDR);
	Log_Printf_Debug("读取后code：%d\r\n", regist_response.code);
	if(regist_response.code == 200)
	{
		TUORENIOT_PrintfRegistResponseStruct();
	}
}

// 将注册响应写入到flash中
static void WriteRegistResponseToFlash(void)
{
	FlashWriteOperate((uint8_t*)&regist_response, sizeof(regist_response), FLASH_SAVE_ADDR);
	regist_response.code = 0;
	Log_Printf_Debug("写入数据完成\r\n");
	FlashReadOperate((uint8_t*)&regist_response, sizeof(regist_response), FLASH_SAVE_ADDR);
	TUORENIOT_PrintfRegistResponseStruct();
}


// 获取code
uint8_t TUORENIOT_GetCodeOfRegistResponse(void)
{
	return regist_response.code;
}