mirror of https://github.com/crytic/slither
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
208 lines
9.4 KiB
208 lines
9.4 KiB
import sys, logging, subprocess
|
|
from collections import defaultdict
|
|
from slither.utils.colors import red, set_colorization_enabled
|
|
from slither.detectors.variables.unused_state_variables import UnusedStateVars
|
|
from slither.detectors.attributes.incorrect_solc import IncorrectSolc
|
|
from slither.detectors.attributes.constant_pragma import ConstantPragma
|
|
from slither.detectors.naming_convention.naming_convention import NamingConvention
|
|
from slither.detectors.functions.external_function import ExternalFunction
|
|
from slither.detectors.variables.possible_const_state_variables import ConstCandidateStateVars
|
|
from slither.detectors.attributes.const_functions import ConstantFunctions
|
|
from .formatters.unused_state import FormatUnusedState
|
|
from .formatters.solc_version import FormatSolcVersion
|
|
from .formatters.pragma import FormatPragma
|
|
from .formatters.naming_convention import FormatNamingConvention
|
|
from .formatters.external_function import FormatExternalFunction
|
|
from .formatters.constable_states import FormatConstableStates
|
|
from .formatters.constant_function import FormatConstantFunction
|
|
|
|
logging.basicConfig(level=logging.INFO)
|
|
logger = logging.getLogger('Slither.Format')
|
|
set_colorization_enabled(True)
|
|
|
|
all_detectors = {
|
|
'unused-state': UnusedStateVars,
|
|
'solc-version': IncorrectSolc,
|
|
'pragma': ConstantPragma,
|
|
'naming-convention': NamingConvention,
|
|
'external-function': ExternalFunction,
|
|
'constable-states' : ConstCandidateStateVars,
|
|
'constant-function': ConstantFunctions
|
|
}
|
|
|
|
def slither_format(args, slither):
|
|
patches = defaultdict(list)
|
|
detectors_to_run = choose_detectors(args)
|
|
for detector in detectors_to_run:
|
|
slither.register_detector(detector)
|
|
results = []
|
|
detector_results = slither.run_detectors()
|
|
detector_results = [x for x in detector_results if x] # remove empty results
|
|
detector_results = [item for sublist in detector_results for item in sublist] # flatten
|
|
results.extend(detector_results)
|
|
number_of_slither_results = get_number_of_slither_results(detector_results)
|
|
apply_detector_results(slither, patches, detector_results)
|
|
sort_and_flag_overlapping_patches(patches)
|
|
prune_overlapping_patches(args, patches)
|
|
if args.verbose_json:
|
|
print_patches_json(number_of_slither_results, patches)
|
|
if args.verbose_test:
|
|
print_patches(number_of_slither_results, patches)
|
|
generate_patch_files(slither, patches)
|
|
|
|
def sort_and_flag_overlapping_patches(patches):
|
|
for file in patches:
|
|
n = len(patches[file])
|
|
for i in range(n):
|
|
for j in range(0, n-i-1):
|
|
# Sort check
|
|
if int(patches[file][j]['start']) > int(patches[file][j+1]['start']):
|
|
temp = patches[file][j+1]
|
|
patches[file][j+1] = patches[file][j]
|
|
patches[file][j] = temp
|
|
# Overlap check
|
|
current = patches[file][j]
|
|
current_start = int(current['start'])
|
|
current_end = int(current['end'])
|
|
next = patches[file][j+1]
|
|
next_start = int(next['start'])
|
|
next_end = int(next['start'])
|
|
if ((current_start >= next_start and current_start <= next_end) or
|
|
(next_start >= current_start and next_start <= current_end)):
|
|
patches[file][j]['overlaps'] = "Yes"
|
|
patches[file][j+1]['overlaps'] = "Yes"
|
|
|
|
def is_overlap_patch(args, patch):
|
|
if 'overlaps' in patch:
|
|
if args.verbose_test:
|
|
logger.info("Overlapping patch won't be applied!")
|
|
logger.info("xDetector: " + patch['detector'])
|
|
logger.info("xOld string: " + patch['old_string'].replace("\n",""))
|
|
logger.info("xNew string: " + patch['new_string'].replace("\n",""))
|
|
logger.info("xLocation start: " + str(patch['start']))
|
|
logger.info("xLocation end: " + str(patch['end']))
|
|
return True
|
|
return False
|
|
|
|
def prune_overlapping_patches(args, patches):
|
|
for file in patches:
|
|
non_overlapping_patches = [patch for patch in patches[file] if not is_overlap_patch(args, patch)]
|
|
patches[file] = non_overlapping_patches
|
|
|
|
def generate_patch_files(slither, patches):
|
|
for file in patches:
|
|
_in_file = file
|
|
current_patches = patches[file]
|
|
if current_patches:
|
|
in_file_str = slither.source_code[current_patches[0]['file']].encode('utf-8')
|
|
out_file_str = ""
|
|
for i in range(len(current_patches)):
|
|
if i != 0:
|
|
out_file_str += in_file_str[int(current_patches[i-1]['end']):int(current_patches[i]['start'])].decode('utf-8')
|
|
else:
|
|
out_file_str += in_file_str[:int(current_patches[i]['start'])].decode('utf-8')
|
|
out_file_str += current_patches[i]['new_string']
|
|
if (i == (len(current_patches) - 1)):
|
|
out_file_str += in_file_str[int(current_patches[i]['end']):].decode('utf-8')
|
|
|
|
logger.info(f'Output new file in {_in_file+".format"}')
|
|
out_file = open(_in_file+".format",'w')
|
|
out_file.write(out_file_str)
|
|
out_file.close()
|
|
patch_file_name = _in_file + ".format.patch"
|
|
outFD = open(patch_file_name,"w")
|
|
logger.info(f'Output new file in {patch_file_name}')
|
|
p1 = subprocess.Popen(['diff', '-u', _in_file, _in_file+".format"], stdout=outFD)
|
|
p1.wait()
|
|
outFD.close()
|
|
|
|
def print_patches(number_of_slither_results, patches):
|
|
logger.info("Number of Slither results: " + str(number_of_slither_results))
|
|
number_of_patches = 0
|
|
for file in patches:
|
|
number_of_patches += len(patches[file])
|
|
logger.info("Number of patches: " + str(number_of_patches))
|
|
for file in patches:
|
|
logger.info("Patch file: " + file)
|
|
for patch in patches[file]:
|
|
logger.info("Detector: " + patch['detector'])
|
|
logger.info("Old string: " + patch['old_string'].replace("\n",""))
|
|
logger.info("New string: " + patch['new_string'].replace("\n",""))
|
|
logger.info("Location start: " + str(patch['start']))
|
|
logger.info("Location end: " + str(patch['end']))
|
|
|
|
def print_patches_json(number_of_slither_results, patches):
|
|
print('{',end='')
|
|
print("\"Number of Slither results\":" + '"' + str(number_of_slither_results) + '",')
|
|
print("\"Number of patchlets\":" + "\"" + str(len(patches)) + "\"", ',')
|
|
print("\"Patchlets\":" + '[')
|
|
for index, file in enumerate(patches):
|
|
if index > 0:
|
|
print(',')
|
|
print('{',end='')
|
|
print("\"Patch file\":" + '"' + file + '",')
|
|
print("\"Number of patches\":" + "\"" + str(len(patches[file])) + "\"", ',')
|
|
print("\"Patches\":" + '[')
|
|
for index, patch in enumerate(patches[file]):
|
|
if index > 0:
|
|
print(',')
|
|
print('{',end='')
|
|
print("\"Detector\":" + '"' + patch['detector'] + '",')
|
|
print("\"Old string\":" + '"' + patch['old_string'].replace("\n","") + '",')
|
|
print("\"New string\":" + '"' + patch['new_string'].replace("\n","") + '",')
|
|
print("\"Location start\":" + '"' + str(patch['start']) + '",')
|
|
print("\"Location end\":" + '"' + str(patch['end']) + '"')
|
|
if 'overlaps' in patch:
|
|
print("\"Overlaps\":" + "Yes")
|
|
print('}',end='')
|
|
print(']',end='')
|
|
print('}',end='')
|
|
print(']',end='')
|
|
print('}')
|
|
|
|
|
|
def choose_detectors(args):
|
|
# If detectors are specified, run only these ones
|
|
detectors_to_run = []
|
|
if args.detectors_to_run == 'all':
|
|
for d in all_detectors:
|
|
detectors_to_run.append(all_detectors[d])
|
|
else:
|
|
for d in args.detectors_to_run.split(','):
|
|
if d in all_detectors:
|
|
detectors_to_run.append(all_detectors[d])
|
|
else:
|
|
raise Exception('Error: {} is not a detector'.format(d))
|
|
return detectors_to_run
|
|
|
|
def apply_detector_results(slither, patches, detector_results):
|
|
for result in detector_results:
|
|
if result['check'] == 'unused-state':
|
|
FormatUnusedState.format(slither, patches, result['elements'])
|
|
elif result['check'] == 'solc-version':
|
|
FormatSolcVersion.format(slither, patches, result['elements'])
|
|
elif result['check'] == 'pragma':
|
|
FormatPragma.format(slither, patches, result['elements'])
|
|
elif result['check'] == 'naming-convention':
|
|
FormatNamingConvention.format(slither, patches, result['elements'])
|
|
elif result['check'] == 'external-function':
|
|
FormatExternalFunction.format(slither, patches, result['elements'])
|
|
elif result['check'] == 'constable-states':
|
|
FormatConstableStates.format(slither, patches, result['elements'])
|
|
elif result['check'] == 'constant-function':
|
|
FormatConstantFunction.format(slither, patches, result['elements'])
|
|
else:
|
|
logger.error(red("Not Supported Yet."))
|
|
sys.exit(-1)
|
|
|
|
def get_number_of_slither_results (detector_results):
|
|
number_of_slither_results = 0
|
|
for result in detector_results:
|
|
for elem in result['elements']:
|
|
if (result['check'] == 'constant-function' and elem['type'] != "function"):
|
|
continue
|
|
if (result['check'] == 'unused-state' and elem['type'] != "variable"):
|
|
continue
|
|
number_of_slither_results += 1
|
|
return number_of_slither_results
|
|
|
|
|