Method compare

src/function_context.py:587–677

Compare our (source) function to a potential binary match. Args: bin_ctx (ComparableContext): context representing a binary function (potential match) logger (logger): logger instance Return Value: floating point score for the entire match

(self, bin_ctx, logger)

        return True

    def compare(self, bin_ctx, logger):
        """Compare our (source) function to a potential binary match.

        Args:
            bin_ctx (ComparableContext): context representing a binary function (potential match)
            logger (logger): logger instance

        Return Value:
            floating point score for the entire match
        """
        score = 0
        logger.addIndent()
        # 0. prepare the instruction ratio (if has one already)
        instr_ratio = (src_instr_count * 1.0 / bin_instr_count) if num_instr_samples >= INSTR_RATIO_COUNT_THRESHOLD else 1
        boost_score = len(self.blocks) <= MINIMAL_BLOCKS_BOOST and len(bin_ctx.blocks) <= MINIMAL_BLOCKS_BOOST
        boost_score = boost_score and bin_ctx.call_hints is None and len(bin_ctx.xref_hints) == 0
        # 1. Match constants
        const_score = ComparableContext.compareConsts(self, bin_ctx)
        logger.debug("Const score: %f", const_score)
        score += const_score
        # 2. Match strings
        string_score = ComparableContext.compareString(self, bin_ctx)
        logger.debug("String score: %f", string_score)
        score += string_score
        # 3. Match sizes
        function_size_score = -1 * abs(self.instrs - bin_ctx.instrs * instr_ratio) * INSTR_COUNT_SCORE
        # check for a probable match
        if abs(function_size_score) <= INSTR_COUNT_THRESHOLD * INSTR_COUNT_SCORE:
            function_size_score += ARTIFACT_MATCH_SCORE
        logger.debug("Function size score: %f", function_size_score)
        score += function_size_score
        # 4. Match stack frames
        frame_size_score = -1 * abs(self.frame - bin_ctx.frame) * FUNC_FRAME_SCORE
        # check for a probable match
        if abs(frame_size_score) <= FRAME_SIZE_THRESHOLD * FUNC_FRAME_SCORE:
            frame_size_score += ARTIFACT_MATCH_SCORE
        logger.debug("Frame size score: %f", frame_size_score)
        score += frame_size_score
        # 5. Match calls
        calls_score = ComparableContext.compareCalls(self, bin_ctx)
        logger.debug("Calls score: %f", calls_score)
        score += calls_score
        # 6. Match code blocks
        code_blocks_score = 0
        for index, block in enumerate(self.blocks):
            code_blocks_score -= abs(self.blocks[index] - ((bin_ctx.blocks[index] * instr_ratio) if index < len(bin_ctx.blocks) else 0)) * BLOCK_MATCH_SCORE
        for j in range(index + 1, len(bin_ctx.blocks)):
            code_blocks_score -= bin_ctx.blocks[j] * BLOCK_MISMATCH_SCORE * instr_ratio
        # check for a probable match
        if abs(code_blocks_score) <= INSTR_COUNT_THRESHOLD * INSTR_COUNT_SCORE:
            code_blocks_score += ARTIFACT_MATCH_SCORE
        logger.debug("Code blocks score: %f", code_blocks_score)
        score += code_blocks_score
        # 7. Match function calls (hints)
        call_hints_score = 0
        merged_hints = 0
        if bin_ctx.call_hints is not None and len(bin_ctx.call_hints) > 0 and self in bin_ctx.call_hints:
            merged_hints = len([x for x in bin_ctx.call_hints if x.hash == self.hash])