首先条件断点定位readfile读聊天数据库的地方

判断是从ImStorage.dll调用来的

ida反编译ImStorage.dll,定位到sqlite3key

断点到sqlite3key,当前的key如下:vJCouweimIBZLuJL

寻找多个号内存对比一下,得到通用特征:9008????f87f00001000000017000000

编写一个特征内存搜索程序,即可在不同环境搜索到key

解密使用sqllite.dll即可

内存搜索代码:

#include <iostream>
#include"Windows.h"
#include "tlhelp32.h"
#include <tchar.h>


char* hexArrayToString(unsigned char* array, int start, int length) {
    // 每个字节需要2个字符表示,加上空格分隔符和结尾的'\0'
    char* result = (char*)malloc(length * 3 + 1);
    if (result == NULL) {
        return NULL;
    }

    char* ptr = result;
    for (int i = start; i < start + length; i++) {
        sprintf(ptr, "%02X", array[i]); // 格式化为2位大写16进制加空格
        ptr += 2;
    }
    return result;
}

unsigned char hex_to_num(unsigned char c) {
    if (c >= '0' && c <= '9') {
        return c - '0';
    }

    if (c >= 'a' && c <= 'f') {
        return c - 'a' + 10;
    }

    if (c >= 'A' && c <= 'F') {
        return c - 'A' + 10;
    }

    return 0;
}

// 自定义内存比较函数,支持通配符"??"
int op_memcmp(char* dst, char* src, int size) {
    int j = 0;
    //size是j的大小才对,原作者不知道是什么意思
    for (int i = 0; i < size; i++) {
        // 跳过通配符"??"
        if (src[i] == '?') {
        }
        else if (src[i] != dst[j]) {
            return -1;
        }
        j += 1;
    }

    return 0;
}

// 计算实际需要比较的字节数(排除通配符"??")  仅仅计算要匹配的字节数
int op_checksize(char* src, int size) {
    int j = 0;
    for (int i = 0; i < size; i++) {
        if (src[i] == '?' && (i + 1) < size && src[i + 1] == '?') {
            i += 1;
        }
        j += 1;
    }
    return j;
}


int checkmem(char* input, int i) {
    int j = 0;
    for (int j = 0xB0; j < 0xC0; j++) {
        if ((unsigned char)(input[i + j]) == 0x00) {
            return 0;
        }
    }
    return 1;
}


// 主搜索函数:在指定进程的内存中搜索特定模式
void _mlockall(uint32_t pid, std::string s) {
    // 打开目标进程
    unsigned char hex_array[16];
    const HANDLE Process = OpenProcess(PROCESS_SET_QUOTA | PROCESS_QUERY_INFORMATION |
        PROCESS_VM_OPERATION | PROCESS_VM_READ,
        false, pid);

    printf("%s pid: 0x%08x, Process: %p\n", __func__, pid, Process);

    if (Process == nullptr) {
        return;
    }

    // 将十六进制字符串转换为字节数组
    int sSize = s.length() / 2;
    char* search = new char[sSize];
    for (int i = 0; i < s.length(); i += 2) {
        unsigned char c = hex_to_num(s.at(i)) << 4 | hex_to_num(s.at(i + 1));
        printf("%02x", c);
        search[i / 2] = c;
    }
    printf("\n");
    uint64_t _1MB = 1024 * 1024;

    // 遍历进程内存区域
    MEMORY_BASIC_INFORMATION MemoryInfo;
    uint64_t NumberBytes = 0;
    uint64_t AmountMb = 0;
    //VirtualQueryEx一次返回一篇内存区域的信息
    for (uint8_t* Address = 0;
        VirtualQueryEx(Process, Address, &MemoryInfo, sizeof(MemoryInfo));
        Address = (uint8_t*)MemoryInfo.BaseAddress + MemoryInfo.RegionSize) {
        PVOID BaseAddress = MemoryInfo.BaseAddress;
        SIZE_T RegionSize = MemoryInfo.RegionSize;

        // 跳过受保护或不可访问的内存区域
        const uint32_t BadProtectBits = PAGE_GUARD | PAGE_NOACCESS;
        if (MemoryInfo.Protect & BadProtectBits) {
            continue;
        }

        const uint32_t BadStatetBits = MEM_FREE | MEM_RESERVE;
        if (MemoryInfo.State & BadStatetBits) {
            continue;
        }

        // 读取整个内存区域
        auto Buffer = std::make_unique<uint8_t[]>(RegionSize);
        SIZE_T NumberBytesRead = 0;
        const bool Ret = ReadProcessMemory(Process, BaseAddress, Buffer.get(),
            RegionSize, &NumberBytesRead);
        if (!Ret || NumberBytesRead != RegionSize) {
            printf("读取进程内存失败,退出.\n");
            return;
        }

        NumberBytes += RegionSize;
        AmountMb = NumberBytes / _1MB;

        // 计算实际需要匹配的字节数
        //size_t size = op_checksize(search, sSize);
        size_t size = sSize;
        unsigned char rKey[0x20] = "";
        char* dst = (char*)(Buffer.get());
        char* findAddr = NULL;
        bool success = false;



        // 在内存区域中搜索模式
        for (int i = 0; i < (RegionSize - size); i++)
        {
            // 找到匹配的模式且后续条件满足  修改后额外的匹配中 && *(int*)(dst + i + size + 0x10) == 0x10暂不需要
            if (!op_memcmp(dst + i, search, size))
            {
                success = true;
                findAddr = *(char**)(dst + i);//偏移也修改,只需要匹配首字节
                //获取的不是地址,就不用readprocessmemory了
                for (int j = 24; j < 40; j++) {
                    hex_array[j - 24] = (unsigned char)dst[i + j];
                }
                printf("寻找到sqlite密钥: %s\n", hex_array);
            }
        }
        if (success)
        {
        }
    }
    delete[]search;
    CloseHandle(Process);
}

