ARM64汇编0C - inlinehook

本文是ARM64汇编系列的完结篇，主要利用前面学过的知识做一个小实验

完整系列博客地址：https://www.lyldalek.top/article/arm

这里只讨论 ARM64 下的 inlinehook，做一个简单的demo，只是抛砖引玉，有兴趣了解更多细节的可以去查找资料，看开源项目。

ARM64 相比 ARM 的 inlinehook 要麻烦不少，因为有很多指令都没了，且无法直接访问 PC 寄存器。

ARM64处理器下是兼容ARM32指令集的，因此，ARM64处理器上可以运行ARM64，ARM32,Thumb-2(Thumb16+Thumb32)三套指令，但是这里我们只讨论 ARM64 模式。

流程图

inlinehook是实现对一个指定函数的hook，其大致流程如下图：

首先，需要替换目标函数的头部的指令，将pc的值修改为hook函数的地址，跳转过去执行。

对于被覆盖的指令，我们将其放入hook函数中执行，对应图中的红色部分，这里会遇到非常多的问题，有兴趣的自行查找资料。

hook函数执行完之后，需要将 pc 的值修改为覆盖指令的下一条指令地址，然后跳转过去执行。

在这些过程中，我们需要保证寄存器在执行hook函数前后的值是一样的，执行的覆盖指令也不能修改寄存器，除非先将寄存器的值储存起来。

方案设计

第一步——原程序插桩

设计思路是：首先插桩代码最基本的是要一个跳转功能。ARM64中PC不让直接读写，那我们怎么改变PC呢？通常程序跳转都有两类方法：相对寻址和直接寻址。

相对寻址是有距离限制的，由于我们的hook程序也是一个so，它的位置是不固定的，且目标so的位置也是不固定的，所以这两个so的距离也是不固定的，使用相对寻址很不明智。

直接寻址，ARM64中有BR X??可以直接把程序跳转到X??寄存器中存储的64位地址上。那么，这时候的方案就应该是：

LDR X0, [TARGET_ADDRESS] 
BR X0

但是，这样会破坏X0中原本的值，所以，我们需要储存一些 X0 的值：

