3_17_GLib库入门与实践_hook函数

最新推荐文章于 2024-04-22 09:46:04 发布
最新推荐文章于 2024-04-22 09:46:04 发布
阅读量588 收藏
点赞数 1
分类专栏： GLib库入门与实践 文章标签： 数据结构 c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/field1003/article/details/123435524
版权

简介

GLib提供了一组函数和数据的对应关系的功能，即hook函数。所有hook函数以链表形式组织在一起，该链表上每个节点都由数据和其处理函数组成，hook链表特有的遍历函数invoke及marshal可以在遍历时使用默认数据处理函数或指定新的处理函数处理数据。hook函数链表还提供了hook节点插入、节点查找、节点删除等功能。举例说明如下。
有一组数据 11 22 33 44，其默认处理函数分别为乘1,乘2,乘3,乘4，invoke遍历完，变成11,44,99,176，使用marshal函数，marshal回调为乘10，marshal遍历完，变成110,220,330,440，也可以只处理部分数据，只需调用g_hook_list_invoke_check或g_hook_list_marshal_check函数，在不需要处理的数据返回FALSE即可。

数据结构

hook函数有两个重要数据结构，GHookList和GHook，前者是hook函数链表，后者是其中的一个节点。

struct GHookList {
  gulong            seq_id;
  guint             hook_size : 16;
  guint             is_setup : 1;
  GHook            *hooks;
  gpointer          dummy3;
  GHookFinalizeFunc finalize_hook;
  gpointer          dummy[2];
};

struct GHook {
  gpointer       data;
  GHook         *next;
  GHook         *prev;
  guint          ref_count;
  gulong         hook_id;
  guint          flags;
  gpointer       func;
  GDestroyNotify destroy;
};

函数列表

g_hook_list_init ()
g_hook_list_invoke ()
g_hook_list_invoke_check ()
g_hook_list_marshal ()
g_hook_list_marshal_check ()
g_hook_list_clear ()
g_hook_alloc ()
g_hook_append()
g_hook_prepend ()
g_hook_insert_before ()
g_hook_insert_sorted ()
g_hook_compare_ids ()
g_hook_get ()
g_hook_find ()
g_hook_find_data ()
g_hook_find_func ()
g_hook_find_func_data ()
g_hook_first_valid ()
g_hook_next_valid ()
G_HOOK_FLAGS()
G_HOOK()
G_HOOK_IS_VALID()
G_HOOK_ACTIVE()
G_HOOK_IN_CALL()
G_HOOK_IS_UNLINKED()
g_hook_ref ()
g_hook_unref ()
g_hook_free ()
g_hook_destroy ()
g_hook_destroy_link ()

函数功能分类

// hook链表初始化
g_hook_list_init ()

// hook节点申请
g_hook_alloc ()

// 节点插入
g_hook_append()
g_hook_prepend ()
g_hook_insert_before ()
g_hook_insert_sorted ()

// 节点查找
// 通过hook_id查找一个hook节点
g_hook_get ()
// 查找hook节点，查找函数用户自己提供
g_hook_find ()
// 查找给定的data是否在hook列表中，如果有则返回该hook节点。
// 由于本函数内部比较是直接指针比较，所以要求传入的data只能是hook节点中的对象，值相等的变量不一定是同一个变量，会导致查找失败。
g_hook_find_data ()
// 给定func查找hook列表中是否有hook节点与此func相同(地址和值完全相等)
g_hook_find_func ()
// 给定func和data，查找hook列表中是否有hook节点与此func和data都相同(地址和值都相等)
g_hook_find_func_data ()
// 返回第一个活动状态的hook节点。hook节点有活动及正在执行两种状态。
g_hook_first_valid ()
// 返回下一个活动状态的hook节点。
g_hook_next_valid ()

// 遍历
// invoke函数对每个hook节点的data数据执行一遍func函数
// invoke_check函数和invoke相似，但hook回调函数返回失败则将该hook节点移出hook链表
// marshal函数对每个hook节点的data数据执行用户指定的marshal函数，而hook节点自身的函数不会被执行到。
// marshal_check函数和marshal函数相似，但hook回调函数返回失败则将该hook节点移出hook链表
g_hook_list_invoke ()
g_hook_list_invoke_check ()
g_hook_list_marshal ()
g_hook_list_marshal_check ()

