File size: 5,818 Bytes
cf36d98 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 | # 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 get the the name of a git repo containing a specific commit
inside of an OSS-Fuzz project.
Example Usage:
python detect_repo.py --src_dir /src --example_commit
b534f03eecd8a109db2b085ab24d419b6486de97
Prints the location of the git remote repo as well as the repo's name
seperated by a space.
https://github.com/VirusTotal/yara.git yara
"""
import argparse
import logging
import os
import subprocess
GO_PATH = '/root/go/src/'
def main():
"""Function to get a git repo's url and name referenced by OSS-Fuzz
Dockerfile.
Raises:
ValueError when a commit or a ref is not provided.
"""
parser = argparse.ArgumentParser(
description=
'Finds a specific git repo in an oss-fuzz project\'s docker file.')
parser.add_argument('--repo_name', help='The name of the git repo.')
parser.add_argument('--src_dir', help='The location of the possible repo.')
parser.add_argument('--example_commit',
help='A commit SHA referencing the project\'s main repo.')
args = parser.parse_args()
if not args.repo_name and not args.example_commit:
raise ValueError(
'Requires an example commit or a repo name to find repo location.')
if args.src_dir:
src_dir = args.src_dir
else:
src_dir = os.environ.get('SRC', '/src')
for single_dir in get_dirs_to_search(src_dir, args.repo_name):
full_path = os.path.join(src_dir, single_dir)
if not os.path.isdir(full_path):
continue
if args.example_commit and check_for_commit(full_path, args.example_commit):
print('Detected repo:', get_repo(full_path), full_path)
return
if args.repo_name and check_for_repo_name(full_path, args.repo_name):
print('Detected repo:', get_repo(full_path), full_path)
return
logging.error('No git repos with specific commit: %s found in %s',
args.example_commit, src_dir)
def get_dirs_to_search(src_dir, repo_name):
"""Gets a list of directories to search for the main git repo.
Args:
src_dir: The location set for the projects SRC.
repo_name: The name of the repo you are searching for.
Returns:
A list of directorys to search.
"""
dirs_to_search = os.listdir(src_dir)
if os.path.exists(GO_PATH) and repo_name:
for root, dirs, _ in os.walk(GO_PATH):
for test_dir in dirs:
if repo_name in test_dir:
dirs_to_search.append(os.path.join(root, test_dir))
return dirs_to_search
def get_repo(repo_path):
"""Gets a git repo link from a specific directory in a docker image.
Args:
repo_path: The directory on the image where the git repo exists.
Returns:
The repo location or None.
"""
output, return_code = execute(['git', 'config', '--get', 'remote.origin.url'],
location=repo_path,
check_result=True)
if return_code == 0 and output:
return output.rstrip()
return None
def check_for_repo_name(repo_path, expected_repo_name):
"""Returns True if the repo at |repo_path| repo_name matches
|expected_repo_name|.
Args:
repo_path: The directory of a git repo.
expected_repo_name: The name of the target git repo.
"""
if not os.path.exists(os.path.join(repo_path, '.git')):
return False
repo_url, _ = execute(['git', 'config', '--get', 'remote.origin.url'],
location=repo_path)
# Handle two common cases:
# https://github.com/google/syzkaller/
# https://github.com/google/syzkaller.git
repo_url = repo_url.replace('.git', '').rstrip().rstrip('/')
actual_repo_name = repo_url.split('/')[-1]
return actual_repo_name == expected_repo_name
def check_for_commit(repo_path, commit):
"""Checks a directory for a specific commit.
Args:
repo_path: The name of the directory to test for the commit.
commit: The commit SHA to check for.
Returns:
True if directory contains that commit.
"""
# Check if valid git repo.
if not os.path.exists(os.path.join(repo_path, '.git')):
return False
# Check if history fetch is needed.
if os.path.exists(os.path.join(repo_path, '.git', 'shallow')):
execute(['git', 'fetch', '--unshallow'], location=repo_path)
# Check if commit is in history.
_, return_code = execute(['git', 'cat-file', '-e', commit],
location=repo_path)
return return_code == 0
def execute(command, location, check_result=False):
"""Runs a shell command in the specified directory location.
Args:
command: The command as a list to be run.
location: The directory the command is run in.
check_result: Should an exception be thrown on failed command.
Returns:
The stdout of the command, the error code.
Raises:
RuntimeError: running a command resulted in an error.
"""
process = subprocess.Popen(command, stdout=subprocess.PIPE, cwd=location)
output, err = process.communicate()
if check_result and (process.returncode or err):
raise RuntimeError(
'Error: %s\n running command: %s\n return code: %s\n out %s\n' %
(err, command, process.returncode, output))
if output is not None:
output = output.decode('ascii')
return output, process.returncode
if __name__ == '__main__':
main()
|