【兆易创新GD32H759I-EVAL开发板】1.（原创）AI自动驾驶公交安全之防御黑客病毒(源代码)

本文链接：https://blog.csdn.net/cjjgjgzs/article/details/136447732

  嗨，亲爱的工程师、学生和爱好者们，我来啦！欢迎来到神秘的兆易创新GD32H759I-EVAL开发板世界！如果你是一位电子工程师或者对魔法般的嵌入式技术感兴趣，那么你来到的地方绝对没错！今天，我们将一起探索一个令人惊叹的【兆易创新GD32H759I-EVAL开发板】。防御黑客病毒入侵AI自动驾驶公交系统是一个涉及到多个层面，包括硬件安全、操作系统安全、网络通信安全、应用层安全等。下面我将写一个简化的C语言程序，用于检测并防御潜在的恶意输入：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

// 假设有一些敏感数据，如公交路线、时间表等
char route[100] = "Route 123"; // 定义字符数组route并初始化为"Route 123"
char schedule[100] = "07:00-19:00"; // 定义字符数组schedule并初始化为"07:00-19:00"

// 用于模拟黑客攻击的函数
void simulateHackerAttack(char *target) {
printf("Hacker trying to access: %s\n", target); // 打印黑客尝试访问的信息
// 这里可以添加模拟黑客攻击的代码，如尝试解密、篡改数据等
}

// 检查输入是否安全的函数
int isInputSafe(char *input) {
// 检查输入是否包含非法字符或恶意代码
// 这里只是一个简单的示例，实际应用中需要更复杂的检查
for (int i = 0; i < strlen(input); i++) {
      if (input < 32 || input > 126) { // 如果字符的ASCII值不在32-126之间，认为是非法字符
         return 0; // 输入包含非法字符，返回0表示不安全
      }
}
return 1; // 输入安全，返回1
}

int main() {
char input[100]; // 定义字符数组input，用于存储用户输入

// 模拟黑客攻击
simulateHackerAttack(route); // 黑客尝试访问route
simulateHackerAttack(schedule); // 黑客尝试访问schedule

// 提示用户输入
printf("Enter a command (e.g., 'show route'): "); // 提示用户输入命令
fgets(input, sizeof(input), stdin); // 从标准输入读取用户输入并存储在input中

// 去除输入中的换行符
input[strcspn(input, "\n")] = 0; // 使用strcspn找到换行符的位置并替换为字符串结束符'\0'

// 检查输入是否安全
if (isInputSafe(input)) { // 如果输入安全
      if (strcmp(input, "show route") == 0) { // 如果输入是"show route"
         printf("Current route: %s\n", route); // 打印当前路线
      } else if (strcmp(input, "show schedule") == 0) { // 如果输入是"show schedule"
         printf("Current schedule: %s\n", schedule); // 打印当前时间表
      } else { // 如果输入是其他命令
         printf("Unknown command. Please try again.\n"); // 提示用户输入未知命令
      }
} else { // 如果输入不安全
      printf("Input contains unsafe characters. Access denied.\n"); // 拒绝访问并打印警告信息
}

return 0; // 程序正常退出
}

首先，我们需要明白，安全策略通常需要在多个层次上实施，包括但不限于：

输入验证和过滤：确保所有进入系统的输入都是预期的、合法的。
最小权限原则：确保系统组件只拥有执行其任务所需的最小权限。
定期更新和补丁管理：及时修复已知的安全漏洞。
安全审计和监控：检测并响应任何可疑活动。

以下是我编写的一个简化的C语言程序，用于检测潜在的恶意输入：
#include <stdio.h>  // 引入标准输入输出库，这样我们可以使用printf和scanf等函数。
#include <string.h> // 引入字符串库，这样我们可以使用strlen等函数。
#include <ctype.h>  // 引入字符类型库，这样我们可以使用isalnum等函数来检测字符是否为字母或数字。

// 这个函数是一个"侦探"，专门查找字符串中的"罪犯"——非法字符。
int contains_malicious_characters(const char *input) {
// 如果传入的字符串是"逃犯"（空指针），则立即报警，返回1表示有非法字符。
if (input == NULL) {
      return 1;
}

// 开始对字符串进行逐字符的"搜捕"。
for (size_t i = 0; i < strlen(input); i++) {
      // 如果字符不是"好人"（字母或数字），也不是"卧底"（下划线或减号），则立即报警，返回1表示有非法字符。
      if (!isalnum(input) && input != '_' && input != '-') {
         return 1;
      }
}

// 如果整个字符串都查完了，没有发现"罪犯"，则返回0表示字符串合法。
return 0;
}

int main() {
// 准备一个"监狱"，用于存放用户输入的公交站点ID。
char bus_stop_id[50];

// 提示用户输入公交站点ID。
printf("请输入公交站点ID: ");
// 使用scanf函数接收用户的输入，但限制最多只能输入49个字符，防止"罪犯"太多导致"监狱"装不下，造成"越狱"（缓冲区溢出）。
scanf("%49s", bus_stop_id);

// 调用"侦探"函数，检查用户输入的公交站点ID是否包含非法字符。
if (contains_malicious_characters(bus_stop_id)) {
      // 如果发现非法字符，立即报警，提示用户有潜在的恶意输入。
      printf("警告：检测到潜在的恶意输入！\n");
} else {
      // 如果一切正常，则告诉用户公交站点ID是合法的。
      printf("公交站点ID合法。\n");
}

// 程序结束，返回0表示一切正常。
return 0;
}

这个程序仅仅是一个非常基础的输入验证。在实际应用中，需要考虑更多的安全策略和措施，包括但不限于：
使用加密技术来保护通信和数据。
实现安全审计和日志记录。
定期更新和打补丁。
使用最小权限原则来配置系统组件。
使用安全的编程实践，如避免缓冲区溢出、输入验证、错误处理等。防御黑客病毒入侵是一个持续的过程，需要不断地评估和调整安全策略。
由于黑客的攻击方式可能多种多样，因此防御策略也需要全面且不断更新。
首先，我们要明白防御黑客入侵的基本原则：最小化权限原则、输入验证、更新和修补程序、日志记录和监控、以及安全审计。
使用安全编程实践：例如，避免使用不安全的函数（如sprintf），而使用更安全的版本（如snprintf）。确保所有输入都经过适当的验证和清理。
实施访问控制：确保只有经过授权的用户或系统组件才能访问敏感数据和功能。
使用加密：对于所有敏感数据和通信，使用加密来确保数据的机密性和完整性。
定期更新和修补：确保系统和所有依赖的库都是最新的，并且已经应用了所有可用的安全修补程序。
监控和日志记录：记录所有系统活动和潜在的安全事件，以便在发生问题时进行审计和调查。
安全审计和漏洞评估：定期进行安全审计和漏洞评估，以识别并修复潜在的安全风险。
培训和教育：确保开发、运维和安全团队都了解最新的安全威胁和防御策略。
请注意，防御黑客入侵是一个持续的过程，需要不断的努力和维护。
以下是我写的一个简化的C语言程序，展示了如何在AI自动驾驶公交系统中实施一些基本的防御措施：

#include <stdio.h>  // 引入标准输入输出库，这样我们可以使用printf和scanf等函数
#include <stdlib.h> // 引入标准库，虽然在这段代码里它没做什么，但它是那种“总是带着，以防万一”的家伙
#include <string.h> // 引入字符串处理库，虽然这里也没用到，但它总是说：“总有一天你会需要我的！”
#include <time.h> // 引入时间库，因为我们想记录活动发生的时间

// 定义一个函数，AI自动驾驶公交车
void driveBus(int route, float speed) {
printf("Driving bus on route %d at speed %.2f km/h\n", route, speed);
// AI说：“我要开车了，路线是%d，速度是%.2f km/h。”
}

// 定义一个函数，检查路线是否有效
int validateRoute(int route) {
if (route < 1 || route > 10) {
      printf("Invalid route number. Please enter a route between 1 and 10.\n");
      // 如果路线不在1到10之间，AI会摇头说：“这个路线不对哦，请输入1到10之间的路线。”
      return 0; // 返回0表示无效
}
return 1; // 返回1表示有效
}

// 定义一个函数，检查速度是否有效
int validateSpeed(float speed) {
if (speed < 0 || speed > 60) {
      printf("Invalid speed. Please enter a speed between 0 and 120 km/h.\n");
      // 如果速度不在0到60之间，AI会摇头说：“这个速度太离谱了，请输入0到60之间的速度。”
      return 0; // 返回0表示无效
}
return 1; // 返回1表示有效
}

// 定义一个函数，记录活动日志
void logActivity(const char *activity) {
time_t currentTime = time(NULL);  // 获取当前时间
char *timeString = ctime(¤tTime); // 将时间转化为可读的字符串
printf("[%s] %s\n", timeString, activity); // 记录活动和时间
// AI说：“现在的时间是%s，我进行了%s活动。”
}

int main() {
int route = 0; // 定义一个变量来保存路线
float speed = 0; // 定义一个变量来保存速度

// 从用户那里获取输入
printf("Enter route number: "); // AI说：“请输入路线号：”
scanf("%d", &route); // 用户输入路线号，AI接收并保存到route变量里
printf("Enter speed (km/h): "); // AI说：“请输入速度（km/h）：”
scanf("%f", &speed); // 用户输入速度，AI接收并保存到speed变量里

// 验证输入
if (!validateRoute(route)) {
      return 1; // 如果路线无效，程序就结束
}
if (!validateSpeed(speed)) {
      return 1; // 如果速度无效，程序也结束
}

// 记录活动日志
logActivity("Driving bus with valid inputs."); // AI说：“用有效的输入来开车了，我要记录一下。”

// 调用AI驾驶系统函数
driveBus(route, speed); // AI说：“好的，我要开始开车了，路线是%d，速度是%.2f km/h。”

return 0; // 程序正常结束
}

防御黑客攻击需要采取综合性的措施以下是一些常见的防御黑客攻击的手段：

使用强密码：使用复杂的、难猜的密码可以减少黑客破解账号的可能性。建议使用大小写字母、数字和特殊字符组合而成的长密码，并定期更换。
定期更新软件和系统补丁：及时更新操作系统、数据库和其他软件补丁，修补已知的安全漏洞，防止利用这些漏洞进行攻击。
使用加密技术：对敏感数据和通信内容进行加密处理，确保只有授权人员能够解密并获取信息。这可以有效地保护数据安全。
加强网络安全意识：提高内部员工和外部用户的安全意识，教育他们不要轻易泄露个人信息或敏感数据，不点击可疑链接或下载不明附件等。
实施访问控制策略：限制对敏感资源的访问权限，例如只允许特定的员工或部门访问某些数据或功能。这样可以防止未经授权的访问和操作。
使用防病毒软件：安装防病毒软件可以帮助检测和清除潜在的恶意软件，防止其对系统的破坏性影响。
定期备份数据：定期备份关键数据和系统镜像，可以在遭受攻击时快速恢复到初始状态，减少损失。
监控网络流量：实时监控网络流量，发现异常活动或攻击迹象及时报警和处理，有助于防范黑客攻击。

需要注意的是，以上只是一些基本的防御黑客攻击手段，实际应用中需要根据具体情况制定更全面的安全防护策略。同时，专业的安全团队也需要持续跟进威胁情报和技术趋势的变化，不断优化和完善防御方案。

#include <stdio.h>  // 引入标准输入输出库，这样我们就可以打印东西到屏幕上了，不然程序就哑巴了。
#include <stdlib.h> // 引入标准库，提供了一些基本的函数，比如exit()。
#include <string.h> // 引入字符串处理库，但在这段代码中它其实没做什么，可能是想偷偷练习字符串操作。
#include <unistd.h> // 引入POSIX操作系统API，这个库提供了很多底层的系统调用，像是读文件、写文件、改变权限之类的。
#include <sys/types.h> // 引入系统类型定义，为了之后使用stat和chmod函数。
#include <sys/stat.h>  // 引入文件状态库，为了获取文件的各种信息，比如大小、时间、权限等。

// 定义一个函数，检查文件或目录的权限
int check_permissions(const char *path) {
struct stat fileStat; // 定义一个结构体来保存文件的状态信息。
if (stat(path, &fileStat) != 0) { // 使用stat函数获取文件状态，如果出错了就打印错误信息。
      perror("stat"); // 打印出“stat: 错误信息”，这里像是给stat函数加了个小喇叭，让它出错时能喊出来。
      return -1; // 出错了就返回-1，告诉调用者：“嘿，我这里有点问题。”
}

// 只允许文件拥有者读写执行
if ((fileStat.st_mode & (S_IRUSR | S_IWUSR | S_IXUSR)) != (S_IRUSR | S_IWUSR | S_IXUSR)) {
      fprintf(stderr, "Insecure permissions on %s\n", path); // 如果权限不对，就向标准错误输出打印一个警告信息，告诉文件：“你的权限设置得太开放了，这样不安全哦！”
      return -1; // 然后返回-1，告诉调用者：“嘿，这个文件权限有问题。”
}

return 0; // 如果一切正常，就返回0，告诉调用者：“这个文件权限设置得很好，没问题！”
}

// 定义一个函数，检查进程是否以root权限运行
int is_running_as_root() {
if (geteuid() != 0) { // 使用geteuid函数检查当前进程的有效用户ID是否为0（即root用户）。
      fprintf(stderr, "This program must be run as root\n"); // 如果不是root用户，就向标准错误输出打印一个信息，告诉用户：“喂，你这个程序必须要用root权限来运行哦！”
      return -1; // 然后返回-1，告诉调用者：“你这个程序没有以root权限运行，我不接受！”
}

return 0; // 如果一切正常，就返回0，告诉调用者：“你这个程序是以root权限运行的，很好！”
}

// 定义一个函数，设置文件权限为只有文件拥有者可以读写执行
int secure_file_permissions(const char *path) {
if (chmod(path, S_IRUSR | S_IWUSR | S_IXUSR) != 0) { // 使用chmod函数来改变文件的权限，只允许文件拥有者读写执行。
      perror("chmod"); // 如果出错了，就打印出“chmod: 错误信息”，这里像是给chmod函数加了个小喇叭，让它出错时能喊出来。
      return -1; // 出错了就返回-1，告诉调用者：“嘿，我试图改变文件权限，但出了点问题。”
}

return 0; // 如果一切正常，就返回0，告诉调用者：“文件权限已经成功设置为只有文件拥有者可以读写执行了。”
}

int main() {
// 检查程序是否以root权限运行
if (is_running_as_root() < 0) {
      exit(EXIT_FAILURE); // 如果不是以root权限运行，就结束程序，并返回一个表示失败的状态码。
}

// 检查关键文件或目录的权限
const char *critical_file = "/path/to/critical/file"; // 定义一个字符串变量来保存关键文件或目录的路径。
if (check_permissions(critical_file) < 0) { // 使用之前定义的函数来检查这个关键文件或目录的权限。
      exit(EXIT_FAILURE); // 如果权限有问题，就结束程序，并返回一个表示失败的状态码。
}

// 设置新文件的安全权限
const char *new_file = "/path/to/new/file"; // 定义一个字符串变量来保存新文件的路径。
if (secure_file_permissions(new_file) < 0) { // 使用之前定义的函数来设置新文件的安全权限。
      exit(EXIT_FAILURE); // 如果设置权限时出错了，就结束程序，并返回一个表示失败的状态码。
}

// TODO: 添加更多的安全检查和防御措施 // 这里像是一个待办事项清单，告诉开发者：“别忘了，这里还有很多其他的安全检查和防御措施需要做呢！”

printf("AI自动公交驾驶系统的基本安全措施已设置。\n"); // 最后，打印一条信息告诉用户：“嘿，你的AI自动公交驾驶系统的基本安全措施已经设置好了！”
return 0; // 程序执行成功，返回0。
}

这个程序展示了如何检查文件和目录的权限，如何确保程序以root权限运行，以及如何设置新文件的安全权限。然而，这只是一个非常基础的程序。在实际应用中，防御黑客病毒入侵AI自动公交驾驶系统需要更全面的安全策略，包括但不限于：
系统更新和补丁管理：确保操作系统、编译器、依赖库、AI框架等都保持最新状态，并及时应用安全补丁。
访问控制：实施严格的访问控制策略，限制对关键文件和目录的访问。
输入验证和过滤：对所有输入进行验证和过滤，防止恶意输入导致的漏洞利用。
网络和通信安全：实施加密通信、防火墙、入侵检测系统等网络安全措施。
备份和恢复策略：定期备份关键数据，并准备好在遭受攻击时能够快速恢复的策略。
我再写一个程序进行说明：
#include <stdio.h>  // 我们引入了这个头文件，就像给程序喂了一勺“魔法粉末”，让它可以开始说话和听话了。
#include <stdlib.h> // 这个头文件提供了许多“标准”工具，像是变魔术一样，让我们的程序可以做出各种神奇的事情。
#include <string.h> // 有了这个头文件，我们的程序就可以玩“字符串接龙”的游戏了。
#include <time.h> // 引入这个头文件，就像给程序戴上一块手表，让它可以知道什么时候是早餐时间，什么时候该去睡觉了。

// 假设有一些敏感数据，如公交路线、时间表等
char route[100] = "Route 123";  // 这是一个“秘密”的公交路线，但它就像把秘密写在额头上，谁都能看见。
char schedule[100] = "07:00-19:00";  // 这是公交的时间表，但它像一张贴在车站的公告，人人皆知。

// 用于模拟黑客攻击的函数
void simulateHackerAttack(char *target) {  // 这是一个假装自己是黑客的函数，但实际上它只是假装攻击一下，然后告诉所有人它做了什么。
printf("Hacker trying to access: %s\n", target);  // 当这个函数被调用时，它会像黑客一样说：“我要攻击这个！”
// 这里可以添加模拟黑客攻击的代码，如尝试解密、篡改数据等  // 但实际上，它只是假装攻击，并没有真的做坏事。
}

// 检查输入是否安全的函数
int isInputSafe(char *input) {  // 这是一个“安全检查员”函数，它会检查输入的内容是否安全。
// 检查输入是否包含非法字符或恶意代码  // 它就像用放大镜仔细检查每一个字符，看是否有坏东西。
// 这里只是一个简单的示例，实际应用中需要更复杂的检查  // 但实际上，它只检查了字符是否在32到126之间，这就像是检查一个苹果是否红，但没有检查它是否烂。
for (int i = 0; i < strlen(input); i++) {  // 它开始一个一个地检查每个字符。
      if (input < 32 || input > 126) {  // 如果字符不在32到126之间，就像找到了一个烂苹果。
         return 0; // 输入包含非法字符  // 于是它急忙报告：“不好，有坏东西！”
      }
}
return 1; // 输入安全  // 如果检查完所有的字符都没问题，它就放心地说：“这个输入是安全的。”
}

int main() {  // 这是程序的主入口，就像是一个大舞台，所有其他的函数和变量都在这里表演和展示。
char input[100];  // 这是一个“观众”变量，它准备接收用户的输入。

// 模拟黑客攻击
simulateHackerAttack(route);  // 假装黑客开始攻击“秘密”的公交路线，但实际上只是告诉所有人它做了什么。
simulateHackerAttack(schedule);  // 假装黑客又开始攻击时间表，但仍然只是虚张声势。

// 提示用户输入
printf("Enter a command (e.g., 'show route'): ");  // 程序像是一个服务员，对用户说：“请输入一个命令，比如‘show route’。”
fgets(input, sizeof(input), stdin);  // 程序开始“聆听”用户的输入，就像是用耳朵接收声音。

// 去除输入中的换行符
input[strcspn(input, "\n")] = 0;  // 程序像一个细心的编辑，仔细地去掉了用户输入中的换行符，就像去掉文章中的多余空格。

// 检查输入是否安全
if (isInputSafe(input)) {  // 安全检查员开始工作，检查用户的输入是否安全。
      if (strcmp(input, "show route") == 0) {  // 如果用户输入的是“show route”，程序就像是一个导游，告诉用户公交路线。
         printf("Current route: %s\n", route);  // 导游说：“当前的路线是Route 123。”
      } else if (strcmp(input, "show schedule") == 0) {  // 如果用户输入的是“show schedule”，程序就像一个时间表管理员，告诉用户公交时间。
         printf("Current schedule: %s\n", schedule);  // 时间表管理员说：“当前的时间表是07:00-19:00。”
      } else {  // 如果用户输入了其他内容，程序就像一个困惑的演员，不知道该如何表演。
         printf("Unknown command. Please try again.\n");  // 它只好尴尬地说：“不知道这个命令，请再试一次。”
      }
} else {  // 如果输入不安全，程序就像一个严格的保安，拒绝用户进入。
      printf("Input contains unsafe characters. Access denied.\n");  // 它严肃地说：“输入包含不安全字符，拒绝访问。”
}

return 0;  // 程序表演结束，完美谢幕，等待下一次的演出。
}