[ 源码 ] - ZERO资源分享

✔️轩少互推公益宣传 【宝贝回家公益宣传系列】 愿所有丢失的孩子都能找到自己的家庭❤️

全网最质量效率可查🕠🕠即可 不打空头支票 效率随时看 点击下方链接可以查看互推效率🌟

✔️轩少互推公益宣传 【宝贝回家公益宣传系列】 愿所有丢失的孩子都能找到自己的家庭❤️

全网最质量效率可查🕠🕠即可 不打空头支票 效率随时看 点击下方链接可以查看互推效率🌟

include $(CLEAR_VARS)
LOCAL_MODULE := shadowhook
LOCAL_SRC_FILES := shadowhook/libshadowhook.a
LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/shadowhook
include $(PREBUILT_STATIC_LIBRARY)

LOCAL_STATIC_LIBRARIES     :=libshadowhook

ANDROID.MK 加入这个

#include "shadowhook/shadowhook.h"

shadowhook_init(shadowhook_mode_t::SHADOWHOOK_MODE_UNIQUE, 0);

void* libEGL_handle = shadowhook_dlopen(oxorany("/system/lib64/libEGL.so"));
    if (libEGL_handle != nullptr) {
        void* target_func = shadowhook_dlsym(libEGL_handle, oxorany("eglSwapBuffers"));
        if (target_func != nullptr) {
            shadowhook_hook_func_addr(
                target_func,
                (void*)_eglSwapBuffers,
                (void**)&orig_eglSwapBuffers
            );
        }
        shadowhook_dlclose(libEGL_handle);
    }

EGL无追封hook

int (*oStrlen)(int a1, const char *a2);
int hStrlen(int a1, const char *a2) {
if (strstr((const char *) a2,oxorany("eglSwapBuffers")) {
return 0;
}else{
return oStrlen(a1,a2);
}}
shadowhook_hook_func_addr((void *)(UE4+oxorany(0xcd42690)), (void *)hStrlen, (void **)&oStrlen); //越南IMGUI防闪


int (*oStrlen)(int a1, const char *a2);
int hStrlen(int a1, const char *a2) {
if (strstr((const char *) a2,oxorany("eglSwapBuffers")) {
return 0;
}else{
return oStrlen(a1,a2);
}}
shadowhook_hook_func_addr((void *)(UE4+oxorany(0xcc8de10)), (void *)hStrlen, (void **)&oStrlen); //三服IMGUI防闪

全套IMGUI防闪+防封HOOK 泛滥频道 @PubgScripts 搬运不带频道死🐴

antiban(int64_t, sub_37C904,(void* reader, void* entry, void** outBuffer, uint32_t* outSize))
{
    if (!entry || !outBuffer || !outSize) {
        if (reader) {
            *(int32_t*)((uintptr_t)reader + 532) = -999;
        }
        return -1;
    }

    uint64_t offset = 0;
    uint32_t size = 0;

    if (*(uint8_t*)((uintptr_t)reader + 528) & 1) { 
        size = *(uint64_t*)((uintptr_t)entry + 32);
        offset = *(uint64_t*)((uintptr_t)entry + 24);
    } else { 
        size = *(uint32_t*)((uintptr_t)entry + 20);
        offset = *(uint32_t*)((uintptr_t)entry + 16);
    }

    *outSize = size;

    void* buffer = malloc(size);
    *outBuffer = buffer;

    if (!buffer) {
        *(int32_t*)((uintptr_t)reader + 532) = -12;
        return -1;
    }

    uintptr_t baseAddress = *(uintptr_t*)((uintptr_t)reader + 512);
    const uint8_t* source = (const uint8_t*)(baseAddress + offset);
    
    memcpy(buffer, source, size);
    
    *(int32_t*)((uintptr_t)reader + 532) = 0; 
    return 0;
}

typedef struct
{
const uint8_t* baseAddress;
uint8_t use64Bit;
int32_t lastError;
} ReaderContext;

typedef struct
{
uint32_t offset32;
uint32_t size32;
uint64_t offset64;
uint64_t size64;
} EntryInfo;

typedef struct
{
ReaderContext context;
} ResourceReader;

void Reader_Init(ResourceReader* reader,const void* baseAddress,uint8_t use64Bit)
{
if(!reader)return;
reader->context.baseAddress=(const uint8_t*)baseAddress;
reader->context.use64Bit=use64Bit;
reader->context.lastError = 0;
}

void Reader_ResetError(ResourceReader* reader)
{
if(!reader)return;
reader->context.lastError = 0;
}

int Reader_GetLastError(const ResourceReader* reader)
{
return reader?reader->context.lastError:-1;
}

int Reader_ReadChunk(ResourceReader* reader,const EntryInfo* entry,void** outBuffer,uint32_t* outSize)
{
if(!reader||!entry||!outBuffer||!outSize)return -1;

Reader_ResetError(reader);

*outBuffer = NULL;
*outSize = 0;

uint64_t offset = 0;
uint32_t size = 0;

if(reader->context.use64Bit&1)
{
offset = entry->offset64;
size = (uint32_t)entry->size64;
}
else
{
offset = entry->offset32;
size = entry->size32;
}

if(!reader->context.baseAddress||size == 0)return 0;

void* buffer = malloc(size);
if(!buffer)
{
reader->context.lastError=-errno;
return -1;
}

const uint8_t* source = reader->context.baseAddress + offset;

memcpy(buffer,source,size);

*outBuffer = buffer;
*outSize = size;

return 0;
}