STP X1, X0, [SP, #-0x10]
LDR X0, [TARGET_ADDRESS]
BR X0

上面的第一个指令就是把X1，X0保存到栈上，这里的X1当然是多余的，纯属是为了满足ARM64上栈要16字节对齐且没有PUSH指令可用的约束。

既然，我们改了栈，那么就需要平衡栈，所以，那最后跳转回原程序时，我们需要将栈的值修改回来：

STP X1, X0, [SP, #-0x10]
LDR X0, [TARGET_ADDRESS]     ; TARGET_ADDRESS 是一个动态值，编译后会需要更多的指令来实现
BR X0
LDR X0, [SP, -0x8]

这里，就与我们设想的流程稍微有点区别，我们需要等hook函数执行完之后，跳转到上面的最后一行指令执行，恢复 X0 寄存器的值。

这里有个需要注意的地方，就是我们的插桩指令至少有4条，占据了16字节，如果函数体很小的话，那么hook就会导致错误。所以这里是一个优化点。

第二步——hook程序

我们在这里需要先保存所有寄存器的值，保存了寄存器的值之后，就可以使用这些寄存器了，保存结构如下：

对应的指令如下：

sub     sp, sp, #0x20          ;sp = sp - 0x20，也就是指针向上移动2格

mrs     x0, NZCV               ;将状态寄存器的值储存到 x0
str     x0, [sp, #0x10]        ;将x0（状态寄存器）的值储存到 sp + 0x10 处，也就是图中的 PSR
str     x30, [sp]              ;将x30的值储存到 sp 处，图中的X30 LR
add     x30, sp, #0x20         ;X30 = sp + 0x20
str     x30, [sp, #0x8]        ;将 sp + 0x20 的值储存到 sp + 0x8处，就是储存原来的 sp值，图中的origin_sp
ldr     x0, [sp, #0x18]        ;将 sp + 0x18 的值给 X0，让 X0 指向栈顶

sub     sp, sp, #0xf0          ;分配空间储存 X0 - X29 寄存器
stp     X0, X1, [SP]
stp     X2, X3, [SP,#0x10]
stp     X4, X5, [SP,#0x20]
stp     X6, X7, [SP,#0x30]
stp     X8, X9, [SP,#0x40]
stp     X10, X11, [SP,#0x50]
stp     X12, X13, [SP,#0x60]
stp     X14, X15, [SP,#0x70]
stp     X16, X17, [SP,#0x80]
stp     X18, X19, [SP,#0x90]
stp     X20, X21, [SP,#0xa0]
stp     X22, X23, [SP,#0xb0]
stp     X24, X25, [SP,#0xc0]
stp     X26, X27, [SP,#0xd0]
stp     X28, X29, [SP,#0xe0]

由于没有了LDM/STM指令，我们向栈上存大量寄存器只能一对一对的来。

接下来，我们可以执行之前被覆盖的代码了，这里不演示，后面写一个demo具体来看。

然后就是恢复寄存器：

ldr     x0, [sp, #0x100]     ;将储存PSR的地址赋值给 X0
msr     NZCV, x0             ;恢复状态寄存器的值

ldp     X0, X1, [SP]         ;恢复X0，X1 的值
ldp     X2, X3, [SP,#0x10]
ldp     X4, X5, [SP,#0x20]
ldp     X6, X7, [SP,#0x30]
ldp     X8, X9, [SP,#0x40]
ldp     X10, X11, [SP,#0x50]
ldp     X12, X13, [SP,#0x60]
ldp     X14, X15, [SP,#0x70]
ldp     X16, X17, [SP,#0x80]
ldp     X18, X19, [SP,#0x90]
ldp     X20, X21, [SP,#0xa0]
ldp     X22, X23, [SP,#0xb0]
ldp     X24, X25, [SP,#0xc0]
ldp     X26, X27, [SP,#0xd0]
ldp     X28, X29, [SP,#0xe0]
add     sp, sp, #0xf0         ;将 sp 的值指向X30 LR位置
 
ldr     x30, [sp]             ;恢复 X30 寄存器
add     sp, sp, #0x20         ;将 sp 的值还原，origin_sp没用到

恢复寄存后，我们还需要再跳转到原函数继续执行，执行覆盖指令的最后一行：

ldr   x0, ret_addr
br    x0

这样，一个hook方案的框架就设计好了。

例子

我们尝试对libc.so 中的 fopen 函数进行 inlinehook。

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <sys/mman.h>
#include <dlfcn.h>

int main()
{
    void *handle = dlopen("libc.so", RTLD_NOW);
    void *hook_addr = dlsym(handle, "fopen");

    printf("hook_addr = %p\n", hook_addr);

    return 0;
}

使用，dlopen 与 dlsym 找到 fopen 函数的地址：

sailfish:/data/local/tmp # ./inlinehook                                      
hook_addr = 0x724f5433d4

运行编译后的程序，确认可以正确的获取到地址。如果是32位的so，这个地址可能是一个奇数，说明它是thumb模式。

接下来，我们编写hook函数，需要注意的是编译器对于一般的函数都会生成 prolog 和 epilog 代码，由于我们需要完全控制 hook 函数生成的汇编指令，所以需要使用裸函数，或者直接写汇编。

void __attribute__((naked)) hook_func()
{
    
}

我们需要覆盖 fopen 函数的头部指令，需要就需要对 .text 段修改，由于 .text 是没有写权限的，所以需要使用 mprotect 函数来获取写权限。

mprotect((void *)((uint64_t)hook_addr & 0xfffffffffffff000), 0x1000, PROT_WRITE | PROT_EXEC | PROT_READ);

可以查看 /proc/pid/maps 文件，看看是否生效：

7454e64000-7454edc000 r-xp 00000000 103:12 946                           /system/lib64/libc.so
7454edc000-7454edd000 rwxp 00078000 103:12 946                           /system/lib64/libc.so
7454edd000-7454f2c000 r-xp 00079000 103:12 946                           /system/lib64/libc.so

可以看到，确实有一个段的权限变成了 rwx。

现在，可以开始覆盖指令了，但是蛋疼的地方出现了，在 ARM32 中，就非常的简单，只需要使用 LDR 就行：

LDR pc, [pc-4]
hook_func_addr

上面的这两条指令，第一条是将下一条指令内容赋值给PC，所以，第二条指令其实不是一个真实的指令，而是hook函数的地址，这样非常简单的实现了hook函数的跳转。

在ARM64中，我们无法操作pc寄存器，只能使用 B 指令来进行跳转：

LDR X0, [TARGET_ADDRESS]
BR X0
LDR X0, [SP, -0x8]

这里出现一个问题，TARGET_ADDRESS 是一个动态值，我们没办法在编译的时候确定。那该怎么办呢？需要采用一种特殊的写法：

STP X1, X0, [SP, #-0x10]   ;储存 x0，x1
LDR X0, 8                  ;将pc+8的地址处内容给x0
BR X0                      ;跳转到x0对应的地址
ADDR(64)                   ;目标地址
LDR X0, [SP, -0x8]         ;让x0指向栈顶

ADDR 是hook函数地址，将这个地址给X0，然后使用 BR X0 进行跳转。注意这个地址占据了8个字节，所以实际上相当于6条指令。

LDR X0, 8 这个需要特别解释一下，这个 ida 的 patch program 生成的偏移是相对于 so 的基址的，不是相对于 pc，想要生成相对于 pc 的指令，需要按下面的写法：

LDR X0, .+8

我看了一个开源项目，它是直接使用的 LDR X0, 8，不知道是不是汇编语言写法处理方式不一样。

在IDA中，生成这些指令的汇编代码，然后覆盖掉 fopen 的函数起始地址的6条指令：

// 指令是4字节的，使用 uint32，地址使用 unit64

// STP X8, X0, [SP, #-0x60]  -> E8 03 3A A9
(*(uint32_t *)(hook_addr + 0)) = 0xA93A03E8;

// LDR X0, 8 -> 40 00 00 58
(*(uint32_t *)(hook_addr + 4)) = 0x58000040;

// BR X0  -> 00 00 1f d6
(*(uint32_t *)(hook_addr + 8)) = 0xd61f0000;

// ADDR  -> 00 00 1f d6，这里要用64位
(*(uint64_t *)(hook_addr + 12)) = hook_func;

// 被覆盖的指令操作了sp，所以需要合并计算sp的值（-0x60+0x50）
// LDR X0, [SP, #-0x10]  -> E0 03 5F F8
(*(uint32_t *)(hook_addr + 20)) = 0xF85F03E0;

这里有一些细节需要注意：

  1. 我们在 sp - 0x60 的位置写入了 X8 与 X0，这是因为我们覆盖的 fopen 指令它会操作sp，它的函数栈大小是 0x50，所以我就将X8 与 X0 放到了 fopen 操作不到的位置，避免覆盖的指令修改栈中的数据导致我们的储存的数据丢失。

  2. 存放 X8 是因为后面，我们生成跳转回来的指令时，gcc 使用到了 X8。

  3. 存放 X0 是因为我们跳转使用的是 X0 寄存器，所以需要储存，后面也要还原。

覆盖指令写好之后，我们就可以写 hook 函数了：

void __attribute__((naked)) hook_func()
{

    // 获取参数
    asm("ldr x0, [sp, #-0x58]");
    asm("str x0,%0":"=m"(x0));

    // 执行被覆盖的指令
    // .text:00000000000783D4 FF 43 01 D1                   SUB             SP, SP, #0x50           ; Alternative name is 'fopen'
    // .text:00000000000783D8 F7 0B 00 F9                   STR             X23, [SP,#0x10]
    // .text:00000000000783DC F6 57 02 A9                   STP             X22, X21, [SP,#0x20]
    // .text:00000000000783E0 F4 4F 03 A9                   STP             X20, X19, [SP,#0x30]
    // .text:00000000000783E4 FD 7B 04 A9                   STP             X29, X30, [SP,#0x40]
    // .text:00000000000783E8 FD 03 01 91                   ADD             X29, SP, #0x40
    asm("SUB             SP, SP, #0x50");
    asm("STR             X23, [SP,#0x10]");
    asm("STP             X22, X21, [SP,#0x20]");
    asm("STP             X20, X19, [SP,#0x30]");
    asm("STP             X29, X30, [SP,#0x40]");
    asm("ADD             X29, SP, #0x40");

    // 跳转到返回地址，这个语句生成的汇编，用到了 x8 寄存器
    asm("ldr x0, %0" ::"m"(hook_return_addr));
    // 还原 x8 寄存器的值
    asm("ldr x8, [sp, #-0x8]");
    asm("br x0");
}

hook 函数我写的比较简单，主要做了3件事：

  • 获取 X0 的值，因为X0是第一个参数，我们可以将 X0 赋值给一个全局变量，然后打印出来看是否hook成功

  • 执行被覆盖的指令，这个很简单，将 fopen 的前6条指令 copy 过来就行了

  • 执行完之后，要跳转回 fopen 继续执行，我们是先计算出了指令的地址，然后使用行内汇编来生成对应的指令

除了使用行内汇编，还可以直接使用汇编来实现，这个我也不太熟，简单介绍一下。

首先在汇编文件里面定义一个变量：

.global _shellcode_start_s

然后，将这个变量当成标号使用：

_shellcode_start_s:

    sub     sp, sp, #0x20

在别的C文件里面，使用 extern 就可以直接引用这变量了：

extern unsigned long _shellcode_start_s;

oid *p_shellcode_start_s = &_shellcode_start_s;

这样，我们就拿到了hook函数的起始地址。有兴趣的可以看下 GitHub 的相关开源项目。

源码

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <sys/mman.h>
#include <dlfcn.h>

static uint64_t hook_return_addr;
static uint64_t x0, x1;

void __attribute__((naked)) hook_func()
{

    // 获取参数
    asm("ldr x0, [sp, #-0x58]");
    asm("str x0,%0" : "=m"(x0));
    asm("str x1,%0" : "=m"(x1));

    // 执行被覆盖的指令
    // .text:00000000000783D4 FF 43 01 D1                   SUB             SP, SP, #0x50           ; Alternative name is 'fopen'
    // .text:00000000000783D8 F7 0B 00 F9                   STR             X23, [SP,#0x10]
    // .text:00000000000783DC F6 57 02 A9                   STP             X22, X21, [SP,#0x20]
    // .text:00000000000783E0 F4 4F 03 A9                   STP             X20, X19, [SP,#0x30]
    // .text:00000000000783E4 FD 7B 04 A9                   STP             X29, X30, [SP,#0x40]
    // .text:00000000000783E8 FD 03 01 91                   ADD             X29, SP, #0x40
    // .text:00000000000783EC 56 D0 3B D5                   MRS             X22, #3, c13, c0, #2
    // .text:00000000000783F0 C9 16 40 F9                   LDR             X9, [X22,#0x28]
    asm("SUB             SP, SP, #0x50");
    asm("STR             X23, [SP,#0x10]");
    asm("STP             X22, X21, [SP,#0x20]");
    asm("STP             X20, X19, [SP,#0x30]");
    asm("STP             X29, X30, [SP,#0x40]");
    asm("ADD             X29, SP, #0x40");

    // 跳转到返回地址，这个语句生成的汇编，用到了 x8 寄存器
    asm("ldr x0, %0" ::"m"(hook_return_addr));
    // 还原 x8 寄存器的值
    asm("ldr x8, [sp, #-0x8]");
    asm("br x0");
}

int main()
{
    void *handle = dlopen("libc.so", RTLD_NOW);
    void *hook_addr = dlsym(handle, "fopen");
    if (hook_addr != NULL)
    {
        hook_return_addr = hook_addr + 20;
    }
    else
    {
        return -1;
    }

    printf("hook_addr = %p\n", hook_addr);

    // 这里改变了 0x1000 这个范围的数据的属性
    mprotect((void *)((uint64_t)hook_addr & 0xfffffffffffff000), 0x1000, PROT_WRITE | PROT_EXEC | PROT_READ);

    // getchar();

    // 指令是4字节的，使用 uint32，地址使用 unit64

    // STP X8, X0, [SP, #-0x60]  -> E8 03 3A A9
    (*(uint32_t *)(hook_addr + 0)) = 0xA93A03E8;

    // LDR X0, 8 -> 40 00 00 58
    (*(uint32_t *)(hook_addr + 4)) = 0x58000040;

    // BR X0  -> 00 00 1f d6
    (*(uint32_t *)(hook_addr + 8)) = 0xd61f0000;

    // ADDR  -> 00 00 1f d6，这里要用64位
    (*(uint64_t *)(hook_addr + 12)) = hook_func;

    // 被覆盖的指令操作了sp，所以需要还原
    // LDR X0, [SP, #-0x10]  -> E0 03 5F F8
    (*(uint32_t *)(hook_addr + 20)) = 0xF85F03E0;

    printf("hook_func = %p\n", hook_func);

    getchar();

    FILE *fp = fopen("/data/local/tmp/android_server64", "rb");
    uint32_t data;
    fread(&data, 4, 1, fp);
    fclose(fp);
    printf("data = %p\n", data);
    printf("x0 = %s\n", x0);
    printf("x1 = %s\n", x1);

    return 0;
}

运行程序，输出：

sailfish:/data/local/tmp # ./inlinehook                         
hook_addr = 0x7c1015a3d4
hook_func = 0x5d3d3099d4

data = 0x464c457f
x0 = /data/local/tmp/android_server64
x1 = rb

可以看到我们成功的hook了 fopen 函数：

  • data 是 so 文件的前4个字节，就是 .elf

  • x0 与 x1 是参数

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

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

相关文章

Treeselect是介绍及使用（梳理了我使用这个组件遇到的大部分问题）

Treeselect是介绍及使用（梳理了我使用这个组件遇到的大部分问题）

介绍&#xff1a; Treeselect是一款基于Vue.js的树形选择器组件&#xff0c;可以快速地实现树形结构的选择功能。 这里梳理了我使用这个组件遇到的大部分问题 安装依赖&#xff1a; 首先&#xff0c;你需要在你的项目中安装Treeselect的依赖。这通常可以通过npm或yarn等来完…
阅读更多...
多线程（总结黑马程序员）

多线程（总结黑马程序员）

一、什么是线程&#xff1f; 是一个程序内部的一条执行流程 多线程是什么&#xff1f; 多条线程由CPU负责调度执行 多线程的创建方式一&#xff1a;继承Thread类 //1.继承Thread类 public class MyThread extends Thread {//2.必须重写run方法Overridepublic void run() {…
阅读更多...
理解HTTP请求格式

理解HTTP请求格式

HTTP概念 HTTP全称HyperTextTransfer Protocol(超文本传输协议)是一种用于分布式、协作式和超媒体信息系统的应用层协议&#xff1b;HTTP是一个客户端&#xff08;用户&#xff09;和服务端&#xff08;网站&#xff09;之间请求和响应的标准。 HTTP 协议是以 ASCII 码传输&…
阅读更多...
FreeRtos-13资源管理

FreeRtos-13资源管理

一、临界资源是什么 要独占式地访问临界资源，有3种方法： 1.公平竞争：比如使用互斥量，谁先获得互斥量谁就访问临界资源，这部分内容前面讲过。 谁要跟我抢，我就灭掉谁： 2.中断要跟我抢？我屏蔽中断 3.其他任务要跟我抢？我禁止调度器，不运行任务切换 二、暂停调度器…
阅读更多...
【漏洞复现】极限OA video_file.php 任意文件读取漏洞

【漏洞复现】极限OA video_file.php 任意文件读取漏洞

免责声明&#xff1a; 本文内容旨在提供有关特定漏洞或安全漏洞的信息&#xff0c;以帮助用户更好地了解可能存在的风险。公布此类信息的目的在于促进网络安全意识和技术进步&#xff0c;并非出于任何恶意目的。阅读者应该明白&#xff0c;在利用本文提到的漏洞信息或进行相关测…
阅读更多...
线性回归模型介绍

线性回归模型介绍

线性回归模型是一种统计方法，用于分析两个或多个变量之间的关系。它通过拟合一条直线（称为回归线）来描述因变量（或目标变量）和一个或多个自变量（或预测变量）之间的关系。这种模型主要用于预测和解释变量间的线性关系。以下是线性回归模型的简单介绍： 1. 线性回归模型的…
阅读更多...
文本挖掘与可视化：生成个性化词云的Python实践【7个案例】

文本挖掘与可视化：生成个性化词云的Python实践【7个案例】

文本挖掘与可视化&#xff1a;生成个性化词云的Python实践【7个案例】 词云&#xff08;Word Cloud&#xff09;&#xff0c;又称为文字云或标签云&#xff0c;是一种用于文本数据可视化的技术&#xff0c;通过不同大小、颜色和字体展示文本中单词的出现频率或重要性。在词云中…
阅读更多...
技术支持与开发助手：Kompas AI的革新力量

技术支持与开发助手：Kompas AI的革新力量

一、引言 随着技术发展的迅猛进步&#xff0c;技术开发的高效需求日益增加。开发人员面临着更复杂的项目、更紧迫的时间表以及不断提高的质量标准。在这种背景下&#xff0c;能够提供智能支持的工具变得尤为重要。Kompas AI 正是在这种需求下应运而生的。它通过人工智能技术&a…
阅读更多...
Arduino平台软硬件原理及使用——电位器模块的使用

Arduino平台软硬件原理及使用——电位器模块的使用

文章目录 一、电位器工作原理 二、电位器与滑动变阻器的异同 三、电位器模块在Arduino中的使用 一、电位器工作原理 上图为市面上常见的电位器元件实物图&#xff0c;其结构及封装根据不同的应用场景也有着不同&#xff0c;但其原理及本质基本一致。 电位器是具有三个引出端、…
阅读更多...
车牌号识别（低级版）

车牌号识别（低级版）

import cv2 from matplotlib import pyplot as plt import os import numpy as np from paddleocr import PaddleOCR, draw_ocr from PIL import Image, ImageDraw, ImageFont# 利用paddelOCR进行文字扫描&#xff0c;并输出结果 def text_scan(img_path):ocr PaddleOCR(use_a…
阅读更多...
[Mysql] 数据库基本概念

[Mysql] 数据库基本概念

前言---数据库系统发展史 当今主流数据库介绍 一、操作系统 Linux操作系统 &#xff1a;RedHat CentOS Debian Ubuntu OpenSUSE 信创标准 会让系统逐渐国产化 国产系统&#xff1a;华为 欧拉 阿里 龙蜥 腾讯 tencentOS 银河麒麟 中标麒麟…
阅读更多...
Linux远程管理日志

Linux远程管理日志

实验介绍 本实验旨在实现主机将日志远程发送到堡垒机或远程服务器上&#xff0c;实现通过一台机器管理整个网络内的主机的效果。 准备两台虚拟机作为生产主机和管理机&#xff0c;保证网络通畅&#xff0c;展示如下&#xff1a; 关闭firewalld&#xff0c;通过配置rsyslog&a…
阅读更多...
分布式锁实现方案

分布式锁实现方案

分布式锁 1 什么是分布式锁 ​ 就是在分布式环境下&#xff0c;保证某个公共资源只能在同一时间被多进程应用的某个进程的某一个线程访问时使用锁。 2 几个使用场景分析 一段代码同一时间只能被同一个不同进程的一个线程执行 库存超卖 (库存被减到 负数)&#xff0c;上面案…
阅读更多...
【机器学习】【深度学习】MXnet神经网络图像风格迁移学习简介

【机器学习】【深度学习】MXnet神经网络图像风格迁移学习简介

使用部分 一、编程环境 编程环境使用Windows11上的Anaconda环境&#xff0c;Python版本为3.6. 关于Conda环境的建立和管理&#xff0c;可以参考我的博客&#xff1a;【Anaconda】【Windows编程技术】【Python】Anaconda的常用命令及实操 二、项目结构&#xff08;代码非原创…
阅读更多...
CTF-pwn-虚拟化-【d3ctf-2021-d3dev】

CTF-pwn-虚拟化-【d3ctf-2021-d3dev】

文章目录 参考流程附件检查启动信息逆向分析漏洞查看设备配置信息exp 参考 https://x1ng.top/2021/11/26/qemu-pwn/ https://bbs.kanxue.com/thread-275216.htm#msg_header_h1_0 https://xz.aliyun.com/t/6562?time__1311n4%2BxnD0DRDBAi%3DGkDgiDlhjmYh2xuCllx7whD&alic…
阅读更多...
Opencv学习项目2——pytesseract

Opencv学习项目2——pytesseract

上一次我们使用pytesseract.image_to_boxes来检测字符&#xff0c;今天我们使用pytesseract.image_to_data来检测文本并显示 实战教程 和上一次一样&#xff0c;添加opencv-python和pytesseract库 首先我们先来了解一下pytesseract.image_to_data pytesseract.image_to_data(…
阅读更多...
无人值守工厂设备日志采集工具

无人值守工厂设备日志采集工具

免费试用下载: Gitee下载 最新版本 优势: A. 开箱即用. 解压直接运行.不需额外安装. B. 批管理设备. 设备配置均在后台管理. C. 无人值守 客户端自启动,自更新. D. 稳定安全. 架构简单,内存占用小,通过授权访问.
阅读更多...
Exposure X7软件安装包下载 丨不限速下载丨亲测好用

Exposure X7软件安装包下载 丨不限速下载丨亲测好用

根据使用者情况表明Exposure的设计鼓励您进行创造性的工作&#xff0c;使用涂刷和遮罩工具将效果有选择地应用于图片的特定区域&#xff0c;非破坏性图层使您能够混合预设和调整&#xff0c;以获得无尽的外观。我们都知道Exposure是用于创意照片编辑的最佳图片编辑器&#xff0…
阅读更多...
【机器学习】使用Python实现图神经网络（GNN）：图结构数据的分析与应用

【机器学习】使用Python实现图神经网络（GNN）：图结构数据的分析与应用

&#x1f525; 个人主页&#xff1a;空白诗 文章目录 一、引言二、图神经网络的基础知识1. 图的基本概念和术语2. 传统的图分析方法3. 图神经网络的基本原理4. GNN的基本模型 三、主要的图神经网络模型1. 图卷积网络&#xff08;Graph Convolutional Network, GCN&#xff09;2…
阅读更多...
086. 分隔链表

086. 分隔链表

题目链接 一、题目描述 (一) 题目 给你一个链表的头节点 head 和一个特定值 x &#xff0c;请你对链表进行分隔&#xff0c;使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。你应当保留两个分区中每个节点的初始相对位置。 (二) 示例 示例 1&#xff1a; 输入&a…
阅读更多...
最新文章

Copyright @ 2022~2023