mirror of https://github.com/google/oss-fuzz.git
96 lines
3.5 KiB
Python
Executable File
96 lines
3.5 KiB
Python
Executable File
# Copyright 2019 Google LLC
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
"""Module to build a image from a specific commit, branch or pull request
|
|
|
|
This module is allows each of the OSS Fuzz projects fuzzers to be built
|
|
from a specific point in time. This feature can be used for implementations
|
|
like continuious integration fuzzing and bisection to find errors
|
|
"""
|
|
import re
|
|
|
|
import helper
|
|
import repo_manager
|
|
|
|
|
|
def build_fuzzer_from_commit(project_name,
|
|
commit,
|
|
local_store_path,
|
|
engine='libfuzzer',
|
|
sanitizer='address',
|
|
architecture='x86_64',
|
|
old_repo_manager=None):
|
|
"""Builds a OSS-Fuzz fuzzer at a specific commit SHA.
|
|
|
|
Args:
|
|
project_name: The OSS-Fuzz project name
|
|
commit: The commit SHA to build the fuzzers at
|
|
local_store_path: The full file path of a place where a temp git repo is stored
|
|
engine: The fuzzing engine to be used
|
|
sanitizer: The fuzzing sanitizer to be used
|
|
architecture: The system architiecture to be used for fuzzing
|
|
|
|
Returns:
|
|
0 on successful build 1 on failure
|
|
"""
|
|
if not old_repo_manager:
|
|
inferred_url = infer_main_repo(project_name, local_store_path, commit)
|
|
old_repo_manager = repo_manager.RepoManager(inferred_url, local_store_path)
|
|
old_repo_manager.checkout_commit(commit)
|
|
return helper.build_fuzzers_impl(
|
|
project_name=project_name,
|
|
clean=True,
|
|
engine=engine,
|
|
sanitizer=sanitizer,
|
|
architecture=architecture,
|
|
env_to_add=None,
|
|
source_path=old_repo_manager.repo_dir)
|
|
|
|
|
|
def infer_main_repo(project_name, local_store_path, example_commit=None):
|
|
"""Tries to guess the main repo a project based on the Dockerfile.
|
|
|
|
NOTE: This is a fragile implementation and only works for git
|
|
Args:
|
|
project_name: The OSS-Fuzz project that you are checking the repo of
|
|
example_commit: A commit that is in the main repos tree
|
|
Returns:
|
|
The guessed repo url path or None on failue
|
|
"""
|
|
if not helper.check_project_exists(project_name):
|
|
return None
|
|
docker_path = helper.get_dockerfile_path(project_name)
|
|
with open(docker_path, 'r') as file_path:
|
|
lines = file_path.read()
|
|
# Use generic git format and project name to guess main repo
|
|
if example_commit is None:
|
|
repo_url = re.search(
|
|
r'\b(?:http|https|git)://[^ ]*' + re.escape(project_name) +
|
|
r'(.git)?', lines)
|
|
if repo_url:
|
|
return repo_url.group(0)
|
|
else:
|
|
# Use example commit SHA to guess main repo
|
|
for clone_command in re.findall('.*clone.*', lines):
|
|
repo_url = re.search(r'\b(?:https|http|git)://[^ ]*',
|
|
clone_command).group(0)
|
|
print(repo_url)
|
|
try:
|
|
test_repo_manager = repo_manager.RepoManager(repo_url.rstrip(),
|
|
local_store_path)
|
|
if test_repo_manager.commit_exists(example_commit):
|
|
return repo_url
|
|
except:
|
|
pass
|
|
return None
|