444 lines
12 KiB
C
444 lines
12 KiB
C
#include <unicorn/unicorn.h>
|
|
#include <stdio.h>
|
|
|
|
/*
|
|
* mov rax, 57
|
|
* syscall
|
|
* test rax, rax
|
|
* jz child
|
|
* xor rax, rax
|
|
* mov rax, 60
|
|
* mov [0x4000], rax
|
|
* syscall
|
|
*
|
|
* child:
|
|
* xor rcx, rcx
|
|
* mov rcx, 42
|
|
* mov [0x4000], rcx
|
|
* mov rax, 60
|
|
* syscall
|
|
*/
|
|
char code[] = "\xB8\x39\x00\x00\x00\x0F\x05\x48\x85\xC0\x74\x0F\xB8\x3C\x00\x00"
|
|
"\x00\x48\x89\x04\x25\x00\x40\x00\x00\x0F\x05\xB9\x2A\x00\x00\x00"
|
|
"\x48\x89\x0C\x25\x00\x40\x00\x00\xB8\x3C\x00\x00\x00\x0F\x05";
|
|
|
|
static void mmu_write_callback(uc_engine *uc, uc_mem_type type,
|
|
uint64_t address, int size, int64_t value,
|
|
void *user_data)
|
|
{
|
|
printf("write at 0x%lx: 0x%lx\n", address, value);
|
|
}
|
|
|
|
static void x86_mmu_prepare_tlb(uc_engine *uc, uint64_t vaddr,
|
|
uint64_t tlb_base)
|
|
{
|
|
uc_err err;
|
|
uint64_t cr0;
|
|
uint64_t cr4;
|
|
uc_x86_msr msr = {.rid = 0xC0000080, .value = 0};
|
|
uint64_t pml4o = ((vaddr & 0x00ff8000000000) >> 39) * 8;
|
|
uint64_t pdpo = ((vaddr & 0x00007fc0000000) >> 30) * 8;
|
|
uint64_t pdo = ((vaddr & 0x0000003fe00000) >> 21) * 8;
|
|
uint64_t pml4e = (tlb_base + 0x1000) | 1 | (1 << 2);
|
|
uint64_t pdpe = (tlb_base + 0x2000) | 1 | (1 << 2);
|
|
uint64_t pde = (tlb_base + 0x3000) | 1 | (1 << 2);
|
|
err = uc_mem_write(uc, tlb_base + pml4o, &pml4e, sizeof(pml4o));
|
|
if (err) {
|
|
printf("failed to write pml4e\n");
|
|
exit(1);
|
|
}
|
|
err = uc_mem_write(uc, tlb_base + 0x1000 + pdpo, &pdpe, sizeof(pdpe));
|
|
if (err) {
|
|
printf("failed to write pml4e\n");
|
|
exit(1);
|
|
}
|
|
err = uc_mem_write(uc, tlb_base + 0x2000 + pdo, &pde, sizeof(pde));
|
|
if (err) {
|
|
printf("failed to write pde\n");
|
|
exit(1);
|
|
}
|
|
err = uc_reg_write(uc, UC_X86_REG_CR3, &tlb_base);
|
|
if (err) {
|
|
printf("failed to write CR3\n");
|
|
exit(1);
|
|
}
|
|
err = uc_reg_read(uc, UC_X86_REG_CR0, &cr0);
|
|
if (err) {
|
|
printf("failed to read CR0\n");
|
|
exit(1);
|
|
}
|
|
err = uc_reg_read(uc, UC_X86_REG_CR4, &cr4);
|
|
if (err) {
|
|
printf("failed to read CR4\n");
|
|
exit(1);
|
|
}
|
|
err = uc_reg_read(uc, UC_X86_REG_MSR, &msr);
|
|
if (err) {
|
|
printf("failed to read MSR\n");
|
|
exit(1);
|
|
}
|
|
|
|
cr0 |= 1; // enable protected mode
|
|
cr0 |= 1l << 31; // enable paging
|
|
cr4 |= 1l << 5; // enable physical address extension
|
|
msr.value |= 1l << 8; // enable long mode
|
|
|
|
err = uc_reg_write(uc, UC_X86_REG_CR0, &cr0);
|
|
if (err) {
|
|
printf("failed to write CR0\n");
|
|
exit(1);
|
|
}
|
|
err = uc_reg_write(uc, UC_X86_REG_CR4, &cr4);
|
|
if (err) {
|
|
printf("failed to write CR4\n");
|
|
exit(1);
|
|
}
|
|
err = uc_reg_write(uc, UC_X86_REG_MSR, &msr);
|
|
if (err) {
|
|
printf("failed to write MSR\n");
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
static void x86_mmu_pt_set(uc_engine *uc, uint64_t vaddr, uint64_t paddr,
|
|
uint64_t tlb_base)
|
|
{
|
|
uint64_t pto = ((vaddr & 0x000000001ff000) >> 12) * 8;
|
|
uint32_t pte = (paddr) | 1 | (1 << 2);
|
|
uc_mem_write(uc, tlb_base + 0x3000 + pto, &pte, sizeof(pte));
|
|
}
|
|
|
|
static void x86_mmu_syscall_callback(uc_engine *uc, void *userdata)
|
|
{
|
|
uc_err err;
|
|
bool *parrent_done = userdata;
|
|
uint64_t rax;
|
|
err = uc_reg_read(uc, UC_X86_REG_RAX, &rax);
|
|
if (err) {
|
|
printf("failed to read rax\n");
|
|
exit(1);
|
|
}
|
|
switch (rax) {
|
|
case 57:
|
|
/* fork */
|
|
break;
|
|
case 60:
|
|
/* exit */
|
|
*parrent_done = true;
|
|
uc_emu_stop(uc);
|
|
return;
|
|
default:
|
|
printf("unknown syscall");
|
|
exit(1);
|
|
}
|
|
|
|
if (!(*parrent_done)) {
|
|
rax = 27;
|
|
err = uc_reg_write(uc, UC_X86_REG_RAX, &rax);
|
|
if (err) {
|
|
printf("failed to write rax\n");
|
|
exit(1);
|
|
}
|
|
uc_emu_stop(uc);
|
|
}
|
|
}
|
|
|
|
void cpu_tlb(void)
|
|
{
|
|
uint64_t tlb_base = 0x3000;
|
|
uint64_t rax, rip;
|
|
bool parrent_done = false;
|
|
uint64_t parrent, child;
|
|
uc_context *context;
|
|
uc_engine *uc;
|
|
uc_err err;
|
|
uc_hook h1, h2;
|
|
|
|
printf("Emulate x86 amd64 code with mmu enabled and switch mappings\n");
|
|
|
|
err = uc_open(UC_ARCH_X86, UC_MODE_64, &uc);
|
|
if (err) {
|
|
printf("Failed on uc_open() with error returned: %u\n", err);
|
|
exit(1);
|
|
}
|
|
uc_ctl_tlb_mode(uc, UC_TLB_CPU);
|
|
err = uc_context_alloc(uc, &context);
|
|
if (err) {
|
|
printf("Failed on uc_context_alloc() with error returned: %u\n", err);
|
|
exit(1);
|
|
}
|
|
|
|
err = uc_hook_add(uc, &h1, UC_HOOK_INSN, &x86_mmu_syscall_callback,
|
|
&parrent_done, 1, 0, UC_X86_INS_SYSCALL);
|
|
if (err) {
|
|
printf("Failed on uc_hook_add() with error returned: %u\n", err);
|
|
exit(1);
|
|
}
|
|
|
|
// Memory hooks are called after the mmu translation, so hook the physicall
|
|
// addresses
|
|
err = uc_hook_add(uc, &h2, UC_HOOK_MEM_WRITE, &mmu_write_callback, NULL,
|
|
0x1000, 0x3000);
|
|
if (err) {
|
|
printf("Faled on uc_hook_add() with error returned: %u\n", err);
|
|
}
|
|
|
|
printf("map code\n");
|
|
err = uc_mem_map(uc, 0x0, 0x1000, UC_PROT_ALL); // Code
|
|
if (err) {
|
|
printf("Failed on uc_mem_map() with error return: %u\n", err);
|
|
exit(1);
|
|
}
|
|
err = uc_mem_write(uc, 0x0, code, sizeof(code) - 1);
|
|
if (err) {
|
|
printf("Failed on uc_mem_wirte() with error return: %u\n", err);
|
|
exit(1);
|
|
}
|
|
printf("map parrent memory\n");
|
|
err = uc_mem_map(uc, 0x1000, 0x1000, UC_PROT_ALL); // Parrent
|
|
if (err) {
|
|
printf("Failed on uc_mem_map() with error return: %u\n", err);
|
|
exit(1);
|
|
}
|
|
printf("map child memory\n");
|
|
err = uc_mem_map(uc, 0x2000, 0x1000, UC_PROT_ALL); // Child
|
|
if (err) {
|
|
printf("failed to map child memory\n");
|
|
exit(1);
|
|
}
|
|
printf("map tlb memory\n");
|
|
err = uc_mem_map(uc, tlb_base, 0x4000, UC_PROT_ALL); // TLB
|
|
if (err) {
|
|
printf("failed to map memory for tlb\n");
|
|
exit(1);
|
|
}
|
|
|
|
printf("set up the tlb\n");
|
|
x86_mmu_prepare_tlb(uc, 0x0, tlb_base);
|
|
x86_mmu_pt_set(uc, 0x2000, 0x0, tlb_base);
|
|
x86_mmu_pt_set(uc, 0x4000, 0x1000, tlb_base);
|
|
|
|
err = uc_ctl_flush_tlb(uc);
|
|
if (err) {
|
|
printf("failed to flush tlb\n");
|
|
exit(1);
|
|
}
|
|
printf("run the parrent\n");
|
|
err = uc_emu_start(uc, 0x2000, 0x0, 0, 0);
|
|
if (err) {
|
|
printf("failed to run parrent\n");
|
|
exit(1);
|
|
}
|
|
|
|
printf("save the context for the child\n");
|
|
err = uc_context_save(uc, context);
|
|
printf("finish the parrent\n");
|
|
err = uc_reg_read(uc, UC_X86_REG_RIP, &rip);
|
|
if (err) {
|
|
printf("failed to read rip\n");
|
|
exit(1);
|
|
}
|
|
|
|
err = uc_emu_start(uc, rip, 0x0, 0, 0);
|
|
if (err) {
|
|
printf("failed to flush tlb\n");
|
|
exit(1);
|
|
}
|
|
|
|
printf("restore the context for the child\n");
|
|
err = uc_context_restore(uc, context);
|
|
if (err) {
|
|
printf("failed to restore context\n");
|
|
exit(1);
|
|
}
|
|
x86_mmu_prepare_tlb(uc, 0x0, tlb_base);
|
|
x86_mmu_pt_set(uc, 0x4000, 0x2000, tlb_base);
|
|
rax = 0;
|
|
err = uc_reg_write(uc, UC_X86_REG_RAX, &rax);
|
|
if (err) {
|
|
printf("failed to write rax\n");
|
|
exit(1);
|
|
}
|
|
err = uc_ctl_flush_tlb(uc);
|
|
if (err) {
|
|
printf("failed to flush tlb\n");
|
|
exit(1);
|
|
}
|
|
|
|
err = uc_emu_start(uc, rip, 0x0, 0, 0);
|
|
if (err) {
|
|
printf("failed to run child\n");
|
|
exit(1);
|
|
}
|
|
err = uc_mem_read(uc, 0x1000, &parrent, sizeof(parrent));
|
|
if (err) {
|
|
printf("failed to read from parrent memory\n");
|
|
exit(1);
|
|
}
|
|
err = uc_mem_read(uc, 0x2000, &child, sizeof(child));
|
|
if (err) {
|
|
printf("failed to read from child memory\n");
|
|
exit(1);
|
|
}
|
|
printf("parrent result == %lu\n", parrent);
|
|
printf("child result == %lu\n", child);
|
|
uc_close(uc);
|
|
}
|
|
|
|
static bool virtual_tlb_callback(uc_engine *uc, uint64_t addr, uc_mem_type type,
|
|
uc_tlb_entry *result, void *user_data)
|
|
{
|
|
bool *parrent_done = user_data;
|
|
printf("tlb lookup for address: 0x%lX\n", addr);
|
|
switch (addr & ~(0xfff)) {
|
|
case 0x2000:
|
|
result->paddr = 0x0;
|
|
result->perms = UC_PROT_EXEC;
|
|
return true;
|
|
case 0x4000:
|
|
if (*parrent_done) {
|
|
result->paddr = 0x2000;
|
|
} else {
|
|
result->paddr = 0x1000;
|
|
}
|
|
result->perms = UC_PROT_READ | UC_PROT_WRITE;
|
|
return true;
|
|
default:
|
|
break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void virtual_tlb(void)
|
|
{
|
|
uint64_t rax, rip;
|
|
bool parrent_done = false;
|
|
uint64_t parrent, child;
|
|
uc_context *context;
|
|
uc_engine *uc;
|
|
uc_err err;
|
|
uc_hook h1, h2, h3;
|
|
|
|
printf("Emulate x86 amd64 code with virtual mmu\n");
|
|
|
|
err = uc_open(UC_ARCH_X86, UC_MODE_64, &uc);
|
|
if (err) {
|
|
printf("Failed on uc_open() with error returned: %u\n", err);
|
|
exit(1);
|
|
}
|
|
uc_ctl_tlb_mode(uc, UC_TLB_VIRTUAL);
|
|
err = uc_context_alloc(uc, &context);
|
|
if (err) {
|
|
printf("Failed on uc_context_alloc() with error returned: %u\n", err);
|
|
exit(1);
|
|
}
|
|
|
|
err = uc_hook_add(uc, &h1, UC_HOOK_INSN, &x86_mmu_syscall_callback,
|
|
&parrent_done, 1, 0, UC_X86_INS_SYSCALL);
|
|
if (err) {
|
|
printf("Failed on uc_hook_add() with error returned: %u\n", err);
|
|
exit(1);
|
|
}
|
|
|
|
// Memory hooks are called after the mmu translation, so hook the physicall
|
|
// addresses
|
|
err = uc_hook_add(uc, &h2, UC_HOOK_MEM_WRITE, &mmu_write_callback, NULL,
|
|
0x1000, 0x3000);
|
|
if (err) {
|
|
printf("Faled on uc_hook_add() with error returned: %u\n", err);
|
|
}
|
|
|
|
printf("map code\n");
|
|
err = uc_mem_map(uc, 0x0, 0x1000, UC_PROT_ALL); // Code
|
|
if (err) {
|
|
printf("Failed on uc_mem_map() with error return: %u\n", err);
|
|
exit(1);
|
|
}
|
|
err = uc_mem_write(uc, 0x0, code, sizeof(code) - 1);
|
|
if (err) {
|
|
printf("Failed on uc_mem_wirte() with error return: %u\n", err);
|
|
exit(1);
|
|
}
|
|
printf("map parrent memory\n");
|
|
err = uc_mem_map(uc, 0x1000, 0x1000, UC_PROT_ALL); // Parrent
|
|
if (err) {
|
|
printf("Failed on uc_mem_map() with error return: %u\n", err);
|
|
exit(1);
|
|
}
|
|
printf("map child memory\n");
|
|
err = uc_mem_map(uc, 0x2000, 0x1000, UC_PROT_ALL); // Child
|
|
if (err) {
|
|
printf("failed to map child memory\n");
|
|
exit(1);
|
|
}
|
|
|
|
err = uc_hook_add(uc, &h3, UC_HOOK_TLB_FILL, virtual_tlb_callback,
|
|
&parrent_done, 1, 0);
|
|
|
|
printf("run the parrent\n");
|
|
err = uc_emu_start(uc, 0x2000, 0x0, 0, 0);
|
|
if (err) {
|
|
printf("failed to run parrent\n");
|
|
exit(1);
|
|
}
|
|
|
|
printf("save the context for the child\n");
|
|
err = uc_context_save(uc, context);
|
|
printf("finish the parrent\n");
|
|
err = uc_reg_read(uc, UC_X86_REG_RIP, &rip);
|
|
if (err) {
|
|
printf("failed to read rip\n");
|
|
exit(1);
|
|
}
|
|
|
|
err = uc_emu_start(uc, rip, 0x0, 0, 0);
|
|
if (err) {
|
|
printf("failed to flush tlb\n");
|
|
exit(1);
|
|
}
|
|
|
|
printf("restore the context for the child\n");
|
|
err = uc_context_restore(uc, context);
|
|
if (err) {
|
|
printf("failed to restore context\n");
|
|
exit(1);
|
|
}
|
|
rax = 0;
|
|
parrent_done = true;
|
|
err = uc_reg_write(uc, UC_X86_REG_RAX, &rax);
|
|
if (err) {
|
|
printf("failed to write rax\n");
|
|
exit(1);
|
|
}
|
|
err = uc_ctl_flush_tlb(uc);
|
|
if (err) {
|
|
printf("failed to flush tlb\n");
|
|
exit(1);
|
|
}
|
|
|
|
err = uc_emu_start(uc, rip, 0x0, 0, 0);
|
|
if (err) {
|
|
printf("failed to run child\n");
|
|
exit(1);
|
|
}
|
|
err = uc_mem_read(uc, 0x1000, &parrent, sizeof(parrent));
|
|
if (err) {
|
|
printf("failed to read from parrent memory\n");
|
|
exit(1);
|
|
}
|
|
err = uc_mem_read(uc, 0x2000, &child, sizeof(child));
|
|
if (err) {
|
|
printf("failed to read from child memory\n");
|
|
exit(1);
|
|
}
|
|
printf("parrent result == %lu\n", parrent);
|
|
printf("child result == %lu\n", child);
|
|
uc_close(uc);
|
|
}
|
|
|
|
int main(void)
|
|
{
|
|
cpu_tlb();
|
|
virtual_tlb();
|
|
}
|