// hook节点销毁
// 给定hook_id销毁一个hook节点，并调用该节点的释放函数。如果用户自定义的节点有内存，应在节点初始化时提供释放函数以释放内存。
g_hook_destroy ()
// 给定一个hook节点将其移出hook链表，并调用该节点释放函数。
g_hook_destroy_link ()

// 清空
// 将hook链表中所有节点全部移出hook链表，每个节点的释放函数均被调用。
g_hook_list_clear ()

// 释放
// 释放一个hook链表
g_hook_free ()

// 引用
// 计数加减一，如果引用计数为0，则该节点被释放，且节点的destroy释放函数会被调用。
g_hook_ref ()
g_hook_unref ()

// 标识
// 获取一个hook节点的标识（VALID、ACTIVE、IN_CALL、UNLINKED）
G_HOOK_FLAGS()
// hook节点是否有效（活动状态切未被销毁）
G_HOOK_IS_VALID()
// hook节点释放为活动状态
G_HOOK_ACTIVE()
// hook节点是否正在被执行
G_HOOK_IN_CALL()
// hook节点是否已经被销毁
G_HOOK_IS_UNLINKED()

函数功能说明及综合演示

hook节点插入-头插及尾插

这里演示将一个hook节点插入到hook链表中。
演示程序：
源码见glib_examples\glib_hook\glib_hook_insert

#include <glib.h>

typedef struct my_data_tag {
    int id;
    char *name;
}my_data_t;

static void hook_func (gpointer data)
{
    my_data_t *d = (my_data_t *)data;
    g_print("(hook_func)data->id:%d, data->name:%s \n", d->id, d->name);
}

static void hook_destroy (gpointer data)
{
    my_data_t *d = (my_data_t *)data;
    if(NULL != d) {
        if(NULL != d->name) {
            g_print("(hook_destroy) %s \n", d->name);
            g_free(d->name);
        }
        g_free(d);
    }
}

static void test_glib_ghook (void)
{
  GHookList *hl;
  GHook *hook1, *hook2;
  my_data_t *d1, *d2;

  d1 = g_new(my_data_t, 1);
  d1->id = 100;
  d1->name = g_strdup_printf("name-%d", d1->id);

  d2 = g_new(my_data_t, 1);
  d2->id = 200;
  d2->name = g_strdup_printf("name-%d", d2->id);

  hl = g_new (GHookList, 1);
  g_hook_list_init (hl, sizeof (GHook));

  hook1 = g_hook_alloc (hl);
  hook1->data = d1;
  hook1->func = hook_func;
  hook1->flags = G_HOOK_FLAG_ACTIVE;
  hook1->destroy = hook_destroy;
  g_hook_append (hl, hook1);

  hook2 = g_hook_alloc (hl);
  hook2->data = d2;
  hook2->func = hook_func;
  hook2->flags = G_HOOK_FLAG_ACTIVE;
  hook2->destroy = hook_destroy;
  g_hook_prepend (hl, hook2);
  
  g_hook_list_clear (hl);
  g_free (hl);
}


int main(int argc, char **argv) 
{
    test_glib_ghook();

    return 0;
}

运行结果：

[root@centos7_6 build]# ./glib_hook_insert 
(hook_destroy) name-200 
(hook_destroy) name-100
数据处理函数的执行

hook函数的重要功能就是使用对应的数据处理函数处理数据，g_hook_list_invoke和g_hook_list_marshal都可以对数据进行处理，链表内的所有节点都会被执行到。invoke函数和marshal函数的区别是，invoke在处理数据时使用的是hook节点添加时指定的处理函数，marshal在处理数据时，使用的是新的数据处理函数，此时将忽略默认数据处理函数。invoke的数据处理函数可以不同，但marshal的数据处理函数只有一个，即调用marshal函数时指定的数据处理函数，对每个hook节点的数据处理，都使用此函数。
演示程序：
源码见glib_examples\glib_hook\glib_hook_invoke_marshal

#include <glib.h>

typedef struct my_data_tag {
    int id;
    char *name;
}my_data_t;

