From b9e5e97741fb53884d41c321c6d99bd09fd4d2b0 Mon Sep 17 00:00:00 2001 From: wgzAIIT <820906721@qq.com> Date: Thu, 29 Jun 2023 15:48:35 +0800 Subject: [PATCH] The password for logging in to the mqtt server is generated using a function --- .../XiZi_IIoT/tool/bootloader/ota/ota.c | 24 +- Ubiquitous/XiZi_IIoT/tool/mqtt/Kconfig | 12 - Ubiquitous/XiZi_IIoT/tool/mqtt/Makefile | 2 +- .../XiZi_IIoT/tool/mqtt/platform_mqtt.c | 28 +- .../XiZi_IIoT/tool/mqtt/platform_mqtt.h | 23 +- .../XiZi_IIoT/tool/mqtt/utils_hmacsha1.c | 399 ++++++++++++++++++ .../XiZi_IIoT/tool/mqtt/utils_hmacsha1.h | 41 ++ 7 files changed, 495 insertions(+), 34 deletions(-) create mode 100644 Ubiquitous/XiZi_IIoT/tool/mqtt/utils_hmacsha1.c create mode 100644 Ubiquitous/XiZi_IIoT/tool/mqtt/utils_hmacsha1.h diff --git a/Ubiquitous/XiZi_IIoT/tool/bootloader/ota/ota.c b/Ubiquitous/XiZi_IIoT/tool/bootloader/ota/ota.c index 9cc091aa8..3aedba32d 100644 --- a/Ubiquitous/XiZi_IIoT/tool/bootloader/ota/ota.c +++ b/Ubiquitous/XiZi_IIoT/tool/bootloader/ota/ota.c @@ -796,6 +796,7 @@ static void app_ota_by_platform(void* parameter) { int datalen; int ret = 0; + int freecnt = 0; ota_info_t ota_info; uint32_t heart_time = 0; uint32_t flashdestination = DOWN_FLAH_ADDRESS; @@ -816,13 +817,23 @@ reconnect: KPrintf("Log in to the cloud platform and subscribe to the topic successfully.\n"); PropertyVersion(); } + else + { + KPrintf("Log in to the cloud platform failed, retry!\n"); + goto reconnect; + } while(1) { memset(MqttRxbuf,0,sizeof(MqttRxbuf)); datalen = MQTT_Recv(MqttRxbuf, sizeof(MqttRxbuf)); - if(MqttRxbuf[0] == 0x30) + if(datalen <= 0) { + freecnt++; + } + else if(MqttRxbuf[0] == 0x30) + { + freecnt = 0; MQTT_DealPublishData(MqttRxbuf, datalen); ptr = strstr((char *)Platform_mqtt.cmdbuff,"{\"code\":\"1000\""); if(ptr != NULL) @@ -896,16 +907,23 @@ reconnect: } } + else + { + freecnt = 0; + continue; + } - if((datalen <= 0) && (CalculateTimeMsFromTick(CurrentTicksGain()) - heart_time >= HEART_TIME)) //空闲状态下每隔一段时间发送需要发送心跳包保活 + if((freecnt >= 10) && (CalculateTimeMsFromTick(CurrentTicksGain()) - heart_time >= HEART_TIME)) //连续10次未收到数据默认为为空闲状态,需每隔一段时间发送需要发送心跳包保活 { heart_time = CalculateTimeMsFromTick(CurrentTicksGain()); - KPrintf("Send heartbeat packet!\n"); if(MQTT_SendHeart() != 0) //发送心跳包失败可能连接断开,需要重连 { + KPrintf("The connection has been disconnected, reconnecting!\n"); + freecnt = 0; heart_time = 0; goto reconnect; } + KPrintf("Send heartbeat packet successful!\n"); } } diff --git a/Ubiquitous/XiZi_IIoT/tool/mqtt/Kconfig b/Ubiquitous/XiZi_IIoT/tool/mqtt/Kconfig index 4024bfdb7..609b0dc78 100644 --- a/Ubiquitous/XiZi_IIoT/tool/mqtt/Kconfig +++ b/Ubiquitous/XiZi_IIoT/tool/mqtt/Kconfig @@ -19,18 +19,6 @@ menu "MQTT function" config CLIENT_DEVICESECRET string "Device secret, used for device authentication and data encryption." default "43b3c332233e2204a0612bfbfe21bb67" - - config CLIENTID - string "mqtt client id." - default "iywhcgnuezz.D001|securemode=2,signmethod=hmacsha256,timestamp=1687917392547|" - - config USERNAME - string "mqtt client username." - default "D001&iywhcgnuezz" - - config PASSWORD - string "mqtt client login passwd." - default "2af06ed86b9f6cbeb66beff402e3e882d41a838180695fced70edcf568052857" config PLATFORM_SERVERIP string "mqtt platform server ip." diff --git a/Ubiquitous/XiZi_IIoT/tool/mqtt/Makefile b/Ubiquitous/XiZi_IIoT/tool/mqtt/Makefile index 93fa24fb1..b924f47d1 100644 --- a/Ubiquitous/XiZi_IIoT/tool/mqtt/Makefile +++ b/Ubiquitous/XiZi_IIoT/tool/mqtt/Makefile @@ -1,3 +1,3 @@ -SRC_FILES := platform_mqtt.c +SRC_FILES := platform_mqtt.c utils_hmacsha1.c include $(KERNEL_ROOT)/compiler.mk \ No newline at end of file diff --git a/Ubiquitous/XiZi_IIoT/tool/mqtt/platform_mqtt.c b/Ubiquitous/XiZi_IIoT/tool/mqtt/platform_mqtt.c index ec051655e..b26e2aa61 100644 --- a/Ubiquitous/XiZi_IIoT/tool/mqtt/platform_mqtt.c +++ b/Ubiquitous/XiZi_IIoT/tool/mqtt/platform_mqtt.c @@ -112,11 +112,19 @@ int MQTT_Recv(uint8_t* buf, int buflen) int MQTT_Connect(void) { uint8_t TryConnect_time = 10; //尝试登录次数 + uint8_t passwdtemp[PASSWARD_SIZE]; + + memset(&Platform_mqtt,0,sizeof(Platform_mqtt)); + sprintf(Platform_mqtt.ClientID,"%s|securemode=3,signmethod=hmacsha1|",CLIENT_DEVICENAME); //构建客户端ID并存入缓冲区 + sprintf(Platform_mqtt.Username,"%s&%s",CLIENT_DEVICENAME,PLATFORM_PRODUCTKEY); //构建用户名并存入缓冲区 + memset(passwdtemp,0,sizeof(passwdtemp)); + sprintf(passwdtemp,"clientId%sdeviceName%sproductKey%s",CLIENT_DEVICENAME,CLIENT_DEVICENAME,PLATFORM_PRODUCTKEY); //构建加密时的明文 + utils_hmac_sha1(passwdtemp,strlen(passwdtemp),Platform_mqtt.Passward,(char *)CLIENT_DEVICESECRET,strlen(CLIENT_DEVICESECRET)); //以DeviceSecret为秘钥对temp中的明文进行hmacsha1加密即为密码 Platform_mqtt.MessageID = 0; //报文标识符清零,CONNECT报文虽然不需要添加报文标识符,但是CONNECT报文是第一个发送的报文,在此清零报文标识符为后续报文做准备 Platform_mqtt.Fixed_len = 1; //CONNECT报文固定报头长度暂定为1 Platform_mqtt.Variable_len = 10; //CONNECT报文可变报头长度为10 - Platform_mqtt.Payload_len = (2+strlen(CLIENTID)) + (2+strlen(USERNAME)) + (2+strlen(PASSWORD)); //CONNECT报文中负载长度 + Platform_mqtt.Payload_len = (2+strlen(Platform_mqtt.ClientID)) + (2+strlen(Platform_mqtt.Username)) + (2+strlen(Platform_mqtt.Passward)); //CONNECT报文中负载长度 Platform_mqtt.Remaining_len = Platform_mqtt.Variable_len + Platform_mqtt.Payload_len; //剩余长度=可变报头长度+负载长度 memset(Platform_mqtt.Pack_buff,0,sizeof(Platform_mqtt.Pack_buff)); @@ -146,17 +154,17 @@ int MQTT_Connect(void) Platform_mqtt.Pack_buff[Platform_mqtt.Fixed_len+9] = KEEPALIVE_TIME%256; //CONNECT报文,可变报头第10个字节:保活时间低字节,单位s /* CLIENT_ID */ - Platform_mqtt.Pack_buff[Platform_mqtt.Fixed_len+10] = strlen(CLIENTID)/256; //客户端ID长度高字节 - Platform_mqtt.Pack_buff[Platform_mqtt.Fixed_len+11] = strlen(CLIENTID)%256; //客户端ID长度低字节 - memcpy(&Platform_mqtt.Pack_buff[Platform_mqtt.Fixed_len+12],CLIENTID,strlen(CLIENTID)); //复制过来客户端ID字串 + Platform_mqtt.Pack_buff[Platform_mqtt.Fixed_len+10] = strlen(Platform_mqtt.ClientID)/256; //客户端ID长度高字节 + Platform_mqtt.Pack_buff[Platform_mqtt.Fixed_len+11] = strlen(Platform_mqtt.ClientID)%256; //客户端ID长度低字节 + memcpy(&Platform_mqtt.Pack_buff[Platform_mqtt.Fixed_len+12],Platform_mqtt.ClientID,strlen(Platform_mqtt.ClientID)); //复制过来客户端ID字串 /* USER_NAME */ - Platform_mqtt.Pack_buff[Platform_mqtt.Fixed_len+12+strlen(CLIENTID)] = strlen(USERNAME)/256; //用户名长度高字节 - Platform_mqtt.Pack_buff[Platform_mqtt.Fixed_len+13+strlen(CLIENTID)] = strlen(USERNAME)%256; //用户名长度低字节 - memcpy(&Platform_mqtt.Pack_buff[Platform_mqtt.Fixed_len+14+strlen(CLIENTID)],USERNAME,strlen(USERNAME)); //复制过来用户名字串 + Platform_mqtt.Pack_buff[Platform_mqtt.Fixed_len+12+strlen(Platform_mqtt.ClientID)] = strlen(Platform_mqtt.Username)/256; //用户名长度高字节 + Platform_mqtt.Pack_buff[Platform_mqtt.Fixed_len+13+strlen(Platform_mqtt.ClientID)] = strlen(Platform_mqtt.Username)%256; //用户名长度低字节 + memcpy(&Platform_mqtt.Pack_buff[Platform_mqtt.Fixed_len+14+strlen(Platform_mqtt.ClientID)],Platform_mqtt.Username,strlen(Platform_mqtt.Username)); //复制过来用户名字串 /* PASSWARD */ - Platform_mqtt.Pack_buff[Platform_mqtt.Fixed_len+14+strlen(CLIENTID)+strlen(USERNAME)] = strlen(PASSWORD)/256; //密码长度高字节 - Platform_mqtt.Pack_buff[Platform_mqtt.Fixed_len+15+strlen(CLIENTID)+strlen(USERNAME)] = strlen(PASSWORD)%256; //密码长度低字节 - memcpy(&Platform_mqtt.Pack_buff[Platform_mqtt.Fixed_len+16+strlen(CLIENTID)+strlen(USERNAME)],PASSWORD,strlen(PASSWORD)); //复制过来密码字串 + Platform_mqtt.Pack_buff[Platform_mqtt.Fixed_len+14+strlen(Platform_mqtt.ClientID)+strlen(Platform_mqtt.Username)] = strlen(Platform_mqtt.Passward)/256; //密码长度高字节 + Platform_mqtt.Pack_buff[Platform_mqtt.Fixed_len+15+strlen(Platform_mqtt.ClientID)+strlen(Platform_mqtt.Username)] = strlen(Platform_mqtt.Passward)%256; //密码长度低字节 + memcpy(&Platform_mqtt.Pack_buff[Platform_mqtt.Fixed_len+16+strlen(Platform_mqtt.ClientID)+strlen(Platform_mqtt.Username)],Platform_mqtt.Passward,strlen(Platform_mqtt.Passward)); //复制过来密码字串 while(TryConnect_time > 0) { diff --git a/Ubiquitous/XiZi_IIoT/tool/mqtt/platform_mqtt.h b/Ubiquitous/XiZi_IIoT/tool/mqtt/platform_mqtt.h index f6ec30783..a7331ffed 100644 --- a/Ubiquitous/XiZi_IIoT/tool/mqtt/platform_mqtt.h +++ b/Ubiquitous/XiZi_IIoT/tool/mqtt/platform_mqtt.h @@ -23,20 +23,27 @@ #define _PLATFORM_MQTT_H_ #include +#include "utils_hmacsha1.h" #define KEEPALIVE_TIME 300 //保活时间(单位s),300s -#define HEART_TIME 60000 //空闲时发送心跳包的时间间隔(单位ms),60s +#define HEART_TIME 120000 //空闲时发送心跳包的时间间隔(单位ms),120s #define PACK_SIZE 512 //存放报文数据缓冲区大小 #define CMD_SIZE 3072 //保存推送的PUBLISH报文中的数据缓冲区大小 +#define CLIENTID_SIZE 64 //存放客户端ID的缓冲区大小 +#define USERNAME_SIZE 64 //存放用户名的缓冲区大小 +#define PASSWARD_SIZE 64 //存放密码的缓冲区大小 typedef struct{ - uint8_t Pack_buff[PACK_SIZE]; //存放发送报文数据缓冲区 - uint16_t MessageID; //记录报文标识符 - uint16_t Fixed_len; //固定报头长度 - uint16_t Variable_len; //可变报头长度 - uint16_t Payload_len; //有效负荷长度 - uint16_t Remaining_len; //保存报文剩余长度字节 - uint8_t cmdbuff[CMD_SIZE]; //保存推送的PUBLISH报文中的数据缓冲区 + uint8_t ClientID[CLIENTID_SIZE]; //存放客户端ID的缓冲区 + uint8_t Username[USERNAME_SIZE]; //存放用户名的缓冲区 + uint8_t Passward[PASSWARD_SIZE]; //存放密码的缓冲区 + uint8_t Pack_buff[PACK_SIZE]; //存放发送报文数据缓冲区 + uint16_t MessageID; //记录报文标识符 + uint16_t Fixed_len; //固定报头长度 + uint16_t Variable_len; //可变报头长度 + uint16_t Payload_len; //有效负荷长度 + uint16_t Remaining_len; //保存报文剩余长度字节 + uint8_t cmdbuff[CMD_SIZE]; //保存推送的PUBLISH报文中的数据缓冲区 }MQTT_TCB; extern MQTT_TCB Platform_mqtt; //外部变量声明 diff --git a/Ubiquitous/XiZi_IIoT/tool/mqtt/utils_hmacsha1.c b/Ubiquitous/XiZi_IIoT/tool/mqtt/utils_hmacsha1.c new file mode 100644 index 000000000..41b63e6e0 --- /dev/null +++ b/Ubiquitous/XiZi_IIoT/tool/mqtt/utils_hmacsha1.c @@ -0,0 +1,399 @@ +/* +* Copyright (c) 2020 AIIT XUOS Lab +* XiUOS is licensed under Mulan PSL v2. +* You can use this software according to the terms and conditions of the Mulan PSL v2. +* You may obtain a copy of Mulan PSL v2 at: +* http://license.coscl.org.cn/MulanPSL2 +* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, +* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, +* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. +* See the Mulan PSL v2 for more details. +*/ + +/** +* @file: utils_hmacsha1.c +* @brief: utils_hmacsha1.c file +* @version: 1.0 +* @author: AIIT XUOS Lab +* @date: 2023/6/29 +* +*/ + +#include "utils_hmacsha1.h" + +#define KEY_IOPAD_SIZE 64 +#define SHA1_DIGEST_SIZE 20 + +static void utils_sha1_zeroize(void *v, size_t n); +static void utils_sha1_init(iot_sha1_context *ctx); +static void utils_sha1_free(iot_sha1_context *ctx); +static void utils_sha1_clone(iot_sha1_context *dst, const iot_sha1_context *src); +static void utils_sha1_starts(iot_sha1_context *ctx); +static void utils_sha1_process(iot_sha1_context *ctx, const unsigned char data[64]); +static void utils_sha1_update(iot_sha1_context *ctx, const unsigned char *input, size_t ilen); +static void utils_sha1_finish(iot_sha1_context *ctx, unsigned char output[20]); +static void utils_sha1(const unsigned char *input, size_t ilen, unsigned char output[20]); +static int8_t utils_hb2hex(uint8_t hb); + +const char * base64char = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + +/* Implementation that should never be optimized out by the compiler */ +static void utils_sha1_zeroize(void *v, size_t n) +{ + volatile unsigned char *p = v; + while(n--) { + *p++ = 0; + } +} + +/* 32-bit integer manipulation macros (big endian) */ +#ifndef IOT_SHA1_GET_UINT32_BE +#define IOT_SHA1_GET_UINT32_BE(n,b,i) \ + { \ + (n) = ( (uint32_t) (b)[(i) ] << 24 ) \ + | ( (uint32_t) (b)[(i) + 1] << 16 ) \ + | ( (uint32_t) (b)[(i) + 2] << 8 ) \ + | ( (uint32_t) (b)[(i) + 3] ); \ + } +#endif + +#ifndef IOT_SHA1_PUT_UINT32_BE +#define IOT_SHA1_PUT_UINT32_BE(n,b,i) \ + { \ + (b)[(i) ] = (unsigned char) ( (n) >> 24 ); \ + (b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \ + (b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \ + (b)[(i) + 3] = (unsigned char) ( (n) ); \ + } +#endif + +void utils_sha1_init(iot_sha1_context *ctx) +{ + memset(ctx, 0, sizeof(iot_sha1_context)); +} + +void utils_sha1_free(iot_sha1_context *ctx) +{ + if(ctx == NULL) { + return; + } + + utils_sha1_zeroize(ctx, sizeof(iot_sha1_context)); +} + +void utils_sha1_clone(iot_sha1_context *dst, + const iot_sha1_context *src) +{ + *dst = *src; +} + +/* SHA-1 context setup */ +void utils_sha1_starts(iot_sha1_context *ctx) +{ + ctx->total[0] = 0; + ctx->total[1] = 0; + + ctx->state[0] = 0x67452301; + ctx->state[1] = 0xEFCDAB89; + ctx->state[2] = 0x98BADCFE; + ctx->state[3] = 0x10325476; + ctx->state[4] = 0xC3D2E1F0; +} + +void utils_sha1_process(iot_sha1_context *ctx, const unsigned char data[64]) +{ + uint32_t temp, W[16], A, B, C, D, E; + + IOT_SHA1_GET_UINT32_BE(W[ 0], data, 0); + IOT_SHA1_GET_UINT32_BE(W[ 1], data, 4); + IOT_SHA1_GET_UINT32_BE(W[ 2], data, 8); + IOT_SHA1_GET_UINT32_BE(W[ 3], data, 12); + IOT_SHA1_GET_UINT32_BE(W[ 4], data, 16); + IOT_SHA1_GET_UINT32_BE(W[ 5], data, 20); + IOT_SHA1_GET_UINT32_BE(W[ 6], data, 24); + IOT_SHA1_GET_UINT32_BE(W[ 7], data, 28); + IOT_SHA1_GET_UINT32_BE(W[ 8], data, 32); + IOT_SHA1_GET_UINT32_BE(W[ 9], data, 36); + IOT_SHA1_GET_UINT32_BE(W[10], data, 40); + IOT_SHA1_GET_UINT32_BE(W[11], data, 44); + IOT_SHA1_GET_UINT32_BE(W[12], data, 48); + IOT_SHA1_GET_UINT32_BE(W[13], data, 52); + IOT_SHA1_GET_UINT32_BE(W[14], data, 56); + IOT_SHA1_GET_UINT32_BE(W[15], data, 60); + +#define S(x,n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n))) + +#define R(t) \ + ( \ + temp = W[( t - 3 ) & 0x0F] ^ W[( t - 8 ) & 0x0F] ^ \ + W[( t - 14 ) & 0x0F] ^ W[ t & 0x0F], \ + ( W[t & 0x0F] = S(temp,1) ) \ + ) + +#define P(a,b,c,d,e,x) \ + { \ + e += S(a,5) + F(b,c,d) + K + x; b = S(b,30); \ + } + + A = ctx->state[0]; + B = ctx->state[1]; + C = ctx->state[2]; + D = ctx->state[3]; + E = ctx->state[4]; + +#define F(x,y,z) (z ^ (x & (y ^ z))) +#define K 0x5A827999 + + P(A, B, C, D, E, W[0]); + P(E, A, B, C, D, W[1]); + P(D, E, A, B, C, W[2]); + P(C, D, E, A, B, W[3]); + P(B, C, D, E, A, W[4]); + P(A, B, C, D, E, W[5]); + P(E, A, B, C, D, W[6]); + P(D, E, A, B, C, W[7]); + P(C, D, E, A, B, W[8]); + P(B, C, D, E, A, W[9]); + P(A, B, C, D, E, W[10]); + P(E, A, B, C, D, W[11]); + P(D, E, A, B, C, W[12]); + P(C, D, E, A, B, W[13]); + P(B, C, D, E, A, W[14]); + P(A, B, C, D, E, W[15]); + P(E, A, B, C, D, R(16)); + P(D, E, A, B, C, R(17)); + P(C, D, E, A, B, R(18)); + P(B, C, D, E, A, R(19)); + +#undef K +#undef F + +#define F(x,y,z) (x ^ y ^ z) +#define K 0x6ED9EBA1 + + P(A, B, C, D, E, R(20)); + P(E, A, B, C, D, R(21)); + P(D, E, A, B, C, R(22)); + P(C, D, E, A, B, R(23)); + P(B, C, D, E, A, R(24)); + P(A, B, C, D, E, R(25)); + P(E, A, B, C, D, R(26)); + P(D, E, A, B, C, R(27)); + P(C, D, E, A, B, R(28)); + P(B, C, D, E, A, R(29)); + P(A, B, C, D, E, R(30)); + P(E, A, B, C, D, R(31)); + P(D, E, A, B, C, R(32)); + P(C, D, E, A, B, R(33)); + P(B, C, D, E, A, R(34)); + P(A, B, C, D, E, R(35)); + P(E, A, B, C, D, R(36)); + P(D, E, A, B, C, R(37)); + P(C, D, E, A, B, R(38)); + P(B, C, D, E, A, R(39)); + +#undef K +#undef F + +#define F(x,y,z) ((x & y) | (z & (x | y))) +#define K 0x8F1BBCDC + + P(A, B, C, D, E, R(40)); + P(E, A, B, C, D, R(41)); + P(D, E, A, B, C, R(42)); + P(C, D, E, A, B, R(43)); + P(B, C, D, E, A, R(44)); + P(A, B, C, D, E, R(45)); + P(E, A, B, C, D, R(46)); + P(D, E, A, B, C, R(47)); + P(C, D, E, A, B, R(48)); + P(B, C, D, E, A, R(49)); + P(A, B, C, D, E, R(50)); + P(E, A, B, C, D, R(51)); + P(D, E, A, B, C, R(52)); + P(C, D, E, A, B, R(53)); + P(B, C, D, E, A, R(54)); + P(A, B, C, D, E, R(55)); + P(E, A, B, C, D, R(56)); + P(D, E, A, B, C, R(57)); + P(C, D, E, A, B, R(58)); + P(B, C, D, E, A, R(59)); + +#undef K +#undef F + +#define F(x,y,z) (x ^ y ^ z) +#define K 0xCA62C1D6 + + P(A, B, C, D, E, R(60)); + P(E, A, B, C, D, R(61)); + P(D, E, A, B, C, R(62)); + P(C, D, E, A, B, R(63)); + P(B, C, D, E, A, R(64)); + P(A, B, C, D, E, R(65)); + P(E, A, B, C, D, R(66)); + P(D, E, A, B, C, R(67)); + P(C, D, E, A, B, R(68)); + P(B, C, D, E, A, R(69)); + P(A, B, C, D, E, R(70)); + P(E, A, B, C, D, R(71)); + P(D, E, A, B, C, R(72)); + P(C, D, E, A, B, R(73)); + P(B, C, D, E, A, R(74)); + P(A, B, C, D, E, R(75)); + P(E, A, B, C, D, R(76)); + P(D, E, A, B, C, R(77)); + P(C, D, E, A, B, R(78)); + P(B, C, D, E, A, R(79)); + +#undef K +#undef F + + ctx->state[0] += A; + ctx->state[1] += B; + ctx->state[2] += C; + ctx->state[3] += D; + ctx->state[4] += E; +} + +/* SHA-1 process buffer */ +void utils_sha1_update(iot_sha1_context *ctx, const unsigned char *input, size_t ilen) +{ + size_t fill; + uint32_t left; + + if(ilen == 0) { + return; + } + + left = ctx->total[0] & 0x3F; + fill = 64 - left; + + ctx->total[0] += (uint32_t) ilen; + ctx->total[0] &= 0xFFFFFFFF; + + if(ctx->total[0] < (uint32_t) ilen) { + ctx->total[1]++; + } + + if(left && ilen >= fill) { + memcpy((void *)(ctx->buffer + left), input, fill); + utils_sha1_process(ctx, ctx->buffer); + input += fill; + ilen -= fill; + left = 0; + } + + while(ilen >= 64) { + utils_sha1_process(ctx, input); + input += 64; + ilen -= 64; + } + + if(ilen > 0) { + memcpy((void *)(ctx->buffer + left), input, ilen); + } +} + +static const unsigned char iot_sha1_padding[64] = { + 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + +/* SHA-1 final digest */ +void utils_sha1_finish(iot_sha1_context *ctx, unsigned char output[20]) +{ + uint32_t last, padn; + uint32_t high, low; + unsigned char msglen[8]; + + high = (ctx->total[0] >> 29) + | (ctx->total[1] << 3); + low = (ctx->total[0] << 3); + + IOT_SHA1_PUT_UINT32_BE(high, msglen, 0); + IOT_SHA1_PUT_UINT32_BE(low, msglen, 4); + + last = ctx->total[0] & 0x3F; + padn = (last < 56) ? (56 - last) : (120 - last); + + utils_sha1_update(ctx, iot_sha1_padding, padn); + utils_sha1_update(ctx, msglen, 8); + + IOT_SHA1_PUT_UINT32_BE(ctx->state[0], output, 0); + IOT_SHA1_PUT_UINT32_BE(ctx->state[1], output, 4); + IOT_SHA1_PUT_UINT32_BE(ctx->state[2], output, 8); + IOT_SHA1_PUT_UINT32_BE(ctx->state[3], output, 12); + IOT_SHA1_PUT_UINT32_BE(ctx->state[4], output, 16); +} + + +/* output = SHA-1(input buffer) */ +void utils_sha1(const unsigned char *input, size_t ilen, unsigned char output[20]) +{ + iot_sha1_context ctx; + + utils_sha1_init(&ctx); + utils_sha1_starts(&ctx); + utils_sha1_update(&ctx, input, ilen); + utils_sha1_finish(&ctx, output); + utils_sha1_free(&ctx); +} + + +inline int8_t utils_hb2hex(uint8_t hb) +{ + hb = hb & 0xF; + return (int8_t)(hb < 10 ? '0' + hb : hb - 10 + 'a'); +} + + +void utils_hmac_sha1(const char *msg, int msg_len, char *digest, const char *key, int key_len) +{ + iot_sha1_context context; + unsigned char k_ipad[KEY_IOPAD_SIZE]; /* inner padding - key XORd with ipad */ + unsigned char k_opad[KEY_IOPAD_SIZE]; /* outer padding - key XORd with opad */ + unsigned char out[SHA1_DIGEST_SIZE]; + int i; + + if((NULL == msg) || (NULL == digest) || (NULL == key)) { + return; + } + + if(key_len > KEY_IOPAD_SIZE) { + return; + } + + /* start out by storing key in pads */ + memset(k_ipad, 0, sizeof(k_ipad)); + memset(k_opad, 0, sizeof(k_opad)); + memcpy(k_ipad, key, key_len); + memcpy(k_opad, key, key_len); + + /* XOR key with ipad and opad values */ + for(i = 0; i < KEY_IOPAD_SIZE; i++) { + k_ipad[i] ^= 0x36; + k_opad[i] ^= 0x5c; + } + + /* perform inner SHA */ + utils_sha1_init(&context); /* init context for 1st pass */ + utils_sha1_starts(&context); /* setup context for 1st pass */ + utils_sha1_update(&context, k_ipad, KEY_IOPAD_SIZE); /* start with inner pad */ + utils_sha1_update(&context, (unsigned char *) msg, msg_len); /* then text of datagram */ + utils_sha1_finish(&context, out); /* finish up 1st pass */ + + /* perform outer SHA */ + utils_sha1_init(&context); /* init context for 2nd pass */ + utils_sha1_starts(&context); /* setup context for 2nd pass */ + utils_sha1_update(&context, k_opad, KEY_IOPAD_SIZE); /* start with outer pad */ + utils_sha1_update(&context, out, SHA1_DIGEST_SIZE); /* then results of 1st hash */ + utils_sha1_finish(&context, out); /* finish up 2nd pass */ + + for(i = 0; i < SHA1_DIGEST_SIZE; ++i) { + digest[i * 2] = utils_hb2hex(out[i] >> 4); + digest[i * 2 + 1] = utils_hb2hex(out[i]); + } +} \ No newline at end of file diff --git a/Ubiquitous/XiZi_IIoT/tool/mqtt/utils_hmacsha1.h b/Ubiquitous/XiZi_IIoT/tool/mqtt/utils_hmacsha1.h new file mode 100644 index 000000000..da56792a4 --- /dev/null +++ b/Ubiquitous/XiZi_IIoT/tool/mqtt/utils_hmacsha1.h @@ -0,0 +1,41 @@ +/* +* Copyright (c) 2020 AIIT XUOS Lab +* XiUOS is licensed under Mulan PSL v2. +* You can use this software according to the terms and conditions of the Mulan PSL v2. +* You may obtain a copy of Mulan PSL v2 at: +* http://license.coscl.org.cn/MulanPSL2 +* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, +* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, +* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. +* See the Mulan PSL v2 for more details. +*/ + +/** +* @file: utils_hmacsha1.h +* @brief: utils_hmacsha1.h file +* @version: 1.0 +* @author: AIIT XUOS Lab +* @date: 2023/6/29 +* +*/ + +#ifndef UTILS_HMACSHA1_H_ +#define UTILS_HMACSHA1_H_ + +#include "stdio.h" +#include "stdint.h" +#include "stdlib.h" +#include "string.h" + +/* SHA-1 context structure */ +typedef struct { + uint32_t total[2]; /* number of bytes processed */ + uint32_t state[5]; /* intermediate digest state */ + unsigned char buffer[64]; /* data block being processed */ +} iot_sha1_context; + + +void utils_hmac_sha1(const char *msg, int msg_len, char *digest, const char *key, int key_len); + +#endif +