Method sendAddressesFromSignatures

src/program/UnityPatching.cpp:1003–1060

}

void UnityPatching::sendAddressesFromSignatures(std::pair<uintptr_t,uintptr_t> executablefile_segment, bool is_64bit)
{
    /* We need to query the executable memory to make the search */
    ptrdiff_t executable_size = executablefile_segment.second - executablefile_segment.first;
    void* executable_local_addr = mmap(nullptr, executable_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    
    if (executable_local_addr == MAP_FAILED) {
        std::cerr << "Could not map a segment of size " << executable_size << " to host the executable memory" << std::endl;
    }
    else {
        int ret = MemAccess::read(executable_local_addr, reinterpret_cast<void*>(executablefile_segment.first), executable_size);
        
        if (ret == -1)
            std::cerr << "Could not read the executable segment memory" << std::endl;
        
        const usig_t* signatures = is_64bit ? UNITY_SIGNATURES_64 : UNITY_SIGNATURES_32;
        
        for (int i=0; signatures[i].id != UNITY_FUNCS_LEN; i++) {
            const char* signature = signatures[i].signature;
            if (strlen(signature) == 0)
                continue;

            /* Get the function name. Not ideal */
            const char* name = "";
            for (int j=0; UNITY_SYMBOLS[j].id != UNITY_FUNCS_LEN; j++) {
                if (UNITY_SYMBOLS[j].id == signatures[i].id) {
                    name = UNITY_SYMBOLS[j].name;
                    break;
                }
            }
            
            Signature sig;
            sig.fromIdaString(signature);
            
            ptrdiff_t func_offset;
            uintptr_t func_addr;
            int match_count = SigSearch::Search(static_cast<uint8_t*>(executable_local_addr), executable_size, sig, &func_offset);
            
            switch (match_count) {
                case 0:
                    // std::cout << "Found no occurrence of signature " << signature << " associated with function symbol " << signature[i].symbol << std::endl;
                    break;
                case 1:
                    func_addr = executablefile_segment.first + func_offset;
                    std::cout << "Found unique matching signature ("<< signature << ") for function " << name << " in address " << std::hex << (uintptr_t)func_addr << std::endl;
                    sendMessage(MSGN_UNITY_ADDR);
                    sendData(&signatures[i].id, sizeof(int));
                    sendData(&func_addr, sizeof(uintptr_t));
                    break;
                default:
                    std::cout << "Found " << match_count << " occurrences of signature " << signature << " associated with function " << name << std::endl;
                    break;
            }
        }
        
        munmap(executable_local_addr, executable_size);
    }
}