def ParseInstrumentation(data): instrumentation = Instrumentation() statusBlockString = '' for line in data.splitlines(): statusBlockString += line + '\n' if line.startswith("INSTRUMENTATION_STATUS_CODE:"): status = _ParseStatus(statusBlockString) instrumentation.addStatus(status) statusBlockString = "" return instrumentation
class TestInstrumentationToTestResultTransformer(unittest.TestCase): SUCCESS = 0 ERROR = -1 FAIL = -2 def setUp(self): self._instrumentation = Instrumentation() def _addTestRun(self, className, methodName, result): status = Status() status['class'] = className status['test'] = methodName status.statusCode = 1 self._instrumentation.addStatus(status) status = Status() status['class'] = className status['test'] = methodName status.statusCode = result self._instrumentation.addStatus(status) def _addSuccessfulTestRun(self, className, methodName): self._addTestRun(className, methodName, self.SUCCESS) def _addFailingTestRun(self, className, methodName, stack): self._addTestRun(className, methodName, self.FAIL) self._instrumentation.statuses()[-1]['stack'] = stack def _addErroringTestRun(self, className, methodName, stack): self._addTestRun(className, methodName, self.ERROR) self._instrumentation.statuses()[-1]['stack'] = stack def assertTestSuite(self, suite, name, package): self.assertEqual(suite.name, name) self.assertEqual(suite.package, package) def assertTestCase(self, case, method): self.assertEqual(case.name, method)
def main(): global tm_start for mod in ('metapc', 'ppc', 'arm'): arch_mod = __import__('arch.%s' % mod, globals(), locals(), ['*']) arch = arch_mod.Arch() if arch: if arch.check_arch(): # This is a valid module for the current architecure # so the search has finished log_message('Using architecture module [%s]' % mod) break else: log_message( 'No module found to process the current architecure [%s]. Exiting.' % (arch.processor_name)) return global instrumentation log_message('Initialization sucessful.') db_engine, db_host, db_name, db_user, db_password = (None, ) * 5 batch_mode = False module_comment = '' process_sections = False # If the configuration filename has been fetched from the # environment variables, then use that. # if CONFIG_FILE_NAME: config_file_path = CONFIG_FILE_NAME # Otherwise fallback into the one expected in the IDA directory # else: config_file_path = os.path.join(idaapi.idadir(''), 'ida2sql.cfg') if os.path.exists(config_file_path): cfg = ConfigParser.ConfigParser() cfg.read(config_file_path) if cfg.has_section('database'): if cfg.has_option('database', 'engine'): db_engine = getattr(DB_ENGINE, cfg.get('database', 'engine')) if cfg.has_option('database', 'host'): db_host = cfg.get('database', 'host') if cfg.has_option('database', 'schema'): db_name = cfg.get('database', 'schema') if cfg.has_option('database', 'user'): db_user = cfg.get('database', 'user') if cfg.has_option('database', 'password'): db_password = cfg.get('database', 'password') if cfg.has_option('importing', 'mode'): batch_mode = cfg.get('importing', 'mode') if batch_mode.lower() in ('batch', 'auto'): batch_mode = True if cfg.has_option('importing', 'comment'): module_comment = cfg.get('importing', 'comment') if cfg.has_option('importing', 'process_sections'): process_sections = cfg.get('importing', 'process_sections') if process_sections.lower() in ('no', 'false'): process_sections = False else: process_sections = True if None in (db_engine, db_host, db_name, db_user, db_password): (db_engine, db_host, db_name, db_user, db_password) = query_configuration() if None in (db_engine, db_host, db_name, db_user, db_password): log_message('User cancelled the exporting.') return failed = False try: sqlexporter = SQLExporter(arch, db_engine, db=db_name, user=db_user, passwd=db_password, host=db_host, use_new_schema=USE_NEW_SCHEMA) except ImportError: print "Error connecting to the database, error importing required module: %s" % sys.exc_info( )[0] failed = True except Exception: print "Error connecting to the database, Reason: %s" % sys.exc_info( )[0] failed = True if failed: # Can't connect to the database, indicate that to BinNavi if batch_mode is True: idc.Exit(FATAL_CANNOT_CONNECT_TO_DATABASE) else: return if not sqlexporter.is_database_ready(): if batch_mode is False: result = idc.AskYN( 1, 'Database has not been initialized yet. Do you want to create now the basic tables? (This step is performed only once)' ) else: result = 1 if result == 1: sqlexporter.init_database() else: log_message('User requested abort.') return iteration = os.environ.get('EXPORT_ITERATION', None) module_id = os.environ.get('MODULE_ID', None) if iteration is None and module_id == None: # Export manually print "Exporting manually ..." iteration = -1 sqlexporter.set_callgraph_only(False) sqlexporter.set_exporting_manually(True) status = sqlexporter.new_module(idc.GetInputFilePath(), arch.get_architecture_name(), idaapi.get_imagebase(), module_comment, batch_mode) elif iteration is not None and module_id is not None: # Export the next k functions or the call graph sqlexporter.set_exporting_manually(False) sqlexporter.set_callgraph_only(int(iteration) == -1) sqlexporter.set_module_id(int(module_id)) status = True else: sqlexporter.set_exporting_manually(False) status = sqlexporter.new_module(idc.GetInputFilePath(), arch.get_architecture_name(), idaapi.get_imagebase(), module_comment, batch_mode) sqlexporter.set_callgraph_only(False) if status is False: log_message('Export aborted') return elif status is None: log_message( 'The database appears to contain data exported with different schemas, exporting not allowed.' ) if batch_mode: idc.Exit(FATAL_INVALID_SCHEMA_VERSION) instrumentation = Instrumentation() instrumentation.new_function_callable(sqlexporter.process_function) instrumentation.new_packet_callable(sqlexporter.process_packet) instrumentation.new_section_callable(sqlexporter.process_section) tm_start = time.time() already_imported = sqlexporter.db.get_already_imported() incomplete = process_binary(arch, process_sections, int(iteration), already_imported) sqlexporter.finish() log_message( 'Results: %d functions, %d instructions, %d basic blocks, %d address references' % (len(sqlexporter.exported_functions), len(sqlexporter.exported_instructions), sqlexporter.basic_blocks_next_id - 1, sqlexporter.address_references_values_count)) log_message( 'Results: %d expression substitutions, %d operand expressions, %d operand tuples' % (sqlexporter.expression_substitutions_values_count, sqlexporter.operand_expressions_values_count, sqlexporter.operand_tuples___operands_values_count)) log_message('Exporting completed in %s' % get_time_delta_string()) # If running in batch mode, exit when done if batch_mode: if incomplete: shiftedModule = (sqlexporter.db.module_id << 0x10) | 0xFF idc.Exit(shiftedModule) elif not sqlexporter.callgraph_only: shiftedModule = (sqlexporter.db.module_id << 0x10) | 0xFE idc.Exit(shiftedModule) else: idc.Exit(0)
def main(): global tm_start for mod in ('metapc', 'ppc', 'arm'): arch_mod = __import__('arch.%s' % mod, globals(), locals(), ['*']) arch = arch_mod.Arch() if arch: if arch.check_arch(): # This is a valid module for the current architecure # so the search has finished log_message('Using architecture module [%s]' % mod) break else: log_message('No module found to process the current architecure [%s]. Exiting.' % (arch.processor_name)) return global instrumentation log_message('Initialization sucessful.') db_engine, db_host, db_name, db_user, db_password = (None,)*5 batch_mode = False module_comment = '' process_sections = False # If the configuration filename has been fetched from the # environment variables, then use that. # if CONFIG_FILE_NAME: config_file_path = CONFIG_FILE_NAME # Otherwise fallback into the one expected in the IDA directory # else: config_file_path = os.path.join(idaapi.idadir(''), 'ida2sql.cfg') if os.path.exists(config_file_path): cfg = ConfigParser.ConfigParser() cfg.read(config_file_path) if cfg.has_section('database'): if cfg.has_option('database', 'engine'): db_engine = getattr(DB_ENGINE, cfg.get('database', 'engine')) if cfg.has_option('database', 'host'): db_host = cfg.get('database', 'host') if cfg.has_option('database', 'schema'): db_name = cfg.get('database', 'schema') if cfg.has_option('database', 'user'): db_user = cfg.get('database', 'user') if cfg.has_option('database', 'password'): db_password = cfg.get('database', 'password') if cfg.has_option('importing', 'mode'): batch_mode = cfg.get('importing', 'mode') if batch_mode.lower() in ('batch', 'auto'): batch_mode = True if cfg.has_option('importing', 'comment'): module_comment = cfg.get('importing', 'comment') if cfg.has_option('importing', 'process_sections'): process_sections = cfg.get('importing', 'process_sections') if process_sections.lower() in ('no', 'false'): process_sections = False else: process_sections = True if None in (db_engine, db_host, db_name, db_user, db_password): (db_engine, db_host, db_name, db_user, db_password) = query_configuration() if None in (db_engine, db_host, db_name, db_user, db_password): log_message('User cancelled the exporting.') return failed = False try: sqlexporter = SQLExporter(arch, db_engine, db=db_name, user=db_user, passwd=db_password, host=db_host, use_new_schema=USE_NEW_SCHEMA) except ImportError: print "Error connecting to the database, error importing required module: %s" % sys.exc_info()[0] failed = True except Exception: print "Error connecting to the database, Reason: %s" % sys.exc_info()[0] failed = True if failed: # Can't connect to the database, indicate that to BinNavi if batch_mode is True: idc.Exit(FATAL_CANNOT_CONNECT_TO_DATABASE) else: return if not sqlexporter.is_database_ready(): if batch_mode is False: result = idc.AskYN(1, 'Database has not been initialized yet. Do you want to create now the basic tables? (This step is performed only once)') else: result = 1 if result == 1: sqlexporter.init_database() else: log_message('User requested abort.') return iteration = os.environ.get('EXPORT_ITERATION', None) module_id = os.environ.get('MODULE_ID', None) if iteration is None and module_id == None: # Export manually print "Exporting manually ..." iteration = -1 sqlexporter.set_callgraph_only(False) sqlexporter.set_exporting_manually(True) status = sqlexporter.new_module( idc.GetInputFilePath(), arch.get_architecture_name(), idaapi.get_imagebase(), module_comment, batch_mode) elif iteration is not None and module_id is not None: # Export the next k functions or the call graph sqlexporter.set_exporting_manually(False) sqlexporter.set_callgraph_only(int(iteration) == -1) sqlexporter.set_module_id(int(module_id)) status = True else: sqlexporter.set_exporting_manually(False) status = sqlexporter.new_module( idc.GetInputFilePath(), arch.get_architecture_name(), idaapi.get_imagebase(), module_comment, batch_mode) sqlexporter.set_callgraph_only(False) if status is False: log_message('Export aborted') return elif status is None: log_message('The database appears to contain data exported with different schemas, exporting not allowed.') if batch_mode: idc.Exit(FATAL_INVALID_SCHEMA_VERSION) instrumentation = Instrumentation() instrumentation.new_function_callable(sqlexporter.process_function) instrumentation.new_packet_callable(sqlexporter.process_packet) instrumentation.new_section_callable(sqlexporter.process_section) tm_start = time.time() already_imported = sqlexporter.db.get_already_imported() incomplete = process_binary(arch, process_sections, int(iteration), already_imported) sqlexporter.finish() log_message('Results: %d functions, %d instructions, %d basic blocks, %d address references' % ( len(sqlexporter.exported_functions), len(sqlexporter.exported_instructions), sqlexporter.basic_blocks_next_id-1, sqlexporter.address_references_values_count )) log_message('Results: %d expression substitutions, %d operand expressions, %d operand tuples' % ( sqlexporter.expression_substitutions_values_count, sqlexporter.operand_expressions_values_count, sqlexporter.operand_tuples___operands_values_count ) ) log_message('Exporting completed in %s' % get_time_delta_string()) # If running in batch mode, exit when done if batch_mode: if incomplete: shiftedModule = (sqlexporter.db.module_id << 0x10) | 0xFF idc.Exit(shiftedModule) elif not sqlexporter.callgraph_only: shiftedModule = (sqlexporter.db.module_id << 0x10) | 0xFE idc.Exit(shiftedModule) else: idc.Exit(0)
def setUp(self): self._instrumentation = Instrumentation()
class TestInstrumentationToTestResultTransformer(unittest.TestCase): SUCCESS = 0 ERROR = -1 FAIL = -2 def setUp(self): self._instrumentation = Instrumentation() def _addTestRun(self, className, methodName, result): status = Status() status['class'] = className status['test'] = methodName status.statusCode = 1 self._instrumentation.addStatus(status) status = Status() status['class'] = className status['test'] = methodName status.statusCode = result self._instrumentation.addStatus(status) def _addSuccessfulTestRun(self, className, methodName): self._addTestRun(className, methodName, self.SUCCESS) def _addFailingTestRun(self, className, methodName, stack): self._addTestRun(className, methodName, self.FAIL) self._instrumentation.statuses()[-1]['stack'] = stack def _addErroringTestRun(self, className, methodName, stack): self._addTestRun(className, methodName, self.ERROR) self._instrumentation.statuses()[-1]['stack'] = stack def assertTestSuite(self, suite, name, package): self.assertEqual(suite.name, name) self.assertEqual(suite.package, package) def assertTestCase(self, case, method): self.assertEqual(case.name, method) PACKAGE = 'com.example' CLASS_NAME = 'TestClass' FULL_CLASS = '.'.join((PACKAGE, CLASS_NAME)) METHOD = 'testMethod' def testOneSucceedingTestMethod(self): self._addSuccessfulTestRun(self.FULL_CLASS, self.METHOD) testResults = Transform(self._instrumentation) self.assertTestSuite(testResults[0], self.FULL_CLASS, self.PACKAGE) self.assertTestCase(testResults[0].testCases[0], self.METHOD) FAIL_REASON = 'frame1' STACK = '\n'.join((FAIL_REASON, 'frame2')) def testOneFailingTestMethod(self): self._addFailingTestRun(self.FULL_CLASS, self.METHOD, self.STACK) testResults = Transform(self._instrumentation) testSuite = testResults[0] testCase = testSuite.testCases[0] self.assertTrue(testCase.isFailing()) self.assertEqual(testCase.failMessage, self.FAIL_REASON) self.assertEqual(testCase.failStack, self.STACK) METHOD2 = 'testMethod2' def testTwoSucceedingTestMethods(self): self._addSuccessfulTestRun(self.FULL_CLASS, self.METHOD) self._addSuccessfulTestRun(self.FULL_CLASS, self.METHOD2) testResults = Transform(self._instrumentation) self.assertTestCase(testResults[0].testCases[0], self.METHOD) self.assertTestCase(testResults[0].testCases[1], self.METHOD2) def testOneErroringTestMethod(self): self._addErroringTestRun(self.FULL_CLASS, self.METHOD, self.STACK) testResults = Transform(self._instrumentation) testSuite = testResults[0] testCase = testSuite.testCases[0] self.assertTrue(testCase.isErroring()) self.assertEqual(testCase.errorMessage, self.FAIL_REASON) self.assertEqual(testCase.errorStack, self.STACK) CLASS_NAME2 = 'TestClass2' FULL_CLASS2 = '.'.join((PACKAGE, CLASS_NAME2)) def testTwoTestSuites(self): self._addSuccessfulTestRun(self.FULL_CLASS, self.METHOD) self._addSuccessfulTestRun(self.FULL_CLASS2, self.METHOD) testResults = Transform(self._instrumentation) self.assertTestSuite(testResults[0], self.FULL_CLASS, self.PACKAGE) self.assertTestCase(testResults[0].testCases[0], self.METHOD) self.assertTestSuite(testResults[1], self.FULL_CLASS2, self.PACKAGE) self.assertTestCase(testResults[1].testCases[0], self.METHOD)