static void hook_marshaller_func(GHook *hook, gpointer marshal_data)
{
    my_data_t *d = (my_data_t *)hook->data;
    d->id = d->id * GPOINTER_TO_INT(marshal_data);
}

static void hook1_func (gpointer data)
{
    my_data_t *d = (my_data_t *)data;
    g_print("(hook1)data->id:%d, data->name:%s \n", d->id, d->name);
    d->id = d->id*10;
    g_free(d->name);
    d->name = g_strdup_printf("new-name-%d", d->id);
}

static void hook1_destroy (gpointer data)
{
    my_data_t *d = (my_data_t *)data;
    if(NULL != d) {
        if(NULL != d->name) {
            g_free(d->name);
        }
        g_free(d);
    }
}

static void hook2_func (gpointer data)
{
    my_data_t *d = (my_data_t *)data;
    g_print("(hook2)data->id:%d, data->name:%s \n", d->id, d->name);
}

static void hook2_destroy (gpointer data)
{
    my_data_t *d = (my_data_t *)data;
    if(NULL != d) {
        if(NULL != d->name) {
            g_free(d->name);
        }
        g_free(d);
    }
}

static void test_glib_ghook (void)
{
  GHookList *hl;
  GHook *hook1, *hook2;
  my_data_t *d1, *d2;

  d1 = g_new(my_data_t, 1);
  d1->id = 100;
  d1->name = g_strdup_printf("name-%d", d1->id);

  d2 = g_new(my_data_t, 1);
  d2->id = 200;
  d2->name = g_strdup_printf("name-%d", d2->id);

  hl = g_new (GHookList, 1);
  g_hook_list_init (hl, sizeof (GHook));

  hook1 = g_hook_alloc (hl);
  hook1->data = d1;
  hook1->func = hook1_func;
  hook1->flags = G_HOOK_FLAG_ACTIVE;
  hook1->destroy = hook1_destroy;
  g_hook_append (hl, hook1);

  hook2 = g_hook_alloc (hl);
  hook2->data = d2;
  hook2->func = hook2_func;
  hook2->flags = G_HOOK_FLAG_ACTIVE;
  hook2->destroy = hook2_destroy;
  g_hook_prepend (hl, hook2);
  
  g_hook_list_invoke (hl, TRUE);

  g_print("after invoke: data1->id:%d, data1->name:%s \n", \
    ((my_data_t *)(hook1->data))->id, ((my_data_t *)(hook1->data))->name);
  g_print("after invoke: data2->id:%d, data2->name:%s \n", \
    ((my_data_t *)(hook2->data))->id, ((my_data_t *)(hook2->data))->name);

  g_hook_list_marshal(hl, TRUE, hook_marshaller_func, GINT_TO_POINTER(3));

  
  g_print("after marshal: data1->id:%d, data1->name:%s \n", \
    ((my_data_t *)(hook1->data))->id, ((my_data_t *)(hook1->data))->name);
  g_print("after marshal: data2->id:%d, data2->name:%s \n", \
    ((my_data_t *)(hook2->data))->id, ((my_data_t *)(hook2->data))->name);

  g_hook_list_clear (hl);
  g_free (hl);
}


int main(int argc, char **argv) 
{
    test_glib_ghook();

    return 0;
}

运行结果：

[root@centos7_6 build]# ./glib_hook_invoke_marshal 
(hook2)data->id:200, data->name:name-200 
(hook1)data->id:100, data->name:name-100 
after invoke: data1->id:1000, data1->name:new-name-1000 
after invoke: data2->id:200, data2->name:name-200 
after marshal: data1->id:3000, data1->name:new-name-1000 
after marshal: data2->id:600, data2->name:name-200
只处理部分数据

g_hook_list_invoke_check 和g_hook_list_marshal_check 可实现对指定特征的数据进行处理，其实现方式为，当数据处理函数返回FALSE时，该数据不被处理，当数据处理函数返回TRUE时，才处理该数据。本程序演示g_hook_list_marshal_check处理部分数据的效果，当数据为偶数时，跳过不处理，当数据为奇数时，才进行乘10的处理，程序见下。
演示程序：
源码见glib_examples\glib_hook\glib_hook_marshal_check

#include <glib.h>

typedef struct my_data_tag {
    int id;
    char *name;
}my_data_t;

