void IA_IAPI::parseSysEnter(std::vector<std::pair<Address, EdgeTypeEnum> >& outEdges) const
{
IA_IAPI* scratch = this->clone();
do {
scratch->advance();
} while(scratch->isNop());
if(scratch->curInsn().getCategory() == c_BranchInsn)
{
parsing_printf("[%s:%d] Detected Linux-ish sysenter idiom at 0x%lx\n",
FILE__, __LINE__, getAddr());
outEdges.push_back(std::make_pair(scratch->getAddr(), COND_NOT_TAKEN));
scratch->advance();
outEdges.push_back(std::make_pair(scratch->getAddr(), CALL_FT));
}
else
{
parsing_printf("[%s:%d] Treating sysenter as call to kernel w/normal return to next insn at 0x%lx\n",
FILE__, __LINE__, getAddr());
outEdges.push_back(std::make_pair(getNextAddr(), CALL_FT));
}
delete scratch;
}
bool IA_x86Details::handleCall(IA_IAPI& block)
{
parsing_printf("\tchecking call at 0x%lx for thunk\n", block.getAddr());
if(!block.isRealCall())
{
parsing_printf("\tthunk found at 0x%lx, checking for add\n", block.getAddr());
block.advance();
thunkInsn.addrFromInsn = block.getAddr();
Instruction::Ptr addInsn = block.getInstruction();
if(addInsn)
parsing_printf("\tinsn after thunk: %s\n", addInsn->format().c_str());
else
parsing_printf("\tNO INSN after thunk at 0x%lx\n", thunkInsn.addrFromInsn);
if(addInsn)
{
std::set<RegisterAST::Ptr> boundRegs;
if(addInsn->getOperation().getID() == e_pop)
{
addInsn->getWriteSet(boundRegs);
block.advance();
addInsn = block.getInstruction();
}
if(addInsn && ((addInsn->getOperation().getID() == e_add) ||
(addInsn->getOperation().getID() == e_lea)))
{
Expression::Ptr op0 = addInsn->getOperand(0).getValue();
Expression::Ptr op1 = addInsn->getOperand(1).getValue();
for(std::set<RegisterAST::Ptr>::const_iterator curReg = boundRegs.begin();
curReg != boundRegs.end();
++curReg)
{
op0->bind(curReg->get(), Result(u64, 0));
op1->bind(curReg->get(), Result(u64, 0));
}
Result imm = addInsn->getOperand(1).getValue()->eval();
Result imm2 = addInsn->getOperand(0).getValue()->eval();
if(imm.defined)
{
Address thunkDiff = imm.convert<Address>();
parsing_printf("\tsetting thunkInsn.addrFromInsn to 0x%lx (0x%lx + 0x%lx)\n",
thunkInsn.addrFromInsn+thunkDiff, thunkInsn.addrFromInsn, thunkDiff);
thunkInsn.addrOfInsn = block.getPrevAddr();
thunkInsn.addrFromInsn = thunkInsn.addrFromInsn + thunkDiff;
return true;
}
else if(imm2.defined)
{
Address thunkDiff = imm2.convert<Address>();
parsing_printf("\tsetting thunkInsn.addrFromInsn to 0x%lx (0x%lx + 0x%lx)\n",
thunkInsn.addrFromInsn+thunkDiff, thunkInsn.addrFromInsn, thunkDiff);
thunkInsn.addrOfInsn = block.getPrevAddr();
thunkInsn.addrFromInsn = thunkInsn.addrFromInsn + thunkDiff;
return true;
}
else
{
parsing_printf("\tadd insn %s found following thunk at 0x%lx, couldn't bind operands!\n",
addInsn->format().c_str(), thunkInsn.addrFromInsn);
}
}
}
thunkInsn.addrFromInsn = 0;
}
thunkInsn.addrFromInsn = 0;
thunkInsn.addrOfInsn = 0;
thunkInsn.insn.reset();
return false;
}
/* returns true if the call leads to:
* -an invalid instruction (or immediately branches/calls to an invalid insn)
* -a block not ending in a return instruction that pops the return address
* off of the stack
*/
bool IA_IAPI::isFakeCall() const
{
assert(_obj->defensiveMode());
if (isDynamicCall()) {
return false;
}
// get func entry
bool tampers = false;
bool valid; Address entry;
boost::tie(valid, entry) = getCFT();
if (!valid) return false;
if (! _cr->contains(entry) ) {
return false;
}
if ( ! _isrc->isCode(entry) ) {
mal_printf("WARNING: found function call at %lx "
"to invalid address %lx %s[%d]\n", current,
entry, FILE__,__LINE__);
return false;
}
// get instruction at func entry
const unsigned char* bufPtr =
(const unsigned char *)(_cr->getPtrToInstruction(entry));
Offset entryOff = entry - _cr->offset();
InstructionDecoder newdec( bufPtr,
_cr->length() - entryOff,
_cr->getArch() );
IA_IAPI *ah = new IA_IAPI(newdec, entry, _obj, _cr, _isrc, _curBlk);
Instruction::Ptr insn = ah->curInsn();
// follow ctrl transfers until you get a block containing non-ctrl
// transfer instructions, or hit a return instruction
while (insn->getCategory() == c_CallInsn ||
insn->getCategory() == c_BranchInsn)
{
boost::tie(valid, entry) = ah->getCFT();
if ( !valid || ! _cr->contains(entry) || ! _isrc->isCode(entry) ) {
mal_printf("WARNING: found call to function at %lx that "
"leaves to %lx, out of the code region %s[%d]\n",
current, entry, FILE__,__LINE__);
return false;
}
bufPtr = (const unsigned char *)(_cr->getPtrToInstruction(entry));
entryOff = entry - _cr->offset();
delete(ah);
newdec = InstructionDecoder(bufPtr,
_cr->length() - entryOff,
_cr->getArch());
ah = new IA_IAPI(newdec, entry, _obj, _cr, _isrc, _curBlk);
insn = ah->curInsn();
}
// calculate instruction stack deltas for the block, leaving the iterator
// at the last ins'n if it's a control transfer, or after calculating the
// last instruction's delta if we run off the end of initialized memory
int stackDelta = 0;
int addrWidth = _isrc->getAddressWidth();
static Expression::Ptr theStackPtr
(new RegisterAST(MachRegister::getStackPointer(_isrc->getArch())));
Address curAddr = entry;
while(true) {
// exit condition 1
if (insn->getCategory() == c_CallInsn ||
insn->getCategory() == c_ReturnInsn ||
insn->getCategory() == c_BranchInsn)
{
break;
}
// calculate instruction delta
if(insn->isWritten(theStackPtr)) {
entryID what = insn->getOperation().getID();
int sign = 1;
switch(what)
{
case e_push:
sign = -1;
//FALLTHROUGH
case e_pop: {
int size = insn->getOperand(0).getValue()->size();
stackDelta += sign * size;
break;
}
case e_pusha:
case e_pushad:
sign = -1;
//FALLTHROUGH
case e_popa:
case e_popad:
if (1 == sign) {
mal_printf("popad ins'n at %lx in func at %lx changes sp "
"by %d. %s[%d]\n", ah->getAddr(),
entry, 8 * sign * addrWidth, FILE__, __LINE__);
}
stackDelta += sign * 8 * addrWidth;
break;
case e_pushf:
case e_pushfd:
sign = -1;
//FALLTHROUGH
case e_popf:
case e_popfd:
stackDelta += sign * 4;
if (1 == sign) {
mal_printf("popf ins'n at %lx in func at %lx changes sp "
"by %d. %s[%d]\n", ah->getAddr(), entry,
sign * 4, FILE__, __LINE__);
}
break;
case e_enter:
//mal_printf("Saw enter instruction at %lx in isFakeCall, "
// "quitting early, assuming not fake "
// "%s[%d]\n",curAddr, FILE__,__LINE__);
// unhandled case, but not essential for correct analysis
delete ah;
return false;
break;
case e_leave:
mal_printf("WARNING: saw leave instruction "
"at %lx that is not handled by isFakeCall %s[%d]\n",
curAddr, FILE__,__LINE__);
// unhandled, not essential for correct analysis, would
// be a red flag if there wasn't an enter ins'n first and
// we didn't end in a return instruction
break;
case e_and:
// Rounding off the stack pointer.
mal_printf("WARNING: saw and instruction at %lx that is not handled by isFakeCall %s[%d]\n",
curAddr, FILE__, __LINE__);
delete ah;
return false;
break;
case e_sub:
sign = -1;
//FALLTHROUGH
case e_add: {
Operand arg = insn->getOperand(1);
Result delta = arg.getValue()->eval();
if(delta.defined) {
int delta_int = sign;
switch (delta.type) {
case u8:
case s8:
delta_int *= (int)delta.convert<char>();
break;
case u16:
case s16:
delta_int *= (int)delta.convert<short>();
break;
case u32:
case s32:
delta_int *= delta.convert<int>();
break;
default:
assert(0 && "got add/sub operand of unusual size");
break;
}
stackDelta += delta_int;
} else if (sign == -1) {
delete ah;
return false;
} else {
mal_printf("ERROR: in isFakeCall, add ins'n "
"at %lx (in first block of function at "
"%lx) modifies the sp but failed to evaluate "
"its arguments %s[%d]\n",
ah->getAddr(), entry, FILE__, __LINE__);
delete ah;
return true;
}
break;
}
default: {
fprintf(stderr,"WARNING: in isFakeCall non-push/pop "
"ins'n at %lx (in first block of function at "
"%lx) modifies the sp by an unknown amount. "
"%s[%d]\n", ah->getAddr(), entry,
FILE__, __LINE__);
break;
} // end default block
} // end switch
}
if (stackDelta > 0) {
tampers=true;
}
// exit condition 2
ah->advance();
Instruction::Ptr next = ah->curInsn();
if (NULL == next) {
break;
}
curAddr += insn->size();
insn = next;
}
// not a fake call if it ends w/ a return instruction
if (insn->getCategory() == c_ReturnInsn) {
delete ah;
return false;
}
// if the stack delta is positive or the return address has been replaced
// with an absolute value, it's a fake call, since in both cases
// the return address is gone and we cannot return to the caller
if ( 0 < stackDelta || tampers ) {
delete ah;
return true;
}
delete ah;
return false;
}