void test_empty_and_free() {
asm_t as1 = as_empty();
as_free(&as1);
asm_p as2 = &(asm_t){ 0 };
as_free(as2);
}
void test_instructions_for_call() {
asm_p as = &(asm_t){ 0 };
char* disassembly = NULL;
as_free(as);
as_call(as, as_disp(0x7abbccdd));
as_call(as, RAX);
as_ret(as, 0);
as_ret(as, 16);
disassembly = disassemble(as);
st_check_str(disassembly,
"call 0x7afbcce2\n"
"call rax\n"
"ret \n"
"ret 0x10\n"
);
as_free(as);
as_enter(as, 65, 0);
as_leave(as);
as_enter(as, 0, 0);
as_leave(as);
disassembly = disassemble(as);
st_check_str(disassembly,
"enter 0x41,0x0\n"
"leave \n"
"enter 0x0,0x0\n"
"leave \n"
);
as_free(as);
free(disassembly);
}
void test_write_with_vars() {
asm_p as = &(asm_t){ 0 };
as_write_with_vars(as, "0010 10dw", (asm_var_t[]){
{ "d", 1 },
{ "w", 0 },
{ "rrr", 0b111 },
{ NULL, 0 }
});
st_check( code_cmp(as, (uint8_t[]){ 0b00101010 }, 1) );
as_free(as);
as_write_with_vars(as, "mm rrr bbb", (asm_var_t[]){
{ "mm", 0b10 },
{ "rrr", 0b110 },
{ "bbb", 0b001 },
{ NULL, 0 }
});
st_check( code_cmp(as, (uint8_t[]){ 0b10110001 }, 1) );
as_free(as);
as_write_with_vars(as, "bbb b 00 bb", (asm_var_t[]){
{ "b", 0b1 },
{ "bb", 0b10 },
{ "bbb", 0b001 },
{ NULL, 0 }
});
st_check( code_cmp(as, (uint8_t[]){ 0b00110010 }, 1) );
as_free(as);
}
void test_jump_instructions() {
asm_p as = &(asm_t){ 0 };
char* disassembly = NULL;
as_free(as);
as_jmp(as, as_disp(0x11223344));
for(size_t i = 0; i < 16; i++)
as_jmp(as, as_reg(8, i));
disassembly = disassemble(as);
st_check_str(disassembly,
"jmp 0x11623349\n"
"jmp rax\n"
"jmp rcx\n"
"jmp rdx\n"
"jmp rbx\n"
"jmp rsp\n"
"jmp rbp\n"
"jmp rsi\n"
"jmp rdi\n"
"jmp r8\n"
"jmp r9\n"
"jmp r10\n"
"jmp r11\n"
"jmp r12\n"
"jmp r13\n"
"jmp r14\n"
"jmp r15\n"
);
as_free(as);
for(size_t i = 0; i < 16; i++)
as_jmp(as, as_mem_rd(8, as_reg(8, i), 0xbeba));
disassembly = disassemble(as);
st_check_str(disassembly,
"jmp QWORD PTR [rax+0xbeba]\n"
"jmp QWORD PTR [rcx+0xbeba]\n"
"jmp QWORD PTR [rdx+0xbeba]\n"
"jmp QWORD PTR [rbx+0xbeba]\n"
"jmp QWORD PTR [rsp+0xbeba]\n"
"jmp QWORD PTR [rbp+0xbeba]\n"
"jmp QWORD PTR [rsi+0xbeba]\n"
"jmp QWORD PTR [rdi+0xbeba]\n"
"jmp QWORD PTR [r8+0xbeba]\n"
"jmp QWORD PTR [r9+0xbeba]\n"
"jmp QWORD PTR [r10+0xbeba]\n"
"jmp QWORD PTR [r11+0xbeba]\n"
"jmp QWORD PTR [r12+0xbeba]\n"
"jmp QWORD PTR [r13+0xbeba]\n"
"jmp QWORD PTR [r14+0xbeba]\n"
"jmp QWORD PTR [r15+0xbeba]\n"
);
as_free(as);
free(disassembly);
}
static PE
name2psap (DN dn)
{
int i;
AttributeType at;
PE pe;
static struct ds_read_arg read_arg = {
default_common_args,
NULLDN, /* read_arg DN */
{
/* entry info selection */
FALSE,
NULLATTR,
EIS_ATTRIBUTESANDVALUES
}
};
struct DSError error;
struct ds_read_result result;
if ((at = AttrT_new (DSAADDRESS_OID)) == NULLAttrT) {
PY_advise (NULLCP, "build of attribute failed (%s)", DSAADDRESS_OID);
return NULLPE;
}
read_arg.rda_common.ca_servicecontrol.svc_prio = SVC_PRIO_HIGH;
read_arg.rda_object = dn;
read_arg.rda_eis.eis_select = as_comp_new (AttrT_cpy (at), NULLAV,
NULLACL_INFO);
i = ds_read (&read_arg, &error, &result);
AttrT_free (at);
as_free (read_arg.rda_eis.eis_select);
if (i != DS_OK) {
PY_advise (NULLCP, "DAP lookup failed (%s)", dn2str (dn));
return NULLPE;
}
if (result.rdr_entry.ent_attr == NULLATTR) {
PY_advise (NULLCP, "no '%s' attribute in entry '%s'",
DSAADDRESS_OID, dn2str (dn));
return NULLPE;
}
pe = grab_pe (&result.rdr_entry.ent_attr -> attr_value -> avseq_av);
as_free (result.rdr_entry.ent_attr);
return pe;
}
int
ems_free (struct entrymod *emp)
{
if(emp == NULLMOD)
return;
ems_free(emp->em_next);
as_free(emp->em_what);
free((char *)emp);
}
void test_write() {
asm_p as = &(asm_t){ 0 };
as_write(as, "0000 1111");
st_check( code_cmp(as, (uint8_t[]){ 0x0f }, 1) );
as_free(as);
as_write(as, "0000 1111 : 1000 1111");
st_check( code_cmp(as, (uint8_t[]){ 0x0f, 0x8f }, 2) );
as_free(as);
as_write(as, "0100 WRXB", 0, 1, 0, 1);
st_check( code_cmp(as, (uint8_t[]){ 0b01000101 }, 1) );
as_free(as);
as_write(as, "mm rrr bbb", 0b00, 0b111, 0b110);
st_check( code_cmp(as, (uint8_t[]){ 0b00111110 }, 1) );
as_free(as);
as_write(as, "xxxx xxxx", 0b10110001);
st_check( code_cmp(as, (uint8_t[]){ 0b10110001 }, 1) );
as_free(as);
as_write(as, "0000 1111 : xxxx 1111", 0b1010);
st_check( code_cmp(as, (uint8_t[]){ 0x0f, 0b10101111 }, 2) );
as_free(as);
as_write(as, "1000 0001 : %8d", 0xab);
st_check( code_cmp(as, (uint8_t[]){ 0b10000001, 0xab }, 2) );
as_free(as);
// Remember, integers are little-endian in memory
as_write(as, "1000 0001 : %16d", 0xaabb);
st_check( code_cmp(as, (uint8_t[]){ 0b10000001, 0xbb, 0xaa }, 3) );
as_free(as);
as_write(as, "1000 0001 : %32d", 0xaabbccdd);
st_check( code_cmp(as, (uint8_t[]){ 0b10000001, 0xdd, 0xcc, 0xbb, 0xaa }, 5) );
as_free(as);
as_write(as, "1000 0001 : %64d", 0xaabbccdd11223344);
st_check( code_cmp(as, (uint8_t[]){ 0b10000001, 0x44, 0x33, 0x22, 0x11, 0xdd, 0xcc, 0xbb, 0xaa }, 9) );
as_free(as);
}
void test_instructions_for_if_and_backpatching() {
int status_code;
asm_p as = &(asm_t){ 0 };
asm_slot_t to_false_case, to_end;
as_mov(as, RAX, as_imm(8, 0));
as_cmp(as, RAX, as_imm(8, 0));
to_false_case = as_jmp_cc(as, CC_NOT_EQUAL, as_disp(0));
as_mov(as, R15, as_imm(8, 43));
to_end = as_jmp(as, as_disp(0));
as_patch_slot(as, to_false_case, as_next_instr_offset(as));
as_mov(as, R15, as_imm(8, 17));
as_patch_slot(as, to_end, as_next_instr_offset(as));
as_mov(as, RAX, as_imm(8, 60));
as_mov(as, RDI, R15);
as_syscall(as);
as_save_elf(as, 4 * 1024 * 1024, 512 * 1024 * 1024, "test_instructions_for_if_true.elf");
as_free(as);
status_code = run_and_delete("test_instructions_for_if_true.elf", "./test_instructions_for_if_true.elf", NULL);
st_check_int(status_code, 43);
as_mov(as, RAX, as_imm(8, 5));
as_cmp(as, RAX, as_imm(8, 0));
to_false_case = as_jmp_cc(as, CC_NOT_EQUAL, as_disp(0));
as_mov(as, R15, as_imm(8, 43));
to_end = as_jmp(as, as_disp(0));
as_patch_slot(as, to_false_case, as_next_instr_offset(as));
as_mov(as, R15, as_imm(8, 17));
as_patch_slot(as, to_end, as_next_instr_offset(as));
as_mov(as, RAX, as_imm(8, 60));
as_mov(as, RDI, R15);
as_syscall(as);
as_save_elf(as, 4 * 1024 * 1024, 512 * 1024 * 1024, "test_instructions_for_if_false.elf");
as_free(as);
status_code = run_and_delete("test_instructions_for_if_false.elf", "./test_instructions_for_if_false.elf", NULL);
st_check_int(status_code, 17);
}
void test_basic_instructions() {
asm_p as = &(asm_t){ 0 };
char* disassembly = NULL;
as_free(as);
as_syscall(as);
disassembly = disassemble(as);
st_check_str(disassembly,
"syscall \n"
);
as_free(as);
for(size_t i = 0; i < 16; i++)
as_mov(as, as_reg(8, i), as_imm(8, 0x1122334455667788));
disassembly = disassemble(as);
st_check_str(disassembly,
"movabs rax,0x1122334455667788\n"
"movabs rcx,0x1122334455667788\n"
"movabs rdx,0x1122334455667788\n"
"movabs rbx,0x1122334455667788\n"
"movabs rsp,0x1122334455667788\n"
"movabs rbp,0x1122334455667788\n"
"movabs rsi,0x1122334455667788\n"
"movabs rdi,0x1122334455667788\n"
"movabs r8,0x1122334455667788\n"
"movabs r9,0x1122334455667788\n"
"movabs r10,0x1122334455667788\n"
"movabs r11,0x1122334455667788\n"
"movabs r12,0x1122334455667788\n"
"movabs r13,0x1122334455667788\n"
"movabs r14,0x1122334455667788\n"
"movabs r15,0x1122334455667788\n"
);
free(disassembly);
}
void
freeOrgs (struct namelist **listpp)
{
struct namelist * x, * y;
x = *listpp;
while (x != NULLLIST) {
if (x->name != NULLCP)
free(x->name);
as_free(x->ats);
y = x->next;
free((char *)x);
x = y;
}
*listpp = NULLLIST;
}
void test_write_elf() {
asm_p as = &(asm_t){ 0 };
size_t code_vaddr = 4 * 1024 * 1024;
size_t data_vaddr = 512 * 1024 * 1024;
const char* text_ptr = "Hello World!\n";
size_t text_len = strlen(text_ptr);
size_t text_offset = as_data(as, text_ptr, text_len);
// mov RAX, 1 // write syscall
as_write(as, "0100 000B : 1011 wrrr : %8d", 0, 0, 0b000, 1);
// mov RDI, 1 // stdout, RDI = R7 = 0b0111
as_write(as, "0100 000B : 1011 wrrr : %8d", 0, 0, 0b111, 1);
// mov RSI, text_vaddr // text_ptr, RSI = R6 = 0b0110
as_write(as, "0100 000B : 1011 wrrr : %32d", 0, 1, 0b110, data_vaddr + text_offset);
// mov RDX, text_len // text len, RDX = R2 = 0b0010
as_write(as, "0100 000B : 1011 wrrr : %32d", 0, 1, 0b010, text_len);
// syscall
as_write(as, "0000 1111 : 0000 0101");
// mov RAX, 60 // exit syscall
as_write(as, "0100 000B : 1011 wrrr : %8d", 0, 0, 0b000, 60);
// mov RDI, 1 // exit code, RDI = R7 = 0b0111
as_write(as, "0100 000B : 1011 wrrr : %8d", 0, 0, 0b111, 1);
// syscall
as_write(as, "0000 1111 : 0000 0101");
as_save_elf(as, code_vaddr, data_vaddr, "test_write_elf.elf");
as_free(as);
char* output = NULL;
int status_code = run_and_delete("test_write_elf.elf", "./test_write_elf.elf", &output);
st_check_int(status_code, 1);
st_check_str(output, text_ptr);
free(output);
}
static Attr_Sequence
dsa_control_info (void) {
extern int slave_edbs;
extern int master_edbs;
extern int local_master_size;
extern int local_slave_size;
extern int local_cache_size;
char buffer [LINESIZE];
Attr_Sequence as;
sprintf (buffer,"%d Master entries (in %d EDBs), %d Slave entries (in %d EDBs), %d Cached entries",
local_master_size,master_edbs,local_slave_size,slave_edbs,local_cache_size);
as=as_comp_alloc();
as->attr_acl = NULLACL_INFO;
as->attr_type = at_control;
as->attr_link = NULLATTR;
if ((as->attr_value = str2avs (buffer,as->attr_type)) == NULLAV) {
as_free (as);
return (NULLATTR);
}
return (as);
}
void test_byte_registers() {
asm_p as = &(asm_t){ 0 };
char* disassembly = NULL;
// reg reg
as_free(as);
for(size_t i = 0; i < 16; i++)
as_mov(as, as_reg(1, i), as_reg(1, i));
disassembly = disassemble(as);
st_check_str(disassembly,
"mov al,al\n"
"mov cl,cl\n"
"mov dl,dl\n"
"mov bl,bl\n"
"mov spl,spl\n"
"mov bpl,bpl\n"
"mov sil,sil\n"
"mov dil,dil\n"
"mov r8b,r8b\n"
"mov r9b,r9b\n"
"mov r10b,r10b\n"
"mov r11b,r11b\n"
"mov r12b,r12b\n"
"mov r13b,r13b\n"
"mov r14b,r14b\n"
"mov r15b,r15b\n"
);
// reg [RIP + displ]
as_free(as);
for(size_t i = 0; i < 16; i++)
as_mov(as, as_reg(1, i), as_mem_rel(1, 0x7abbccdd));
disassembly = disassemble(as);
st_check_str(disassembly,
"mov al,BYTE PTR [rip+0x7abbccdd] # 0x7afbcce4\n"
"mov cl,BYTE PTR [rip+0x7abbccdd] # 0x7afbcceb\n"
"mov dl,BYTE PTR [rip+0x7abbccdd] # 0x7afbccf2\n"
"mov bl,BYTE PTR [rip+0x7abbccdd] # 0x7afbccf9\n"
"mov spl,BYTE PTR [rip+0x7abbccdd] # 0x7afbcd00\n"
"mov bpl,BYTE PTR [rip+0x7abbccdd] # 0x7afbcd07\n"
"mov sil,BYTE PTR [rip+0x7abbccdd] # 0x7afbcd0e\n"
"mov dil,BYTE PTR [rip+0x7abbccdd] # 0x7afbcd15\n"
"mov r8b,BYTE PTR [rip+0x7abbccdd] # 0x7afbcd1c\n"
"mov r9b,BYTE PTR [rip+0x7abbccdd] # 0x7afbcd23\n"
"mov r10b,BYTE PTR [rip+0x7abbccdd] # 0x7afbcd2a\n"
"mov r11b,BYTE PTR [rip+0x7abbccdd] # 0x7afbcd31\n"
"mov r12b,BYTE PTR [rip+0x7abbccdd] # 0x7afbcd38\n"
"mov r13b,BYTE PTR [rip+0x7abbccdd] # 0x7afbcd3f\n"
"mov r14b,BYTE PTR [rip+0x7abbccdd] # 0x7afbcd46\n"
"mov r15b,BYTE PTR [rip+0x7abbccdd] # 0x7afbcd4d\n"
);
// reg [displ]
as_free(as);
for(size_t i = 0; i < 16; i++)
as_mov(as, as_reg(1, i), as_mem_d(1, 0x7abbccdd));
disassembly = disassemble(as);
st_check_str(disassembly,
"mov al,BYTE PTR ds:0x7abbccdd\n"
"mov cl,BYTE PTR ds:0x7abbccdd\n"
"mov dl,BYTE PTR ds:0x7abbccdd\n"
"mov bl,BYTE PTR ds:0x7abbccdd\n"
"mov spl,BYTE PTR ds:0x7abbccdd\n"
"mov bpl,BYTE PTR ds:0x7abbccdd\n"
"mov sil,BYTE PTR ds:0x7abbccdd\n"
"mov dil,BYTE PTR ds:0x7abbccdd\n"
"mov r8b,BYTE PTR ds:0x7abbccdd\n"
"mov r9b,BYTE PTR ds:0x7abbccdd\n"
"mov r10b,BYTE PTR ds:0x7abbccdd\n"
"mov r11b,BYTE PTR ds:0x7abbccdd\n"
"mov r12b,BYTE PTR ds:0x7abbccdd\n"
"mov r13b,BYTE PTR ds:0x7abbccdd\n"
"mov r14b,BYTE PTR ds:0x7abbccdd\n"
"mov r15b,BYTE PTR ds:0x7abbccdd\n"
);
// reg [reg + displ]
as_free(as);
for(size_t i = 0; i < 16; i++)
as_mov(as, as_reg(1, i), as_mem_rd(1, as_reg(8, i), 0x7abbccdd));
disassembly = disassemble(as);
st_check_str(disassembly,
"mov al,BYTE PTR [rax+0x7abbccdd]\n"
"mov cl,BYTE PTR [rcx+0x7abbccdd]\n"
"mov dl,BYTE PTR [rdx+0x7abbccdd]\n"
"mov bl,BYTE PTR [rbx+0x7abbccdd]\n"
"mov spl,BYTE PTR [rsp+0x7abbccdd]\n"
"mov bpl,BYTE PTR [rbp+0x7abbccdd]\n"
"mov sil,BYTE PTR [rsi+0x7abbccdd]\n"
"mov dil,BYTE PTR [rdi+0x7abbccdd]\n"
"mov r8b,BYTE PTR [r8+0x7abbccdd]\n"
"mov r9b,BYTE PTR [r9+0x7abbccdd]\n"
"mov r10b,BYTE PTR [r10+0x7abbccdd]\n"
"mov r11b,BYTE PTR [r11+0x7abbccdd]\n"
"mov r12b,BYTE PTR [r12+0x7abbccdd]\n"
"mov r13b,BYTE PTR [r13+0x7abbccdd]\n"
"mov r14b,BYTE PTR [r14+0x7abbccdd]\n"
"mov r15b,BYTE PTR [r15+0x7abbccdd]\n"
);
as_free(as);
for(size_t i = 0; i < 16; i++)
as_mul(as, as_reg(1, i));
disassembly = disassemble(as);
st_check_str(disassembly,
"mul al\n"
"mul cl\n"
"mul dl\n"
"mul bl\n"
"mul spl\n"
"mul bpl\n"
"mul sil\n"
"mul dil\n"
"mul r8b\n"
"mul r9b\n"
"mul r10b\n"
"mul r11b\n"
"mul r12b\n"
"mul r13b\n"
"mul r14b\n"
"mul r15b\n"
);
as_free(as);
for(size_t i = 0; i < 16; i++)
as_cmp(as, as_reg(1, i), as_reg(1, i));
disassembly = disassemble(as);
st_check_str(disassembly,
"cmp al,al\n"
"cmp cl,cl\n"
"cmp dl,dl\n"
"cmp bl,bl\n"
"cmp spl,spl\n"
"cmp bpl,bpl\n"
"cmp sil,sil\n"
"cmp dil,dil\n"
"cmp r8b,r8b\n"
"cmp r9b,r9b\n"
"cmp r10b,r10b\n"
"cmp r11b,r11b\n"
"cmp r12b,r12b\n"
"cmp r13b,r13b\n"
"cmp r14b,r14b\n"
"cmp r15b,r15b\n"
);
as_free(as);
for(size_t i = 0; i < 16; i++)
as_cmp(as, as_reg(1, i), as_mem_rel(1, 0x7abbccdd));
disassembly = disassemble(as);
st_check_str(disassembly,
"cmp al,BYTE PTR [rip+0x7abbccdd] # 0x7afbcce4\n"
"cmp cl,BYTE PTR [rip+0x7abbccdd] # 0x7afbcceb\n"
"cmp dl,BYTE PTR [rip+0x7abbccdd] # 0x7afbccf2\n"
"cmp bl,BYTE PTR [rip+0x7abbccdd] # 0x7afbccf9\n"
"cmp spl,BYTE PTR [rip+0x7abbccdd] # 0x7afbcd00\n"
"cmp bpl,BYTE PTR [rip+0x7abbccdd] # 0x7afbcd07\n"
"cmp sil,BYTE PTR [rip+0x7abbccdd] # 0x7afbcd0e\n"
"cmp dil,BYTE PTR [rip+0x7abbccdd] # 0x7afbcd15\n"
"cmp r8b,BYTE PTR [rip+0x7abbccdd] # 0x7afbcd1c\n"
"cmp r9b,BYTE PTR [rip+0x7abbccdd] # 0x7afbcd23\n"
"cmp r10b,BYTE PTR [rip+0x7abbccdd] # 0x7afbcd2a\n"
"cmp r11b,BYTE PTR [rip+0x7abbccdd] # 0x7afbcd31\n"
"cmp r12b,BYTE PTR [rip+0x7abbccdd] # 0x7afbcd38\n"
"cmp r13b,BYTE PTR [rip+0x7abbccdd] # 0x7afbcd3f\n"
"cmp r14b,BYTE PTR [rip+0x7abbccdd] # 0x7afbcd46\n"
"cmp r15b,BYTE PTR [rip+0x7abbccdd] # 0x7afbcd4d\n"
);
as_free(as);
free(disassembly);
}
void test_addressing_modes() {
asm_p as = &(asm_t){ 0 };
char* disassembly = NULL;
// reg reg
as_free(as);
for(size_t i = 0; i < 16; i++)
as_mov(as, as_reg(8, i), as_reg(8, i));
disassembly = disassemble(as);
st_check_str(disassembly,
"mov rax,rax\n"
"mov rcx,rcx\n"
"mov rdx,rdx\n"
"mov rbx,rbx\n"
"mov rsp,rsp\n"
"mov rbp,rbp\n"
"mov rsi,rsi\n"
"mov rdi,rdi\n"
"mov r8,r8\n"
"mov r9,r9\n"
"mov r10,r10\n"
"mov r11,r11\n"
"mov r12,r12\n"
"mov r13,r13\n"
"mov r14,r14\n"
"mov r15,r15\n"
);
// reg [RIP + displ]
as_free(as);
for(size_t i = 0; i < 16; i++)
as_mov(as, as_reg(8, i), as_mem_rel(8, 0xbeba));
disassembly = disassemble(as);
st_check_str(disassembly,
"mov rax,QWORD PTR [rip+0xbeba] # 0x40bec1\n"
"mov rcx,QWORD PTR [rip+0xbeba] # 0x40bec8\n"
"mov rdx,QWORD PTR [rip+0xbeba] # 0x40becf\n"
"mov rbx,QWORD PTR [rip+0xbeba] # 0x40bed6\n"
"mov rsp,QWORD PTR [rip+0xbeba] # 0x40bedd\n"
"mov rbp,QWORD PTR [rip+0xbeba] # 0x40bee4\n"
"mov rsi,QWORD PTR [rip+0xbeba] # 0x40beeb\n"
"mov rdi,QWORD PTR [rip+0xbeba] # 0x40bef2\n"
"mov r8,QWORD PTR [rip+0xbeba] # 0x40bef9\n"
"mov r9,QWORD PTR [rip+0xbeba] # 0x40bf00\n"
"mov r10,QWORD PTR [rip+0xbeba] # 0x40bf07\n"
"mov r11,QWORD PTR [rip+0xbeba] # 0x40bf0e\n"
"mov r12,QWORD PTR [rip+0xbeba] # 0x40bf15\n"
"mov r13,QWORD PTR [rip+0xbeba] # 0x40bf1c\n"
"mov r14,QWORD PTR [rip+0xbeba] # 0x40bf23\n"
"mov r15,QWORD PTR [rip+0xbeba] # 0x40bf2a\n"
);
// reg [displ]
as_free(as);
for(size_t i = 0; i < 16; i++)
as_mov(as, as_reg(8, i), as_mem_d(8, 0xbeba));
disassembly = disassemble(as);
st_check_str(disassembly,
// Funny syntax when disassembling with intel syntax. Looks normal with
// GNU syntax.
"mov rax,QWORD PTR ds:0xbeba\n"
"mov rcx,QWORD PTR ds:0xbeba\n"
"mov rdx,QWORD PTR ds:0xbeba\n"
"mov rbx,QWORD PTR ds:0xbeba\n"
"mov rsp,QWORD PTR ds:0xbeba\n"
"mov rbp,QWORD PTR ds:0xbeba\n"
"mov rsi,QWORD PTR ds:0xbeba\n"
"mov rdi,QWORD PTR ds:0xbeba\n"
"mov r8,QWORD PTR ds:0xbeba\n"
"mov r9,QWORD PTR ds:0xbeba\n"
"mov r10,QWORD PTR ds:0xbeba\n"
"mov r11,QWORD PTR ds:0xbeba\n"
"mov r12,QWORD PTR ds:0xbeba\n"
"mov r13,QWORD PTR ds:0xbeba\n"
"mov r14,QWORD PTR ds:0xbeba\n"
"mov r15,QWORD PTR ds:0xbeba\n"
);
// reg [reg + displ]
as_free(as);
for(size_t i = 0; i < 16; i++)
as_mov(as, as_reg(8, i), as_mem_rd(8, as_reg(8, i), 0xbeba));
disassembly = disassemble(as);
st_check_str(disassembly,
"mov rax,QWORD PTR [rax+0xbeba]\n"
"mov rcx,QWORD PTR [rcx+0xbeba]\n"
"mov rdx,QWORD PTR [rdx+0xbeba]\n"
"mov rbx,QWORD PTR [rbx+0xbeba]\n"
"mov rsp,QWORD PTR [rsp+0xbeba]\n"
"mov rbp,QWORD PTR [rbp+0xbeba]\n"
"mov rsi,QWORD PTR [rsi+0xbeba]\n"
"mov rdi,QWORD PTR [rdi+0xbeba]\n"
"mov r8,QWORD PTR [r8+0xbeba]\n"
"mov r9,QWORD PTR [r9+0xbeba]\n"
"mov r10,QWORD PTR [r10+0xbeba]\n"
"mov r11,QWORD PTR [r11+0xbeba]\n"
"mov r12,QWORD PTR [r12+0xbeba]\n"
"mov r13,QWORD PTR [r13+0xbeba]\n"
"mov r14,QWORD PTR [r14+0xbeba]\n"
"mov r15,QWORD PTR [r15+0xbeba]\n"
);
as_free(as);
free(disassembly);
}
void test_32bit_registers() {
asm_p as = &(asm_t){ 0 };
char* disassembly = NULL;
// reg reg
as_free(as);
for(size_t i = 0; i < 16; i++)
as_mov(as, as_reg(4, i), as_reg(4, i));
disassembly = disassemble(as);
st_check_str(disassembly,
"mov eax,eax\n"
"mov ecx,ecx\n"
"mov edx,edx\n"
"mov ebx,ebx\n"
"mov esp,esp\n"
"mov ebp,ebp\n"
"mov esi,esi\n"
"mov edi,edi\n"
"mov r8d,r8d\n"
"mov r9d,r9d\n"
"mov r10d,r10d\n"
"mov r11d,r11d\n"
"mov r12d,r12d\n"
"mov r13d,r13d\n"
"mov r14d,r14d\n"
"mov r15d,r15d\n"
);
// reg [RIP + displ]
as_free(as);
for(size_t i = 0; i < 16; i++)
as_mov(as, as_reg(4, i), as_mem_rel(4, 0x7abbccdd));
disassembly = disassemble(as);
st_check_str(disassembly,
"mov eax,DWORD PTR [rip+0x7abbccdd] # 0x7afbcce3\n"
"mov ecx,DWORD PTR [rip+0x7abbccdd] # 0x7afbcce9\n"
"mov edx,DWORD PTR [rip+0x7abbccdd] # 0x7afbccef\n"
"mov ebx,DWORD PTR [rip+0x7abbccdd] # 0x7afbccf5\n"
"mov esp,DWORD PTR [rip+0x7abbccdd] # 0x7afbccfb\n"
"mov ebp,DWORD PTR [rip+0x7abbccdd] # 0x7afbcd01\n"
"mov esi,DWORD PTR [rip+0x7abbccdd] # 0x7afbcd07\n"
"mov edi,DWORD PTR [rip+0x7abbccdd] # 0x7afbcd0d\n"
"mov r8d,DWORD PTR [rip+0x7abbccdd] # 0x7afbcd14\n"
"mov r9d,DWORD PTR [rip+0x7abbccdd] # 0x7afbcd1b\n"
"mov r10d,DWORD PTR [rip+0x7abbccdd] # 0x7afbcd22\n"
"mov r11d,DWORD PTR [rip+0x7abbccdd] # 0x7afbcd29\n"
"mov r12d,DWORD PTR [rip+0x7abbccdd] # 0x7afbcd30\n"
"mov r13d,DWORD PTR [rip+0x7abbccdd] # 0x7afbcd37\n"
"mov r14d,DWORD PTR [rip+0x7abbccdd] # 0x7afbcd3e\n"
"mov r15d,DWORD PTR [rip+0x7abbccdd] # 0x7afbcd45\n"
);
// reg [displ]
as_free(as);
for(size_t i = 0; i < 16; i++)
as_mov(as, as_reg(4, i), as_mem_d(4, 0x7abbccdd));
disassembly = disassemble(as);
st_check_str(disassembly,
"mov eax,DWORD PTR ds:0x7abbccdd\n"
"mov ecx,DWORD PTR ds:0x7abbccdd\n"
"mov edx,DWORD PTR ds:0x7abbccdd\n"
"mov ebx,DWORD PTR ds:0x7abbccdd\n"
"mov esp,DWORD PTR ds:0x7abbccdd\n"
"mov ebp,DWORD PTR ds:0x7abbccdd\n"
"mov esi,DWORD PTR ds:0x7abbccdd\n"
"mov edi,DWORD PTR ds:0x7abbccdd\n"
"mov r8d,DWORD PTR ds:0x7abbccdd\n"
"mov r9d,DWORD PTR ds:0x7abbccdd\n"
"mov r10d,DWORD PTR ds:0x7abbccdd\n"
"mov r11d,DWORD PTR ds:0x7abbccdd\n"
"mov r12d,DWORD PTR ds:0x7abbccdd\n"
"mov r13d,DWORD PTR ds:0x7abbccdd\n"
"mov r14d,DWORD PTR ds:0x7abbccdd\n"
"mov r15d,DWORD PTR ds:0x7abbccdd\n"
);
// reg [reg + displ]
as_free(as);
for(size_t i = 0; i < 16; i++)
as_mov(as, as_reg(4, i), as_mem_rd(4, as_reg(8, i), 0x7abbccdd));
disassembly = disassemble(as);
st_check_str(disassembly,
"mov eax,DWORD PTR [rax+0x7abbccdd]\n"
"mov ecx,DWORD PTR [rcx+0x7abbccdd]\n"
"mov edx,DWORD PTR [rdx+0x7abbccdd]\n"
"mov ebx,DWORD PTR [rbx+0x7abbccdd]\n"
"mov esp,DWORD PTR [rsp+0x7abbccdd]\n"
"mov ebp,DWORD PTR [rbp+0x7abbccdd]\n"
"mov esi,DWORD PTR [rsi+0x7abbccdd]\n"
"mov edi,DWORD PTR [rdi+0x7abbccdd]\n"
"mov r8d,DWORD PTR [r8+0x7abbccdd]\n"
"mov r9d,DWORD PTR [r9+0x7abbccdd]\n"
"mov r10d,DWORD PTR [r10+0x7abbccdd]\n"
"mov r11d,DWORD PTR [r11+0x7abbccdd]\n"
"mov r12d,DWORD PTR [r12+0x7abbccdd]\n"
"mov r13d,DWORD PTR [r13+0x7abbccdd]\n"
"mov r14d,DWORD PTR [r14+0x7abbccdd]\n"
"mov r15d,DWORD PTR [r15+0x7abbccdd]\n"
);
as_free(as);
for(size_t i = 0; i < 16; i++)
as_mul(as, as_reg(4, i));
disassembly = disassemble(as);
st_check_str(disassembly,
"mul eax\n"
"mul ecx\n"
"mul edx\n"
"mul ebx\n"
"mul esp\n"
"mul ebp\n"
"mul esi\n"
"mul edi\n"
"mul r8d\n"
"mul r9d\n"
"mul r10d\n"
"mul r11d\n"
"mul r12d\n"
"mul r13d\n"
"mul r14d\n"
"mul r15d\n"
);
as_free(as);
free(disassembly);
}
void test_16bit_registers() {
asm_p as = &(asm_t){ 0 };
char* disassembly = NULL;
// reg reg
as_free(as);
for(size_t i = 0; i < 16; i++)
as_mov(as, as_reg(2, i), as_reg(2, i));
disassembly = disassemble(as);
st_check_str(disassembly,
"mov ax,ax\n"
"mov cx,cx\n"
"mov dx,dx\n"
"mov bx,bx\n"
"mov sp,sp\n"
"mov bp,bp\n"
"mov si,si\n"
"mov di,di\n"
"mov r8w,r8w\n"
"mov r9w,r9w\n"
"mov r10w,r10w\n"
"mov r11w,r11w\n"
"mov r12w,r12w\n"
"mov r13w,r13w\n"
"mov r14w,r14w\n"
"mov r15w,r15w\n"
);
// reg [RIP + displ]
as_free(as);
for(size_t i = 0; i < 16; i++)
as_mov(as, as_reg(2, i), as_mem_rel(2, 0x7abbccdd));
disassembly = disassemble(as);
st_check_str(disassembly,
"mov ax,WORD PTR [rip+0x7abbccdd] # 0x7afbcce4\n"
"mov cx,WORD PTR [rip+0x7abbccdd] # 0x7afbcceb\n"
"mov dx,WORD PTR [rip+0x7abbccdd] # 0x7afbccf2\n"
"mov bx,WORD PTR [rip+0x7abbccdd] # 0x7afbccf9\n"
"mov sp,WORD PTR [rip+0x7abbccdd] # 0x7afbcd00\n"
"mov bp,WORD PTR [rip+0x7abbccdd] # 0x7afbcd07\n"
"mov si,WORD PTR [rip+0x7abbccdd] # 0x7afbcd0e\n"
"mov di,WORD PTR [rip+0x7abbccdd] # 0x7afbcd15\n"
"mov r8w,WORD PTR [rip+0x7abbccdd] # 0x7afbcd1d\n"
"mov r9w,WORD PTR [rip+0x7abbccdd] # 0x7afbcd25\n"
"mov r10w,WORD PTR [rip+0x7abbccdd] # 0x7afbcd2d\n"
"mov r11w,WORD PTR [rip+0x7abbccdd] # 0x7afbcd35\n"
"mov r12w,WORD PTR [rip+0x7abbccdd] # 0x7afbcd3d\n"
"mov r13w,WORD PTR [rip+0x7abbccdd] # 0x7afbcd45\n"
"mov r14w,WORD PTR [rip+0x7abbccdd] # 0x7afbcd4d\n"
"mov r15w,WORD PTR [rip+0x7abbccdd] # 0x7afbcd55\n"
);
// reg [displ]
as_free(as);
for(size_t i = 0; i < 16; i++)
as_mov(as, as_reg(2, i), as_mem_d(2, 0x7abbccdd));
disassembly = disassemble(as);
st_check_str(disassembly,
"mov ax,WORD PTR ds:0x7abbccdd\n"
"mov cx,WORD PTR ds:0x7abbccdd\n"
"mov dx,WORD PTR ds:0x7abbccdd\n"
"mov bx,WORD PTR ds:0x7abbccdd\n"
"mov sp,WORD PTR ds:0x7abbccdd\n"
"mov bp,WORD PTR ds:0x7abbccdd\n"
"mov si,WORD PTR ds:0x7abbccdd\n"
"mov di,WORD PTR ds:0x7abbccdd\n"
"mov r8w,WORD PTR ds:0x7abbccdd\n"
"mov r9w,WORD PTR ds:0x7abbccdd\n"
"mov r10w,WORD PTR ds:0x7abbccdd\n"
"mov r11w,WORD PTR ds:0x7abbccdd\n"
"mov r12w,WORD PTR ds:0x7abbccdd\n"
"mov r13w,WORD PTR ds:0x7abbccdd\n"
"mov r14w,WORD PTR ds:0x7abbccdd\n"
"mov r15w,WORD PTR ds:0x7abbccdd\n"
);
// reg [reg + displ]
as_free(as);
for(size_t i = 0; i < 16; i++)
as_mov(as, as_reg(2, i), as_mem_rd(2, as_reg(8, i), 0x7abbccdd));
disassembly = disassemble(as);
st_check_str(disassembly,
"mov ax,WORD PTR [rax+0x7abbccdd]\n"
"mov cx,WORD PTR [rcx+0x7abbccdd]\n"
"mov dx,WORD PTR [rdx+0x7abbccdd]\n"
"mov bx,WORD PTR [rbx+0x7abbccdd]\n"
"mov sp,WORD PTR [rsp+0x7abbccdd]\n"
"mov bp,WORD PTR [rbp+0x7abbccdd]\n"
"mov si,WORD PTR [rsi+0x7abbccdd]\n"
"mov di,WORD PTR [rdi+0x7abbccdd]\n"
"mov r8w,WORD PTR [r8+0x7abbccdd]\n"
"mov r9w,WORD PTR [r9+0x7abbccdd]\n"
"mov r10w,WORD PTR [r10+0x7abbccdd]\n"
"mov r11w,WORD PTR [r11+0x7abbccdd]\n"
"mov r12w,WORD PTR [r12+0x7abbccdd]\n"
"mov r13w,WORD PTR [r13+0x7abbccdd]\n"
"mov r14w,WORD PTR [r14+0x7abbccdd]\n"
"mov r15w,WORD PTR [r15+0x7abbccdd]\n"
);
as_free(as);
for(size_t i = 0; i < 16; i++)
as_mul(as, as_reg(2, i));
disassembly = disassemble(as);
st_check_str(disassembly,
"mul ax\n"
"mul cx\n"
"mul dx\n"
"mul bx\n"
"mul sp\n"
"mul bp\n"
"mul si\n"
"mul di\n"
"mul r8w\n"
"mul r9w\n"
"mul r10w\n"
"mul r11w\n"
"mul r12w\n"
"mul r13w\n"
"mul r14w\n"
"mul r15w\n"
);
as_free(as);
free(disassembly);
}
void test_arithmetic_instructions() {
asm_p as = &(asm_t){ 0 };
char* disassembly = NULL;
as_free(as);
for(size_t i = 0; i < 16; i++)
as_add(as, as_reg(8, i), as_reg(8, i));
for(size_t i = 0; i < 16; i++)
as_add(as, as_reg(8, i), as_imm(4, 0x7abbccdd));
disassembly = disassemble(as);
st_check_str(disassembly,
"add rax,rax\n"
"add rcx,rcx\n"
"add rdx,rdx\n"
"add rbx,rbx\n"
"add rsp,rsp\n"
"add rbp,rbp\n"
"add rsi,rsi\n"
"add rdi,rdi\n"
"add r8,r8\n"
"add r9,r9\n"
"add r10,r10\n"
"add r11,r11\n"
"add r12,r12\n"
"add r13,r13\n"
"add r14,r14\n"
"add r15,r15\n"
"add rax,0x7abbccdd\n"
"add rcx,0x7abbccdd\n"
"add rdx,0x7abbccdd\n"
"add rbx,0x7abbccdd\n"
"add rsp,0x7abbccdd\n"
"add rbp,0x7abbccdd\n"
"add rsi,0x7abbccdd\n"
"add rdi,0x7abbccdd\n"
"add r8,0x7abbccdd\n"
"add r9,0x7abbccdd\n"
"add r10,0x7abbccdd\n"
"add r11,0x7abbccdd\n"
"add r12,0x7abbccdd\n"
"add r13,0x7abbccdd\n"
"add r14,0x7abbccdd\n"
"add r15,0x7abbccdd\n"
);
as_free(as);
for(size_t i = 0; i < 16; i++)
as_sub(as, as_reg(8, i), as_reg(8, i));
for(size_t i = 0; i < 16; i++)
as_sub(as, as_reg(8, i), as_imm(4, 0x7abbccdd));
disassembly = disassemble(as);
st_check_str(disassembly,
"sub rax,rax\n"
"sub rcx,rcx\n"
"sub rdx,rdx\n"
"sub rbx,rbx\n"
"sub rsp,rsp\n"
"sub rbp,rbp\n"
"sub rsi,rsi\n"
"sub rdi,rdi\n"
"sub r8,r8\n"
"sub r9,r9\n"
"sub r10,r10\n"
"sub r11,r11\n"
"sub r12,r12\n"
"sub r13,r13\n"
"sub r14,r14\n"
"sub r15,r15\n"
"sub rax,0x7abbccdd\n"
"sub rcx,0x7abbccdd\n"
"sub rdx,0x7abbccdd\n"
"sub rbx,0x7abbccdd\n"
"sub rsp,0x7abbccdd\n"
"sub rbp,0x7abbccdd\n"
"sub rsi,0x7abbccdd\n"
"sub rdi,0x7abbccdd\n"
"sub r8,0x7abbccdd\n"
"sub r9,0x7abbccdd\n"
"sub r10,0x7abbccdd\n"
"sub r11,0x7abbccdd\n"
"sub r12,0x7abbccdd\n"
"sub r13,0x7abbccdd\n"
"sub r14,0x7abbccdd\n"
"sub r15,0x7abbccdd\n"
);
as_free(as);
for(size_t i = 0; i < 16; i++)
as_mul(as, as_reg(8, i));
for(size_t i = 0; i < 16; i++)
as_mul(as, as_mem_rd(8, as_reg(8, i), 0xbeba));
disassembly = disassemble(as);
st_check_str(disassembly,
"mul rax\n"
"mul rcx\n"
"mul rdx\n"
"mul rbx\n"
"mul rsp\n"
"mul rbp\n"
"mul rsi\n"
"mul rdi\n"
"mul r8\n"
"mul r9\n"
"mul r10\n"
"mul r11\n"
"mul r12\n"
"mul r13\n"
"mul r14\n"
"mul r15\n"
"mul QWORD PTR [rax+0xbeba]\n"
"mul QWORD PTR [rcx+0xbeba]\n"
"mul QWORD PTR [rdx+0xbeba]\n"
"mul QWORD PTR [rbx+0xbeba]\n"
"mul QWORD PTR [rsp+0xbeba]\n"
"mul QWORD PTR [rbp+0xbeba]\n"
"mul QWORD PTR [rsi+0xbeba]\n"
"mul QWORD PTR [rdi+0xbeba]\n"
"mul QWORD PTR [r8+0xbeba]\n"
"mul QWORD PTR [r9+0xbeba]\n"
"mul QWORD PTR [r10+0xbeba]\n"
"mul QWORD PTR [r11+0xbeba]\n"
"mul QWORD PTR [r12+0xbeba]\n"
"mul QWORD PTR [r13+0xbeba]\n"
"mul QWORD PTR [r14+0xbeba]\n"
"mul QWORD PTR [r15+0xbeba]\n"
);
as_free(as);
for(size_t i = 0; i < 16; i++)
as_div(as, as_reg(8, i));
for(size_t i = 0; i < 16; i++)
as_div(as, as_mem_rd(8, as_reg(8, i), 0xbeba));
disassembly = disassemble(as);
st_check_str(disassembly,
"div rax\n"
"div rcx\n"
"div rdx\n"
"div rbx\n"
"div rsp\n"
"div rbp\n"
"div rsi\n"
"div rdi\n"
"div r8\n"
"div r9\n"
"div r10\n"
"div r11\n"
"div r12\n"
"div r13\n"
"div r14\n"
"div r15\n"
"div QWORD PTR [rax+0xbeba]\n"
"div QWORD PTR [rcx+0xbeba]\n"
"div QWORD PTR [rdx+0xbeba]\n"
"div QWORD PTR [rbx+0xbeba]\n"
"div QWORD PTR [rsp+0xbeba]\n"
"div QWORD PTR [rbp+0xbeba]\n"
"div QWORD PTR [rsi+0xbeba]\n"
"div QWORD PTR [rdi+0xbeba]\n"
"div QWORD PTR [r8+0xbeba]\n"
"div QWORD PTR [r9+0xbeba]\n"
"div QWORD PTR [r10+0xbeba]\n"
"div QWORD PTR [r11+0xbeba]\n"
"div QWORD PTR [r12+0xbeba]\n"
"div QWORD PTR [r13+0xbeba]\n"
"div QWORD PTR [r14+0xbeba]\n"
"div QWORD PTR [r15+0xbeba]\n"
);
as_free(as);
free(disassembly);
}
void test_stack_instructions() {
asm_p as = &(asm_t){ 0 };
char* disassembly = NULL;
as_free(as);
as_push(as, as_imm(1, 0x7a));
as_push(as, as_imm(2, 0x1122));
as_push(as, as_imm(4, 0x1122334455667788));
disassembly = disassemble(as);
st_check_str(disassembly,
"push 0x7a\n"
"pushw 0x1122\n"
"push 0x55667788\n"
);
as_free(as);
for(size_t i = 0; i < 16; i++)
as_push(as, as_reg(8, i));
for(size_t i = 0; i < 16; i++)
as_push(as, as_mem_rd(8, as_reg(8, i), 0xbeba));
disassembly = disassemble(as);
st_check_str(disassembly,
"push rax\n"
"push rcx\n"
"push rdx\n"
"push rbx\n"
"push rsp\n"
"push rbp\n"
"push rsi\n"
"push rdi\n"
"push r8\n"
"push r9\n"
"push r10\n"
"push r11\n"
"push r12\n"
"push r13\n"
"push r14\n"
"push r15\n"
"push QWORD PTR [rax+0xbeba]\n"
"push QWORD PTR [rcx+0xbeba]\n"
"push QWORD PTR [rdx+0xbeba]\n"
"push QWORD PTR [rbx+0xbeba]\n"
"push QWORD PTR [rsp+0xbeba]\n"
"push QWORD PTR [rbp+0xbeba]\n"
"push QWORD PTR [rsi+0xbeba]\n"
"push QWORD PTR [rdi+0xbeba]\n"
"push QWORD PTR [r8+0xbeba]\n"
"push QWORD PTR [r9+0xbeba]\n"
"push QWORD PTR [r10+0xbeba]\n"
"push QWORD PTR [r11+0xbeba]\n"
"push QWORD PTR [r12+0xbeba]\n"
"push QWORD PTR [r13+0xbeba]\n"
"push QWORD PTR [r14+0xbeba]\n"
"push QWORD PTR [r15+0xbeba]\n"
);
as_free(as);
for(size_t i = 0; i < 16; i++)
as_pop(as, as_reg(8, i));
for(size_t i = 0; i < 16; i++)
as_pop(as, as_mem_rd(8, as_reg(8, i), 0xbeba));
disassembly = disassemble(as);
st_check_str(disassembly,
"pop rax\n"
"pop rcx\n"
"pop rdx\n"
"pop rbx\n"
"pop rsp\n"
"pop rbp\n"
"pop rsi\n"
"pop rdi\n"
"pop r8\n"
"pop r9\n"
"pop r10\n"
"pop r11\n"
"pop r12\n"
"pop r13\n"
"pop r14\n"
"pop r15\n"
"pop QWORD PTR [rax+0xbeba]\n"
"pop QWORD PTR [rcx+0xbeba]\n"
"pop QWORD PTR [rdx+0xbeba]\n"
"pop QWORD PTR [rbx+0xbeba]\n"
"pop QWORD PTR [rsp+0xbeba]\n"
"pop QWORD PTR [rbp+0xbeba]\n"
"pop QWORD PTR [rsi+0xbeba]\n"
"pop QWORD PTR [rdi+0xbeba]\n"
"pop QWORD PTR [r8+0xbeba]\n"
"pop QWORD PTR [r9+0xbeba]\n"
"pop QWORD PTR [r10+0xbeba]\n"
"pop QWORD PTR [r11+0xbeba]\n"
"pop QWORD PTR [r12+0xbeba]\n"
"pop QWORD PTR [r13+0xbeba]\n"
"pop QWORD PTR [r14+0xbeba]\n"
"pop QWORD PTR [r15+0xbeba]\n"
);
as_free(as);
free(disassembly);
}
void test_conditional_instructions() {
asm_p as = &(asm_t){ 0 };
char* disassembly = NULL;
int condition_codes[] = {
CC_OVERFLOW, CC_NO_OVERFLOW,
CC_BELOW, CC_ABOVE_OR_EQUAL,
CC_EQUAL, CC_NOT_EQUAL,
CC_BELOW_OR_EQUAL, CC_ABOVE,
CC_SIGN, CC_NO_SIGN,
CC_PARITY_EVEN, CC_PARITY_ODD,
CC_LESS, CC_GREATER_OR_EQUAL,
CC_LESS_OR_EQUAL, CC_GREATER
};
as_free(as);
for(size_t i = 0; i < sizeof(condition_codes) / sizeof(condition_codes[0]); i++)
as_jmp_cc(as, condition_codes[i], as_disp(0x11223344));
disassembly = disassemble(as);
st_check_str(disassembly,
"jo 0x1162334a\n"
"jno 0x11623350\n"
"jb 0x11623356\n"
"jae 0x1162335c\n"
"je 0x11623362\n"
"jne 0x11623368\n"
"jbe 0x1162336e\n"
"ja 0x11623374\n"
"js 0x1162337a\n"
"jns 0x11623380\n"
"jp 0x11623386\n"
"jnp 0x1162338c\n"
"jl 0x11623392\n"
"jge 0x11623398\n"
"jle 0x1162339e\n"
"jg 0x116233a4\n"
);
as_free(as);
for(size_t i = 0; i < sizeof(condition_codes) / sizeof(condition_codes[0]); i++)
as_set_cc(as, condition_codes[i], as_reg(1, i));
disassembly = disassemble(as);
st_check_str(disassembly,
"seto al\n"
"setno cl\n"
"setb dl\n"
"setae bl\n"
"sete spl\n"
"setne bpl\n"
"setbe sil\n"
"seta dil\n"
"sets r8b\n"
"setns r9b\n"
"setp r10b\n"
"setnp r11b\n"
"setl r12b\n"
"setge r13b\n"
"setle r14b\n"
"setg r15b\n"
);
as_free(as);
free(disassembly);
}
dsa_init () {
Attr_Sequence as, get_cacheEDB();
AttributeType manager;
DN str2dn();
struct edb_info * dsainfo;
AV_Sequence avs;
Entry newentry;
Entry my_entry;
int real_unravel_attribute ();
int real_check_schema ();
char loadstate = TRUE;
struct DSError error;
Entry akid;
check_dsa_known_oids ();
unrav_fn = (IFP) real_unravel_attribute;
schema_fn = (IFP) real_check_schema;
restart_fn = (IFP) attempt_restart;
if (( manager = AttrT_new (MANAGER_OID)) == NULLAttrT)
fatal (-1,"Manager - unknown attribute - check oid tables");
LLOG (log_dsap,LLOG_NOTICE,("dsa name %s",mydsaname));
if ((mydsadn = str2dn (mydsaname)) == NULLDN) {
fatal (-2,"Invalid dsa name");
}
if ((my_entry = load_dsa_cache_entry (mydsadn)) == NULLENTRY) {
if (parse_status != 0)
fatal (-3,"Can't load EDB subtree holding my DSA entry");
if (database_root != NULLENTRY)
fatal (-4,"Found EDB - but my DSA entry not in it!");
fatal (-4,"can't locate my DSA entry in local database!");
} else if (my_entry->e_data == E_TYPE_CACHE_FROM_MASTER)
shadow_myentry ();
if (get_entry_passwd (my_entry->e_attributes) == NULLCP)
/* This is not a fatal error, but some remote operations may fail */
LLOG(log_dsap,LLOG_EXCEPTIONS,("Can't find my own PASSWORD"));
if (dsa_real_attr) {
if (as_cmp (my_entry->e_attributes,dsa_real_attr) != 0) {
LLOG (log_dsap,LLOG_EXCEPTIONS,
("DSA.real entry inconsistent with EDB -- problem should fix itself later!"));
as_free (my_entry->e_attributes);
my_entry->e_attributes = as_cpy (dsa_real_attr);
if (unravel_attribute (my_entry,&error) != OK)
fatal (-82,"schema error in DSA entry");
}
} else
dsa_real_attr = as_cpy (my_entry->e_attributes);
if (my_entry->e_dsainfo != NULLDSA) {
/* get manager attribute */
if ((as = entry_find_type(my_entry,manager)) == NULLATTR )
fatal (-5,"Manager attribute missing in my own entry");
AttrT_free (manager);
super_user = avs_cpy ((AV_Sequence)as->attr_value);
if (quipu_ctx_supported(my_entry) < 5) {
LLOG(log_dsap,LLOG_EXCEPTIONS,(
"Adding QUIPU and/or Internet DSP to application context!!!"));
set_context (my_entry);
}
my_entry->e_dsainfo->dsa_version =
TidyString (strdup (quipuversion));
if (as = entry_find_type (my_entry,at_version))
if ( strcmp (
(char *) as->attr_value->avseq_av.av_struct,
my_entry->e_dsainfo->dsa_version) != 0) {
if (as->attr_value->avseq_av.av_struct)
free (as->attr_value->avseq_av.av_struct);
as->attr_value->avseq_av.av_struct =
(caddr_t) strdup (my_entry->e_dsainfo->dsa_version);
if (as = as_find_type (dsa_real_attr,at_version)) {
if (as->attr_value->avseq_av.av_struct)
free (as->attr_value->avseq_av.av_struct);
as->attr_value->avseq_av.av_struct =
(caddr_t) strdup (my_entry->e_dsainfo->dsa_version);
}
if (parse_status == 0)
if (my_entry->e_data == E_DATA_MASTER) {
if (my_entry->e_parent != NULLENTRY)
my_entry->e_parent->e_edbversion = new_version();
LLOG (log_dsap,LLOG_NOTICE,("Updating version number"));
#ifdef TURBO_DISK
if (turbo_write(my_entry) != OK)
fatal (-33,"self rewrite failed - check database");
#else
akid = (Entry) avl_getone(my_entry->e_parent->e_children);
if (journal (akid) != OK)
fatal (-33,"self rewrite failed - check database");
#endif
} else {
write_dsa_entry(my_entry);
}
}
} else
fatal (-6,"No edbinfo attribute in my own entry");
if (parse_status != 0)
loadstate = FALSE;
for (avs = my_entry->e_dsainfo->dsa_attr ; avs != NULLAV; avs=avs->avseq_next) {
if (avs->avseq_av.av_struct == NULL)
continue;
dsainfo = (struct edb_info *) avs->avseq_av.av_struct;
if ((newentry = make_path (dsainfo->edb_name)) == NULLENTRY)
continue;
(void) subtree_load (newentry,dsainfo->edb_name);
if (parse_status != 0)
loadstate = FALSE;
}
if (loadstate == FALSE)
fatal (-7,"DSA Halted");
if ((akid = (Entry) avl_getone(database_root->e_children))
!= NULLENTRY )
database_root->e_data = akid->e_data;
/* Load cached EDB files - if any */
if ((as = get_cacheEDB()) != NULLATTR) {
(void) time (&timenow);
for (avs = as -> attr_value; avs != NULLAV; avs = avs -> avseq_next) {
if ((newentry = make_path ((DN)avs->avseq_av.av_struct)) == NULLENTRY)
continue;
newentry = subtree_load (newentry,(DN)avs->avseq_av.av_struct);
/* Should timestamp using version number ! */
if (newentry)
newentry->e_age = timenow;
}
}
#ifndef TURBO_DISK
free_phylinebuf(); /* Large buffer used in loading text database */
#endif
return (OK);
}
void
__pthread_thread_halt (struct __pthread *thread, int need_dealloc)
{
/* We may deallocate THREAD. First save any data we need. */
addr_t exception_area[EXCEPTION_AREA_SIZE / PAGESIZE];
memcpy (exception_area, thread->exception_area,
sizeof (thread->exception_area));
memset (thread->exception_area, 0, sizeof (thread->exception_area));
void *va = thread->exception_area_va;
addr_t object = thread->object;
l4_thread_id_t tid = thread->threadid;
if (need_dealloc)
__pthread_dealloc (thread);
/* The THREAD data structure is no longer valid. */
thread = NULL;
/* Deallocate any saved object. */
ss_mutex_lock (&saved_object_lock);
if (! ADDR_IS_VOID (saved_object))
{
storage_free (saved_object, false);
saved_object = ADDR_VOID;
}
ss_mutex_unlock (&saved_object_lock);
/* Free the exception area. */
/* Clean up the exception page. */
exception_page_cleanup
(ADDR_TO_PTR (addr_extend (exception_area[EXCEPTION_PAGE],
0, PAGESIZE_LOG2)));
/* Free the storage. */
int i;
for (i = 0; i < EXCEPTION_AREA_SIZE / PAGESIZE; i ++)
{
assert (! ADDR_IS_VOID (exception_area[i]));
storage_free (exception_area[i], false);
}
/* And the address space. */
as_free (addr_chop (PTR_TO_ADDR (va), EXCEPTION_AREA_SIZE_LOG2), false);
if (tid == l4_myself ())
/* If we try to storage_free (storage.addr), we will freeze in the
middle. That's no good. We set SAVED_OBJECT to our thread
object and the next thread in will free us. */
{
ss_mutex_lock (&saved_object_lock);
saved_object = object;
ss_mutex_unlock (&saved_object_lock);
}
else
storage_free (object, false);
if (tid == l4_myself ())
{
l4_send_timeout (l4_myself (), L4_NEVER);
panic ("Failed to stop thread %x.%x!",
l4_thread_no (l4_myself ()), l4_version (l4_myself ()));
}
else
thread_stop (object);
}
AS* as_new(int argc, char* argv[], ShadowLogFunc slogf) {
assert(slogf);
in_addr_t inaddr = 0,
outaddr = 0,
traceaddr = 0;
char *hostname_bind,
*hostname_connect,
*hostname_trace;
char *inport,
*outport,
*traceport;
char *tmp;
if(argc < 4) {
slogf(SHADOW_LOG_LEVEL_WARNING, __FUNCTION__, USAGE);
return NULL;
}
asprintf(&tmp, "%s", argv[1]);
hostname_bind = strsep(&tmp, ":");
inport = tmp;
asprintf(&tmp, "%s", argv[2]);
hostname_connect = strsep(&tmp, ":");
outport = tmp;
asprintf(&tmp, "%s", argv[3]);
hostname_trace = strsep(&tmp, ":");
traceport = tmp;
printf("\t%s %s %s %s\n", hostname_bind, inport , hostname_connect, outport);
char myhostname[1024];
gethostname(myhostname, 1024);
slogf(SHADOW_LOG_LEVEL_MESSAGE, __FUNCTION__,
"myhostname %s", myhostname);
/* use epoll to asynchronously watch events for all of our sockets */
int inputEd = epoll_create(MAX_CLIENTS);
if(inputEd == -1) {
slogf(SHADOW_LOG_LEVEL_CRITICAL, __FUNCTION__,
"Error in main epoll_create");
close(inputEd);
return NULL;
}
/* DNS query */
/* get the address in network order */
inaddr = dnsQuery(hostname_bind);
outaddr = dnsQuery(hostname_connect);
traceaddr = dnsQuery(hostname_trace);
/* get memory for the new state */
AS* h = calloc(1, sizeof(AS));
assert(h);
h->outport = htons(atoi(outport));
h->inport = htons(atoi(inport));
h->traceport = htons(atoi(traceport));
h->ined = inputEd;
h->slogf = slogf;
h->isDone = 0;
h->hostIP = inaddr;
h->remoteIP = outaddr;
h->traceIP = traceaddr;
h->hashmap = g_hash_table_new(g_int_hash, g_int_equal);
h->serverMode = 0;
prepareToTrace(argc, argv, h);
/* extract the server hostname from argv if in client mode */
int isFail = 0;
isFail = _as_startAs(h);
if(isFail) {
as_free(h);
return NULL;
} else {
return h;
}
}
void test_compare_instructions() {
asm_p as = &(asm_t){ 0 };
char* disassembly = NULL;
as_free(as);
for(size_t i = 0; i < 16; i++)
as_cmp(as, as_reg(8, i), as_reg(8, i));
disassembly = disassemble(as);
st_check_str(disassembly,
"cmp rax,rax\n"
"cmp rcx,rcx\n"
"cmp rdx,rdx\n"
"cmp rbx,rbx\n"
"cmp rsp,rsp\n"
"cmp rbp,rbp\n"
"cmp rsi,rsi\n"
"cmp rdi,rdi\n"
"cmp r8,r8\n"
"cmp r9,r9\n"
"cmp r10,r10\n"
"cmp r11,r11\n"
"cmp r12,r12\n"
"cmp r13,r13\n"
"cmp r14,r14\n"
"cmp r15,r15\n"
);
as_free(as);
for(size_t i = 0; i < 16; i++)
as_cmp(as, as_reg(8, i), as_mem_rd(8, as_reg(8, i), 0xbeba));
disassembly = disassemble(as);
st_check_str(disassembly,
"cmp rax,QWORD PTR [rax+0xbeba]\n"
"cmp rcx,QWORD PTR [rcx+0xbeba]\n"
"cmp rdx,QWORD PTR [rdx+0xbeba]\n"
"cmp rbx,QWORD PTR [rbx+0xbeba]\n"
"cmp rsp,QWORD PTR [rsp+0xbeba]\n"
"cmp rbp,QWORD PTR [rbp+0xbeba]\n"
"cmp rsi,QWORD PTR [rsi+0xbeba]\n"
"cmp rdi,QWORD PTR [rdi+0xbeba]\n"
"cmp r8,QWORD PTR [r8+0xbeba]\n"
"cmp r9,QWORD PTR [r9+0xbeba]\n"
"cmp r10,QWORD PTR [r10+0xbeba]\n"
"cmp r11,QWORD PTR [r11+0xbeba]\n"
"cmp r12,QWORD PTR [r12+0xbeba]\n"
"cmp r13,QWORD PTR [r13+0xbeba]\n"
"cmp r14,QWORD PTR [r14+0xbeba]\n"
"cmp r15,QWORD PTR [r15+0xbeba]\n"
);
as_free(as);
for(size_t i = 0; i < 16; i++)
as_cmp(as, as_reg(8, i), as_imm(4, 0x11223344));
disassembly = disassemble(as);
st_check_str(disassembly,
"cmp rax,0x11223344\n"
"cmp rcx,0x11223344\n"
"cmp rdx,0x11223344\n"
"cmp rbx,0x11223344\n"
"cmp rsp,0x11223344\n"
"cmp rbp,0x11223344\n"
"cmp rsi,0x11223344\n"
"cmp rdi,0x11223344\n"
"cmp r8,0x11223344\n"
"cmp r9,0x11223344\n"
"cmp r10,0x11223344\n"
"cmp r11,0x11223344\n"
"cmp r12,0x11223344\n"
"cmp r13,0x11223344\n"
"cmp r14,0x11223344\n"
"cmp r15,0x11223344\n"
);
free(disassembly);
}
/* this main replaces the as-plugin.c file to run outside of shadow */
int main(int argc, char *argv[]) {
mylog("Starting AS program");
signal(SIGTERM, exit_handler);
perror("signal");
/* create the new state according to user inputs */
AS* asState = as_new(argc, argv, &_mylog);
if(!asState) {
mylog("Error initializing new AS instance");
return -1;
}
/* now we need to watch all of the as descriptors in our main loop
* so we know when we can wait on any of them without blocking. */
int mainepolld = epoll_create(1);
if(mainepolld == -1) {
mylog("Error in main epoll_create");
close(mainepolld);
return -1;
}
/* as has one main epoll descriptor that watches all of its sockets,
* so we now register that descriptor so we can watch for its events */
struct epoll_event mainevent;
mainevent.events = EPOLLIN;
mainevent.data.fd = as_getEpollDescriptor(asState);
if(!mainevent.data.fd) {
mylog("Error retrieving as epoll descriptor");
close(mainepolld);
return -1;
}
epoll_ctl(mainepolld, EPOLL_CTL_ADD, mainevent.data.fd, &mainevent);
/* main loop - wait for events from the as descriptors */
struct epoll_event events[100];
int nReadyFDs;
mylog("entering main loop to watch descriptors");
while(1) {
/* wait for some events */
mylog("waiting for events");
nReadyFDs = epoll_wait(mainepolld, events, 100, -1);
if(nReadyFDs == -1) {
mylog("Error in client epoll_wait");
return -1;
}
/* activate if something is ready */
mylog("processing event");
if(nReadyFDs > 0) {
as_ready(asState);
}
}
mylog("finished main loop, cleaning up");
/* de-register the as epoll descriptor */
mainevent.data.fd = as_getEpollDescriptor(asState);
if(mainevent.data.fd) {
epoll_ctl(mainepolld, EPOLL_CTL_DEL, mainevent.data.fd, &mainevent);
}
/* cleanup and close */
close(mainepolld);
/* de-register the as epoll descriptor */
mainevent.data.fd = as_getEpollDescriptor(asState);
if(mainevent.data.fd) {
epoll_ctl(mainepolld, EPOLL_CTL_DEL, mainevent.data.fd, &mainevent);
}
/* cleanup and close */
close(mainepolld);
as_free(asState);
mylog("exiting cleanly");
return 0;
}
void thread_delete(ustack_t *thread) {
_deregister(thread);
void *base = _unprotect(thread);
as_free(AS_REGISTERED, base);
}