gboolean hook_marshal_func(GHook *hook, gpointer marshal_data)
{
    my_data_t *d = (my_data_t *)hook->data;
    if((d->id/10)%2) {
        return FALSE;
    }

    return TRUE;
}


static void hook_func (gpointer data)
{
    my_data_t *d = (my_data_t *)data;
    g_print("(hook_func)data->id:%d, data->name:%s \n", d->id, d->name);
    d->id = d->id*10;
}

static void hook_destroy (gpointer data)
{
    my_data_t *d = (my_data_t *)data;
    if(NULL != d) {
        if(NULL != d->name) {
            g_print("(hook_destroy) id:%d, name:%s \n", d->id, d->name);
            g_free(d->name);
        }
        g_free(d);
    }
}

static void test_glib_ghook (void)
{
    GHookList *hl;
    GHook *hook1, *hook2, *hook3, *hook4;
    my_data_t *d1, *d2, *d3, *d4;

    d1 = g_new(my_data_t, 1);
    d1->id = 1;
    d1->name = g_strdup_printf("name-%d", d1->id);

    d2 = g_new(my_data_t, 1);
    d2->id = 2;
    d2->name = g_strdup_printf("name-%d", d2->id);

    d3 = g_new(my_data_t, 1);
    d3->id = 3;
    d3->name = g_strdup_printf("name-%d", d3->id);

    d4 = g_new(my_data_t, 1);
    d4->id = 4;
    d4->name = g_strdup_printf("name-%d", d4->id);

    hl = g_new (GHookList, 1);
    g_hook_list_init (hl, sizeof (GHook));

    hook1 = g_hook_alloc (hl);
    hook1->data = d1;
    hook1->func = hook_func;
    hook1->flags = G_HOOK_FLAG_ACTIVE;
    hook1->destroy = hook_destroy;
    g_hook_append (hl, hook1);

    hook2 = g_hook_alloc (hl);
    hook2->data = d2;
    hook2->func = hook_func;
    hook2->flags = G_HOOK_FLAG_ACTIVE;
    hook2->destroy = hook_destroy;
    g_hook_append (hl, hook2);

    hook3 = g_hook_alloc (hl);
    hook3->data = d3;
    hook3->func = hook_func;
    hook3->flags = G_HOOK_FLAG_ACTIVE;
    hook3->destroy = hook_destroy;
    g_hook_append (hl, hook3);

    hook4 = g_hook_alloc (hl);
    hook4->data = d4;
    hook4->func = hook_func;
    hook4->flags = G_HOOK_FLAG_ACTIVE;
    hook4->destroy = hook_destroy;
    g_hook_append (hl, hook4);

    g_print("invoke 1st \n");
    g_hook_list_invoke(hl, TRUE);

    g_print("marshal_check \n");
    g_hook_list_marshal_check(hl, TRUE, hook_marshal_func, NULL);

    g_print("invoke 2nd \n");
    g_hook_list_invoke(hl, TRUE);

    g_hook_list_clear (hl);
    g_free (hl);
}


int main(int argc, char **argv) 
{
    test_glib_ghook();

    return 0;
}

运行结果：

[root@centos7_6 build]# ./glib_hook_marshal_check 
invoke 1st 
(hook_func)data->id:1, data->name:name-1 
(hook_func)data->id:2, data->name:name-2 
(hook_func)data->id:3, data->name:name-3 
(hook_func)data->id:4, data->name:name-4 
marshal_check 
(hook_destroy) id:10, name:name-1 
(hook_destroy) id:30, name:name-3 
invoke 2nd 
(hook_func)data->id:20, data->name:name-2 
(hook_func)data->id:40, data->name:name-4 
(hook_destroy) id:200, name:name-2 
(hook_destroy) id:400, name:name-4
hook节点销毁及hook链表清空

这里演示将一个hook节点销毁及将整个hook链表清空的效果。
演示程序：
源码见glib_examples\glib_hook\glib_hook_destroy

#include <glib.h>

typedef struct my_data_tag {
    int id;
    char *name;
}my_data_t;

static void hook_func (gpointer data)
{
    my_data_t *d = (my_data_t *)data;
    g_print("(hook_func)data->id:%d, data->name:%s \n", d->id, d->name);
}

static void hook_destroy (gpointer data)
{
    my_data_t *d = (my_data_t *)data;
    if(NULL != d) {
        if(NULL != d->name) {
            g_print("(hook_destroy) %s \n", d->name);
            g_free(d->name);
        }
        g_free(d);
    }
}

static void test_glib_ghook (void)
{
    GHookList *hl;
    GHook *hook1, *hook2, *hook3;
    my_data_t *d1, *d2, *d3;

    d1 = g_new(my_data_t, 1);
    d1->id = 100;
    d1->name = g_strdup_printf("name-%d", d1->id);

    d2 = g_new(my_data_t, 1);
    d2->id = 200;
    d2->name = g_strdup_printf("name-%d", d2->id);

    d3 = g_new(my_data_t, 1);
    d3->id = 300;
    d3->name = g_strdup_printf("name-%d", d3->id);

    hl = g_new (GHookList, 1);
    g_hook_list_init (hl, sizeof (GHook));

    hook1 = g_hook_alloc (hl);
    hook1->data = d1;
    hook1->func = hook_func;
    hook1->flags = G_HOOK_FLAG_ACTIVE;
    hook1->destroy = hook_destroy;
    g_hook_append (hl, hook1);

    hook2 = g_hook_alloc (hl);
    hook2->data = d2;
    hook2->func = hook_func;
    hook2->flags = G_HOOK_FLAG_ACTIVE;
    hook2->destroy = hook_destroy;
    g_hook_append (hl, hook2);

    hook3 = g_hook_alloc (hl);
    hook3->data = d3;
    hook3->func = hook_func;
    hook3->flags = G_HOOK_FLAG_ACTIVE;
    hook3->destroy = hook_destroy;
    g_hook_append (hl, hook3);

    g_hook_list_invoke (hl, TRUE);

    g_print("after invoke: data1->id:%d, data1->name:%s \n", \
    ((my_data_t *)(hook1->data))->id, ((my_data_t *)(hook1->data))->name);
    g_print("after invoke: data2->id:%d, data2->name:%s \n", \
    ((my_data_t *)(hook2->data))->id, ((my_data_t *)(hook2->data))->name);
    g_print("after invoke: data3->id:%d, data3->name:%s \n", \
    ((my_data_t *)(hook3->data))->id, ((my_data_t *)(hook3->data))->name);

    g_print("destroy hook: %d \n", hook2->hook_id);
    g_hook_destroy(hl, hook2->hook_id);

    g_print("destroy_link hook: %d \n", hook1->hook_id);
    g_hook_destroy_link(hl, hook1);

    g_print("clear list! \n");
    g_hook_list_clear (hl);
    g_free (hl);
}


int main(int argc, char **argv) 
{
    test_glib_ghook();

    return 0;
}

运行结果：

