Skip to content

C
car-controlserver
Commit c380ff23 authored by 学习的菜鸟's avatar 学习的菜鸟
Browse files
Options

feature://加入了jwt验证，已测试一部分，后端还在测试，测试通过后直接打标签

parent 8deca748
Show whitespace changes
Inline Side-by-side
Showing with 565 additions and 345 deletions
build/include/version.h
View file @ c380ff23
......@@ -2,5 +2,5 @@
#define PROJECT_VERSION_MINOR 1
#define PROJECT_VERSION_PATCH 8
#define GIT_HASH ""
#define BUILD_TIMESTAMP "2025-06-24T10:17:31"
#define BUILD_TIMESTAMP "2025-06-26T03:49:36"
#define BUILD_USER "orangepi"
build/main
View file @ c380ff23
No preview for this file type
include/mqtt_verify.h
View file @ c380ff23
......@@ -6,10 +6,14 @@
extern int gverify_count;//验证计时
extern int gverify_index;//判断是否验证成功
int receive_jwt(cJSON *body);//jwt验证
//接收安卓发送的mqtt
int receive_verify(cJSON *body);
//int receive_verify(cJSON *body);//为aes验证，暂时不用，注释
//加密并发送mqtt
int mqtt_encryption();
//int mqtt_encryption();//为aes验证，暂时不用，注释
int message2006_verify(cJSON *body);
#endif
\ No newline at end of file
src/audioplay.c
View file @ c380ff23
......@@ -8,6 +8,7 @@ char urlbuf[512];
char keybuf[256];
double audio_volume=0.8;
//接收音频播放
void audioplay_mqtt_receive(cJSON *json) {
// 解析"audioLink"字段（修正了原始JSON中的拼写错误）
cJSON *audio_link = cJSON_GetObjectItemCaseSensitive(json, "audioLink");
......@@ -49,7 +50,8 @@ void audioplay_mqtt_receive(cJSON *json) {
}
}
void audioplay_send_mqtt() {//发送音频播放是否完毕
//发送音频播放是否完毕
void audioplay_send_mqtt() {
cJSON *root = cJSON_CreateObject();
cJSON *body = cJSON_CreateObject();
cJSON *head = cJSON_CreateObject();
......@@ -73,6 +75,7 @@ void audioplay_send_mqtt() {//发送音频播放是否完毕
cJSON_Delete(root);
}
//音频播放
void audioplay_cycle(){
char command[512];
int ret;
......
src/mqtt.c
View file @ c380ff23
......@@ -52,6 +52,7 @@ char *glon=NULL;//加入gps后删除，心跳预留，不更改
time_t gStart;//时间戳
//mqtt初始化
int mqtt_init() {
mosquitto_lib_init();
// 这里创建mosq可以保留，也可以删除这一行，让创建放到 Mqtt_onnect 里
......@@ -64,7 +65,8 @@ int mqtt_init() {
return 0;
}
void on_connect(struct mosquitto *mosq, void *obj, int rc) {//回调函数
//回调函数
void on_connect(struct mosquitto *mosq, void *obj, int rc) {
if (rc == 0) {
my_zlog_debug("Connected to broker");
topic_middle_value();
......@@ -76,7 +78,8 @@ void on_connect(struct mosquitto *mosq, void *obj, int rc) {//回调函数
}
}
void heartbeat_send() {//心跳发送格式*5/2
//心跳发送格式*5/2
void heartbeat_send() {
float voltage = INA226_readBusVoltage();
float current = INA226_readCurrent();
//my_zlog_debug("%.2f\n", voltage);
......@@ -130,7 +133,8 @@ void heartbeat_send() {//心跳发送格式*5/2
cJSON_Delete(root); // 释放 cJSON 对象
}
void angle_mqtt_send() { //角度发送
//角度发送
void angle_mqtt_send() {
float angle_shot=ads1115_read_channel(2);
if(angle_shot>0){
angle_shot=angle_shot*360/5;
......@@ -151,14 +155,16 @@ void angle_mqtt_send() { //角度发送
}
void mqtt_wirte(){//心跳格式，每5s一次心跳
//心跳格式，每5s一次心跳
void mqtt_wirte(){
if( heartbeat_count >= 30) heartbeat_send();
if( AppExit_pin_pwm == 202) angle_mqtt_send();
}
void message_3(cJSON *body){//message_type为3，控制pwm
//message_type为3，控制pwm
void message_3(cJSON *body){
cJSON *pwm_ctrl = cJSON_GetObjectItem(body, "pwm_ctrl");
cJSON *pin_setctrl = cJSON_GetObjectItem(body, "pin_setctrl");
if(pwm_ctrl==NULL||pin_setctrl==NULL){
......@@ -220,7 +226,39 @@ void message_4(cJSON *body){//message 为4时候
if(AppExit_pin_pwm == 202 ) tank_shot_back_stop(gvalt[1],gvalt[2]);
}
int download_message(cJSON *body){//接收的下载的mqtt消息
//当接收到2时候验证
void message_2_judyverify(cJSON *body){
receive_jwt(body);
if(gverify_index == 0) {
refresh_cam();
} else {
my_zlog_warn("验证不通过");
}
}
//当接收到3时候验证
void message_3_judyverify(cJSON *body){
receive_jwt(body);
if(gverify_index == 0) {
message_3(body);
} else {
my_zlog_warn("验证不通过");
}
}
//当接收到4时候验证
void message_4_judyverify(cJSON *body){
receive_jwt(body);
if(gverify_index == 0) {
message_4(body);
} else {
my_zlog_warn("验证不通过");
}
}
//接收的下载的mqtt消息
int download_message(cJSON *body){
if (cJSON_IsObject(body)) {
// 获取 doby 对象
// 获取 site 中的 name 和 url
......@@ -246,6 +284,7 @@ int download_message(cJSON *body){//接收的下载的mqtt消息
return 0;
}
//接收到设备改名函数
int device_mqttchange_name(cJSON *device_id){
cJSON *id = cJSON_GetObjectItem(device_id, "id");// 提取ID
cJSON *date = cJSON_GetObjectItem(device_id, "date");// 提取日期
......@@ -274,21 +313,16 @@ int device_message_receive(cJSON *json){//接收到的控制设备的mqtt消息
gmessage_type=message_type->valueint;
my_zlog_debug("message_type: %d",message_type->valueint);
switch(gmessage_type){
case 1:
system("sudo reboot");//重启香橙派
my_zlog_debug("重启成功");
break;
case 2:
refresh_cam();
my_zlog_debug("刷新成功");
message_2_judyverify(body);
my_zlog_debug("进入刷新");
break;
case 3:
receive_verify(body);
if(gverify_index == 0) message_3(body);
message_3_judyverify(body);
my_zlog_debug("进入pwm控制");
break;
case 4:
message_4(body);
message_4_judyverify(body);
my_zlog_debug("进入引脚控制");
break;
case 2001:
......@@ -309,6 +343,19 @@ int device_message_receive(cJSON *json){//接收到的控制设备的mqtt消息
break;
case 2005:
download_message(body);
my_zlog_debug("进入下载");
break;
case 2006:
message2006_verify(body);
my_zlog_debug("进入消息为2006验证");
break;
case 2011:
system("sudo reboot");//重启香橙派
my_zlog_debug("重启成功");
break;
case 2012:
refresh_cam();
my_zlog_debug("刷新成功");
break;
default:
break;
......@@ -318,7 +365,8 @@ int device_message_receive(cJSON *json){//接收到的控制设备的mqtt消息
return 0;
}
void on_message(struct mosquitto *mosq, void *obj, const struct mosquitto_message *message) {//消息回环函数
//消息回环函数
void on_message(struct mosquitto *mosq, void *obj, const struct mosquitto_message *message) {
time_t end = time(NULL);
if(gStart+5>end){
......@@ -349,8 +397,8 @@ void on_message(struct mosquitto *mosq, void *obj, const struct mosquitto_messag
}
}
int mqtt_create(struct mosquitto *mosq) { // 返回连接结果，0成功，非0失败
// 返回连接结果，0成功，非0失败
int mqtt_create(struct mosquitto *mosq) {
mosquitto_reconnect_delay_set(mosq, 2, 10, true);
mosquitto_connect_callback_set(mosq, on_connect);
mosquitto_message_callback_set(mosq, on_message);
......@@ -365,7 +413,8 @@ int mqtt_create(struct mosquitto *mosq) { // 返回连接结果，0成功，非0
return 0; // 成功
}
int mqtt_cycle(struct mosquitto *mosq) {//阻塞型
//阻塞型
int mqtt_cycle(struct mosquitto *mosq) {
// 这个函数会阻塞直到连接断开或错误返回
int rc = mosquitto_loop_forever(mosq, -1, 1);
if (rc != MOSQ_ERR_SUCCESS) {
......@@ -386,6 +435,7 @@ int mqtt_cycle(struct mosquitto *mosq) {//阻塞型
// }
// }
//mqtt清理
void mqtt_clean(struct mosquitto *mosq){
// 清理
mosquitto_destroy(mosq);
......
src/mqtt_verify.c
View file @ c380ff23
......@@ -11,144 +11,52 @@
#include "mqtt.h"
#include "judg.h"
bool service_verify=TRUE;//验证判断
char *id = NULL;
char *model = NULL;
char *number = NULL;
int *start_time = NULL;
char *user_id = NULL;
int gverify_count =12000;//判断是否有一分钟
int gverify_count =0;//判断是否有15s
int gverify_index =0;//判断是否验证成功
char only_id_middle[11];
char secret_key[256];//存储上一次的topic
bool secret_key_index = TRUE;//用于判断是否对比topic
//接收验证消息并15s一次验证，只有在接收时候才会15s一次验证
int receive_verify(cJSON *body) {
cJSON *device_info = cJSON_GetObjectItem(body, "device_info");
if(device_info == NULL) {
my_zlog_debug("验证为空");
return 1;
}
// 取各个字段（字符串类型）
cJSON *json_id = cJSON_GetObjectItem(device_info, "id");
cJSON *json_model = cJSON_GetObjectItem(device_info, "model");
cJSON *json_number = cJSON_GetObjectItem(device_info, "number");
cJSON *json_start_time = cJSON_GetObjectItem(device_info, "start_time");
cJSON *json_user_id = cJSON_GetObjectItem(device_info, "user_id");
if (json_id && json_model && json_number && json_start_time && json_user_id) {
id=json_id->valuestring;
model=json_model->valuestring;
number=json_number->valuestring;
start_time=&json_start_time->valueint;
user_id=json_user_id->valuestring;
my_zlog_debug("id: %s", id);
my_zlog_debug("model: %s", model);
my_zlog_debug("number: %s", number);
my_zlog_debug("start_time: %d", *start_time);
my_zlog_debug("user_id: %s", user_id);
if(gverify_count>3000){
int encryption_index=mqtt_encryption();
my_zlog_notice("加密情况：%d",encryption_index);
gverify_count=0;
}
int gverify_index =0;//判断是否验证成功
pthread_mutex_t gverify_mutex = PTHREAD_MUTEX_INITIALIZER;//线程锁
} else {
my_zlog_warn("Some fields missing");
return -1;
}
char *generate_random_id() {
return 0;
}
char *id_buffer=malloc(11);
// 1. 定义字符池：包含所有小写字母、大写字母和数字
const char charset[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
const int charset_size = sizeof(charset) - 1; // 减去末尾的 '\0'
/**
* @brief 根据传入的参数动态创建一个JSON字符串。
*
* @param id 记录ID
* @param model 设备型号
* @param number 编号
* @param start_time 开始时间
* @param user_id 用户ID
* @return char* 一个动态分配的JSON字符串。使用后必须调用free()释放。
* 如果内存分配失败，返回NULL。
*/
char* create_json_string(const char* id, const char* model, const char* number, const int* start_time, const char* user_id , const char* only_id) {
// JSON格式模板
const char *json_format = "{\"id\":\"%s\",\"model\":\"%s\",\"number\":\"%s\",\"start_time\":\"%s\",\"user_id\":\"%s\",\"only_id\":\"%s\"}";
char time_str[20]; // 足够存储20位数字和终止符
snprintf(time_str, sizeof(time_str), "%d", *start_time);
// 1. 计算所需总长度，以安全地分配内存
// 长度 = 模板长度 - 5*%s长度(10) + 各字符串实际长度 + 1个空终止符
int needed_size = strlen(json_format) - 10
+ strlen(id)
+ strlen(model)
+ strlen(number)
+ strlen(time_str)
+ strlen(user_id)
+ strlen(only_id) + 1;
// 2. 分配内存
char *json_string = (char*)malloc(needed_size);
if (json_string == NULL) {
fprintf(stderr, "错误: JSON字符串内存分配失败\n");
return NULL;
// 2. 循环生成每个字符
for (int i = 0; i < 10; ++i) {
// 从字符池中随机选择一个字符
int key = rand() % charset_size;
id_buffer[i] = charset[key];
}
// 3. 使用snprintf安全地格式化字符串
snprintf(json_string, needed_size, json_format, id, model, number, time_str, user_id,only_id);
return json_string;
// 3. 在字符串末尾添加空字符终止符
id_buffer[10] = '\0';
return id_buffer;
}
//base64编码代码
char* base64_encode(const unsigned char* buffer, int length) {
// Base64编码后的长度计算公式：4 * ((length + 2) / 3)
// +1 是为了最后的空终止符 '\0'
int b64_len = 4 * ((length + 2) / 3) + 1;
char *b64_str = (char*)malloc(b64_len);
if (b64_str == NULL) {
fprintf(stderr, "错误: Base64字符串内存分配失败\n");
return NULL;
}
// 使用OpenSSL的函数进行编码
int encoded_len = EVP_EncodeBlock((unsigned char*)b64_str, buffer, length);
// EVP_EncodeBlock 不会添加空终止符，我们需要手动添加
b64_str[encoded_len] = '\0';
return b64_str;
}
void mqtt_send_verify(unsigned char *ciphertext, int cipher_len) {
//发送用户获取jwt给服务端验证
int send_jwtser(const char *token){
topic_middle_value();//指针中间函数
cJSON *root = cJSON_CreateObject();
cJSON *body = cJSON_CreateObject();
cJSON *head = cJSON_CreateObject();
char *only_Id =generate_random_id();
// 8. 【新】将拼接后的二进制数据进行 Base64 编码
char *base64_output_str = base64_encode(ciphertext, cipher_len);
if (base64_output_str == NULL) {
// 错误处理
my_zlog_debug("base64_output_str为空");
return ;
}
strcpy(only_id_middle,only_Id);
// 打印出最终的、可以直接复制的Base64字符串
my_zlog_debug("要发送的完整数据 (Base64): %s", base64_output_str);
cJSON_AddStringToObject(body, "data", token);//为0成功
cJSON_AddStringToObject(body, "data", base64_output_str);//为0成功
cJSON_AddStringToObject(body, "only_id", only_Id);
cJSON_AddNumberToObject(head, "message_type",3006);
......@@ -159,231 +67,481 @@ void mqtt_send_verify(unsigned char *ciphertext, int cipher_len) {
my_zlog_debug("%s",payload);
mosquitto_publish(mosq, NULL, TOPIC3, strlen(payload), payload, 0, false);
free(only_Id);
cJSON_Delete(root); // 释放 cJSON 对象
}
//jwt验证函数
int receive_jwt(cJSON *body) {
//加密并发送mqtt
int mqtt_encryption(){
// =================================================================
char *only_id="sadas";
// 1. 准备明文、密钥和IV
// 从配置数据动态生成JSON字符串
char *json_to_encrypt = create_json_string(id, model, number, start_time, user_id,only_id);
if (json_to_encrypt == NULL) {
return 1; // 内存分配失败，退出
}
char *token=NULL;
char *token_time=NULL;
my_zlog_debug("生成的待加密JSON: %s", json_to_encrypt);
const unsigned char *plaintext = (const unsigned char *)json_to_encrypt;
const unsigned char *key = (const unsigned char *)"gds-dfgbcvdfgghj";//密钥
unsigned char iv[AES_BLOCK_SIZE];
// 生成随机IV
if (!RAND_bytes(iv, sizeof(iv))) {
fprintf(stderr, "错误: 无法生成随机IV\n");
my_zlog_error("错误: 无法生成随机IV");
free(json_to_encrypt); // 别忘了释放内存
return 1;
}
my_zlog_debug("原始JSON: %s", plaintext);
my_zlog_debug("\n--- 加密开始 ---");
// 2. 初始化加密上下文
EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
if (!ctx) {
fprintf(stderr, "错误: EVP_CIPHER_CTX_new 失败\n");
my_zlog_debug("错误: EVP_CIPHER_CTX_new 失败");
free(json_to_encrypt);
cJSON *json_token = cJSON_GetObjectItem(body, "token");
cJSON *json_token_time = cJSON_GetObjectItem(body, "token_time");
if(json_token == NULL || json_token_time==NULL) {
my_zlog_debug("验证为空");
gverify_index=1;
return 1;
}
// 3. 设置加密算法、密钥和IV
if (1 != EVP_EncryptInit_ex(ctx, EVP_aes_128_cbc(), NULL, key, iv)) {
fprintf(stderr, "错误: EVP_EncryptInit_ex 失败\n");
my_zlog_debug("错误: EVP_EncryptInit_ex 失败");
EVP_CIPHER_CTX_free(ctx);
free(json_to_encrypt);
return 1;
}
token=json_token->valuestring;
token_time=json_token_time->valuestring;
// 4. 提供明文进行加密
int plaintext_len = strlen((char*)plaintext);
unsigned char *ciphertext = malloc(plaintext_len + AES_BLOCK_SIZE);
int len, ciphertext_len;
if (1 != EVP_EncryptUpdate(ctx, ciphertext, &len, plaintext, plaintext_len)) {
// ... 错误处理 ...
my_zlog_error("错误处理，释放相关内存，返回1");
EVP_CIPHER_CTX_free(ctx);
free(json_to_encrypt);
free(ciphertext);
return 1;
}
ciphertext_len = len;
// 5. 结束加密
if (1 != EVP_EncryptFinal_ex(ctx, ciphertext + len, &len)) {
// ... 错误处理 ...
EVP_CIPHER_CTX_free(ctx);
free(json_to_encrypt);
free(ciphertext);
return 1;
if(secret_key_index == FALSE) {
if(strcmp(token,secret_key)!=0){
send_jwtser(token);
secret_key_index = TRUE;
pthread_mutex_lock(&gverify_mutex);
gverify_count=0;
pthread_mutex_unlock(&gverify_mutex);
my_zlog_notice("topic不同，验证完成");
}
ciphertext_len += len;
// 6. 打印结果并清理
my_zlog_debug("加密后的密文 (Ciphertext)", ciphertext, ciphertext_len);
EVP_CIPHER_CTX_free(ctx);
//拼接cbc
int final_data_len = AES_BLOCK_SIZE + ciphertext_len;
unsigned char *final_data = malloc(final_data_len);
if (final_data == NULL) {
// 错误处理
my_zlog_error("最终数据内存分配失败");
free(json_to_encrypt);
free(ciphertext);
return 1;
}
// 先拷贝IV到最终数据的前16个字节
memcpy(final_data, iv, AES_BLOCK_SIZE);
// 再拷贝密文到IV的后面
memcpy(final_data + AES_BLOCK_SIZE, ciphertext, ciphertext_len);
my_zlog_debug("--- 加密完成 ---");
mqtt_send_verify(final_data, final_data_len);//发送mqtt给服务端
// ********** 重要: 释放所有动态分配的内存 **********
free(json_to_encrypt);
free(ciphertext);
free(final_data);
return 0;
}
//解密函数
// base64解码函数
unsigned char *base64_decode(const char *base64_str, int *out_len) {
BIO *bio, *b64;
int decode_len = strlen(base64_str) * 3 / 4;
unsigned char *buffer = (unsigned char *)malloc(decode_len + 1);
if (buffer == NULL) {
fprintf(stderr, "内存分配失败\n");
return NULL;
if(secret_key_index == TRUE) {
strcpy(secret_key,token);
secret_key_index = FALSE;
}
bio = BIO_new_mem_buf((void *)base64_str, -1);
b64 = BIO_new(BIO_f_base64());
bio = BIO_push(b64, bio);
unsigned long long token_time_s = strtoull(token_time, NULL, 10);
// 不使用换行符
BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL);
// 转换为秒级时间戳
time_t token_time_sec = (time_t)(token_time_s );//后端给的时间戳
*out_len = BIO_read(bio, buffer, strlen(base64_str));
buffer[*out_len] = '\0';
time_t current_verify_time=time(NULL);//当前时间戳
BIO_free_all(bio);
return buffer;
}
// AES-128-CBC 解密
int aes_decrypt(const unsigned char *ciphertext, int ciphertext_len, const unsigned char *key, const unsigned char *iv, unsigned char **plaintext) {
EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
if (!ctx) {
fprintf(stderr, "EVP_CIPHER_CTX_new 失败\n");
return -1;
}
my_zlog_debug("目前时间戳:%1d",(long)current_verify_time);
my_zlog_debug("token时间戳:%1d",(long)token_time_sec);
if (1 != EVP_DecryptInit_ex(ctx, EVP_aes_128_cbc(), NULL, key, iv)) {
fprintf(stderr, "EVP_DecryptInit_ex 失败\n");
EVP_CIPHER_CTX_free(ctx);
return -1;
}
*plaintext = (unsigned char *)malloc(ciphertext_len + AES_BLOCK_SIZE);
if (*plaintext == NULL) {
fprintf(stderr, "内存分配失败\n");
EVP_CIPHER_CTX_free(ctx);
return -1;
if(token_time_sec>current_verify_time){
if(service_verify == TRUE) gverify_index=0;//验证默认为正确
my_zlog_debug("gverify_index= %d ",gverify_index);
if(gverify_count>12000){
send_jwtser(token);
my_zlog_debug("在有效期内");
pthread_mutex_lock(&gverify_mutex);
gverify_count=0;
pthread_mutex_unlock(&gverify_mutex);
my_zlog_debug("gverify_count=%d",gverify_count);
}
int len, plaintext_len;
if (1 != EVP_DecryptUpdate(ctx, *plaintext, &len, ciphertext, ciphertext_len)) {
fprintf(stderr, "EVP_DecryptUpdate 失败\n");
EVP_CIPHER_CTX_free(ctx);
free(*plaintext);
return -1;
}else {
gverify_index=1;
my_zlog_debug("gverify_index= %d ",gverify_index);
}
plaintext_len = len;
if (1 != EVP_DecryptFinal_ex(ctx, *plaintext + len, &len)) {
fprintf(stderr, "EVP_DecryptFinal_ex 失败，可能是密钥或IV错误，或者填充不正确\n");
EVP_CIPHER_CTX_free(ctx);
free(*plaintext);
return -1;
}
plaintext_len += len;
(*plaintext)[plaintext_len] = '\0';
my_zlog_info("token: %s", token);
my_zlog_info("token_time: %s", token_time);
return 0;
EVP_CIPHER_CTX_free(ctx);
return plaintext_len;
}
//当接收到2006判断是否验证成功
int message2006_verify(cJSON *body){
char *status=NULL;
char *onlyid=NULL;
//总解密函数，将base64位进行解密
int aes_decrypt_base64_cbc(const char *base64_input) {
cJSON *json_status = cJSON_GetObjectItem(body, "status");
cJSON *json_onlyid = cJSON_GetObjectItem(body, "only_id");
// 密钥 (必须与加密端一致)
const unsigned char *key = (const unsigned char *)"gds-dfgbcvdfgghj";
// 1. Base64 解码
int binary_len = 0;
unsigned char *binary_data = base64_decode(base64_input, &binary_len);
if (binary_data == NULL) {
fprintf(stderr, "Base64 解码失败\n");
my_zlog_warn("Base64 解码失败");
if(json_status == NULL || json_onlyid==NULL) {
my_zlog_debug("验证为空");
service_verify = FALSE;
gverify_index=1;
my_zlog_debug("gverify_index= %d ",gverify_index);
return 1;
}
// 2. 提取 IV 和密文
if (binary_len <= AES_BLOCK_SIZE) {
fprintf(stderr, "数据长度不足，无法提取 IV\n");
my_zlog_warn("数据长度不足，无法提取 IV");
free(binary_data);
return 1;
status = json_status->valuestring;
onlyid = json_onlyid->valuestring;
my_zlog_debug("data: %s", status);
my_zlog_debug("onlyid: %s", onlyid);
if(strcmp(onlyid,only_id_middle) == 0 && strcmp(status, "1") == 0){
my_zlog_debug("获得验证正确");
service_verify = TRUE;
}else {
my_zlog_debug("获得验证c错误，禁止使用");
gverify_index=1;
my_zlog_debug("gverify_index= %d ",gverify_index);
service_verify = FALSE;
return 2;
}
unsigned char iv[AES_BLOCK_SIZE];
memcpy(iv, binary_data, AES_BLOCK_SIZE);
unsigned char *ciphertext = binary_data + AES_BLOCK_SIZE;
int ciphertext_len = binary_len - AES_BLOCK_SIZE;
return 0;
// 3. 解密
unsigned char *plaintext = NULL;
int plaintext_len = aes_decrypt(ciphertext, ciphertext_len, key, iv, &plaintext);
if (plaintext_len < 0) {
fprintf(stderr, "解密失败\n");
my_zlog_error("解密失败");
free(binary_data);
return 1;
}
my_zlog_debug("解密结果: %s", plaintext);//解密出来的基本为json字符串，到时候可用
// 释放内存
free(binary_data);
free(plaintext);
return 0;
}
// 以下为aes验证，暂时不用注释
// //接收验证消息一次验证，只有在接收时候才会验证,此为aes验证
// int receive_verify(cJSON *body) {
// cJSON *device_info = cJSON_GetObjectItem(body, "device_info");
// if(device_info == NULL) {
// my_zlog_debug("验证为空");
// return 1;
// }
// char *id = NULL;
// char *model = NULL;
// char *number = NULL;
// int *start_time = NULL;
// char *user_id = NULL;
// char *only_id="sdadas";
// // 取各个字段（字符串类型）
// cJSON *json_id = cJSON_GetObjectItem(device_info, "id");
// cJSON *json_model = cJSON_GetObjectItem(device_info, "model");
// cJSON *json_number = cJSON_GetObjectItem(device_info, "number");
// cJSON *json_start_time = cJSON_GetObjectItem(device_info, "start_time");
// cJSON *json_user_id = cJSON_GetObjectItem(device_info, "user_id");
// if (json_id && json_model && json_number && json_start_time && json_user_id) {
// id=json_id->valuestring;
// model=json_model->valuestring;
// number=json_number->valuestring;
// start_time=&json_start_time->valueint;
// user_id=json_user_id->valuestring;
// my_zlog_debug("id: %s", id);
// my_zlog_debug("model: %s", model);
// my_zlog_debug("number: %s", number);
// my_zlog_debug("start_time: %d", *start_time);
// my_zlog_debug("user_id: %s", user_id);
// if(gverify_count>3000){
// int encryption_index=mqtt_encryption(id,model,number, start_time,user_id,only_id);
// my_zlog_notice("加密情况：%d",encryption_index);
// gverify_count=0;
// }
// } else {
// my_zlog_warn("Some fields missing");
// return -1;
// }
// return 0;
// }
// /**
// * @brief 根据传入的参数动态创建一个JSON字符串。
// *
// * @param id 记录ID
// * @param model 设备型号
// * @param number 编号
// * @param start_time 开始时间
// * @param user_id 用户ID
// * @return char* 一个动态分配的JSON字符串。使用后必须调用free()释放。
// * 如果内存分配失败，返回NULL。
// */
// char* create_json_string(const char* id, const char* model, const char* number, const int* start_time, const char* user_id , const char* only_id) {
// // JSON格式模板
// const char *json_format = "{\"id\":\"%s\",\"model\":\"%s\",\"number\":\"%s\",\"start_time\":\"%s\",\"user_id\":\"%s\",\"only_id\":\"%s\"}";
// char time_str[20]; // 足够存储20位数字和终止符
// snprintf(time_str, sizeof(time_str), "%d", *start_time);
// // 1. 计算所需总长度，以安全地分配内存
// // 长度 = 模板长度 - 5*%s长度(10) + 各字符串实际长度 + 1个空终止符
// int needed_size = strlen(json_format) - 10
// + strlen(id)
// + strlen(model)
// + strlen(number)
// + strlen(time_str)
// + strlen(user_id)
// + strlen(only_id) + 1;
// // 2. 分配内存
// char *json_string = (char*)malloc(needed_size);
// if (json_string == NULL) {
// fprintf(stderr, "错误: JSON字符串内存分配失败\n");
// return NULL;
// }
// // 3. 使用snprintf安全地格式化字符串
// snprintf(json_string, needed_size, json_format, id, model, number, time_str, user_id,only_id);
// return json_string;
// }
// //base64编码代码
// char* base64_encode(const unsigned char* buffer, int length) {
// // Base64编码后的长度计算公式：4 * ((length + 2) / 3)
// // +1 是为了最后的空终止符 '\0'
// int b64_len = 4 * ((length + 2) / 3) + 1;
// char *b64_str = (char*)malloc(b64_len);
// if (b64_str == NULL) {
// fprintf(stderr, "错误: Base64字符串内存分配失败\n");
// return NULL;
// }
// // 使用OpenSSL的函数进行编码
// int encoded_len = EVP_EncodeBlock((unsigned char*)b64_str, buffer, length);
// // EVP_EncodeBlock 不会添加空终止符，我们需要手动添加
// b64_str[encoded_len] = '\0';
// return b64_str;
// }
// void mqtt_send_verify(unsigned char *ciphertext, int cipher_len) {
// topic_middle_value();//指针中间函数
// cJSON *root = cJSON_CreateObject();
// cJSON *body = cJSON_CreateObject();
// cJSON *head = cJSON_CreateObject();
// // 8. 【新】将拼接后的二进制数据进行 Base64 编码
// char *base64_output_str = base64_encode(ciphertext, cipher_len);
// if (base64_output_str == NULL) {
// // 错误处理
// my_zlog_debug("base64_output_str为空");
// return ;
// }
// // 打印出最终的、可以直接复制的Base64字符串
// my_zlog_debug("要发送的完整数据 (Base64): %s", base64_output_str);
// cJSON_AddStringToObject(body, "data", base64_output_str);//为0成功
// cJSON_AddNumberToObject(head, "message_type",3006);
// cJSON_AddItemToObject(root, "body", body);
// cJSON_AddItemToObject(root, "head",head);
// char *payload = cJSON_PrintUnformatted(root);
// my_zlog_debug("%s",payload);
// mosquitto_publish(mosq, NULL, TOPIC3, strlen(payload), payload, 0, false);
// cJSON_Delete(root); // 释放 cJSON 对象
// }
// //加密并发送mqtt
// int mqtt_encryption(const char* id, const char* model, const char* number, const int* start_time, const char* user_id , const char* only_id){
// // =================================================================
// // 1. 准备明文、密钥和IV
// // 从配置数据动态生成JSON字符串
// char *json_to_encrypt = create_json_string(id, model, number, start_time, user_id,only_id);
// if (json_to_encrypt == NULL) {
// return 1; // 内存分配失败，退出
// }
// my_zlog_debug("生成的待加密JSON: %s", json_to_encrypt);
// const unsigned char *plaintext = (const unsigned char *)json_to_encrypt;
// const unsigned char *key = (const unsigned char *)"gds-dfgbcvdfgghj";//密钥
// unsigned char iv[AES_BLOCK_SIZE];
// // 生成随机IV
// if (!RAND_bytes(iv, sizeof(iv))) {
// fprintf(stderr, "错误: 无法生成随机IV\n");
// my_zlog_error("错误: 无法生成随机IV");
// free(json_to_encrypt); // 别忘了释放内存
// return 1;
// }
// my_zlog_debug("原始JSON: %s", plaintext);
// my_zlog_debug("\n--- 加密开始 ---");
// // 2. 初始化加密上下文
// EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
// if (!ctx) {
// fprintf(stderr, "错误: EVP_CIPHER_CTX_new 失败\n");
// my_zlog_debug("错误: EVP_CIPHER_CTX_new 失败");
// free(json_to_encrypt);
// return 1;
// }
// // 3. 设置加密算法、密钥和IV
// if (1 != EVP_EncryptInit_ex(ctx, EVP_aes_128_cbc(), NULL, key, iv)) {
// fprintf(stderr, "错误: EVP_EncryptInit_ex 失败\n");
// my_zlog_debug("错误: EVP_EncryptInit_ex 失败");
// EVP_CIPHER_CTX_free(ctx);
// free(json_to_encrypt);
// return 1;
// }
// // 4. 提供明文进行加密
// int plaintext_len = strlen((char*)plaintext);
// unsigned char *ciphertext = malloc(plaintext_len + AES_BLOCK_SIZE);
// int len, ciphertext_len;
// if (1 != EVP_EncryptUpdate(ctx, ciphertext, &len, plaintext, plaintext_len)) {
// // ... 错误处理 ...
// my_zlog_error("错误处理，释放相关内存，返回1");
// EVP_CIPHER_CTX_free(ctx);
// free(json_to_encrypt);
// free(ciphertext);
// return 1;
// }
// ciphertext_len = len;
// // 5. 结束加密
// if (1 != EVP_EncryptFinal_ex(ctx, ciphertext + len, &len)) {
// // ... 错误处理 ...
// EVP_CIPHER_CTX_free(ctx);
// free(json_to_encrypt);
// free(ciphertext);
// return 1;
// }
// ciphertext_len += len;
// // 6. 打印结果并清理
// my_zlog_debug("加密后的密文 (Ciphertext)", ciphertext, ciphertext_len);
// EVP_CIPHER_CTX_free(ctx);
// //拼接cbc
// int final_data_len = AES_BLOCK_SIZE + ciphertext_len;
// unsigned char *final_data = malloc(final_data_len);
// if (final_data == NULL) {
// // 错误处理
// my_zlog_error("最终数据内存分配失败");
// free(json_to_encrypt);
// free(ciphertext);
// return 1;
// }
// // 先拷贝IV到最终数据的前16个字节
// memcpy(final_data, iv, AES_BLOCK_SIZE);
// // 再拷贝密文到IV的后面
// memcpy(final_data + AES_BLOCK_SIZE, ciphertext, ciphertext_len);
// my_zlog_debug("--- 加密完成 ---");
// mqtt_send_verify(final_data, final_data_len);//发送mqtt给服务端
// // ********** 重要: 释放所有动态分配的内存 **********
// free(json_to_encrypt);
// free(ciphertext);
// free(final_data);
// return 0;
// }
// //解密函数
// // base64解码函数
// unsigned char *base64_decode(const char *base64_str, int *out_len) {
// BIO *bio, *b64;
// int decode_len = strlen(base64_str) * 3 / 4;
// unsigned char *buffer = (unsigned char *)malloc(decode_len + 1);
// if (buffer == NULL) {
// fprintf(stderr, "内存分配失败\n");
// return NULL;
// }
// bio = BIO_new_mem_buf((void *)base64_str, -1);
// b64 = BIO_new(BIO_f_base64());
// bio = BIO_push(b64, bio);
// // 不使用换行符
// BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL);
// *out_len = BIO_read(bio, buffer, strlen(base64_str));
// buffer[*out_len] = '\0';
// BIO_free_all(bio);
// return buffer;
// }
// // AES-128-CBC 解密
// int aes_decrypt(const unsigned char *ciphertext, int ciphertext_len, const unsigned char *key, const unsigned char *iv, unsigned char **plaintext) {
// EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
// if (!ctx) {
// fprintf(stderr, "EVP_CIPHER_CTX_new 失败\n");
// return -1;
// }
// if (1 != EVP_DecryptInit_ex(ctx, EVP_aes_128_cbc(), NULL, key, iv)) {
// fprintf(stderr, "EVP_DecryptInit_ex 失败\n");
// EVP_CIPHER_CTX_free(ctx);
// return -1;
// }
// *plaintext = (unsigned char *)malloc(ciphertext_len + AES_BLOCK_SIZE);
// if (*plaintext == NULL) {
// fprintf(stderr, "内存分配失败\n");
// EVP_CIPHER_CTX_free(ctx);
// return -1;
// }
// int len, plaintext_len;
// if (1 != EVP_DecryptUpdate(ctx, *plaintext, &len, ciphertext, ciphertext_len)) {
// fprintf(stderr, "EVP_DecryptUpdate 失败\n");
// EVP_CIPHER_CTX_free(ctx);
// free(*plaintext);
// return -1;
// }
// plaintext_len = len;
// if (1 != EVP_DecryptFinal_ex(ctx, *plaintext + len, &len)) {
// fprintf(stderr, "EVP_DecryptFinal_ex 失败，可能是密钥或IV错误，或者填充不正确\n");
// EVP_CIPHER_CTX_free(ctx);
// free(*plaintext);
// return -1;
// }
// plaintext_len += len;
// (*plaintext)[plaintext_len] = '\0';
// EVP_CIPHER_CTX_free(ctx);
// return plaintext_len;
// }
// //总解密函数，将base64位进行解密
// int aes_decrypt_base64_cbc(const char *base64_input) {
// // 密钥 (必须与加密端一致)
// const unsigned char *key = (const unsigned char *)"gds-dfgbcvdfgghj";
// // 1. Base64 解码
// int binary_len = 0;
// unsigned char *binary_data = base64_decode(base64_input, &binary_len);
// if (binary_data == NULL) {
// fprintf(stderr, "Base64 解码失败\n");
// my_zlog_warn("Base64 解码失败");
// return 1;
// }
// // 2. 提取 IV 和密文
// if (binary_len <= AES_BLOCK_SIZE) {
// fprintf(stderr, "数据长度不足，无法提取 IV\n");
// my_zlog_warn("数据长度不足，无法提取 IV");
// free(binary_data);
// return 1;
// }
// unsigned char iv[AES_BLOCK_SIZE];
// memcpy(iv, binary_data, AES_BLOCK_SIZE);
// unsigned char *ciphertext = binary_data + AES_BLOCK_SIZE;
// int ciphertext_len = binary_len - AES_BLOCK_SIZE;
// // 3. 解密
// unsigned char *plaintext = NULL;
// int plaintext_len = aes_decrypt(ciphertext, ciphertext_len, key, iv, &plaintext);
// if (plaintext_len < 0) {
// fprintf(stderr, "解密失败\n");
// my_zlog_error("解密失败");
// free(binary_data);
// return 1;
// }
// my_zlog_debug("解密结果: %s", plaintext);//解密出来的基本为json字符串，到时候可用
// // 释放内存
// free(binary_data);
// free(plaintext);
// return 0;
// }
\ No newline at end of file
src/thread_main.c
View file @ c380ff23
......@@ -138,7 +138,7 @@ void *delay_count(void *arg) {
Delay_Ms(0,5);
device_delay_count++;//设备计时，坦克打击倒退逻辑
gverify_count++;//验证计时,每15s一次
if(gverify_count >= 5000) gverify_count = 5000;
if(gverify_count >= 20000) gverify_count = 20000;
if(device_delay_count >= 5000) device_delay_count = 5000;
}
return NULL;
......
system/gpio/gpio_pwm_car0102.c
View file @ c380ff23
......@@ -70,19 +70,19 @@ void car0102_mode_2_back(unsigned char gval) {
if (gval < 50) {
pwmWrite(PWM_PIN_SPEED, 0);
} else if (gval <= 55) {
pwmWrite(PWM_PIN_SPEED, b + 30 * k);
pwmWrite(PWM_PIN_SPEED,b + 40 * k);
} else if (gval <= 60) {
pwmWrite(PWM_PIN_SPEED, b + 30 * k);
pwmWrite(PWM_PIN_SPEED,b + 40 * k);
} else if (gval <= 65) {
pwmWrite(PWM_PIN_SPEED, b + 30 * k);
pwmWrite(PWM_PIN_SPEED, b + 40* k);
} else if (gval <= 70) {
pwmWrite(PWM_PIN_SPEED, b + 30 * k);
pwmWrite(PWM_PIN_SPEED, b + 40 * k);
} else if (gval <= 75) {
pwmWrite(PWM_PIN_SPEED, b + 30 * k);
pwmWrite(PWM_PIN_SPEED, b + 40 * k);
} else if (gval <= 90) {
pwmWrite(PWM_PIN_SPEED, b + 30 * k);
pwmWrite(PWM_PIN_SPEED, b + 40 * k);
} else if (gval <= 100) {
pwmWrite(PWM_PIN_SPEED, b + 35 * k);
pwmWrite(PWM_PIN_SPEED, b + 40 * k);
} else if (gval <= 110) {
pwmWrite(PWM_PIN_SPEED, b + 40 * k);
} else if (gval <= 120) {
......
system/sensor/heat.c
View file @ c380ff23
......@@ -5,6 +5,7 @@
char temperature[20];
float temp_str;
//温度获取
int heat_tem() {
FILE *file;
char line[MAX_LINE_LENGTH];
......
system/sensor/warm.c
View file @ c380ff23
......@@ -4,7 +4,8 @@
#include "gpio_pwm_carship.h"
#include "request.h"
int alarm_highest(int index) {//最高警报，最低电压报警
//最高警报，最低电压报警
int alarm_highest(int index) {
if(index == 1) {
pin_value(20,1);//紫灯
if(enable_buzzer_value) {
......@@ -18,7 +19,8 @@ int alarm_highest(int index) {//最高警报，最低电压报警
return index ;
}
int alarm_low(int index) {//比较小警报
//比较小警报
int alarm_low(int index) {
if(index == 1) {
pin_value(16,1);//黄灯
} else if(index == 0) {
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment