拦截 open调用 （进程白名单，文件白名单）

news2024/11/26 23:37:19

拦截 open

文章目录

      • 拦截 open
      • 第一个需求
      • 文件结构
        • 进程白名单
        • 文件白名单
      • 测试代码
      • 第一个版本
      • 版本二
        • 代码演示
      • 增加一个日志记录
      • 代码解释

gcc -shared -fPIC -o libintercept.so intercept.c -ldl

LD_PRELOAD=./libintercept.so ./processA

在Linux中，我们可以使用LD_PRELOAD环境变量来拦截并替换系统调用，如open函数。这是一个简单的示例，展示了如何创建一个新的open函数来替换系统的open函数：

#define _GNU_SOURCE
#include <dlfcn.h>
#include <stdio.h>

// 定义原始的open函数
static int (*original_open)(const char*, int, ...);

// 我们的新open函数
int open(const char *pathname, int flags, ...) {
    printf("Intercepted open call for %s\n", pathname);

    // 获取原始的open函数
    original_open = dlsym(RTLD_NEXT, "open");

    // 调用原始的open函数
    return original_open(pathname, flags);
}

~~~

你可以将这段代码保存为一个.c文件，然后使用以下命令编译为共享库：

gcc -shared -fPIC -o libintercept.so intercept.c -ldl


然后，你可以使用LD_PRELOAD环境变量来运行你的程序，如下所示：

```bash
LD_PRELOAD=./libintercept.so your_program

这样，每当你的程序调用open函数时，都会调用我们的新open函数，而不是系统的open函数。

请注意，这只是一个基本的示例，你可能需要根据你的具体需求来修改这个新的open函数。此外，使用LD_PRELOAD拦截系统调用应该谨慎进行，因为它可能会影响到其他库的行为。

第一个需求

第一个需求
1.白名单进程 保存在 进程白名单文件 , 受保护文件的文件名保存在 文件白名单文件 中,
2.白名单 进程 能访问 所有文件(受保护文件和非保护文件)
3.对所有进程访问文件的 过程进行日志记录.(进程名,文件名,访问时间,成功与否)

在这里插入图片描述

文件结构

.
├── Files
│   ├── t1
│   ├── t2
│   ├── t3
│   ├── t4
│   ├── t5
│   ├── t6
│   ├── t7
│   ├── t8
│   └── t9
├── WHITELIST
│   ├── file_whitelist
│   ├── file_whitelist_backup
│   └── process_whitelist
├── intercept.c
├── libintercept.so
├── log.txt
├── p1
└── p1.c
进程白名单

白名单文件的路径名是/home/xxx/Test/WHITELIST/process_whitelist

/home/xxx/Test/p1
/home/xxx/Test/p2
/home/xxx/Test/p3
/home/xxx/Test/p4
/home/xxx/Test/p5
文件白名单

非白名单文件的路径名是/home/xxx/Test/WHITELIST/file_whitelist

/home/xxx/Test/Files/t1
/home/xxx/Test/Files/t2
/home/xxx/Test/Files/t3
/home/xxx/Test/Files/t4
/home/xxx/Test/Files/t5

测试代码

#include <dirent.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

int main() {
    DIR *dir;
    struct dirent *entry;
    int fd;

    // 打开目录
    dir = opendir("/home/xxx/Test/Files");
    if (dir == NULL) {
        perror("无法打开目录");
        return 1;
    }

    // 遍历目录中的每个文件
    while ((entry = readdir(dir)) != NULL) {
        // 检查文件名是否以"t"开头
        if (strncmp(entry->d_name, "t", 1) == 0) {
            char filepath[1024];

            // 构造文件路径
            snprintf(filepath, sizeof(filepath), "/home/xxx/Test/Files/%s", entry->d_name);

            // 使用open函数打开文件
            fd = open(filepath, O_RDWR);
            if (fd == -1) {
                perror("无法打开文件");
                continue;
            }

            printf("打开文件: %s\n", filepath);

            // 写入文件
            const char *message = "我访问了这个文件\n";
            if (write(fd, message, strlen(message)) == -1) {
                perror("无法写入文件");
            }

            // 关闭文件
            if (close(fd) == -1) {
                perror("无法关闭文件");
            }
        }
    }

    // 关闭目录
    if (closedir(dir) == -1) {
        perror("无法关闭目录");
    }

    return 0;
}

第一个版本

gcc -shared -fPIC -o libintercept.so intercept.c -ldl

当然，这是修改后的完整代码：

#define _GNU_SOURCE
#include <dlfcn.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <limits.h>

// 定义原始的open函数
static int (*original_open)(const char*, int, ...);

// 根据进程ID获取进程名
char *get_process_name(pid_t pid) {
    char path[256];
    static char name[256];

    snprintf(path, sizeof(path), "/proc/%d/cmdline", pid);
    FILE *file = fopen(path, "r");
    if (file == NULL) {
        return NULL;
    }
    if (fgets(name, sizeof(name), file) == NULL) {
        fclose(file);
        return NULL;
    }

    fclose(file);

    // 将程序名称转换为绝对路径
    char *absolute_path = realpath(name, NULL);
    if (absolute_path != NULL) {
        strncpy(name, absolute_path, sizeof(name));
        free(absolute_path);
    }

    return name;
}

// 检查进程是否在白名单中
int is_whitelisted_process(const char *whitelist) {
    FILE *file = fopen(whitelist, "r");
    if (file == NULL) {
        return 0;
    }

    char *process_name = get_process_name(getpid());
    if (process_name == NULL) {
        fclose(file);
        return 0;
    }

    char line[256];
    while (fgets(line, sizeof(line), file)) {
        line[strcspn(line, "\n")] = '\0';  // 去掉换行符
        if (strcmp(line, process_name) == 0) {
            printf("匹配进程白名单成功,进程名为%s\n",process_name);
            fclose(file);
            return 1;
        }
    }

    fclose(file);
    return 0;
}

// 检查文件是否在白名单中
int is_whitelisted_file(const char *whitelist, const char *filename) {
    FILE *file = fopen(whitelist, "r");
    if (file == NULL) {
        return 0;
    }

    char line[256];
    while (fgets(line, sizeof(line), file)) {
        line[strcspn(line, "\n")] = '\0';  // 去掉换行符
        if (strcmp(line, filename) == 0) {
            printf("匹配文件白名单成功,访问文件名为%s\n",filename);
            fclose(file);
            return 1;
        }
    }

    fclose(file);
    return 0;
}

// 我们的新open函数
int open(const char *pathname, int flags, ...) {   //pathname 是打开的文件地址
    // 获取原始的open函数
    original_open = dlsym(RTLD_NEXT, "open");

    char real_path[PATH_MAX];
    realpath(pathname, real_path); // 将打开的文件路径转换为绝对路径

    // 检查进程是否在白名单中
    if (is_whitelisted_process("/home/xxx/Test/WHITELIST/process_whitelist")) {   // 传入的是进程白名单列表的绝对地址
        // 白名单进程可以访问所有文件
        return original_open(real_path, flags);
    }

    // 检查文件是否在白名单中,  传入文件白名单的绝对地址,和要访问文件的绝对地址
    if (!is_whitelisted_file("/home/xxx/Test/WHITELIST/file_whitelist", real_path)) {
        printf("非白名单文件的路径名是%s\n",real_path);
        // 非白名单进程可以访问非白名单文件
        return original_open(real_path, flags);
    }

    // 非白名单进程不能访问白名单文件
    fprintf(stderr, "拒绝访问: %s\n", real_path);
    return -1;
}

这段代码首先获取进程名，并将其转换为绝对路径。然后，它将这个绝对路径与进程白名单进行比较。如果进程在白名单中，它就可以访问所有文件。如果进程不在白名单中，但要访问的文件也不在白名单中，那么进程仍然可以访问该文件。如果进程和文件都不在白名单中，那么访问将被拒绝。

之前的版本一没有获取进程名绝对值

版本二

  1. 使用哈希表存储白名单：每次检查文件或进程是否在白名单中时，都需要打开白名单文件并逐行读取。这在白名单很大时会非常低效。相反，可以在程序启动时将白名单读入内存中的哈希表。这样，检查一个文件或进程是否在白名单中只需要在哈希表中查找，这将大大提高效率。
  2. 避免重复计算：is_whitelisted_process和is_whitelisted_file函数都调用了get_process_name函数来获取进程名。这意味着在一次open调用中，可能会多次计算同一个进程的名字。可以通过将进程名缓存到全局变量中来避免这种重复计算。
  3. 减少内存分配：在get_process_name函数中，每次调用都会分配一个新的字符串来存储进程名。这可能会导致大量的内存分配和释放。可以考虑使用静态缓冲区来存储进程名，从而避免频繁的内存分配。
  4. 关闭文件描述符：在is_whitelisted_process和is_whitelisted_file函数中，如果在打开文件后发生错误，函数会直接返回，可能会导致文件描述符泄漏。应确保在所有可能的代码路径上都正确关闭了文件描述符。
gcc -I/usr/include/glib-2.0 -I/usr/lib/x86_64-linux-gnu/glib-2.0/include/ -shared -fPIC -o libintercept.so intercept.c -ldl -lglib-2.0

#define _GNU_SOURCE
#include <dlfcn.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <limits.h>

#include <glib.h>  // 需要安装glib库

// 定义原始的open函数
static int (*original_open)(const char*, int, ...);

// 进程名和白名单的全局变量
static char process_name[256] = {0};
static GHashTable *process_whitelist = NULL;
static GHashTable *file_whitelist = NULL;

// 根据进程ID获取进程名
char *get_process_name(pid_t pid) {
    if (process_name[0] == '\0') {
        char path[256];
        snprintf(path, sizeof(path), "/proc/%d/cmdline", pid);
        FILE *file = fopen(path, "r");
        if (file == NULL) {
            return NULL;
        }
        if (fgets(process_name, sizeof(process_name), file) == NULL) {
            fclose(file);
            return NULL;
        }
        fclose(file);
    }

      // 将程序名称转换为绝对路径
    char *absolute_path = realpath(process_name, NULL);
    if (absolute_path != NULL) {
        strncpy(process_name, absolute_path, sizeof(process_name));
        free(absolute_path);
        // printf("绝对路径不为空");
//      printf("进程绝对路径为 %s",process_name);
    }

    else{

        printf("进程名 %s 绝对路径为空\n",process_name);
    }
    return process_name;
}

// 从文件中加载白名单到哈希表
void load_whitelist(const char *filename, GHashTable **whitelist) {
    FILE *file = fopen(filename, "r");
    if (file == NULL) {
        return;
    }
    char line[256];
    while (fgets(line, sizeof(line), file)) {
        line[strcspn(line, "\n")] = '\0';  // 去掉换行符
        g_hash_table_insert(*whitelist, g_strdup(line), NULL);
    }
    fclose(file);
}

// 检查进程是否在白名单中
int is_whitelisted_process() {
    if (process_whitelist == NULL) {
        process_whitelist = g_hash_table_new(g_str_hash, g_str_equal);
        load_whitelist("/home/xxx/Test/WHITELIST/process_whitelist", &process_whitelist);
    }
    return g_hash_table_contains(process_whitelist, get_process_name(getpid()));
}

// 检查文件是否在白名单中
int is_whitelisted_file(const char *filename) {
    if (file_whitelist == NULL) {
        file_whitelist = g_hash_table_new(g_str_hash, g_str_equal);
        load_whitelist("/home/xxx/Test/WHITELIST/file_whitelist", &file_whitelist);
    }
    return g_hash_table_contains(file_whitelist, filename);
}

// 我们的新open函数
int open(const char *pathname, int flags, ...) {
    // 获取原始的open函数
    original_open = dlsym(RTLD_NEXT, "open");

    char real_path[PATH_MAX];
    realpath(pathname, real_path); // 将打开的文件路径转换为绝对路径

    // 检查进程是否在白名单中
    if (is_whitelisted_process()) {
        // 白名单进程可以访问所有文件

             printf("白名单进程访问%s 访问文件%s\n",get_process_name(getpid()),real_path);
        return original_open(real_path, flags);

    }

    // 检查文件是否在白名单中
    if (!is_whitelisted_file(real_path)) {
        // 非白名单进程可以访问非白名单文件

             printf("非白名单进程访问%s 访问 非白名单文件%s\n",get_process_name(getpid()),real_path);
        return original_open(real_path, flags);
    }

             printf("非白名单进程访问%s 访问 白名单文件%s\n",get_process_name(getpid()),real_path);
    // 非白名单进程不能访问白名单文件
    fprintf(stderr, "拒绝访问: %s\n", real_path);
    return -1;
}

这个代码使用了glib库的哈希表实现。在程序启动时，它会将白名单文件读入内存中的哈希表。然后，检查一个文件或进程是否在白名单中只需要在哈希表中查找，这将大大提高效率。此外，它还缓存了进程名，避免了重复计算。请注意，这个代码需要安装glib库才能编译和运行。

代码演示

白名单进程

能访问所有文件

在这里插入图片描述
在这里插入图片描述

非白名单进程

只能访问非白名单文件

在这里插入图片描述
在这里插入图片描述

增加一个日志记录

#define _GNU_SOURCE
#include <dlfcn.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <limits.h>
#include <time.h>

#include <glib.h>  // 需要安装glib库

// 定义原始的open函数
static int (*original_open)(const char*, int, ...);

// 进程名和白名单的全局变量
static char process_name[256] = {0};
static GHashTable *process_whitelist = NULL;
static GHashTable *file_whitelist = NULL;

// 日志文件名
static const char *log_filename = "/home/xxx/Test/LOG";

// 根据进程ID获取进程名
char *get_process_name(pid_t pid) {
    if (process_name[0] == '\0') {
        char path[256];
        snprintf(path, sizeof(path), "/proc/%d/cmdline", pid);
        FILE *file = fopen(path, "r");
        if (file == NULL) {
            return NULL;
        }
        if (fgets(process_name, sizeof(process_name), file) == NULL) {
            fclose(file);
            return NULL;
        }
        fclose(file);
    }


     // 将程序名称转换为绝对路径
    char *absolute_path = realpath(process_name, NULL);
    if (absolute_path != NULL) {
        strncpy(process_name, absolute_path, sizeof(process_name));
        free(absolute_path);
        // printf("绝对路径不为空");
//      printf("进程绝对路径为 %s",process_name);
    }

    else{

        printf("进程名 %s 绝对路径为空\n",process_name);
    }



    return process_name;
}

// 从文件中加载白名单到哈希表
void load_whitelist(const char *filename, GHashTable **whitelist) {
    FILE *file = fopen(filename, "r");
    if (file == NULL) {
        return;
    }
    char line[256];
    while (fgets(line, sizeof(line), file)) {
        line[strcspn(line, "\n")] = '\0';  // 去掉换行符
        g_hash_table_insert(*whitelist, g_strdup(line), NULL);
    }
    fclose(file);
}

// 检查进程是否在白名单中
int is_whitelisted_process() {
    if (process_whitelist == NULL) {
        process_whitelist = g_hash_table_new(g_str_hash, g_str_equal);
        load_whitelist("/home/xxx/Test/WHITELIST/process_whitelist", &process_whitelist);
    }
    return g_hash_table_contains(process_whitelist, get_process_name(getpid()));
}

// 检查文件是否在白名单中
int is_whitelisted_file(const char *filename) {
    if (file_whitelist == NULL) {
        file_whitelist = g_hash_table_new(g_str_hash, g_str_equal);
        load_whitelist("/home/xxx/Test/WHITELIST/file_whitelist", &file_whitelist);
    }
    return g_hash_table_contains(file_whitelist, filename);
}

// 记录日志
void log_access(const char *process, const char *file, int success) {
    FILE *log_file = fopen(log_filename, "a");
    if (log_file == NULL) {
        return;
    }

    time_t now = time(NULL);
    char *time_str = ctime(&now);
    time_str[strlen(time_str) - 1] = '\0';  // 去掉换行符

    fprintf(log_file, "[%s] Process: %s, File: %s, Access: %s\n",
            time_str, process, file, success ? "SUCCESS" : "FAILURE");

    fclose(log_file);
}

// 我们的新open函数
int open(const char *pathname, int flags, ...) {
    // 获取原始的open函数
    original_open = dlsym(RTLD_NEXT, "open");

    char real_path[PATH_MAX];
    realpath(pathname, real_path); // 将打开的文件路径转换为绝对路径

    // 检查进程是否在白名单中
    if (is_whitelisted_process()) {
        // 白名单进程可以访问所有文件
        if (is_whitelisted_file(real_path)) {
            // 记录白名单进程访问白名单文件的日志
            log_access(get_process_name(getpid()), real_path, 1);
        }
        return original_open(real_path, flags);
    }

    // 检查文件是否在白名单中
    if (is_whitelisted_file(real_path)) {
        // 记录非白名单进程访问白名单文件的日志
        log_access(get_process_name(getpid()), real_path, 0);
        fprintf(stderr, "拒绝访问: %s\n", real_path);
        return -1;
    }

    // 非白名单进程可以访问非白名单文件
    return original_open(real_path, flags);
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

代码解释

这段代码主要包含以下几个函数：

  1. get_process_name(pid_t pid)：此函数根据进程ID获取进程名。它首先检查全局变量process_name是否已经被设置。如果没有，它会打开/proc/<pid>/cmdline文件并读取第一行，这就是进程名。然后，它会将进程名转换为绝对路径。
  2. load_whitelist(const char *filename, GHashTable **whitelist)：此函数从指定的文件中加载白名单，并将其存储在一个哈希表中。每一行都被视为一个独立的条目。
  3. is_whitelisted_process()和is_whitelisted_file(const char *filename)：这两个函数检查给定的进程或文件是否在相应的白名单中。如果白名单哈希表尚未创建，它们会首先调用load_whitelist函数来加载白名单。
  4. log_access(const char *process, const char *file, int success)：此函数将访问记录写入日志文件。每条记录包含时间戳、进程名、文件名和访问结果（成功或失败）。
  5. open(const char *pathname, int flags, ...)：这是一个拦截open系统调用的函数。它首先检查调用进程是否在进程白名单中。如果在，那么它可以打开任何文件。否则，它只能打开文件白名单中的文件。如果一个非白名单进程试图打开一个白名单文件，访问将被拒绝，并记录一条失败的访问记录。

这个拦截器可以用来限制某些进程访问敏感文件，或者跟踪某些进程的文件访问行为。但是，它也可能被用于恶意目的，比如阻止某些进程正常工作。因此，使用这种拦截器需要谨慎。

这段代码是一个Linux系统调用拦截器，它拦截了open系统调用。这个拦截器的目的是限制某些进程访问特定的文件。它的工作原理如下：

  1. 获取进程名：get_process_name函数通过读取/proc/<pid>/cmdline文件来获取进程名。这个文件包含了启动该进程的命令行参数。
  2. 加载白名单：load_whitelist函数从指定的文件中读取白名单，并将其存储在一个哈希表中。白名单中的每一行都被视为一个独立的条目。
  3. 检查白名单：is_whitelisted_process和is_whitelisted_file函数检查给定的进程或文件是否在相应的白名单中。
  4. 记录日志：log_access函数将访问记录写入日志文件。每条记录包含时间戳、进程名、文件名和访问结果（成功或失败）。
  5. 拦截open系统调用：新的open函数首先检查调用进程是否在进程白名单中。如果在，那么它可以打开任何文件。否则，它只能打开文件白名单中的文件。如果一个非白名单进程试图打开一个白名单文件，访问将被拒绝，并记录一条失败的访问记录。

这个拦截器可以用来限制某些进程访问敏感文件，或者跟踪某些进程的文件访问行为。但是，它也可能被用于恶意目的，比如阻止某些进程正常工作。因此，使用这种拦截器需要谨慎。

记录。

这个拦截器可以用来限制某些进程访问敏感文件，或者跟踪某些进程的文件访问行为。但是，它也可能被用于恶意目的，比如阻止某些进程正常工作。因此，使用这种拦截器需要谨慎。

这段代码是一个Linux系统调用拦截器，它拦截了open系统调用。这个拦截器的目的是限制某些进程访问特定的文件。它的工作原理如下：

  1. 获取进程名：get_process_name函数通过读取/proc/<pid>/cmdline文件来获取进程名。这个文件包含了启动该进程的命令行参数。
  2. 加载白名单：load_whitelist函数从指定的文件中读取白名单，并将其存储在一个哈希表中。白名单中的每一行都被视为一个独立的条目。
  3. 检查白名单：is_whitelisted_process和is_whitelisted_file函数检查给定的进程或文件是否在相应的白名单中。
  4. 记录日志：log_access函数将访问记录写入日志文件。每条记录包含时间戳、进程名、文件名和访问结果（成功或失败）。
  5. 拦截open系统调用：新的open函数首先检查调用进程是否在进程白名单中。如果在，那么它可以打开任何文件。否则，它只能打开文件白名单中的文件。如果一个非白名单进程试图打开一个白名单文件，访问将被拒绝，并记录一条失败的访问记录。

这个拦截器可以用来限制某些进程访问敏感文件，或者跟踪某些进程的文件访问行为。但是，它也可能被用于恶意目的，比如阻止某些进程正常工作。因此，使用这种拦截器需要谨慎。

待改进之处
程序一开始就应该加载白名单文件，而不是在open函数调用一次就加载一次。但是如果一开始就加载文件白名单，之后如果对白名单文件进行修改，就要将 该so 库文件重新编译一次。 如果能监控白名单文件是否修改，如果修改了就再加载白名单文件 就好了

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1296300.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Navicat 技术指引 | 适用于 GaussDB 分布式的用户/权限功能

Navicat 技术指引 | 适用于 GaussDB 分布式的用户/权限功能

Navicat Premium&#xff08;16.3.3 Windows 版或以上&#xff09;正式支持 GaussDB 分布式数据库。GaussDB 分布式模式更适合对系统可用性和数据处理能力要求较高的场景。Navicat 工具不仅提供可视化数据查看和编辑功能&#xff0c;还提供强大的高阶功能&#xff08;如模型、结…
阅读更多...
如何提高大模型在超长上下文的表现？Claude实验表明加一句prompt立即提升效果~

如何提高大模型在超长上下文的表现？Claude实验表明加一句prompt立即提升效果~

本文来自DataLearnerAI官方网站&#xff1a;如何提高大模型在超长上下文的表现&#xff1f;Claude实验表明加一句prompt立即提升效果~ | 数据学习者官方网站(Datalearner)https://www.datalearner.com/blog/1051701947131881 Claude 2.1版本的模型上下文长度最高拓展到200K&am…
阅读更多...
UG NX二次开发(C#)-求曲线在某一点处的法矢和切矢

UG NX二次开发(C#)-求曲线在某一点处的法矢和切矢

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 1、前言2、在UG NX中创建一个曲线3、直接放代码4、测试案例1、前言 最近确实有点忙了，好久没更新博客了。今天恰好有时间，就更新下，还请家人们见谅。 今天我们讲一下如何获取一条曲线上某一条曲…
阅读更多...
自然语言处理22-基于本地知识库的快速问答系统，利用大模型的中文训练集为知识库

自然语言处理22-基于本地知识库的快速问答系统，利用大模型的中文训练集为知识库

大家好，我是微学AI，今天给大家介绍一下自然语言处理22-基于本地知识库的快速问答系统，利用大模型的中文训练集为知识库。我们的快速问答系统是基于本地知识库和大模型的最新技术，它利用了经过训练的中文大模型，该模型使用了包括alpaca_gpt4_data的开源数据集。 一、本地…
阅读更多...
分布式数据库 GaiaDB-X 金融应用实践

分布式数据库 GaiaDB-X 金融应用实践

1 银行新一代核心系统建设背景及架构 在银行的 IT 建设历程中&#xff0c;尤其是中大行&#xff0c;大多都基于大型机和小型机来构建核心系统。随着银行业务的快速发展&#xff0c;这样的系统对业务的支持越来越举步维艰&#xff0c;主要体现在以下四个方面&#xff1a; 首先…
阅读更多...
RHEL8_Linux计划任务

RHEL8_Linux计划任务

本章主要介绍如何创建计划任务 使用 at 创建计划任务使用 crontab 创建计划任务 有时需要在某个指定的时间执行一个操作&#xff0c;此时就要使用计划任务了。计划任务有两种&#xff1a;一个是at计划任务&#xff0c;另一个是 crontab计划任务。 下面我们分别来看这两种计划任…
阅读更多...
AI聊天专题报告：ChatGPT全景图聊聊技术产品和未来

AI聊天专题报告：ChatGPT全景图聊聊技术产品和未来

今天分享的AI系列深度研究报告&#xff1a;《AI聊天专题报告&#xff1a;ChatGPT全景图聊聊技术产品和未来》。 &#xff08;报告出品方&#xff1a;LanguageX&#xff09; 报告共计&#xff1a;22页 争论&#xff1a;ChatGPT算不算技术革命 回应吴军老师“ChatGPT不算新技术…
阅读更多...
基于jsonrpc4j实现JSON-RPC over HTTP(服务端集成Spring Boot)

基于jsonrpc4j实现JSON-RPC over HTTP(服务端集成Spring Boot)

1.JSON-RPC说明 JSON-RPC是一个无状态且轻量级的远程过程调用(RPC)协议。 它主要定义了一些数据结构及其相关的处理规则。 它运行时可以基于tcp(socket),http等不同的消息传输方式&#xff0c; 即它不关心底层传输方式的细节。 它使用JSON&#xff08;RFC 4627&#xff09;作为…
阅读更多...
空间运算设备-Apple Vision Pro

空间运算设备-Apple Vision Pro

苹果以其在科技领域的创新而闻名&#xff0c;他们致力于推动技术的边界&#xff0c;这在他们的产品中表现得非常明显。他们尝试开发一项的新型突破性显示技术。在 2023 年 6 月 5 日官网宣布将发布 Apple Vision Pro 头戴空间设备&#xff0c;我们一起来了解一下 Apple Vision …
阅读更多...
《每天一个Linux命令》 -- (5)通过sshkey密钥登录服务器

《每天一个Linux命令》 -- (5)通过sshkey密钥登录服务器

欢迎阅读《每天一个Linux命令》系列&#xff01;在本篇文章中&#xff0c;将介绍通过密钥生成&#xff0c;使用公钥连接管理服务器。 概念 SSH 密钥是用于安全地访问远程服务器的一种方法。SSH 密钥由一对密钥组成&#xff1a;公钥和私钥。公钥存储在远程服务器上&#xff0c;…
阅读更多...
PandoraFMS 监控软件 SQL注入漏洞复现

PandoraFMS 监控软件 SQL注入漏洞复现

0x01 产品简介 Pandora FMS是西班牙Artica公司的一套监控系统。该系统通过可视化的方式监控网络、服务器、虚拟基础架构和应用程序等。 0x02 漏洞概述 Pandora FMS监控软件存在SQL注入漏洞，攻击者通过chart_generator.php 来执行恶意语句，获取数据库敏感信息。 0x03 复现…
阅读更多...
湖南电网启用输电线路无人机巡视，提升电力运维水平

湖南电网启用输电线路无人机巡视，提升电力运维水平

国网湖南电网近期成功引入输电线路无人机巡视技术&#xff0c;实现了电力运维的全新突破。此创新模式通过全自主飞行、自主巡检&#xff0c;极大提高了电力线路运维效率&#xff0c;确保了电网的安全稳定。 一、全自动巡检&#xff0c;无人值守 在输电线路无人机巡视作业现场&…
阅读更多...
【Cisco Packet Tracer】路由器实验 静态路由/RIP/OSPF/BGP

【Cisco Packet Tracer】路由器实验 静态路由/RIP/OSPF/BGP

本教程讲解路由器的静态IP配置、RIP、OSPF、BGP等实验内容。 一、基本设置 绘制以下拓扑结构&#xff1a; PC0设置&#xff1a; PC1设置&#xff1a; Router0端口0设置&#xff1a; Router0端口1设置&#xff1a; Router1端口0设置&#xff1a; Router1端口1设置&#xff1a…
阅读更多...
【Vue3从入门到项目实现】RuoYi-Vue3若依框架前端学习——动态路由与菜单栏

【Vue3从入门到项目实现】RuoYi-Vue3若依框架前端学习——动态路由与菜单栏

菜单栏 若依框架的侧边栏组件通常由菜单项和子菜单组成。 登录后&#xff0c;会获取用户拥有的路由菜单 {"msg": "操作成功","code": 200,"data": [{"name": "System","path": "/system",…
阅读更多...
unity 2d 入门 飞翔小鸟 场景延续（八)

unity 2d 入门 飞翔小鸟 场景延续（八)

1、新建c#脚本如下 代码&#xff0c;在前方生成生成自身图片并3s后销毁自身&#xff0c;在碰撞物体后小鸟死亡后不删除自身 using System.Collections; using System.Collections.Generic; using UnityEngine;public class CopyScene : MonoBehaviour { //要复制的对象public…
阅读更多...
硕士毕业论文格式修改要点_word

硕士毕业论文格式修改要点_word

目录 0、最开始要做的事情1、更改样式&#xff08;先善器&#xff09;2、多级标题&#xff08;解决自动更新问题必要的基础设置&#xff09;2、插入图片&#xff08;1&#xff09;设置一个图片样式——“无间隔”&#xff08;2&#xff09;插入题注&#xff08;3&#xff09;修…
阅读更多...
【K8S】微服务不香了？单体化改造悄然兴起！！

【K8S】微服务不香了？单体化改造悄然兴起！！

微服务一直以来是服务治理的基本盘之一，落地到云原生上，往往是每个 K8s pods 部署一个服务，独立迭代、独立运维。 但是在快速部署的时候，有时候，我们可能需要一些宏服务的优势。有没有一种方法，能够 “既要又要” 呢？本文基于 tRPC-Go 服务，提出并最终实践了一种经验证…
阅读更多...
AI 训练框架：Pytorch TensorFLow MXNet Caffe ONNX PaddlePaddle

AI 训练框架：Pytorch TensorFLow MXNet Caffe ONNX PaddlePaddle

https://medium.com/jit-team/bridge-tools-for-machine-learning-frameworks-3eb68d6c6558
阅读更多...
12.Mysql 多表数据横向合并和纵向合并

12.Mysql 多表数据横向合并和纵向合并

Mysql 函数参考和扩展&#xff1a;Mysql 常用函数和基础查询、 Mysql 官网 Mysql 语法执行顺序如下&#xff0c;一定要清楚&#xff01;&#xff01;&#xff01;运算符相关&#xff0c;可前往 Mysql 基础语法和执行顺序扩展。 (8) select (9) distinct (11)<columns_name…
阅读更多...
oracle 下载java之前版本

oracle 下载java之前版本

登录oracle官网&#xff1a;Oracle | Cloud Applications and Cloud Platform 点击resource 进入该页面 点击这个 出现之前版本
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023