[root@centos7_6 build]# ./glib_hook_destroy 
(hook_func)data->id:100, data->name:name-100 
(hook_func)data->id:200, data->name:name-200 
(hook_func)data->id:300, data->name:name-300 
after invoke: data1->id:100, data1->name:name-100 
after invoke: data2->id:200, data2->name:name-200 
after invoke: data3->id:300, data3->name:name-300 
destroy hook: 2 
(hook_destroy) name-200 
destroy_link hook: 1 
(hook_destroy) name-100 
clear list! 
(hook_destroy) name-300
field1003
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
hook glibc
weixin_41041321的博客
12-12 825
我们知道，Linux的用C库的都是glibc，有一个叫libc.so.6的文件，这是几乎所有Linux下命令的动态链接中，其中有标准C的各种函数，默认情况下，linux所编译的程序中对标准C函数的链接，都是通过动态链接方式来链接libc.so.6这个函数库的。这也意味着我们在通过我们注入的.so来实现函数覆盖劫持之后需要从libc.so.6中取得原本的正常函数，让程序继续正常执行 正常程序m
Hook插件（一）
Aidang的博客
01-12 2405
1. 新建工程时选择“No Activity” 2. App目录下创建一个新的文件夹”lib” (这里一定要注意，不是使用libs文件夹而是创建一个lib文件夹，如果这里使用了libs文件夹的话，在安装成功模块之后重启会发现Hook是失败的，通过打印tag为xposed的日志信息会发现这样的错误：Java.lang.IllegalAccessError: Class ref in pre-verified class resolved to unexpected implementation这个错误主要是因
GoHook: 动态Hook框架，高效调试与监控利器
最新发布
gitblog_00044的博客
04-22 316
GoHook: 动态Hook框架，高效调试与监控利器 项目地址:https://gitcode.com/HavenShen/gohook GoHook 是一个强大的Go语言动态Hook框架，它允许开发者在运行时无侵入地拦截和修改函数调用行为，为调试、性能监控和自动化测试提供了全新的可能性。 技术概览 GoHook 基于Go语言的反射(reflection)和插桩(Tracing)机制实现。它允许你...
【Android 插件化】Hook 插件化框架总结 ( 插件包管理 | Hook Activity 启动流程 | Hook 插件包资源加载 ) ★★★
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
08-12 1391
Android 插件化系列文章目录、 前言、 一、项目结构及运行方法、 1、项目结构、 2、项目运行、 二、宿主应用、 1、拷贝工具类、 2、自定义 Application、 3、宿主 Activity 界面、 三、插件化框架、 1、反射工具类、 2、插件包管理器类、 3、Hook 操作类、 4、Hook AMS 代理类、 5、Hook Handler 代理类、 6、Hook Instrumentation 代理类、 7、占坑 Activity、 四、插件应用、 五、博客资源、
chrome五十大实用插件集合！
热门推荐
·没有风雨躲得过，没有坎坷不必走·
04-02 4万+
Chrome插件！
Linux下Gogs配置Git钩子 服务端部署钩子 hooks
陈万洲的专栏
04-09 4339
在Git版本控制中，本地push代码至git服务端后，线上web站点自动的pull拉取代码，实现代码同步。于是git的hooks钩子就是实现自动化更新的核心技术。 准备工作：（Gogs 和 Web服务都安装好） 1、 保证Gogs和web站点在同一台服务上。（如果不在同一服务器，只能考虑用web钩子了） 2、 Gogs创建远程仓库 3、 Web站点根目录，克隆一个仓库。（g...
【Android 插件化】Hook 插件化框架 ( 通过反射获取 “插件包“ 中的 Element[] dexElements )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
08-02 1400
一、通过反射获取 "插件包" 中的 Element[] dexElements、 1、反射获取 BaseDexClassLoader.class、 2、反射获取 DexPathList pathList 字段、 3、反射获取 DexPathList pathList 对象、 4、获取 DexPathList pathList 对象、 5、反射获取 Element[] dexElements 字段、 6、反射获取 Element[] dexElements 对象、
U8glib_forwardveg_U8glib\utility_u8glib支持oled_u8glib_u8glib库下载_源
10-03
**U8glib库详解与应用** U8glib是一个为微控制器平台设计的开源图形库，主要用于驱动各种类型的OLED（有机发光二极管）显示屏。这个库由Oliver Klotz开发，旨在简化在嵌入式系统上实现文本、图形以及基本的图像处理...
message_pump_glib.rar_On Message
09-24
在Linux操作系统中，GLib库是GObject系统的基础，它提供了一套强大的数据结构、线程管理、事件处理等工具。GLib的消息泵，又称为事件循环，是其核心功能之一，对于理解和编写高效、响应的图形用户界面（GUI）程序至...
WDTandEINT.rar_glib.h 2410
09-14
标题中的“WDTandEINT.rar_glib.h 2410”表明这是一个关于在ARM2410平台上使用glib.h库进行看门狗和中断处理的实践教程。 首先，让我们了解看门狗定时器。看门狗定时器是一种硬件安全机制，用于防止系统因软件故障...
glib-html-2.6.6.tar.gz_glib_glib-2.6.6.tar.b_linux gl
09-22
这表明我们要讨论的是GLib库在Linux系统上的一个特定版本，以及与图形库相关的应用。 GLib是GObject的基础库，它是GNOME桌面环境的核心部分，广泛用于C语言编程。GLib提供了许多基础功能，如数据结构、线程、定时器...
U8g2_Arduino：用于Arduino的U8glib V2库
01-28
U8g2_Arduino：用于Arduino的U8glib V2库
干货|Android免Root最全Hook插件(免Root Hook任意App)
哆啦安全
09-28 5589
支持276个API接口的Hook，覆盖Android系统级API和50个常见开源框架的Hook，包括对网络、算法、TextView、WebView、JSONObject等API接口的Hook支持，可以免Root实现高效的全自动化Hook任意App。 Android Studio gradle无法编译App的完美解决方法 Android Studio中gradle版本升级报gradle的仓库地址不安全警告 Android Studio中gradle版本是否升级的方案(选其一)
android gl修改工具,gl工具箱(GLTools)软件下载-gl工具箱appv3.06 安卓版-腾牛安卓网...
weixin_33247358的博客
05-25 4157
gl工具箱app英文名为GLTools，软件可以修改游戏数据，让玩家更轻松激情爽玩各种手游，软件还支持GPU、RAM信息模拟、处理器特效优化等，觉得不错的朋友欢迎前来下载使用。gl工具箱app介绍：gl工具箱app是一款好用的游戏数据修改工具，不仅可以模拟GPU还可以模拟CPU，同时还支持GPU、RAM信息模拟、处理器及特效优化等，仅推荐动手能力强的玩家使用。使用说明：1.手机需root。安装GL...
Android中GOT表HOOK手动实现
Rorschach:Blog
11-17 4778
网上对于Android中各种HOOK的实现都有很多的介绍了，之前看懂了原理相关的东西，一直没有去尝试手动实现，最近刚好想起就手动实现了一下，简单尝试记录下实现过程以及坑点。如何理解HOOK？ 我理解的HOOK就是去动态的修改代码段中相关跳转地址或者指令，执行我们的代码，然后跳转回去接着执行。那既然这样，肯定要保证动态修改的操作先于该函数被执行，因此一般会将HOOK代码放在比较靠前被执行的地方，如i
mac下GLTools的安装
sxc1989的博客
03-06 3469
在学习《OpenGL超级宝典》时， 其中的例子用到了GLTools库，需要自行安装。MAC下GLTools的安装方法如下： 1. git clone https://github.com/HazimGazov/GLTools 2. cd build 3. cmake .. 4. make 5. sudo make install备注如果cmake时提示GLEW_LIBRARY找不到， 则需
php ghook 全局钩子功能 v0
朱健强的blog 天行健 君子以自强不息
11-29 2813
在 cms 系统中遇到过这种情况： 其它模块的数据需要关联会员模块的会员数据，所以在删除会员时应需要与会员数据关联的模块进行数据关联操作。 比如删除一个会员时同时删除此会员发布的文章。 但是，其它模块是在会员模块之后才开发出来的，要实现这种关联性，可以每多一个与会员模块关联的模块就改动一次会员模块的代码，又或者，使用 hook(钩子)的概念。 通过制定一套全系统模块统一的 hook 规
Golang使用接口和组合实现hook函数
Yobol2016的博客
04-25 5047
目录Golang使用接口和组合实现hook函数继承和组合的优缺点继承的优缺点优点缺点组合的优缺点优点缺点实现父类调用子类方法的效果 Golang使用接口和组合实现hook函数 面向对象的高级编程语言（以Java为例）主要有四大特性：抽象、封装、继承和多态： 抽象是指提取出某一类事物的共性（包括特征和行为），形成类模型，用类的属性和方法分别表示这类事物的特征和行为。 封装是指把抽象出来的特征和行为...
VS下glut freeglut GLtools glew等 配置教程
guchaono1的专栏
12-02 2833
                         转自：http://www.jianshu.com/p/b49fd7fe8b5c              freeglut 与 glut的差别：  [源自百度百科]  freeglut是GLUT [注1]的一个完全开源替代库。  GLUT最初是《OpenGL红皮书(第二版)》[注2]
g_object_new_with_properties方法在glib的哪里
05-25
g_object_new_with_properties方法在GLib的Object类型的源文件"gobject/gobject.c"中实现。该方法是从g_object_newv()方法派生而来的，它允许在创建新对象时设置属性。它接受一个GObjectClass指针和一个NULL结束的GParameter数组作为参数，其中每个元素表示一个属性及其值。这些参数被用来设置新对象的属性值。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值