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'
