def setUp(self):
test_helpers.patch_environ(self)
self.app = webtest.TestApp(
webapp2.WSGIApplication([('/schedule-ml-train-tasks',
ml_train.Handler)]))
test_helpers.patch(
self,
['base.tasks.add_task', 'handlers.base_handler.Handler.is_cron'])
# Create fake jobs.
data_types.Job(name='libfuzzer_asan',
environment_string='USE_CORPUS_FOR_ML = True\n').put()
data_types.Job(name='libfuzzer_msan',
environment_string='USE_CORPUS_FOR_ML = True\n').put()
data_types.Job(name='afl_asan',
environment_string='USE_CORPUS_FOR_ML = False\n').put()
# Create fake fuzzers.
data_types.Fuzzer(name='libFuzzer', jobs=['libfuzzer_asan']).put()
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):
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,
['base.tasks.add_task', 'handlers.base_handler.Handler.is_cron'])
# Create fake jobs.
data_types.Job(name='libfuzzer_asan',
environment_string='USE_CORPUS_FOR_ML = True\n').put()
data_types.Job(name='libfuzzer_msan',
environment_string='USE_CORPUS_FOR_ML = True\n').put()
data_types.Job(name='afl_asan',
environment_string='USE_CORPUS_FOR_ML = False\n').put()
# Create fake fuzzers.
data_types.Fuzzer(name='libFuzzer', jobs=['libfuzzer_asan']).put()
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 test_new_fuzzer(self):
"""Tests to ensure that the new fuzzer query works properly."""
data_types.FuzzTarget(engine='libFuzzer',
binary='old_fuzzer',
project='test-project').put()
data_types.FuzzTargetJob(fuzz_target_name='libFuzzer_old_fuzzer',
engine='libFuzzer',
job='dummy_job',
weight=1.0).put()
data_types.FuzzTarget(engine='libFuzzer',
binary='new_fuzzer',
project='test-project').put()
data_types.FuzzTargetJob(fuzz_target_name='libFuzzer_new_fuzzer',
engine='libFuzzer',
job='dummy_job',
weight=1.0).put()
self.mock._query_helper.return_value = [
{
'fuzzer': 'libFuzzer_new_fuzzer',
'job': 'dummy_job',
'new_weight': 5.0,
'first_time': '<irrelavent for test>',
},
]
fuzzer_and_job_weights.update_target_weights_for_engine(
None, 'libFuzzer',
[fuzzer_and_job_weights.NEW_FUZZER_SPECIFICATION])
expected_match = fuzzer_and_job_weights.SpecificationMatch(
new_weight=5.0,
reason=fuzzer_and_job_weights.NEW_FUZZER_SPECIFICATION.reason)
self.mock.update_weight_for_target.assert_called_with(
'libFuzzer_new_fuzzer', 'dummy_job', expected_match)
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):
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\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_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):
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/trap_fuzzer',
engine='libFuzzer',
project='fuchsia').put()
environment.set_value('UNPACK_ALL_FUZZ_TARGETS_AND_FILES', True)
helpers.patch(self, [
'system.shell.clear_temp_directory',
])
def test_weight_increase(self):
"""Ensure that weight increases are possible."""
data_types.FuzzTarget(engine='libFuzzer',
binary='very_good_fuzzer',
project='test-project').put()
data_types.FuzzTargetJob(fuzz_target_name='libFuzzer_very_good_fuzzer',
engine='libFuzzer',
job='asan',
weight=1.0).put()
# Report that the issue is corrected.
self.mock._query_helper.return_value = [
{
'fuzzer': 'libFuzzer_very_good_fuzzer',
'job': 'asan',
'new_weight': 2.00,
},
]
specification = fuzzer_and_job_weights.QuerySpecification(
query_format='ignored',
formatter=fuzzer_and_job_weights._past_day_formatter,
reason='increase weight for test')
match = fuzzer_and_job_weights.SpecificationMatch(
new_weight=2.0, reason=specification.reason)
fuzzer_and_job_weights.update_target_weights_for_engine(
None, 'libFuzzer', [specification])
self.mock.update_weight_for_target.assert_called_with(
'libFuzzer_very_good_fuzzer', 'asan', match)
def setUp(self):
helpers.patch(self, [
'build_management.revisions.get_component_range_list',
'config.local_config.ProjectConfig',
'google_cloud_utils.blobs.read_key',
'google_cloud_utils.pubsub.PubSubClient.publish',
])
data_types.FuzzTarget(
id='libFuzzer_proj_target',
engine='libFuzzer',
project='proj',
binary='target').put()
self.testcase = data_types.Testcase(
bug_information='1337',
job_type='libfuzzer_asan_proj',
fuzzer_name='libFuzzer',
overridden_fuzzer_name='libFuzzer_proj_target',
regression='123:456',
fixed='123:456')
self.testcase.put()
self.mock.read_key.return_value = b'reproducer'
self.mock.get_component_range_list.return_value = [
{
'link_text': 'old:new',
},
]
self.mock.ProjectConfig.return_value = mock_config.MockConfig({
'bisect_service': {
'pubsub_topic': '/projects/project/topics/topic',
}
})
def test_weight_increase(self):
"""Ensure that weight increases are possible."""
data_types.FuzzTarget(engine="libFuzzer",
binary="very_good_fuzzer",
project="test-project").put()
data_types.FuzzTargetJob(
fuzz_target_name="libFuzzer_very_good_fuzzer",
engine="libFuzzer",
job="asan",
weight=1.0,
).put()
# Report that the issue is corrected.
self.mock._query_helper.return_value = [{
"fuzzer": "libFuzzer_very_good_fuzzer",
"job": "asan",
"new_weight": 2.00
}]
specification = fuzzer_and_job_weights.QuerySpecification(
query_format="ignored",
formatter=fuzzer_and_job_weights._past_day_formatter,
reason="increase weight for test",
)
match = fuzzer_and_job_weights.SpecificationMatch(
new_weight=2.0, reason=specification.reason)
fuzzer_and_job_weights.update_target_weights_for_engine(
None, "libFuzzer", [specification])
self.mock.update_weight_for_target.assert_called_with(
"libFuzzer_very_good_fuzzer", "asan", match)
def setUp(self):
BaseTest.setUp(self)
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/overflow_fuzzer",
engine="libFuzzer",
project="fuchsia",
).put()
environment.set_value("UNPACK_ALL_FUZZ_TARGETS_AND_FILES", True)
helpers.patch(self, ["system.shell.clear_temp_directory"])
def test_problem_penalized(self):
"""Ensure that we penalize a target for having problems."""
data_types.FuzzTarget(engine='libFuzzer',
binary='problematic_fuzzer',
project='test-project').put()
data_types.FuzzTargetJob(
fuzz_target_name='libFuzzer_problematic_fuzzer',
engine='libFuzzer',
job='dummy_job',
weight=0.1).put()
self.mock._query_helper.return_value = [
{
'fuzzer': 'libFuzzer_problematic_fuzzer',
'job': 'dummy_job',
'new_weight': 0.25,
},
]
fuzzer_and_job_weights.update_target_weights_for_engine(
None, 'libFuzzer', [_TEST_SPECIFICATION])
expected_match = fuzzer_and_job_weights.SpecificationMatch(
new_weight=0.25, reason=_TEST_SPECIFICATION.reason)
self.mock.update_weight_for_target.assert_called_with(
'libFuzzer_problematic_fuzzer', 'dummy_job', expected_match)
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()
fuzz_task.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):
self.maxDiff = None # pylint: disable=invalid-name
test_helpers.patch_environ(self)
test_helpers.patch(self, [
'google_cloud_utils.blobs.get_blob_info',
'google_cloud_utils.blobs.write_blob',
'libs.access.has_access',
'libs.helpers.get_user_email',
'base.utils.current_date_time',
'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()
flaskapp = flask.Flask('testflask')
flaskapp.add_url_rule(
'/', view_func=upload_testcase.UploadHandlerOAuth.as_view(''))
self.app = webtest.TestApp(flaskapp)
def test_reported_fuzzer_has_weight_restored(self):
"""Ensure that a target reported fixed has its weight restored."""
data_types.FuzzTarget(engine="libFuzzer",
binary="good_fuzzer",
project="test-project").put()
data_types.FuzzTargetJob(
fuzz_target_name="libFuzzer_good_fuzzer",
engine="libFuzzer",
job="asan",
weight=0.1,
).put()
# Report that the issue is corrected.
self.mock._query_helper.return_value = [{
"fuzzer": "libFuzzer_good_fuzzer",
"job": "asan",
"new_weight": 1.00
}]
fuzzer_and_job_weights.update_target_weights_for_engine(
None, "libFuzzer", [_TEST_SPECIFICATION])
self.mock.update_weight_for_target.assert_called_with(
"libFuzzer_good_fuzzer",
"asan",
fuzzer_and_job_weights.RESTORE_DEFAULT_MATCH,
)
def setUp(self):
test_utils.set_up_pyfakefs(self)
helpers.patch_environ(self)
helpers.patch(self, [
'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 test_minimize(self):
"""Test minimize."""
helpers.patch(self, ["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("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",
original_absolute_path=testcase_path,
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) as f:
self.assertEqual(1, len(f.read()))
def setUp(self):
"""Set up."""
super(MinimizeTaskTestUntrusted, self).setUp()
environment.set_value("JOB_NAME", "libfuzzer_asan_job")
helpers.patch(self,
["datastore.data_handler.get_data_bundle_bucket_name"])
patcher = mock.patch(
"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",
"python",
"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 test_minimize(self):
"""Test minimize."""
helpers.patch(self, ['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',
original_absolute_path=testcase_path,
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) as f:
self.assertEqual(1, len(f.read()))
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_new_fuzzer(self):
"""Tests to ensure that the new fuzzer query works properly."""
data_types.FuzzTarget(engine="libFuzzer",
binary="old_fuzzer",
project="test-project").put()
data_types.FuzzTargetJob(
fuzz_target_name="libFuzzer_old_fuzzer",
engine="libFuzzer",
job="dummy_job",
weight=1.0,
).put()
data_types.FuzzTarget(engine="libFuzzer",
binary="new_fuzzer",
project="test-project").put()
data_types.FuzzTargetJob(
fuzz_target_name="libFuzzer_new_fuzzer",
engine="libFuzzer",
job="dummy_job",
weight=1.0,
).put()
self.mock._query_helper.return_value = [{
"fuzzer":
"libFuzzer_new_fuzzer",
"job":
"dummy_job",
"new_weight":
5.0,
"first_time":
"<irrelavent for test>",
}]
fuzzer_and_job_weights.update_target_weights_for_engine(
None, "libFuzzer",
[fuzzer_and_job_weights.NEW_FUZZER_SPECIFICATION])
expected_match = fuzzer_and_job_weights.SpecificationMatch(
new_weight=5.0,
reason=fuzzer_and_job_weights.NEW_FUZZER_SPECIFICATION.reason,
)
self.mock.update_weight_for_target.assert_called_with(
"libFuzzer_new_fuzzer", "dummy_job", expected_match)
def setUp(self):
helpers.patch_environ(self)
helpers.patch(self, [
'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(self, [
'libs.access.get_access',
'base.external_users.allowed_jobs_for_user',
'libs.helpers.get_user_email',
])
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 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 get_fuzz_targets(engine=None, project=None, binary=None):
"""Return a Datastore query for fuzz targets."""
query = data_types.FuzzTarget().query()
if engine:
query = query.filter(data_types.FuzzTarget.engine == engine)
if project:
query = query.filter(data_types.FuzzTarget.project == project)
if binary:
query = query.filter(data_types.FuzzTarget.binary == binary)
return ndb_utils.get_all_from_query(query)
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, [
'base.tasks.add_task', 'handlers.base_handler.Handler.is_cron',
'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(self, [
'bot.fuzzers.engine_common.find_fuzzer_path',
'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_existing_unreproducible_testcase(self):
"""Test existing unreproducible testcase."""
crashes = [self._make_crash('c1'), self._make_crash('c2')]
self.mock.test_for_reproducibility.return_value = False
existing_testcase = data_types.Testcase()
existing_testcase.crash_stacktrace = 'existing'
existing_testcase.crash_type = crashes[0].crash_type
existing_testcase.crash_state = crashes[0].crash_state
existing_testcase.security_flag = crashes[0].security_flag
existing_testcase.one_time_crasher_flag = True
existing_testcase.job_type = 'existing_job'
existing_testcase.timestamp = datetime.datetime.now()
existing_testcase.project_name = 'some_project'
existing_testcase.put()
new_crash_count, known_crash_count, groups = fuzz_task.process_crashes(
crashes=crashes,
context=fuzz_task.Context(
project_name='some_project',
bot_name='bot',
job_type='job',
fuzz_target=data_types.FuzzTarget(engine='engine', binary='binary'),
redzone=111,
platform_id='platform',
crash_revision=1234,
fuzzer_name='fuzzer',
window_argument='win_args',
fuzzer_metadata={},
testcases_metadata={},
timeout_multiplier=1,
test_timeout=2,
thread_wait_timeout=3,
data_directory='/data'))
self.assertEqual(0, new_crash_count)
self.assertEqual(2, known_crash_count)
self.assertEqual(1, len(groups))
self.assertEqual(2, len(groups[0].crashes))
self.assertFalse(groups[0].is_new())
self.assertEqual(crashes[0].crash_type, groups[0].main_crash.crash_type)
self.assertEqual(crashes[0].crash_state, groups[0].main_crash.crash_state)
self.assertEqual(crashes[0].security_flag,
groups[0].main_crash.security_flag)
testcases = list(data_types.Testcase.query())
self.assertEqual(1, len(testcases))
self.assertEqual('existing', testcases[0].crash_stacktrace)
def setUp(self):
"""Set up."""
super(MinimizeTaskTestUntrusted, self).setUp()
environment.set_value('JOB_NAME', 'libfuzzer_asan_job')
helpers.patch(self, [
'datastore.data_handler.get_data_bundle_bucket_name',
])
patcher = mock.patch(
'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', 'python', 'bot',
'fuzzers', 'libFuzzer')
job = data_types.Job(
name='libfuzzer_asan_job',
environment_string=(
'APP_NAME = launcher.py\n'
'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 test_target_ignored_if_not_ran(self):
"""Ensure that we don't reset a target weight if it did not run."""
data_types.FuzzTarget(engine='libFuzzer',
binary='good_fuzzer',
project='test-project').put()
data_types.FuzzTargetJob(fuzz_target_name='libFuzzer_good_fuzzer',
engine='libFuzzer',
job='asan',
weight=0.1).put()
# Do not report any runs.
self.mock._query_helper.return_value = []
fuzzer_and_job_weights.update_target_weights_for_engine(
None, 'libFuzzer', [_TEST_SPECIFICATION])
self.assertFalse(self.mock.update_weight_for_target.called)