DWORD GetPidByProcessName(const TCHAR* processName) {
    PROCESSENTRY32 pe32;
    pe32.dwSize = sizeof(PROCESSENTRY32);
    HANDLE hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hProcessSnap == INVALID_HANDLE_VALUE) {
        _tprintf(_T("CreateToolhelp32Snapshot failed. Error: %d\n"), GetLastError());
        return 0;
    }
    if (Process32First(hProcessSnap, &pe32)) {
        do {
            if (_tcsicmp(pe32.szExeFile, processName) == 0) {
                CloseHandle(hProcessSnap);
                return pe32.th32ProcessID;
            }
        } while (Process32Next(hProcessSnap, &pe32));
    }

    CloseHandle(hProcessSnap);
    return 0;
}


int main() {
    const TCHAR* processName = L"infoflow.exe";
    DWORD pid = GetPidByProcessName(processName);
    std::string sa = "90083f3ff87f00001000000017000000";
    _mlockall(pid, sa);
}

解密代码如下:

import ctypes
import sqlite3

# ====== 配置 ======
DLL_PATH = "D:\project\python\sqlite3_dec\sqlite3.dll"        # 必须是 SQLCipher 版本
DB_PATH = "msg31.db"
KEY = b"vJCouweimIBZLuJL"
OUT_DB_PATH = "decrypted.db"


dll = ctypes.cdll.LoadLibrary(DLL_PATH)

# ===== C函数 =====
sqlite3_open = dll.sqlite3_open
sqlite3_open.argtypes = [ctypes.c_char_p, ctypes.POINTER(ctypes.c_void_p)]

sqlite3_key = dll.sqlite3_key
sqlite3_key.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_int]

sqlite3_exec = dll.sqlite3_exec

# ===== 打开 =====
db = ctypes.c_void_p()
sqlite3_open(DB_PATH.encode(), ctypes.byref(db))
sqlite3_key(db, KEY, len(KEY))


# ===== 查询工具 =====
def query(sql):
    results = []

    CALLBACK = ctypes.CFUNCTYPE(
        ctypes.c_int,
        ctypes.c_void_p,
        ctypes.c_int,
        ctypes.POINTER(ctypes.c_char_p),
        ctypes.POINTER(ctypes.c_char_p)
    )

    def cb(_, col_count, values, names):
        row = []
        for i in range(col_count):
            v = values[i]
            row.append(v.decode() if v else None)
        results.append(row)
        return 0

    callback = CALLBACK(cb)

    err = ctypes.c_char_p()
    sqlite3_exec(db, sql.encode(), callback, None, ctypes.byref(err))

    return results


# ===== 1️⃣ 获取所有表结构 =====
tables = query("SELECT name, sql FROM sqlite_master WHERE type='table';")

# ===== 2️⃣ 创建新数据库 =====
out_conn = sqlite3.connect(OUT_DB_PATH)
out_cur = out_conn.cursor()

for table_name, create_sql in tables:
    if table_name.startswith("sqlite_"):
        continue

    print(f"[+] Creating table: {table_name}")
    out_cur.execute(create_sql)

    # ===== 3️⃣ 导出数据 =====
    rows = query(f"SELECT * FROM {table_name}")

    if not rows:
        continue

    placeholders = ",".join(["?"] * len(rows[0]))

    for row in rows:
        out_cur.execute(f"INSERT INTO {table_name} VALUES ({placeholders})", row)

    out_conn.commit()

print(f"[+] Exported to {OUT_DB_PATH}")
out_conn.close()

​