def setUp(self): test_helpers.patch_environ(self) data_types.FuzzTarget(engine='libFuzzer', project='test-project', binary='binary').put() data_types.FuzzTarget(engine='libFuzzer', project='proj', binary='binary').put()
def setUp(self): test_helpers.patch(self, [ 'libs.access.get_access', 'clusterfuzz._internal.base.external_users.allowed_jobs_for_user', 'libs.helpers.get_user_email', 'clusterfuzz._internal.google_cloud_utils.storage.read_data', 'clusterfuzz._internal.google_cloud_utils.storage.exists' ]) self.mock.read_data.return_value = '' self.mock.exists.return_value = False data_types.Job( name='libfuzzer_asan_lib', environment_string=('PROJECT_NAME = lib\n' 'CORPUS_PRUNE = True')).put() data_types.Job( name='afl_asan_lib', environment_string=('PROJECT_NAME = lib\n')).put() data_types.Job( name='libfuzzer_msan_lib', environment_string='PROJECT_NAME = lib').put() data_types.Job( name='afl_asan_lib2', environment_string=('PROJECT_NAME = lib2\n')).put() data_types.Job( name='libfuzzer_asan_lib2', environment_string=('PROJECT_NAME = lib2\n' 'CORPUS_PRUNE = True')).put() data_types.Job( name='libfuzzer_ubsan_lib2', environment_string='PROJECT_NAME = lib2').put() data_types.FuzzTarget(engine='afl', binary='fuzzer', project='lib2').put() data_types.FuzzTargetJob( fuzz_target_name='afl_lib2_fuzzer', job='afl_asan_lib2', last_run=datetime.datetime.utcnow()).put() data_types.FuzzTarget( engine='libFuzzer', binary='fuzzer', project='lib2').put() data_types.FuzzTargetJob( fuzz_target_name='libFuzzer_lib2_fuzzer', job='libfuzzer_asan_lib2', last_run=datetime.datetime.utcnow()).put() data_types.FuzzTargetJob( fuzz_target_name='libFuzzer_lib2_fuzzer', job='libfuzzer_ubsan_lib2', last_run=datetime.datetime.utcnow()).put() self.maxDiff = None # pylint: disable=invalid-name
def test_select_targets_with_tagged_cross_pollination(self): """Test that selecting targets with a given tag returns the right target.""" data_types.CorpusTag( tag='test_tag', fully_qualified_fuzz_target_name='libFuzzer_test_fuzzer').put() data_types.CorpusTag(tag='test_tag', fully_qualified_fuzz_target_name= 'libFuzzer_cross_pollination_test_fuzzer').put() similar_target = data_types.FuzzTarget( engine='libFuzzer', binary='cross_pollination_test_fuzzer', project='test-project') similar_target.put() similar_job = data_types.FuzzTargetJob( fuzz_target_name='libFuzzer_cross_pollination_test_fuzzer', engine='libFuzzer', job='libfuzzer_asan_job') similar_job.put() selected = corpus_pruning_task._select_targets_and_jobs_for_pollination( 'libFuzzer', 'libFuzzer_test_fuzzer', 'tagged', 'test_tag') self.assertEqual([(similar_target, similar_job)], selected)
def setUp(self): self.maxDiff = None # pylint: disable=invalid-name test_helpers.patch_environ(self) test_helpers.patch(self, [ 'clusterfuzz._internal.google_cloud_utils.blobs.get_blob_info', 'clusterfuzz._internal.google_cloud_utils.blobs.write_blob', 'libs.access.has_access', 'libs.helpers.get_user_email', 'clusterfuzz._internal.base.utils.current_date_time', 'clusterfuzz._internal.base.utils.utcnow', ]) self.mock.get_blob_info.return_value.filename = 'input' self.mock.get_blob_info.return_value.key.return_value = 'blob_key' self.mock.write_blob.return_value = 'blob_key' self.mock.has_access.return_value = True self.mock.current_date_time.return_value = '2021-01-01 00:00:00 UTC' self.mock.utcnow.return_value = datetime.datetime(2021, 1, 1) self.mock.get_user_email.return_value = 'uploader@email' data_types.FuzzTarget(engine='libFuzzer', project='test-project', binary='binary').put() data_types.Job(name='libfuzzer_proj_external', environment_string='PROJECT_NAME = proj', platform='LINUX', external_reproduction_topic='topic', external_updates_subscription='sub').put() self.app = flask.Flask('testflask') self.app.add_url_rule( '/', view_func=upload_testcase.UploadHandlerOAuth.as_view(''))
def setUp(self): test_utils.set_up_pyfakefs(self) helpers.patch_environ(self) helpers.patch(self, [ 'clusterfuzz._internal.google_cloud_utils.storage.copy_file_to', ]) os.environ['CORPUS_BUCKET'] = 'corpus' fuzz_target = data_types.FuzzTarget( id='libFuzzer_test_project_test_fuzzer') fuzz_target.binary = 'test_fuzzer' fuzz_target.project = 'test_project' fuzz_target.engine = 'libFuzzer' fuzz_target.put() self.testcase = data_types.Testcase() self.testcase.fuzzer_name = 'libFuzzer' self.testcase.overridden_fuzzer_name = 'libFuzzer_test_project_test_fuzzer' self.testcase.job_type = 'job' self.testcase.bug_information = '123' self.testcase.open = False self.testcase.put() self.testcase_file_path = '/testcase' self.fs.create_file(self.testcase_file_path, contents='A')
def setUp(self): helpers.patch_environ(self) job = data_types.Job() job.name = 'job_with_help_format' job.environment_string = ( 'HELP_FORMAT = -%TESTCASE%\\n-%FUZZER_NAME%\\n-%FUZZ_TARGET%\\n' '-%PROJECT%\\n-%REVISION%\\n-%ENGINE%\\n-%SANITIZER%\\n%ARGS%\\n' '%SANITIZER_OPTIONS%\n' 'PROJECT_NAME = test_project') job.put() job = data_types.Job() job.name = 'ubsan_job_without_help_format' job.environment_string = ( 'PROJECT_NAME = test_project\n' 'APP_ARGS = ' '--disable-logging --disable-experiments --testcase=%TESTCASE_HTTP_URL%' ) job.put() fuzz_target = data_types.FuzzTarget(id='libFuzzer_test_project_test_fuzzer') fuzz_target.binary = 'test_fuzzer' fuzz_target.project = 'test_project' fuzz_target.engine = 'libFuzzer' fuzz_target.put()
def test_record_fuzz_target_existing(self): """Test that record_fuzz_target works when updating an existing entity.""" data_types.FuzzTarget( binary='child', engine='libFuzzer', project='test-project').put() data_types.FuzzTargetJob( fuzz_target_name='libFuzzer_child', job='job', engine='libFuzzer', last_run=datetime.datetime(2017, 12, 31, 0, 0)).put() data_handler.record_fuzz_target('libFuzzer', 'child', 'job') fuzz_target = ndb.Key(data_types.FuzzTarget, 'libFuzzer_child').get() self.assertDictEqual({ 'binary': 'child', 'engine': 'libFuzzer', 'project': 'test-project', }, fuzz_target.to_dict()) job_mapping = ndb.Key(data_types.FuzzTargetJob, 'libFuzzer_child/job').get() self.assertDictEqual({ 'fuzz_target_name': 'libFuzzer_child', 'job': 'job', 'engine': 'libFuzzer', 'last_run': datetime.datetime(2018, 1, 1, 0, 0), 'weight': 1.0, }, job_mapping.to_dict()) self.assertEqual('libFuzzer_child', fuzz_target.fully_qualified_name()) self.assertEqual('child', fuzz_target.project_qualified_name())
def setUp(self): BaseTest.setUp(self) self.fuchsia_corpus_dir = os.path.join(self.corpus_bucket, 'fuchsia') shutil.copytree(os.path.join(TEST_DIR, 'fuchsia'), self.fuchsia_corpus_dir) self.temp_dir = tempfile.mkdtemp() builds_dir = os.path.join(self.temp_dir, 'builds') os.mkdir(builds_dir) urls_dir = os.path.join(self.temp_dir, 'urls') os.mkdir(urls_dir) environment.set_value('BUILDS_DIR', builds_dir) environment.set_value('BUILD_URLS_DIR', urls_dir) environment.set_value('QUEUE_OVERRIDE', 'FUCHSIA') environment.set_value('OS_OVERRIDE', 'FUCHSIA') env_string = ('RELEASE_BUILD_BUCKET_PATH = ' 'gs://clusterfuchsia-builds-test/libfuzzer/' 'fuchsia-([0-9]+).zip') commands.update_environment_for_job(env_string) data_types.Job(name='libfuzzer_asan_fuchsia', platform='FUCHSIA', environment_string=env_string).put() data_types.FuzzTarget(binary='example-fuzzers/crash_fuzzer', engine='libFuzzer', project='fuchsia').put() environment.set_value('UNPACK_ALL_FUZZ_TARGETS_AND_FILES', True) helpers.patch(self, [ 'clusterfuzz._internal.system.shell.clear_temp_directory', ])
def get_fuzz_target(self): """Return a fuzz target for this test case in the expected format.""" if not self.serialized_fuzz_target: return None fuzz_target = data_types.FuzzTarget( engine=self.serialized_fuzz_target['engine'], project=self.serialized_fuzz_target['project'], binary=self.serialized_fuzz_target['binary']) return fuzz_target
def test_minimize(self): """Test minimize.""" helpers.patch(self, ['clusterfuzz._internal.base.utils.is_oss_fuzz']) self.mock.is_oss_fuzz.return_value = True testcase_file_path = os.path.join(self.temp_dir, 'testcase') with open(testcase_file_path, 'wb') as f: f.write(b'EEE') with open(testcase_file_path) as f: fuzzed_keys = blobs.write_blob(f) testcase_path = os.path.join(self.temp_dir, 'testcase') testcase = data_types.Testcase( crash_type='Null-dereference WRITE', crash_address='', crash_state='Foo\n', crash_stacktrace='', crash_revision=1337, fuzzed_keys=fuzzed_keys, fuzzer_name='libFuzzer', overridden_fuzzer_name='libFuzzer_test_fuzzer', job_type='libfuzzer_asan_job', absolute_path=testcase_path, minimized_arguments='%TESTCASE% test_fuzzer') testcase.put() data_types.FuzzTarget(engine='libFuzzer', binary='test_fuzzer').put() fuzzers_init.run() self._setup_env(job_type='libfuzzer_asan_job') environment.set_value('APP_ARGS', testcase.minimized_arguments) environment.set_value('LIBFUZZER_MINIMIZATION_ROUNDS', 3) environment.set_value('UBSAN_OPTIONS', 'unneeded_option=1:silence_unsigned_overflow=1') minimize_task.execute_task(testcase.key.id(), 'libfuzzer_asan_job') testcase = data_handler.get_testcase_by_id(testcase.key.id()) self.assertNotEqual('', testcase.minimized_keys) self.assertNotEqual('NA', testcase.minimized_keys) self.assertNotEqual(testcase.fuzzed_keys, testcase.minimized_keys) self.assertEqual( { 'ASAN_OPTIONS': {}, 'UBSAN_OPTIONS': { 'silence_unsigned_overflow': 1 } }, testcase.get_metadata('env')) blobs.read_blob_to_disk(testcase.minimized_keys, testcase_path) with open(testcase_path, 'rb') as f: self.assertEqual(1, len(f.read()))
def setUp(self): helpers.patch_environ(self) helpers.patch(self, [ 'clusterfuzz._internal.google_cloud_utils.blobs.read_key', ]) self.mock.read_key.return_value = b'reproducer' self.client = pubsub.PubSubClient() self.topic = pubsub.topic_name('proj', 'repro') self.client.create_topic(self.topic) self.subscription = pubsub.subscription_name('proj', 'repro') self.client.create_subscription(self.subscription, self.topic) data_types.Job( name='libfuzzer_asan_blah_external', platform='LINUX', environment_string= ('RELEASE_BUILD_BUCKET_PATH = gs://bucket/a/b/release-([0-9]+).zip\n' 'PROJECT_NAME = proj\n'), external_reproduction_topic=self.topic, external_updates_subscription='projects/proj/subscriptions/updates' ).put() data_types.Job( name='libfuzzer_msan_blah_external', platform='LINUX', environment_string=( 'FUZZ_TARGET_BUILD_BUCKET_PATH = ' 'gs://bucket/a/b/%TARGET%/release-([0-9]+).zip\n' 'PROJECT_NAME = proj\n'), external_reproduction_topic=self.topic, external_updates_subscription='projects/proj/subscriptions/updates' ).put() data_types.FuzzTarget(id='libFuzzer_abc', engine='libFuzzer', binary='abc').put() self.testcase_0 = data_types.Testcase( fuzzer_name='libFuzzer', overridden_fuzzer_name='libFuzzer_abc', crash_revision=1336, minimized_keys='key') self.testcase_0.set_metadata('last_tested_revision', 1337) self.testcase_0.put() self.testcase_1 = data_types.Testcase( fuzzer_name='libFuzzer', overridden_fuzzer_name='libFuzzer_abc', crash_revision=1336, fuzzed_keys='key') self.testcase_1.put()
def setUp(self): test_helpers.patch_environ(self) flaskapp = flask.Flask('testflask') flaskapp.add_url_rule( '/schedule-ml-train-tasks', view_func=ml_train.Handler.as_view('/schedule-ml-train-tasks')) self.app = webtest.TestApp(flaskapp) test_helpers.patch(self, [ 'clusterfuzz._internal.base.tasks.add_task', 'handlers.base_handler.Handler.is_cron', 'clusterfuzz._internal.metrics.logs.log_error' ]) # Create fake jobs. data_types.Job( name='libfuzzer_asan', environment_string='ML_MODELS_TO_USE = rnn_generator').put() data_types.Job(name='libfuzzer_msan', environment_string='').put() data_types.Job(name='afl_asan', environment_string='').put() data_types.Job( name='libfuzzer_asan_invalid', environment_string='ML_MODELS_TO_USE = invalid_model\n').put() # Create fake fuzzers. data_types.Fuzzer(name='afl', jobs=['afl_asan']).put() # Create fake child fuzzers. data_types.FuzzTarget(engine='libFuzzer', binary='fake_fuzzer', project='test-project').put() data_types.FuzzTargetJob(fuzz_target_name='libFuzzer_fake_fuzzer', job='libfuzzer_asan').put() data_types.FuzzTarget(engine='afl', binary='fake_fuzzer', project='test-project').put() data_types.FuzzTargetJob(fuzz_target_name='afl_fake_fuzzer', job='afl_asan').put()
def setUp(self): helpers.patch_environ(self) helpers.patch(self, [ 'clusterfuzz._internal.build_management.build_manager.get_primary_bucket_path', 'clusterfuzz._internal.build_management.build_manager.get_revisions_list', 'clusterfuzz._internal.build_management.revisions.get_component_range_list', 'clusterfuzz._internal.config.local_config.ProjectConfig', 'clusterfuzz._internal.google_cloud_utils.blobs.read_key', 'clusterfuzz._internal.google_cloud_utils.pubsub.PubSubClient.publish', ]) self.mock.ProjectConfig.return_value = mock_config.MockConfig({ 'env': { 'PROJECT_NAME': 'test-project', }, 'bisect_service': { 'pubsub_topic': '/projects/project/topics/topic', } }) data_types.FuzzTarget(id='libFuzzer_proj_target', engine='libFuzzer', project='proj', binary='target').put() self.testcase = data_types.Testcase( timestamp=datetime.datetime(2021, 1, 1), crash_type='crash-type', crash_state='A\nB\nC', security_flag=True, bug_information='1337', job_type='libfuzzer_asan_proj', fuzzer_name='libFuzzer', overridden_fuzzer_name='libFuzzer_proj_target', regression='123:456', fixed='123:456', crash_revision=3, security_severity=data_types.SecuritySeverity.MEDIUM, additional_metadata='{"last_tested_crash_revision": 4}') self.testcase.put() data_types.Job( name='libfuzzer_asan_proj', environment_string='MAIN_REPO = https://repo_url').put() self.mock.read_key.return_value = b'reproducer' self.mock.get_component_range_list.return_value = [ { 'link_text': 'old:new', }, ]
def setUp(self): test_helpers.patch_environ(self) data_types.FuzzTarget( engine='engine', project='proj', binary='child_0', ).put() data_types.FuzzTargetJob( fuzz_target_name='engine_proj_child_0', engine='engine', job='some_job_engine', weight=1.5, ).put() data_types.FuzzTarget( engine='engine', project='proj', binary='child_1', ).put() data_types.FuzzTargetJob( fuzz_target_name='engine_proj_child_1', engine='engine', job='some_job_engine', weight=0.75, ).put() data_types.FuzzTarget( engine='different_fuzzer', binary='child_2', project='test-project', ).put() data_types.FuzzTargetJob( fuzz_target_name='different_fuzzer_child_2', engine='different_fuzzer', job='some_job_different_fuzzer', weight=3.0, ).put()
def setUp(self): helpers.patch(self, [ 'clusterfuzz._internal.bot.fuzzers.engine_common.find_fuzzer_path', 'clusterfuzz._internal.bot.fuzzers.engine_common.get_all_issue_metadata', ]) data_types.FuzzTarget(engine='libFuzzer', binary='fuzzer').put() self.mock.get_all_issue_metadata.return_value = { 'issue_labels': 'label1', 'issue_components': 'component1', } self.testcase = data_types.Testcase( overridden_fuzzer_name='libFuzzer_fuzzer') self.testcase.put()
def test_multi_target_binary(self): """Test multi target binaries.""" fuzz_target = data_types.FuzzTarget() fuzz_target.binary = 'base_fuzzer@blah' fuzz_target.project = 'test_project' fuzz_target.engine = 'googlefuzztest' fuzz_target.put() environment.set_value('HELP_FORMAT', '%BASE_FUZZ_TARGET%\n%FUZZ_TEST_NAME%') testcase = data_types.Testcase() testcase.fuzzer_name = 'googlefuzztest' testcase.job_type = 'jobtype' testcase.overridden_fuzzer_name = 'googlefuzztest_test_project_base_fuzzer-blah' testcase.put() self.assertEqual( data_handler.get_formatted_reproduction_help(testcase), 'base_fuzzer\nblah')
def setUp(self): """Setup for testcase running test.""" test_helpers.patch_environ(self) test_utils.set_up_pyfakefs(self) test_helpers.patch(self, [ 'clusterfuzz._internal.bot.fuzzers.engine_common.find_fuzzer_path', 'clusterfuzz._internal.crash_analysis.stack_parsing.stack_analyzer.get_crash_data', 'clusterfuzz._internal.system.process_handler.run_process', 'clusterfuzz._internal.system.process_handler.' 'terminate_stale_application_instances', 'clusterfuzz.fuzz.engine.get', 'clusterfuzz._internal.metrics.logs.log', ]) os.environ['CRASH_RETRIES'] = '3' os.environ['FAIL_RETRIES'] = '3' os.environ['BOT_TMPDIR'] = '/bot/tmp' os.environ['TEST_TMPDIR'] = '/bot/tmp' os.environ['USER_PROFILE_ROOT_DIR'] = '/user-profiles' os.environ['APP_NAME'] = 'app_name' os.environ['APP_PATH'] = '/build_dir/app_name' os.environ['BUILD_DIR'] = os.environ['APP_DIR'] = '/build_dir' os.environ['CRASH_STACKTRACES_DIR'] = '/crashes' os.environ['INPUT_DIR'] = '/input' os.environ['FUZZER_DIR'] = '/fuzzer' os.environ['WARMUP_TIMEOUT'] = '120' os.environ['BOT_NAME'] = 'bot_name' data_types.FuzzTarget(engine='engine', project=None, binary='target').put() self.blackbox_testcase = data_types.Testcase( crash_state='state', overridden_fuzzer_name='fuzzer') self.greybox_testcase = data_types.Testcase( crash_state='state', overridden_fuzzer_name='engine_target') self.mock.find_fuzzer_path.return_value = '/build_dir/target' self.mock.run_process.return_value = (0, 0, 'output') self.mock.get.return_value = None self.mock.get_crash_data.side_effect = mock_get_crash_data self.fs.create_file('/flags-testcase', contents='-arg1 -arg2') self.fs.create_dir('/bot/tmp')
def setUp(self): """Set up.""" super().setUp() environment.set_value('JOB_NAME', 'libfuzzer_asan_job') patcher = mock.patch( 'clusterfuzz._internal.bot.fuzzers.libFuzzer.fuzzer.LibFuzzer.fuzzer_directory', new_callable=mock.PropertyMock) mock_fuzzer_directory = patcher.start() self.addCleanup(patcher.stop) mock_fuzzer_directory.return_value = os.path.join( environment.get_value('ROOT_DIR'), 'src', 'clusterfuzz', '_internal', 'bot', 'fuzzers', 'libFuzzer') job = data_types.Job( name='libfuzzer_asan_job', environment_string=( 'RELEASE_BUILD_BUCKET_PATH = ' 'gs://clusterfuzz-test-data/test_libfuzzer_builds/' 'test-libfuzzer-build-([0-9]+).zip\n' 'REVISION_VARS_URL = https://commondatastorage.googleapis.com/' 'clusterfuzz-test-data/test_libfuzzer_builds/' 'test-libfuzzer-build-%s.srcmap.json\n')) job.put() data_types.FuzzTarget(engine='libFuzzer', binary='test_fuzzer', project='test-project').put() data_types.FuzzTargetJob(fuzz_target_name='libFuzzer_test_fuzzer', engine='libFuzzer', job='libfuzzer_asan_job').put() environment.set_value('USE_MINIJAIL', True) data_types.Fuzzer(revision=1, file_size='builtin', source='builtin', name='libFuzzer', max_testcases=4, builtin=True).put() self.temp_dir = tempfile.mkdtemp( dir=environment.get_value('FUZZ_INPUTS'))
def setUp(self): flaskapp = flask.Flask('testflask') flaskapp.add_url_rule( '/external-update', view_func=external_update.Handler.as_view('')) self.app = webtest.TestApp(flaskapp) test_helpers.patch(self, [ 'clusterfuzz._internal.base.utils.utcnow', 'google.oauth2.id_token.verify_oauth2_token', ]) self.mock.verify_oauth2_token.return_value = { 'email_verified': True, 'email': '*****@*****.**', } self.mock.utcnow.return_value = datetime.datetime(2021, 1, 1) data_types.Job( name='libfuzzer_external_job', external_reproduction_topic='topic', external_updates_subscription='subscription').put() data_types.Job(name='job').put() data_types.FuzzTarget(engine='libFuzzer', binary='fuzzer').put() self.testcase = data_types.Testcase( open=True, status='Processed', fuzzer_name='libFuzzer', overridden_fuzzer_name='libFuzzer_fuzzer', job_type='libfuzzer_external_job', crash_state=('blink::InputTypeView::element\n' 'blink::TextFieldInputType::didSetValueByUserEdit\n' 'blink::TextFieldInputType::subtreeHasChanged\n'), crash_revision=1336, crash_stacktrace='original', last_tested_crash_stacktrace='last_tested', crash_type='', security_flag=True) self.testcase.put()
def setUp(self): test_helpers.patch_environ(self) self.fuzzer_name = 'fake_fuzzer' self.full_fuzzer_name = 'libFuzzer_fake_fuzzer' self.job_type = 'fake_job' self.temp_dir = tempfile.mkdtemp() data_types.FuzzTarget( engine='libFuzzer', binary='fake_fuzzer', project='test-project').put() os.environ['FUZZ_INPUTS_DISK'] = self.temp_dir test_helpers.patch(self, [ 'clusterfuzz._internal.bot.tasks.ml_train_utils.get_corpus', 'clusterfuzz._internal.bot.tasks.train_rnn_generator_task.train_rnn', 'clusterfuzz._internal.bot.tasks.train_rnn_generator_task.upload_model_to_gcs', ]) self.mock.get_corpus.return_value = True self.mock.train_rnn.return_value = new_process.ProcessResult(return_code=0) self.mock.upload_model_to_gcs.return_value = True
def test_footer_formatting(self): """Test footer message with formatting.""" policy = issue_tracker_policy.IssueTrackerPolicy({ 'status': { 'assigned': 'Assigned', 'duplicate': 'Duplicate', 'verified': 'Verified', 'new': 'Untriaged', 'wontfix': 'WontFix', 'fixed': 'Fixed' }, 'all': { 'status': 'new', 'issue_body_footer': 'Target: %FUZZ_TARGET%, Project: %PROJECT%' }, 'non_security': {}, 'labels': {}, 'security': {}, 'existing': {}, }) self.mock.get.return_value = policy issue_tracker = monorail.IssueTracker(IssueTrackerManager('chromium')) self.testcase1.project_name = 'proj' self.testcase1.fuzzer_name = 'libFuzzer' self.testcase1.overridden_fuzzer_name = 'libFuzzer_proj_target' data_types.FuzzTarget(id='libFuzzer_proj_target', project='proj', engine='libFuzzer', binary='target').put() issue_filer.file_issue(self.testcase1, issue_tracker) self.assertIn('Target: target, Project: proj', issue_tracker._itm.last_issue.body)
def setUp(self): test_helpers.patch_environ(self) self.maxDiff = None # pylint: disable=invalid-name data_types.Fuzzer( name='testFuzzer', stats_columns=('sum(t.blah) as blah, custom(j.new_crashes) ' 'as new_crashes, _EDGE_COV as edge_coverage, ' '_FUNC_COV as func_coverage, ' '_CORPUS_SIZE as corpus_size, ' '_CORPUS_BACKUP as corpus_backup, ' '_QUARANTINE_SIZE as quarantine_size, ' '_COV_REPORT as coverage_report, ' '_FUZZER_RUN_LOGS as fuzzer_logs,' '_PERFORMANCE_REPORT as performance_report'), stats_column_descriptions=( 'blah: "blah description"\n' 'func_coverage: "func coverage description"\n')).put() data_types.Fuzzer( name='testFuzzer2', stats_columns=('sum(t.blah) as blah, custom(j.new_crashes) ' 'as new_crashes, _EDGE_COV as edge_coverage, ' '_FUNC_COV as func_coverage, ' '_CORPUS_SIZE as corpus_size, ' '_CORPUS_BACKUP as corpus_backup, ' '_QUARANTINE_SIZE as quarantine_size, ' '_COV_REPORT as coverage_report, ' '_FUZZER_RUN_LOGS as fuzzer_logs,' '_PERFORMANCE_REPORT as performance_report'), stats_column_descriptions=( 'blah: "blah description"\n' 'func_coverage: "func coverage description"\n')).put() data_types.Job(name='job', environment_string='FUZZ_LOGS_BUCKET = bucket').put() now = datetime.datetime.utcnow() data_types.FuzzTarget(engine='testFuzzer', project='test-project', binary='1_fuzzer').put() data_types.FuzzTargetJob(fuzz_target_name='testFuzzer_1_fuzzer', job='job', last_run=now).put() data_types.FuzzTarget(engine='testFuzzer', project='test-project', binary='2_fuzzer').put() data_types.FuzzTargetJob(fuzz_target_name='testFuzzer_2_fuzzer', job='job', last_run=now).put() data_types.FuzzTarget(engine='testFuzzer', project='test-project', binary='3_fuzzer').put() data_types.FuzzTargetJob(fuzz_target_name='testFuzzer_3_fuzzer', job='job', last_run=now).put() data_types.FuzzTarget(engine='testFuzzer2', project='test-project', binary='1_fuzzer').put() data_types.FuzzTargetJob(fuzz_target_name='testFuzzer2_1_fuzzer', job='job', last_run=now).put() cov_info = data_types.CoverageInformation(fuzzer='2_fuzzer', date=datetime.date( 2016, 10, 19)) cov_info.edges_covered = 11 cov_info.edges_total = 30 cov_info.functions_covered = 10 cov_info.functions_total = 15 cov_info.html_report_url = 'https://report_for_2_fuzzer/20161019' cov_info.corpus_size_units = 20 cov_info.corpus_size_bytes = 200 cov_info.quarantine_size_units = 0 cov_info.quarantine_size_bytes = 0 cov_info.corpus_location = 'gs://corpus' cov_info.corpus_backup_location = 'gs://corpus-backup/file.zip' cov_info.quarantine_location = 'gs://quarantine' cov_info.put() cov_info = data_types.CoverageInformation(fuzzer='2_fuzzer', date=datetime.date( 2016, 10, 21)) cov_info.edges_covered = 15 cov_info.edges_total = 30 cov_info.functions_covered = 11 cov_info.functions_total = 15 cov_info.html_report_url = 'https://report_for_2_fuzzer/20161021' cov_info.corpus_size_units = 40 cov_info.corpus_size_bytes = 400 cov_info.quarantine_size_units = 8 cov_info.quarantine_size_bytes = 80 cov_info.corpus_location = 'gs://corpus' cov_info.corpus_backup_location = 'gs://corpus-backup/file.zip' cov_info.quarantine_location = 'gs://quarantine' cov_info.put() cov_info = data_types.CoverageInformation(fuzzer='1_fuzzer', date=datetime.date( 2016, 10, 20)) cov_info.edges_covered = 17 cov_info.edges_total = 38 cov_info.functions_covered = 12 cov_info.functions_total = 19 cov_info.html_report_url = 'https://report_for_1_fuzzer/20161020' cov_info.corpus_size_units = 47 cov_info.corpus_size_bytes = 480 cov_info.quarantine_size_units = 3 cov_info.quarantine_size_bytes = 8 cov_info.corpus_location = 'gs://corpus' cov_info.corpus_backup_location = 'gs://corpus-backup/file.zip' cov_info.quarantine_location = 'gs://quarantine' cov_info.put() self.client = mock.Mock(spec_set=big_query.Client) test_helpers.patch(self, [ 'clusterfuzz._internal.google_cloud_utils.big_query.Client', ]) self.mock.Client.return_value = self.client
def _proto_to_fuzz_target(proto): """Convert protobuf to FuzzTarget.""" return data_types.FuzzTarget(engine=proto.engine, project=proto.project, binary=proto.binary)
def setUp(self): helpers.patch_environ(self) # Fake permissions. data_types.ExternalUserPermission( email='*****@*****.**', entity_name='fuzzer', entity_kind=data_types.PermissionEntityKind.FUZZER, auto_cc=data_types.AutoCCType.ALL).put() data_types.ExternalUserPermission( email='*****@*****.**', entity_name='fuzz', entity_kind=data_types.PermissionEntityKind.FUZZER, is_prefix=True, auto_cc=data_types.AutoCCType.SECURITY).put() data_types.ExternalUserPermission( email='*****@*****.**', entity_name='parent_', entity_kind=data_types.PermissionEntityKind.FUZZER, is_prefix=True, auto_cc=data_types.AutoCCType.NONE).put() data_types.ExternalUserPermission( email='*****@*****.**', entity_name='parent', entity_kind=data_types.PermissionEntityKind.FUZZER, auto_cc=data_types.AutoCCType.NONE).put() data_types.ExternalUserPermission( email='*****@*****.**', entity_name='parent_cg', entity_kind=data_types.PermissionEntityKind.FUZZER, is_prefix=True, auto_cc=data_types.AutoCCType.NONE).put() data_types.ExternalUserPermission( email='*****@*****.**', entity_name='parens', entity_kind=data_types.PermissionEntityKind.FUZZER, is_prefix=True, auto_cc=data_types.AutoCCType.NONE).put() data_types.ExternalUserPermission( email='*****@*****.**', entity_name='parent', entity_kind=data_types.PermissionEntityKind.FUZZER, is_prefix=True, auto_cc=data_types.AutoCCType.ALL).put() data_types.ExternalUserPermission( email='*****@*****.**', entity_name='job', entity_kind=data_types.PermissionEntityKind.JOB, is_prefix=False, auto_cc=data_types.AutoCCType.ALL).put() data_types.ExternalUserPermission( email='*****@*****.**', entity_name='job', entity_kind=data_types.PermissionEntityKind.JOB, is_prefix=True, auto_cc=data_types.AutoCCType.ALL).put() data_types.ExternalUserPermission( email='*****@*****.**', entity_name='job2', entity_kind=data_types.PermissionEntityKind.JOB, is_prefix=False, auto_cc=data_types.AutoCCType.ALL).put() data_types.ExternalUserPermission( email='*****@*****.**', entity_name='job', entity_kind=data_types.PermissionEntityKind.JOB, is_prefix=False, auto_cc=data_types.AutoCCType.NONE).put() data_types.ExternalUserPermission( email='*****@*****.**', entity_name='job2', entity_kind=data_types.PermissionEntityKind.JOB, is_prefix=False, auto_cc=data_types.AutoCCType.NONE).put() data_types.ExternalUserPermission( email='*****@*****.**', entity_name='job', entity_kind=data_types.PermissionEntityKind.JOB, is_prefix=False, auto_cc=data_types.AutoCCType.NONE).put() data_types.ExternalUserPermission( email='*****@*****.**', entity_name='job3', entity_kind=data_types.PermissionEntityKind.JOB, is_prefix=False, auto_cc=data_types.AutoCCType.NONE).put() data_types.ExternalUserPermission( email='*****@*****.**', entity_name=None, entity_kind=data_types.PermissionEntityKind.UPLOADER, is_prefix=False, auto_cc=data_types.AutoCCType.NONE).put() # Fake fuzzers. data_types.Fuzzer(name='fuzzer').put() data_types.Fuzzer(name='parent', jobs=['job', 'job2', 'job3']).put() data_types.Job(name='job').put() data_types.Job(name='job2').put() data_types.Job(name='job3').put() data_types.FuzzTarget(engine='parent', binary='child', project='test-project').put() data_types.FuzzTargetJob(fuzz_target_name='parent_child', job='job', last_run=datetime.datetime.utcnow()).put() data_types.FuzzTarget(engine='parent', binary='child2', project='test-project').put() data_types.FuzzTargetJob(fuzz_target_name='parent_child2', job='job', last_run=datetime.datetime.utcnow()).put() data_types.FuzzTarget(engine='parent', binary='child', project='test-project').put() data_types.FuzzTargetJob(fuzz_target_name='parent_child', job='job3', last_run=datetime.datetime.utcnow()).put()
def setUp(self): helpers.patch_environ(self) # Two fuzz targets with two jobs enabled, one with and one without pruning. data_types.FuzzTarget( engine='libFuzzer', binary='test_fuzzer_1', project='project_1').put() data_types.FuzzTarget( engine='libFuzzer', binary='test_fuzzer_2', project='project_1').put() data_types.FuzzTargetJob( fuzz_target_name='libFuzzer_test_fuzzer_1', engine='libFuzzer', job='continuous_fuzzing_job_with_pruning').put() data_types.FuzzTargetJob( fuzz_target_name='libFuzzer_test_fuzzer_2', engine='libFuzzer', job='continuous_fuzzing_job_with_pruning').put() data_types.Job( name='continuous_fuzzing_job_with_pruning', platform='LINUX', environment_string=('CORPUS_PRUNE = True\n' 'RELEASE_BUILD_BUCKET_PATH=DOES_NOT_MATTER')).put() data_types.FuzzTargetJob( fuzz_target_name='libFuzzer_test_fuzzer_1', engine='libFuzzer', job='continuous_fuzzing_job_without_pruning').put() data_types.FuzzTargetJob( fuzz_target_name='libFuzzer_test_fuzzer_2', engine='libFuzzer', job='continuous_fuzzing_job_without_pruning').put() data_types.Job( name='continuous_fuzzing_job_without_pruning', platform='LINUX', environment_string=('CORPUS_PRUNE = False\n' 'RELEASE_BUILD_BUCKET_PATH=DOES_NOT_MATTER')).put() # Two fuzz targets with two CUSTOM_BINARY jobs, with and without pruning. data_types.FuzzTarget( engine='libFuzzer', binary='test_fuzzer_a', project='project_1').put() data_types.FuzzTarget( engine='libFuzzer', binary='test_fuzzer_b', project='project_1').put() data_types.FuzzTargetJob( fuzz_target_name='libFuzzer_test_fuzzer_a', engine='libFuzzer', job='custom_binary_job_with_pruning').put() data_types.FuzzTargetJob( fuzz_target_name='libFuzzer_test_fuzzer_b', engine='libFuzzer', job='custom_binary_job_with_pruning').put() data_types.Job( name='custom_binary_job_with_pruning', platform='LINUX', environment_string=('CORPUS_PRUNE = True\n' 'CUSTOM_BINARY = True')).put() data_types.FuzzTargetJob( fuzz_target_name='libFuzzer_test_fuzzer_a', engine='libFuzzer', job='custom_binary_job_without_pruning').put() data_types.FuzzTargetJob( fuzz_target_name='libFuzzer_test_fuzzer_b', engine='libFuzzer', job='custom_binary_job_without_pruning').put() data_types.Job( name='custom_binary_job_without_pruning', platform='LINUX', environment_string=('CORPUS_PRUNE = False\n' 'CUSTOM_BINARY = True')).put()
def setUp(self): """Set up.""" super(CorpusPruningTestUntrusted, self).setUp() environment.set_value('JOB_NAME', 'libfuzzer_asan_job') helpers.patch(self, [ 'clusterfuzz._internal.bot.tasks.setup.get_fuzzer_directory', 'clusterfuzz._internal.base.tasks.add_task', 'clusterfuzz._internal.bot.tasks.corpus_pruning_task.' '_record_cross_pollination_stats', 'clusterfuzz.fuzz.engine.get', ]) self.mock.get.return_value = libFuzzer_engine.Engine() self.mock.get_fuzzer_directory.return_value = os.path.join( environment.get_value('ROOT_DIR'), 'src', 'clusterfuzz', '_internal', 'bot', 'fuzzers', 'libFuzzer') self.corpus_bucket = os.environ['CORPUS_BUCKET'] self.quarantine_bucket = os.environ['QUARANTINE_BUCKET'] self.backup_bucket = os.environ['BACKUP_BUCKET'] job = data_types.Job( name='libfuzzer_asan_job', environment_string=( 'APP_NAME = test_fuzzer\n' 'CORPUS_BUCKET = {corpus_bucket}\n' 'QUARANTINE_BUCKET = {quarantine_bucket}\n' 'BACKUP_BUCKET={backup_bucket}\n' 'RELEASE_BUILD_BUCKET_PATH = ' 'gs://clusterfuzz-test-data/test_libfuzzer_builds/' 'test-libfuzzer-build-([0-9]+).zip\n' 'REVISION_VARS_URL = gs://clusterfuzz-test-data/' 'test_libfuzzer_builds/' 'test-libfuzzer-build-%s.srcmap.json\n'.format( corpus_bucket=self.corpus_bucket, quarantine_bucket=self.quarantine_bucket, backup_bucket=self.backup_bucket))) job.put() job = data_types.Job( name='libfuzzer_asan_job2', environment_string=( 'APP_NAME = test2_fuzzer\n' 'BACKUP_BUCKET = {backup_bucket}\n' 'CORPUS_FUZZER_NAME_OVERRIDE = libfuzzer\n'.format( backup_bucket=self.backup_bucket))) job.put() os.environ['PROJECT_NAME'] = 'oss-fuzz' data_types.FuzzTarget(engine='libFuzzer', project='test', binary='test_fuzzer').put() data_types.FuzzTargetJob(fuzz_target_name='libFuzzer_test_fuzzer', engine='libFuzzer', job='libfuzzer_asan_job', last_run=datetime.datetime.now()).put() data_types.FuzzTarget(engine='libFuzzer', project='test2', binary='fuzzer').put() data_types.FuzzTargetJob(fuzz_target_name='libFuzzer_test2_fuzzer', engine='libFuzzer', job='libfuzzer_asan_job2', last_run=datetime.datetime.now()).put() environment.set_value('USE_MINIJAIL', True) environment.set_value('SHARED_CORPUS_BUCKET', TEST_SHARED_BUCKET) # Set up remote corpora. self.corpus = corpus_manager.FuzzTargetCorpus('libFuzzer', 'test_fuzzer') self.corpus.rsync_from_disk(os.path.join(TEST_DIR, 'corpus'), delete=True) self.quarantine_corpus = corpus_manager.FuzzTargetCorpus( 'libFuzzer', 'test_fuzzer', quarantine=True) self.quarantine_corpus.rsync_from_disk(os.path.join( TEST_DIR, 'quarantine'), delete=True) self.mock.get_data_bundle_bucket_name.return_value = TEST_GLOBAL_BUCKET data_types.DataBundle(name='bundle', is_local=True, sync_to_worker=True).put() data_types.Fuzzer(revision=1, file_size='builtin', source='builtin', name='libFuzzer', max_testcases=4, builtin=True, data_bundle_name='bundle').put() self.temp_dir = tempfile.mkdtemp() # Copy corpus backup in the older date format. corpus_backup_date = ( datetime.datetime.utcnow().date() - datetime.timedelta( days=data_types.CORPUS_BACKUP_PUBLIC_LOOKBACK_DAYS)) corpus_backup_dir = ('gs://{bucket}/corpus/libfuzzer/test2_fuzzer/') gsutil.GSUtilRunner().run_gsutil([ 'cp', (corpus_backup_dir + 'backup.zip').format(bucket=TEST2_BACKUP_BUCKET), (corpus_backup_dir + '%s.zip' % corpus_backup_date).format(bucket=self.backup_bucket) ])
def setUp(self): """Setup.""" helpers.patch_environ(self) helpers.patch(self, [ 'clusterfuzz._internal.bot.fuzzers.engine_common.unpack_seed_corpus_if_needed', 'clusterfuzz._internal.bot.tasks.corpus_pruning_task.' 'choose_cross_pollination_strategy', 'clusterfuzz._internal.bot.tasks.task_creation.create_tasks', 'clusterfuzz._internal.bot.tasks.setup.update_fuzzer_and_data_bundles', 'clusterfuzz._internal.fuzzing.corpus_manager.backup_corpus', 'clusterfuzz._internal.fuzzing.corpus_manager.GcsCorpus.rsync_to_disk', 'clusterfuzz._internal.fuzzing.corpus_manager.FuzzTargetCorpus.rsync_from_disk', 'clusterfuzz._internal.google_cloud_utils.blobs.write_blob', 'clusterfuzz._internal.google_cloud_utils.storage.write_data', 'clusterfuzz.fuzz.engine.get', ]) self.mock.get.return_value = libFuzzer_engine.Engine() self.mock.rsync_to_disk.side_effect = self._mock_rsync_to_disk self.mock.rsync_from_disk.side_effect = self._mock_rsync_from_disk self.mock.update_fuzzer_and_data_bundles.return_value = True self.mock.write_blob.return_value = 'key' self.mock.backup_corpus.return_value = 'backup_link' self.mock.choose_cross_pollination_strategy.return_value = ('random', None) def mocked_unpack_seed_corpus_if_needed(*args, **kwargs): """Mock's assert called methods are not powerful enough to ensure that unpack_seed_corpus_if_needed was called once with force_unpack=True. Instead, just assert that it was called once and during the call assert that it was called correctly. """ self.assertTrue(kwargs.get('force_unpack', False)) self.mock.unpack_seed_corpus_if_needed.side_effect = ( mocked_unpack_seed_corpus_if_needed) data_types.FuzzTarget(engine='libFuzzer', binary='test_fuzzer', project='test-project').put() data_types.FuzzTargetJob(fuzz_target_name='libFuzzer_test_fuzzer', engine='libFuzzer', job='libfuzzer_asan_job').put() self.fuzz_inputs_disk = tempfile.mkdtemp() self.bot_tmpdir = tempfile.mkdtemp() self.build_dir = os.path.join(TEST_DIR, 'build') self.corpus_bucket = tempfile.mkdtemp() self.corpus_dir = os.path.join(self.corpus_bucket, 'corpus') self.quarantine_dir = os.path.join(self.corpus_bucket, 'quarantine') self.shared_corpus_dir = os.path.join(self.corpus_bucket, 'shared') shutil.copytree(os.path.join(TEST_DIR, 'corpus'), self.corpus_dir) shutil.copytree(os.path.join(TEST_DIR, 'quarantine'), self.quarantine_dir) shutil.copytree(os.path.join(TEST_DIR, 'shared'), self.shared_corpus_dir) os.environ['BOT_TMPDIR'] = self.bot_tmpdir os.environ['FUZZ_INPUTS'] = self.fuzz_inputs_disk os.environ['FUZZ_INPUTS_DISK'] = self.fuzz_inputs_disk os.environ['CORPUS_BUCKET'] = 'bucket' os.environ['QUARANTINE_BUCKET'] = 'bucket-quarantine' os.environ['SHARED_CORPUS_BUCKET'] = 'bucket-shared' os.environ['JOB_NAME'] = 'libfuzzer_asan_job' os.environ['FAIL_RETRIES'] = '1' os.environ['APP_REVISION'] = '1337'